Spaces:
Running
Running
| ; | |
| 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 = (target2, all) => { | |
| for (var name in all) | |
| __defProp(target2, 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, target2) => (target2 = 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(target2, "default", { value: mod, enumerable: true }) : target2, | |
| mod | |
| )); | |
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | |
| var admin_exports = {}; | |
| __export(admin_exports, { | |
| commands: () => commands, | |
| pages: () => pages | |
| }); | |
| module.exports = __toCommonJS(admin_exports); | |
| var path = __toESM(require("path")); | |
| var child_process = __toESM(require("child_process")); | |
| var import_lib = require("../../lib"); | |
| /** | |
| * Administration commands | |
| * Pokemon Showdown - http://pokemonshowdown.com/ | |
| * | |
| * These are administration commands, generally only useful for | |
| * programmers for managing the server. | |
| * | |
| * For the API, see chat-plugins/COMMANDS.md | |
| * | |
| * @license MIT | |
| */ | |
| function hasDevAuth(user2) { | |
| const devRoom = Rooms.get("development"); | |
| return devRoom && Users.Auth.atLeast(devRoom.auth.getDirect(user2.id), "%"); | |
| } | |
| function bash(command, context, cwd) { | |
| context.stafflog(`$ ${command}`); | |
| if (!cwd) | |
| cwd = import_lib.FS.ROOT_PATH; | |
| return new Promise((resolve) => { | |
| child_process.exec(command, { cwd }, (error, stdout, stderr) => { | |
| let log = `[o] ${stdout}[e] ${stderr}`; | |
| if (error) | |
| log = `[c] ${error.code} | |
| ${log}`; | |
| context.stafflog(log); | |
| resolve([error?.code || 0, stdout, stderr]); | |
| }); | |
| }); | |
| } | |
| function keysIncludingNonEnumerable(obj) { | |
| const methods = /* @__PURE__ */ new Set(); | |
| let current = obj; | |
| do { | |
| const curProps = Object.getOwnPropertyNames(current); | |
| for (const prop of curProps) { | |
| methods.add(prop); | |
| } | |
| } while (current = Object.getPrototypeOf(current)); | |
| return [...methods]; | |
| } | |
| function keysToCopy(obj) { | |
| return keysIncludingNonEnumerable(obj).filter( | |
| // `__` matches sucrase init methods | |
| // prop is excluded because it can hit things like hasOwnProperty that are potentially annoying (?) with | |
| // the kind of prototype patching we want to do here - same for constructor and valueOf | |
| (prop) => !(prop.includes("__") || prop.toLowerCase().includes("prop") || ["valueOf", "constructor"].includes(prop)) | |
| ); | |
| } | |
| async function updateserver(context, codePath) { | |
| const exec = (command) => bash(command, context, codePath); | |
| context.sendReply(`Fetching newest version of code in the repository ${codePath}...`); | |
| let [code, stdout, stderr] = await exec(`git fetch`); | |
| if (code) | |
| throw new Error(`updateserver: Crash while fetching - make sure this is a Git repository`); | |
| if (!stdout && !stderr) { | |
| context.sendReply(`There were no updates.`); | |
| Monitor.updateServerLock = false; | |
| return true; | |
| } | |
| [code, stdout, stderr] = await exec(`git rev-parse HEAD`); | |
| if (code || stderr) | |
| throw new Error(`updateserver: Crash while grabbing hash`); | |
| const oldHash = String(stdout).trim(); | |
| [code, stdout, stderr] = await exec(`git stash save "PS /updateserver autostash"`); | |
| let stashedChanges = true; | |
| if (code) | |
| throw new Error(`updateserver: Crash while stashing`); | |
| if ((stdout + stderr).includes("No local changes")) { | |
| stashedChanges = false; | |
| } else if (stderr) { | |
| throw new Error(`updateserver: Crash while stashing`); | |
| } else { | |
| context.sendReply(`Saving changes...`); | |
| } | |
| try { | |
| context.sendReply(`Rebasing...`); | |
| [code] = await exec(`git rebase --no-autostash FETCH_HEAD`); | |
| if (code) { | |
| await exec(`git rebase --abort`); | |
| throw new Error(`restore`); | |
| } | |
| if (stashedChanges) { | |
| context.sendReply(`Restoring saved changes...`); | |
| [code] = await exec(`git stash pop`); | |
| if (code) { | |
| await exec(`git reset HEAD .`); | |
| await exec(`git checkout .`); | |
| throw new Error(`restore`); | |
| } | |
| } | |
| return true; | |
| } catch { | |
| await exec(`git reset --hard ${oldHash}`); | |
| if (stashedChanges) | |
| await exec(`git stash pop`); | |
| return false; | |
| } | |
| } | |
| const commands = { | |
| potd(target2, room2, user2) { | |
| this.canUseConsole(); | |
| const species = Dex.species.get(target2); | |
| if (species.id === Config.potd) { | |
| return this.errorReply(`The PotD is already set to ${species.name}`); | |
| } | |
| if (!species.exists) | |
| return this.errorReply(`Pokemon "${target2}" not found.`); | |
| if (!Dex.species.getFullLearnset(species.id).length) { | |
| return this.errorReply(`That Pokemon has no learnset and cannot be used as the PotD.`); | |
| } | |
| Config.potd = species.id; | |
| for (const process2 of Rooms.PM.processes) { | |
| process2.getProcess().send(`EVAL | |
| Config.potd = '${species.id}'`); | |
| } | |
| this.addGlobalModAction(`${user2.name} set the PotD to ${species.name}.`); | |
| this.globalModlog(`POTD`, null, species.name); | |
| }, | |
| potdhelp: [ | |
| `/potd [pokemon] - Set the Pokemon of the Day to the given [pokemon]. Requires: ~` | |
| ], | |
| /********************************************************* | |
| * Bot commands (chat-log manipulation) | |
| *********************************************************/ | |
| htmlbox(target2, room2, user2) { | |
| if (!target2) | |
| return this.parse("/help htmlbox"); | |
| room2 = this.requireRoom(); | |
| this.checkHTML(target2); | |
| target2 = Chat.collapseLineBreaksHTML(target2); | |
| this.checkBroadcast(true, "!htmlbox"); | |
| if (this.broadcastMessage) | |
| this.checkCan("declare", null, room2); | |
| if (!this.runBroadcast(true, "!htmlbox")) | |
| return; | |
| if (this.broadcasting) { | |
| return `/raw <div class="infobox">${target2}</div>`; | |
| } else { | |
| this.sendReplyBox(target2); | |
| } | |
| }, | |
| htmlboxhelp: [ | |
| `/htmlbox [message] - Displays a message, parsing HTML code contained.`, | |
| `!htmlbox [message] - Shows everyone a message, parsing HTML code contained. Requires: * # ~` | |
| ], | |
| addhtmlbox(target2, room2, user2, connection2, cmd) { | |
| if (!target2) | |
| return this.parse("/help " + cmd); | |
| room2 = this.requireRoom(); | |
| this.checkChat(); | |
| this.checkHTML(target2); | |
| this.checkCan("addhtml", null, room2); | |
| target2 = Chat.collapseLineBreaksHTML(target2); | |
| if (user2.tempGroup !== "*") { | |
| target2 += import_lib.Utils.html`<div style="float:right;color:#888;font-size:8pt">[${user2.name}]</div><div style="clear:both"></div>`; | |
| } | |
| return `/raw <div class="infobox">${target2}</div>`; | |
| }, | |
| addhtmlboxhelp: [ | |
| `/addhtmlbox [message] - Shows everyone a message, parsing HTML code contained. Requires: * # ~` | |
| ], | |
| addrankhtmlbox(target2, room2, user2, connection2, cmd) { | |
| room2 = this.requireRoom(); | |
| if (!target2) | |
| return this.parse("/help " + cmd); | |
| this.checkChat(); | |
| let [rank, html] = this.splitOne(target2); | |
| if (!(rank in Config.groups)) | |
| return this.errorReply(`Group '${rank}' does not exist.`); | |
| html = this.checkHTML(html); | |
| this.checkCan("addhtml", null, room2); | |
| html = Chat.collapseLineBreaksHTML(html); | |
| if (user2.tempGroup !== "*") { | |
| html += import_lib.Utils.html`<div style="float:right;color:#888;font-size:8pt">[${user2.name}]</div><div style="clear:both"></div>`; | |
| } | |
| room2.sendRankedUsers(`|html|<div class="infobox">${html}</div>`, rank); | |
| }, | |
| addrankhtmlboxhelp: [ | |
| `/addrankhtmlbox [rank], [message] - Shows everyone with the specified rank or higher a message, parsing HTML code contained. Requires: * # ~` | |
| ], | |
| changeuhtml: "adduhtml", | |
| adduhtml(target2, room2, user2, connection2, cmd) { | |
| room2 = this.requireRoom(); | |
| if (!target2) | |
| return this.parse("/help " + cmd); | |
| this.checkChat(); | |
| let [name, html] = this.splitOne(target2); | |
| name = toID(name); | |
| html = this.checkHTML(html); | |
| this.checkCan("addhtml", null, room2); | |
| html = Chat.collapseLineBreaksHTML(html); | |
| if (user2.tempGroup !== "*") { | |
| html += import_lib.Utils.html`<div style="float:right;color:#888;font-size:8pt">[${user2.name}]</div><div style="clear:both"></div>`; | |
| } | |
| if (cmd === "changeuhtml") { | |
| room2.attributedUhtmlchange(user2, name, html); | |
| } else { | |
| return `/uhtml ${name},${html}`; | |
| } | |
| }, | |
| adduhtmlhelp: [ | |
| `/adduhtml [name], [message] - Shows everyone a message that can change, parsing HTML code contained. Requires: * # ~` | |
| ], | |
| changeuhtmlhelp: [ | |
| `/changeuhtml [name], [message] - Changes the message previously shown with /adduhtml [name]. Requires: * # ~` | |
| ], | |
| changerankuhtml: "addrankuhtml", | |
| addrankuhtml(target2, room2, user2, connection2, cmd) { | |
| room2 = this.requireRoom(); | |
| if (!target2) | |
| return this.parse("/help " + cmd); | |
| this.checkChat(); | |
| const [rank, uhtml] = this.splitOne(target2); | |
| if (!(rank in Config.groups)) | |
| return this.errorReply(`Group '${rank}' does not exist.`); | |
| let [name, html] = this.splitOne(uhtml); | |
| name = toID(name); | |
| html = this.checkHTML(html); | |
| this.checkCan("addhtml", null, room2); | |
| html = Chat.collapseLineBreaksHTML(html); | |
| if (user2.tempGroup !== "*") { | |
| html += import_lib.Utils.html`<div style="float:right;color:#888;font-size:8pt">[${user2.name}]</div><div style="clear:both"></div>`; | |
| } | |
| html = `|uhtml${cmd === "changerankuhtml" ? "change" : ""}|${name}|${html}`; | |
| room2.sendRankedUsers(html, rank); | |
| }, | |
| addrankuhtmlhelp: [ | |
| `/addrankuhtml [rank], [name], [message] - Shows everyone with the specified rank or higher a message that can change, parsing HTML code contained. Requires: * # ~` | |
| ], | |
| changerankuhtmlhelp: [ | |
| `/changerankuhtml [rank], [name], [message] - Changes the message previously shown with /addrankuhtml [rank], [name]. Requires: * # ~` | |
| ], | |
| deletenamecolor: "setnamecolor", | |
| snc: "setnamecolor", | |
| dnc: "setnamecolor", | |
| async setnamecolor(target2, room2, user2, connection2, cmd) { | |
| this.checkCan("rangeban"); | |
| if (!toID(target2)) { | |
| return this.parse(`/help ${cmd}`); | |
| } | |
| let [userid, source] = this.splitOne(target2).map(toID); | |
| if (cmd.startsWith("d")) { | |
| source = ""; | |
| } else if (!source || source.length > 18) { | |
| return this.errorReply( | |
| `Specify a source username to take the color from. Name must be <19 characters.` | |
| ); | |
| } | |
| if (!userid || userid.length > 18) { | |
| return this.errorReply(`Specify a valid name to set a new color for. Names must be <19 characters.`); | |
| } | |
| const [res, error] = await LoginServer.request("updatenamecolor", { | |
| userid, | |
| source, | |
| by: user2.id | |
| }); | |
| if (error) { | |
| return this.errorReply(error.message); | |
| } | |
| if (!res || res.actionerror) { | |
| return this.errorReply(res?.actionerror || "The loginserver is currently disabled."); | |
| } | |
| if (source) { | |
| return this.sendReply( | |
| `|html|<username>${userid}</username>'s namecolor was successfully updated to match '<username>${source}</username>'. Refresh your browser for it to take effect.` | |
| ); | |
| } else { | |
| return this.sendReply(`${userid}'s namecolor was removed.`); | |
| } | |
| }, | |
| setnamecolorhelp: [ | |
| `/setnamecolor OR /snc [username], [source name] - Set [username]'s name color to match the [source name]'s color.`, | |
| `Requires: ~` | |
| ], | |
| deletenamecolorhelp: [ | |
| `/deletenamecolor OR /dnc [username] - Remove [username]'s namecolor.`, | |
| `Requires: ~` | |
| ], | |
| pline(target2, room2, user2) { | |
| this.canUseConsole(); | |
| const message = target2.length > 30 ? target2.slice(0, 30) + "..." : target2; | |
| this.checkBroadcast(true, `!pline ${message}`); | |
| this.runBroadcast(true); | |
| this.sendReply(target2); | |
| }, | |
| plinehelp: [ | |
| `/pline [protocol lines] - Adds the given [protocol lines] to the current room. Requires: ~ console access` | |
| ], | |
| pminfobox(target2, room2, user2, connection2) { | |
| this.checkChat(); | |
| room2 = this.requireRoom(); | |
| this.checkCan("addhtml", null, room2); | |
| if (!target2) | |
| return this.parse("/help pminfobox"); | |
| const { targetUser, rest: html } = this.requireUser(target2); | |
| this.checkHTML(html); | |
| this.checkPMHTML(targetUser); | |
| const message = `|pm|${user2.getIdentity()}|${targetUser.getIdentity()}|/raw <div class="infobox">${html}</div>`; | |
| user2.send(message); | |
| if (targetUser !== user2) | |
| targetUser.send(message); | |
| targetUser.lastPM = user2.id; | |
| user2.lastPM = targetUser.id; | |
| }, | |
| pminfoboxhelp: [`/pminfobox [user], [html]- PMs an [html] infobox to [user]. Requires * # ~`], | |
| pmuhtmlchange: "pmuhtml", | |
| pmuhtml(target2, room2, user2, connection2, cmd) { | |
| this.checkChat(); | |
| room2 = this.requireRoom(); | |
| this.checkCan("addhtml", null, room2); | |
| if (!target2) | |
| return this.parse("/help " + cmd); | |
| const { targetUser, rest: html } = this.requireUser(target2); | |
| this.checkHTML(html); | |
| this.checkPMHTML(targetUser); | |
| const message = `|pm|${user2.getIdentity()}|${targetUser.getIdentity()}|/uhtml${cmd === "pmuhtmlchange" ? "change" : ""} ${html}`; | |
| user2.send(message); | |
| if (targetUser !== user2) | |
| targetUser.send(message); | |
| targetUser.lastPM = user2.id; | |
| user2.lastPM = targetUser.id; | |
| }, | |
| pmuhtmlhelp: [`/pmuhtml [user], [name], [html] - PMs [html] that can change to [user]. Requires * # ~`], | |
| pmuhtmlchangehelp: [ | |
| `/pmuhtmlchange [user], [name], [html] - Changes html that was previously PMed to [user] to [html]. Requires * # ~` | |
| ], | |
| closehtmlpage: "sendhtmlpage", | |
| changehtmlpageselector: "sendhtmlpage", | |
| sendhtmlpage(target2, room2, user2, connection2, cmd) { | |
| room2 = this.requireRoom(); | |
| this.checkCan("addhtml", null, room2); | |
| const closeHtmlPage = cmd === "closehtmlpage"; | |
| const [targetStr, rest] = this.splitOne(target2).map((str) => str.trim()); | |
| const targets = targetStr.split("|").map((u) => u.trim()); | |
| let [pageid, content] = this.splitOne(rest); | |
| let selector; | |
| if (cmd === "changehtmlpageselector") { | |
| [selector, content] = this.splitOne(content); | |
| if (!selector) | |
| return this.parse(`/help ${cmd}`); | |
| } | |
| if (!pageid || (closeHtmlPage ? content : !content)) { | |
| return this.parse(`/help ${cmd}`); | |
| } | |
| pageid = `${user2.id}-${toID(pageid)}`; | |
| const successes = [], errors = []; | |
| content = this.checkHTML(content); | |
| targets.forEach((targetUsername) => { | |
| const targetUser = Users.get(targetUsername); | |
| if (!targetUser) | |
| return errors.push(`${targetUsername} [offline/misspelled]`); | |
| if (targetUser.locked && !this.user.can("lock")) { | |
| return errors.push(`${targetUser.name} [locked]`); | |
| } | |
| let targetConnections = []; | |
| for (const c of targetUser.connections) { | |
| if (c.lastRequestedPage === pageid) { | |
| targetConnections.push(c); | |
| } | |
| } | |
| if (!targetConnections.length) { | |
| try { | |
| this.checkPMHTML(targetUser); | |
| } catch { | |
| return errors.push(`${targetUser.name} [not in room / blocking PMs]`); | |
| } | |
| targetConnections = targetUser.connections; | |
| } | |
| for (const targetConnection of targetConnections) { | |
| const context = new Chat.PageContext({ | |
| user: targetUser, | |
| connection: targetConnection, | |
| pageid: `view-bot-${pageid}` | |
| }); | |
| if (closeHtmlPage) { | |
| context.send(`|deinit|`); | |
| } else if (selector) { | |
| context.send(`|selectorhtml|${selector}|${content}`); | |
| } else { | |
| context.title = `[${user2.name}] ${pageid}`; | |
| context.setHTML(content); | |
| } | |
| } | |
| successes.push(targetUser.name); | |
| }); | |
| if (closeHtmlPage) { | |
| if (successes.length) { | |
| this.sendReply(`Closed the bot page ${pageid} for ${Chat.toListString(successes)}.`); | |
| } | |
| if (errors.length) { | |
| this.errorReply(`Unable to close the bot page for ${Chat.toListString(errors)}.`); | |
| } | |
| } else { | |
| if (successes.length) { | |
| this.sendReply(`Sent ${Chat.toListString(successes)}${selector ? ` the selector ${selector} on` : ""} the bot page ${pageid}.`); | |
| } | |
| if (errors.length) { | |
| this.errorReply(`Unable to send the bot page ${pageid} to ${Chat.toListString(errors)}.`); | |
| } | |
| } | |
| if (!successes.length) | |
| return false; | |
| }, | |
| sendhtmlpagehelp: [ | |
| `/sendhtmlpage [userid], [pageid], [html] - Sends [userid] the bot page [pageid] with the content [html]. Requires: * # ~` | |
| ], | |
| changehtmlpageselectorhelp: [ | |
| `/changehtmlpageselector [userid], [pageid], [selector], [html] - Sends [userid] the content [html] for the selector [selector] on the bot page [pageid]. Requires: * # ~` | |
| ], | |
| closehtmlpagehelp: [ | |
| `/closehtmlpage [userid], [pageid], - Closes the bot page [pageid] for [userid]. Requires: * # ~` | |
| ], | |
| highlighthtmlpage(target2, room2, user2) { | |
| const { targetUser, rest } = this.requireUser(target2); | |
| let [pageid, title, highlight] = import_lib.Utils.splitFirst(rest, ",", 2); | |
| pageid = `${user2.id}-${toID(pageid)}`; | |
| if (!pageid || !target2) | |
| return this.parse(`/help highlighthtmlpage`); | |
| if (targetUser.locked && !this.user.can("lock")) { | |
| throw new Chat.ErrorMessage("This user is currently locked, so you cannot send them highlights."); | |
| } | |
| const buf = `|tempnotify|bot-${pageid}|${title} [from ${user2.name}]|${highlight ? highlight : ""}`; | |
| let targetConnections = []; | |
| this.checkPMHTML(targetUser); | |
| for (const c of targetUser.connections) { | |
| if (c.lastRequestedPage === pageid) { | |
| targetConnections.push(c); | |
| } | |
| } | |
| if (!targetConnections.length) { | |
| targetConnections = [targetUser.connections[0]]; | |
| } | |
| for (const conn of targetConnections) { | |
| conn.send(`>view-bot-${pageid} | |
| ${buf}`); | |
| } | |
| this.sendReply(`Sent a highlight to ${targetUser.name} on the bot page ${pageid}.`); | |
| }, | |
| highlighthtmlpagehelp: [ | |
| `/highlighthtmlpage [userid], [pageid], [title], [optional highlight] - Sends a highlight to [userid] if they're viewing the bot page [pageid].`, | |
| `If a [highlight] is specified, only highlights them if they have that term on their highlight list.` | |
| ], | |
| changeprivateuhtml: "sendprivatehtmlbox", | |
| sendprivateuhtml: "sendprivatehtmlbox", | |
| sendprivatehtmlbox(target2, room2, user2, connection2, cmd) { | |
| room2 = this.requireRoom(); | |
| this.checkCan("addhtml", null, room2); | |
| const [targetStr, rest] = this.splitOne(target2).map((str) => str.trim()); | |
| const targets = targetStr.split("|").map((u) => u.trim()); | |
| let html; | |
| let messageType; | |
| let name; | |
| const plainHtml = cmd === "sendprivatehtmlbox"; | |
| if (plainHtml) { | |
| html = rest; | |
| messageType = "html"; | |
| } else { | |
| [name, html] = this.splitOne(rest); | |
| if (!name) | |
| return this.parse("/help sendprivatehtmlbox"); | |
| messageType = `uhtml${cmd === "changeprivateuhtml" ? "change" : ""}|${name}`; | |
| } | |
| html = this.checkHTML(html); | |
| if (!html) | |
| return this.parse("/help sendprivatehtmlbox"); | |
| html = `${import_lib.Utils.html`<div style="color:#888;font-size:8pt">[Private from ${user2.name}]</div>`}${Chat.collapseLineBreaksHTML(html)}`; | |
| if (plainHtml) | |
| html = `<div class="infobox">${html}</div>`; | |
| const successes = [], errors = []; | |
| targets.forEach((targetUsername) => { | |
| const targetUser = Users.get(targetUsername); | |
| if (!targetUser) | |
| return errors.push(`${targetUsername} [offline/misspelled]`); | |
| if (targetUser.locked && !this.user.can("lock")) { | |
| return errors.push(`${targetUser.name} [locked]`); | |
| } | |
| if (!(targetUser.id in room2.users)) { | |
| return errors.push(`${targetUser.name} [not in room]`); | |
| } | |
| successes.push(targetUser.name); | |
| targetUser.sendTo(room2, `|${messageType}|${html}`); | |
| }); | |
| if (successes.length) | |
| this.sendReply(`Sent private HTML to ${Chat.toListString(successes)}.`); | |
| if (errors.length) | |
| this.errorReply(`Unable to send private HTML to ${Chat.toListString(errors)}.`); | |
| if (!successes.length) | |
| return false; | |
| }, | |
| sendprivatehtmlboxhelp: [ | |
| `/sendprivatehtmlbox [userid], [html] - Sends [userid] the private [html]. Requires: * # ~`, | |
| `/sendprivateuhtml [userid], [name], [html] - Sends [userid] the private [html] that can change. Requires: * # ~`, | |
| `/changeprivateuhtml [userid], [name], [html] - Changes the message previously sent with /sendprivateuhtml [userid], [name], [html]. Requires: * # ~` | |
| ], | |
| botmsg(target2, room2, user2, connection2) { | |
| if (!target2?.includes(",")) { | |
| return this.parse("/help botmsg"); | |
| } | |
| this.checkRecursion(); | |
| let { targetUser, rest: message } = this.requireUser(target2); | |
| const auth = this.room ? this.room.auth : Users.globalAuth; | |
| if (!["*", "#"].includes(auth.get(targetUser))) { | |
| return this.popupReply(`The user "${targetUser.name}" is not a bot in this room.`); | |
| } | |
| this.room = null; | |
| this.pmTarget = targetUser; | |
| message = this.checkChat(message); | |
| if (!message) | |
| return; | |
| Chat.PrivateMessages.send(`/botmsg ${message}`, user2, targetUser, targetUser); | |
| }, | |
| botmsghelp: [`/botmsg [username], [message] - Send a private message to a bot without feedback. For room bots, must use in the room the bot is auth in.`], | |
| nick() { | |
| this.sendReply(`||New to the Pok\xE9mon Showdown protocol? Your client needs to get a signed assertion from the login server and send /trn`); | |
| this.sendReply(`||https://github.com/smogon/pokemon-showdown/blob/master/PROTOCOL.md#global-messages`); | |
| this.sendReply(`||Follow the instructions for handling |challstr| in this documentation`); | |
| }, | |
| /********************************************************* | |
| * Server management commands | |
| *********************************************************/ | |
| memusage: "memoryusage", | |
| memoryusage(target2, room2, user2) { | |
| if (!hasDevAuth(user2)) | |
| this.checkCan("lockdown"); | |
| const memUsage = process.memoryUsage(); | |
| const resultNums = [memUsage.rss, memUsage.heapUsed, memUsage.heapTotal]; | |
| const units = ["B", "KiB", "MiB", "GiB", "TiB"]; | |
| const results = resultNums.map((num) => { | |
| const unitIndex = Math.floor(Math.log2(num) / 10); | |
| return `${(num / 2 ** (10 * unitIndex)).toFixed(2)} ${units[unitIndex]}`; | |
| }); | |
| this.sendReply(`||[Main process] RSS: ${results[0]}, Heap: ${results[1]} / ${results[2]}`); | |
| }, | |
| memoryusagehelp: [ | |
| `/memoryusage OR /memusage - Get the current memory usage of the server. Requires: ~` | |
| ], | |
| forcehotpatch: "hotpatch", | |
| async hotpatch(target2, room2, user2, connection2, cmd) { | |
| if (!target2) | |
| return this.parse("/help hotpatch"); | |
| this.canUseConsole(); | |
| if (Monitor.updateServerLock) { | |
| return this.errorReply("Wait for /updateserver to finish before hotpatching."); | |
| } | |
| await this.parse(`/rebuild`); | |
| const lock = Monitor.hotpatchLock; | |
| const hotpatches = [ | |
| "chat", | |
| "formats", | |
| "loginserver", | |
| "punishments", | |
| "dnsbl", | |
| "modlog", | |
| "processmanager", | |
| "roomsp", | |
| "usersp" | |
| ]; | |
| target2 = toID(target2); | |
| try { | |
| import_lib.Utils.clearRequireCache({ exclude: ["/lib/process-manager"] }); | |
| if (target2 === "all") { | |
| if (lock["all"]) { | |
| return this.errorReply(`Hot-patching all has been disabled by ${lock["all"].by} (${lock["all"].reason})`); | |
| } | |
| if (Config.disablehotpatchall) { | |
| return this.errorReply("This server does not allow for the use of /hotpatch all"); | |
| } | |
| for (const hotpatch of hotpatches) { | |
| await this.parse(`/hotpatch ${hotpatch}`); | |
| } | |
| } else if (target2 === "chat" || target2 === "commands") { | |
| if (lock["tournaments"]) { | |
| return this.errorReply(`Hot-patching tournaments has been disabled by ${lock["tournaments"].by} (${lock["tournaments"].reason})`); | |
| } | |
| if (lock["chat"]) { | |
| return this.errorReply(`Hot-patching chat has been disabled by ${lock["chat"].by} (${lock["chat"].reason})`); | |
| } | |
| this.sendReply("Hotpatching chat commands..."); | |
| const disabledCommands = Chat.allCommands().filter((c) => c.disabled).map((c) => `/${c.fullCmd}`); | |
| if (cmd !== "forcehotpatch" && disabledCommands.length) { | |
| this.errorReply(`${Chat.count(disabledCommands.length, "commands")} are disabled right now.`); | |
| this.errorReply(`Hotpatching will enable them. Use /forcehotpatch chat if you're sure.`); | |
| return this.errorReply(`Currently disabled: ${disabledCommands.join(", ")}`); | |
| } | |
| const oldPlugins = Chat.plugins; | |
| Chat.destroy(); | |
| const processManagers = import_lib.ProcessManager.processManagers; | |
| for (const manager of processManagers.slice()) { | |
| if (manager.filename.startsWith((0, import_lib.FS)(__dirname + "/../chat-plugins/").path)) { | |
| void manager.destroy(); | |
| } | |
| } | |
| void Chat.PM.destroy(); | |
| global.Chat = require("../chat").Chat; | |
| global.Tournaments = require("../tournaments").Tournaments; | |
| this.sendReply("Reloading chat plugins..."); | |
| Chat.loadPlugins(oldPlugins); | |
| this.sendReply("DONE"); | |
| } else if (target2 === "processmanager") { | |
| if (lock["processmanager"]) { | |
| return this.errorReply( | |
| `Hot-patching formats has been disabled by ${lock["processmanager"].by} (${lock["processmanager"].reason})` | |
| ); | |
| } | |
| this.sendReply("Hotpatching processmanager prototypes..."); | |
| const cache = { ...require.cache }; | |
| import_lib.Utils.clearRequireCache(); | |
| const newPM = require("../../lib/process-manager"); | |
| require.cache = cache; | |
| const protos = [ | |
| [import_lib.ProcessManager.QueryProcessManager, newPM.QueryProcessManager], | |
| [import_lib.ProcessManager.StreamProcessManager, newPM.StreamProcessManager], | |
| [import_lib.ProcessManager.ProcessManager, newPM.ProcessManager], | |
| [import_lib.ProcessManager.RawProcessManager, newPM.RawProcessManager], | |
| [import_lib.ProcessManager.QueryProcessWrapper, newPM.QueryProcessWrapper], | |
| [import_lib.ProcessManager.StreamProcessWrapper, newPM.StreamProcessWrapper], | |
| [import_lib.ProcessManager.RawProcessManager, newPM.RawProcessWrapper] | |
| ].map((part) => part.map((constructor) => constructor.prototype)); | |
| for (const [oldProto, newProto] of protos) { | |
| const newKeys = keysToCopy(newProto); | |
| const oldKeys = keysToCopy(oldProto); | |
| for (const key of oldKeys) { | |
| if (!newProto[key]) { | |
| delete oldProto[key]; | |
| } | |
| } | |
| for (const key of newKeys) { | |
| oldProto[key] = newProto[key]; | |
| } | |
| } | |
| this.sendReply("DONE"); | |
| } else if (target2 === "usersp" || target2 === "roomsp") { | |
| if (lock[target2]) { | |
| return this.errorReply(`Hot-patching ${target2} has been disabled by ${lock[target2].by} (${lock[target2].reason})`); | |
| } | |
| let newProto, oldProto, message; | |
| switch (target2) { | |
| case "usersp": | |
| newProto = require("../users").User.prototype; | |
| oldProto = Users.User.prototype; | |
| message = "user prototypes"; | |
| break; | |
| case "roomsp": | |
| newProto = require("../rooms").BasicRoom.prototype; | |
| oldProto = Rooms.BasicRoom.prototype; | |
| message = "rooms prototypes"; | |
| break; | |
| } | |
| this.sendReply(`Hotpatching ${message}...`); | |
| const newKeys = keysToCopy(newProto); | |
| const oldKeys = keysToCopy(oldProto); | |
| const counts = { | |
| added: 0, | |
| updated: 0, | |
| deleted: 0 | |
| }; | |
| for (const key of oldKeys) { | |
| if (!newProto[key]) { | |
| counts.deleted++; | |
| delete oldProto[key]; | |
| } | |
| } | |
| for (const key of newKeys) { | |
| if (!oldProto[key]) { | |
| counts.added++; | |
| } else if (// compare source code | |
| typeof oldProto[key] !== "function" || oldProto[key].toString() !== newProto[key].toString()) { | |
| counts.updated++; | |
| } | |
| oldProto[key] = newProto[key]; | |
| } | |
| this.sendReply(`DONE`); | |
| this.sendReply( | |
| `Updated ${Chat.count(counts.updated, "methods")}` + (counts.added ? `, added ${Chat.count(counts.added, "new methods")} to ${message}` : "") + (counts.deleted ? `, and removed ${Chat.count(counts.deleted, "methods")}.` : ".") | |
| ); | |
| } else if (target2 === "tournaments") { | |
| if (lock["tournaments"]) { | |
| return this.errorReply(`Hot-patching tournaments has been disabled by ${lock["tournaments"].by} (${lock["tournaments"].reason})`); | |
| } | |
| this.sendReply("Hotpatching tournaments..."); | |
| global.Tournaments = require("../tournaments").Tournaments; | |
| Chat.loadPlugin(Tournaments, "tournaments"); | |
| this.sendReply("DONE"); | |
| } else if (target2 === "formats" || target2 === "battles") { | |
| if (lock["formats"]) { | |
| return this.errorReply(`Hot-patching formats has been disabled by ${lock["formats"].by} (${lock["formats"].reason})`); | |
| } | |
| if (lock["battles"]) { | |
| return this.errorReply(`Hot-patching battles has been disabled by ${lock["battles"].by} (${lock["battles"].reason})`); | |
| } | |
| if (lock["validator"]) { | |
| return this.errorReply(`Hot-patching the validator has been disabled by ${lock["validator"].by} (${lock["validator"].reason})`); | |
| } | |
| this.sendReply("Hotpatching formats..."); | |
| global.Dex = require("../../sim/dex").Dex; | |
| Rooms.global.formatList = ""; | |
| void TeamValidatorAsync.PM.respawn(); | |
| void Rooms.PM.respawn(); | |
| void Chat.plugins.datasearch?.PM?.respawn(); | |
| global.Teams = require("../../sim/teams").Teams; | |
| Rooms.global.sendAll(Rooms.global.formatListText); | |
| this.sendReply("DONE"); | |
| } else if (target2 === "loginserver") { | |
| this.sendReply("Hotpatching loginserver..."); | |
| (0, import_lib.FS)("config/custom.css").unwatch(); | |
| global.LoginServer = require("../loginserver").LoginServer; | |
| this.sendReply("DONE. New login server requests will use the new code."); | |
| } else if (target2 === "learnsets" || target2 === "validator") { | |
| if (lock["validator"]) { | |
| return this.errorReply(`Hot-patching the validator has been disabled by ${lock["validator"].by} (${lock["validator"].reason})`); | |
| } | |
| if (lock["formats"]) { | |
| return this.errorReply(`Hot-patching formats has been disabled by ${lock["formats"].by} (${lock["formats"].reason})`); | |
| } | |
| this.sendReply("Hotpatching validator..."); | |
| void TeamValidatorAsync.PM.respawn(); | |
| global.Teams = require("../../sim/teams").Teams; | |
| this.sendReply("DONE. Any battles started after now will have teams be validated according to the new code."); | |
| } else if (target2 === "punishments") { | |
| if (lock["punishments"]) { | |
| return this.errorReply(`Hot-patching punishments has been disabled by ${lock["punishments"].by} (${lock["punishments"].reason})`); | |
| } | |
| this.sendReply("Hotpatching punishments..."); | |
| global.Punishments = require("../punishments").Punishments; | |
| this.sendReply("DONE"); | |
| } else if (target2 === "dnsbl" || target2 === "datacenters" || target2 === "iptools") { | |
| this.sendReply("Hotpatching ip-tools..."); | |
| global.IPTools = require("../ip-tools").IPTools; | |
| void IPTools.loadHostsAndRanges(); | |
| this.sendReply("DONE"); | |
| } else if (target2 === "modlog") { | |
| if (lock["modlog"]) { | |
| return this.errorReply(`Hot-patching modlogs has been disabled by ${lock["modlog"].by} (${lock["modlog"].reason})`); | |
| } | |
| this.sendReply("Hotpatching modlog..."); | |
| void Rooms.Modlog.database.destroy(); | |
| const { mainModlog } = require("../modlog"); | |
| if (mainModlog.readyPromise) { | |
| this.sendReply("Waiting for the new SQLite database to be ready..."); | |
| await mainModlog.readyPromise; | |
| } else { | |
| this.sendReply("The new SQLite database is ready!"); | |
| } | |
| Rooms.Modlog.destroyAllSQLite(); | |
| Rooms.Modlog = mainModlog; | |
| this.sendReply("DONE"); | |
| } else if (target2.startsWith("disable")) { | |
| this.sendReply("Disabling hot-patch has been moved to its own command:"); | |
| return this.parse("/help nohotpatch"); | |
| } else { | |
| return this.errorReply("Your hot-patch command was unrecognized."); | |
| } | |
| } catch (e) { | |
| Rooms.global.notifyRooms( | |
| ["development", "staff"], | |
| `|c|${user2.getIdentity()}|/log ${user2.name} used /hotpatch ${target2} - but something failed while trying to hot-patch.` | |
| ); | |
| return this.errorReply(`Something failed while trying to hot-patch ${target2}: | |
| ${e.stack}`); | |
| } | |
| Rooms.global.notifyRooms( | |
| ["development", "staff"], | |
| `|c|${user2.getIdentity()}|/log ${user2.name} used /hotpatch ${target2}` | |
| ); | |
| }, | |
| hotpatchhelp: [ | |
| `Hot-patching the game engine allows you to update parts of Showdown without interrupting currently-running battles. Requires: console access`, | |
| `Hot-patching has greater memory requirements than restarting`, | |
| `You can disable various hot-patches with /nohotpatch. For more information on this, see /help nohotpatch`, | |
| `/hotpatch chat - reloads the chat-commands and chat-plugins directories`, | |
| `/hotpatch validator - spawn new team validator processes`, | |
| `/hotpatch formats - reload the sim/dex.ts tree, reload the formats list, and spawn new simulator and team validator processes`, | |
| `/hotpatch dnsbl - reloads IPTools datacenters`, | |
| `/hotpatch punishments - reloads new punishments code`, | |
| `/hotpatch loginserver - reloads new loginserver code`, | |
| `/hotpatch tournaments - reloads new tournaments code`, | |
| `/hotpatch modlog - reloads new modlog code`, | |
| `/hotpatch all - hot-patches chat, tournaments, formats, login server, punishments, modlog, and dnsbl`, | |
| `/forcehotpatch [target] - as above, but performs the update regardless of whether the history has changed in git` | |
| ], | |
| hotpatchlock: "nohotpatch", | |
| yeshotpatch: "nohotpatch", | |
| allowhotpatch: "nohotpatch", | |
| nohotpatch(target2, room2, user2, connection2, cmd) { | |
| this.checkCan("gdeclare"); | |
| if (!target2) | |
| return this.parse("/help nohotpatch"); | |
| const separator = " "; | |
| const hotpatch = toID(target2.substr(0, target2.indexOf(separator))); | |
| const reason = target2.substr(target2.indexOf(separator), target2.length).trim(); | |
| if (!reason || !target2.includes(separator)) | |
| return this.parse("/help nohotpatch"); | |
| const lock = Monitor.hotpatchLock; | |
| const validDisable = [ | |
| "roomsp", | |
| "usersp", | |
| "chat", | |
| "battles", | |
| "formats", | |
| "validator", | |
| "tournaments", | |
| "punishments", | |
| "modlog", | |
| "all", | |
| "processmanager" | |
| ]; | |
| if (!validDisable.includes(hotpatch)) { | |
| return this.errorReply(`Disabling hotpatching "${hotpatch}" is not supported.`); | |
| } | |
| const enable = ["allowhotpatch", "yeshotpatch"].includes(cmd); | |
| if (enable) { | |
| if (!lock[hotpatch]) | |
| return this.errorReply(`Hot-patching ${hotpatch} is not disabled.`); | |
| delete lock[hotpatch]; | |
| this.sendReply(`You have enabled hot-patching ${hotpatch}.`); | |
| } else { | |
| if (lock[hotpatch]) { | |
| return this.errorReply(`Hot-patching ${hotpatch} has already been disabled by ${lock[hotpatch].by} (${lock[hotpatch].reason})`); | |
| } | |
| lock[hotpatch] = { | |
| by: user2.name, | |
| reason | |
| }; | |
| this.sendReply(`You have disabled hot-patching ${hotpatch}.`); | |
| } | |
| Rooms.global.notifyRooms( | |
| ["development", "staff", "upperstaff"], | |
| `|c|${user2.getIdentity()}|/log ${user2.name} has ${enable ? "enabled" : "disabled"} hot-patching ${hotpatch}. Reason: ${reason}` | |
| ); | |
| }, | |
| nohotpatchhelp: [ | |
| `/nohotpatch [chat|formats|battles|validator|tournaments|punishments|modlog|all] [reason] - Disables hotpatching the specified part of the simulator. Requires: ~`, | |
| `/allowhotpatch [chat|formats|battles|validator|tournaments|punishments|modlog|all] [reason] - Enables hotpatching the specified part of the simulator. Requires: ~` | |
| ], | |
| async processes(target2, room2, user2) { | |
| if (!hasDevAuth(user2)) | |
| this.checkCan("lockdown"); | |
| const processes = /* @__PURE__ */ new Map(); | |
| const ramUnits = ["KiB", "MiB", "GiB", "TiB"]; | |
| const cwd = import_lib.FS.ROOT_PATH; | |
| await new Promise((resolve) => { | |
| const child = child_process.exec("ps -o pid,%cpu,time,rss,command", { cwd }, (err, stdout) => { | |
| if (err) | |
| throw err; | |
| const rows = stdout.split("\n").slice(1); | |
| for (const row of rows) { | |
| if (!row.trim()) | |
| continue; | |
| const [pid, cpu, time, ram, ...rest] = row.split(" ").filter(Boolean); | |
| if (pid === `${child.pid}`) | |
| continue; | |
| const entry = { cmd: rest.join(" ") }; | |
| if (time && !time.startsWith("0:00")) { | |
| entry.time = time; | |
| } | |
| if (cpu && cpu !== "0.0") | |
| entry.cpu = `${cpu}%`; | |
| const ramNum = parseInt(ram); | |
| if (!isNaN(ramNum)) { | |
| const unitIndex = Math.floor(Math.log2(ramNum) / 10); | |
| entry.ram = `${(ramNum / 2 ** (10 * unitIndex)).toFixed(2)} ${ramUnits[unitIndex]}`; | |
| } | |
| processes.set(pid, entry); | |
| } | |
| resolve(); | |
| }); | |
| }); | |
| let buf = `<strong>${process.pid}</strong> - Main `; | |
| const mainDisplay = []; | |
| const mainProcess = processes.get(`${process.pid}`); | |
| if (mainProcess.cpu) | |
| mainDisplay.push(`CPU ${mainProcess.cpu}`); | |
| if (mainProcess.time) | |
| mainDisplay.push(`time: ${mainProcess.time})`); | |
| if (mainProcess.ram) { | |
| mainDisplay.push(`RAM: ${mainProcess.ram}`); | |
| } | |
| if (mainDisplay.length) | |
| buf += ` (${mainDisplay.join(", ")})`; | |
| buf += `<br /><br /><strong>Process managers:</strong><br />`; | |
| processes.delete(`${process.pid}`); | |
| for (const manager of import_lib.ProcessManager.processManagers) { | |
| for (const [i, process2] of manager.processes.entries()) { | |
| const pid = process2.getProcess().pid; | |
| let managerName = manager.basename; | |
| if (managerName.startsWith("index.")) { | |
| managerName = manager.filename.split(path.sep).slice(-2).join(path.sep); | |
| } | |
| buf += `<strong>${pid}</strong> - ${managerName} ${i} (load ${process2.getLoad()}`; | |
| const info = processes.get(`${pid}`); | |
| const display = []; | |
| if (info.cpu) | |
| display.push(`CPU: ${info.cpu}`); | |
| if (info.time) | |
| display.push(`time: ${info.time}`); | |
| if (info.ram) | |
| display.push(`RAM: ${info.ram}`); | |
| if (display.length) | |
| buf += `, ${display.join(", ")})`; | |
| buf += `<br />`; | |
| processes.delete(`${pid}`); | |
| } | |
| for (const [i, process2] of manager.releasingProcesses.entries()) { | |
| const pid = process2.getProcess().pid; | |
| buf += `<strong>${pid}</strong> - PENDING RELEASE ${manager.basename} ${i} (load ${process2.getLoad()}`; | |
| const info = processes.get(`${pid}`); | |
| if (info) { | |
| const display = []; | |
| if (info.cpu) | |
| display.push(`CPU: ${info.cpu}`); | |
| if (info.time) | |
| display.push(`time: ${info.time}`); | |
| if (info.ram) | |
| display.push(`RAM: ${info.ram}`); | |
| if (display.length) | |
| buf += `, ${display.join(", ")})`; | |
| } | |
| buf += `<br />`; | |
| processes.delete(`${pid}`); | |
| } | |
| } | |
| buf += `<br />`; | |
| buf += `<details class="readmore"><summary><strong>Other processes:</strong></summary>`; | |
| for (const [pid, info] of processes) { | |
| buf += `<strong>${pid}</strong> - <code>${info.cmd}</code>`; | |
| const display = []; | |
| if (info.cpu) | |
| display.push(`CPU: ${info.cpu}`); | |
| if (info.time) | |
| display.push(`time: ${info.time}`); | |
| if (info.ram) | |
| display.push(`RAM: ${info.ram}`); | |
| if (display.length) | |
| buf += `(${display.join(", ")})`; | |
| buf += `<br />`; | |
| } | |
| buf += `</details>`; | |
| this.sendReplyBox(buf); | |
| }, | |
| processeshelp: [ | |
| `/processes - Get information about the running processes on the server. Requires: ~.` | |
| ], | |
| async savelearnsets(target2, room2, user2, connection2) { | |
| this.canUseConsole(); | |
| this.sendReply("saving..."); | |
| await (0, import_lib.FS)("data/learnsets.js").write(`'use strict'; | |
| exports.Learnsets = { | |
| ` + Object.entries(Dex.data.Learnsets).map(([id, entry]) => ` ${id}: {learnset: { | |
| ` + import_lib.Utils.sortBy( | |
| Object.entries(Dex.species.getLearnsetData(id).learnset), | |
| ([moveid]) => moveid | |
| ).map(([moveid, sources]) => ` ${moveid}: ["` + sources.join(`", "`) + `"], | |
| `).join("") + ` }}, | |
| `).join("") + `}; | |
| `); | |
| this.sendReply("learnsets.js saved."); | |
| }, | |
| savelearnsetshelp: [ | |
| `/savelearnsets - Saves the learnset list currently active on the server. Requires: ~` | |
| ], | |
| toggleripgrep(target2, room2, user2) { | |
| this.checkCan("rangeban"); | |
| Config.disableripgrep = !Config.disableripgrep; | |
| this.addGlobalModAction(`${user2.name} ${Config.disableripgrep ? "disabled" : "enabled"} Ripgrep-related functionality.`); | |
| }, | |
| toggleripgrephelp: [`/toggleripgrep - Disable/enable all functionality depending on Ripgrep. Requires: ~`], | |
| disablecommand(target2, room2, user2) { | |
| this.checkCan("makeroom"); | |
| if (!toID(target2)) { | |
| return this.parse(`/help disablecommand`); | |
| } | |
| if (["!", "/"].some((c) => target2.startsWith(c))) | |
| target2 = target2.slice(1); | |
| const parsed = Chat.parseCommand(`/${target2}`); | |
| if (!parsed) { | |
| return this.errorReply(`Command "/${target2}" is in an invalid format.`); | |
| } | |
| const { handler, fullCmd } = parsed; | |
| if (!handler) { | |
| return this.errorReply(`Command "/${target2}" not found.`); | |
| } | |
| if (handler.disabled) { | |
| return this.errorReply(`Command "/${target2}" is already disabled`); | |
| } | |
| handler.disabled = true; | |
| this.addGlobalModAction(`${user2.name} disabled the command /${fullCmd}.`); | |
| this.globalModlog(`DISABLECOMMAND`, null, target2); | |
| }, | |
| disablecommandhelp: [`/disablecommand [command] - Disables the given [command]. Requires: ~`], | |
| widendatacenters: "adddatacenters", | |
| adddatacenters() { | |
| this.errorReply("This command has been replaced by /datacenter add"); | |
| return this.parse("/help datacenters"); | |
| }, | |
| disableladder(target2, room2, user2) { | |
| this.checkCan("disableladder"); | |
| if (Ladders.disabled) { | |
| return this.errorReply(`/disableladder - Ladder is already disabled.`); | |
| } | |
| Ladders.disabled = true; | |
| this.modlog(`DISABLELADDER`); | |
| Monitor.log(`The ladder was disabled by ${user2.name}.`); | |
| const innerHTML = `<b>Due to technical difficulties, the ladder has been temporarily disabled.</b><br />Rated games will no longer update the ladder. It will be back momentarily.`; | |
| for (const curRoom of Rooms.rooms.values()) { | |
| if (curRoom.type === "battle") | |
| curRoom.rated = 0; | |
| curRoom.addRaw(`<div class="broadcast-red">${innerHTML}</div>`).update(); | |
| } | |
| for (const u of Users.users.values()) { | |
| if (u.connected) | |
| u.send(`|pm|~|${u.tempGroup}${u.name}|/raw <div class="broadcast-red">${innerHTML}</div>`); | |
| } | |
| }, | |
| disableladderhelp: [`/disableladder - Stops all rated battles from updating the ladder. Requires: ~`], | |
| enableladder(target2, room2, user2) { | |
| this.checkCan("disableladder"); | |
| if (!Ladders.disabled) { | |
| return this.errorReply(`/enable - Ladder is already enabled.`); | |
| } | |
| Ladders.disabled = false; | |
| this.modlog("ENABLELADDER"); | |
| Monitor.log(`The ladder was enabled by ${user2.name}.`); | |
| const innerHTML = `<b>The ladder is now back.</b><br />Rated games will update the ladder now..`; | |
| for (const curRoom of Rooms.rooms.values()) { | |
| curRoom.addRaw(`<div class="broadcast-green">${innerHTML}</div>`).update(); | |
| } | |
| for (const u of Users.users.values()) { | |
| if (u.connected) | |
| u.send(`|pm|~|${u.tempGroup}${u.name}|/raw <div class="broadcast-green">${innerHTML}</div>`); | |
| } | |
| }, | |
| enableladderhelp: [`/enable - Allows all rated games to update the ladder. Requires: ~`], | |
| lockdown(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| const disabledCommands = Chat.allCommands().filter((c) => c.disabled).map((c) => `/${c.fullCmd}`); | |
| if (disabledCommands.length) { | |
| this.sendReply(`${Chat.count(disabledCommands.length, "commands")} are disabled right now.`); | |
| this.sendReply(`Be aware that restarting will re-enable them.`); | |
| this.sendReply(`Currently disabled: ${disabledCommands.join(", ")}`); | |
| } | |
| Rooms.global.startLockdown(); | |
| this.stafflog(`${user2.name} used /lockdown`); | |
| }, | |
| lockdownhelp: [ | |
| `/lockdown - locks down the server, which prevents new battles from starting so that the server can eventually be restarted. Requires: ~` | |
| ], | |
| autolockdown: "autolockdownkill", | |
| autolockdownkill(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| if (Config.autolockdown === void 0) | |
| Config.autolockdown = true; | |
| if (this.meansYes(target2)) { | |
| if (Config.autolockdown) { | |
| return this.errorReply("The server is already set to automatically kill itself upon the final battle finishing."); | |
| } | |
| Config.autolockdown = true; | |
| this.privateGlobalModAction(`${user2.name} used /autolockdownkill on (autokill on final battle finishing)`); | |
| } else if (this.meansNo(target2)) { | |
| if (!Config.autolockdown) { | |
| return this.errorReply("The server is already set to not automatically kill itself upon the final battle finishing."); | |
| } | |
| Config.autolockdown = false; | |
| this.privateGlobalModAction(`${user2.name} used /autolockdownkill off (no autokill on final battle finishing)`); | |
| } else { | |
| return this.parse("/help autolockdownkill"); | |
| } | |
| }, | |
| autolockdownkillhelp: [ | |
| `/autolockdownkill on - Turns on the setting to enable the server to automatically kill itself upon the final battle finishing. Requires ~`, | |
| `/autolockdownkill off - Turns off the setting to enable the server to automatically kill itself upon the final battle finishing. Requires ~` | |
| ], | |
| prelockdown(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| Rooms.global.lockdown = "pre"; | |
| this.privateGlobalModAction(`${user2.name} used /prelockdown (disabled tournaments in preparation for server restart)`); | |
| }, | |
| prelockdownhelp: [`/prelockdown - Prevents new tournaments from starting so that the server can be restarted. Requires: ~`], | |
| slowlockdown(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| Rooms.global.startLockdown(void 0, true); | |
| this.privateGlobalModAction(`${user2.name} used /slowlockdown (lockdown without auto-restart)`); | |
| }, | |
| slowlockdownhelp: [ | |
| `/slowlockdown - Locks down the server, but disables the automatic restart after all battles end.`, | |
| `Requires: ~` | |
| ], | |
| crashfixed: "endlockdown", | |
| endlockdown(target2, room2, user2, connection2, cmd) { | |
| this.checkCan("lockdown"); | |
| if (!Rooms.global.lockdown) { | |
| return this.errorReply("We're not under lockdown right now."); | |
| } | |
| if (Rooms.global.lockdown !== true && cmd === "crashfixed") { | |
| return this.errorReply("/crashfixed - There is no active crash."); | |
| } | |
| const message = cmd === "crashfixed" ? `<div class="broadcast-green"><b>We fixed the crash without restarting the server!</b></div>` : `<div class="broadcast-green"><b>The server restart was canceled.</b></div>`; | |
| if (Rooms.global.lockdown === true) { | |
| for (const curRoom of Rooms.rooms.values()) { | |
| curRoom.addRaw(message).update(); | |
| } | |
| for (const curUser of Users.users.values()) { | |
| curUser.send(`|pm|~|${curUser.tempGroup}${curUser.name}|/raw ${message}`); | |
| } | |
| } else { | |
| this.sendReply("Preparation for the server shutdown was canceled."); | |
| } | |
| Rooms.global.lockdown = false; | |
| this.stafflog(`${user2.name} used /endlockdown`); | |
| }, | |
| endlockdownhelp: [ | |
| `/endlockdown - Cancels the server restart and takes the server out of lockdown state. Requires: ~`, | |
| `/crashfixed - Ends the active lockdown caused by a crash without the need of a restart. Requires: ~` | |
| ], | |
| emergency(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| if (Config.emergency) { | |
| return this.errorReply("We're already in emergency mode."); | |
| } | |
| Config.emergency = true; | |
| for (const curRoom of Rooms.rooms.values()) { | |
| curRoom.addRaw(`<div class="broadcast-red">The server has entered emergency mode. Some features might be disabled or limited.</div>`).update(); | |
| } | |
| this.stafflog(`${user2.name} used /emergency.`); | |
| }, | |
| emergencyhelp: [ | |
| `/emergency - Turns on emergency mode and enables extra logging. Requires: ~` | |
| ], | |
| endemergency(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| if (!Config.emergency) { | |
| return this.errorReply("We're not in emergency mode."); | |
| } | |
| Config.emergency = false; | |
| for (const curRoom of Rooms.rooms.values()) { | |
| curRoom.addRaw(`<div class="broadcast-green"><b>The server is no longer in emergency mode.</b></div>`).update(); | |
| } | |
| this.stafflog(`${user2.name} used /endemergency.`); | |
| }, | |
| endemergencyhelp: [ | |
| `/endemergency - Turns off emergency mode. Requires: ~` | |
| ], | |
| remainingbattles() { | |
| this.checkCan("lockdown"); | |
| if (!Rooms.global.lockdown) { | |
| return this.errorReply("The server is not under lockdown right now."); | |
| } | |
| const battleRooms = [...Rooms.rooms.values()].filter((x) => x.battle?.rated && !x.battle?.ended); | |
| let buf = `Total remaining rated battles: <b>${battleRooms.length}</b>`; | |
| if (battleRooms.length > 10) | |
| buf += `<details><summary>View all battles</summary>`; | |
| for (const battle2 of battleRooms) { | |
| buf += `<br />`; | |
| buf += `<a href="${battle2.roomid}">${battle2.title}</a>`; | |
| if (battle2.settings.isPrivate) | |
| buf += " (Private)"; | |
| } | |
| if (battleRooms.length > 10) | |
| buf += `</details>`; | |
| this.sendReplyBox(buf); | |
| }, | |
| remainingbattleshelp: [ | |
| `/remainingbattles - View a list of the remaining battles during lockdown. Requires: ~` | |
| ], | |
| async savebattles(target2, room2, user2) { | |
| this.checkCan("rangeban"); | |
| this.sendReply(`Saving battles...`); | |
| const count = await Rooms.global.saveBattles(); | |
| this.sendReply(`DONE.`); | |
| this.sendReply(`${count} battles saved.`); | |
| this.addModAction(`${user2.name} used /savebattles`); | |
| }, | |
| async kill(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| let noSave = toID(target2) === "nosave"; | |
| if (!Config.usepostgres) | |
| noSave = true; | |
| if (Rooms.global.lockdown !== true && noSave) { | |
| return this.errorReply("For safety reasons, using /kill without saving battles can only be done during lockdown."); | |
| } | |
| if (Monitor.updateServerLock) { | |
| return this.errorReply("Wait for /updateserver to finish before using /kill."); | |
| } | |
| if (!noSave) { | |
| this.sendReply("Saving battles..."); | |
| Rooms.global.lockdown = true; | |
| for (const u of Users.users.values()) { | |
| u.send( | |
| `|pm|~|${u.getIdentity()}|/raw <div class="broadcast-red"><b>The server is restarting soon.</b><br />While battles are being saved, no more can be started. If you're in a battle, it will be paused during saving.<br />After the restart, you will be able to resume your battles from where you left off.` | |
| ); | |
| } | |
| const count = await Rooms.global.saveBattles(); | |
| this.sendReply(`DONE.`); | |
| this.sendReply(`${count} battles saved.`); | |
| } | |
| const logRoom2 = Rooms.get("staff") || Rooms.lobby || room2; | |
| if (!logRoom2?.log.roomlogStream) | |
| return process.exit(); | |
| logRoom2.roomlog(`${user2.name} used /kill`); | |
| void logRoom2.log.roomlogStream.writeEnd().then(() => { | |
| process.exit(); | |
| }); | |
| setTimeout(() => { | |
| process.exit(); | |
| }, 1e4); | |
| }, | |
| killhelp: [ | |
| `/kill - kills the server. Use the argument \`nosave\` to prevent the saving of battles.`, | |
| ` If this argument is used, the server must be in lockdown. Requires: ~` | |
| ], | |
| loadbanlist(target2, room2, user2, connection2) { | |
| this.checkCan("lockdown"); | |
| connection2.sendTo(room2, "Loading ipbans.txt..."); | |
| Punishments.loadBanlist().then( | |
| () => connection2.sendTo(room2, "ipbans.txt has been reloaded."), | |
| (error) => connection2.sendTo(room2, `Something went wrong while loading ipbans.txt: ${error}`) | |
| ); | |
| }, | |
| loadbanlisthelp: [ | |
| `/loadbanlist - Loads the bans located at ipbans.txt. The command is executed automatically at startup. Requires: ~` | |
| ], | |
| refreshpage(target2, room2, user2) { | |
| this.checkCan("lockdown"); | |
| if (user2.lastCommand !== "refreshpage") { | |
| user2.lastCommand = "refreshpage"; | |
| this.errorReply(`Are you sure you wish to refresh the page for every user online?`); | |
| return this.errorReply(`If you are sure, please type /refreshpage again to confirm.`); | |
| } | |
| Rooms.global.sendAll("|refresh|"); | |
| this.stafflog(`${user2.name} used /refreshpage`); | |
| }, | |
| refreshpagehelp: [ | |
| `/refreshpage - refreshes the page for every user online. Requires: ~` | |
| ], | |
| async updateserver(target2, room2, user2, connection2) { | |
| this.canUseConsole(); | |
| if (Monitor.updateServerLock) { | |
| return this.errorReply(`/updateserver - Another update is already in progress (or a previous update crashed).`); | |
| } | |
| const validPrivateCodePath = Config.privatecodepath && path.isAbsolute(Config.privatecodepath); | |
| target2 = toID(target2); | |
| Monitor.updateServerLock = true; | |
| let success = true; | |
| if (target2 === "private") { | |
| if (!validPrivateCodePath) { | |
| Monitor.updateServerLock = false; | |
| throw new Chat.ErrorMessage("`Config.privatecodepath` must be set to an absolute path before using /updateserver private."); | |
| } | |
| success = await updateserver(this, Config.privatecodepath); | |
| this.addGlobalModAction(`${user2.name} used /updateserver private`); | |
| } else { | |
| if (target2 !== "public" && validPrivateCodePath) { | |
| success = await updateserver(this, Config.privatecodepath); | |
| } | |
| success = success && await updateserver(this, import_lib.FS.ROOT_PATH); | |
| this.addGlobalModAction(`${user2.name} used /updateserver${target2 === "public" ? " public" : ""}`); | |
| } | |
| this.sendReply(success ? `DONE` : `FAILED, old changes restored.`); | |
| Monitor.updateServerLock = false; | |
| }, | |
| updateserverhelp: [ | |
| `/updateserver - Updates the server's code from its Git repository, including private code if present. Requires: console access`, | |
| `/updateserver private - Updates only the server's private code. Requires: console access` | |
| ], | |
| async updateloginserver(target2, room2, user2) { | |
| this.canUseConsole(); | |
| this.sendReply("Restarting..."); | |
| const [result2, err] = await LoginServer.request("restart"); | |
| if (err) { | |
| Rooms.global.notifyRooms( | |
| ["staff", "development"], | |
| `|c|${user2.getIdentity()}|/log ${user2.name} used /updateloginserver - but something failed while updating.` | |
| ); | |
| return this.errorReply(`${err.message} | |
| ${err.stack}`); | |
| } | |
| if (!result2) | |
| return this.errorReply("No result received."); | |
| this.stafflog(`[o] ${result2.success || ""} [e] ${result2.actionerror || ""}`); | |
| if (result2.actionerror) { | |
| return this.errorReply(result2.actionerror); | |
| } | |
| let message = `${user2.name} used /updateloginserver`; | |
| if (result2.updated) { | |
| this.sendReply(`DONE. Server updated and restarted.`); | |
| } else { | |
| message += ` - but something failed while updating.`; | |
| this.errorReply(`FAILED. Conflicts were found while updating - the restart was aborted.`); | |
| } | |
| Rooms.global.notifyRooms( | |
| ["staff", "development"], | |
| `|c|${user2.getIdentity()}|/log ${message}` | |
| ); | |
| }, | |
| updateloginserverhelp: [ | |
| `/updateloginserver - Updates and restarts the loginserver. Requires: console access` | |
| ], | |
| async updateclient(target2, room2, user2) { | |
| this.canUseConsole(); | |
| this.sendReply("Restarting..."); | |
| const [result2, err] = await LoginServer.request("rebuildclient", { | |
| full: toID(target2) === "full" | |
| }); | |
| if (err) { | |
| Rooms.global.notifyRooms( | |
| ["staff", "development"], | |
| `|c|${user2.getIdentity()}|/log ${user2.name} used /updateclient - but something failed while updating.` | |
| ); | |
| return this.errorReply(`${err.message} | |
| ${err.stack}`); | |
| } | |
| if (!result2) | |
| return this.errorReply("No result received."); | |
| this.stafflog(`[o] ${result2.success || ""} [e] ${result2.actionerror || ""}`); | |
| if (result2.actionerror) { | |
| return this.errorReply(result2.actionerror); | |
| } | |
| let message = `${user2.name} used /updateclient`; | |
| if (result2.updated) { | |
| this.sendReply(`DONE. Client updated.`); | |
| } else { | |
| message += ` - but something failed while updating.`; | |
| this.errorReply(`FAILED. Conflicts were found while updating.`); | |
| } | |
| Rooms.global.notifyRooms( | |
| ["staff", "development"], | |
| `|c|${user2.getIdentity()}|/log ${message}` | |
| ); | |
| }, | |
| updateclienthelp: [ | |
| `/updateclient [full] - Update the client source code. Provide the argument 'full' to make it a full rebuild.`, | |
| `Requires: ~ console access` | |
| ], | |
| async rebuild() { | |
| this.canUseConsole(); | |
| const [, , stderr] = await bash("node ./build", this); | |
| if (stderr) { | |
| throw new Chat.ErrorMessage(`Crash while rebuilding: ${stderr}`); | |
| } | |
| this.sendReply("Rebuilt."); | |
| }, | |
| /********************************************************* | |
| * Low-level administration commands | |
| *********************************************************/ | |
| async bash(target2, room2, user2, connection2) { | |
| this.canUseConsole(); | |
| if (!target2) | |
| return this.parse("/help bash"); | |
| this.sendReply(`$ ${target2}`); | |
| const [, stdout, stderr] = await bash(target2, this); | |
| this.runBroadcast(); | |
| this.sendReply(`${stdout}${stderr}`); | |
| }, | |
| bashhelp: [`/bash [command] - Executes a bash command on the server. Requires: ~ console access`], | |
| async eval(target, room, user, connection) { | |
| this.canUseConsole(); | |
| if (!this.runBroadcast(true)) | |
| return; | |
| const logRoom = Rooms.get("upperstaff") || Rooms.get("staff"); | |
| if (this.message.startsWith(">>") && room) { | |
| this.broadcasting = true; | |
| this.broadcastToRoom = true; | |
| } | |
| const generateHTML = (direction, contents) => `<table border="0" cellspacing="0" cellpadding="0"><tr><td valign="top">` + import_lib.Utils.escapeHTML(direction).repeat(2) + ` </td><td>${Chat.getReadmoreCodeBlock(contents)}</td></tr><table>`; | |
| this.sendReply(`|html|${generateHTML(">", target)}`); | |
| logRoom?.roomlog(`>> ${target}`); | |
| let uhtmlId = null; | |
| try { | |
| const battle = room?.battle; | |
| const me = user; | |
| let result = eval(target); | |
| if (result?.then) { | |
| uhtmlId = `eval-${Date.now().toString().slice(-6)}-${Math.random().toFixed(6).slice(-6)}`; | |
| this.sendReply(`|uhtml|${uhtmlId}|${generateHTML("<", "Promise pending")}`); | |
| this.update(); | |
| result = `Promise -> ${import_lib.Utils.visualize(await result)}`; | |
| this.sendReply(`|uhtmlchange|${uhtmlId}|${generateHTML("<", result)}`); | |
| } else { | |
| result = import_lib.Utils.visualize(result); | |
| this.sendReply(`|html|${generateHTML("<", result)}`); | |
| } | |
| logRoom?.roomlog(`<< ${result}`); | |
| } catch (e) { | |
| const message = `${e.stack}`.replace(/\n *at CommandContext\.eval [\s\S]*/m, ""); | |
| const command = uhtmlId ? `|uhtmlchange|${uhtmlId}|` : "|html|"; | |
| this.sendReply(`${command}${generateHTML("<", message)}`); | |
| logRoom?.roomlog(`<< ${message}`); | |
| } | |
| }, | |
| evalhelp: [ | |
| `/eval [code] - Evaluates the code given and shows results. Requires: ~ console access.` | |
| ], | |
| async evalsql(target2, room2) { | |
| this.canUseConsole(); | |
| this.runBroadcast(true); | |
| if (!Config.usesqlite) | |
| return this.errorReply(`SQLite is disabled.`); | |
| const logRoom2 = Rooms.get("upperstaff") || Rooms.get("staff"); | |
| if (!target2) | |
| return this.errorReply(`Specify a database to access and a query.`); | |
| const [db, query] = import_lib.Utils.splitFirst(target2, ",").map((item) => item.trim()); | |
| if (!(0, import_lib.FS)("./databases").readdirSync().includes(`${db}.db`)) { | |
| return this.errorReply(`The database file ${db}.db was not found.`); | |
| } | |
| if (room2 && this.message.startsWith(">>sql")) { | |
| this.broadcasting = true; | |
| this.broadcastToRoom = true; | |
| } | |
| this.sendReply( | |
| `|html|<table border="0" cellspacing="0" cellpadding="0"><tr><td valign="top">SQLite> [${db}.db] </td><td>${Chat.getReadmoreCodeBlock(query)}</td></tr><table>` | |
| ); | |
| logRoom2?.roomlog(`SQLite> ${target2}`); | |
| const database = (0, import_lib.SQL)(module, { | |
| file: `./databases/${db}.db`, | |
| onError(err) { | |
| return { err: err.message, stack: err.stack }; | |
| } | |
| }); | |
| function formatResult(result3) { | |
| if (!Array.isArray(result3)) { | |
| return `<table border="0" cellspacing="0" cellpadding="0"><tr><td valign="top">SQLite< </td><td>${Chat.getReadmoreCodeBlock(result3)}</td></tr><table>`; | |
| } | |
| let buffer = '<div class="ladder pad" style="overflow-x: auto;"><table><tr><th>'; | |
| if (!result3.length) { | |
| buffer += `No data in table.</th></tr>`; | |
| return buffer; | |
| } | |
| buffer += Object.keys(result3[0]).join("</th><th>"); | |
| buffer += `</th></tr><tr>`; | |
| buffer += result3.map((item) => `<td>${Object.values(item).map((val) => import_lib.Utils.escapeHTML(val)).join("</td><td>")}</td>`).join("</tr><tr>"); | |
| buffer += `</tr></table></div>`; | |
| return buffer; | |
| } | |
| function parseError(res) { | |
| const err = new Error(res.err); | |
| err.stack = res.stack; | |
| throw err; | |
| } | |
| let result2; | |
| try { | |
| result2 = await database.all(query, []); | |
| if (result2.err) | |
| parseError(result2); | |
| } catch (err) { | |
| if (err.stack?.includes(`Use run() instead`)) { | |
| try { | |
| result2 = await database.run(query, []); | |
| if (result2.err) | |
| parseError(result2); | |
| result2 = import_lib.Utils.visualize(result2); | |
| } catch (e) { | |
| result2 = `${e.stack}`.replace(/\n *at CommandContext\.evalsql [\s\S]*/m, ""); | |
| } | |
| } else { | |
| result2 = `${err.stack}`.replace(/\n *at CommandContext\.evalsql [\s\S]*/m, ""); | |
| } | |
| } | |
| await database.destroy(); | |
| const formattedResult = `|html|${formatResult(result2)}`; | |
| logRoom2?.roomlog(formattedResult); | |
| this.sendReply(formattedResult); | |
| }, | |
| evalsqlhelp: [ | |
| `/evalsql [database], [query] - Evaluates the given SQL [query] in the given [database].`, | |
| `Requires: ~ console access` | |
| ], | |
| evalbattle(target2, room2, user2, connection2) { | |
| room2 = this.requireRoom(); | |
| this.canUseConsole(); | |
| if (!this.runBroadcast(true)) | |
| return; | |
| if (!room2.battle) { | |
| return this.errorReply("/evalbattle - This isn't a battle room."); | |
| } | |
| void room2.battle.stream.write(`>eval ${target2.replace(/\n/g, "\f")}`); | |
| }, | |
| evalbattlehelp: [ | |
| `/evalbattle [code] - Evaluates the code in the battle stream of the current room. Requires: ~ console access.` | |
| ], | |
| ebat: "editbattle", | |
| editbattle(target2, room2, user2) { | |
| room2 = this.requireRoom(); | |
| this.checkCan("forcewin"); | |
| if (!target2) | |
| return this.parse("/help editbattle"); | |
| if (!room2.battle) { | |
| this.errorReply("/editbattle - This is not a battle room."); | |
| return false; | |
| } | |
| const battle2 = room2.battle; | |
| let cmd; | |
| [cmd, target2] = import_lib.Utils.splitFirst(target2, " "); | |
| if (cmd.endsWith(",")) | |
| cmd = cmd.slice(0, -1); | |
| const targets = target2.split(","); | |
| if (targets.length === 1 && targets[0] === "") | |
| targets.pop(); | |
| let player, pokemon, move, stat, value; | |
| switch (cmd) { | |
| case "hp": | |
| case "h": | |
| if (targets.length !== 3) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, pokemon, value] = targets.map((f) => f.trim()); | |
| [player, pokemon] = [player, pokemon].map(toID); | |
| void battle2.stream.write( | |
| `>eval let p=pokemon('${player}', '${pokemon}');p.sethp(${parseInt(value)});if (p.isActive)battle.add('-damage',p,p.getHealth);` | |
| ); | |
| break; | |
| case "status": | |
| case "s": | |
| if (targets.length !== 3) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, pokemon, value] = targets.map(toID); | |
| void battle2.stream.write( | |
| `>eval let pl=player('${player}');let p=pokemon(pl,'${pokemon}');p.setStatus('${value}');if (!p.isActive){battle.add('','please ignore the above');battle.add('-status',pl.active[0],pl.active[0].status,'[silent]');}` | |
| ); | |
| break; | |
| case "pp": | |
| if (targets.length !== 4) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, pokemon, move, value] = targets.map((f) => f.trim()); | |
| [player, pokemon, move] = [player, pokemon, move].map(toID); | |
| void battle2.stream.write( | |
| `>eval pokemon('${player}','${pokemon}').getMoveData('${move}').pp = ${parseInt(value)};` | |
| ); | |
| break; | |
| case "boost": | |
| case "b": | |
| if (targets.length !== 4) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, pokemon, stat, value] = targets.map((f) => f.trim()); | |
| [player, pokemon, stat] = [player, pokemon, stat].map(toID); | |
| void battle2.stream.write( | |
| `>eval let p=pokemon('${player}','${pokemon}');battle.boost({${stat}:${parseInt(value)}},p)` | |
| ); | |
| break; | |
| case "volatile": | |
| case "v": | |
| if (targets.length !== 3) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, pokemon, value] = targets.map(toID); | |
| void battle2.stream.write( | |
| `>eval pokemon('${player}','${pokemon}').addVolatile('${value}')` | |
| ); | |
| break; | |
| case "sidecondition": | |
| case "sc": | |
| if (targets.length !== 2) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [player, value] = targets.map(toID); | |
| void battle2.stream.write(`>eval player('${player}').addSideCondition('${value}', 'debug')`); | |
| break; | |
| case "fieldcondition": | |
| case "pseudoweather": | |
| case "fc": | |
| if (targets.length !== 1) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [value] = targets.map(toID); | |
| void battle2.stream.write(`>eval battle.field.addPseudoWeather('${value}', 'debug')`); | |
| break; | |
| case "weather": | |
| case "w": | |
| if (targets.length !== 1) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [value] = targets.map(toID); | |
| void battle2.stream.write(`>eval battle.field.setWeather('${value}', 'debug')`); | |
| break; | |
| case "terrain": | |
| case "t": | |
| if (targets.length !== 1) { | |
| this.errorReply("Incorrect command use"); | |
| return this.parse("/help editbattle"); | |
| } | |
| [value] = targets.map(toID); | |
| void battle2.stream.write(`>eval battle.field.setTerrain('${value}', 'debug')`); | |
| break; | |
| case "reseed": | |
| if (targets.length !== 0) { | |
| if (targets.length !== 4) { | |
| this.errorReply("Seed must have 4 parts"); | |
| return this.parse("/help editbattle"); | |
| } | |
| if (!targets.every((val) => /^[0-9]{1,5}$/.test(val))) { | |
| this.errorReply("Seed parts much be unsigned 16-bit integers"); | |
| return this.parse("/help editbattle"); | |
| } | |
| } | |
| void battle2.stream.write(`>reseed ${targets.join(",")}`); | |
| if (targets.length) | |
| this.sendReply(`Reseeded to ${targets.join(",")}`); | |
| break; | |
| default: | |
| this.errorReply(`Unknown editbattle command: ${cmd}`); | |
| return this.parse("/help editbattle"); | |
| } | |
| }, | |
| editbattlehelp: [ | |
| `/editbattle hp [player], [pokemon], [hp]`, | |
| `/editbattle status [player], [pokemon], [status]`, | |
| `/editbattle pp [player], [pokemon], [move], [pp]`, | |
| `/editbattle boost [player], [pokemon], [stat], [amount]`, | |
| `/editbattle volatile [player], [pokemon], [volatile]`, | |
| `/editbattle sidecondition [player], [sidecondition]`, | |
| `/editbattle fieldcondition [fieldcondition]`, | |
| `/editbattle weather [weather]`, | |
| `/editbattle terrain [terrain]`, | |
| `/editbattle reseed [optional seed]`, | |
| `Short forms: /ebat h OR s OR pp OR b OR v OR sc OR fc OR w OR t`, | |
| `[player] must be a username or number, [pokemon] must be species name or party slot number (not nickname), [move] must be move name.` | |
| ] | |
| }; | |
| const pages = { | |
| bot(args, user2, connection2) { | |
| const [botid, ...pageArgs] = args; | |
| const pageid = pageArgs.join("-"); | |
| if (pageid.length > 300) { | |
| return this.errorReply(`The page ID specified is too long.`); | |
| } | |
| const bot = Users.get(botid); | |
| if (!bot) { | |
| return `<div class="pad"><h2>The bot "${bot}" is not available.</h2></div>`; | |
| } | |
| let canSend = Users.globalAuth.get(bot) === "*"; | |
| let room2; | |
| for (const curRoom of Rooms.global.chatRooms) { | |
| if (["*", "#"].includes(curRoom.auth.getDirect(bot.id))) { | |
| canSend = true; | |
| room2 = curRoom; | |
| } | |
| } | |
| if (!canSend) { | |
| return `<div class="pad"><h2>"${bot}" is not a bot.</h2></div>`; | |
| } | |
| connection2.lastRequestedPage = `${bot.id}-${pageid}`; | |
| bot.sendTo( | |
| room2 ? room2.roomid : "lobby", | |
| `|pm|${user2.getIdentity()}|${bot.getIdentity()}||requestpage|${user2.name}|${pageid}` | |
| ); | |
| } | |
| }; | |
| //# sourceMappingURL=admin.js.map | |