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]>
286 lines
11 KiB
JavaScript
286 lines
11 KiB
JavaScript
"use strict";
|
|
|
|
const accounts = require("./accounts.js");
|
|
const achievements = require("./achievements.js");
|
|
const bans = require("./bans.js");
|
|
const dens = require("./dens.js");
|
|
const config = require("../config.js");
|
|
const {CURRENCIES} = require("./player.js");
|
|
|
|
// moderation: kick, ban, silence, clear a den, grant gems, message a player.
|
|
// these are done from the admin panel (lib/panel.js). no game account has
|
|
// them: the client's own moderator requests (FacilitatorXtCommManager) are
|
|
// always refused.
|
|
|
|
const PERMANENT = -1;
|
|
const SECONDS_PER_MINUTE = 60;
|
|
const CURRENCY_GEMS = 0;
|
|
// ItemXtCommManager.currencyUpdateResponse: with this as the reason the
|
|
// client says "You earned N ..." in a popup when the amount went up.
|
|
const REASON_ANNOUNCE = 3;
|
|
|
|
// a warning's reason, and the client's own warning popup for it
|
|
// (FacilitatorXtCommManager.showContextualWarningPopup, "fw"): its artwork
|
|
// and its words, which this server's strings already say in its own name.
|
|
const WARNINGS = {
|
|
behavior: 4, // "Inappropriate Behavior"
|
|
bullying: 1, // "Bullying"
|
|
personal: 3, // "Personal Information"
|
|
scamming: 9, // "Scamming"
|
|
// in the staff member's own words: its note is what the player is shown,
|
|
// in a message box (there is no popup for it), and it cannot be left out.
|
|
custom: null,
|
|
};
|
|
const CUSTOM_WARNING = "custom";
|
|
const MAX_WARNINGS_KEPT = 100;
|
|
const MAX_WARNING_NOTE = 200;
|
|
const SECONDS_PER_DAY = 86400;
|
|
|
|
const now = () => Math.floor(Date.now() / 1000);
|
|
|
|
// seconds of ban left, PERMANENT, or 0 when not banned.
|
|
const banRemaining = account => {
|
|
if (account.bannedUntil === PERMANENT) {
|
|
return PERMANENT;
|
|
}
|
|
return Math.max(0, (account.bannedUntil || 0) - now());
|
|
};
|
|
|
|
// the ban an account is under, for whoever may know why (the banned player,
|
|
// and whoever runs the server): {seconds, reason, by, since}, or null.
|
|
const banOf = account => {
|
|
const seconds = banRemaining(account);
|
|
return seconds === 0 ? null : {seconds, reason: account.banReason || bans.NO_REASON, by: account.bannedBy || "", since: account.bannedAt || null};
|
|
};
|
|
|
|
// the warnings an account has had in the last config.warningSilence.days
|
|
// (all of them when that is 0).
|
|
const recentWarnings = account => {
|
|
const days = (config.warningSilence || {}).days || 0;
|
|
const since = now() - days * SECONDS_PER_DAY;
|
|
return (account.warnings || []).filter(entry => !days || entry.at >= since).length;
|
|
};
|
|
|
|
// the minutes of silence a warning brings when it is the Nth recent one
|
|
// (config.warningSilence.steps, [[N, minutes], ...]); 0 for none.
|
|
const silenceForWarning = count => {
|
|
const step = ((config.warningSilence || {}).steps || []).find(([warnings]) => warnings === count);
|
|
return step ? step[1] : 0;
|
|
};
|
|
|
|
const isSilenced = account => account.silencedUntil === PERMANENT || (account.silencedUntil || 0) > now();
|
|
|
|
// seconds of silence left, PERMANENT, or 0 when the account may chat.
|
|
const silenceRemaining = account => {
|
|
if (account.silencedUntil === PERMANENT) {
|
|
return PERMANENT;
|
|
}
|
|
return Math.max(0, (account.silencedUntil || 0) - now());
|
|
};
|
|
|
|
module.exports = ({findOnline}) => {
|
|
// FacilitatorXtCommManager.facilitatorDisciplineResponse: what the affected
|
|
// player's client is told.
|
|
const discipline = (session, ...fields) => session.sendXt("fd", -1, ...fields);
|
|
|
|
// A "message from moderator" popup; also used to answer chat commands.
|
|
const notify = (session, text) => discipline(session, "fp", text, 0);
|
|
// a warning as the player sees it: the game's popup for its reason, or a
|
|
// custom one's words.
|
|
const showWarning = (session, entry) => {
|
|
if (entry.reason === CUSTOM_WARNING && entry.note) {
|
|
notify(session, `Warning: ${entry.note}`);
|
|
}
|
|
else {
|
|
discipline(session, "fw", WARNINGS[entry.reason] ?? WARNINGS.behavior);
|
|
}
|
|
};
|
|
|
|
const actions = {
|
|
kick(target) {
|
|
const session = findOnline(target.username);
|
|
if (!session) {
|
|
return false;
|
|
}
|
|
discipline(session, "fk", 0);
|
|
session.close();
|
|
return true;
|
|
},
|
|
|
|
// duration in seconds, or PERMANENT. the reason is for the banned
|
|
// player and whoever runs the server, nobody else; `by` is who gave it.
|
|
ban(target, duration, reason = "", by = "") {
|
|
target.bannedUntil = duration === PERMANENT ? PERMANENT : now() + duration;
|
|
target.banReason = bans.reasonText(reason);
|
|
target.bannedBy = by;
|
|
target.bannedAt = now();
|
|
accounts.save(target);
|
|
bans.record({account: target, action: "ban", seconds: duration, reason: target.banReason, by});
|
|
const session = findOnline(target.username);
|
|
if (session) {
|
|
discipline(session, "fb", 1, duration);
|
|
session.close();
|
|
}
|
|
return true;
|
|
},
|
|
|
|
unban(target, by = "") {
|
|
const was = banRemaining(target) !== 0;
|
|
delete target.bannedUntil;
|
|
delete target.banReason;
|
|
delete target.bannedBy;
|
|
delete target.bannedAt;
|
|
accounts.save(target);
|
|
if (was) {
|
|
bans.record({account: target, action: "unban", by});
|
|
}
|
|
return true;
|
|
},
|
|
|
|
// another reason for the ban they are under; its length stays.
|
|
banReason(target, reason, by = "") {
|
|
if (banRemaining(target) === 0) {
|
|
return false;
|
|
}
|
|
target.banReason = bans.reasonText(reason);
|
|
accounts.save(target);
|
|
bans.record({account: target, action: "reason", reason: target.banReason, by});
|
|
return true;
|
|
},
|
|
|
|
// duration in seconds, PERMANENT, or 0 to lift
|
|
silence(target, duration) {
|
|
target.silencedUntil = duration === PERMANENT ? PERMANENT : (duration > 0 ? now() + duration : 0);
|
|
accounts.save(target);
|
|
const session = findOnline(target.username);
|
|
if (session) {
|
|
// minutes, negative for "until further notice", 0 for "you may type again"
|
|
discipline(session, "fs", duration === PERMANENT ? PERMANENT : Math.ceil(duration / SECONDS_PER_MINUTE));
|
|
}
|
|
return true;
|
|
},
|
|
|
|
// their username will not do: they are put out, every saved sign-in
|
|
// ends, and the next sign-in asks for another name before it lets them
|
|
// in (lib/http.js, lib/manage.js). the name itself stays until then.
|
|
rejectName(target, by = "") {
|
|
target.nameRejected = {by, at: now()};
|
|
accounts.revokeTokens(target);
|
|
accounts.save(target);
|
|
actions.kick(target);
|
|
return true;
|
|
},
|
|
|
|
// taken back: the name will do after all.
|
|
acceptName(target) {
|
|
delete target.nameRejected;
|
|
accounts.save(target);
|
|
return true;
|
|
},
|
|
|
|
clearDen(target) {
|
|
dens.clearDen(target, findOnline);
|
|
return true;
|
|
},
|
|
|
|
grantGems(target, amount) {
|
|
return actions.grantCurrency(target, CURRENCY_GEMS, amount, false);
|
|
},
|
|
|
|
// adds to (or with a negative amount takes from) one of a player's
|
|
// currencies: an index into CURRENCIES. `announce` has their game say so.
|
|
grantCurrency(target, currencyType, amount, announce = true) {
|
|
const name = CURRENCIES[currencyType];
|
|
if (!name) {
|
|
return false;
|
|
}
|
|
const before = target.currency[name] || 0;
|
|
target.currency[name] = Math.max(0, before + amount);
|
|
achievements.currencyChanged(target, name, target.currency[name] - before);
|
|
accounts.save(target);
|
|
const session = findOnline(target.username);
|
|
if (session) {
|
|
// ItemXtCommManager.currencyUpdateResponse: [currencyType, newAmount, reason]
|
|
session.sendXt("cu", -1, currencyType, target.currency[name], announce ? REASON_ANNOUNCE : 0);
|
|
}
|
|
return true;
|
|
},
|
|
|
|
message(target, text) {
|
|
const session = findOnline(target.username);
|
|
if (!session) {
|
|
return false;
|
|
}
|
|
notify(session, text);
|
|
return true;
|
|
},
|
|
|
|
// a warning: kept on the account (who, when, why and a note for staff),
|
|
// and shown with the game's own warning popup: now if they are in a
|
|
// room, else once they are next (greet). the Nth warning within
|
|
// config.warningSilence.days may also silence them for a while; a
|
|
// longer silence already on them is left alone.
|
|
// returns {count, online, silencedMinutes}, or null for a reason that
|
|
// is not one (or a custom warning with nothing to say).
|
|
warn(target, reason, by, note = "") {
|
|
const text = String(note).trim().slice(0, MAX_WARNING_NOTE);
|
|
if (!Object.hasOwn(WARNINGS, reason) || (reason === CUSTOM_WARNING && !text)) {
|
|
return null;
|
|
}
|
|
const session = findOnline(target.username);
|
|
const seen = Boolean(session && session.greeted);
|
|
const entry = {at: now(), by, reason, note: text, seen};
|
|
target.warnings = [...(target.warnings || []), entry].slice(-MAX_WARNINGS_KEPT);
|
|
accounts.save();
|
|
if (seen) {
|
|
showWarning(session, entry);
|
|
}
|
|
let silencedMinutes = silenceForWarning(recentWarnings(target));
|
|
const left = silenceRemaining(target);
|
|
if (silencedMinutes && left !== PERMANENT && left < silencedMinutes * SECONDS_PER_MINUTE) {
|
|
actions.silence(target, silencedMinutes * SECONDS_PER_MINUTE);
|
|
}
|
|
else {
|
|
silencedMinutes = 0;
|
|
}
|
|
return {count: target.warnings.length, online: Boolean(session), silencedMinutes};
|
|
},
|
|
|
|
// takes back their latest warning (one given by mistake). a silence it
|
|
// brought stays; that is lifted on its own (silence 0). returns the
|
|
// warning taken back, or null when there is none.
|
|
unwarn(target) {
|
|
const list = target.warnings || [];
|
|
if (!list.length) {
|
|
return null;
|
|
}
|
|
const removed = list[list.length - 1];
|
|
target.warnings = list.slice(0, -1);
|
|
accounts.save();
|
|
return removed;
|
|
},
|
|
};
|
|
|
|
// the client's moderator requests, refused whoever sends them. each
|
|
// expects [0] for failure; "fc" (clear den) has no reply at all.
|
|
const refuse = reply => session => session.sendXt(reply, -1, 0);
|
|
const handlers = {fk: refuse("fk"), fb: refuse("fb"), fs: refuse("fs"), fm: refuse("fm"), fg: refuse("fg"), fp: refuse("fp"), fc() {}};
|
|
|
|
// the first room has loaded (lib/world.js): a warning given while they
|
|
// were away is shown now, the latest only (the game has one warning
|
|
// popup), and all of them count as seen.
|
|
const greet = session => {
|
|
const unseen = (session.account.warnings || []).filter(entry => entry.seen === false);
|
|
if (!unseen.length) {
|
|
return;
|
|
}
|
|
unseen.forEach(entry => { entry.seen = true; });
|
|
accounts.save();
|
|
showWarning(session, unseen[unseen.length - 1]);
|
|
};
|
|
|
|
return {handlers, actions, greet, banRemaining, banOf, isSilenced, silenceRemaining, PERMANENT, WARNINGS: Object.keys(WARNINGS)};
|
|
};
|
|
|
|
Object.assign(module.exports, {isSilenced, banRemaining, banOf});
|