src/services/CommandManager.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 {
    ChatInputCommandInteraction,
    ContextMenuCommandInteraction,
    InteractionReplyOptions,
    Message,
    Snowflake,
    User
} from "discord.js";
import { CommandAbortedError, CommandMessage } from "../core/Command";
import Service from "../core/Service";
import { log, logError, logWarn } from "../utils/Logger";
import { GuildConfig } from "./ConfigManager";

export const name = "commandManager";

export interface CommandContext {
    isLegacy: boolean;
    config: GuildConfig;
}

export interface LegacyCommandContext extends CommandContext {
    isLegacy: true;
    isContextMenu: false;
    argv: string[];
    args: string[];
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    parsedArgs: any[];
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    parsedNamedArgs: Record<string, any>;
    prefix: string;
    has(arg: string): boolean;
}

export interface ChatInputCommandContext extends CommandContext {
    isLegacy: false;
    isContextMenu: false;
    options: ChatInputCommandInteraction["options"];
    commandName: string;
}

export interface ContextMenuCommandContext extends CommandContext {
    isLegacy: false;
    isContextMenu: true;
    options: ContextMenuCommandInteraction["options"];
    commandName: string;
}

export default class CommandManager extends Service {
    protected readonly userBans = new Set<Snowflake>();

    async boot() {
        const bans = await this.client.prisma.globalUserBan.findMany();

        for (const ban of bans) {
            this.userBans.add(ban.userId);
        }
    }

    getBan(userId: Snowflake) {
        return this.client.prisma.globalUserBan.findFirst({
            where: {
                userId
            }
        });
    }

    isBanned(userId: Snowflake) {
        return this.userBans.has(userId);
    }

    async addBan(userId: Snowflake, executorId: Snowflake, reason: string | null = null) {
        if (this.isBanned(userId)) {
            throw new Error("This user is already banned");
        }

        const ban = await this.client.prisma.globalUserBan.create({
            data: {
                userId,
                reason,
                executorId
            }
        });

        this.userBans.add(ban.userId);
        return ban;
    }

    async removeBan(userId: Snowflake) {
        if (!this.isBanned(userId)) {
            return null;
        }

        await this.client.prisma.globalUserBan.deleteMany({
            where: {
                userId
            }
        });

        this.userBans.delete(userId);
        return userId;
    }

    async notifyBannedUser(user: User) {
        if (this.isBanned(user.id)) {
            const ban = await this.getBan(user.id);

            if (!ban) {
                return;
            }

            const newBan = await this.client.prisma.globalUserBan.updateMany({
                where: {
                    id: ban.id
                },
                data: {
                    notified: true
                }
            });

            await user
                .send({
                    embeds: [
                        {
                            author: {
                                icon_url: this.client.user?.displayAvatarURL(),
                                name: "You have been banned from using SudoBot"
                            },
                            description:
                                "You won't be able to use SudoBot anymore, and your SudoBot account will be terminated. Please try not to violate the SudoBot [Terms of Service](https://docs.sudobot.org/legal/terms) before we take action on your account.",
                            fields: [
                                {
                                    name: "Reason",
                                    value: ban.reason ?? "No reason provided"
                                }
                            ],
                            color: 0xf14a60,
                            timestamp: new Date().toISOString()
                        }
                    ]
                })
                .catch(logError);

            return newBan;
        }
    }

    public async runCommandFromMessage(message: Message, checkOnly = false, wait: boolean = false) {
        if (!message.content) return;

        const config = this.client.configManager.config[message.guildId!];

        if (!config) {
            logWarn("This guild is not configured: ", message.guildId!);
            return;
        }

        const prefixes = [config.prefix];
        let foundPrefix: string | undefined = undefined;

        if (
            this.client.configManager.systemConfig.commands.mention_prefix &&
            config.commands.mention_prefix
        ) {
            prefixes.push(`<@${this.client.user!.id}>`, `<@!${this.client.user!.id}>`);
        }

        for (const prefix of prefixes) {
            if (message.content.startsWith(prefix)) {
                foundPrefix = prefix;
                break;
            }
        }

        if (!foundPrefix) {
            return;
        }

        const commandText = message.content.substring(foundPrefix.length).trimStart();
        const [commandName, ...commandArguments] = commandText.split(/ +/);

        if (commandName.includes("__")) {
            return;
        }

        const command = this.client.commands.get(commandName);

        if (!command) {
            log("Command not found, trying to find a snippet");
            return await this.client.snippetManager.onMessageCreate(
                message,
                foundPrefix,
                commandName
            );
        }

        if (!command.supportsLegacy) {
            log("This command does not support legacy mode");
            return;
        }

        const context = {
            isLegacy: true,
            argv: [commandName, ...commandArguments],
            args: commandArguments,
            config,
            parsedArgs: [],
            parsedNamedArgs: {},
            isContextMenu: false,
            prefix: foundPrefix,
            has(arg: string) {
                return this.args.includes(arg);
            }
        } satisfies LegacyCommandContext;

        const handlerObject = {
            _stopped: false,
            stopCommandExecution() {
                this._stopped = true;
            }
        };

        try {
            await this.client.emitWaitLocal(
                "command",
                command.name,
                handlerObject,
                command,
                message,
                context
            );
        } catch (error) {
            if (error instanceof CommandAbortedError) {
                return;
            }

            throw error;
        }

        await Promise.resolve();

        if (handlerObject._stopped) {
            return;
        }

        return new Promise<boolean | null>((resolve, reject) => {
            command
                .run({
                    context,
                    checkOnly,
                    message,
                    onAbort: wait ? () => resolve(null) : undefined
                })
                .then(result => {
                    if (
                        result &&
                        typeof result === "object" &&
                        "__reply" in result &&
                        result.__reply === true
                    ) {
                        message
                            .reply(result as Parameters<typeof message.reply>[0])
                            .catch(console.error);
                    }
                    if (wait) {
                        resolve(true);
                    }
                })
                .catch(e => {
                    logError(e);
                    reject(e);
                });

            if (!wait) {
                resolve(true);
            }
        });
    }

    public async runCommandFromCommandInteraction(
        interaction: Exclude<CommandMessage, Message>,
        checkOnly = false
    ) {
        const config = this.client.configManager.config[interaction.guildId!];

        if (!config) {
            logWarn("This guild is not configured: ", interaction.guildId!);
            return;
        }

        const { commandName } = interaction;
        const command = this.client.commands.get(commandName);

        if (!command) {
            return false;
        }

        if (!command.supportsInteractions) {
            log("This command does not support application command mode");
            return;
        }

        const context = {
            isLegacy: false,
            config,
            options: interaction.options,
            isContextMenu: interaction.isContextMenuCommand(),
            commandName
        } as ContextMenuCommandContext | ChatInputCommandContext;

        const handlerObject = {
            _stopped: false,
            stopCommandExecution() {
                this._stopped = true;
            }
        };

        await this.client.emitWait(
            "command",
            command.name,
            handlerObject,
            command,
            interaction,
            context
        );
        await Promise.resolve();

        if (handlerObject._stopped) {
            return;
        }

        command
            .run({
                message: interaction,
                context,
                checkOnly
            })
            .then(result => {
                if (
                    result &&
                    typeof result === "object" &&
                    "__reply" in result &&
                    result.__reply === true
                ) {
                    interaction.reply(result as InteractionReplyOptions).catch(console.error);
                }
            })
            .catch(logError);
    }
}
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 {
21			ChatInputCommandInteraction,
22			ContextMenuCommandInteraction,
23			InteractionReplyOptions,
24			Message,
25			Snowflake,
26			User
27			} from "discord.js";
28			import { CommandAbortedError, CommandMessage } from "../core/Command";
29			import Service from "../core/Service";
30			import { log, logError, logWarn } from "../utils/Logger";
31			import { GuildConfig } from "./ConfigManager";
32
33			export const name = "commandManager";
34
35			export interface CommandContext {
36			isLegacy: boolean;
37			config: GuildConfig;
38			}
39
40			export interface LegacyCommandContext extends CommandContext {
41			isLegacy: true;
42			isContextMenu: false;
43			argv: string[];
44			args: string[];
45			// eslint-disable-next-line @typescript-eslint/no-explicit-any
46			parsedArgs: any[];
47			// eslint-disable-next-line @typescript-eslint/no-explicit-any
48			parsedNamedArgs: Record<string, any>;
49			prefix: string;
50			has(arg: string): boolean;
51			}
52
53			export interface ChatInputCommandContext extends CommandContext {
54			isLegacy: false;
55			isContextMenu: false;
56			options: ChatInputCommandInteraction["options"];
57			commandName: string;
58			}
59
60			export interface ContextMenuCommandContext extends CommandContext {
61			isLegacy: false;
62			isContextMenu: true;
63			options: ContextMenuCommandInteraction["options"];
64			commandName: string;
65			}
66
67			export default class CommandManager extends Service {
68			protected readonly userBans = new Set<Snowflake>();
69
70			async boot() {
71			const bans = await this.client.prisma.globalUserBan.findMany();
72
73			for (const ban of bans) {
74			this.userBans.add(ban.userId);
75			}
76			}
77
78			getBan(userId: Snowflake) {
79			return this.client.prisma.globalUserBan.findFirst({
80			where: {
81			userId
82			}
83			});
84			}
85
86			isBanned(userId: Snowflake) {
87			return this.userBans.has(userId);
88			}
89
90			async addBan(userId: Snowflake, executorId: Snowflake, reason: string \| null = null) {
91			if (this.isBanned(userId)) {
92			throw new Error("This user is already banned");
93			}
94
95			const ban = await this.client.prisma.globalUserBan.create({
96			data: {
97			userId,
98			reason,
99			executorId
100			}
101			});
102
103			this.userBans.add(ban.userId);
104			return ban;
105			}
106
107			async removeBan(userId: Snowflake) {
108			if (!this.isBanned(userId)) {
109			return null;
110			}
111
112			await this.client.prisma.globalUserBan.deleteMany({
113			where: {
114			userId
115			}
116			});
117
118			this.userBans.delete(userId);
119			return userId;
120			}
121
122			async notifyBannedUser(user: User) {
123			if (this.isBanned(user.id)) {
124			const ban = await this.getBan(user.id);
125
126			if (!ban) {
127			return;
128			}
129
130			const newBan = await this.client.prisma.globalUserBan.updateMany({
131			where: {
132			id: ban.id
133			},
134			data: {
135			notified: true
136			}
137			});
138
139			await user
140			.send({
141			embeds: [
142			{
143			author: {
144			icon_url: this.client.user?.displayAvatarURL(),
145			name: "You have been banned from using SudoBot"
146			},
147			description:
148			"You won't be able to use SudoBot anymore, and your SudoBot account will be terminated. Please try not to violate the SudoBot [Terms of Service](https://docs.sudobot.org/legal/terms) before we take action on your account.",
149			fields: [
150			{
151			name: "Reason",
152			value: ban.reason ?? "No reason provided"
153			}
154			],
155			color: 0xf14a60,
156			timestamp: new Date().toISOString()
157			}
158			]
159			})
160			.catch(logError);
161
162			return newBan;
163			}
164			}
165
166			public async runCommandFromMessage(message: Message, checkOnly = false, wait: boolean = false) {
167			if (!message.content) return;
168
169			const config = this.client.configManager.config[message.guildId!];
170
171			if (!config) {
172			logWarn("This guild is not configured: ", message.guildId!);
173			return;
174			}
175
176			const prefixes = [config.prefix];
177			let foundPrefix: string \| undefined = undefined;
178
179			if (
180			this.client.configManager.systemConfig.commands.mention_prefix &&
181			config.commands.mention_prefix
182			) {
183			prefixes.push(`<@${this.client.user!.id}>`, `<@!${this.client.user!.id}>`);
184			}
185
186			for (const prefix of prefixes) {
187			if (message.content.startsWith(prefix)) {
188			foundPrefix = prefix;
189			break;
190			}
191			}
192
193			if (!foundPrefix) {
194			return;
195			}
196
197			const commandText = message.content.substring(foundPrefix.length).trimStart();
198			const [commandName, ...commandArguments] = commandText.split(/ +/);
199
200			if (commandName.includes("__")) {
201			return;
202			}
203
204			const command = this.client.commands.get(commandName);
205
206			if (!command) {
207			log("Command not found, trying to find a snippet");
208			return await this.client.snippetManager.onMessageCreate(
209			message,
210			foundPrefix,
211			commandName
212			);
213			}
214
215			if (!command.supportsLegacy) {
216			log("This command does not support legacy mode");
217			return;
218			}
219
220			const context = {
221			isLegacy: true,
222			argv: [commandName, ...commandArguments],
223			args: commandArguments,
224			config,
225			parsedArgs: [],
226			parsedNamedArgs: {},
227			isContextMenu: false,
228			prefix: foundPrefix,
229			has(arg: string) {
230			return this.args.includes(arg);
231			}
232			} satisfies LegacyCommandContext;
233
234			const handlerObject = {
235			_stopped: false,
236			stopCommandExecution() {
237			this._stopped = true;
238			}
239			};
240
241			try {
242			await this.client.emitWaitLocal(
243			"command",
244			command.name,
245			handlerObject,
246			command,
247			message,
248			context
249			);
250			} catch (error) {
251			if (error instanceof CommandAbortedError) {
252			return;
253			}
254
255			throw error;
256			}
257
258			await Promise.resolve();
259
260			if (handlerObject._stopped) {
261			return;
262			}
263
264			return new Promise<boolean \| null>((resolve, reject) => {
265			command
266			.run({
267			context,
268			checkOnly,
269			message,
270			onAbort: wait ? () => resolve(null) : undefined
271			})
272			.then(result => {
273			if (
274			result &&
275			typeof result === "object" &&
276			"__reply" in result &&
277			result.__reply === true
278			) {
279			message
280			.reply(result as Parameters<typeof message.reply>[0])
281			.catch(console.error);
282			}
283			if (wait) {
284			resolve(true);
285			}
286			})
287			.catch(e => {
288			logError(e);
289			reject(e);
290			});
291
292			if (!wait) {
293			resolve(true);
294			}
295			});
296			}
297
298			public async runCommandFromCommandInteraction(
299			interaction: Exclude<CommandMessage, Message>,
300			checkOnly = false
301			) {
302			const config = this.client.configManager.config[interaction.guildId!];
303
304			if (!config) {
305			logWarn("This guild is not configured: ", interaction.guildId!);
306			return;
307			}
308
309			const { commandName } = interaction;
310			const command = this.client.commands.get(commandName);
311
312			if (!command) {
313			return false;
314			}
315
316			if (!command.supportsInteractions) {
317			log("This command does not support application command mode");
318			return;
319			}
320
321			const context = {
322			isLegacy: false,
323			config,
324			options: interaction.options,
325			isContextMenu: interaction.isContextMenuCommand(),
326			commandName
327			} as ContextMenuCommandContext \| ChatInputCommandContext;
328
329			const handlerObject = {
330			_stopped: false,
331			stopCommandExecution() {
332			this._stopped = true;
333			}
334			};
335
336			await this.client.emitWait(
337			"command",
338			command.name,
339			handlerObject,
340			command,
341			interaction,
342			context
343			);
344			await Promise.resolve();
345
346			if (handlerObject._stopped) {
347			return;
348			}
349
350			command
351			.run({
352			message: interaction,
353			context,
354			checkOnly
355			})
356			.then(result => {
357			if (
358			result &&
359			typeof result === "object" &&
360			"__reply" in result &&
361			result.__reply === true
362			) {
363			interaction.reply(result as InteractionReplyOptions).catch(console.error);
364			}
365			})
366			.catch(logError);
367			}
368			}