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	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			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			}