Files
burrow-server/tools/room-history.js
T
SnipzilandClaude Opus 5.5 e05565787f feat(server): staff tools, player-made items, picture safety, chat, multiplayer games
Staff and moderation
- Invisible staff (!invisible, "xiv"): hidden from players, half see-through
  to other staff, cannot chat while hidden. New permission staff.invisible.
- Summon and goto land on the player's exact spot ("xgt" before the move).
- Custom warnings (!warn PLAYER custom TEXT), shown in the warning popup.
- Mod notes (!note, !notes; lib/modnotes.js), on the player page and the
  dashboard.
- Granular permissions: per-role overrides (setting rolePermissions) and
  per-account grants and denies, applied live to staff who are playing
  (refreshStaff re-sends "xsp").
- Item control (lib/itemcontrol.js): lock items out of the item finder
  (!lock, !unlock, !locked), take an item from a player (!take), delete a
  custom item from the game and every inventory.
- GET items/find: search any item by name or id, marked locked, for the
  dashboards' quick lock.

Player-made items (lib/playeritems.js, "xcm")
- The Item Maker: make, rename, set the worn look, delete. 5 a day, 20 in all;
  names go through the name filter.
- Admin switches: Item Maker on/off, new items wait for approval, and a
  separate switch (on by default) that holds every player-uploaded picture
  for a moderator. Review queue for items.approve (moderator and up).
- Pictures (lib/itemart.js): PNG, JPEG and GIF cleaned of metadata, BMP
  converted to PNG; 512px and 300KB at most once cleaned.
- Worn as the maker chooses: a sticker (the picture) or a texture (the
  item's shape painted with the picture).

Picture safety
- A picture waiting for approval is never served publicly: /itemart/ 404s it,
  and it is only shown through /account|/mod|/admin/api/itemart to its maker
  and to staff who review or make items.
- A picture turned away or taken off is remembered by SHA-256 and cannot be
  uploaded again.
- Three strikes: three pictures turned away stops a player's uploads until a
  moderator lets them again. Staff can stop or allow uploads by hand.
- Accounts under 24 hours old cannot upload pictures (AJ_ITEM_ART_MIN_HOURS);
  uploads capped at 10 a day.
- Optional Google Cloud Vision SafeSearch (lib/image-moderation.js) for item
  pictures and Art Studio paintings when AJ_GOOGLE_VISION_API_KEY is set;
  fails closed when the scanner is unreachable.

Chat
- Emoji: Twemoji pictures served at /emoji/<codepoints>.png and cached in
  data/emoji (lib/emoji.js).
- Smart spam filtering before the word filter (lib/chatspam.js): long runs of
  one character, repeated words and lines, huge words and emoji floods are
  tidied, and repeats within 20 seconds are dropped.
- Typing indicator: "xty" is passed on to everyone in the room who can see
  the player, at most every 2 seconds.

Games (lib/minigames.js)
- Room games can be played together: a MULTIPLAYER table gives a game a
  waiting list (Single Player / Multiplayer). Players in the same room are
  matched, taken into the game together, and each one's moves are relayed to
  the others. Gem Breaker is the first: two players, "pos", "shoot" and
  "playerLost" relayed.
- Gem Breaker's start message now lists each player's id. Without it no
  player counted as local, so even single player could not aim.

Other
- Players stay connected through the client's new 75-minute AFK limit
  (idleTimeoutMs 80 minutes).
- Jam-a-Grams carry custom items and colours; Jammer Wall avatar photos are
  validated (walls.js photoParam).
- Weak passwords refused (common words, or containing the username).
- Code-scanning fixes: every logged value goes through logText
  (lib/logtext.js) against log injection, HSTS, path-only error logs, a
  single file read in lib/names.js.

Tests: items (pictures, approval, strikes, re-upload refusal, the hidden
waiting picture, the dashboard search), staff (invisibility, goto and summon
spots, custom warnings, notes), buddygames (two-player Gem Breaker, the
typing relay), and updates for main's verified badge and spawn rooms.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 21:44:10 -04:00

152 lines
6.1 KiB
JavaScript

"use strict";
// lists every version of the lands' room files the CDN still has: for each
// room, which builds share a version, the big pictures inside it, and when
// its newest artwork was saved. this is how the older designs in the Theme
// list were found (DISCOVERIES.md, "Older designs of the lands").
//
// node tools/room-history.js <workdir>
//
// downloads about 1.9 GB and keeps the 400 MB that is distinct, in
// <workdir>/files, so a second run only reads. A build is dated by the
// newest sale start in its item pack, which is a few weeks ahead of it.
const crypto = require("crypto");
const fs = require("fs");
const path = require("path");
const zlib = require("zlib");
const amf3 = require("../lib/amf3.js");
const cdn = require("../lib/cdn.js");
const config = require("../config.js");
const OLDEST_BUILD = 1600;
const LANDS = /^(appondale|aussie|balloosh|bahari_bay|canyon_path|coral_canyons|coralpets|crystal_sands|jamaa_township|lost_temple_of_zios|mountains_of_shivveer|oceans|pirate_ship|sarepia|r?holidays_and_celebrations)\//;
const BIG_PICTURE = 60000; // bytes; smaller JPEGs are patches and signs
const WORKERS = 12;
const tail = assetPath => cdn.hashedPath(assetPath).split("/").slice(1).join("/");
const download = async (build, assetPath) => {
const url = new URL(`${build}/${tail(assetPath)}`, config.upstreamContent);
url.searchParams.set("v", config.upstreamBuildVersion);
for (let attempt = 0; attempt < 4; attempt++) {
try {
const res = await fetch(url, {headers: {"User-Agent": "Mozilla/5.0"}});
if (res.status === 404 || res.status === 403) {
return null;
}
if (res.ok) {
return Buffer.from(await res.arrayBuffer());
}
}
catch (err) {
// tried again below
}
}
throw new Error(`could not fetch ${assetPath} of build ${build}`);
};
const day = time => new Date(time).toISOString().slice(0, 10);
(async () => {
const workDir = process.argv[2];
if (!workDir) {
console.log("usage: node tools/room-history.js <workdir>");
process.exit(1);
}
const filesDir = path.join(workDir, "files");
const indexFile = path.join(workDir, "index.json");
fs.mkdirSync(filesDir, {recursive: true});
// {builds: {build: newest sale start}, rooms: {room: {build: hash of its file}}}
// read if it is there: no separate look first, which the file could change after
let index = null;
try {
index = JSON.parse(fs.readFileSync(indexFile));
}
catch (err) {
if (err.code !== "ENOENT") {
throw err;
}
}
if (!index) {
index = {builds: {}, rooms: {}};
const jobs = [];
const candidates = Array.from({length: Number(config.deployVersion) - OLDEST_BUILD + 1}, (unused, at) => OLDEST_BUILD + at);
await Promise.all(candidates.map(async build => {
const rooms = await download(build, "defPacks/1011");
if (!rooms) {
return;
}
const items = Object.values(amf3.decode(zlib.inflateRawSync(await download(build, "defPacks/1000"))));
index.builds[build] = day(1000 * Math.max(...items.map(def => Number(def.availabilityStartTime) || 0)));
for (const def of Object.values(amf3.decode(zlib.inflateRawSync(rooms)))) {
if (def && LANDS.test(def.pathName)) {
jobs.push([build, String(def.pathName)]);
}
}
}));
console.log(`${Object.keys(index.builds).length} builds, ${jobs.length} room files`);
const worker = async () => {
while (jobs.length > 0) {
const [build, room] = jobs.pop();
const body = await download(build, `roomDefs/${room}.xroom`);
const hash = body ? crypto.createHash("sha1").update(body).digest("hex").slice(0, 12) : null;
// named by its own hash, so one already there is this same file: "wx"
// writes only a new one, in the one step.
if (body) {
try {
fs.writeFileSync(path.join(filesDir, hash), body, {flag: "wx"});
}
catch (err) {
if (err.code !== "EEXIST") {
throw err;
}
}
}
(index.rooms[room] = index.rooms[room] || {})[build] = hash;
}
};
await Promise.all(Array.from({length: WORKERS}, worker));
// written whole under another name, then put in its place
fs.writeFileSync(`${indexFile}.tmp`, JSON.stringify(index));
fs.renameSync(`${indexFile}.tmp`, indexFile);
}
console.log("Builds, by the newest sale start in each:");
console.log(Object.entries(index.builds).map(([build, date]) => ` ${build} ${date}`).join("\n"));
const described = new Map();
const describe = hash => {
if (!described.has(hash)) {
const room = amf3.decode(zlib.inflateSync(fs.readFileSync(path.join(filesDir, hash))));
const pictures = room.assets.filter(asset => /\.jpe?g$/i.test(asset.name) && Buffer.isBuffer(asset.ba) && asset.ba.length > BIG_PICTURE)
.map(asset => String(asset.name).split("\\").slice(-2).join("/")).sort();
const newest = Math.max(0, ...room.assets.map(asset => Number(new Date(asset.timeStamp)) || 0));
described.set(hash, {pictures: pictures.join(" + ") || "(no big picture)", newest: newest ? day(newest) : "?", assets: room.assets.length});
}
return described.get(hash);
};
for (const room of Object.keys(index.rooms).sort()) {
// versions with the same big pictures are one line: they differ in
// decorations, which change monthly.
const looks = new Map();
for (const build of Object.keys(index.rooms[room]).sort()) {
const hash = index.rooms[room][build];
if (hash) {
const {pictures, newest, assets} = describe(hash);
const look = looks.get(pictures) || looks.set(pictures, {builds: [], newest, assets: new Set()}).get(pictures);
look.builds.push(build);
look.newest = newest > look.newest ? newest : look.newest;
look.assets.add(assets);
}
}
console.log(`\n${room}`);
for (const [pictures, look] of looks) {
console.log(` ${pictures}\n builds ${look.builds.join(" ")}; ${Math.min(...look.assets)}-${Math.max(...look.assets)} assets; newest artwork ${look.newest}`);
}
}
})().catch(err => {
console.error(err);
process.exit(1);
});