reciple 5.4.0 → 5.4.1-pre.1

package/bin/mjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -0,0 +1,218 @@
+import { CommandBuilderType } from '../../types/builders';
+import { normalizeArray } from 'discord.js';
+import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
+/**
+ * Reciple builder for message command
+ */
+export class MessageCommandBuilder {
+    type = CommandBuilderType.MessageCommand;
+    name = '';
+    description = '';
+    cooldown = 0;
+    aliases = [];
+    validateOptions = false;
+    options = [];
+    requiredBotPermissions = [];
+    requiredMemberPermissions = [];
+    allowExecuteInDM = true;
+    allowExecuteByBots = false;
+    halt;
+    execute = () => { };
+    constructor(data) {
+        if (data?.name !== undefined)
+            this.setName(data.name);
+        if (data?.description !== undefined)
+            this.setDescription(data.description);
+        if (data?.cooldown !== undefined)
+            this.setCooldown(Number(data?.cooldown));
+        if (data?.requiredBotPermissions !== undefined)
+            this.setRequiredBotPermissions(data.requiredBotPermissions);
+        if (data?.requiredMemberPermissions !== undefined)
+            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
+        if (data?.halt !== undefined)
+            this.setHalt(this.halt);
+        if (data?.execute !== undefined)
+            this.setExecute(data.execute);
+        if (data?.aliases !== undefined)
+            this.addAliases(data.aliases);
+        if (data?.allowExecuteByBots)
+            this.setAllowExecuteByBots(true);
+        if (data?.allowExecuteInDM)
+            this.setAllowExecuteInDM(true);
+        if (data?.validateOptions)
+            this.setValidateOptions(true);
+        if (data?.options !== undefined)
+            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder(o));
+    }
+    /**
+     * Sets the command name
+     * @param name Command name
+     */
+    setName(name) {
+        if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+            throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
+        this.name = name;
+        return this;
+    }
+    /**
+     * Sets the command description
+     * @param description Command description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Add aliases to the command
+     * @param aliases Command aliases
+     */
+    addAliases(...aliases) {
+        aliases = normalizeArray(aliases);
+        if (!aliases.length)
+            throw new TypeError('Provide atleast one alias');
+        if (aliases.some(a => !a || typeof a !== 'string' || a.match(/^\s+$/)))
+            throw new TypeError('aliases must be strings and should not contain whitespaces');
+        if (this.name && aliases.some(a => a == this.name))
+            throw new TypeError('alias cannot have same name to its real command name');
+        this.aliases = [...new Set(aliases.map(s => s.toLowerCase()))];
+        return this;
+    }
+    /**
+     * Set if command can be executed in dms
+     * @param allowExecuteInDM `true` if the command can execute in DMs
+     */
+    setAllowExecuteInDM(allowExecuteInDM) {
+        if (typeof allowExecuteInDM !== 'boolean')
+            throw new TypeError('allowExecuteInDM must be a boolean.');
+        this.allowExecuteInDM = allowExecuteInDM;
+        return this;
+    }
+    /**
+     * Allow command to be executed by bots
+     * @param allowExecuteByBots `true` if the command can be executed by bots
+     */
+    setAllowExecuteByBots(allowExecuteByBots) {
+        if (typeof allowExecuteByBots !== 'boolean')
+            throw new TypeError('allowExecuteByBots must be a boolean.');
+        this.allowExecuteByBots = allowExecuteByBots;
+        return this;
+    }
+    /**
+     * Add option to the command
+     * @param option Message option builder
+     */
+    addOption(option) {
+        if (!option)
+            throw new TypeError('option must be a MessageOption.');
+        option = typeof option === 'function' ? option(new MessageCommandOptionBuilder()) : option;
+        if (this.options.find(o => o.name === option.name))
+            throw new TypeError('option with name "' + option.name + '" already exists.');
+        if (this.options.length > 0 && !this.options[this.options.length - 1 < 0 ? 0 : this.options.length - 1].required && option.required)
+            throw new TypeError('All required options must be before optional options.');
+        this.options = [...this.options, option];
+        return this;
+    }
+    /**
+     * Validate options before executing
+     * @param validateOptions `true` if the command options needs to be validated before executing
+     */
+    setValidateOptions(validateOptions) {
+        if (typeof validateOptions !== 'boolean')
+            throw new TypeError('validateOptions must be a boolean.');
+        this.validateOptions = validateOptions;
+        return this;
+    }
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setRequiredMemberPermissions(...permissions) {
+        this.requiredMemberPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setHalt(halt) {
+        this.halt = halt ?? undefined;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new TypeError('execute must be a function.');
+        this.execute = execute;
+        return this;
+    }
+    /**
+     * Returns JSON object of this builder
+     */
+    toJSON() {
+        return {
+            type: this.type,
+            name: this.name,
+            description: this.description,
+            aliases: this.aliases,
+            cooldown: this.cooldown,
+            requiredBotPermissions: this.requiredBotPermissions,
+            requiredMemberPermissions: this.requiredMemberPermissions,
+            halt: this.halt,
+            execute: this.execute,
+            allowExecuteByBots: this.allowExecuteByBots,
+            allowExecuteInDM: this.allowExecuteInDM,
+            validateOptions: this.validateOptions,
+            options: this.options.map(o => o.toJSON()),
+        };
+    }
+    static resolveMessageCommand(commandData) {
+        return this.isMessageCommandBuilder(commandData) ? commandData : new MessageCommandBuilder(commandData);
+    }
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder) {
+        return builder instanceof MessageCommandBuilder;
+    }
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
+    }
+}
+export async function validateMessageCommandOptions(builder, options) {
+    const args = options.args || [];
+    const required = builder.options.filter(o => o.required);
+    const optional = builder.options.filter(o => !o.required);
+    const allOptions = [...required, ...optional];
+    const result = [];
+    let i = 0;
+    for (const option of allOptions) {
+        const arg = args[i];
+        const value = {
+            name: option.name,
+            value: arg ?? undefined,
+            required: option.required,
+            invalid: false,
+            missing: false
+        };
+        if (arg == undefined && option.required) {
+            value.missing = true;
+            result.push(value);
+            continue;
+        }
+        if (arg == undefined && !option.required) {
+            result.push(value);
+            continue;
+        }
+        const validate = option.validator ? await Promise.resolve(option.validator(arg)) : true;
+        if (!validate)
+            value.invalid = true;
+        result.push(value);
+        i++;
+    }
+    return new MessageCommandOptionManager(...result);
+}

package/bin/mjs/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -0,0 +1,67 @@
+/**
+ * Option builder for MessageCommandBuilder
+ */
+export class MessageCommandOptionBuilder {
+    name = '';
+    description = '';
+    required = false;
+    validator = () => true;
+    constructor(data) {
+        if (data?.name !== undefined)
+            this.setName(data.name);
+        if (data?.description !== undefined)
+            this.setDescription(data.description);
+        if (data?.required !== undefined)
+            this.setRequired(data.required);
+        if (data?.validator !== undefined)
+            this.setValidator(data.validator);
+    }
+    /**
+     * Set command option name
+     * @param name Option name
+     */
+    setName(name) {
+        if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
+            throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
+        this.name = name;
+        return this;
+    }
+    /**
+     * Set command option description
+     * @param description Option description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Set if this option is required
+     * @param required `true` if this option is required
+     */
+    setRequired(required) {
+        if (typeof required !== 'boolean')
+            throw new TypeError('required must be a boolean.');
+        this.required = required;
+        return this;
+    }
+    /**
+     * Set your custom function to validate given value for this option
+     * @param validator Custom function to validate value given for this option
+     */
+    setValidator(validator) {
+        if (!validator || typeof validator !== 'function')
+            throw new TypeError('validator must be a function.');
+        this.validator = validator;
+        return this;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            required: this.required,
+            validator: this.validator,
+        };
+    }
+}

package/bin/mjs/reciple/classes/builders/SlashCommandBuilder.js

@@ -0,0 +1,204 @@
+import { CommandBuilderType } from '../../types/builders';
+import { isClass } from '../../util';
+import { normalizeArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, ApplicationCommandOptionType } from 'discord.js';
+/**
+ * Reciple builder for slash command
+ */
+export class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    type = CommandBuilderType.SlashCommand;
+    cooldown = 0;
+    requiredBotPermissions = [];
+    requiredMemberPermissions = [];
+    halt;
+    execute = () => { };
+    constructor(data) {
+        super();
+        if (data?.name !== undefined)
+            this.setName(data.name);
+        if (data?.description !== undefined)
+            this.setDescription(data.description);
+        if (data?.cooldown !== undefined)
+            this.setCooldown(Number(data?.cooldown));
+        if (data?.requiredBotPermissions !== undefined)
+            this.setRequiredBotPermissions(data.requiredBotPermissions);
+        if (data?.requiredMemberPermissions !== undefined)
+            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
+        if (data?.halt !== undefined)
+            this.setHalt(this.halt);
+        if (data?.execute !== undefined)
+            this.setExecute(data.execute);
+        if (data?.nameLocalizations !== undefined)
+            this.setNameLocalizations(data.nameLocalizations);
+        if (data?.descriptionLocalizations !== undefined)
+            this.setDescriptionLocalizations(data.descriptionLocalizations);
+        if (data?.defaultMemberPermissions !== undefined)
+            this.setDefaultMemberPermissions(data.defaultMemberPermissions);
+        if (data?.dmPermission)
+            this.setDMPermission(true);
+        if (data?.defaultPermission)
+            this.setDefaultPermission(true);
+        if (data?.options) {
+            for (const option of data.options) {
+                SlashCommandBuilder.addOption(this, isClass(option) ? option : SlashCommandBuilder.resolveOption(option));
+            }
+        }
+    }
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setRequiredMemberPermissions(...permissions) {
+        this.requiredMemberPermissions = normalizeArray(permissions);
+        return this;
+    }
+    setHalt(halt) {
+        this.halt = halt ?? undefined;
+        return this;
+    }
+    setExecute(execute) {
+        if (!execute || typeof execute !== 'function')
+            throw new Error('execute must be a function.');
+        this.execute = execute;
+        return this;
+    }
+    /**
+     * Add option builder to command builder
+     */
+    static addOption(builder, option) {
+        if (option instanceof SlashCommandAttachmentOption) {
+            builder.addAttachmentOption(option);
+        }
+        else if (option instanceof SlashCommandBooleanOption) {
+            builder.addBooleanOption(option);
+        }
+        else if (option instanceof SlashCommandChannelOption) {
+            builder.addChannelOption(option);
+        }
+        else if (option instanceof SlashCommandIntegerOption) {
+            builder.addIntegerOption(option);
+        }
+        else if (option instanceof SlashCommandMentionableOption) {
+            builder.addMentionableOption(option);
+        }
+        else if (option instanceof SlashCommandNumberOption) {
+            builder.addNumberOption(option);
+        }
+        else if (option instanceof SlashCommandRoleOption) {
+            builder.addRoleOption(option);
+        }
+        else if (option instanceof SlashCommandStringOption) {
+            builder.addStringOption(option);
+        }
+        else if (option instanceof SlashCommandUserOption) {
+            builder.addUserOption(option);
+        }
+        else if (builder instanceof SlashCommandBuilder) {
+            if (option instanceof SlashCommandSubcommandBuilder) {
+                builder.addSubcommand(option);
+            }
+            else if (option instanceof SlashCommandSubcommandGroupBuilder) {
+                builder.addSubcommandGroup(option);
+            }
+        }
+        return builder;
+    }
+    /**
+     * Resolve option data
+     */
+    static resolveOption(option) {
+        let builder;
+        switch (option.type) {
+            case ApplicationCommandOptionType.Attachment:
+                builder = new SlashCommandAttachmentOption();
+                break;
+            case ApplicationCommandOptionType.Boolean:
+                builder = new SlashCommandBooleanOption();
+                break;
+            case ApplicationCommandOptionType.Channel:
+                builder = new SlashCommandChannelOption()
+                    .addChannelTypes(...(option.channelTypes ?? []));
+                break;
+            case ApplicationCommandOptionType.Integer:
+                builder = new SlashCommandIntegerOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case ApplicationCommandOptionType.Mentionable:
+                builder = new SlashCommandMentionableOption();
+                break;
+            case ApplicationCommandOptionType.Number:
+                builder = new SlashCommandNumberOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case ApplicationCommandOptionType.Role:
+                builder = new SlashCommandRoleOption();
+                break;
+            case ApplicationCommandOptionType.String:
+                builder = new SlashCommandStringOption()
+                    .addChoices(...(option.choices ?? []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxLength)
+                    builder.setMaxLength(option.maxLength);
+                if (option.minLength)
+                    builder.setMinLength(option.minLength);
+                break;
+            case ApplicationCommandOptionType.User:
+                builder = new SlashCommandUserOption();
+                break;
+            case ApplicationCommandOptionType.Subcommand:
+                builder = new SlashCommandSubcommandBuilder();
+                for (const optionData of option.options) {
+                    this.addOption(builder, this.resolveOption(optionData));
+                }
+                break;
+            case ApplicationCommandOptionType.SubcommandGroup:
+                builder = new SlashCommandSubcommandGroupBuilder();
+                for (const subCommandData of option.options) {
+                    builder.addSubcommand(subCommandData instanceof SlashCommandSubcommandBuilder
+                        ? subCommandData
+                        : this.resolveOption(subCommandData));
+                }
+                break;
+            default:
+                throw new TypeError("Unknown option data");
+        }
+        if (!(builder instanceof SlashCommandSubcommandBuilder) && !(builder instanceof SlashCommandSubcommandGroupBuilder)
+            &&
+                option.type !== ApplicationCommandOptionType.Subcommand && option.type !== ApplicationCommandOptionType.SubcommandGroup) {
+            builder.setRequired(option.required ?? false);
+        }
+        return builder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setNameLocalizations(option.nameLocalizations ?? null)
+            .setDescriptionLocalizations(option.descriptionLocalizations ?? null);
+    }
+    static resolveSlashCommand(commandData) {
+        return this.isSlashCommandBuilder(commandData) ? commandData : new SlashCommandBuilder(commandData);
+    }
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder) {
+        return builder instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);
+    }
+}

package/bin/mjs/reciple/flags.js

@@ -0,0 +1,28 @@
+import { rawVersion } from './version';
+import { Command } from 'commander';
+/**
+ * Commander
+ */
+export const commander = new Command()
+    .name('reciple')
+    .description('Reciple.js - Discord.js handler cli')
+    .version(`v${rawVersion}`, '-v, --version')
+    .argument('[current-working-directory]', 'Change the current working directory')
+    .option('-t, --token <token>', 'Replace used bot token')
+    .option('-c, --config <config>', 'Change path to config file')
+    .option('-D, --debugmode', 'Enable debug mode')
+    .option('-y, --yes', 'Automatically agree to Reciple confirmation prompts')
+    .option('-v, --version', 'Display version')
+    .parse();
+/**
+ * Used flags
+ */
+export const flags = commander.opts();
+/**
+ * Token flag
+ */
+export const token = flags.token;
+/**
+ * Current working directory
+ */
+export const cwd = commander.args[0] || process.cwd();

package/bin/mjs/reciple/logger.js

@@ -0,0 +1,28 @@
+import { Logger, LogLevels } from 'fallout-utility';
+import { flags } from './flags';
+import chalk from 'chalk';
+/**
+ * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+export function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    return new Logger({
+        stringifyJSON: stringifyJSON,
+        enableDebugMode: flags.debugmode ?? debugmode,
+        loggerName: 'Main',
+        prefixes: {
+            [LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, { hour12: false })}][${(name ? name + "/" : '') + "INFO"}]`,
+            [LogLevels.WARN]: (name) => `[${chalk.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.yellow((name ? name + "/" : '') + "WARN")}]`,
+            [LogLevels.ERROR]: (name) => `[${chalk.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.red((name ? name + "/" : '') + "ERROR")}]`,
+            [LogLevels.DEBUG]: (name) => `[${chalk.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk.blue((name ? name + "/" : '') + "DEBUG")}]`
+        },
+        colorMessages: {
+            [LogLevels.INFO]: (message) => message,
+            [LogLevels.WARN]: (message) => !colorizeMessage ? message : chalk.yellow(message),
+            [LogLevels.ERROR]: (message) => !colorizeMessage ? message : chalk.red(message),
+            [LogLevels.DEBUG]: (message) => !colorizeMessage ? message : chalk.blue(message)
+        }
+    });
+}

package/bin/mjs/reciple/modules.js

@@ -0,0 +1,81 @@
+import { CommandBuilderType } from './types/builders';
+import { MessageCommandBuilder } from './classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
+import { normalizeArray } from 'discord.js';
+import { isSupportedVersion, version } from './version';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import wildcard from 'wildcard-match';
+import { cwd } from './flags';
+import path from 'path';
+/**
+ * Load modules from folder
+ * @param client Reciple client
+ * @param folder Modules folder
+ */
+export async function getModules(client, folder) {
+    const response = { commands: [], modules: [] };
+    const modulesDir = folder || path.join(cwd, 'modules');
+    if (!existsSync(modulesDir))
+        mkdirSync(modulesDir, { recursive: true });
+    const ignoredFiles = (client.config.ignoredFiles || []).map(file => file.endsWith('.js') ? file : `${file}.js`);
+    const scripts = readdirSync(modulesDir).filter(file => {
+        return file.endsWith('.js') && (!file.startsWith('_') && !file.startsWith('.')) && !ignoredFiles.some(f => wildcard(f)(file));
+    });
+    for (const script of scripts) {
+        const modulePath = path.join(modulesDir, script);
+        const commands = [];
+        let module_;
+        try {
+            const reqMod = require(modulePath);
+            module_ = reqMod?.default !== undefined ? reqMod.default : reqMod;
+            if (!module_?.versions.length)
+                throw new Error(`${modulePath} does not have supported versions.`);
+            const versions = normalizeArray([module_.versions]);
+            if (!client.config.disableVersionCheck && !versions.some(v => isSupportedVersion(v, version)))
+                throw new Error(`${modulePath} is unsupported; current version: ${version}; module supported versions: ` + versions.join(', ') ?? 'none');
+            if (!await Promise.resolve(module_.onStart(client)).catch(() => null))
+                throw new Error(script + ' onStart returned false or undefined.');
+            if (module_.commands) {
+                for (const command of module_.commands) {
+                    if (command.type === CommandBuilderType.MessageCommand) {
+                        commands.push(MessageCommandBuilder.resolveMessageCommand(command));
+                    }
+                    else if (command.type === CommandBuilderType.SlashCommand) {
+                        commands.push(SlashCommandBuilder.resolveSlashCommand(command));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (client.isClientLogsEnabled()) {
+                client.logger.error(`Failed to load module ${script}`);
+                client.logger.error(error);
+            }
+            continue;
+        }
+        response.commands.push(...commands.filter((c) => {
+            if (!c.name) {
+                if (client.isClientLogsEnabled())
+                    client.logger.error(`A ${CommandBuilderType[c.type]} command name is not defined in ${modulePath}`);
+                return false;
+            }
+            if (c.type === CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (client.isClientLogsEnabled())
+                    client.logger.error(`A ${CommandBuilderType[c.type]} option name is not defined in ${modulePath}`);
+                return false;
+            }
+            return true;
+        }));
+        response.modules.push({
+            script: module_,
+            info: {
+                filename: script,
+                versions: normalizeArray([module_.versions]),
+                path: modulePath
+            }
+        });
+        if (client.isClientLogsEnabled())
+            client.logger.info(`Loaded module ${modulePath}`);
+    }
+    return response;
+}

package/bin/mjs/reciple/permissions.js

@@ -0,0 +1,23 @@
+/**
+ * Check if the user has permissions to execute the given command name
+ * @param options options
+ */
+export function userHasCommandPermissions(options) {
+    const command = (options.commandPermissions?.enabled
+        ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
+        : null)
+        ?? { permissions: options.builder.requiredMemberPermissions };
+    if (!command.permissions.length)
+        return true;
+    return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;
+}
+/**
+ * Check if the bot has the required permissions in a guild
+ * @param guild Guild
+ * @param requiredPermissions Required guild bot permissions
+ */
+export function botHasExecutePermissions(guild, requiredPermissions) {
+    if (!requiredPermissions?.length)
+        return true;
+    return guild?.members.me ? guild.members.me.permissions.has(requiredPermissions) : false;
+}