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 {
    APIMessage,
    ApplicationCommandType,
    CacheType,
    ChatInputCommandInteraction,
    ContextMenuCommandBuilder,
    ContextMenuCommandInteraction,
    GuildBasedChannel,
    GuildMember,
    InteractionDeferReplyOptions,
    InteractionEditReplyOptions,
    InteractionReplyOptions,
    Message,
    MessageCreateOptions,
    MessageMentions,
    MessagePayload,
    PermissionResolvable,
    PermissionsBitField,
    Role,
    SlashCommandBuilder,
    Snowflake,
    User
} from "discord.js";
import { ChatInputCommandContext, ContextMenuCommandContext, LegacyCommandContext } from "../services/CommandManager";
import { stringToTimeInterval } from "../utils/datetime";
import { log, logError } from "../utils/logger";
import { getEmoji, isSnowflake } from "../utils/utils";
import Client from "./Client";

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;

export enum ArgumentType {
    String = 1,
    StringRest,
    Number,
    Integer,
    Float,
    Boolean,
    Snowflake,
    User,
    GuildMember,
    Channel,
    Role,
    Link,
    TimeInterval
}

export interface ValidationRule {
    types?: readonly ArgumentType[];
    optional?: boolean;
    default?: any;
    requiredErrorMessage?: string;
    typeErrorMessage?: string;
    entityNotNullErrorMessage?: string;
    entityNotNull?: boolean;
    minValue?: number;
    maxValue?: number;
    minMaxErrorMessage?: string;
    lengthMaxErrorMessage?: string;
    lengthMax?: number;
    name?: string;
    timeMilliseconds?: boolean;
}

type ValidationRuleAndOutputMap = {
    [ArgumentType.Boolean]: boolean;
    [ArgumentType.Channel]: GuildBasedChannel;
    [ArgumentType.Float]: number;
    [ArgumentType.Number]: number;
    [ArgumentType.Integer]: number;
    [ArgumentType.TimeInterval]: number;
    [ArgumentType.Link]: string;
    [ArgumentType.Role]: Role;
    [ArgumentType.Snowflake]: Snowflake;
    [ArgumentType.String]: string;
    [ArgumentType.StringRest]: string;
    [ArgumentType.User]: User;
    [ArgumentType.GuildMember]: GuildMember;
};

type ValidationRuleParsedArg<T extends ValidationRule["types"]> = T extends ReadonlyArray<infer U>
    ? U extends keyof ValidationRuleAndOutputMap
        ? ValidationRuleAndOutputMap[U]
        : never
    : T extends Array<infer U>
    ? U extends keyof ValidationRuleAndOutputMap
        ? ValidationRuleAndOutputMap[U]
        : never
    : never;

export type ValidationRuleParsedArgs<T extends readonly ValidationRule[]> = {
    [K in keyof T]: ValidationRuleParsedArg<T[K]["types"]>;
};

// TODO: Split the logic into separate methods

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?:
        | Partial<Pick<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">>
        | Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;

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

    public readonly subcommands: string[] = [];

    constructor(protected client: Client) {}

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

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

    async deferredReply(
        message: CommandMessage,
        options: MessageCreateOptions | MessagePayload | InteractionEditReplyOptions | string
    ) {
        if (message instanceof ChatInputCommandInteraction || message instanceof ContextMenuCommandInteraction) {
            return message.deferred ? await message.editReply(options) : await message.reply(options as any);
        }

        return message.reply(options as any);
    }

    async error(message: CommandMessage, errorMessage?: string) {
        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.`
        );
    }

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

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

    async run(message: CommandMessage, context: AnyCommandContext, checkOnly = false) {
        const isSystemAdmin = this.client.configManager.systemConfig.system_admins.includes(message.member!.user.id);

        if (this.systemAdminOnly && !isSystemAdmin) {
            message
                .reply({
                    content: `${this.emoji("error")} You don't have permission to run this command.`,
                    ephemeral: true
                })
                .catch(logError);

            return;
        }

        if (!isSystemAdmin) {
            const commandName = this.client.commands.get(context.isLegacy ? context.argv[0] : context.commandName)?.name;
            const { disabled_commands } = this.client.configManager.systemConfig;

            if (disabled_commands.includes(commandName ?? "")) {
                await this.error(message, "This command is disabled.");
                return;
            }

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

            if (guild && guild.includes(commandName ?? "")) {
                await this.error(message, "This command is disabled in this server.");
                return;
            }

            if (channels && channels[message.channelId!] && channels[message.channelId!].includes(commandName ?? "")) {
                await this.error(message, "This command is disabled in this channel.");
                return;
            }
        }

        const { validationRules, permissions } = this;
        const parsedArgs = [];
        const parsedNamedArgs: Record<string, any> = {};

        if (!isSystemAdmin) {
            let member: GuildMember = <any>message.member!;

            if (!(member.permissions as any)?.has) {
                try {
                    member = await message.guild!.members.fetch(member.user.id);

                    if (!member) {
                        throw new Error("Invalid member");
                    }
                } catch (e) {
                    logError(e);
                    message
                        .reply({
                            content: `Sorry, I couldn't determine whether you have the enough permissions to perform this action or not. Please contact the bot developer.`,
                            ephemeral: true
                        })
                        .catch(logError);
                    return;
                }
            }

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

            if (permissions.length > 0) {
                const memberBotPermissions = this.client.permissionManager.getMemberPermissions(member);
                const memberRequiredPermissions = new PermissionsBitField(permissions).toArray();

                if (this.permissionMode === "and") {
                    for (const permission of permissions) {
                        if (!member.permissions.has(permission, true)) {
                            const mode = this.client.configManager.config[message.guildId!]?.permissions?.mode;

                            if (mode !== "advanced" && mode !== "levels") {
                                await message.reply({
                                    content: `${this.emoji("error")} You don't have permission to run this command.`,
                                    ephemeral: true
                                });

                                log("Skip");

                                return;
                            }

                            const memberBotPermissions = this.client.permissionManager.getMemberPermissions(member);
                            const memberRequiredPermissions = new PermissionsBitField(permissions).toArray();

                            log("PERMS: ", [...memberBotPermissions.values()]);
                            log("PERMS 2: ", memberRequiredPermissions);

                            for (const memberRequiredPermission of memberRequiredPermissions) {
                                if (!memberBotPermissions.has(memberRequiredPermission)) {
                                    await message.reply({
                                        content: `${this.emoji("error")} You don't have permission to run this command.`,
                                        ephemeral: true
                                    });

                                    return;
                                }
                            }
                        }
                    }
                } else
                    orMode: {
                        for (const permission of permissions) {
                            if (member.permissions.has(permission, true)) {
                                break orMode;
                            }
                        }

                        if (mode === "advanced" || mode === "levels") {
                            for (const memberRequiredPermission of memberRequiredPermissions) {
                                if (memberBotPermissions.has(memberRequiredPermission)) {
                                    break orMode;
                                }
                            }
                        }

                        await message.reply({
                            content: `${this.emoji("error")} You don't have enough permissions to run this command.`,
                            ephemeral: true
                        });

                        return;
                    }
            }

            const permissionOverwrite = this.client.commandManager.permissionOverwrites.get(
                `${message.guildId!}____${this.name}`
            );

            log([...this.client.commandManager.permissionOverwrites.keys()]);

            errorRootBlock: if (permissionOverwrite) {
                let userCheckPassed = false;
                let levelCheckPassed = false;
                let roleCheckPassed = false;
                let permissonCheckPassed = false;

                permissionOverwriteIfBlock: {
                    if (permissionOverwrite.requiredUsers.length > 0) {
                        userCheckPassed = permissionOverwrite.requiredUsers.includes(member.user.id);

                        if (permissionOverwrite.mode === "AND" && !userCheckPassed) {
                            break permissionOverwriteIfBlock;
                        }

                        if (permissionOverwrite.mode === "OR" && userCheckPassed) {
                            log("User check passed [OR]");
                            break errorRootBlock;
                        }
                    }

                    if (mode === "levels" && permissionOverwrite.requiredLevel !== null) {
                        const level = this.client.permissionManager.getMemberPermissionLevel(member);
                        levelCheckPassed = level >= permissionOverwrite.requiredLevel;

                        log("level", level, "<", permissionOverwrite.requiredLevel);

                        if (!levelCheckPassed && permissionOverwrite.mode === "AND") {
                            break permissionOverwriteIfBlock;
                        } else if (levelCheckPassed && permissionOverwrite.mode === "OR") {
                            log("Level check passed [OR]");
                            break errorRootBlock;
                        }
                    }

                    if (permissionOverwrite.requiredPermissions.length > 0) {
                        const requiredPermissions = permissionOverwrite.requiredPermissions as PermissionResolvable[];

                        if (permissionOverwrite.requiredPermissionMode === "OR") {
                            let found = false;

                            for (const permission of requiredPermissions) {
                                if (member.permissions.has(permission, true)) {
                                    found = true;
                                    break;
                                }
                            }

                            permissonCheckPassed = found;

                            if (!found && permissionOverwrite.mode === "AND") {
                                break permissionOverwriteIfBlock;
                            } else if (found && permissionOverwrite.mode === "OR") {
                                log("Permission check passed [OR_OR]");
                                break errorRootBlock;
                            }
                        } else {
                            log(requiredPermissions);
                            permissonCheckPassed = member.permissions.has(requiredPermissions, true);

                            if (!permissonCheckPassed && permissionOverwrite.mode === "AND") {
                                log("Fail");
                                break permissionOverwriteIfBlock;
                            } else if (permissonCheckPassed && permissionOverwrite.mode === "OR") {
                                log("Permission check passed [AND_OR]");
                                break errorRootBlock;
                            }
                        }
                    }

                    if (permissionOverwrite.requiredRoles.length > 0) {
                        roleCheckPassed = member.roles.cache.hasAll(...permissionOverwrite.requiredRoles);

                        if (!roleCheckPassed && permissionOverwrite.mode === "AND") {
                            break permissionOverwriteIfBlock;
                        } else if (roleCheckPassed && permissionOverwrite.mode === "OR") {
                            break errorRootBlock;
                        }
                    }

                    log("userCheckPassed", userCheckPassed);
                    log("levelCheckPassed", levelCheckPassed);
                    log("permissonCheckPassed", permissonCheckPassed);
                    log("roleCheckPassed", roleCheckPassed);

                    if (permissionOverwrite.mode === "OR") {
                        break permissionOverwriteIfBlock;
                    }

                    if (
                        permissionOverwrite.requiredChannels.length > 0 &&
                        !permissionOverwrite.requiredChannels.includes(message.channelId!)
                    ) {
                        await message.reply({
                            content: `${this.emoji("error")} This command is disabled in this channel.`,
                            ephemeral: true
                        });

                        return;
                    }

                    break errorRootBlock;
                }

                await message.reply({
                    content: `${this.emoji("error")} You don't have enough permissions to run this command.`,
                    ephemeral: true
                });

                return;
            }
        }

        if (context.isLegacy) {
            let index = 0;

            loop: for await (const rule of validationRules) {
                const arg = context.args[index];

                if (arg === undefined) {
                    if (!rule.optional) {
                        await this.error(message, rule.requiredErrorMessage ?? `Argument #${index} is required`);
                        return;
                    }

                    if (rule.default !== undefined) {
                        parsedArgs.push(rule.default);
                    }

                    continue;
                }

                if (rule.types) {
                    const prevLengthOuter = parsedArgs.length;

                    for (const type of rule.types) {
                        const prevLength = parsedArgs.length;

                        if (
                            /^(\-)?[\d\.]+$/.test(arg) &&
                            (((rule.minValue || rule.maxValue) && type === ArgumentType.Float) ||
                                type === ArgumentType.Integer ||
                                type === ArgumentType.Number)
                        ) {
                            const float = parseFloat(arg);

                            if (
                                !isNaN(float) &&
                                ((rule.minValue !== undefined && rule.minValue > float) ||
                                    (rule.maxValue !== undefined && rule.maxValue < float))
                            ) {
                                await message.reply(
                                    rule.minMaxErrorMessage ??
                                        `Argument #${index} has a min/max numeric value range but the given value is out of range.`
                                );
                                return;
                            }
                        }

                        switch (type) {
                            case ArgumentType.Boolean:
                                if (["true", "false"].includes(arg.toLowerCase())) {
                                    parsedArgs[index] = arg.toLowerCase() === "true";
                                }

                                break;

                            case ArgumentType.Float:
                                const float = parseFloat(arg);

                                if (isNaN(float)) {
                                    break;
                                }

                                parsedArgs[index] = float;
                                break;

                            case ArgumentType.Integer:
                                if (!/^(\-)?\d+$/.test(arg)) {
                                    break;
                                }

                                const int = parseInt(arg);

                                if (isNaN(int)) {
                                    break;
                                }

                                parsedArgs[index] = int;
                                break;

                            case ArgumentType.Number:
                                const number = arg.includes(".") ? parseFloat(arg) : parseInt(arg);

                                if (isNaN(number)) {
                                    break;
                                }

                                parsedArgs[index] = number;
                                break;

                            case ArgumentType.TimeInterval:
                                const { result, error } = stringToTimeInterval(arg, {
                                    milliseconds: rule.timeMilliseconds ?? false
                                });

                                if (error) {
                                    if (rule.types.length === 1) {
                                        await message
                                            .reply({
                                                ephemeral: true,
                                                content: `${this.emoji("error")} ${error}`
                                            })
                                            .catch(logError);

                                        return;
                                    }

                                    break;
                                }

                                if (
                                    !isNaN(result) &&
                                    ((rule.minValue !== undefined && rule.minValue > result) ||
                                        (rule.maxValue !== undefined && rule.maxValue < result))
                                ) {
                                    await message.reply(
                                        `${this.emoji("error")} ` + rule.minMaxErrorMessage ??
                                            `Argument #${index} has a min/max numeric time value range but the given value is out of range.`
                                    );
                                    return;
                                }

                                parsedArgs[index] = result;
                                break;

                            case ArgumentType.Link:
                                try {
                                    parsedArgs[index] = new URL(arg);
                                } catch (e) {
                                    break;
                                }

                                break;

                            case ArgumentType.String:
                                if (arg.trim() === "") break;

                                parsedArgs[index] = arg;
                                break;

                            case ArgumentType.Snowflake:
                                if (!isSnowflake(arg)) break;

                                parsedArgs[index] = arg;
                                break;

                            case ArgumentType.User:
                            case ArgumentType.GuildMember:
                            case ArgumentType.Channel:
                            case ArgumentType.Role:
                                // TODO: Use message.mentions object to improve performance and reduce API requests

                                let id;

                                if (MessageMentions.UsersPattern.test(arg)) {
                                    id = arg.substring(arg.includes("!") ? 3 : 2, arg.length - 1);
                                } else if (MessageMentions.ChannelsPattern.test(arg)) {
                                    id = arg.substring(2, arg.length - 1);
                                } else if (MessageMentions.RolesPattern.test(arg)) {
                                    id = arg.substring(3, arg.length - 1);
                                } else if (isSnowflake(arg)) {
                                    id = arg;
                                } else {
                                    break;
                                }

                                try {
                                    let entity = null;

                                    if (type === ArgumentType.User) entity = await this.client.users.fetch(id);
                                    else {
                                        entity =
                                            type === ArgumentType.Role
                                                ? await message.guild!.roles.fetch(id)
                                                : type === ArgumentType.Channel
                                                ? await message.guild!.channels.fetch(id)
                                                : await message.guild!.members.fetch(id);
                                    }

                                    if (!entity) {
                                        throw new Error("Invalid entity received");
                                    }

                                    parsedArgs[index] = entity;
                                } catch (e) {
                                    logError(e);

                                    if (rule.entityNotNull) {
                                        await message.reply(
                                            `${this.emoji("error")} ` + rule.entityNotNullErrorMessage ??
                                                `Argument ${index} is invalid`
                                        );
                                        return;
                                    }

                                    parsedArgs[index] = null;
                                }

                                break;

                            case ArgumentType.StringRest:
                                if (arg.trim() === "") break;

                                let str = ((message as Message).content ?? "")
                                    .slice(context.prefix.length)
                                    .trimStart()
                                    .slice(context.argv[0].length)
                                    .trimStart();

                                for (let i = 0; i < index; i++) {
                                    str = str.slice(context.args[i].length).trimStart();
                                }

                                str = str.trimEnd();

                                if (str === "") break;

                                parsedArgs[index] = str;

                                if (rule.name) {
                                    parsedNamedArgs[rule.name] = parsedArgs[index];
                                }

                                break loop;
                        }

                        if (
                            rule.lengthMax !== undefined &&
                            typeof parsedArgs[index] === "string" &&
                            parsedArgs[index].length > rule.lengthMax
                        ) {
                            await message.reply(
                                `${this.emoji("error")} ` + rule.lengthMaxErrorMessage ?? `Argument #${index} is too long`
                            );
                            return;
                        }

                        if (prevLength !== parsedArgs.length) {
                            break;
                        }
                    }

                    if (prevLengthOuter === parsedArgs.length) {
                        await message.reply(
                            `${this.emoji("error")} ` + rule.typeErrorMessage ?? `Argument #${index} is invalid, type mismatch`
                        );
                        return;
                    }
                }

                if (rule.name) {
                    parsedNamedArgs[rule.name] = parsedArgs[index];
                }

                index++;
            }
        }

        if (!checkOnly) {
            return await this.execute(message, {
                ...context,
                ...(context.isLegacy
                    ? {
                          parsedArgs,
                          parsedNamedArgs
                      }
                    : {})
            });
        }
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import {
21			APIMessage,
22			ApplicationCommandType,
23			CacheType,
24			ChatInputCommandInteraction,
25			ContextMenuCommandBuilder,
26			ContextMenuCommandInteraction,
27			GuildBasedChannel,
28			GuildMember,
29			InteractionDeferReplyOptions,
30			InteractionEditReplyOptions,
31			InteractionReplyOptions,
32			Message,
33			MessageCreateOptions,
34			MessageMentions,
35			MessagePayload,
36			PermissionResolvable,
37			PermissionsBitField,
38			Role,
39			SlashCommandBuilder,
40			Snowflake,
41			User
42			} from "discord.js";
43			import { ChatInputCommandContext, ContextMenuCommandContext, LegacyCommandContext } from "../services/CommandManager";
44			import { stringToTimeInterval } from "../utils/datetime";
45			import { log, logError } from "../utils/logger";
46			import { getEmoji, isSnowflake } from "../utils/utils";
47			import Client from "./Client";
48
49			export type CommandMessage = Message<boolean> \| ChatInputCommandInteraction<CacheType> \| ContextMenuCommandInteraction;
50			export type BasicCommandContext = LegacyCommandContext \| ChatInputCommandContext;
51			export type AnyCommandContext = BasicCommandContext \| ContextMenuCommandContext;
52			export type CommandReturn =
53			\| ((MessageCreateOptions \| APIMessage \| InteractionReplyOptions) & { __reply?: boolean })
54			\| undefined
55			\| null
56			\| void;
57
58			export enum ArgumentType {
59			String = 1,
60			StringRest,
61			Number,
62			Integer,
63			Float,
64			Boolean,
65			Snowflake,
66			User,
67			GuildMember,
68			Channel,
69			Role,
70			Link,
71			TimeInterval
72			}
73
74			export interface ValidationRule {
75			types?: readonly ArgumentType[];
76			optional?: boolean;
77			default?: any;
78			requiredErrorMessage?: string;
79			typeErrorMessage?: string;
80			entityNotNullErrorMessage?: string;
81			entityNotNull?: boolean;
82			minValue?: number;
83			maxValue?: number;
84			minMaxErrorMessage?: string;
85			lengthMaxErrorMessage?: string;
86			lengthMax?: number;
87			name?: string;
88			timeMilliseconds?: boolean;
89			}
90
91			type ValidationRuleAndOutputMap = {
92			[ArgumentType.Boolean]: boolean;
93			[ArgumentType.Channel]: GuildBasedChannel;
94			[ArgumentType.Float]: number;
95			[ArgumentType.Number]: number;
96			[ArgumentType.Integer]: number;
97			[ArgumentType.TimeInterval]: number;
98			[ArgumentType.Link]: string;
99			[ArgumentType.Role]: Role;
100			[ArgumentType.Snowflake]: Snowflake;
101			[ArgumentType.String]: string;
102			[ArgumentType.StringRest]: string;
103			[ArgumentType.User]: User;
104			[ArgumentType.GuildMember]: GuildMember;
105			};
106
107			type ValidationRuleParsedArg<T extends ValidationRule["types"]> = T extends ReadonlyArray<infer U>
108			? U extends keyof ValidationRuleAndOutputMap
109			? ValidationRuleAndOutputMap[U]
110			: never
111			: T extends Array<infer U>
112			? U extends keyof ValidationRuleAndOutputMap
113			? ValidationRuleAndOutputMap[U]
114			: never
115			: never;
116
117			export type ValidationRuleParsedArgs<T extends readonly ValidationRule[]> = {
118			[K in keyof T]: ValidationRuleParsedArg<T[K]["types"]>;
119			};
120
121			// TODO: Split the logic into separate methods
122
123			export default abstract class Command {
124			public readonly name: string = "";
125			public group: string = "Default";
126			public readonly aliases: string[] = [];
127
128			public readonly supportsInteractions: boolean = true;
129			public readonly supportsLegacy: boolean = true;
130
131			public readonly permissions: PermissionResolvable[] = [];
132			public readonly validationRules: readonly ValidationRule[] = [];
133			public readonly permissionMode: "or" \| "and" = "and";
134			public readonly systemAdminOnly: boolean = false;
135
136			public readonly description?: string;
137			public readonly detailedDescription?: string;
138			public readonly argumentSyntaxes?: string[];
139			public readonly availableOptions?: Record<string, string>;
140			public readonly beta: boolean = false;
141			public readonly since: string = "1.0.0";
142			public readonly botRequiredPermissions: PermissionResolvable[] = [];
143			public readonly slashCommandBuilder?:
144			\| Partial<Pick<SlashCommandBuilder, "addSubcommand" \| "addSubcommandGroup">>
145			\| Omit<SlashCommandBuilder, "addSubcommand" \| "addSubcommandGroup">;
146
147			public readonly applicationCommandType: ApplicationCommandType = ApplicationCommandType.ChatInput;
148			public readonly otherApplicationCommandBuilders: (ContextMenuCommandBuilder \| SlashCommandBuilder)[] = [];
149
150			public readonly subcommands: string[] = [];
151
152			constructor(protected client: Client) {}
153
154			abstract execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn>;
155
156			async deferIfInteraction(message: CommandMessage, options?: InteractionDeferReplyOptions) {
157			if (message instanceof ChatInputCommandInteraction) return await message.deferReply(options).catch(logError);
158			}
159
160			async deferredReply(
161			message: CommandMessage,
162			options: MessageCreateOptions \| MessagePayload \| InteractionEditReplyOptions \| string
163			) {
164			if (message instanceof ChatInputCommandInteraction \|\| message instanceof ContextMenuCommandInteraction) {
165			return message.deferred ? await message.editReply(options) : await message.reply(options as any);
166			}
167
168			return message.reply(options as any);
169			}
170
171			async error(message: CommandMessage, errorMessage?: string) {
172			return await this.deferredReply(
173			message,
174			errorMessage
175			? `${this.emoji("error")} ${errorMessage}`
176			: `⚠️ An error has occurred while performing this action. Please make sure that the bot has the required permissions to perform this action.`
177			);
178			}
179
180			async success(message: CommandMessage, successMessage?: string) {
181			return await this.deferredReply(
182			message,
183			successMessage ? `${this.emoji("check")} ${successMessage}` : `Successfully completed the given task.`
184			);
185			}
186
187			emoji(name: string) {
188			return getEmoji(this.client, name);
189			}
190
191			async run(message: CommandMessage, context: AnyCommandContext, checkOnly = false) {
192			const isSystemAdmin = this.client.configManager.systemConfig.system_admins.includes(message.member!.user.id);
193
194			if (this.systemAdminOnly && !isSystemAdmin) {
195			message
196			.reply({
197			content: `${this.emoji("error")} You don't have permission to run this command.`,
198			ephemeral: true
199			})
200			.catch(logError);
201
202			return;
203			}
204
205			if (!isSystemAdmin) {
206			const commandName = this.client.commands.get(context.isLegacy ? context.argv[0] : context.commandName)?.name;
207			const { disabled_commands } = this.client.configManager.systemConfig;
208
209			if (disabled_commands.includes(commandName ?? "")) {
210			await this.error(message, "This command is disabled.");
211			return;
212			}
213
214			const { channels, guild } = this.client.configManager.config[message.guildId!]?.disabled_commands ?? {};
215
216			if (guild && guild.includes(commandName ?? "")) {
217			await this.error(message, "This command is disabled in this server.");
218			return;
219			}
220
221			if (channels && channels[message.channelId!] && channels[message.channelId!].includes(commandName ?? "")) {
222			await this.error(message, "This command is disabled in this channel.");
223			return;
224			}
225			}
226
227			const { validationRules, permissions } = this;
228			const parsedArgs = [];
229			const parsedNamedArgs: Record<string, any> = {};
230
231			if (!isSystemAdmin) {
232			let member: GuildMember = <any>message.member!;
233
234			if (!(member.permissions as any)?.has) {
235			try {
236			member = await message.guild!.members.fetch(member.user.id);
237
238			if (!member) {
239			throw new Error("Invalid member");
240			}
241			} catch (e) {
242			logError(e);
243			message
244			.reply({
245			content: `Sorry, I couldn't determine whether you have the enough permissions to perform this action or not. Please contact the bot developer.`,
246			ephemeral: true
247			})
248			.catch(logError);
249			return;
250			}
251			}
252
253			const mode = this.client.configManager.config[message.guildId!]?.permissions?.mode;
254
255			if (permissions.length > 0) {
256			const memberBotPermissions = this.client.permissionManager.getMemberPermissions(member);
257			const memberRequiredPermissions = new PermissionsBitField(permissions).toArray();
258
259			if (this.permissionMode === "and") {
260			for (const permission of permissions) {
261			if (!member.permissions.has(permission, true)) {
262			const mode = this.client.configManager.config[message.guildId!]?.permissions?.mode;
263
264			if (mode !== "advanced" && mode !== "levels") {
265			await message.reply({
266			content: `${this.emoji("error")} You don't have permission to run this command.`,
267			ephemeral: true
268			});
269
270			log("Skip");
271
272			return;
273			}
274
275			const memberBotPermissions = this.client.permissionManager.getMemberPermissions(member);
276			const memberRequiredPermissions = new PermissionsBitField(permissions).toArray();
277
278			log("PERMS: ", [...memberBotPermissions.values()]);
279			log("PERMS 2: ", memberRequiredPermissions);
280
281			for (const memberRequiredPermission of memberRequiredPermissions) {
282			if (!memberBotPermissions.has(memberRequiredPermission)) {
283			await message.reply({
284			content: `${this.emoji("error")} You don't have permission to run this command.`,
285			ephemeral: true
286			});
287
288			return;
289			}
290			}
291			}
292			}
293			} else
294			orMode: {
295			for (const permission of permissions) {
296			if (member.permissions.has(permission, true)) {
297			break orMode;
298			}
299			}
300
301			if (mode === "advanced" \|\| mode === "levels") {
302			for (const memberRequiredPermission of memberRequiredPermissions) {
303			if (memberBotPermissions.has(memberRequiredPermission)) {
304			break orMode;
305			}
306			}
307			}
308
309			await message.reply({
310			content: `${this.emoji("error")} You don't have enough permissions to run this command.`,
311			ephemeral: true
312			});
313
314			return;
315			}
316			}
317
318			const permissionOverwrite = this.client.commandManager.permissionOverwrites.get(
319			`${message.guildId!}____${this.name}`
320			);
321
322			log([...this.client.commandManager.permissionOverwrites.keys()]);
323
324			errorRootBlock: if (permissionOverwrite) {
325			let userCheckPassed = false;
326			let levelCheckPassed = false;
327			let roleCheckPassed = false;
328			let permissonCheckPassed = false;
329
330			permissionOverwriteIfBlock: {
331			if (permissionOverwrite.requiredUsers.length > 0) {
332			userCheckPassed = permissionOverwrite.requiredUsers.includes(member.user.id);
333
334			if (permissionOverwrite.mode === "AND" && !userCheckPassed) {
335			break permissionOverwriteIfBlock;
336			}
337
338			if (permissionOverwrite.mode === "OR" && userCheckPassed) {
339			log("User check passed [OR]");
340			break errorRootBlock;
341			}
342			}
343
344			if (mode === "levels" && permissionOverwrite.requiredLevel !== null) {
345			const level = this.client.permissionManager.getMemberPermissionLevel(member);
346			levelCheckPassed = level >= permissionOverwrite.requiredLevel;
347
348			log("level", level, "<", permissionOverwrite.requiredLevel);
349
350			if (!levelCheckPassed && permissionOverwrite.mode === "AND") {
351			break permissionOverwriteIfBlock;
352			} else if (levelCheckPassed && permissionOverwrite.mode === "OR") {
353			log("Level check passed [OR]");
354			break errorRootBlock;
355			}
356			}
357
358			if (permissionOverwrite.requiredPermissions.length > 0) {
359			const requiredPermissions = permissionOverwrite.requiredPermissions as PermissionResolvable[];
360
361			if (permissionOverwrite.requiredPermissionMode === "OR") {
362			let found = false;
363
364			for (const permission of requiredPermissions) {
365			if (member.permissions.has(permission, true)) {
366			found = true;
367			break;
368			}
369			}
370
371			permissonCheckPassed = found;
372
373			if (!found && permissionOverwrite.mode === "AND") {
374			break permissionOverwriteIfBlock;
375			} else if (found && permissionOverwrite.mode === "OR") {
376			log("Permission check passed [OR_OR]");
377			break errorRootBlock;
378			}
379			} else {
380			log(requiredPermissions);
381			permissonCheckPassed = member.permissions.has(requiredPermissions, true);
382
383			if (!permissonCheckPassed && permissionOverwrite.mode === "AND") {
384			log("Fail");
385			break permissionOverwriteIfBlock;
386			} else if (permissonCheckPassed && permissionOverwrite.mode === "OR") {
387			log("Permission check passed [AND_OR]");
388			break errorRootBlock;
389			}
390			}
391			}
392
393			if (permissionOverwrite.requiredRoles.length > 0) {
394			roleCheckPassed = member.roles.cache.hasAll(...permissionOverwrite.requiredRoles);
395
396			if (!roleCheckPassed && permissionOverwrite.mode === "AND") {
397			break permissionOverwriteIfBlock;
398			} else if (roleCheckPassed && permissionOverwrite.mode === "OR") {
399			break errorRootBlock;
400			}
401			}
402
403			log("userCheckPassed", userCheckPassed);
404			log("levelCheckPassed", levelCheckPassed);
405			log("permissonCheckPassed", permissonCheckPassed);
406			log("roleCheckPassed", roleCheckPassed);
407
408			if (permissionOverwrite.mode === "OR") {
409			break permissionOverwriteIfBlock;
410			}
411
412			if (
413			permissionOverwrite.requiredChannels.length > 0 &&
414			!permissionOverwrite.requiredChannels.includes(message.channelId!)
415			) {
416			await message.reply({
417			content: `${this.emoji("error")} This command is disabled in this channel.`,
418			ephemeral: true
419			});
420
421			return;
422			}
423
424			break errorRootBlock;
425			}
426
427			await message.reply({
428			content: `${this.emoji("error")} You don't have enough permissions to run this command.`,
429			ephemeral: true
430			});
431
432			return;
433			}
434			}
435
436			if (context.isLegacy) {
437			let index = 0;
438
439			loop: for await (const rule of validationRules) {
440			const arg = context.args[index];
441
442			if (arg === undefined) {
443			if (!rule.optional) {
444			await this.error(message, rule.requiredErrorMessage ?? `Argument #${index} is required`);
445			return;
446			}
447
448			if (rule.default !== undefined) {
449			parsedArgs.push(rule.default);
450			}
451
452			continue;
453			}
454
455			if (rule.types) {
456			const prevLengthOuter = parsedArgs.length;
457
458			for (const type of rule.types) {
459			const prevLength = parsedArgs.length;
460
461			if (
462			/^(\-)?[\d\.]+$/.test(arg) &&
463			(((rule.minValue \|\| rule.maxValue) && type === ArgumentType.Float) \|\|
464			type === ArgumentType.Integer \|\|
465			type === ArgumentType.Number)
466			) {
467			const float = parseFloat(arg);
468
469			if (
470			!isNaN(float) &&
471			((rule.minValue !== undefined && rule.minValue > float) \|\|
472			(rule.maxValue !== undefined && rule.maxValue < float))
473			) {
474			await message.reply(
475			rule.minMaxErrorMessage ??
476			`Argument #${index} has a min/max numeric value range but the given value is out of range.`
477			);
478			return;
479			}
480			}
481
482			switch (type) {
483			case ArgumentType.Boolean:
484			if (["true", "false"].includes(arg.toLowerCase())) {
485			parsedArgs[index] = arg.toLowerCase() === "true";
486			}
487
488			break;
489
490			case ArgumentType.Float:
491			const float = parseFloat(arg);
492
493			if (isNaN(float)) {
494			break;
495			}
496
497			parsedArgs[index] = float;
498			break;
499
500			case ArgumentType.Integer:
501			if (!/^(\-)?\d+$/.test(arg)) {
502			break;
503			}
504
505			const int = parseInt(arg);
506
507			if (isNaN(int)) {
508			break;
509			}
510
511			parsedArgs[index] = int;
512			break;
513
514			case ArgumentType.Number:
515			const number = arg.includes(".") ? parseFloat(arg) : parseInt(arg);
516
517			if (isNaN(number)) {
518			break;
519			}
520
521			parsedArgs[index] = number;
522			break;
523
524			case ArgumentType.TimeInterval:
525			const { result, error } = stringToTimeInterval(arg, {
526			milliseconds: rule.timeMilliseconds ?? false
527			});
528
529			if (error) {
530			if (rule.types.length === 1) {
531			await message
532			.reply({
533			ephemeral: true,
534			content: `${this.emoji("error")} ${error}`
535			})
536			.catch(logError);
537
538			return;
539			}
540
541			break;
542			}
543
544			if (
545			!isNaN(result) &&
546			((rule.minValue !== undefined && rule.minValue > result) \|\|
547			(rule.maxValue !== undefined && rule.maxValue < result))
548			) {
549			await message.reply(
550			`${this.emoji("error")} ` + rule.minMaxErrorMessage ??
551			`Argument #${index} has a min/max numeric time value range but the given value is out of range.`
552			);
553			return;
554			}
555
556			parsedArgs[index] = result;
557			break;
558
559			case ArgumentType.Link:
560			try {
561			parsedArgs[index] = new URL(arg);
562			} catch (e) {
563			break;
564			}
565
566			break;
567
568			case ArgumentType.String:
569			if (arg.trim() === "") break;
570
571			parsedArgs[index] = arg;
572			break;
573
574			case ArgumentType.Snowflake:
575			if (!isSnowflake(arg)) break;
576
577			parsedArgs[index] = arg;
578			break;
579
580			case ArgumentType.User:
581			case ArgumentType.GuildMember:
582			case ArgumentType.Channel:
583			case ArgumentType.Role:
584			// TODO: Use message.mentions object to improve performance and reduce API requests
585
586			let id;
587
588			if (MessageMentions.UsersPattern.test(arg)) {
589			id = arg.substring(arg.includes("!") ? 3 : 2, arg.length - 1);
590			} else if (MessageMentions.ChannelsPattern.test(arg)) {
591			id = arg.substring(2, arg.length - 1);
592			} else if (MessageMentions.RolesPattern.test(arg)) {
593			id = arg.substring(3, arg.length - 1);
594			} else if (isSnowflake(arg)) {
595			id = arg;
596			} else {
597			break;
598			}
599
600			try {
601			let entity = null;
602
603			if (type === ArgumentType.User) entity = await this.client.users.fetch(id);
604			else {
605			entity =
606			type === ArgumentType.Role
607			? await message.guild!.roles.fetch(id)
608			: type === ArgumentType.Channel
609			? await message.guild!.channels.fetch(id)
610			: await message.guild!.members.fetch(id);
611			}
612
613			if (!entity) {
614			throw new Error("Invalid entity received");
615			}
616
617			parsedArgs[index] = entity;
618			} catch (e) {
619			logError(e);
620
621			if (rule.entityNotNull) {
622			await message.reply(
623			`${this.emoji("error")} ` + rule.entityNotNullErrorMessage ??
624			`Argument ${index} is invalid`
625			);
626			return;
627			}
628
629			parsedArgs[index] = null;
630			}
631
632			break;
633
634			case ArgumentType.StringRest:
635			if (arg.trim() === "") break;
636
637			let str = ((message as Message).content ?? "")
638			.slice(context.prefix.length)
639			.trimStart()
640			.slice(context.argv[0].length)
641			.trimStart();
642
643			for (let i = 0; i < index; i++) {
644			str = str.slice(context.args[i].length).trimStart();
645			}
646
647			str = str.trimEnd();
648
649			if (str === "") break;
650
651			parsedArgs[index] = str;
652
653			if (rule.name) {
654			parsedNamedArgs[rule.name] = parsedArgs[index];
655			}
656
657			break loop;
658			}
659
660			if (
661			rule.lengthMax !== undefined &&
662			typeof parsedArgs[index] === "string" &&
663			parsedArgs[index].length > rule.lengthMax
664			) {
665			await message.reply(
666			`${this.emoji("error")} ` + rule.lengthMaxErrorMessage ?? `Argument #${index} is too long`
667			);
668			return;
669			}
670
671			if (prevLength !== parsedArgs.length) {
672			break;
673			}
674			}
675
676			if (prevLengthOuter === parsedArgs.length) {
677			await message.reply(
678			`${this.emoji("error")} ` + rule.typeErrorMessage ?? `Argument #${index} is invalid, type mismatch`
679			);
680			return;
681			}
682			}
683
684			if (rule.name) {
685			parsedNamedArgs[rule.name] = parsedArgs[index];
686			}
687
688			index++;
689			}
690			}
691
692			if (!checkOnly) {
693			return await this.execute(message, {
694			...context,
695			...(context.isLegacy
696			? {
697			parsedArgs,
698			parsedNamedArgs
699			}
700			: {})
701			});
702			}
703			}
704			}