src/core/Command.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 {
    APIEmbed,
    APIEmbedField,
    APIMessage,
    ApplicationCommandType,
    Awaitable,
    CacheType,
    Channel,
    ChatInputCommandInteraction,
    ContextMenuCommandBuilder,
    ContextMenuCommandInteraction,
    GuildMember,
    InteractionDeferReplyOptions,
    InteractionEditReplyOptions,
    InteractionReplyOptions,
    Message,
    MessageCreateOptions,
    MessagePayload,
    ModalSubmitInteraction,
    PermissionResolvable,
    SlashCommandBuilder,
    TextBasedChannel,
    User
} from "discord.js";
import { ChatInputCommandContext, ContextMenuCommandContext, LegacyCommandContext } from "../services/CommandManager";
import EmbedSchemaParser from "../utils/EmbedSchemaParser";
import { channelInfo, guildInfo, userInfo } from "../utils/embed";
import { safeChannelFetch } from "../utils/fetch";
import { logError } from "../utils/logger";
import { getEmoji } from "../utils/utils";
import Client from "./Client";
import CommandArgumentParser from "./CommandArgumentParser";
import { ValidationRule } from "./CommandArgumentParserInterface";

export * from "./CommandArgumentParserInterface";

export type CommandMessage = Message<boolean> | ChatInputCommandInteraction<CacheType> | ContextMenuCommandInteraction;
export type BasicCommandContext = LegacyCommandContext | ChatInputCommandContext;
export type AnyCommandContext = BasicCommandContext | ContextMenuCommandContext;
export type CommandReturn =
    | ((MessageCreateOptions | APIMessage | InteractionReplyOptions) & { __reply?: boolean })
    | undefined
    | null
    | void;

type CommandSlashCommandBuilder =
    | Partial<Pick<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">>
    | Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;

type DeferReplyMode = "delete" | "channel" | "default" | "auto";
type DeferReplyOptions =
    | ((MessageCreateOptions | MessagePayload | InteractionEditReplyOptions) & { ephemeral?: boolean })
    | string;
type PermissionValidationResult =
    | boolean
    | {
          isPermitted: boolean;
          source?: string;
      };
export type RunCommandOptions = {
    message: CommandMessage;
    context: AnyCommandContext;
    onAbort?: () => unknown;
    checkOnly?: boolean;
};

class PermissionError extends Error {}

export default abstract class Command {
    public readonly name: string = "";
    public group: string = "Default";
    public readonly aliases: string[] = [];

    public readonly supportsInteractions: boolean = true;
    public readonly supportsLegacy: boolean = true;

    public readonly permissions: PermissionResolvable[] = [];
    public readonly validationRules: readonly ValidationRule[] = [];
    public readonly permissionMode: "or" | "and" = "and";
    public readonly systemAdminOnly: boolean = false;

    public readonly description?: string;
    public readonly detailedDescription?: string;
    public readonly argumentSyntaxes?: string[];
    public readonly availableOptions?: Record<string, string>;
    public readonly beta: boolean = false;
    public readonly since: string = "1.0.0";
    public readonly botRequiredPermissions: PermissionResolvable[] = [];
    public readonly slashCommandBuilder?: CommandSlashCommandBuilder;

    public readonly applicationCommandType: ApplicationCommandType = ApplicationCommandType.ChatInput;
    public readonly otherApplicationCommandBuilders: (ContextMenuCommandBuilder | SlashCommandBuilder)[] = [];

    public readonly subcommands: string[] = [];
    public readonly subCommandCheck: boolean = false;
    public readonly cooldown?: number = undefined;

    protected message?: CommandMessage;

    protected static argumentParser = new CommandArgumentParser(Client.instance);

    protected constructor(protected client: Client<true>) {}

    abstract execute(message: CommandMessage, context: AnyCommandContext, options?: RunCommandOptions): Promise<CommandReturn>;

    protected getCommandMessage(): CommandMessage {
        if (!this.message) {
            throw new TypeError(`${this.constructor.name}.message is undefined`);
        }

        return this.message;
    }

    protected async deferIfInteraction(message: CommandMessage, options?: InteractionDeferReplyOptions) {
        if (message instanceof ChatInputCommandInteraction) return await message.deferReply(options).catch(logError);
    }

    public async deferredReply(message: CommandMessage, options: DeferReplyOptions, mode: DeferReplyMode = "default") {
        if (message instanceof ChatInputCommandInteraction || message instanceof ContextMenuCommandInteraction) {
            return message.deferred ? await message.editReply(options) : await message.reply(options as any);
        }

        const behaviour = this.client.configManager.config[message.guildId!]?.commands.moderation_command_behaviour;

        if (mode === "delete" || (mode === "auto" && behaviour === "delete")) {
            await message.delete().catch(logError);
        }

        return mode === "delete" || (mode === "auto" && behaviour === "delete") || mode === "channel"
            ? message.channel.send(options as any)
            : message.reply(options as any);
    }

    protected async error(message: CommandMessage, errorMessage?: string, mode: DeferReplyMode = "default") {
        return await this.deferredReply(
            message,
            errorMessage
                ? `${this.emoji("error")} ${errorMessage}`
                : `⚠️ An error has occurred while performing this action. Please make sure that the bot has the required permissions to perform this action.`,
            mode
        );
    }

    protected async success(message: CommandMessage, successMessage?: string, mode: DeferReplyMode = "default") {
        return await this.deferredReply(
            message,
            successMessage ? `${this.emoji("check")} ${successMessage}` : `Successfully completed the given task.`,
            mode
        );
    }

    protected sendError(errorMessage?: string, mode: DeferReplyMode = "default") {
        return this.error(this.getCommandMessage(), errorMessage, mode);
    }

    protected sendSuccess(successMessage?: string, mode: DeferReplyMode = "default") {
        return this.success(this.getCommandMessage(), successMessage, mode);
    }

    protected emoji(name: string) {
        return getEmoji(this.client, name);
    }

    protected async sendCommandRanLog(
        message: CommandMessage | ModalSubmitInteraction,
        options: APIEmbed,
        params: {
            fields?: (fields: APIEmbedField[]) => Awaitable<APIEmbedField[]>;
            before?: (channel: TextBasedChannel, sentMessages: Array<Message | null>) => any;
            previews?: Array<MessageCreateOptions | MessagePayload>;
            url?: string | null;
        } = {}
    ) {
        if (!this.client.configManager.systemConfig.logging?.enabled) {
            return;
        }

        const { previews = [] } = params;
        const logChannelId = this.client.configManager.systemConfig.logging?.channels?.echo_send_logs;

        if (!logChannelId) {
            return;
        }

        try {
            const channel = await safeChannelFetch(await this.client.getHomeGuild(), logChannelId);

            if (!channel?.isTextBased()) {
                return;
            }

            const sentMessages = [];

            for (const preview of previews) {
                const sentMessage = await EmbedSchemaParser.sendMessage(channel, {
                    ...preview,
                    reply: undefined
                } as MessageCreateOptions).catch(logError);
                sentMessages.push(sentMessage ?? null);
            }

            (await params.before?.(channel, sentMessages))?.catch?.(logError);

            const embedFields = [
                {
                    name: "Command Name",
                    value: this.name
                },
                {
                    name: "Guild Info",
                    value: guildInfo(message.guild!),
                    inline: true
                },
                {
                    name: "Channel Info",
                    value: channelInfo(message.channel as Channel),
                    inline: true
                },
                {
                    name: "User (Executor)",
                    value: userInfo(message.member!.user as User),
                    inline: true
                },
                {
                    name: "Mode",
                    value: message instanceof Message ? "Legacy" : "Application Interaction"
                },
                ...(params.url !== null
                    ? [
                          {
                              name: "Message URL",
                              value: params.url ?? (message instanceof Message ? message.url : "*Not available*")
                          }
                      ]
                    : [])
            ];

            await channel
                ?.send({
                    embeds: [
                        {
                            author: {
                                name: message.member?.user.username as string,
                                icon_url: (message.member?.user as User)?.displayAvatarURL()
                            },
                            title: "A command was executed",
                            color: 0x007bff,
                            fields: (await params.fields?.(embedFields)) ?? embedFields,
                            ...options
                        }
                    ]
                })
                .catch(logError);
        } catch (error) {
            logError(error);
        }
    }

    /**
     * Check for command cooldowns.
     *
     * @param message The target message
     * @returns {Promise<boolean>} Whether to abort the command
     */
    private async cooldownCheck(message: CommandMessage): Promise<boolean> {
        if (!this.cooldown) {
            return false;
        }

        const { cooldown, enabled } = this.client.cooldown.lock(message.guildId!, this.name, this.cooldown);

        if (enabled) {
            const seconds = Math.max(Math.ceil(((cooldown ?? 0) - Date.now()) / 1000), 1);

            await this.deferredReply(message, {
                embeds: [
                    {
                        description: `${this.emoji(
                            "clock_red"
                        )} You're being rate limited, please wait for **${seconds}** second${seconds === 1 ? "" : "s"}.`,
                        color: 0xf14a60
                    }
                ],
                ephemeral: true
            });

            return true;
        }

        return false;
    }

    protected async validateCommandBuiltInPermissions(member: GuildMember, hasOverwrite: boolean): Promise<boolean> {
        if (
            this.client.configManager.systemConfig.default_permissions_mode === "ignore" ||
            (hasOverwrite && this.client.configManager.systemConfig.default_permissions_mode === "overwrite")
        ) {
            return true;
        }

        return (
            (this.permissionMode === "and" && member.permissions.has(this.permissions, true)) ||
            (this.permissionMode === "or" && member.permissions.any(this.permissions, true))
        );
    }

    protected async validateNonSystemAdminPermissions({ message }: RunCommandOptions) {
        const commandName = this.name;
        const { disabled_commands } = this.client.configManager.systemConfig;

        if (disabled_commands.includes(commandName ?? "")) {
            throw new PermissionError("This command is disabled.");
        }

        const { channels, guild } = this.client.configManager.config[message.guildId!]?.disabled_commands ?? {};

        if (guild && guild.includes(commandName ?? "")) {
            throw new PermissionError("This command is disabled in this server.");
        }

        if (channels && channels[message.channelId!] && channels[message.channelId!].includes(commandName ?? "")) {
            throw new PermissionError("This command is disabled in this channel.");
        }

        return true;
    }

    protected validateSystemAdminPermissions(member: GuildMember) {
        const isSystemAdmin = this.client.configManager.systemConfig.system_admins.includes(member.id);

        if (this.systemAdminOnly && !isSystemAdmin) {
            throw new PermissionError("This command is only available to system administrators.");
        }

        return {
            isSystemAdmin
        };
    }

    protected async validatePermissions(
        options: RunCommandOptions
    ): Promise<{ result?: PermissionValidationResult; abort?: boolean; error?: string }> {
        const { message } = options;

        try {
            const { isSystemAdmin } = this.validateSystemAdminPermissions(message.member as GuildMember);

            if (isSystemAdmin) {
                return { result: true };
            }

            if (this.client.commandManager.isBanned(message.member!.user.id)) {
                return { abort: true };
            }

            const builtInValidationResult = await this.validateCommandBuiltInPermissions(
                message.member as GuildMember,
                !!this.client.commandPermissionOverwriteManager.permissionOverwrites.get(`${message.guildId!}____${this.name}`)
                    ?.length
            );

            if (!builtInValidationResult) {
                return { result: false };
            }

            const { result: permissionOverwriteResult } =
                await this.client.commandPermissionOverwriteManager.validatePermissionOverwrites({
                    commandName: this.name,
                    guildId: message.guildId!,
                    member: message.member as GuildMember,
                    channelId: message.channelId!
                });

            if (!permissionOverwriteResult) {
                return {
                    error: "You don't have enough permissions to run this command."
                };
            }

            return {
                result: await this.validateNonSystemAdminPermissions(options)
            };
        } catch (error) {
            if (error instanceof PermissionError) {
                return {
                    error: error.message
                };
            }

            logError(error);

            return {
                abort: true
            };
        }
    }

    protected async doChecks(options: RunCommandOptions) {
        const { message } = options;
        const { result: permissionValidationResult, abort, error } = await this.validatePermissions(options);

        if (abort) {
            return;
        }

        const isPermitted =
            (typeof permissionValidationResult === "boolean" && permissionValidationResult) ||
            (typeof permissionValidationResult === "object" && permissionValidationResult.isPermitted);

        if (!isPermitted || error) {
            const permissionValidationFailureSource =
                (typeof permissionValidationResult === "object" && permissionValidationResult.source) || undefined;
            const debugMode =
                (this.client.configManager.systemConfig.debug_mode ||
                    this.client.configManager.config[message.guildId!]?.debug_mode) ??
                false;

            await this.error(
                message,
                `${error ?? "You don't have permission to run this command."}${
                    debugMode && permissionValidationFailureSource ? `\nSource: \`${permissionValidationFailureSource}\`` : ""
                }`
            );

            return false;
        }

        if (this.cooldown) {
            const abort = await this.cooldownCheck(message);

            if (abort) {
                return;
            }
        }

        return true;
    }

    protected async parseArguments({ message, context }: RunCommandOptions) {
        if (!(message instanceof Message) || !context.isLegacy) {
            return true;
        }

        const { error, parsedArgs } = await Command.argumentParser.parse({
            message,
            input: message.content,
            prefix: context.prefix,
            rules: this.validationRules
        });

        if (error) {
            await this.error(message, error);
            return false;
        }

        if (context.isLegacy && this.subCommandCheck && !this.subcommands.includes(context.args[0])) {
            await this.error(
                message,
                `Please provide a valid subcommand! The valid subcommands are \`${this.subcommands.join("`, `")}\`.`
            );

            return false;
        }

        return parsedArgs;
    }

    async run(options: RunCommandOptions) {
        const { message, context, checkOnly = false, onAbort } = options;

        this.message = message;

        if (!(await this.doChecks(options))) {
            this.message = undefined;
            onAbort?.();
            return;
        }

        const parsedArgs = await this.parseArguments(options);

        if (parsedArgs === false) {
            this.message = undefined;
            onAbort?.();
            return;
        }

        if (checkOnly) {
            this.message = undefined;
            return;
        }

        if (typeof parsedArgs === "object" && context.isLegacy) {
            context.parsedArgs = [];

            for (const key in parsedArgs) {
                context.parsedArgs[key as unknown as number] = parsedArgs[key];
            }

            context.parsedNamedArgs = parsedArgs;
        }

        const commandReturn = await this.execute(message, context);
        this.message = undefined;
        return commandReturn;
    }
}
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 {
21	APIEmbed,
22	APIEmbedField,
23	APIMessage,
24	ApplicationCommandType,
25	Awaitable,
26	CacheType,
27	Channel,
28	ChatInputCommandInteraction,
29	ContextMenuCommandBuilder,
30	ContextMenuCommandInteraction,
31	GuildMember,
32	InteractionDeferReplyOptions,
33	InteractionEditReplyOptions,
34	InteractionReplyOptions,
35	Message,
36	MessageCreateOptions,
37	MessagePayload,
38	ModalSubmitInteraction,
39	PermissionResolvable,
40	SlashCommandBuilder,
41	TextBasedChannel,
42	User
43	} from "discord.js";
44	import { ChatInputCommandContext, ContextMenuCommandContext, LegacyCommandContext } from "../services/CommandManager";
45	import EmbedSchemaParser from "../utils/EmbedSchemaParser";
46	import { channelInfo, guildInfo, userInfo } from "../utils/embed";
47	import { safeChannelFetch } from "../utils/fetch";
48	import { logError } from "../utils/logger";
49	import { getEmoji } from "../utils/utils";
50	import Client from "./Client";
51	import CommandArgumentParser from "./CommandArgumentParser";
52	import { ValidationRule } from "./CommandArgumentParserInterface";
53
54	export * from "./CommandArgumentParserInterface";
55
56	export type CommandMessage = Message<boolean> \| ChatInputCommandInteraction<CacheType> \| ContextMenuCommandInteraction;
57	export type BasicCommandContext = LegacyCommandContext \| ChatInputCommandContext;
58	export type AnyCommandContext = BasicCommandContext \| ContextMenuCommandContext;
59	export type CommandReturn =
60	\| ((MessageCreateOptions \| APIMessage \| InteractionReplyOptions) & { __reply?: boolean })
61	\| undefined
62	\| null
63	\| void;
64
65	type CommandSlashCommandBuilder =
66	\| Partial<Pick<SlashCommandBuilder, "addSubcommand" \| "addSubcommandGroup">>
67	\| Omit<SlashCommandBuilder, "addSubcommand" \| "addSubcommandGroup">;
68
69	type DeferReplyMode = "delete" \| "channel" \| "default" \| "auto";
70	type DeferReplyOptions =
71	\| ((MessageCreateOptions \| MessagePayload \| InteractionEditReplyOptions) & { ephemeral?: boolean })
72	\| string;
73	type PermissionValidationResult =
74	\| boolean
75	\| {
76	isPermitted: boolean;
77	source?: string;
78	};
79	export type RunCommandOptions = {
80	message: CommandMessage;
81	context: AnyCommandContext;
82	onAbort?: () => unknown;
83	checkOnly?: boolean;
84	};
85
86	class PermissionError extends Error {}
87
88	export default abstract class Command {
89	public readonly name: string = "";
90	public group: string = "Default";
91	public readonly aliases: string[] = [];
92
93	public readonly supportsInteractions: boolean = true;
94	public readonly supportsLegacy: boolean = true;
95
96	public readonly permissions: PermissionResolvable[] = [];
97	public readonly validationRules: readonly ValidationRule[] = [];
98	public readonly permissionMode: "or" \| "and" = "and";
99	public readonly systemAdminOnly: boolean = false;
100
101	public readonly description?: string;
102	public readonly detailedDescription?: string;
103	public readonly argumentSyntaxes?: string[];
104	public readonly availableOptions?: Record<string, string>;
105	public readonly beta: boolean = false;
106	public readonly since: string = "1.0.0";
107	public readonly botRequiredPermissions: PermissionResolvable[] = [];
108	public readonly slashCommandBuilder?: CommandSlashCommandBuilder;
109
110	public readonly applicationCommandType: ApplicationCommandType = ApplicationCommandType.ChatInput;
111	public readonly otherApplicationCommandBuilders: (ContextMenuCommandBuilder \| SlashCommandBuilder)[] = [];
112
113	public readonly subcommands: string[] = [];
114	public readonly subCommandCheck: boolean = false;
115	public readonly cooldown?: number = undefined;
116
117	protected message?: CommandMessage;
118
119	protected static argumentParser = new CommandArgumentParser(Client.instance);
120
121	protected constructor(protected client: Client<true>) {}
122
123	abstract execute(message: CommandMessage, context: AnyCommandContext, options?: RunCommandOptions): Promise<CommandReturn>;
124
125	protected getCommandMessage(): CommandMessage {
126	if (!this.message) {
127	throw new TypeError(`${this.constructor.name}.message is undefined`);
128	}
129
130	return this.message;
131	}
132
133	protected async deferIfInteraction(message: CommandMessage, options?: InteractionDeferReplyOptions) {
134	if (message instanceof ChatInputCommandInteraction) return await message.deferReply(options).catch(logError);
135	}
136
137	public async deferredReply(message: CommandMessage, options: DeferReplyOptions, mode: DeferReplyMode = "default") {
138	if (message instanceof ChatInputCommandInteraction \|\| message instanceof ContextMenuCommandInteraction) {
139	return message.deferred ? await message.editReply(options) : await message.reply(options as any);
140	}
141
142	const behaviour = this.client.configManager.config[message.guildId!]?.commands.moderation_command_behaviour;
143
144	if (mode === "delete" \|\| (mode === "auto" && behaviour === "delete")) {
145	await message.delete().catch(logError);
146	}
147
148	return mode === "delete" \|\| (mode === "auto" && behaviour === "delete") \|\| mode === "channel"
149	? message.channel.send(options as any)
150	: message.reply(options as any);
151	}
152
153	protected async error(message: CommandMessage, errorMessage?: string, mode: DeferReplyMode = "default") {
154	return await this.deferredReply(
155	message,
156	errorMessage
157	? `${this.emoji("error")} ${errorMessage}`
158	: `⚠️ An error has occurred while performing this action. Please make sure that the bot has the required permissions to perform this action.`,
159	mode
160	);
161	}
162
163	protected async success(message: CommandMessage, successMessage?: string, mode: DeferReplyMode = "default") {
164	return await this.deferredReply(
165	message,
166	successMessage ? `${this.emoji("check")} ${successMessage}` : `Successfully completed the given task.`,
167	mode
168	);
169	}
170
171	protected sendError(errorMessage?: string, mode: DeferReplyMode = "default") {
172	return this.error(this.getCommandMessage(), errorMessage, mode);
173	}
174
175	protected sendSuccess(successMessage?: string, mode: DeferReplyMode = "default") {
176	return this.success(this.getCommandMessage(), successMessage, mode);
177	}
178
179	protected emoji(name: string) {
180	return getEmoji(this.client, name);
181	}
182
183	protected async sendCommandRanLog(
184	message: CommandMessage \| ModalSubmitInteraction,
185	options: APIEmbed,
186	params: {
187	fields?: (fields: APIEmbedField[]) => Awaitable<APIEmbedField[]>;
188	before?: (channel: TextBasedChannel, sentMessages: Array<Message \| null>) => any;
189	previews?: Array<MessageCreateOptions \| MessagePayload>;
190	url?: string \| null;
191	} = {}
192	) {
193	if (!this.client.configManager.systemConfig.logging?.enabled) {
194	return;
195	}
196
197	const { previews = [] } = params;
198	const logChannelId = this.client.configManager.systemConfig.logging?.channels?.echo_send_logs;
199
200	if (!logChannelId) {
201	return;
202	}
203
204	try {
205	const channel = await safeChannelFetch(await this.client.getHomeGuild(), logChannelId);
206
207	if (!channel?.isTextBased()) {
208	return;
209	}
210
211	const sentMessages = [];
212
213	for (const preview of previews) {
214	const sentMessage = await EmbedSchemaParser.sendMessage(channel, {
215	...preview,
216	reply: undefined
217	} as MessageCreateOptions).catch(logError);
218	sentMessages.push(sentMessage ?? null);
219	}
220
221	(await params.before?.(channel, sentMessages))?.catch?.(logError);
222
223	const embedFields = [
224	{
225	name: "Command Name",
226	value: this.name
227	},
228	{
229	name: "Guild Info",
230	value: guildInfo(message.guild!),
231	inline: true
232	},
233	{
234	name: "Channel Info",
235	value: channelInfo(message.channel as Channel),
236	inline: true
237	},
238	{
239	name: "User (Executor)",
240	value: userInfo(message.member!.user as User),
241	inline: true
242	},
243	{
244	name: "Mode",
245	value: message instanceof Message ? "Legacy" : "Application Interaction"
246	},
247	...(params.url !== null
248	? [
249	{
250	name: "Message URL",
251	value: params.url ?? (message instanceof Message ? message.url : "Not available")
252	}
253	]
254	: [])
255	];
256
257	await channel
258	?.send({
259	embeds: [
260	{
261	author: {
262	name: message.member?.user.username as string,
263	icon_url: (message.member?.user as User)?.displayAvatarURL()
264	},
265	title: "A command was executed",
266	color: 0x007bff,
267	fields: (await params.fields?.(embedFields)) ?? embedFields,
268	...options
269	}
270	]
271	})
272	.catch(logError);
273	} catch (error) {
274	logError(error);
275	}
276	}
277
278	/**
279	* Check for command cooldowns.
280	*
281	* @param message The target message
282	* @returns {Promise<boolean>} Whether to abort the command
283	*/
284	private async cooldownCheck(message: CommandMessage): Promise<boolean> {
285	if (!this.cooldown) {
286	return false;
287	}
288
289	const { cooldown, enabled } = this.client.cooldown.lock(message.guildId!, this.name, this.cooldown);
290
291	if (enabled) {
292	const seconds = Math.max(Math.ceil(((cooldown ?? 0) - Date.now()) / 1000), 1);
293
294	await this.deferredReply(message, {
295	embeds: [
296	{
297	description: `${this.emoji(
298	"clock_red"
299	)} You're being rate limited, please wait for ${seconds} second${seconds === 1 ? "" : "s"}.`,
300	color: 0xf14a60
301	}
302	],
303	ephemeral: true
304	});
305
306	return true;
307	}
308
309	return false;
310	}
311
312	protected async validateCommandBuiltInPermissions(member: GuildMember, hasOverwrite: boolean): Promise<boolean> {
313	if (
314	this.client.configManager.systemConfig.default_permissions_mode === "ignore" \|\|
315	(hasOverwrite && this.client.configManager.systemConfig.default_permissions_mode === "overwrite")
316	) {
317	return true;
318	}
319
320	return (
321	(this.permissionMode === "and" && member.permissions.has(this.permissions, true)) \|\|
322	(this.permissionMode === "or" && member.permissions.any(this.permissions, true))
323	);
324	}
325
326	protected async validateNonSystemAdminPermissions({ message }: RunCommandOptions) {
327	const commandName = this.name;
328	const { disabled_commands } = this.client.configManager.systemConfig;
329
330	if (disabled_commands.includes(commandName ?? "")) {
331	throw new PermissionError("This command is disabled.");
332	}
333
334	const { channels, guild } = this.client.configManager.config[message.guildId!]?.disabled_commands ?? {};
335
336	if (guild && guild.includes(commandName ?? "")) {
337	throw new PermissionError("This command is disabled in this server.");
338	}
339
340	if (channels && channels[message.channelId!] && channels[message.channelId!].includes(commandName ?? "")) {
341	throw new PermissionError("This command is disabled in this channel.");
342	}
343
344	return true;
345	}
346
347	protected validateSystemAdminPermissions(member: GuildMember) {
348	const isSystemAdmin = this.client.configManager.systemConfig.system_admins.includes(member.id);
349
350	if (this.systemAdminOnly && !isSystemAdmin) {
351	throw new PermissionError("This command is only available to system administrators.");
352	}
353
354	return {
355	isSystemAdmin
356	};
357	}
358
359	protected async validatePermissions(
360	options: RunCommandOptions
361	): Promise<{ result?: PermissionValidationResult; abort?: boolean; error?: string }> {
362	const { message } = options;
363
364	try {
365	const { isSystemAdmin } = this.validateSystemAdminPermissions(message.member as GuildMember);
366
367	if (isSystemAdmin) {
368	return { result: true };
369	}
370
371	if (this.client.commandManager.isBanned(message.member!.user.id)) {
372	return { abort: true };
373	}
374
375	const builtInValidationResult = await this.validateCommandBuiltInPermissions(
376	message.member as GuildMember,
377	!!this.client.commandPermissionOverwriteManager.permissionOverwrites.get(`${message.guildId!}____${this.name}`)
378	?.length
379	);
380
381	if (!builtInValidationResult) {
382	return { result: false };
383	}
384
385	const { result: permissionOverwriteResult } =
386	await this.client.commandPermissionOverwriteManager.validatePermissionOverwrites({
387	commandName: this.name,
388	guildId: message.guildId!,
389	member: message.member as GuildMember,
390	channelId: message.channelId!
391	});
392
393	if (!permissionOverwriteResult) {
394	return {
395	error: "You don't have enough permissions to run this command."
396	};
397	}
398
399	return {
400	result: await this.validateNonSystemAdminPermissions(options)
401	};
402	} catch (error) {
403	if (error instanceof PermissionError) {
404	return {
405	error: error.message
406	};
407	}
408
409	logError(error);
410
411	return {
412	abort: true
413	};
414	}
415	}
416
417	protected async doChecks(options: RunCommandOptions) {
418	const { message } = options;
419	const { result: permissionValidationResult, abort, error } = await this.validatePermissions(options);
420
421	if (abort) {
422	return;
423	}
424
425	const isPermitted =
426	(typeof permissionValidationResult === "boolean" && permissionValidationResult) \|\|
427	(typeof permissionValidationResult === "object" && permissionValidationResult.isPermitted);
428
429	if (!isPermitted \|\| error) {
430	const permissionValidationFailureSource =
431	(typeof permissionValidationResult === "object" && permissionValidationResult.source) \|\| undefined;
432	const debugMode =
433	(this.client.configManager.systemConfig.debug_mode \|\|
434	this.client.configManager.config[message.guildId!]?.debug_mode) ??
435	false;
436
437	await this.error(
438	message,
439	`${error ?? "You don't have permission to run this command."}${
440	debugMode && permissionValidationFailureSource ? `\nSource: \`${permissionValidationFailureSource}\`` : ""
441	}`
442	);
443
444	return false;
445	}
446
447	if (this.cooldown) {
448	const abort = await this.cooldownCheck(message);
449
450	if (abort) {
451	return;
452	}
453	}
454
455	return true;
456	}
457
458	protected async parseArguments({ message, context }: RunCommandOptions) {
459	if (!(message instanceof Message) \|\| !context.isLegacy) {
460	return true;
461	}
462
463	const { error, parsedArgs } = await Command.argumentParser.parse({
464	message,
465	input: message.content,
466	prefix: context.prefix,
467	rules: this.validationRules
468	});
469
470	if (error) {
471	await this.error(message, error);
472	return false;
473	}
474
475	if (context.isLegacy && this.subCommandCheck && !this.subcommands.includes(context.args[0])) {
476	await this.error(
477	message,
478	`Please provide a valid subcommand! The valid subcommands are \`${this.subcommands.join("`, `")}\`.`
479	);
480
481	return false;
482	}
483
484	return parsedArgs;
485	}
486
487	async run(options: RunCommandOptions) {
488	const { message, context, checkOnly = false, onAbort } = options;
489
490	this.message = message;
491
492	if (!(await this.doChecks(options))) {
493	this.message = undefined;
494	onAbort?.();
495	return;
496	}
497
498	const parsedArgs = await this.parseArguments(options);
499
500	if (parsedArgs === false) {
501	this.message = undefined;
502	onAbort?.();
503	return;
504	}
505
506	if (checkOnly) {
507	this.message = undefined;
508	return;
509	}
510
511	if (typeof parsedArgs === "object" && context.isLegacy) {
512	context.parsedArgs = [];
513
514	for (const key in parsedArgs) {
515	context.parsedArgs[key as unknown as number] = parsedArgs[key];
516	}
517
518	context.parsedNamedArgs = parsedArgs;
519	}
520
521	const commandReturn = await this.execute(message, context);
522	this.message = undefined;
523	return commandReturn;
524	}
525	}