2345 lines
95 KiB
JavaScript
2345 lines
95 KiB
JavaScript
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var abuse_monitor_exports = {};
|
|
__export(abuse_monitor_exports, {
|
|
cache: () => cache,
|
|
chatfilter: () => chatfilter,
|
|
classifier: () => classifier,
|
|
commands: () => commands,
|
|
handlers: () => handlers,
|
|
lastLogTime: () => lastLogTime,
|
|
lock: () => lock,
|
|
loginfilter: () => loginfilter,
|
|
metadata: () => metadata,
|
|
migrated: () => migrated,
|
|
muted: () => muted,
|
|
notifyStaff: () => notifyStaff,
|
|
pages: () => pages,
|
|
pokemonRegex: () => pokemonRegex,
|
|
punishmentCache: () => punishmentCache,
|
|
punishmentfilter: () => punishmentfilter,
|
|
reviews: () => reviews,
|
|
runActions: () => runActions,
|
|
searchModlog: () => searchModlog,
|
|
settings: () => settings,
|
|
writeStats: () => writeStats
|
|
});
|
|
module.exports = __toCommonJS(abuse_monitor_exports);
|
|
var Artemis = __toESM(require("../artemis"));
|
|
var import_lib = require("../../lib");
|
|
var import_config_loader = require("../config-loader");
|
|
var import_dex_data = require("../../sim/dex-data");
|
|
var import_helptickets = require("./helptickets");
|
|
const WHITELIST = ["mia"];
|
|
const MUTE_DURATION = 7 * 60 * 1e3;
|
|
const DAY = 24 * 60 * 60 * 1e3;
|
|
const STAFF_NOTIF_INTERVAL = 10 * 60 * 1e3;
|
|
const MAX_MODLOG_TIME = 2 * 365 * DAY;
|
|
const NON_PUNISHMENTS = ["MUTE", "REPORT"];
|
|
const NOJOIN_COMMAND_WHITELIST = {
|
|
"lock": "/lock",
|
|
"weeklock": "/weeklock",
|
|
"warn": "/warn",
|
|
"forcerename": "/fr",
|
|
"namelock": "/nl",
|
|
"weeknamelock": "/wnl"
|
|
};
|
|
let migrated = global.Chat?.oldPlugins["abuse-monitor"]?.migrated || false;
|
|
const cache = (() => {
|
|
const plugin = global.Chat?.oldPlugins["abuse-monitor"];
|
|
if (!plugin?.cache)
|
|
return {};
|
|
if (plugin.migrated)
|
|
return plugin.cache;
|
|
for (const k in plugin.cache) {
|
|
const cur = plugin.cache[k];
|
|
if (typeof cur.recommended?.type === "string") {
|
|
delete cur.recommended;
|
|
}
|
|
}
|
|
migrated = true;
|
|
return plugin.cache;
|
|
})();
|
|
const muted = Chat.oldPlugins["abuse-monitor"]?.muted || /* @__PURE__ */ new WeakMap();
|
|
const defaults = {
|
|
threshold: 4,
|
|
thresholdIncrement: null,
|
|
minScore: 0.65,
|
|
specials: {
|
|
THREAT: { 0.96: "MAXIMUM" },
|
|
IDENTITY_ATTACK: { 0.8: 2 },
|
|
SEVERE_TOXICITY: { 0.8: 2 }
|
|
},
|
|
replacements: {},
|
|
recommendOnly: true,
|
|
punishments: [
|
|
{ certainty: 0.93, type: "IDENTITY_ATTACK", punishment: "WARN", count: 2 }
|
|
]
|
|
};
|
|
const settings = (() => {
|
|
try {
|
|
return { ...defaults, ...JSON.parse((0, import_lib.FS)("config/chat-plugins/nf.json").readSync()) };
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT")
|
|
throw e;
|
|
return defaults;
|
|
}
|
|
})();
|
|
const reviews = (() => {
|
|
try {
|
|
return JSON.parse((0, import_lib.FS)(`config/chat-plugins/artemis-reviews.json`).readSync());
|
|
} catch {
|
|
return {};
|
|
}
|
|
})();
|
|
const metadata = (() => {
|
|
try {
|
|
return JSON.parse((0, import_lib.FS)("config/chat-plugins/artemis-metadata.json").readSync());
|
|
} catch {
|
|
return {};
|
|
}
|
|
})();
|
|
function nextMonth(month) {
|
|
const next = new Date(new Date(`${month}-15`).getTime() + 30 * 24 * 60 * 60 * 1e3);
|
|
return next.toISOString().slice(0, 7);
|
|
}
|
|
function isFlaggedUserid(name, room) {
|
|
const id = (0, import_dex_data.toID)(name);
|
|
const entry = cache[room]?.staffNotified;
|
|
if (!entry)
|
|
return false;
|
|
return typeof entry === "string" ? entry === id : entry.includes(id);
|
|
}
|
|
function visualizePunishmentKey(punishment, key) {
|
|
if (key === "secondaryTypes") {
|
|
if (!punishment.secondaryTypes)
|
|
return "";
|
|
const keys = import_lib.Utils.sortBy(Object.keys(punishment.secondaryTypes));
|
|
return `${keys.map((k) => `${k}: ${punishment.secondaryTypes[k]}`).join(", ")}`;
|
|
}
|
|
return punishment[key]?.toString() || "";
|
|
}
|
|
function visualizePunishment(punishment) {
|
|
return import_lib.Utils.sortBy(Object.keys(punishment)).map((k) => `${k}: ${visualizePunishmentKey(punishment, k)}`).join(", ");
|
|
}
|
|
function displayResolved(review, justSubmitted = false) {
|
|
const user = Users.get(review.staff);
|
|
if (!user)
|
|
return;
|
|
const resolved = review.resolved;
|
|
if (!resolved)
|
|
return;
|
|
const prefix = `|pm|&|${user.getIdentity()}|`;
|
|
user.send(
|
|
prefix + `Your Artemis review for <<${review.room}>> was resolved by ${resolved.by}` + (justSubmitted ? "." : `, ${Chat.toDurationString(Date.now() - resolved.time)} ago.`)
|
|
);
|
|
if (resolved.details)
|
|
user.send(prefix + `The response was: "${resolved.details}"`);
|
|
const idx = reviews[review.staff].findIndex((r) => r.room === review.room);
|
|
if (idx > -1)
|
|
reviews[review.staff].splice(idx, 1);
|
|
if (!reviews[review.staff].length) {
|
|
delete reviews[review.staff];
|
|
}
|
|
saveReviews();
|
|
}
|
|
const punishmentCache = Chat.oldPlugins["abuse-monitor"]?.punishmentCache || /* @__PURE__ */ new WeakMap();
|
|
async function searchModlog(query) {
|
|
const userObj = Users.get(query.user);
|
|
if (userObj) {
|
|
const data = punishmentCache.get(userObj);
|
|
if (data) {
|
|
let sum = 0;
|
|
for (const action of query.actions || Object.keys(data)) {
|
|
sum += data[action] || 0;
|
|
}
|
|
return sum;
|
|
}
|
|
}
|
|
const search = {
|
|
user: [],
|
|
ip: [],
|
|
note: [],
|
|
actionTaker: [],
|
|
action: []
|
|
};
|
|
if (query.user)
|
|
search.user.push({ search: query.user, isExact: true });
|
|
if (query.ip) {
|
|
if (!Array.isArray(query.ip))
|
|
query.ip = [query.ip];
|
|
for (const ip of query.ip) {
|
|
search.ip.push({ search: ip });
|
|
}
|
|
}
|
|
const modlog = await Rooms.Modlog.search("global", search);
|
|
if (!modlog)
|
|
return 0;
|
|
const ignores = metadata.modlogIgnores?.[query.user];
|
|
if (userObj) {
|
|
const validTypes = Array.from(Punishments.punishmentTypes.keys());
|
|
const cacheEntry = {};
|
|
for (const entry of modlog.results) {
|
|
if (Date.now() - entry.time > MAX_MODLOG_TIME)
|
|
continue;
|
|
if (!validTypes.some((k) => entry.action.endsWith(k)))
|
|
continue;
|
|
if (!cacheEntry[entry.action])
|
|
cacheEntry[entry.action] = 0;
|
|
if (ignores) {
|
|
if (typeof ignores === "string" && new Date(ignores).getTime() < new Date(entry.time).getTime()) {
|
|
continue;
|
|
} else if (Array.isArray(ignores) && ignores.includes(entry.entryID)) {
|
|
continue;
|
|
}
|
|
}
|
|
cacheEntry[entry.action]++;
|
|
}
|
|
punishmentCache.set(userObj, cacheEntry);
|
|
let sum = 0;
|
|
for (const action of query.actions || Object.keys(cacheEntry)) {
|
|
sum += cacheEntry[action] || 0;
|
|
}
|
|
return sum;
|
|
}
|
|
if (query.actions) {
|
|
for (const [i, entry] of modlog.results.entries()) {
|
|
if (!query.actions.includes(entry.action)) {
|
|
modlog.results.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
return modlog.results.length;
|
|
}
|
|
const classifier = new Artemis.RemoteClassifier();
|
|
async function runActions(user, room, message, response) {
|
|
const keys = import_lib.Utils.sortBy(Object.keys(response), (k) => -response[k]);
|
|
const recommended = [];
|
|
const prevRecommend = cache[room.roomid]?.recommended?.[user.id];
|
|
for (const punishment of settings.punishments) {
|
|
if (prevRecommend?.type) {
|
|
if (PUNISHMENTS.indexOf(punishment.punishment) <= PUNISHMENTS.indexOf(prevRecommend?.type))
|
|
continue;
|
|
}
|
|
for (const type of keys) {
|
|
const num = response[type];
|
|
if (punishment.type && punishment.type !== type)
|
|
continue;
|
|
if (punishment.certainty && punishment.certainty > num)
|
|
continue;
|
|
if (punishment.modlogCount) {
|
|
const modlog = await searchModlog({
|
|
user: user.id,
|
|
actions: punishment.modlogActions
|
|
});
|
|
if (modlog < punishment.modlogCount)
|
|
continue;
|
|
}
|
|
if (punishment.secondaryTypes) {
|
|
let matches = 0;
|
|
for (const curType in punishment.secondaryTypes) {
|
|
if (response[curType] >= punishment.secondaryTypes[curType])
|
|
matches++;
|
|
}
|
|
if (matches < Object.keys(punishment.secondaryTypes).length)
|
|
continue;
|
|
}
|
|
if (punishment.count) {
|
|
let hits = await Chat.database.all(
|
|
`SELECT * FROM perspective_flags WHERE userid = ? AND type = ? AND certainty >= ?`,
|
|
[user.id, type, num]
|
|
);
|
|
hits = hits.filter((f) => {
|
|
const date = new Date(f.time);
|
|
if (date.getFullYear() < 2022)
|
|
return false;
|
|
return !(date.getFullYear() === 2022 && date.getMonth() <= 4 && date.getDate() <= 17);
|
|
});
|
|
if (hits.length < punishment.count)
|
|
continue;
|
|
}
|
|
recommended.push([punishment.punishment, type, !!punishment.requiresPunishment]);
|
|
}
|
|
}
|
|
if (recommended.length) {
|
|
import_lib.Utils.sortBy(recommended, ([punishment2]) => -PUNISHMENTS.indexOf(punishment2));
|
|
if (recommended.filter((k) => !NON_PUNISHMENTS.includes(k[1])).every((k) => k[2])) {
|
|
return;
|
|
}
|
|
const [punishment, reason] = recommended[0];
|
|
if (cache[room.roomid]) {
|
|
if (!cache[room.roomid].recommended)
|
|
cache[room.roomid].recommended = {};
|
|
cache[room.roomid].recommended[user.id] = { type: punishment, reason: reason.replace(/_/g, " ").toLowerCase() };
|
|
}
|
|
if (user.trusted) {
|
|
Rooms.get("staff")?.add(
|
|
`|c|&|/log [Artemis] ${getViewLink(room.roomid)} ${punishment} recommended for trusted user ${user.id}${user.trusted !== user.id ? ` [${user.trusted}]` : ""} `
|
|
).update();
|
|
return;
|
|
}
|
|
const result = await punishmentHandlers[(0, import_dex_data.toID)(punishment)]?.(user, room, response, message);
|
|
writeStats("punishments", {
|
|
punishment,
|
|
userid: user.id,
|
|
roomid: room.roomid,
|
|
timestamp: Date.now()
|
|
});
|
|
if (result !== false) {
|
|
const notified = cache[room.roomid].staffNotified;
|
|
if (notified) {
|
|
if (typeof notified === "string") {
|
|
if (notified === user.id)
|
|
delete cache[room.roomid].staffNotified;
|
|
} else {
|
|
notified.splice(notified.indexOf(user.id), 1);
|
|
if (!notified.length) {
|
|
delete cache[room.roomid].staffNotified;
|
|
void Chat.database.run(
|
|
`INSERT INTO perspective_stats (staff, roomid, result, timestamp) VALUES ($staff, $roomid, $result, $timestamp) ON CONFLICT (roomid) DO UPDATE SET result = $result, timestamp = $timestamp`,
|
|
// todo: maybe use 3 to indicate punishment?
|
|
{ staff: "", roomid: room.roomid, result: 1, timestamp: Date.now() }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
delete cache[room.roomid].users[user.id];
|
|
if (!Object.keys(cache[room.roomid].users).length) {
|
|
delete cache[room.roomid];
|
|
}
|
|
notifyStaff();
|
|
}
|
|
}
|
|
}
|
|
function globalModlog(action, user, note, roomid) {
|
|
if (typeof roomid === "object")
|
|
roomid = roomid.roomid;
|
|
user = Users.get(user) || user;
|
|
void Rooms.Modlog.write(roomid || "global", {
|
|
isGlobal: true,
|
|
action,
|
|
ip: user && typeof user === "object" ? user.latestIp : void 0,
|
|
userid: (0, import_dex_data.toID)(user) || void 0,
|
|
loggedBy: "artemis",
|
|
note
|
|
});
|
|
}
|
|
const getViewLink = (roomid) => `<<view-battlechat-${roomid.replace("battle-", "")}>>`;
|
|
function addGlobalModAction(message, room) {
|
|
room.add(`|c|&|/log ${message}`).update();
|
|
Rooms.get(`staff`)?.add(`|c|&|/log ${getViewLink(room.roomid)} ${message}`).update();
|
|
}
|
|
const DISCLAIMER = '<small>This action was done automatically. Want to learn more about the AI? <a href="https://www.smogon.com/forums/threads/3570628/#post-9056769">Visit the information thread</a>.</small>';
|
|
async function lock(user, room, reason, isWeek) {
|
|
if (settings.recommendOnly) {
|
|
Rooms.get("staff")?.add(
|
|
`|c|&|/log [Artemis] ${getViewLink(room.roomid)} ${isWeek ? "WEEK" : ""}LOCK recommended for ${user.id}`
|
|
).update();
|
|
room.hideText([user.id], void 0, true);
|
|
return false;
|
|
}
|
|
const affected = await Punishments.lock(
|
|
user,
|
|
isWeek ? Date.now() + 7 * 24 * 60 * 60 * 1e3 : null,
|
|
user.id,
|
|
false,
|
|
reason,
|
|
false,
|
|
["#artemis"]
|
|
);
|
|
globalModlog(`${isWeek ? "WEEK" : ""}LOCK`, user, reason, room);
|
|
addGlobalModAction(`${user.name} was locked from talking by Artemis${isWeek ? " for a week. " : ". "}(${reason})`, room);
|
|
if (affected.length > 1) {
|
|
Rooms.get("staff")?.add(
|
|
`|c|&|/log (${user.id}'s locked alts: ${affected.slice(1).map((curUser) => curUser.getLastName()).join(", ")})`
|
|
);
|
|
}
|
|
room.add(`|c|&|/raw ${DISCLAIMER}`).update();
|
|
room.hideText(affected.map((f) => f.id), void 0, true);
|
|
let message = `|popup||html|${user.name} has locked you from talking in chats, battles, and PMing regular users`;
|
|
message += ` ${isWeek ? "for two days" : "for a week"}`;
|
|
message += `
|
|
|
|
Reason: ${reason}`;
|
|
let appeal = "";
|
|
if (Chat.pages.help) {
|
|
appeal += `<a href="view-help-request--appeal"><button class="button"><strong>Appeal your punishment</strong></button></a>`;
|
|
} else if (import_config_loader.Config.appealurl) {
|
|
appeal += `appeal: <a href="${import_config_loader.Config.appealurl}">${import_config_loader.Config.appealurl}</a>`;
|
|
}
|
|
if (appeal)
|
|
message += `
|
|
|
|
If you feel that your lock was unjustified, you can ${appeal}.`;
|
|
message += `
|
|
|
|
Your lock will expire in a few days.`;
|
|
user.send(message);
|
|
const roomauth = Rooms.global.destroyPersonalRooms(user.id);
|
|
if (roomauth.length) {
|
|
Monitor.log(
|
|
`[CrisisMonitor] Locked user ${user.name} has public roomauth (${roomauth.join(", ")}), and should probably be demoted.`
|
|
);
|
|
}
|
|
}
|
|
const punishmentHandlers = {
|
|
report(user, room) {
|
|
for (const k in room.users) {
|
|
if (k === user.id)
|
|
continue;
|
|
const u = room.users[k];
|
|
if (room.auth.get(u) !== Users.PLAYER_SYMBOL)
|
|
continue;
|
|
u.sendTo(
|
|
room.roomid,
|
|
`|c|&|/uhtml report,Toxicity has been automatically detected in this battle, please click below if you would like to report it.<br /><a class="button notifying" href="/view-help-request">Make a report</a>`
|
|
);
|
|
}
|
|
},
|
|
mute(user, room) {
|
|
const roomMutes = muted.get(room) || /* @__PURE__ */ new WeakMap();
|
|
if (!user.trusted) {
|
|
muted.set(room, roomMutes);
|
|
roomMutes.set(user, Date.now() + MUTE_DURATION);
|
|
}
|
|
},
|
|
warn(user, room, response, message) {
|
|
const reason = `${Users.PLAYER_SYMBOL}${user.name}: ${message}`;
|
|
if (!user.connected) {
|
|
Punishments.offlineWarns.set(user.id, reason);
|
|
} else {
|
|
user.send(`|c|~|/warn ${reason}`);
|
|
}
|
|
globalModlog("WARN", user, reason, room);
|
|
addGlobalModAction(`${user.name} was warned by Artemis (${reason})`, room);
|
|
const punishments = punishmentCache.get(user) || {};
|
|
if (!punishments["WARN"])
|
|
punishments["WARN"] = 0;
|
|
punishments["WARN"]++;
|
|
punishmentCache.set(user, punishments);
|
|
room.add(`|c|&|/raw ${DISCLAIMER}`).update();
|
|
room.hideText([user.id], void 0, true);
|
|
},
|
|
lock(user, room, response, message) {
|
|
return lock(user, room, `${Users.PLAYER_SYMBOL}${user.name}: ${message}`);
|
|
},
|
|
weeklock(user, room, response, message) {
|
|
return lock(user, room, `${Users.PLAYER_SYMBOL}${user.name}: ${message}`, true);
|
|
}
|
|
};
|
|
const PUNISHMENTS = Object.keys(punishmentHandlers).map((f) => f.toUpperCase());
|
|
function makeScore(roomid, result) {
|
|
let score = 0;
|
|
let main = "";
|
|
const flags = /* @__PURE__ */ new Set();
|
|
for (const type in result) {
|
|
const data = result[type];
|
|
if (settings.minScore && data < settings.minScore)
|
|
continue;
|
|
const curScore = score;
|
|
if (settings.specials[type]) {
|
|
for (const k in settings.specials[type]) {
|
|
if (data < Number(k))
|
|
continue;
|
|
const num = settings.specials[type][k];
|
|
if (num === "MAXIMUM") {
|
|
score = calcThreshold(roomid);
|
|
main = type;
|
|
} else {
|
|
if (num > score) {
|
|
score = num;
|
|
main = type;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (settings.minScore) {
|
|
if (score < 1) {
|
|
score = 1;
|
|
main = type;
|
|
}
|
|
}
|
|
if (score !== curScore)
|
|
flags.add(type);
|
|
}
|
|
return { score, flags: [...flags], main };
|
|
}
|
|
const chatfilter = function(message, user, room) {
|
|
if (!room?.battle || !["rated", "unrated"].includes(room.battle.challengeType))
|
|
return;
|
|
const mutes = muted.get(room);
|
|
const muteEntry = mutes?.get(user);
|
|
if (muteEntry) {
|
|
if (Date.now() > muteEntry) {
|
|
mutes.delete(user);
|
|
if (!mutes.size) {
|
|
muted.delete(room);
|
|
}
|
|
} else {
|
|
this.sendReply(
|
|
`|c|&|/raw <div class="message-error">Your behavior in this battle has been automatically identified as breaking <a href="https://${import_config_loader.Config.routes.root}/rules">Pokemon Showdown's global rules.</a> Repeated instances of misbehavior may incur harsher punishment.</div>`
|
|
);
|
|
return false;
|
|
}
|
|
}
|
|
if (settings.disabled)
|
|
return;
|
|
if (!import_config_loader.Config.perspectiveKey || message.startsWith("!"))
|
|
return;
|
|
const roomid = room.roomid;
|
|
void (async () => {
|
|
message = message.trim();
|
|
message = message.replace(pokemonRegex, "[[Pokemon]]");
|
|
for (const k in settings.replacements) {
|
|
message = message.replace(new RegExp(k, "gi"), settings.replacements[k]);
|
|
}
|
|
const response = await classifier.classify(message);
|
|
const { score, flags, main } = makeScore(roomid, response || {});
|
|
if (score) {
|
|
if (!cache[roomid])
|
|
cache[roomid] = { users: {} };
|
|
if (!cache[roomid].users[user.id])
|
|
cache[roomid].users[user.id] = 0;
|
|
cache[roomid].users[user.id] += score;
|
|
let hitThreshold = 0;
|
|
if (cache[roomid].users[user.id] >= calcThreshold(roomid)) {
|
|
let notified = cache[roomid].staffNotified;
|
|
if (notified) {
|
|
if (!Array.isArray(notified)) {
|
|
cache[roomid].staffNotified = notified = [notified];
|
|
}
|
|
if (!notified.includes(user.id)) {
|
|
notified.push(user.id);
|
|
}
|
|
} else {
|
|
cache[roomid].staffNotified = [user.id];
|
|
}
|
|
notifyStaff();
|
|
hitThreshold = 1;
|
|
void room?.uploadReplay?.(user, this.connection, "forpunishment");
|
|
await Chat.database.run(
|
|
`INSERT INTO perspective_flags (userid, score, certainty, type, roomid, time) VALUES (?, ?, ?, ?, ?, ?)`,
|
|
// response exists if we got this far
|
|
[user.id, score, response[main], main, room.roomid, Date.now()]
|
|
);
|
|
void runActions(user, room, message, response || {});
|
|
}
|
|
await Chat.database.run(
|
|
"INSERT INTO perspective_logs (userid, message, score, flags, roomid, time, hit_threshold) VALUES (?, ?, ?, ?, ?, ?, ?)",
|
|
[user.id, message, score, import_lib.Utils.sortBy(flags).join(","), roomid, Date.now(), hitThreshold]
|
|
);
|
|
}
|
|
})();
|
|
};
|
|
chatfilter.priority = -100;
|
|
const loginfilter = (user) => {
|
|
if (reviews[user.id]?.length) {
|
|
for (const r of reviews[user.id]) {
|
|
displayResolved(r);
|
|
}
|
|
}
|
|
};
|
|
function calcThreshold(roomid) {
|
|
const incr = settings.thresholdIncrement;
|
|
let num = settings.threshold;
|
|
const room = Rooms.get(roomid);
|
|
if (!room || !room.battle || !incr)
|
|
return num;
|
|
if (!incr.minTurns || room.battle.turn >= incr.minTurns) {
|
|
num += Math.floor(room.battle.turn / incr.turns) * incr.amount;
|
|
}
|
|
return num;
|
|
}
|
|
const handlers = {
|
|
onRoomDestroy(roomid) {
|
|
const entry = cache[roomid];
|
|
if (entry) {
|
|
delete cache[roomid];
|
|
if (entry.staffNotified) {
|
|
notifyStaff();
|
|
void Chat.database.run(
|
|
`INSERT INTO perspective_stats (staff, roomid, result, timestamp) VALUES ($staff, $roomid, $result, $timestamp) ON CONFLICT (roomid) DO UPDATE SET result = $result, timestamp = $timestamp`,
|
|
// 2 means dead
|
|
{ staff: "", roomid, result: 2, timestamp: Date.now() }
|
|
);
|
|
}
|
|
}
|
|
},
|
|
onRoomClose(roomid, user) {
|
|
if (!roomid.startsWith("view-abusemonitor-view"))
|
|
return;
|
|
const targetId = roomid.slice("view-abusemonitor-view-".length);
|
|
if (cache[targetId]?.claimed === user.id) {
|
|
delete cache[targetId].claimed;
|
|
notifyStaff();
|
|
}
|
|
},
|
|
onRenameRoom(oldId, newId, room) {
|
|
if (cache[oldId]) {
|
|
cache[newId] = cache[oldId];
|
|
delete cache[oldId];
|
|
notifyStaff();
|
|
}
|
|
}
|
|
};
|
|
function getFlaggedRooms() {
|
|
return Object.keys(cache).filter((roomid) => cache[roomid].staffNotified);
|
|
}
|
|
function writeStats(type, entry) {
|
|
const path = `logs/artemis/${type}/${Chat.toTimestamp(new Date()).split(" ")[0].slice(0, -3)}.jsonl`;
|
|
try {
|
|
(0, import_lib.FS)(path).parentDir().mkdirpSync();
|
|
} catch {
|
|
}
|
|
void (0, import_lib.FS)(path).append(JSON.stringify(entry) + "\n");
|
|
}
|
|
function saveSettings(path) {
|
|
if (!path)
|
|
path = "nf";
|
|
(0, import_lib.FS)(`config/chat-plugins/${path}.json`).writeUpdate(() => JSON.stringify(settings));
|
|
}
|
|
function saveReviews() {
|
|
(0, import_lib.FS)(`config/chat-plugins/artemis-reviews.json`).writeUpdate(() => JSON.stringify(reviews));
|
|
}
|
|
function saveMetadata() {
|
|
(0, import_lib.FS)("config/chat-plugins/artemis-metadata.json").writeUpdate(() => JSON.stringify(metadata));
|
|
}
|
|
const pokemonRegex = new RegExp(
|
|
// we want only base formes and existent stuff
|
|
`\\b(${Dex.species.all().filter((s) => !s.forme && s.num > 0).map((f) => f.id).join("|")})\\b`,
|
|
"gi"
|
|
);
|
|
let lastLogTime = Chat.oldPlugins["abuse-monitor"]?.lastLogTime || 0;
|
|
function notifyStaff() {
|
|
const staffRoom = Rooms.get("staff");
|
|
if (staffRoom) {
|
|
const flagged = getFlaggedRooms();
|
|
let buf = "";
|
|
if (flagged.length) {
|
|
buf = `<button class="button" name="send" value="/am">Flagged battles need review</button>`;
|
|
} else {
|
|
buf = "No battles flagged.";
|
|
}
|
|
if (lastLogTime + STAFF_NOTIF_INTERVAL < Date.now() || !flagged.length) {
|
|
staffRoom.send(`|uhtml|abusemonitor|<div class="infobox">${buf}</div>`);
|
|
if (flagged.length) {
|
|
lastLogTime = Date.now();
|
|
} else {
|
|
lastLogTime = 0;
|
|
}
|
|
}
|
|
Chat.refreshPageFor("abusemonitor-flagged", staffRoom);
|
|
}
|
|
}
|
|
function checkAccess(context, perm = "bypassall") {
|
|
const user = context.user;
|
|
if (!(WHITELIST.includes(user.id) || user.previousIDs.some((id) => WHITELIST.includes(id)))) {
|
|
context.checkCan(perm);
|
|
}
|
|
}
|
|
const commands = {
|
|
am: "abusemonitor",
|
|
abusemonitor: {
|
|
""() {
|
|
return this.parse("/join view-abusemonitor-flagged");
|
|
},
|
|
async test(target, room, user) {
|
|
checkAccess(this);
|
|
const text = target;
|
|
if (!text)
|
|
return this.parse(`/help abusemonitor`);
|
|
this.runBroadcast();
|
|
let response = await classifier.classify(text);
|
|
if (!response)
|
|
response = {};
|
|
for (const k in settings.replacements) {
|
|
target = target.replace(new RegExp(k, "gi"), settings.replacements[k]);
|
|
}
|
|
const { score, flags } = makeScore("staff", response);
|
|
let buf = `<strong>Score for "${text}"${target === text ? "" : ` (alt: "${target}")`}:</strong> ${score}<br />`;
|
|
buf += `<strong>Flags:</strong> ${flags.join(", ")}<br />`;
|
|
const punishments = [];
|
|
for (const [i, p] of settings.punishments.entries()) {
|
|
const matches = [];
|
|
for (const k in response) {
|
|
const descriptors = [];
|
|
if (p.type) {
|
|
if (p.type !== k)
|
|
continue;
|
|
descriptors.push("type");
|
|
}
|
|
if (p.certainty) {
|
|
if (response[k] < p.certainty)
|
|
continue;
|
|
descriptors.push("certainty");
|
|
}
|
|
const secondaries = Object.entries(p.secondaryTypes || {});
|
|
if (secondaries.length) {
|
|
if (!secondaries.every(([sK, sV]) => response[sK] >= sV))
|
|
continue;
|
|
descriptors.push("secondary");
|
|
}
|
|
if (descriptors.length) {
|
|
matches.push(`${k} (${descriptors.map((f) => `${f} match`).join(", ")})`);
|
|
}
|
|
}
|
|
if (matches.length) {
|
|
punishments.push({
|
|
punishment: p,
|
|
desc: matches,
|
|
index: i
|
|
});
|
|
}
|
|
}
|
|
if (punishments.length) {
|
|
buf += `<strong>Punishments:</strong><br />`;
|
|
buf += punishments.map((p) => `• ${p.index + 1}: <code>${visualizePunishment(p.punishment)}</code>: ${p.desc.join(", ")}`).join("<br />");
|
|
buf += `<br />`;
|
|
}
|
|
buf += `<strong>Score breakdown:</strong><br />`;
|
|
for (const k in response) {
|
|
buf += `• ${k}: ${response[k]}<br />`;
|
|
}
|
|
this.sendReplyBox(buf);
|
|
},
|
|
cm: "compare",
|
|
async compare(target) {
|
|
checkAccess(this);
|
|
const [base, against] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim());
|
|
if (!(base && against))
|
|
return this.parse(`/help abusemonitor`);
|
|
const colors = {
|
|
"0": "Purple",
|
|
"1": "DodgerBlue",
|
|
"2": "Red"
|
|
};
|
|
const baseResponse = await classifier.classify(base) || {};
|
|
const againstResponse = await new Promise((resolve) => {
|
|
setTimeout(() => {
|
|
resolve(classifier.classify(against));
|
|
}, 500);
|
|
}) || {};
|
|
let buf = import_lib.Utils.html`<strong>Compared scores for "${base}" `;
|
|
buf += `(<strong style="color: ${colors["1"]}">1</strong>) `;
|
|
buf += import_lib.Utils.html`and "${against}" (<strong style="color: ${colors["2"]}">2</strong>): </strong><br />`;
|
|
for (const [k, val] of Object.entries(baseResponse)) {
|
|
const max = Math.max(val, againstResponse[k]);
|
|
const num = val === againstResponse[k] ? "0" : max === val ? "1" : "2";
|
|
buf += `• ${k}: <strong style="color: ${colors[num]}">${num}</strong> `;
|
|
if (num === "0") {
|
|
buf += `(${max})`;
|
|
} else {
|
|
buf += `(${max} vs ${(max === val ? againstResponse : baseResponse)[k]})`;
|
|
}
|
|
buf += `<br />`;
|
|
}
|
|
this.runBroadcast();
|
|
return this.sendReplyBox(buf);
|
|
},
|
|
async score(target) {
|
|
checkAccess(this);
|
|
target = target.trim();
|
|
if (!target)
|
|
return this.parse(`/help abusemonitor`);
|
|
const [text, scoreText] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim());
|
|
const args = Chat.parseArguments(scoreText, ",", { useIDs: false });
|
|
const scores = {};
|
|
for (let k in args) {
|
|
const vals = args[k];
|
|
if (vals.length > 1) {
|
|
return this.errorReply(`Too many values for ${k}`);
|
|
}
|
|
k = k.toUpperCase().replace(/\s/g, "_");
|
|
if (!(k in Artemis.RemoteClassifier.ATTRIBUTES)) {
|
|
return this.errorReply(`Invalid attribute: ${k}`);
|
|
}
|
|
const val = parseFloat(vals[0]);
|
|
if (isNaN(val)) {
|
|
return this.errorReply(`Invalid value for ${k}: ${vals[0]}`);
|
|
}
|
|
scores[k] = val;
|
|
}
|
|
for (const k in Artemis.RemoteClassifier.ATTRIBUTES) {
|
|
if (!(k in scores))
|
|
scores[k] = 0;
|
|
}
|
|
const response = await classifier.suggestScore(text, scores);
|
|
if (response.error)
|
|
throw new Chat.ErrorMessage(response.error);
|
|
this.sendReply(`Recommendation successfully sent.`);
|
|
Rooms.get("abuselog")?.roomlog(`${this.user.name} used /am score ${target}`);
|
|
},
|
|
toggle(target) {
|
|
checkAccess(this);
|
|
if (this.meansYes(target)) {
|
|
if (!settings.disabled)
|
|
return this.errorReply(`The abuse monitor is already enabled.`);
|
|
settings.disabled = false;
|
|
} else if (this.meansNo(target)) {
|
|
if (settings.disabled)
|
|
return this.errorReply(`The abuse monitor is already disabled.`);
|
|
settings.disabled = true;
|
|
} else {
|
|
return this.errorReply(`Invalid setting. Must be 'on' or 'off'.`);
|
|
}
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${this.user.name} ${!settings.disabled ? "enabled" : "disabled"} the abuse monitor.`);
|
|
this.globalModlog("ABUSEMONITOR", null, !settings.disabled ? "enable" : "disable");
|
|
},
|
|
threshold(target) {
|
|
checkAccess(this);
|
|
if (!target) {
|
|
return this.sendReply(`The current abuse monitor threshold is ${settings.threshold}.`);
|
|
}
|
|
const num = parseInt(target);
|
|
if (isNaN(num)) {
|
|
this.errorReply(`Invalid number: ${target}`);
|
|
return this.parse(`/help abusemonitor`);
|
|
}
|
|
if (settings.threshold === num) {
|
|
return this.errorReply(`The abuse monitor threshold is already ${num}.`);
|
|
}
|
|
settings.threshold = num;
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${this.user.name} set the abuse monitor trigger threshold to ${num}.`);
|
|
this.globalModlog("ABUSEMONITOR THRESHOLD", null, `${num}`);
|
|
this.sendReply(
|
|
`|html|Remember to use <code>/am respawn</code> to deploy the settings to the child process.`
|
|
);
|
|
},
|
|
async resolve(target) {
|
|
this.checkCan("lock");
|
|
target = target.toLowerCase().trim().replace(/ +/g, "");
|
|
let [roomid, rawResult] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim());
|
|
const tarRoom = Rooms.get(roomid);
|
|
if (!tarRoom || !cache[tarRoom.roomid] || !cache[tarRoom.roomid]?.staffNotified) {
|
|
return this.popupReply(`That room has not been flagged by the abuse monitor.`);
|
|
}
|
|
if (roomid.includes("-") && roomid.endsWith("pw")) {
|
|
roomid = roomid.split("-").slice(0, -1).join("-");
|
|
}
|
|
let result = (0, import_dex_data.toID)(rawResult) === "success" ? 1 : (0, import_dex_data.toID)(rawResult) === "failure" ? 0 : null;
|
|
if (result === null)
|
|
return this.popupReply(`Invalid result - must be 'success' or 'failure'.`);
|
|
const inserted = await Chat.database.get(`SELECT result FROM perspective_stats WHERE roomid = ?`, [roomid]);
|
|
if (inserted?.result === 1) {
|
|
result = inserted.result;
|
|
}
|
|
delete cache[tarRoom.roomid];
|
|
notifyStaff();
|
|
this.closePage(`abusemonitor-view-${tarRoom.roomid}`);
|
|
this.closePage(`abusemonitor-flagged`);
|
|
await Chat.database.run(
|
|
`INSERT INTO perspective_stats (staff, roomid, result, timestamp) VALUES ($staff, $roomid, $result, $timestamp) ON CONFLICT (roomid) DO UPDATE SET result = $result, timestamp = $timestamp`,
|
|
{ staff: this.user.id, roomid, result, timestamp: Date.now() }
|
|
);
|
|
return this.parse(`/j view-abusemonitor-flagged`);
|
|
},
|
|
unmute(target, room, user) {
|
|
this.checkCan("lock");
|
|
room = this.requireRoom();
|
|
target = (0, import_dex_data.toID)(target);
|
|
if (!target) {
|
|
return this.parse(`/help am`);
|
|
}
|
|
const roomMutes = muted.get(room);
|
|
if (!roomMutes) {
|
|
return this.errorReply(`No users have Artemis mutes in this room.`);
|
|
}
|
|
const targetUser = Users.get(target);
|
|
if (!targetUser) {
|
|
return this.errorReply(`User '${target}' not found.`);
|
|
}
|
|
if (!roomMutes.has(targetUser)) {
|
|
return this.errorReply(`That user does not have an Artemis mute in this room.`);
|
|
}
|
|
roomMutes.delete(targetUser);
|
|
this.modlog(`ABUSEMONITOR UNMUTE`, targetUser);
|
|
this.privateModAction(`${user.name} removed ${targetUser.name}'s Artemis mute.`);
|
|
},
|
|
async nojoinpunish(target, room, user) {
|
|
this.checkCan("lock");
|
|
const [roomid, type, rest] = import_lib.Utils.splitFirst(target, ",", 2).map((f) => f.trim());
|
|
const tarRoom = Rooms.get(roomid);
|
|
if (!tarRoom)
|
|
return this.popupReply(`The room "${roomid}" does not exist.`);
|
|
const cmd = NOJOIN_COMMAND_WHITELIST[(0, import_dex_data.toID)(type)];
|
|
if (!cmd) {
|
|
return this.errorReply(
|
|
`Invalid punishment given. Must be one of ${Object.keys(NOJOIN_COMMAND_WHITELIST).join(", ")}.`
|
|
);
|
|
}
|
|
this.room = tarRoom;
|
|
this.room.reportJoin("j", user.getIdentityWithStatus(this.room), user);
|
|
const result = await this.parse(`${cmd} ${rest}`, { bypassRoomCheck: true });
|
|
if (result) {
|
|
this.add(
|
|
'|c|&|/raw If you have questions about this action, please contact staff by making a <a href="view-help-request" class="button">help ticket</a>'
|
|
);
|
|
}
|
|
this.room.reportJoin("l", user.getIdentityWithStatus(this.room), user);
|
|
},
|
|
view(target, room, user) {
|
|
target = target.toLowerCase().trim();
|
|
if (!target)
|
|
return this.parse(`/help am`);
|
|
return this.parse(`/j view-abusemonitor-view-${target}`);
|
|
},
|
|
logs(target) {
|
|
checkAccess(this);
|
|
const [count, userid] = import_lib.Utils.splitFirst(target, ",").map(import_dex_data.toID);
|
|
this.parse(`/join view-abusemonitor-logs-${count || "200"}${userid ? `-${userid}` : ""}`);
|
|
},
|
|
ul: "userlogs",
|
|
userlogs(target) {
|
|
checkAccess(this, "lock");
|
|
return this.parse(`/join view-abusemonitor-userlogs-${(0, import_dex_data.toID)(target)}`);
|
|
},
|
|
stats(target) {
|
|
checkAccess(this);
|
|
return this.parse(`/join view-abusemonitor-stats${target ? `-${target}` : ""}`);
|
|
},
|
|
async respawn(target, room, user) {
|
|
checkAccess(this);
|
|
this.sendReply(`Respawning...`);
|
|
const unspawned = await classifier.respawn();
|
|
this.sendReply(`DONE. ${Chat.count(unspawned, "processes", "process")} unspawned.`);
|
|
this.addGlobalModAction(`${user.name} used /abusemonitor respawn`);
|
|
},
|
|
async rescale(target, room, user) {
|
|
if (!WHITELIST.includes(user.id))
|
|
this.canUseConsole();
|
|
const examples = target.split(",").filter(Boolean);
|
|
const type = examples.shift()?.toUpperCase().replace(/\s/g, "_") || "";
|
|
if (!(type in Artemis.RemoteClassifier.ATTRIBUTES)) {
|
|
return this.errorReply(`Invalid type: ${type}`);
|
|
}
|
|
if (examples.length < 3) {
|
|
return this.errorReply(`At least 3 examples are needed.`);
|
|
}
|
|
const scales = [];
|
|
const oldScales = [];
|
|
for (const chunk of examples) {
|
|
const [message, rawNum] = chunk.split("|");
|
|
if (!(message && rawNum)) {
|
|
return this.errorReply(`Invalid example: "${chunk}". Must be in \`\`message|num\`\` format.`);
|
|
}
|
|
const num = parseFloat(rawNum);
|
|
if (isNaN(num)) {
|
|
return this.errorReply(`Invalid number in example '${chunk}'.`);
|
|
}
|
|
const data = await classifier.classify(message);
|
|
if (!data) {
|
|
return this.errorReply(`No results found. Try again in a minute?`);
|
|
}
|
|
oldScales.push(num);
|
|
scales.push(data[type]);
|
|
await import_lib.Utils.waitUntil(Date.now() + 1e3);
|
|
}
|
|
const newAverage = scales.reduce((a, b) => a + b) / scales.length;
|
|
const oldAverage = oldScales.reduce((a, b) => a + b) / oldScales.length;
|
|
const round = (num) => Number(num.toFixed(4));
|
|
const change = newAverage / oldAverage;
|
|
this.sendReply(`Change average: ${change}`);
|
|
await this.parse(`/am bs prescale`);
|
|
for (const p of settings.punishments) {
|
|
if (p.type !== type)
|
|
continue;
|
|
if (p.certainty)
|
|
p.certainty = round(p.certainty * change);
|
|
if (p.secondaryTypes) {
|
|
for (const k in p.secondaryTypes) {
|
|
p.secondaryTypes[k] = round(p.secondaryTypes[k] * change);
|
|
}
|
|
}
|
|
}
|
|
if (type in settings.specials) {
|
|
for (const n in settings.specials[type]) {
|
|
const num = settings.specials[type][n];
|
|
delete settings.specials[type][n];
|
|
settings.specials[type][round(parseFloat(n) * change)] = num;
|
|
}
|
|
}
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.addGlobalModAction(
|
|
`${user.name} used /abusemonitor rescale ${type.toLowerCase().replace("_", "")}`
|
|
);
|
|
this.globalModlog(`ABUSEMONITOR RESCALE`, null, `${type}: ${examples.join(", ")}`);
|
|
},
|
|
async userclear(target, room, user) {
|
|
checkAccess(this);
|
|
const { targetUsername, rest } = this.splitUser(target);
|
|
const targetId = (0, import_dex_data.toID)(targetUsername);
|
|
if (!targetId)
|
|
return this.parse(`/help abusemonitor`);
|
|
if (user.lastCommand !== `am userclear ${targetId}`) {
|
|
user.lastCommand = `am userclear ${targetId}`;
|
|
this.errorReply(`Are you sure you want to clear abuse monitor database records for ${targetId}?`);
|
|
this.errorReply(`Retype the command if you're sure.`);
|
|
return;
|
|
}
|
|
user.lastCommand = "";
|
|
const results = await Chat.database.run(
|
|
"DELETE FROM perspective_logs WHERE userid = ?",
|
|
[targetId]
|
|
);
|
|
if (!results.changes) {
|
|
return this.errorReply(`No logs for ${targetUsername} found.`);
|
|
}
|
|
this.sendReply(`${results.changes} log(s) cleared for ${targetId}.`);
|
|
this.privateGlobalModAction(`${user.name} cleared abuse monitor logs for ${targetUsername}${rest ? ` (${rest})` : ""}.`);
|
|
this.globalModlog("ABUSEMONITOR CLEAR", targetId, rest);
|
|
},
|
|
async deletelog(target, room, user) {
|
|
checkAccess(this);
|
|
target = (0, import_dex_data.toID)(target);
|
|
if (!target)
|
|
return this.parse(`/help abusemonitor`);
|
|
const num = parseInt(target);
|
|
if (isNaN(num)) {
|
|
return this.errorReply(`Invalid log number: ${target}`);
|
|
}
|
|
const row = await Chat.database.get(
|
|
"SELECT * FROM perspective_logs WHERE rowid = ?",
|
|
[num]
|
|
);
|
|
if (!row) {
|
|
return this.errorReply(`No log with ID ${num} found.`);
|
|
}
|
|
await Chat.database.run(
|
|
// my kingdom for RETURNING * in sqlite :(
|
|
"DELETE FROM perspective_logs WHERE rowid = ?",
|
|
[num]
|
|
);
|
|
this.sendReply(`Log ${num} deleted.`);
|
|
this.privateGlobalModAction(`${user.name} deleted an abuse monitor log for the user ${row.userid}.`);
|
|
this.stafflog(
|
|
`Message: "${row.message}", room: ${row.roomid}, time: ${Chat.toTimestamp(new Date(row.time))}`
|
|
);
|
|
this.globalModlog("ABUSEMONITOR DELETELOG", row.userid, `${num}`);
|
|
Chat.refreshPageFor("abusemonitor-logs", "staff", true);
|
|
},
|
|
es: "editspecial",
|
|
editspecial(target, room, user) {
|
|
checkAccess(this);
|
|
if (!(0, import_dex_data.toID)(target))
|
|
return this.parse(`/help abusemonitor`);
|
|
let [rawType, rawPercent, rawScore] = target.split(",");
|
|
const type = rawType.toUpperCase().replace(/\s/g, "_");
|
|
rawScore = (0, import_dex_data.toID)(rawScore);
|
|
const types = { ...Artemis.RemoteClassifier.ATTRIBUTES, "ALL": {} };
|
|
if (!(type in types)) {
|
|
return this.errorReply(`Invalid type: ${type}. Valid types: ${Object.keys(types).join(", ")}.`);
|
|
}
|
|
const percent = parseFloat(rawPercent);
|
|
if (isNaN(percent) || percent > 1 || percent < 0) {
|
|
return this.errorReply(`Invalid percent: ${percent}. Must be between 0 and 1.`);
|
|
}
|
|
const score = parseInt(rawScore) || (0, import_dex_data.toID)(rawScore).toUpperCase();
|
|
switch (typeof score) {
|
|
case "string":
|
|
if (score !== "MAXIMUM") {
|
|
return this.errorReply(`Invalid score. Must be a number or "MAXIMUM".`);
|
|
}
|
|
break;
|
|
case "number":
|
|
if (isNaN(score) || score < 0) {
|
|
return this.errorReply(`Invalid score. Must be a number or "MAXIMUM".`);
|
|
}
|
|
break;
|
|
}
|
|
if (settings.specials[type]?.[percent] && !this.cmd.includes("f")) {
|
|
return this.errorReply(`That special case already exists. Use /am forceeditspecial to change it.`);
|
|
}
|
|
if (!settings.specials[type])
|
|
settings.specials[type] = {};
|
|
settings.specials[type][percent] = score;
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} set the abuse monitor special case for ${type} at ${percent}% to ${score}.`);
|
|
this.globalModlog("ABUSEMONITOR SPECIAL", type, `${percent}% to ${score}`);
|
|
this.sendReply(`|html|Remember to use <code>/am respawn</code> to deploy the settings to the child processes.`);
|
|
},
|
|
ds: "deletespecial",
|
|
deletespecial(target, room, user) {
|
|
checkAccess(this);
|
|
const [rawType, rawPercent] = target.split(",");
|
|
const type = rawType.toUpperCase().replace(/\s/g, "_");
|
|
const types = { ...Artemis.RemoteClassifier.ATTRIBUTES, "ALL": {} };
|
|
if (!(type in types)) {
|
|
return this.errorReply(`Invalid type: ${type}. Valid types: ${Object.keys(types).join(", ")}.`);
|
|
}
|
|
const percent = parseFloat(rawPercent);
|
|
if (isNaN(percent) || percent > 1 || percent < 0) {
|
|
return this.errorReply(`Invalid percent: ${percent}. Must be between 0 and 1.`);
|
|
}
|
|
if (!settings.specials[type]?.[percent]) {
|
|
return this.errorReply(`That special case does not exist.`);
|
|
}
|
|
delete settings.specials[type][percent];
|
|
if (!Object.keys(settings.specials[type]).length) {
|
|
delete settings.specials[type];
|
|
}
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} deleted the abuse monitor special case for ${type} at ${percent}%.`);
|
|
this.globalModlog("ABUSEMONITOR DELETESPECIAL", type, `${percent}%`);
|
|
this.sendReply(`|html|Remember to use <code>/am respawn</code> to deploy the settings to the child processes.`);
|
|
},
|
|
em: "editmin",
|
|
editmin(target, room, user) {
|
|
checkAccess(this);
|
|
const num = parseFloat(target);
|
|
if (isNaN(num) || num < 0 || num > 1) {
|
|
return this.errorReply(`Invalid minimum score: ${num}. Must be a positive integer.`);
|
|
}
|
|
settings.minScore = num;
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} set the abuse monitor minimum score to ${num}.`);
|
|
this.globalModlog("ABUSEMONITOR MIN", null, "" + num);
|
|
this.sendReply(`|html|Remember to use <code>/am respawn</code> to deploy the settings to the child processes.`);
|
|
},
|
|
ex: "exportpunishment",
|
|
exportpunishment(target) {
|
|
checkAccess(this);
|
|
const num = parseInt(target) - 1;
|
|
if (isNaN(num)) {
|
|
return this.errorReply(`Invalid punishment number: ${num + 1}.`);
|
|
}
|
|
const punishment = settings.punishments[num];
|
|
if (!punishment) {
|
|
return this.errorReply(`Punishment ${num + 1} does not exist.`);
|
|
}
|
|
this.sendReply(
|
|
`|html|Punishment ${num + 1}: <code>${visualizePunishment(punishment).replace(/: /g, " = ")}</code>`
|
|
);
|
|
},
|
|
changeall(target, room, user) {
|
|
checkAccess(this);
|
|
const [to, from] = target.split(",").map((f) => (0, import_dex_data.toID)(f));
|
|
if (!(to && from)) {
|
|
return this.errorReply(`Specify a type to change and a type to change to.`);
|
|
}
|
|
if (![to, from].every((f) => punishmentHandlers[f])) {
|
|
return this.errorReply(
|
|
`Invalid types given. Valid types: ${Object.keys(punishmentHandlers).join(", ")}.`
|
|
);
|
|
}
|
|
const changed = [];
|
|
for (const [i, punishment] of settings.punishments.entries()) {
|
|
if ((0, import_dex_data.toID)(punishment.type) === to) {
|
|
punishment.type = from.toUpperCase();
|
|
changed.push(i + 1);
|
|
}
|
|
}
|
|
if (!changed.length) {
|
|
return this.errorReply(`No punishments of type '${to}' found.`);
|
|
}
|
|
this.sendReply(`Updated punishment(s) ${changed.join(", ")}`);
|
|
this.privateGlobalModAction(`${user.name} updated all abuse-monitor punishments of type ${to} to type ${from}`);
|
|
saveSettings();
|
|
this.globalModlog(`ABUSEMONITOR CHANGEALL`, null, `${to} to ${from}`);
|
|
},
|
|
ep: "exportpunishments",
|
|
// exports punishment settings to something easily copy/pastable
|
|
exportpunishments() {
|
|
checkAccess(this);
|
|
let buf = settings.punishments.map((punishment) => {
|
|
const line = [];
|
|
for (const k in punishment) {
|
|
const key = k;
|
|
const val = punishment[key];
|
|
switch (key) {
|
|
case "modlogCount":
|
|
line.push(`mlc=${val}`);
|
|
break;
|
|
case "modlogActions":
|
|
line.push(`${val.map((f) => `mla=${f}`).join(", ")}`);
|
|
break;
|
|
case "punishment":
|
|
line.push(`p=${val}`);
|
|
break;
|
|
case "type":
|
|
line.push(`t=${val}`);
|
|
break;
|
|
case "count":
|
|
line.push(`c=${val}`);
|
|
break;
|
|
case "certainty":
|
|
line.push(`ct=${val}`);
|
|
break;
|
|
case "secondaryTypes":
|
|
for (const type in val) {
|
|
line.push(`st=${type}|${val[type]}`);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return line.join(", ");
|
|
}).join("<br />");
|
|
if (!buf)
|
|
buf = "None found";
|
|
this.sendReplyBox(buf);
|
|
},
|
|
ap: "addpunishment",
|
|
addpunishment(target, room, user) {
|
|
checkAccess(this);
|
|
if (!(0, import_dex_data.toID)(target))
|
|
return this.parse(`/help am`);
|
|
const targets = target.split(",").map((f) => f.trim());
|
|
const punishment = {};
|
|
for (const cur of targets) {
|
|
let [key, value] = import_lib.Utils.splitFirst(cur, "=").map((f) => f.trim());
|
|
key = (0, import_dex_data.toID)(key);
|
|
if (!key || !value) {
|
|
continue;
|
|
}
|
|
switch (key) {
|
|
case "punishment":
|
|
case "p":
|
|
if (punishment.punishment) {
|
|
return this.errorReply(`Duplicate punishment values.`);
|
|
}
|
|
value = (0, import_dex_data.toID)(value).toUpperCase();
|
|
if (!PUNISHMENTS.includes(value)) {
|
|
return this.errorReply(`Invalid punishment: ${value}. Valid punishments: ${PUNISHMENTS.join(", ")}.`);
|
|
}
|
|
punishment.punishment = value;
|
|
break;
|
|
case "count":
|
|
case "num":
|
|
case "c":
|
|
if (punishment.count) {
|
|
return this.errorReply(`Duplicate count values.`);
|
|
}
|
|
const num = parseInt(value);
|
|
if (isNaN(num)) {
|
|
return this.errorReply(`Invalid count '${value}'. Must be a number.`);
|
|
}
|
|
punishment.count = num;
|
|
break;
|
|
case "type":
|
|
case "t":
|
|
if (punishment.type) {
|
|
return this.errorReply(`Duplicate type values.`);
|
|
}
|
|
value = value.replace(/\s/g, "_").toUpperCase();
|
|
if (!Artemis.RemoteClassifier.ATTRIBUTES[value]) {
|
|
return this.errorReply(
|
|
`Invalid attribute: ${value}. Valid attributes: ${Object.keys(Artemis.RemoteClassifier.ATTRIBUTES).join(", ")}.`
|
|
);
|
|
}
|
|
punishment.type = value;
|
|
break;
|
|
case "certainty":
|
|
case "ct":
|
|
if (punishment.certainty) {
|
|
return this.errorReply(`Duplicate certainty values.`);
|
|
}
|
|
const certainty = parseFloat(value);
|
|
if (isNaN(certainty) || certainty > 1 || certainty < 0) {
|
|
return this.errorReply(`Invalid certainty '${value}'. Must be a number above 0 and below 1.`);
|
|
}
|
|
punishment.certainty = certainty;
|
|
break;
|
|
case "mla":
|
|
case "modlogaction":
|
|
value = value.toUpperCase();
|
|
if (!punishment.modlogActions) {
|
|
punishment.modlogActions = [];
|
|
}
|
|
if (punishment.modlogActions.includes(value)) {
|
|
return this.errorReply(`Duplicate modlog action values - '${value}'.`);
|
|
}
|
|
punishment.modlogActions.push(value);
|
|
break;
|
|
case "mlc":
|
|
case "modlogcount":
|
|
if (punishment.modlogCount) {
|
|
return this.errorReply(`Duplicate modlog count values.`);
|
|
}
|
|
const count = parseInt(value);
|
|
if (isNaN(count)) {
|
|
return this.errorReply(`Invalid modlog count.`);
|
|
}
|
|
punishment.modlogCount = count;
|
|
break;
|
|
case "st":
|
|
case "s":
|
|
case "secondary":
|
|
let [sType, sValue] = import_lib.Utils.splitFirst(value, "|").map((f) => f.trim());
|
|
if (!sType || !sValue) {
|
|
return this.errorReply(`Invalid secondary type/certainty.`);
|
|
}
|
|
sType = sType.replace(/\s/g, "_").toUpperCase();
|
|
if (!Artemis.RemoteClassifier.ATTRIBUTES[sType]) {
|
|
return this.errorReply(
|
|
`Invalid secondary attribute: ${sType}. Valid attributes: ${Object.keys(Artemis.RemoteClassifier.ATTRIBUTES).join(", ")}.`
|
|
);
|
|
}
|
|
const sCertainty = parseFloat(sValue);
|
|
if (isNaN(sCertainty) || sCertainty > 1 || sCertainty < 0) {
|
|
return this.errorReply(`Invalid secondary certainty '${sValue}'. Must be a number above 0 and below 1.`);
|
|
}
|
|
if (!punishment.secondaryTypes) {
|
|
punishment.secondaryTypes = {};
|
|
}
|
|
if (punishment.secondaryTypes[sType]) {
|
|
return this.errorReply(`Duplicate secondary type.`);
|
|
}
|
|
punishment.secondaryTypes[sType] = sCertainty;
|
|
break;
|
|
case "requirepunishment":
|
|
case "rp":
|
|
punishment.requiresPunishment = true;
|
|
break;
|
|
default:
|
|
this.errorReply(`Invalid key: ${key}`);
|
|
return this.parse(`/help am`);
|
|
}
|
|
}
|
|
if (!punishment.punishment) {
|
|
return this.errorReply(`A punishment type must be specified.`);
|
|
}
|
|
for (const [i, p] of settings.punishments.entries()) {
|
|
let matches = 0;
|
|
for (const k in p) {
|
|
const key = k;
|
|
const val = visualizePunishmentKey(punishment, key);
|
|
if (val && val === visualizePunishmentKey(p, key))
|
|
matches++;
|
|
}
|
|
if (matches === Object.keys(p).length) {
|
|
return this.errorReply(`This punishment is already stored at ${i + 1}.`);
|
|
}
|
|
}
|
|
settings.punishments.push(punishment);
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} added a ${punishment.punishment} abuse-monitor punishment.`);
|
|
const str = visualizePunishment(punishment);
|
|
this.stafflog(`Info: ${str}`);
|
|
this.globalModlog(`ABUSEMONITOR ADDPUNISHMENT`, null, str);
|
|
},
|
|
dp: "deletepunishment",
|
|
deletepunishment(target, room, user) {
|
|
checkAccess(this);
|
|
const idx = parseInt(target) - 1;
|
|
if (isNaN(idx))
|
|
return this.errorReply(`Invalid number.`);
|
|
const punishment = settings.punishments[idx];
|
|
if (!punishment) {
|
|
return this.errorReply(`No punishments exist at index ${idx + 1}.`);
|
|
}
|
|
settings.punishments.splice(idx, 1);
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} removed the abuse-monitor punishment indexed at ${idx + 1}.`);
|
|
this.stafflog(
|
|
`Punishment: ${Object.keys(punishment).map((f) => `${f}: ${punishment[f]}`).join(", ")}`
|
|
);
|
|
this.globalModlog(`ABUSEMONITOR REMOVEPUNISHMENT`, null, `${idx + 1}`);
|
|
},
|
|
vs: "viewsettings",
|
|
settings: "viewsettings",
|
|
viewsettings() {
|
|
checkAccess(this);
|
|
return this.parse(`/join view-abusemonitor-settings`);
|
|
},
|
|
ti: "thresholdincrement",
|
|
thresholdincrement(target, room, user) {
|
|
checkAccess(this);
|
|
if (!(0, import_dex_data.toID)(target)) {
|
|
return this.parse(`/help am`);
|
|
}
|
|
const [rawTurns, rawIncrement, rawMin] = import_lib.Utils.splitFirst(target, ",", 2).map(import_dex_data.toID);
|
|
const turns = parseInt(rawTurns);
|
|
if (isNaN(turns) || turns < 0) {
|
|
return this.errorReply(`Turns must be a number above 0.`);
|
|
}
|
|
const increment = parseInt(rawIncrement);
|
|
if (isNaN(increment) || increment < 0) {
|
|
return this.errorReply(`The increment must be a number above 0.`);
|
|
}
|
|
const min = parseInt(rawMin);
|
|
if (rawMin && isNaN(min)) {
|
|
return this.errorReply(`Invalid minimum (must be a number).`);
|
|
}
|
|
settings.thresholdIncrement = { amount: increment, turns };
|
|
if (min) {
|
|
settings.thresholdIncrement.minTurns = min;
|
|
}
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(
|
|
`${user.name} set the abuse-monitor threshold increment ${increment} every ${Chat.count(turns, "turns")}${min ? ` after ${Chat.count(min, "turns")}` : ""}`
|
|
);
|
|
this.globalModlog(
|
|
`ABUSEMONITOR INCREMENT`,
|
|
null,
|
|
`${increment} every ${turns} turn(s)${min ? ` after ${min} turn(s)` : ""}`
|
|
);
|
|
},
|
|
di: "deleteincrement",
|
|
deleteincrement(target, room, user) {
|
|
checkAccess(this);
|
|
if (!settings.thresholdIncrement)
|
|
return this.errorReply(`The threshold increment is already disabled.`);
|
|
settings.thresholdIncrement = null;
|
|
saveSettings();
|
|
this.refreshPage("abusemonitor-settings");
|
|
this.privateGlobalModAction(`${user.name} disabled the abuse-monitor threshold increment.`);
|
|
this.globalModlog(`ABUSEMONITOR DISABLEINCREMENT`);
|
|
},
|
|
async failures(target) {
|
|
checkAccess(this);
|
|
if (!(0, import_dex_data.toID)(target)) {
|
|
target = Chat.toTimestamp(new Date()).split(" ")[0];
|
|
}
|
|
const timeNum = new Date(target).getTime();
|
|
if (isNaN(timeNum)) {
|
|
return this.errorReply(`Invalid date.`);
|
|
}
|
|
let logs = await Chat.database.all(
|
|
"SELECT * FROM perspective_stats WHERE result = 0 AND timestamp > ? AND timestamp < ?",
|
|
[timeNum, timeNum + 24 * 60 * 60 * 1e3]
|
|
);
|
|
logs = logs.filter((log) => // proofing against node's stupid date lib
|
|
Chat.toTimestamp(new Date(log.timestamp)).split(" ")[0] === target);
|
|
if (!logs.length) {
|
|
return this.errorReply(`No logs found for that date.`);
|
|
}
|
|
this.sendReplyBox(
|
|
`<strong>${Chat.count(logs, "logs")}</strong> found on the date ${target}:<hr />` + logs.map((f) => `<a href="/${f.roomid}">${f.roomid}</a>`).join("<br />")
|
|
);
|
|
},
|
|
bs: "backupsettings",
|
|
async backupsettings(target, room, user) {
|
|
checkAccess(this);
|
|
target = target.replace(/\//g, "-").toLowerCase().trim();
|
|
let dotIdx = target.lastIndexOf(".");
|
|
if (dotIdx < 0) {
|
|
dotIdx = target.length;
|
|
}
|
|
target = target.toLowerCase().slice(0, dotIdx);
|
|
if (target) {
|
|
target = `/artemis/${target}`;
|
|
await (0, import_lib.FS)(`config/chat-plugins/artemis/`).mkdirIfNonexistent();
|
|
} else {
|
|
target = `/nf.backup`;
|
|
}
|
|
saveSettings(target);
|
|
this.addGlobalModAction(`${user.name} used /abusemonitor backupsettings`);
|
|
this.stafflog(`Logged to ${target || "default location"}`);
|
|
if (target) {
|
|
this.globalModlog(`ABUSEMONITOR BACKUP`, null, target);
|
|
}
|
|
this.refreshPage("abusemonitor-settings");
|
|
},
|
|
lb: "loadbackup",
|
|
async loadbackup(target, room, user) {
|
|
checkAccess(this);
|
|
let path = `nf.backup`;
|
|
if (target) {
|
|
path = `artemis/${target.toLowerCase().replace(/\//g, "-")}`;
|
|
}
|
|
const backup = await (0, import_lib.FS)(`config/chat-plugins/${path}.json`).readIfExists();
|
|
if (!backup)
|
|
return this.errorReply(`No backup settings saved.`);
|
|
const backupSettings = JSON.parse(backup);
|
|
Object.assign(settings, backupSettings);
|
|
saveSettings();
|
|
this.addGlobalModAction(`${user.name} used /abusemonitor loadbackup`);
|
|
this.stafflog(`Loaded ${path}`);
|
|
this.refreshPage("abusemonitor-settings");
|
|
},
|
|
async deletebackup(target, room, user) {
|
|
checkAccess(this);
|
|
target = target.toLowerCase().replace(/\//g, "-");
|
|
if (!target)
|
|
return this.errorReply(`Specify a backup file.`);
|
|
const path = (0, import_lib.FS)(`config/chat-plugins/artemis/${target}.json`);
|
|
if (!await path.exists()) {
|
|
return this.errorReply(`Backup '${target}' not found.`);
|
|
}
|
|
await path.unlinkIfExists();
|
|
this.globalModlog(`ABUSEMONITOR DELETEBACKUP`, null, target);
|
|
this.sendReply(`Backup '${target}' deleted.`);
|
|
this.privateGlobalModAction(`${user.name} deleted the abuse-monitor backup '${target}'`);
|
|
},
|
|
async backups() {
|
|
checkAccess(this);
|
|
let buf = `<strong>Artemis backups:</strong><br />`;
|
|
const files = await (0, import_lib.FS)(`config/chat-plugins/artemis`).readdirIfExists();
|
|
if (!files.length) {
|
|
buf += `No backups found.`;
|
|
} else {
|
|
buf += files.map((f) => {
|
|
const fName = f.slice(0, f.lastIndexOf("."));
|
|
let line = `• ${fName} `;
|
|
line += `<button name="send" value="/abusemonitor deletebackup ${fName}">Delete</button> `;
|
|
line += `<button name="send" value="/abusemonitor loadbackup ${fName}">Load</button>`;
|
|
return line;
|
|
}).join("<br />");
|
|
}
|
|
this.sendReplyBox(buf);
|
|
},
|
|
togglepunishments(target, room, user) {
|
|
checkAccess(this);
|
|
let message;
|
|
if (this.meansYes(target)) {
|
|
if (!settings.recommendOnly) {
|
|
return this.errorReply(`Automatic punishments are already enabled.`);
|
|
}
|
|
settings.recommendOnly = false;
|
|
message = `${user.name} enabled automatic punishments for the Artemis battle monitor`;
|
|
} else if (this.meansNo(target)) {
|
|
if (settings.recommendOnly) {
|
|
return this.errorReply(`Automatic punishments are already disabled.`);
|
|
}
|
|
settings.recommendOnly = true;
|
|
message = `${user.name} disabled automatic punishments for the Artemis battle monitor`;
|
|
} else {
|
|
return this.sendReply(`Automatic punishments are: ${!settings.recommendOnly ? "ON" : "OFF"}.`);
|
|
}
|
|
this.privateGlobalModAction(message);
|
|
this.globalModlog(`ABUSEMONITOR TOGGLE`, null, settings.recommendOnly ? "off" : "on");
|
|
saveSettings();
|
|
},
|
|
review() {
|
|
this.checkCan("lock");
|
|
return this.parse(`/join view-abusemonitor-review`);
|
|
},
|
|
reviews() {
|
|
checkAccess(this);
|
|
return this.parse(`/join view-abusemonitor-reviews`);
|
|
},
|
|
async submitreview(target, room, user) {
|
|
var _a;
|
|
this.checkCan("lock");
|
|
if (!target)
|
|
return this.parse(`/help abusemonitor submitreview`);
|
|
const [roomid, reason] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim());
|
|
const log = await (0, import_helptickets.getBattleLog)((0, import_helptickets.getBattleLinks)(roomid)[0] || "");
|
|
if (!log) {
|
|
return this.popupReply(`No logs found for that roomid.`);
|
|
}
|
|
if (reviews[user.id]?.some((f) => f.room === roomid)) {
|
|
return this.popupReply(`You have already submitted a review for this room.`);
|
|
}
|
|
if (reason.length < 1 || reason.length > 2e3) {
|
|
return this.popupReply(`Your review must be between 1 and 2000 characters.`);
|
|
}
|
|
(reviews[_a = user.id] || (reviews[_a] = [])).push({
|
|
room: roomid,
|
|
details: reason,
|
|
staff: user.id,
|
|
time: Date.now()
|
|
});
|
|
saveReviews();
|
|
Chat.refreshPageFor("abusemonitor-reviews", "staff");
|
|
this.closePage("abusemonitor-review");
|
|
this.popupReply(`Your review has been submitted.`);
|
|
},
|
|
resolvereview(target, room, user) {
|
|
checkAccess(this);
|
|
let [userid, roomid, accurate, result] = import_lib.Utils.splitFirst(target, ",", 3).map((f) => f.trim());
|
|
userid = (0, import_dex_data.toID)(userid);
|
|
roomid = (0, import_helptickets.getBattleLinks)(roomid)[0] || "";
|
|
if (!userid || !roomid || !accurate || !result) {
|
|
return this.parse(`/help abusemonitor resolvereview`);
|
|
}
|
|
if (!reviews[userid]) {
|
|
return this.errorReply(`No reviews found by that user.`);
|
|
}
|
|
const review = reviews[userid].find((f) => (0, import_helptickets.getBattleLinks)(f.room).includes(roomid));
|
|
if (!review) {
|
|
return this.errorReply(`No reviews found by that user for that room.`);
|
|
}
|
|
const isAccurate = Number(accurate);
|
|
if (isNaN(isAccurate) || isAccurate < 0 || isAccurate > 1) {
|
|
return this.popupReply(`Invalid accuracy. Must be a number between 0 and 1.`);
|
|
}
|
|
if (review.resolved) {
|
|
return this.errorReply(`That review has already been resolved.`);
|
|
}
|
|
review.resolved = {
|
|
by: user.id,
|
|
time: Date.now(),
|
|
details: result,
|
|
result: isAccurate
|
|
};
|
|
displayResolved(review, true);
|
|
writeStats("reviews", review);
|
|
Chat.refreshPageFor("abusemonitor-reviews", "staff");
|
|
},
|
|
replace(target, room, user) {
|
|
checkAccess(this);
|
|
if (!target)
|
|
return this.parse(`/help am`);
|
|
const [old, newWord] = target.split(",");
|
|
if (!old || !newWord)
|
|
return this.errorReply(`Invalid arguments - must be [oldWord], [newWord].`);
|
|
if ((0, import_dex_data.toID)(old) === (0, import_dex_data.toID)(newWord))
|
|
return this.errorReply(`The old word and the new word are the same.`);
|
|
if (settings.replacements[old]) {
|
|
return this.errorReply(`The old word '${old}' is already in use (for '${settings.replacements[old]}').`);
|
|
}
|
|
Chat.validateRegex(target);
|
|
settings.replacements[old] = newWord;
|
|
saveSettings();
|
|
this.privateGlobalModAction(`${user.name} added an Artemis replacement for '${old}' to '${newWord}'.`);
|
|
this.globalModlog(`ABUSEMONITOR REPLACE`, null, `'${old}' to '${newWord}'`);
|
|
this.refreshPage("abusemonitor-settings");
|
|
},
|
|
removereplace(target, room, user) {
|
|
checkAccess(this);
|
|
if (!target)
|
|
return this.parse(`/help am`);
|
|
const replaceTo = settings.replacements[target];
|
|
if (!replaceTo) {
|
|
return this.errorReply(`${target} is not a currently set replacement.`);
|
|
}
|
|
delete settings.replacements[target];
|
|
saveSettings();
|
|
this.privateGlobalModAction(`${user.name} removed the Artemis replacement for ${target}`);
|
|
this.globalModlog(`ABUSEMONITOR REMOVEREPLACEMENT`, null, `${target} (=> ${replaceTo})`);
|
|
this.refreshPage("abusemonitor-settings");
|
|
},
|
|
edithistory(target, room, user) {
|
|
this.checkCan("globalban");
|
|
target = (0, import_dex_data.toID)(target);
|
|
if (!target) {
|
|
return this.parse(`/help abusemonitor`);
|
|
}
|
|
return this.parse(`/j view-abusemonitor-edithistory-${target}`);
|
|
},
|
|
ignoremodlog: {
|
|
add(target, room, user) {
|
|
this.checkCan("globalban");
|
|
let targetUser;
|
|
[targetUser, target] = this.splitOne(target).map((f) => f.trim());
|
|
targetUser = (0, import_dex_data.toID)(targetUser);
|
|
if (!targetUser || !target) {
|
|
return this.popupReply(
|
|
`Must specify a user and a target date (or modlog entry number).`
|
|
);
|
|
}
|
|
if (!metadata.modlogIgnores)
|
|
metadata.modlogIgnores = {};
|
|
const num = Number(target);
|
|
if (isNaN(num)) {
|
|
if (!/[0-9]{4}-[0-9]{2}-[0-9]{2}/.test(target)) {
|
|
return this.errorReply(`Invalid date provided. Must be in YYYY-MM-DD format.`);
|
|
}
|
|
metadata.modlogIgnores[targetUser] = target;
|
|
target = "before and including " + target;
|
|
} else {
|
|
let ignores = metadata.modlogIgnores[targetUser];
|
|
if (!Array.isArray(ignores)) {
|
|
metadata.modlogIgnores[targetUser] = ignores = [];
|
|
}
|
|
if (ignores.includes(num)) {
|
|
return this.errorReply(`That modlog entry is already ignored.`);
|
|
}
|
|
ignores.push(num);
|
|
target = `entry #${target}`;
|
|
}
|
|
this.globalModlog(`ABUSEMONITOR MODLOGIGNORE`, targetUser, target);
|
|
saveMetadata();
|
|
this.refreshPage(`abusemonitor-edithistory-${targetUser}`);
|
|
},
|
|
remove(target, room, user) {
|
|
this.checkCan("globalban");
|
|
let [targetUser, rawNum] = this.splitOne(target).map((f) => f.trim());
|
|
targetUser = (0, import_dex_data.toID)(targetUser);
|
|
const num = Number(rawNum);
|
|
if (!targetUser || !rawNum) {
|
|
return this.popupReply(
|
|
`Specify a target user and a target (either a modlog entry # or a date).`
|
|
);
|
|
}
|
|
const entry = metadata.modlogIgnores?.[targetUser];
|
|
if (!entry) {
|
|
return this.errorReply(`That user has no ignored modlog entries registered.`);
|
|
}
|
|
if (typeof entry === "string") {
|
|
rawNum = entry;
|
|
delete metadata.modlogIgnores[targetUser];
|
|
} else {
|
|
if (isNaN(num)) {
|
|
return this.errorReply(`Invalid modlog entry number: ${num}`);
|
|
}
|
|
const idx = entry.indexOf(num);
|
|
if (idx === -1) {
|
|
return this.errorReply(`That modlog entry is not ignored for the user ${targetUser}.`);
|
|
}
|
|
entry.splice(idx, 1);
|
|
if (!entry.length) {
|
|
delete metadata.modlogIgnores[targetUser];
|
|
}
|
|
}
|
|
saveMetadata();
|
|
this.globalModlog(`ABUSEMONITOR REMOVEMODLOGIGNORE`, targetUser, rawNum);
|
|
this.refreshPage(`abusemonitor-edithistory-${targetUser}`);
|
|
}
|
|
}
|
|
},
|
|
abusemonitorhelp() {
|
|
return this.sendReplyBox([
|
|
`<strong>Staff commands:</strong>`,
|
|
`/am userlogs [user] - View the Artemis flagged message logs for the given [user]. Requires: % @ &`,
|
|
`/am unmute [user] - Remove the Artemis mute from the given [user]. Requires: % @ &`,
|
|
`/am review - Submit feedback for manual abuse monitor review. Requires: % @ &`,
|
|
`</details><br /><details class="readmore"><summary><strong>Management commands:</strong></summary>`,
|
|
`/am toggle - Toggle the abuse monitor on and off. Requires: whitelist &`,
|
|
`/am threshold [number] - Set the abuse monitor trigger threshold. Requires: whitelist &`,
|
|
`/am resolve [room] - Mark a abuse monitor flagged room as handled by staff. Requires: % @ &`,
|
|
`/am respawn - Respawns abuse monitor processes. Requires: whitelist &`,
|
|
`/am logs [count][, userid] - View logs of recent matches by the abuse monitor. `,
|
|
`If a userid is given, searches only logs from that userid. Requires: whitelist &`,
|
|
`/am userclear [user] - Clear all logged abuse monitor hits for a user. Requires: whitelist &`,
|
|
`/am deletelog [number] - Deletes a abuse monitor log matching the row ID [number] given. Requires: whitelist &`,
|
|
`/am editspecial [type], [percent], [score] - Sets a special case for the abuse monitor. Requires: whitelist &`,
|
|
`[score] can be either a number or MAXIMUM, which will set it to the maximum score possible (that will trigger an action)`,
|
|
`/am deletespecial [type], [percent] - Deletes a special case for the abuse monitor. Requires: whitelist &`,
|
|
`/am editmin [number] - Sets the minimum percent needed to process for all flags. Requires: whitelist &`,
|
|
`/am viewsettings - View the current settings for the abuse monitor. Requires: whitelist &`,
|
|
`/am thresholdincrement [num], [amount][, min turns] - Sets the threshold increment for the abuse monitor to increase [amount] every [num] turns.`,
|
|
`If [min turns] is provided, increments will start after that turn number. Requires: whitelist &`,
|
|
`/am deleteincrement - clear abuse-monitor threshold increment. Requires: whitelist &`,
|
|
`</details>`
|
|
].join("<br />"));
|
|
}
|
|
};
|
|
const pages = {
|
|
abusemonitor: {
|
|
flagged(query, user) {
|
|
checkAccess(this, "lock");
|
|
const ids = getFlaggedRooms();
|
|
this.title = "[Abuse Monitor] Flagged rooms";
|
|
let buf = `<div class="pad">`;
|
|
buf += `<h2>Flagged rooms</h2>`;
|
|
if (!ids.length) {
|
|
buf += `<p class="error">No rooms have been flagged recently.</p>`;
|
|
return buf;
|
|
}
|
|
buf += `<p>Currently flagged rooms: ${ids.length}</p>`;
|
|
buf += `<div class="ladder pad">`;
|
|
buf += `<table><tr><th>Status</th><th>Room</th><th>Claimed by</th><th>Action</th></tr>`;
|
|
for (const roomid of ids) {
|
|
const entry = cache[roomid];
|
|
buf += `<tr>`;
|
|
if (entry.claimed) {
|
|
buf += `<td><span style="color:green">`;
|
|
buf += `<i class="fa fa-circle-o"></i> <strong>Claimed</strong></span></td>`;
|
|
} else {
|
|
buf += `<td><span style="color:orange">`;
|
|
buf += `<i class="fa fa-circle-o"></i> <strong>Unclaimed</strong></span></td>`;
|
|
}
|
|
buf += import_lib.Utils.html`<td>${Rooms.get(roomid)?.title || roomid}</td>`;
|
|
buf += `<td>${entry.claimed ? entry.claimed : "-"}</td>`;
|
|
buf += `<td><button class="button" name="send" value="/am view ${roomid}">`;
|
|
buf += `${entry.claimed ? "Show" : "Claim"}</button></td>`;
|
|
buf += `</tr>`;
|
|
}
|
|
buf += `</table></div>`;
|
|
return buf;
|
|
},
|
|
async view(query, user) {
|
|
checkAccess(this, "lock");
|
|
const roomid = query.join("-");
|
|
if (!(0, import_dex_data.toID)(roomid)) {
|
|
return this.errorReply(`You must specify a roomid to view abuse monitor data for.`);
|
|
}
|
|
let buf = `<div class="pad">`;
|
|
buf += `<button style="float:right;" class="button" name="send" value="/join ${this.pageid}">`;
|
|
buf += `<i class="fa fa-refresh"></i> Refresh</button>`;
|
|
buf += `<h2>Abuse Monitor`;
|
|
const room = Rooms.get(roomid);
|
|
if (!room) {
|
|
if (cache[roomid]) {
|
|
delete cache[roomid];
|
|
notifyStaff();
|
|
}
|
|
buf += `</h2><hr /><p class="error">No such room.</p>`;
|
|
return buf;
|
|
}
|
|
room.pokeExpireTimer();
|
|
if (!cache[roomid]) {
|
|
buf += `</h2><hr /><p class="error">The abuse monitor has not flagged the given room.</p>`;
|
|
return buf;
|
|
}
|
|
const titleParts = room.roomid.split("-");
|
|
if (titleParts[titleParts.length - 1].endsWith("pw")) {
|
|
titleParts.pop();
|
|
}
|
|
buf += import_lib.Utils.html` - ${room.title}</h2>`;
|
|
this.title = `[Abuse Monitor] ${titleParts.join("-")}`;
|
|
buf += `<p>${Chat.formatText(`<<${room.roomid}>>`)}</p>`;
|
|
buf += `<hr />`;
|
|
if (!cache[roomid].claimed) {
|
|
cache[roomid].claimed = user.id;
|
|
notifyStaff();
|
|
} else {
|
|
buf += `<p><strong>Claimed:</strong> ${cache[roomid].claimed}</p>`;
|
|
}
|
|
buf += `<details class="readmore"><summary><strong>Chat:</strong></summary><div class="infobox">`;
|
|
const users = new import_lib.Utils.Multiset();
|
|
const logData = await (0, import_helptickets.getBattleLog)(room.roomid, true);
|
|
if (!logData)
|
|
return `<div class="pad"><p class="error">No such room.</p></div>`;
|
|
for (const line of logData.log) {
|
|
const data = room.log.parseChatLine(line);
|
|
if (!data)
|
|
continue;
|
|
if (["/log", "/raw"].some((prefix) => data.message.startsWith(prefix))) {
|
|
continue;
|
|
}
|
|
const id = (0, import_dex_data.toID)(data.user);
|
|
if (!id)
|
|
continue;
|
|
users.add(id);
|
|
buf += `<div class="chat chatmessage">`;
|
|
buf += `<strong style="color: ${import_helptickets.HelpTicket.colorName(id, logData)}">`;
|
|
buf += import_lib.Utils.html`<span class="username">${data.user}:</span></strong> ${data.message}</div>`;
|
|
}
|
|
buf += `</div></details>`;
|
|
const recs = cache[roomid].recommended || {};
|
|
if (Object.keys(recs).length) {
|
|
for (const id in recs) {
|
|
const rec = recs[id];
|
|
buf += `<p><strong>Recommended action for ${id}:</strong> ${rec.type} (${rec.reason})</p>`;
|
|
}
|
|
}
|
|
buf += `<p><strong>Users:</strong><small> (click a name to punish)</small></p>`;
|
|
const sortedUsers = import_lib.Utils.sortBy([...users], ([id, num]) => [isFlaggedUserid(id, roomid), -num, id]);
|
|
for (const [id] of sortedUsers) {
|
|
const curUser = Users.getExact(id);
|
|
buf += import_lib.Utils.html`<details class="readmore"><summary>${curUser?.name || id} `;
|
|
buf += `<button class="button" name="send" value="/mlid ${id},room=global">Modlog</button>`;
|
|
buf += `</summary><div class="infobox">`;
|
|
const punishments = ["Warn", "Lock", "Weeklock", "Forcerename", "Namelock", "Weeknamelock"];
|
|
for (const name of punishments) {
|
|
buf += `<form data-submitsend="/am nojoinpunish ${roomid},${(0, import_dex_data.toID)(name)},${id},{reason}">`;
|
|
buf += `<button class="button notifying" type="submit">${name}</button><br />`;
|
|
buf += `Optional reason: <input name="reason" />`;
|
|
buf += `</form><br />`;
|
|
}
|
|
buf += `</div></details><br />`;
|
|
}
|
|
buf += `<hr /><strong>Mark resolved:</strong><br />`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff, /am resolve ${room.roomid},success">As accurate flag</button> | `;
|
|
buf += `<button class="button" name="send" value="/msgroom staff, /am resolve ${room.roomid},failure">As inaccurate flag</button>`;
|
|
return buf;
|
|
},
|
|
async userlogs(query, user) {
|
|
this.checkCan("lock");
|
|
let buf = `<div class="pad"><h2>Artemis user logs</h2><hr />`;
|
|
const userid = (0, import_dex_data.toID)(query.shift());
|
|
if (!userid || userid.length > 18) {
|
|
buf += `<p class="message-error">Invalid username.</p>`;
|
|
return buf;
|
|
}
|
|
this.title = `[Artemis Logs] ${userid}`;
|
|
const logs = await Chat.database.all(`SELECT * FROM perspective_logs WHERE userid = ? LIMIT 100`, [userid]);
|
|
if (!logs.length) {
|
|
buf += `<p class="message-error">No logs found.</p>`;
|
|
return buf;
|
|
}
|
|
buf += `<div class="ladder pad"><table><tr><th>Date</th><th>Room</th><th>User</th><th>Message</th></tr>`;
|
|
import_lib.Utils.sortBy(logs, (log) => -log.time);
|
|
for (const log of logs) {
|
|
buf += `<tr><td>${Chat.toTimestamp(new Date(log.time), { human: true })}</td>`;
|
|
buf += `<td><a href="/${log.roomid}">${log.roomid}</a></td>`;
|
|
buf += import_lib.Utils.html`<td>${log.userid}</td><td>${log.message}</td></tr>`;
|
|
}
|
|
return buf;
|
|
},
|
|
async logs(query, user) {
|
|
checkAccess(this);
|
|
this.title = "[Abuse Monitor] Logs";
|
|
let buf = `<div class="pad">`;
|
|
buf += `<h2>Abuse Monitor Logs</h2><hr />`;
|
|
const rawCount = query.shift() || "";
|
|
let count = 200;
|
|
if (rawCount) {
|
|
count = parseInt(rawCount);
|
|
if (isNaN(count)) {
|
|
buf += `<p class="message-error">Invalid limit specified: ${rawCount}</p>`;
|
|
return buf;
|
|
}
|
|
}
|
|
const userid = (0, import_dex_data.toID)(query.shift());
|
|
let logQuery = `SELECT rowid, * FROM perspective_logs `;
|
|
const args = [];
|
|
if (userid) {
|
|
logQuery += `WHERE userid = ? `;
|
|
args.push(userid);
|
|
}
|
|
logQuery += `ORDER BY rowid DESC LIMIT ?`;
|
|
args.push(count);
|
|
const logs = await Chat.database.all(logQuery, args);
|
|
if (!logs.length) {
|
|
buf += `<p class="message-error">No logs found${userid ? ` for the user ${userid}` : ""}.</p>`;
|
|
return buf;
|
|
}
|
|
import_lib.Utils.sortBy(logs, (log) => [-log.time, log.roomid, log.userid]);
|
|
buf += `<p>${logs.length} log(s) found.</p>`;
|
|
buf += `<div class="ladder pad">`;
|
|
buf += `<table><tr><th>Room</th>`;
|
|
if (!userid) {
|
|
buf += `<th>User</th>`;
|
|
}
|
|
buf += `<th>Message</th>`;
|
|
buf += `<th>Time</th><th>Score / Flags</th><th>Other data</th><th>Manage</th></tr>`;
|
|
const prettifyFlag = (flag) => flag.toLowerCase().replace(/_/g, " ");
|
|
for (const log of logs) {
|
|
const { roomid } = log;
|
|
buf += `<tr>`;
|
|
buf += `<td><a href="https://${import_config_loader.Config.routes.replays}/${roomid.slice(7)}">${roomid}</a></td>`;
|
|
if (!userid)
|
|
buf += `<td>${log.userid}</td>`;
|
|
buf += import_lib.Utils.html`<td>${log.message}</td>`;
|
|
buf += `<td>${Chat.toTimestamp(new Date(log.time))}</td>`;
|
|
buf += `<td>${log.score} (${log.flags.split(",").map(prettifyFlag).join(", ")})</td>`;
|
|
buf += `<td>Hit threshold: ${log.hit_threshold ? "Yes" : "No"}</td><td>`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff,/abusemonitor deletelog ${log.rowid}">Delete</button>`;
|
|
buf += `</td>`;
|
|
buf += `</tr>`;
|
|
}
|
|
buf += `</table></div>`;
|
|
if (count === logs.length) {
|
|
buf += `<center>`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff, /am logs ${count + 100}">Show 100 more</button>`;
|
|
buf += `</center>`;
|
|
}
|
|
return buf;
|
|
},
|
|
async stats(query, user) {
|
|
checkAccess(this);
|
|
const dateString = (query.join("-") || Chat.toTimestamp(new Date())).slice(0, 7);
|
|
if (!/^[0-9]{4}-[0-9]{2}$/.test(dateString)) {
|
|
return this.errorReply(`Invalid date: ${dateString}`);
|
|
}
|
|
let buf = `<div class="pad">`;
|
|
buf += `<button style="float:right;" class="button" name="send" value="/join ${this.pageid}">`;
|
|
buf += `<i class="fa fa-refresh"></i> Refresh</button>`;
|
|
buf += `<h2>Abuse Monitor stats for ${dateString}</h2>`;
|
|
const next = nextMonth(dateString);
|
|
const prev = new Date(new Date(`${dateString}-15`).getTime() - 30 * 24 * 60 * 60 * 1e3).toISOString().slice(0, 7);
|
|
buf += `<a class="button" target="replace" href="/view-abusemonitor-stats-${prev}-15">Previous month</a> | `;
|
|
buf += `<a class="button" target="replace" href="/view-abusemonitor-stats-${next}-15">Next month</a>`;
|
|
buf += `<hr />`;
|
|
const logs = await Chat.database.all(
|
|
`SELECT * FROM perspective_stats WHERE timestamp > ? AND timestamp < ?`,
|
|
[new Date(dateString + "-01").getTime(), new Date(nextMonth(dateString)).getTime()]
|
|
);
|
|
this.title = "[Abuse Monitor] Stats";
|
|
if (!logs.length) {
|
|
buf += `<p class="message-error">No logs found for the month ${dateString}.</p>`;
|
|
return buf;
|
|
}
|
|
this.title += ` ${dateString}`;
|
|
buf += `<p>${Chat.count(logs.length, "logs")} found.</p>`;
|
|
let successes = 0;
|
|
let failures = 0;
|
|
let dead = 0;
|
|
const staffStats = {};
|
|
const dayStats = {};
|
|
for (const log of logs) {
|
|
const cur = Chat.toTimestamp(new Date(log.timestamp)).split(" ")[0];
|
|
if (!dayStats[cur])
|
|
dayStats[cur] = { successes: 0, failures: 0, dead: 0, total: 0 };
|
|
if (log.result === 2) {
|
|
dead++;
|
|
dayStats[cur].dead++;
|
|
continue;
|
|
} else if (log.result === 1) {
|
|
successes++;
|
|
dayStats[cur].successes++;
|
|
} else {
|
|
failures++;
|
|
dayStats[cur].failures++;
|
|
}
|
|
if (!staffStats[log.staff])
|
|
staffStats[log.staff] = 0;
|
|
staffStats[log.staff]++;
|
|
dayStats[cur].total++;
|
|
}
|
|
const percent = (numerator, denom) => Math.floor(numerator / denom * 100) || 0;
|
|
buf += `<p><strong>Success rate:</strong> ${percent(successes, successes + failures)}% (${successes})</p>`;
|
|
buf += `<p><strong>Failure rate:</strong> ${percent(failures, successes + failures)}% (${failures})</p>`;
|
|
buf += `<p><details class="readmore"><summary><strong>Stats including dead flags</strong></summary>`;
|
|
buf += `<p><strong>Total dead: ${dead}</strong></p>`;
|
|
buf += `<p><strong>Success rate:</strong> ${percent(successes, logs.length)}% (${successes})</p>`;
|
|
buf += `<p><strong>Failure rate:</strong> ${percent(failures, logs.length)}% (${failures})</p>`;
|
|
buf += `</summary></details></p>`;
|
|
buf += `<p><strong>Day stats:</strong></p>`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
let header = "";
|
|
let data = "";
|
|
const sortedDays = import_lib.Utils.sortBy(Object.keys(dayStats), (d) => new Date(d).getTime());
|
|
for (const [i, day] of sortedDays.entries()) {
|
|
const cur = dayStats[day];
|
|
if (!cur.total)
|
|
continue;
|
|
header += `<th>${day.split("-")[2]} (${cur.total})</th>`;
|
|
data += `<td><small>${cur.successes} (${percent(cur.successes, cur.total)}%)`;
|
|
if (cur.failures) {
|
|
data += ` | ${cur.failures} (${percent(cur.failures, cur.total)}%)`;
|
|
} else {
|
|
data += " | 0 (0%)";
|
|
}
|
|
if (cur.dead)
|
|
data += ` | ${cur.dead}`;
|
|
data += "</small></td>";
|
|
if ((i + 1) % 5 === 0 && sortedDays[i + 1]) {
|
|
buf += `<tr>${header}</tr><tr>${data}</tr>`;
|
|
buf += `</div></table>`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
header = "";
|
|
data = "";
|
|
}
|
|
}
|
|
buf += `<tr>${header}</tr><tr>${data}</tr>`;
|
|
buf += `</div></table>`;
|
|
buf += `<hr /><p><strong>Punishment stats:</strong></p>`;
|
|
const punishmentStats = {
|
|
inaccurate: 0,
|
|
total: 0,
|
|
byDay: {},
|
|
types: {}
|
|
};
|
|
const inaccurate = /* @__PURE__ */ new Set();
|
|
const logPath = (0, import_lib.FS)(`logs/artemis/punishments/${dateString}.jsonl`);
|
|
if (await logPath.exists()) {
|
|
const stream = logPath.createReadStream();
|
|
for await (const line of stream.byLine()) {
|
|
if (!line.trim())
|
|
continue;
|
|
const chunk = JSON.parse(line.trim());
|
|
punishmentStats.total++;
|
|
if (!punishmentStats.types[chunk.punishment])
|
|
punishmentStats.types[chunk.punishment] = 0;
|
|
punishmentStats.types[chunk.punishment]++;
|
|
const day = Chat.toTimestamp(new Date(chunk.timestamp)).split(" ")[0];
|
|
if (!punishmentStats.byDay[day])
|
|
punishmentStats.byDay[day] = { total: 0, inaccurate: 0 };
|
|
punishmentStats.byDay[day].total++;
|
|
}
|
|
}
|
|
const reviewLogPath = (0, import_lib.FS)(`logs/artemis/reviews/${dateString}.jsonl`);
|
|
if (await reviewLogPath.exists()) {
|
|
const stream = reviewLogPath.createReadStream();
|
|
for await (const line of stream.byLine()) {
|
|
if (!line.trim())
|
|
continue;
|
|
const chunk = JSON.parse(line.trim());
|
|
if (!chunk.resolved.result) {
|
|
punishmentStats.inaccurate++;
|
|
inaccurate.add(chunk.room);
|
|
const day = Chat.toTimestamp(new Date(chunk.time)).split(" ")[0];
|
|
if (!punishmentStats.byDay[day])
|
|
punishmentStats.byDay[day] = { total: 0, inaccurate: 0 };
|
|
punishmentStats.byDay[day].inaccurate++;
|
|
}
|
|
}
|
|
}
|
|
buf += `<p>Total punishments: ${punishmentStats.total}</p>`;
|
|
const accurate = punishmentStats.total - punishmentStats.inaccurate;
|
|
buf += `<p>Accurate punishments: ${accurate} (${percent(accurate, punishmentStats.total)}%)</p>`;
|
|
buf += `<details class="readmore"><summary>Inaccurate punishments: ${punishmentStats.inaccurate} `;
|
|
buf += `(${percent(punishmentStats.inaccurate, punishmentStats.total)}%)</summary>`;
|
|
buf += Array.from(inaccurate).map((f) => `<a href="/${f}">${f}</a>`).join(", ");
|
|
buf += `</details>`;
|
|
if (punishmentStats.total) {
|
|
buf += `<p><strong>Day stats:</strong></p>`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
header = "";
|
|
data = "";
|
|
const sortedDayStats = import_lib.Utils.sortBy(Object.keys(punishmentStats.byDay), (d) => new Date(d).getTime());
|
|
for (const [i, day] of sortedDayStats.entries()) {
|
|
const cur = punishmentStats.byDay[day];
|
|
if (!cur.total)
|
|
continue;
|
|
header += `<th>${day.split("-")[2]} (${cur.total})</th>`;
|
|
const curAccurate = cur.total - cur.inaccurate;
|
|
data += `<td><small>${curAccurate} (${percent(curAccurate, cur.total)}%)`;
|
|
if (cur.inaccurate) {
|
|
data += ` | ${cur.inaccurate} (${percent(cur.inaccurate, cur.total)}%)`;
|
|
} else {
|
|
data += " | 0 (0%)";
|
|
}
|
|
data += "</small></td>";
|
|
if ((i + 1) % 5 === 0 && sortedDays[i + 1]) {
|
|
buf += `<tr>${header}</tr><tr>${data}</tr>`;
|
|
buf += `</div></table>`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
header = "";
|
|
data = "";
|
|
}
|
|
}
|
|
buf += `<tr>${header}</tr><tr>${data}</tr>`;
|
|
buf += `</div></table>`;
|
|
buf += `<br /><strong>Punishment breakdown:</strong><br />`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
buf += `<tr><th>Type</th><th>Count</th><th>Percent</th></tr>`;
|
|
const sorted = import_lib.Utils.sortBy(Object.entries(punishmentStats.types), (e) => e[1]);
|
|
for (const [type, num] of sorted) {
|
|
buf += `<tr><td>${type}</td><td>${num}</td><td>${percent(num, punishmentStats.total)}%</td></tr>`;
|
|
}
|
|
buf += `</table></div>`;
|
|
}
|
|
buf += `<hr /><p><strong>Staff stats:</strong></p>`;
|
|
buf += `<div class="ladder pad"><table>`;
|
|
buf += `<tr><th>User</th><th>Total</th><th>Percent total</th></tr>`;
|
|
for (const id of import_lib.Utils.sortBy(Object.keys(staffStats), (k) => -staffStats[k])) {
|
|
buf += `<tr><td>${id}</td><td>${staffStats[id]}</td><td>${staffStats[id] / logs.length * 100}%</td></tr>`;
|
|
}
|
|
buf += `</table></div>`;
|
|
return buf;
|
|
},
|
|
async settings() {
|
|
checkAccess(this);
|
|
this.title = `[Abuse Monitor] Settings`;
|
|
let buf = `<div class="pad"><h2>Abuse Monitor Settings</h2>`;
|
|
buf += `<button class="button" name="send" value="/am vs">Reload page</button>`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff,/am respawn">Reload processes</button>`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff,/am bs">Backup settings</button>`;
|
|
if (await (0, import_lib.FS)("config/chat-plugins/nf.backup.json").exists()) {
|
|
buf += `<button class="button" name="send" value="/msgroom staff,/am lb">Load backup</button>`;
|
|
}
|
|
buf += `<div class="infobox"><h3>Miscellaneous settings</h3><hr />`;
|
|
buf += `Minimum percent to process: <form data-submitsend="/msgroom staff,/am editmin {num}">`;
|
|
buf += `<input name="num" value="${settings.minScore}"/>`;
|
|
buf += `<button class="button notifying" type="submit">Change minimum</button></form>`;
|
|
buf += `<br />Score threshold: <form data-submitsend="/msgroom staff,/am threshold {num}">`;
|
|
buf += `<input name="num" value="${settings.threshold}"/>`;
|
|
buf += `<button class="button notifying" type="submit">Change threshold</button></form>`;
|
|
const incr = settings.thresholdIncrement;
|
|
if (incr) {
|
|
buf += `<br />Threshold increments: `;
|
|
buf += `Increases ${incr.amount} every ${incr.turns} turns`;
|
|
if (incr.minTurns)
|
|
buf += ` after turn ${incr.minTurns}`;
|
|
buf += `<br />`;
|
|
}
|
|
const replacements = Object.keys(settings.replacements);
|
|
if (replacements.length) {
|
|
buf += `<br />Replacements: `;
|
|
buf += replacements.map((k) => `${k}: ${settings.replacements[k]}`).join(", ");
|
|
buf += `<br />`;
|
|
}
|
|
buf += `</div><div class="infobox"><h3>Punishment settings</h3><hr />`;
|
|
if (settings.punishments.length) {
|
|
for (const [i, p] of settings.punishments.entries()) {
|
|
buf += `• ${i + 1}: `;
|
|
buf += Object.keys(p).map(
|
|
(f) => `${f}: ${visualizePunishmentKey(p, f)}`
|
|
).join(", ");
|
|
buf += ` (<button class="button" name="send" value="/msgroom staff,/am dp ${i + 1}">delete</button>)`;
|
|
buf += `<br />`;
|
|
}
|
|
buf += `<br />`;
|
|
}
|
|
buf += `<details class="readmore"><summary>Add a punishment</summary>`;
|
|
buf += `<form data-submitsend="/msgroom staff,/am ap p={punishment},t={type},ct={certainty},c={count}">`;
|
|
buf += `Punishment: <input name="punishment" /> <small>(required)</small><br />`;
|
|
buf += `Type: <input name="type" /> <small>(required)</small><br />`;
|
|
buf += `Certainty: <input name="certainty" /> <small>(optional)</small><br />`;
|
|
buf += `Count: <input name="count" /> <small>(optional)</small><br />`;
|
|
buf += `<button class="button notifying" type="submit">Add punishment</button></details>`;
|
|
buf += `</form><br />`;
|
|
buf += `</div><div class="infobox"><h3>Scoring:</h3><hr />`;
|
|
const keys = import_lib.Utils.sortBy(
|
|
Object.keys(Artemis.RemoteClassifier.ATTRIBUTES),
|
|
(k) => [-Object.keys(settings.specials[k] || {}).length, k]
|
|
);
|
|
for (const k of keys) {
|
|
buf += `<strong>${k}</strong>:<br />`;
|
|
if (settings.specials[k]) {
|
|
for (const percent in settings.specials[k]) {
|
|
buf += `• ${percent}%: ${settings.specials[k][percent]} `;
|
|
buf += `(<button class="button" name="send" value="/msgroom staff,/am ds ${k},${percent}">Delete</button>)`;
|
|
buf += `<br />`;
|
|
}
|
|
}
|
|
buf += `<br />`;
|
|
buf += `<details class="readmore"><summary>Add a special case</summary>`;
|
|
buf += `<form data-submitsend="/msgroom staff,/am es ${k},{percent},{score}">`;
|
|
buf += `Percent needed: <input type="text" name="percent" /><br />`;
|
|
buf += `Score: <input type="text" name="score" /><br />`;
|
|
buf += `<button class="button notifying" type="submit">Add</button>`;
|
|
buf += `</form></details>`;
|
|
buf += `<hr />`;
|
|
}
|
|
buf += `</div>`;
|
|
return buf;
|
|
},
|
|
reviews() {
|
|
checkAccess(this);
|
|
this.title = `[Abuse Monitor] Reviews`;
|
|
let buf = `<div class="pad"><h2>Artemis recommendation reviews ({{total}})</h2>`;
|
|
buf += `<button class="button" name="send" value="/msgroom staff,/am reviews">Reload reviews</button>`;
|
|
buf += `<hr />`;
|
|
let total = 0;
|
|
let atLeastOne = false;
|
|
for (const userid in reviews) {
|
|
const curReviews = reviews[userid].filter((f) => !f.resolved);
|
|
if (curReviews.length) {
|
|
buf += `<strong>${Chat.count(curReviews, "reviews")} from ${userid}:</strong><hr />`;
|
|
total += curReviews.length;
|
|
} else {
|
|
continue;
|
|
}
|
|
for (const review of curReviews) {
|
|
buf += `<div class="infobox">`;
|
|
buf += `Battle: <a href="//${import_config_loader.Config.routes.client}/${(0, import_helptickets.getBattleLinks)(review.room)[0]}">${review.room}</a><br />`;
|
|
buf += import_lib.Utils.html`<details class="readmore"><summary>Review details:</summary>${review.details}</details>`;
|
|
buf += `<form data-submitsend="/msgroom staff,/am resolvereview ${review.staff},${review.room},{result},{response}">`;
|
|
buf += `Respond: <br /><textarea name="response" rows="3" cols="40"></textarea><br />`;
|
|
buf += `Mark result: <select name="result">`;
|
|
buf += `<option value="1">Accurate</option>`;
|
|
buf += `<option value="0">Inaccurate</option>`;
|
|
buf += `</select><br />`;
|
|
buf += `<button class="button notifying" type="submit">Resolve</button>`;
|
|
buf += `</form></div><br />`;
|
|
atLeastOne = true;
|
|
}
|
|
buf += `<hr />`;
|
|
}
|
|
if (!atLeastOne) {
|
|
buf += `No reviews to display.`;
|
|
return buf;
|
|
}
|
|
buf = buf.replace("{{total}}", `${total}`);
|
|
return buf;
|
|
},
|
|
review() {
|
|
this.checkCan("lock");
|
|
this.title = `[Abuse Monitor] Review`;
|
|
let buf = `<div class="pad"><h2>Artemis recommendation review</h2>`;
|
|
buf += `<hr />`;
|
|
buf += `<form data-submitsend="/msgroom staff,/am submitreview {room},{details}">`;
|
|
buf += `<label>Enter a room ID (replay URL will work):</label>`;
|
|
buf += `<br />`;
|
|
buf += `<input type="text" name="room" />`;
|
|
buf += `<br />`;
|
|
buf += `<label>Tell what was inaccurate and why:</label> `;
|
|
buf += `<br />`;
|
|
buf += `<textarea name="details" rows="3" cols="20"></textarea>`;
|
|
buf += `<br />`;
|
|
buf += `<button class="button notifying" type="submit">Submit</button>`;
|
|
buf += `</form>`;
|
|
return buf;
|
|
},
|
|
async edithistory(query, user) {
|
|
this.checkCan("globalban");
|
|
const targetUser = (0, import_dex_data.toID)(query[0]);
|
|
if (!targetUser) {
|
|
return this.errorReply(`Specify a user.`);
|
|
}
|
|
this.title = `[Artemis History] ${targetUser}`;
|
|
let buf = `<div class="pad"><h2>Artemis modlog handling for ${targetUser}</h2><hr />`;
|
|
const modlogEntries = await Rooms.Modlog.search("global", {
|
|
user: [{ search: targetUser, isExact: true }],
|
|
note: [],
|
|
ip: [],
|
|
action: [],
|
|
actionTaker: []
|
|
}, 100, true);
|
|
if (!modlogEntries?.results.length) {
|
|
buf += `<div class="message-error">No entries found.</div>`;
|
|
return buf;
|
|
}
|
|
buf += `<div class="ladder pad"><table><tr><th>Entry</th><th>Options</th></tr><tr>`;
|
|
buf += modlogEntries.results.map((result) => {
|
|
const day = Chat.toTimestamp(new Date(result.time)).split(" ")[0];
|
|
let innerBuf = import_lib.Utils.html`<td><small>#${result.entryID}</small> [${day}] `;
|
|
innerBuf += `${result.action}${result.note ? ` (${result.note.trim()})` : ``}</td>`;
|
|
const existingIgnore = metadata.modlogIgnores?.[targetUser];
|
|
const todayMatch = existingIgnore === day;
|
|
const entryMatch = Array.isArray(existingIgnore) && existingIgnore?.includes(result.entryID);
|
|
let cmd = entryMatch ? `am ignoremodlog remove` : `am ignoremodlog add`;
|
|
innerBuf += `<td><button class="button" name="send" value="/${cmd} ${targetUser},${result.entryID}">`;
|
|
innerBuf += `(${entryMatch ? "Unignore" : "Ignore"} specific)</button> `;
|
|
cmd = todayMatch ? `am ignoremodlog remove` : `am ignoremodlog add`;
|
|
innerBuf += `<button class="button" name="send" value="/${cmd} ${targetUser},${day}">`;
|
|
innerBuf += `(${todayMatch ? "Unignore" : "Ignore"} up to this date)</button></td>`;
|
|
return innerBuf;
|
|
}).join("</tr><tr>");
|
|
buf += `</tr></table></div>`;
|
|
return buf;
|
|
}
|
|
},
|
|
async battlechat(query) {
|
|
const [format, num, pw] = query.map(import_dex_data.toID);
|
|
this.checkCan("lock");
|
|
if (!format || !num) {
|
|
return this.errorReply(`Invalid battle link provided.`);
|
|
}
|
|
this.title = `[Battle Logs] ${format}-${num}`;
|
|
const full = `battle-${format}-${num}${pw ? `-${pw}` : ""}`;
|
|
const logData = await (0, import_helptickets.getBattleLog)(full);
|
|
if (!logData) {
|
|
return this.errorReply(`No logs found for the battle <code>${full}</code>.`);
|
|
}
|
|
let log = logData.log;
|
|
log = log.filter((l) => l.startsWith("|c|"));
|
|
let buf = '<div class="pad">';
|
|
buf += `<h2>Logs for <a href="/${full}">${logData.title}</a></h2>`;
|
|
buf += `Players: ${Object.values(logData.players).map(import_dex_data.toID).filter(Boolean).join(", ")}<hr />`;
|
|
let atLeastOne = false;
|
|
for (const line of log) {
|
|
const [, , username, message] = import_lib.Utils.splitFirst(line, "|", 3);
|
|
buf += import_lib.Utils.html`<div class="chat"><span class="username"><username>${username}:</username></span> ${message}</div>`;
|
|
atLeastOne = true;
|
|
}
|
|
if (!atLeastOne)
|
|
buf += `None found.`;
|
|
return buf;
|
|
}
|
|
};
|
|
const punishmentfilter = (user, punishment) => {
|
|
if (typeof user === "string")
|
|
return;
|
|
if (!Punishments.punishmentTypes.has(punishment.type))
|
|
return;
|
|
const cacheEntry = punishmentCache.get(user) || {};
|
|
if (!cacheEntry[punishment.type])
|
|
cacheEntry[punishment.type] = 0;
|
|
cacheEntry[punishment.type]++;
|
|
};
|
|
//# sourceMappingURL=abuse-monitor.js.map
|