Files
burrow-server/test/staff.js
T
SnipzilandClaude Opus 5.5 6563d5de99 Custom items made while the server runs, and a Developer role
Staff with the new items.create permission (admins, and the new Developer
role) make clothing and den items from the game's own art: an existing
item under a new id (50000 on), name, price, members-only flag and choice
of its colours. No restart of the server or of anyone's game:

- lib/customitems.js keeps them (custom_items table) and puts them into
  the server's tables and the packs new games fetch (defpacks.setCustomItem)
- games already playing get the def rows in "xdi"; so does every game at
  login. The client adds them (ItemXtCommManager.addItemDefs,
  DenXtCommManager.addDenItemDefs, both now in swf-src; rebuild with
  tools/build-client.sh)
- they are sold first in the two shops of oddities and found by the item
  finder; an item can be renamed, repriced, recoloured and taken off sale,
  never deleted (players may own it)
- the moderator panel has an Items page; in game, "!item clothing|den ID
  NAME" and "!item list"
- the Developer role holds only staff.list and items.create. The panel's
  pages that show players (players, chat, reports, requests, bans,
  paintings) now need player.view, which helpers and up have

test/items.js covers it end to end, including a restart (withServer can
keep its database for that).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 22:43:27 -04:00

246 lines
12 KiB
JavaScript

"use strict";
// end to end: staff roles (lib/roles.js), the staff chat commands
// (lib/commands.js) and the moderator panel's role checks
// (lib/modpanel.js), against a real server with a database of its own.
const assert = require("assert");
const crypto = require("crypto");
const harness = require("./harness.js");
const HTTP_PORT = 18091;
const GAME_PORT = 19350;
const BASE = `http://127.0.0.1:${HTTP_PORT}`;
const TOWNSHIP = "jamaa_township.room_main#1";
const SAREPIA = "sarepia.room_main#1";
const {postJson} = harness;
// the authenticator app's side of 2FA (lib/totp.js): a base32 secret,
// HMAC-SHA1, 30-second steps, six digits.
const STEP = 30;
const base32Decode = text => {
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
const bits = text.replace(/=+$/, "").toUpperCase().split("").map(c => alphabet.indexOf(c).toString(2).padStart(5, "0")).join("");
const bytes = [];
for (let i = 0; i + 8 <= bits.length; i += 8) {
bytes.push(parseInt(bits.slice(i, i + 8), 2));
}
return Buffer.from(bytes);
};
const codeAt = (secret, step) => {
const counter = Buffer.alloc(8);
counter.writeBigUInt64BE(BigInt(step));
const mac = crypto.createHmac("sha1", base32Decode(secret)).update(counter).digest();
const offset = mac[mac.length - 1] & 0x0F;
return String((mac.readUInt32BE(offset) & 0x7FFFFFFF) % 1000000).padStart(6, "0");
};
const stepNow = () => Math.floor(Date.now() / 1000 / STEP);
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
// a code is taken once: each use needs a later step than the last.
const waitForStep = async step => {
while (stepNow() < step) {
await sleep(250);
}
};
// a web panel's session: keeps the cookie it is given.
const webSession = () => {
let cookie = "";
return async (path, body) => {
const headers = {cookie};
const options = body === undefined ? {headers} : {method: "POST", headers: {...headers, "Content-Type": "application/json"}, body: JSON.stringify(body)};
const res = await fetch(`${BASE}${path}`, options);
const set = res.headers.get("set-cookie");
if (set) {
cookie = set.split(";")[0];
}
return {status: res.status, data: await res.json().catch(() => ({}))};
};
};
const say = (client, roomId, text) =>
client.send(`<msg t='sys'><body action='pubMsg' r='${roomId}'><txt><![CDATA[${text}%0]]></txt></body></msg>`);
// logs in (with a 2FA code when given) and walks into `room`.
const arrive = async (username, password, room, totp) => {
const res = await postJson(`${BASE}/authenticate`, {username, password, ...(totp ? {totp} : {})});
const auth = await res.json();
assert.strictEqual(res.status, 200, `${username} could not sign in: ${JSON.stringify(auth)}`);
const client = new harness.GameClient(GAME_PORT);
await client.connect();
const login = await client.logIn(username, auth.auth_token);
assert.strictEqual(login.status, "1");
client.xt("rj", 1, room, 1, 0, 0);
const rj = await client.untilXt("rj");
await client.untilXt("rp");
client.xt("au", rj[4], 1, 400, 400, 14, 1);
return {client, login, roomId: rj[4], room: rj[3]};
};
// the next moderator popup ("fd") of this kind, skipping earlier ones (a
// silence notice, say) still waiting.
const untilPopup = async (client, kind) => {
for (;;) {
const fields = await client.untilXt("fd");
if (fields[2] === kind) {
return fields;
}
}
};
// the next message box ("xtl") the server shows this client.
const nextBox = async client => (await client.untilXt("xtl"))[2];
// the chat line `text` coming back (every typed line, a command too, is
// shown to its sender, so skip those before it).
const untilChat = async (client, text) => {
for (;;) {
const line = await client.untilXt("uc");
if (line[3] === text) {
return line;
}
}
};
const run = async () => {
const registerJson = body => fetch(`${BASE}/api/register`, {method: "POST", headers: {"Content-Type": "application/json"}, body: JSON.stringify({avatarType: 1, agreed: true, ...body})});
const people = {Mira: "Password11", Hal: "Password12", Pip: "Password13", Ann: "Password14"};
for (const [username, password] of Object.entries(people)) {
assert.strictEqual((await registerJson({username, password})).status, 200);
}
// --- the admin gives roles
const admin = webSession();
assert.strictEqual((await admin("/admin/api/setup", {password: "AdminPass99!"})).status, 200);
assert.strictEqual((await admin("/admin/api/login", {password: "AdminPass99!"})).status, 200);
const roleList = await admin("/admin/api/roles");
assert.deepStrictEqual(roleList.data.roles.map(role => role.id), ["developer", "helper", "moderator", "admin"]);
assert.match((await admin("/admin/api/account", {username: "Mira", action: "role", role: "boss"})).data.error, /No such role/);
// staff need 2FA: turned on from the account page.
const secrets = {};
const usedStep = {};
for (const username of ["Mira", "Hal"]) {
const page = webSession();
assert.strictEqual((await page("/account/api/login", {username, password: people[username]})).status, 200);
const begun = await page("/account/api/act", {action: "twoStepStart", current: people[username]});
secrets[username] = begun.data.setup.secret;
usedStep[username] = stepNow();
const confirmed = await page("/account/api/act", {action: "twoStepConfirm", code: codeAt(secrets[username], usedStep[username])});
assert.ok(confirmed.data.ok, JSON.stringify(confirmed.data));
}
assert.match((await admin("/admin/api/account", {username: "Mira", action: "role", role: "moderator"})).data.ok, /moderator/);
assert.match((await admin("/admin/api/account", {username: "Hal", action: "role", role: "helper"})).data.ok, /helper/);
// --- the game: the login reply carries your own role, and nobody else's
usedStep.Mira++;
const mira = await arrive("Mira", people.Mira, TOWNSHIP, codeAt(secrets.Mira, usedStep.Mira));
assert.strictEqual(mira.login.params.staffRole, "moderator");
assert.ok(mira.login.params.staffPermissions.split(",").includes("player.summon"));
usedStep.Hal++;
const hal = await arrive("Hal", people.Hal, TOWNSHIP, codeAt(secrets.Hal, usedStep.Hal));
assert.strictEqual(hal.login.params.staffRole, "helper");
const pip = await arrive("Pip", people.Pip, SAREPIA);
assert.strictEqual(pip.login.params.staffRole, "");
const ann = await arrive("Ann", people.Ann, SAREPIA);
// a staff command from a player is plain chat
say(pip.client, pip.roomId, "!kick Mira");
await untilChat(pip.client, "!kick Mira");
say(mira.client, mira.roomId, "!staff");
const staffBox = await nextBox(mira.client);
assert.match(staffBox, /Mira \(Moderator\)/);
assert.match(staffBox, /Hal \(Helper\)/);
// summon: Pip is brought from Sarepia to Mira in the township
say(mira.client, mira.roomId, "!summon Pip");
assert.strictEqual((await pip.client.untilXt("rj"))[3], TOWNSHIP);
assert.strictEqual(await nextBox(mira.client), "Pip was brought here.");
// a helper may silence a player, but not kick, nor act on a moderator
say(hal.client, hal.roomId, "!silence Pip 1");
assert.strictEqual(await nextBox(hal.client), "Pip cannot chat for 1 hours.");
say(hal.client, hal.roomId, "!silence Pip off");
assert.strictEqual(await nextBox(hal.client), "Pip can chat again.");
say(hal.client, hal.roomId, "!silence Mira 1");
assert.match(await nextBox(hal.client), /your rank or above/);
say(hal.client, hal.roomId, "!kick Pip");
// no permission: just chat, seen by the room (Mira, in the township)
await untilChat(mira.client, "!kick Pip");
// goto: Mira goes to Ann in Sarepia
say(mira.client, mira.roomId, "!goto Ann");
assert.strictEqual((await mira.client.untilXt("rj"))[3], SAREPIA);
// a warning: the game's own popup for the reason ("fw", 1 = bullying),
// kept on the account; a message box; the count; then kick disconnects
say(mira.client, ann.roomId, "!warn Ann bullying called names");
assert.deepStrictEqual((await ann.client.untilXt("fd")).slice(2, 4), ["fw", "1"]);
assert.strictEqual(await nextBox(mira.client), "Ann warned (bullying): warning 1.");
say(mira.client, ann.roomId, "!warn Ann");
assert.deepStrictEqual((await ann.client.untilXt("fd")).slice(2, 4), ["fw", "4"]); // behavior, the default
assert.strictEqual(await nextBox(mira.client), "Ann warned (behavior): warning 2.");
say(mira.client, ann.roomId, "!message Ann please be kind");
assert.deepStrictEqual((await ann.client.untilXt("fd")).slice(2, 4), ["fp", "please be kind"]);
assert.strictEqual(await nextBox(mira.client), "Shown to Ann.");
say(mira.client, ann.roomId, "!warnings Ann");
assert.match(await nextBox(mira.client), /^Ann has 2 warnings\. Latest: \S+ behavior by Mira; \S+ bullying by Mira \(called names\)$/);
say(mira.client, ann.roomId, "!kick Ann");
assert.strictEqual((await ann.client.untilXt("fd"))[2], "fk");
assert.strictEqual(await nextBox(mira.client), "Ann was disconnected.");
// --- the moderator panel: what the role allows, checked by the server
for (const username of ["Mira", "Hal"]) {
usedStep[username]++;
}
await waitForStep(Math.max(usedStep.Mira, usedStep.Hal) - 1);
const modPage = webSession();
assert.strictEqual((await modPage("/mod/api/login", {username: "Mira", password: people.Mira, code: codeAt(secrets.Mira, usedStep.Mira)})).status, 200);
const miraMe = (await modPage("/mod/api/me")).data;
assert.strictEqual(miraMe.role, "moderator");
assert.ok(miraMe.permissions.includes("player.ban"));
const halPage = webSession();
assert.strictEqual((await halPage("/mod/api/login", {username: "Hal", password: people.Hal, code: codeAt(secrets.Hal, usedStep.Hal)})).status, 200);
const halMe = (await halPage("/mod/api/me")).data;
assert.strictEqual(halMe.role, "helper");
assert.ok(!halMe.permissions.includes("player.ban"));
assert.strictEqual((await halPage("/mod/api/act", {username: "Pip", action: "ban", hours: 1, reason: "x"})).data.error, "Your role cannot do that.");
assert.match((await halPage("/mod/api/act", {username: "Mira", action: "silence", hours: 1})).data.error, /your rank or above/);
// a warning from the panel, and on the player's page
assert.match((await modPage("/mod/api/act", {username: "Pip", action: "warn", reason: "scamming", note: "fake trade"})).data.ok, /^Pip warned \(scamming\): warning 1\./);
assert.match((await modPage("/mod/api/act", {username: "Pip", action: "warn", reason: "nonsense"})).data.error, /reason/);
assert.deepStrictEqual((await untilPopup(pip.client, "fw")).slice(2, 4), ["fw", "9"]);
const pipPage = (await modPage("/mod/api/player?username=Pip")).data;
assert.strictEqual(pipPage.warnings, 1);
assert.deepStrictEqual([pipPage.warningList[0].reason, pipPage.warningList[0].note, pipPage.warningList[0].by], ["scamming", "fake trade", "Mira"]);
// the panel's summon brings Pip to Mira (now in Sarepia)
assert.match((await modPage("/mod/api/act", {username: "Pip", action: "summon"})).data.ok || "", /^Pip was brought to /);
assert.strictEqual((await pip.client.untilXt("rj"))[3], SAREPIA);
// everything above is in the moderators' log, the in-game ones marked so
const log = (await admin("/admin/api/moderators")).data.log.map(entry => `${entry.by} ${entry.action} ${entry.target}`);
for (const line of ["Mira summon (in game) Pip", "Hal silence (in game) Pip", "Mira goto (in game) Ann", "Mira warn (in game) Ann",
"Mira message (in game) Ann", "Mira kick (in game) Ann", "Mira warn Pip", "Mira summon Pip"]) {
assert.ok(log.includes(line), `missing from the log: ${line}\n${log.join("\n")}`);
}
// the moderators' message box header has real line breaks, not "\\n"
const zlib = require("zlib");
const {decode} = require("../lib/amf3.js");
const stringsPath = require("../lib/cdn.js").hashedPath("defPacks/10230");
const strings = decode(zlib.inflateRawSync(Buffer.from(await (await fetch(`${BASE}/${stringsPath}`)).arrayBuffer())));
assert.strictEqual(strings[11134], "--Message From Moderator--\n\n");
assert.ok(!strings[11135].includes("\\n"));
for (const {client} of [mira, hal, pip]) {
client.socket.destroy();
}
};
harness.withServer("staff test", HTTP_PORT, GAME_PORT, run).catch(err => {
console.error(err);
process.exit(1);
});