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 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");
            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	rakinar2	577	/**
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 any)?.toString === "function"
77			? escapeCodeBlock((e as any)?.toString ? (e as any).toString() : (e as any))
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 any)?.toString ? (result as any).toString() : (result as any))
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 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			}