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",
            requiredErrorMessage: "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 any)?.toString === "function"
                                ? escapeCodeBlock((e as any)?.toString ? (e as any).toString() : (e as any))
                                : 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 any)?.toString ? (result as any).toString() : (result as any))
                    : 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");
            logError(e);

            if ("stack" in (e as any) && "message" in (e as any)) exceptionHandler(e as any);
            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	requiredErrorMessage: "You must provide expression(s) to evaluate!"
32	}
33	];
34	public readonly systemAdminOnly = true;
35	public errorOccurred: boolean = false;
36
37	public readonly description = "Execute JavaScript code.";
38	public readonly detailedDescription = "This command executes arbitrary JavaScript code. Must be used with caution.";
39	public readonly argumentSyntaxes = ["<...Code>"];
40
41	public readonly botRequiredPermissions = [];
42
43	public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
44	option.setName("code").setDescription("The code to execute").setRequired(true)
45	);
46
47	createUncaughtExecptionHandler(message: CommandMessage) {
48	return (e: Error) => {
49	this.errorOccurred = true;
50	logError(e);
51
52	this.deferredReply(message, {
53	embeds: [
54	{
55	description: `${this.emoji("error")} Exception occurred\n\n\`\`\`\n${escapeMarkdown(
56	e.message + "\n" + e.stack
57	)}\n\`\`\``,
58	color: 0xf14a60
59	}
60	]
61	}).catch(logError);
62	};
63	}
64
65	createUnhandledRejection(message: CommandMessage) {
66	return (e: unknown) => {
67	this.errorOccurred = true;
68	logError(e);
69
70	this.deferredReply(message, {
71	embeds: [
72	{
73	description: `${this.emoji("error")} Unhandled promise rejection\n\n\`\`\`\n${
74	typeof e === "string" \|\| typeof (e as any)?.toString === "function"
75	? escapeCodeBlock((e as any)?.toString ? (e as any).toString() : (e as any))
76	: e
77	}\n\`\`\``,
78	color: 0xf14a60
79	}
80	]
81	}).catch(logError);
82	};
83	}
84
85	async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
86	this.errorOccurred = false;
87
88	const code = context.isLegacy ? context.parsedNamedArgs.code : context.options.getString("code", true);
89	await this.deferIfInteraction(message);
90
91	const exceptionHandler = this.createUncaughtExecptionHandler(message);
92	const rejectionHandler = this.createUnhandledRejection(message);
93
94	process.on("uncaughtExceptionMonitor", exceptionHandler);
95	process.on("unhandledRejection", rejectionHandler);
96
97	try {
98	const result = eval(code);
99	const string = `${
100	typeof result === "string" \|\| typeof result?.toString === "function"
101	? escapeCodeBlock((result as any)?.toString ? (result as any).toString() : (result as any))
102	: result
103	}`;
104
105	if (!this.errorOccurred) {
106	await this.deferredReply(message, {
107	embeds: [
108	{
109	description: `${this.emoji("check")} Execution succeeded\n\n${
110	string.trim() === "" ? "No output" : `\`\`\`${string}\`\`\``
111	}`,
112	color: 0x007bff
113	}
114	]
115	});
116	}
117	} catch (e) {
118	logError("Evaluation failed");
119	logError(e);
120
121	if ("stack" in (e as any) && "message" in (e as any)) exceptionHandler(e as any);
122	else rejectionHandler(e);
123	}
124
125	process.off("uncaughtExceptionMonitor", exceptionHandler);
126	process.off("unhandledRejection", rejectionHandler);
127	}
128	}