commands/settings/EvalCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { SlashCommandBuilder, escapeCodeBlock, escapeMarkdown } from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { logError } from "../../utils/Logger";

export default class EvalCommand extends Command {
    public readonly name = "eval";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.StringRest],
            optional: false,
            name: "code",
            errors: {
                required: "You must provide expression(s) to evaluate!"
            }
        }
    ];
    public readonly systemAdminOnly = true;
    public errorOccurred: boolean = false;

    public readonly description = "Execute JavaScript code.";
    public readonly detailedDescription = "This command executes arbitrary JavaScript code. Must be used with caution.";
    public readonly argumentSyntaxes = ["<...Code>"];

    public readonly botRequiredPermissions = [];

    public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
        option.setName("code").setDescription("The code to execute").setRequired(true)
    );

    createUncaughtExecptionHandler(message: CommandMessage) {
        return (e: Error) => {
            this.errorOccurred = true;
            logError(e);

            this.deferredReply(message, {
                embeds: [
                    {
                        description: `${this.emoji("error")} **Exception occurred**\n\n\`\`\`\n${escapeMarkdown(
                            e.message + "\n" + e.stack
                        )}\n\`\`\``,
                        color: 0xf14a60
                    }
                ]
            }).catch(logError);
        };
    }

    createUnhandledRejection(message: CommandMessage) {
        return (e: unknown) => {
            this.errorOccurred = true;
            logError(e);

            this.deferredReply(message, {
                embeds: [
                    {
                        description: `${this.emoji("error")} **Unhandled promise rejection**\n\n\`\`\`\n${
                            typeof e === "string" || typeof (e as string)?.toString === "function"
                                ? escapeCodeBlock((e as string)?.toString ? (e as string).toString() : (e as string))
                                : e
                        }\n\`\`\``,
                        color: 0xf14a60
                    }
                ]
            }).catch(logError);
        };
    }

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        this.errorOccurred = false;

        const code = context.isLegacy ? context.parsedNamedArgs.code : context.options.getString("code", true);
        await this.deferIfInteraction(message);

        const exceptionHandler = this.createUncaughtExecptionHandler(message);
        const rejectionHandler = this.createUnhandledRejection(message);

        process.on("uncaughtExceptionMonitor", exceptionHandler);
        process.on("unhandledRejection", rejectionHandler);

        try {
            const result = eval(code);
            const string = `${
                typeof result === "string" || typeof result?.toString === "function"
                    ? escapeCodeBlock((result as string)?.toString ? (result as string).toString() : (result as string))
                    : result
            }`;

            if (!this.errorOccurred) {
                await this.deferredReply(message, {
                    embeds: [
                        {
                            description: `${this.emoji("check")} **Execution succeeded**\n\n${
                                string.trim() === "" ? "*No output*" : `\`\`\`${string}\`\`\``
                            }`,
                            color: 0x007bff
                        }
                    ]
                });
            }
        } catch (e) {
            logError("Evaluation failed");
            if ("stack" in (e as Error) && "message" in (e as Error)) exceptionHandler(e as Error);
            else rejectionHandler(e);
        }

        process.off("uncaughtExceptionMonitor", exceptionHandler);
        process.off("unhandledRejection", rejectionHandler);
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import { SlashCommandBuilder, escapeCodeBlock, escapeMarkdown } from "discord.js";
21	import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22	import { logError } from "../../utils/Logger";
23
24	export default class EvalCommand extends Command {
25	public readonly name = "eval";
26	public readonly validationRules: ValidationRule[] = [
27	{
28	types: [ArgumentType.StringRest],
29	optional: false,
30	name: "code",
31	errors: {
32	required: "You must provide expression(s) to evaluate!"
33	}
34	}
35	];
36	public readonly systemAdminOnly = true;
37	public errorOccurred: boolean = false;
38
39	public readonly description = "Execute JavaScript code.";
40	public readonly detailedDescription = "This command executes arbitrary JavaScript code. Must be used with caution.";
41	public readonly argumentSyntaxes = ["<...Code>"];
42
43	public readonly botRequiredPermissions = [];
44
45	public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
46	option.setName("code").setDescription("The code to execute").setRequired(true)
47	);
48
49	createUncaughtExecptionHandler(message: CommandMessage) {
50	return (e: Error) => {
51	this.errorOccurred = true;
52	logError(e);
53
54	this.deferredReply(message, {
55	embeds: [
56	{
57	description: `${this.emoji("error")} Exception occurred\n\n\`\`\`\n${escapeMarkdown(
58	e.message + "\n" + e.stack
59	)}\n\`\`\``,
60	color: 0xf14a60
61	}
62	]
63	}).catch(logError);
64	};
65	}
66
67	createUnhandledRejection(message: CommandMessage) {
68	return (e: unknown) => {
69	this.errorOccurred = true;
70	logError(e);
71
72	this.deferredReply(message, {
73	embeds: [
74	{
75	description: `${this.emoji("error")} Unhandled promise rejection\n\n\`\`\`\n${
76	typeof e === "string" \|\| typeof (e as string)?.toString === "function"
77	? escapeCodeBlock((e as string)?.toString ? (e as string).toString() : (e as string))
78	: e
79	}\n\`\`\``,
80	color: 0xf14a60
81	}
82	]
83	}).catch(logError);
84	};
85	}
86
87	async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
88	this.errorOccurred = false;
89
90	const code = context.isLegacy ? context.parsedNamedArgs.code : context.options.getString("code", true);
91	await this.deferIfInteraction(message);
92
93	const exceptionHandler = this.createUncaughtExecptionHandler(message);
94	const rejectionHandler = this.createUnhandledRejection(message);
95
96	process.on("uncaughtExceptionMonitor", exceptionHandler);
97	process.on("unhandledRejection", rejectionHandler);
98
99	try {
100	const result = eval(code);
101	const string = `${
102	typeof result === "string" \|\| typeof result?.toString === "function"
103	? escapeCodeBlock((result as string)?.toString ? (result as string).toString() : (result as string))
104	: result
105	}`;
106
107	if (!this.errorOccurred) {
108	await this.deferredReply(message, {
109	embeds: [
110	{
111	description: `${this.emoji("check")} Execution succeeded\n\n${
112	string.trim() === "" ? "No output" : `\`\`\`${string}\`\`\``
113	}`,
114	color: 0x007bff
115	}
116	]
117	});
118	}
119	} catch (e) {
120	logError("Evaluation failed");
121	if ("stack" in (e as Error) && "message" in (e as Error)) exceptionHandler(e as Error);
122	else rejectionHandler(e);
123	}
124
125	process.off("uncaughtExceptionMonitor", exceptionHandler);
126	process.off("unhandledRejection", rejectionHandler);
127	}
128	}