reciple 5.4.0 → 5.4.1-pre.3

package/bin/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/bin/mjs/bin.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { RecipleClient } from './reciple/classes/RecipleClient.js';
+import { RecipleConfig } from './reciple/classes/RecipleConfig.js';
+import { rawVersion } from './reciple/version.js';
+import { existsSync, readdirSync } from 'fs.js';
+import { cwd, flags } from './reciple/flags.js';
+import { input } from 'fallout-utility.js';
+import chalk from 'chalk.js';
+import 'dotenv/config';
+import { normalizeArray } from 'discord.js.js';
+import path from 'path.js';
+const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
+const configPath = path.join(cwd, './reciple.yml');
+if (readdirSync(cwd).filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !existsSync(flags.config ?? configPath)) {
+    const ask = (flags.yes ? 'y' : null) ?? input('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ') ?? '';
+    if (ask.toString().toLowerCase() !== 'y')
+        process.exit(0);
+}
+let configParser;
+try {
+    configParser = new RecipleConfig(flags.config ?? configPath).parseConfig();
+}
+catch (err) {
+    console.error(`${chalk.bold.red('Config Error')}: ${chalk.white(err.message)}`);
+    process.exit(1);
+}
+const config = configParser.getConfig();
+const client = new RecipleClient({ config: config, ...config.client });
+if (config.fileLogging.clientLogs)
+    client.logger.info('Starting Reciple client v' + rawVersion);
+(async () => {
+    await client.startModules(normalizeArray(config.modulesFolder));
+    client.on('ready', async () => {
+        if (client.isClientLogsEnabled())
+            client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
+        client.on('cacheSweep', () => {
+            client.cooldowns.clean();
+        });
+        await client.loadModules();
+        client.addCommandListeners();
+    });
+    client.login(config.token).catch(err => {
+        if (client.isClientLogsEnabled())
+            client.logger.error(err);
+    });
+})();

package/bin/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/bin/mjs/reciple/classes/CommandCooldownManager.js

@@ -0,0 +1,87 @@
+import { normalizeArray } from 'discord.js.js';
+/**
+ * cooled-down users manager
+ */
+export class CommandCooldownManager extends Array {
+    constructor(...data) {
+        super(...normalizeArray(data));
+    }
+    /**
+     * Alias for `CommandCooldownManager#push()`
+     * @param options Cooled-down user data
+     */
+    add(...options) {
+        return this.push(...options);
+    }
+    /**
+     * Remove cooldown from specific user, channel or guild
+     * @param options Remove cooldown data options
+     * @param limit Remove cooldown data limit
+     */
+    remove(options, limit = 0) {
+        if (!Object.keys(options).length)
+            throw new TypeError('Provide atleast one option to remove cooldown data.');
+        let i = 0;
+        for (const index in this) {
+            if (!CommandCooldownManager.checkOptions(options, this[index]))
+                continue;
+            if (options.expireTime && this[index].expireTime > Date.now())
+                continue;
+            if (limit && i >= limit)
+                continue;
+            this.splice(Number(index));
+            i++;
+        }
+    }
+    /**
+     * Check if the given user is cooled-down
+     * @param options Options to identify if user is on cooldown
+     */
+    isCooledDown(options) {
+        const data = this.get(options);
+        if (!data)
+            return false;
+        this.remove({ ...data, channel: undefined, guild: undefined, type: undefined, command: undefined });
+        if (data.expireTime < Date.now())
+            return false;
+        return true;
+    }
+    /**
+     * Purge non cooled-down users from this array
+     * @param options Clean cooldown options
+     */
+    clean(options) {
+        for (const index in this) {
+            if (options && !CommandCooldownManager.checkOptions(options, this[index]))
+                return;
+            if (this[index].expireTime > Date.now())
+                return;
+            this.slice(Number(index));
+        }
+    }
+    /**
+     * Get someone's cooldown data
+     * @param options Get cooldown data options
+     */
+    get(options) {
+        return this.find(data => CommandCooldownManager.checkOptions(options, data));
+    }
+    /**
+     * Check if the options are valid
+     * @param options Options to validated
+     * @param data Cooled-down user data
+     */
+    static checkOptions(options, data) {
+        if (options?.user && options.user.id !== data.user.id)
+            return false;
+        if (options?.guild && options.guild.id !== data.guild?.id)
+            return false;
+        if (options?.channel && options.channel.id !== data.channel?.id)
+            return false;
+        if (options?.command && options.command !== data.command)
+            return false;
+        if (options?.type && options.type !== data.type)
+            return false;
+        return true;
+    }
+}

package/bin/mjs/reciple/classes/MessageCommandOptionManager.js

@@ -0,0 +1,21 @@
+import { normalizeArray } from 'discord.js.js';
+/**
+ * Validated message options manager
+ */
+export class MessageCommandOptionManager extends Array {
+    constructor(...data) {
+        super(...normalizeArray(data));
+    }
+    get(name, required) {
+        const option = this.find(o => o.name == name);
+        if (!option?.value == undefined && required)
+            throw new TypeError(`Can't find option named ${name}`);
+        return option ?? null;
+    }
+    getValue(name, requied) {
+        const option = this.get(name, requied);
+        if (!option?.value && requied)
+            throw new TypeError(`Value of option named ${name} is undefined`);
+        return option?.value ?? null;
+    }
+}

package/bin/mjs/reciple/classes/RecipleClient.js

@@ -0,0 +1,363 @@
+import { MessageCommandBuilder, validateMessageCommandOptions } from './builders/MessageCommandBuilder.js';
+import { SlashCommandBuilder } from './builders/SlashCommandBuilder.js';
+import { CommandBuilderType } from '../types/builders.js';
+import { registerApplicationCommands } from '../registerApplicationCommands.js';
+import { CommandHaltReason } from '../types/commands.js';
+import { botHasExecutePermissions, userHasCommandPermissions } from '../permissions.js';
+import { CommandCooldownManager } from './CommandCooldownManager.js';
+import { MessageCommandOptionManager } from './MessageCommandOptionManager.js';
+import { getCommand } from 'fallout-utility.js';
+import { RecipleConfig } from './RecipleConfig.js';
+import { getModules } from '../modules.js';
+import { createLogger } from '../logger.js';
+import { version } from '../version.js';
+import { cwd } from '../flags.js';
+import path from 'path.js';
+import { ChannelType, Client, normalizeArray } from 'discord.js.js';
+export class RecipleClient extends Client {
+    config = RecipleConfig.getDefaultConfig();
+    commands = { slashCommands: {}, messageCommands: {} };
+    additionalApplicationCommands = [];
+    cooldowns = new CommandCooldownManager();
+    modules = [];
+    logger;
+    version = version;
+    /**
+     * @param options Client options
+     */
+    constructor(options) {
+        super(options);
+        this.logger = createLogger(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
+        if (!options.config)
+            throw new Error('Config is not defined.');
+        this.config = { ...this.config, ...(options.config ?? {}) };
+        if (this.config.fileLogging.enabled)
+            this.logger.logFile(path.join(cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
+    }
+    /**
+     * Load modules from modules folder
+     * @param folders List of folders that contains the modules you want to load
+     */
+    async startModules(...folders) {
+        folders = normalizeArray(folders).map(f => path.join(cwd, f));
+        for (const folder of folders) {
+            if (this.isClientLogsEnabled())
+                this.logger.info(`Loading Modules from ${folder}`);
+            const modules = await getModules(this, folder).catch(() => null);
+            if (!modules) {
+                if (this.isClientLogsEnabled())
+                    this.logger.error(`Failed to load modules from ${folder}`);
+                continue;
+            }
+            this.modules.push(...modules.modules);
+        }
+        return this;
+    }
+    /**
+     * Execute `onLoad()` from client modules and register application commands if enabled
+     */
+    async loadModules() {
+        for (const m in this.modules) {
+            const module_ = this.modules[m];
+            if (typeof module_.script?.onLoad === 'function') {
+                await Promise.resolve(module_.script.onLoad(this)).catch(err => {
+                    if (this.isClientLogsEnabled()) {
+                        this.logger.error(`Error loading ${module_.info.filename ?? 'unknown module'}:`);
+                        this.logger.error(err);
+                    }
+                    this.modules = this.modules.filter((_r, i) => i.toString() !== m.toString());
+                });
+            }
+            if (typeof module_.script?.commands !== 'undefined') {
+                for (const command of module_.script.commands) {
+                    this.addCommand(command);
+                }
+            }
+        }
+        if (this.isClientLogsEnabled()) {
+            this.logger.info(`${this.modules.length} modules loaded.`);
+            this.logger.info(`${Object.keys(this.commands.messageCommands).length} message commands loaded.`);
+            this.logger.info(`${Object.keys(this.commands.slashCommands).length} slash commands loaded.`);
+        }
+        if (this.config.commands.slashCommand.registerCommands) {
+            await registerApplicationCommands({
+                client: this,
+                commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
+                guilds: this.config.commands.slashCommand.guilds
+            });
+        }
+        return this;
+    }
+    /**
+     * Add module
+     * @param options Module options
+     */
+    async addModule(options) {
+        const { script } = options;
+        const registerCommands = options.registerApplicationCommands;
+        const info = options.moduleInfo;
+        this.modules.push({
+            script,
+            info: {
+                filename: undefined,
+                versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
+                path: undefined,
+                ...info
+            }
+        });
+        if (typeof script?.onLoad === 'function')
+            await Promise.resolve(script.onLoad(this));
+        if (this.isClientLogsEnabled())
+            this.logger.info(`${this.modules.length} modules loaded.`);
+        for (const command of script.commands ?? []) {
+            if (!command.name)
+                continue;
+            this.addCommand(command);
+        }
+        if (registerCommands)
+            await registerApplicationCommands({
+                client: this,
+                commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
+                guilds: this.config.commands.slashCommand.guilds
+            });
+    }
+    /**
+     * Add slash or message command to client
+     * @param command Slash/Message command builder
+     */
+    addCommand(command) {
+        if (command.type === CommandBuilderType.SlashCommand) {
+            this.commands.slashCommands[command.name] = SlashCommandBuilder.resolveSlashCommand(command);
+        }
+        else if (command.type === CommandBuilderType.MessageCommand) {
+            this.commands.messageCommands[command.name] = MessageCommandBuilder.resolveMessageCommand(command);
+        }
+        else if (this.isClientLogsEnabled()) {
+            this.logger.error(`Unknow command "${typeof command ?? 'unknown'}".`);
+        }
+        return this;
+    }
+    /**
+     * Listed to command executions
+     */
+    addCommandListeners() {
+        if (this.config.commands.messageCommand.enabled)
+            this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
+        if (this.config.commands.slashCommand.enabled)
+            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
+        return this;
+    }
+    /**
+     * Execute a slash command
+     * @param interaction Slash command interaction
+     */
+    async slashCommandExecute(interaction) {
+        if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
+            return;
+        const command = this.findCommand(interaction.commandName, CommandBuilderType.SlashCommand);
+        if (!command)
+            return;
+        const executeData = {
+            interaction,
+            builder: command,
+            client: this
+        };
+        if (userHasCommandPermissions({
+            builder: command,
+            memberPermissions: interaction.memberPermissions ?? undefined,
+            commandPermissions: this.config.commands.slashCommand.permissions
+        })) {
+            if (!command)
+                return;
+            if (interaction.guild && !botHasExecutePermissions(interaction.guild, command.requiredBotPermissions)) {
+                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingBotPermissions })) {
+                    await interaction.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            const userCooldown = {
+                user: interaction.user,
+                command: command.name,
+                channel: interaction.channel ?? undefined,
+                guild: interaction.guild,
+                type: CommandBuilderType.SlashCommand
+            };
+            if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                this.cooldowns.add({ ...userCooldown, expireTime: Date.now() + command.cooldown });
+            }
+            else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
+                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.Cooldown, ...this.cooldowns.get(userCooldown) })) {
+                    await interaction.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            return this._executeCommand(command, executeData);
+        }
+        else if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingMemberPermissions })) {
+            await interaction.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+        }
+    }
+    /**
+     * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
+     */
+    async messageCommandExecute(message, prefix) {
+        if (!message.content || !this.isReady())
+            return;
+        const parseCommand = getCommand(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+        if (!parseCommand || !parseCommand?.command)
+            return;
+        const command = this.findCommand(parseCommand.command, CommandBuilderType.MessageCommand);
+        if (!command)
+            return;
+        const commandOptions = await validateMessageCommandOptions(command, parseCommand);
+        const executeData = {
+            message: message,
+            options: commandOptions,
+            command: parseCommand,
+            builder: command,
+            client: this
+        };
+        if (userHasCommandPermissions({
+            builder: command,
+            memberPermissions: message.member?.permissions,
+            commandPermissions: this.config.commands.messageCommand.permissions
+        })) {
+            if (!command.allowExecuteInDM && message.channel.type === ChannelType.DM || !command.allowExecuteByBots && (message.author.bot || message.author.system))
+                return;
+            if (command.validateOptions) {
+                if (commandOptions.some(o => o.invalid)) {
+                    if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) })) {
+                        message.reply(this.getConfigMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                if (commandOptions.some(o => o.missing)) {
+                    if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingArguments, missingArguments: new MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) })) {
+                        message.reply(this.getConfigMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+            }
+            if (message.guild && !botHasExecutePermissions(message.guild, command.requiredBotPermissions)) {
+                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingBotPermissions })) {
+                    message.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            const userCooldown = {
+                user: message.author,
+                command: command.name,
+                channel: message.channel,
+                guild: message.guild,
+                type: CommandBuilderType.MessageCommand
+            };
+            if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                this.cooldowns.add({ ...userCooldown, expireTime: Date.now() + command.cooldown });
+            }
+            else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
+                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.Cooldown, ...this.cooldowns.get(userCooldown) })) {
+                    await message.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            return this._executeCommand(command, executeData);
+        }
+        else if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingMemberPermissions })) {
+            message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+        }
+    }
+    /**
+     * Get a message from config
+     * @param messageKey Config messages key
+     * @param defaultMessage Default message when the key does not exists
+     */
+    getConfigMessage(messageKey, defaultMessage) {
+        return this.config.messages[messageKey] ?? defaultMessage ?? messageKey;
+    }
+    findCommand(command, type) {
+        switch (type) {
+            case CommandBuilderType.SlashCommand:
+                return this.commands.slashCommands[command];
+            case CommandBuilderType.MessageCommand:
+                return this.commands.messageCommands[command.toLowerCase()]
+                    ?? (this.config.commands.messageCommand.allowCommandAlias
+                        ? Object.values(this.commands.messageCommands).find(c => c.aliases.some(a => a == command?.toLowerCase()))
+                        : undefined);
+            default:
+                throw new TypeError('Unknown command type');
+        }
+    }
+    /**
+     * Returns true if client logs is enabled
+     */
+    isClientLogsEnabled() {
+        return !!this.config.fileLogging.clientLogs;
+    }
+    /**
+     * Emits the "recipleReplyError" event
+     * @param error Received Error
+     */
+    _replyError(error) {
+        this.emit('recipleReplyError', error);
+    }
+    async _haltCommand(command, haltData) {
+        try {
+            const haltResolved = (command.halt
+                ? await (command.type == CommandBuilderType.SlashCommand
+                    ? Promise.resolve(command.halt(haltData))
+                    : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
+                : false) ?? false;
+            this.emit('recipleCommandHalt', haltData);
+            return haltResolved;
+        }
+        catch (err) {
+            if (this.isClientLogsEnabled()) {
+                this.logger.error(`An error occured executing command halt for "${command.name}"`);
+                this.logger.error(err);
+            }
+            return false;
+        }
+    }
+    async _executeCommand(command, executeData) {
+        try {
+            await Promise.resolve(command.type === CommandBuilderType.SlashCommand
+                ? command.execute(executeData)
+                : command.execute(executeData))
+                .then(() => this.emit('recipleCommandExecute', executeData))
+                .catch(async (err) => await this._haltCommand(command, { executeData: executeData, reason: CommandHaltReason.Error, error: err })
+                ? this._commandExecuteError(err, executeData)
+                : void 0);
+            return executeData;
+        }
+        catch (err) {
+            if (!await this._haltCommand(command, { executeData: executeData, reason: CommandHaltReason.Error, error: err })) {
+                this._commandExecuteError(err, executeData);
+            }
+        }
+    }
+    /**
+     * Error message when a command fails to execute
+     * @param err Received error
+     * @param command Slash/Message command execute data
+     */
+    async _commandExecuteError(err, command) {
+        if (this.isClientLogsEnabled()) {
+            this.logger.error(`An error occured executing ${command.builder.type == CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+            this.logger.error(err);
+        }
+        if (!err || !command)
+            return;
+        if (SlashCommandBuilder.isSlashCommandExecuteData(command)) {
+            if (!this.config.commands.slashCommand.replyOnError)
+                return;
+            await command.interaction.followUp(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+        }
+        else if (MessageCommandBuilder.isMessageCommandExecuteData(command)) {
+            if (!this.config.commands.messageCommand.replyOnError)
+                return;
+            await command.message.reply(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+        }
+    }
+}

package/bin/mjs/reciple/classes/RecipleConfig.js

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs.js';
+import { isSupportedVersion, version } from '../version.js';
+import { input, replaceAll } from 'fallout-utility.js';
+import { cwd, token as __token } from '../flags.js';
+import path from 'path.js';
+import yaml from 'yaml.js';
+/**
+ * Create/parse reciple config
+ */
+export class RecipleConfig {
+    config = RecipleConfig.getDefaultConfig();
+    configPath = path.join(cwd, 'reciple.yml');
+    static defaultConfigPath = path.join(__dirname, '../../../resource/reciple.yml');
+    /**
+     * @param configPath Path to config
+     */
+    constructor(configPath) {
+        if (!configPath)
+            throw new Error('Config path is not defined');
+        this.configPath = configPath;
+    }
+    /**
+     * Parse the config file
+     */
+    parseConfig() {
+        if (!existsSync(this.configPath)) {
+            const defaultConfigPath = RecipleConfig.defaultConfigPath;
+            if (!existsSync(defaultConfigPath))
+                throw new Error('Default Config file not found. Please reinstall Reciple.');
+            const defaultConfig = replaceAll(readFileSync(defaultConfigPath, 'utf-8'), 'VERSION', version);
+            writeFileSync(this.configPath, defaultConfig, 'utf-8');
+            if (!existsSync(this.configPath))
+                throw new Error('Failed to create config file.');
+            this.config = yaml.parse(defaultConfig);
+            if (this.config && this.config.token === 'TOKEN') {
+                this.config.token = this._askToken() || this.config.token;
+                writeFileSync(this.configPath, replaceAll(defaultConfig, ' TOKEN', ` ${this.config.token}`), 'utf-8');
+            }
+            return this;
+        }
+        if (!existsSync(this.configPath))
+            throw new Error('Failed to read config file.');
+        const config = readFileSync(this.configPath, 'utf-8');
+        this.config = yaml.parse(config);
+        if (!this._isSupportedConfig())
+            throw new Error('Unsupported config version. Your config version: ' + (this.config?.version || 'No version specified.') + ', Reciple version: ' + version);
+        return this;
+    }
+    /**
+     * Returns the parsed config file
+     */
+    getConfig() {
+        if (!this.config)
+            throw new Error('Config is not parsed.');
+        this.config.token = this.parseToken() || 'TOKEN';
+        return this.config;
+    }
+    /**
+     * Parse token from config
+     * @param askIfNull Ask for token if the token is null/undefined
+     */
+    parseToken(askIfNull = true) {
+        let token = __token || this.config?.token || null;
+        if (!token)
+            return token || (askIfNull ? this._askToken() : null);
+        const envToken = token.toString().split(':');
+        if (envToken.length === 2 && envToken[0].toLocaleLowerCase() === 'env' && envToken[1]) {
+            token = process.env[envToken[1]] || null;
+        }
+        return token || (askIfNull ? this._askToken() : null);
+    }
+    /**
+     * Check if the config version is supported
+     */
+    _isSupportedConfig() {
+        return isSupportedVersion(this.config?.version || '0.0.0', version);
+    }
+    /**
+     * Ask for a token
+     */
+    _askToken() {
+        return __token || input({ text: 'Bot Token >>> ', echo: '*', repeatIfEmpty: true, sigint: true }) || null;
+    }
+    /**
+     * Get default config
+     */
+    static getDefaultConfig() {
+        if (!existsSync(this.defaultConfigPath))
+            throw new Error("Default config file does not exists.");
+        return yaml.parse(readFileSync(this.defaultConfigPath, 'utf-8'));
+    }
+}