src/core/Command.ts

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

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