mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27:50 -05:00
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]>
152 lines
6.1 KiB
JavaScript
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);
|
|
});
|