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 { CommandPermissionOverwrites } from "@prisma/client";
import { ChatInputCommandInteraction, ContextMenuCommandInteraction, Message, Snowflake } from "discord.js";
import Command, { CommandMessage, ValidationRuleParsedArgs } from "../core/Command";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
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[];
    parsedArgs: any[];
    parsedNamedArgs: Record<string, any>;
    prefix: string;
    has(arg: string): boolean;
    getParsedArgs<C extends Command>(command: C): ValidationRuleParsedArgs<C["validationRules"]>;
    getParsedArg<C extends Command, I extends keyof C["validationRules"]>(
        command: C,
        index: I
    ): ValidationRuleParsedArgs<C["validationRules"]>[I];
}

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 implements HasEventListeners {
    readonly permissionOverwrites = new Map<`${Snowflake}____${string}`, CommandPermissionOverwrites>();

    @GatewayEventListener("ready")
    async onReady() {
        log("Syncing command permission overwrites...");

        const permissionOverwrites = await this.client.prisma.commandPermissionOverwrites.findMany();

        for (const permissionOverwrite of permissionOverwrites) {
            for (const command of permissionOverwrite.commands) {
                this.permissionOverwrites.set(`${permissionOverwrite.guildId}____${command}`, permissionOverwrite);
            }
        }

        log("Successfully synced command permission overwrites");
    }

    public async runCommandFromMessage(message: Message, checkOnly = 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(/ +/);

        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, commandName);
        }

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

        command
            .run(
                message,
                {
                    isLegacy: true,
                    argv: [commandName, ...commandArguments],
                    args: commandArguments,
                    config,
                    parsedArgs: [],
                    parsedNamedArgs: {},
                    isContextMenu: false,
                    prefix: foundPrefix,
                    has(arg: string) {
                        return this.args.includes(arg);
                    },
                    getParsedArg<C extends Command, I extends keyof C["validationRules"]>(command: C, index: I) {
                        return this.parsedArgs[index as number] as ValidationRuleParsedArgs<C["validationRules"]>[I];
                    },
                    getParsedArgs<C extends Command>(command: C) {
                        return this.parsedArgs as ValidationRuleParsedArgs<C["validationRules"]>;
                    }
                } satisfies LegacyCommandContext,
                checkOnly
            )
            .then(result => {
                if (result && typeof result === "object" && "__reply" in result && result.__reply === true) {
                    message.reply(result as any).catch(console.error);
                }
            })
            .catch(logError);

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

        command
            .run(
                interaction,
                {
                    isLegacy: false,
                    config,
                    options: interaction.options,
                    isContextMenu: interaction.isContextMenuCommand(),
                    commandName
                } as ContextMenuCommandContext | ChatInputCommandContext,
                checkOnly
            )
            .then(result => {
                if (result && typeof result === "object" && "__reply" in result && result.__reply === true) {
                    interaction.reply(result as any).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 { CommandPermissionOverwrites } from "@prisma/client";
21			import { ChatInputCommandInteraction, ContextMenuCommandInteraction, Message, Snowflake } from "discord.js";
22			import Command, { CommandMessage, ValidationRuleParsedArgs } from "../core/Command";
23			import Service from "../core/Service";
24			import { GatewayEventListener } from "../decorators/GatewayEventListener";
25			import { HasEventListeners } from "../types/HasEventListeners";
26			import { log, logError, logWarn } from "../utils/logger";
27			import { GuildConfig } from "./ConfigManager";
28
29			export const name = "commandManager";
30
31			export interface CommandContext {
32			isLegacy: boolean;
33			config: GuildConfig;
34			}
35
36			export interface LegacyCommandContext extends CommandContext {
37			isLegacy: true;
38			isContextMenu: false;
39			argv: string[];
40			args: string[];
41			parsedArgs: any[];
42			parsedNamedArgs: Record<string, any>;
43			prefix: string;
44			has(arg: string): boolean;
45			getParsedArgs<C extends Command>(command: C): ValidationRuleParsedArgs<C["validationRules"]>;
46			getParsedArg<C extends Command, I extends keyof C["validationRules"]>(
47			command: C,
48			index: I
49			): ValidationRuleParsedArgs<C["validationRules"]>[I];
50			}
51
52			export interface ChatInputCommandContext extends CommandContext {
53			isLegacy: false;
54			isContextMenu: false;
55			options: ChatInputCommandInteraction["options"];
56			commandName: string;
57			}
58
59			export interface ContextMenuCommandContext extends CommandContext {
60			isLegacy: false;
61			isContextMenu: true;
62			options: ContextMenuCommandInteraction["options"];
63			commandName: string;
64			}
65
66			export default class CommandManager extends Service implements HasEventListeners {
67			readonly permissionOverwrites = new Map<`${Snowflake}____${string}`, CommandPermissionOverwrites>();
68
69			@GatewayEventListener("ready")
70			async onReady() {
71			log("Syncing command permission overwrites...");
72
73			const permissionOverwrites = await this.client.prisma.commandPermissionOverwrites.findMany();
74
75			for (const permissionOverwrite of permissionOverwrites) {
76			for (const command of permissionOverwrite.commands) {
77			this.permissionOverwrites.set(`${permissionOverwrite.guildId}____${command}`, permissionOverwrite);
78			}
79			}
80
81			log("Successfully synced command permission overwrites");
82			}
83
84			public async runCommandFromMessage(message: Message, checkOnly = false) {
85			if (!message.content) return;
86
87			const config = this.client.configManager.config[message.guildId!];
88
89			if (!config) {
90			logWarn("This guild is not configured: ", message.guildId!);
91			return;
92			}
93
94			const prefixes = [config.prefix];
95			let foundPrefix: string \| undefined = undefined;
96
97			if (this.client.configManager.systemConfig.commands.mention_prefix && config.commands.mention_prefix) {
98			prefixes.push(`<@${this.client.user!.id}>`, `<@!${this.client.user!.id}>`);
99			}
100
101			for (const prefix of prefixes) {
102			if (message.content.startsWith(prefix)) {
103			foundPrefix = prefix;
104			break;
105			}
106			}
107
108			if (!foundPrefix) {
109			return;
110			}
111
112			const commandText = message.content.substring(foundPrefix.length).trimStart();
113			const [commandName, ...commandArguments] = commandText.split(/ +/);
114
115			const command = this.client.commands.get(commandName);
116
117			if (!command) {
118			log("Command not found, trying to find a snippet");
119			return await this.client.snippetManager.onMessageCreate(message, commandName);
120			}
121
122			if (!command.supportsLegacy) {
123			log("This command does not support legacy mode");
124			return;
125			}
126
127			command
128			.run(
129			message,
130			{
131			isLegacy: true,
132			argv: [commandName, ...commandArguments],
133			args: commandArguments,
134			config,
135			parsedArgs: [],
136			parsedNamedArgs: {},
137			isContextMenu: false,
138			prefix: foundPrefix,
139			has(arg: string) {
140			return this.args.includes(arg);
141			},
142			getParsedArg<C extends Command, I extends keyof C["validationRules"]>(command: C, index: I) {
143			return this.parsedArgs[index as number] as ValidationRuleParsedArgs<C["validationRules"]>[I];
144			},
145			getParsedArgs<C extends Command>(command: C) {
146			return this.parsedArgs as ValidationRuleParsedArgs<C["validationRules"]>;
147			}
148			} satisfies LegacyCommandContext,
149			checkOnly
150			)
151			.then(result => {
152			if (result && typeof result === "object" && "__reply" in result && result.__reply === true) {
153			message.reply(result as any).catch(console.error);
154			}
155			})
156			.catch(logError);
157
158			return true;
159			}
160
161			public async runCommandFromCommandInteraction(interaction: Exclude<CommandMessage, Message>, checkOnly = false) {
162			const config = this.client.configManager.config[interaction.guildId!];
163
164			if (!config) {
165			logWarn("This guild is not configured: ", interaction.guildId!);
166			return;
167			}
168
169			const { commandName } = interaction;
170			const command = this.client.commands.get(commandName);
171
172			if (!command) {
173			return false;
174			}
175
176			if (!command.supportsInteractions) {
177			log("This command does not support application command mode");
178			return;
179			}
180
181			command
182			.run(
183			interaction,
184			{
185			isLegacy: false,
186			config,
187			options: interaction.options,
188			isContextMenu: interaction.isContextMenuCommand(),
189			commandName
190			} as ContextMenuCommandContext \| ChatInputCommandContext,
191			checkOnly
192			)
193			.then(result => {
194			if (result && typeof result === "object" && "__reply" in result && result.__reply === true) {
195			interaction.reply(result as any).catch(console.error);
196			}
197			})
198			.catch(logError);
199			}
200			}