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,
    MessageReplyOptions,
    ModalSubmitInteraction,
    PermissionResolvable,
    SlashCommandBuilder,
    TextBasedChannel,
    User,
    SlashCommandOptionsOnlyBuilder,
    SlashCommandSubcommandsOnlyBuilder
} from "discord.js";
import {
    ChatInputCommandContext,
    ContextMenuCommandContext,
    LegacyCommandContext
} from "../services/CommandManager";
import EmbedSchemaParser from "../utils/EmbedSchemaParser";
import { logError } from "../utils/Logger";
import { channelInfo, guildInfo, userInfo } from "../utils/embed";
import { safeChannelFetch } from "../utils/fetch";
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">
    | SlashCommandBuilder
    | SlashCommandOptionsOnlyBuilder
    | SlashCommandSubcommandsOnlyBuilder;

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

export class PermissionError extends Error {}
type MessageOptions = string | MessageCreateOptions | MessagePayload | InteractionReplyOptions;

export class CommandAbortedError extends Error {
    public readonly options?: MessageOptions | null;

    constructor(
        public readonly reason: string,
        messageOptionsOrCallback?:
            | MessageOptions
            | null
            | (() => MessageOptions | void | undefined | null)
    ) {
        super(reason);
        this.options =
            typeof messageOptionsOrCallback === "function"
                ? messageOptionsOrCallback() ?? undefined
                : messageOptionsOrCallback === undefined
                ? {
                      content: reason
                  }
                : messageOptionsOrCallback;
    }

    public send(message: CommandMessage) {
        if (this.options) {
            return message.reply(this.options as MessagePayload);
        }
    }
}

type SubcommandMeta = {
    description?: string;
    detailedDescription?: string;
    argumentSyntaxes?: string[];
    availableOptions?: Record<string, string>;
    beta?: boolean;
    since?: string;
    botRequiredPermissions?: PermissionResolvable[];
    permissions?: PermissionResolvable[];
    supportsLegacy?: boolean;
    supportsInteractions?: boolean;
    systemAdminOnly?: boolean;
};

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;
    public readonly subcommandsMeta: Record<string, SubcommandMeta> = {};

    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
        ) {
            if (message.deferred) {
                return message.editReply(options);
            }

            const response = await message.reply(options as InteractionReplyOptions);
            return response.fetch();
        }

        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 MessageCreateOptions)
            : message.reply(options as MessageReplyOptions);
    }

    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 abort(
        options:
            | string
            | MessageCreateOptions
            | MessagePayload
            | InteractionReplyOptions
            | null
            | undefined = null
    ) {
        throw new CommandAbortedError(`Command aborted: ${this.name}`, options);
    }

    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>
            ) => Awaitable<void>;
            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);

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

        try {
            const commandReturn = await this.execute(message, context);
            this.message = undefined;
            return commandReturn;
        } catch (error) {
            if (error instanceof CommandAbortedError) {
                if (error.options) {
                    await this.deferredReply(message, error.options);
                }

                this.message = undefined;
                onAbort?.();
                return;
            }

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