@spatulox/simplediscordbot 1.0.24 → 1.0.26

package/.env.example

@@ -0,0 +1,2 @@
+DISCORD_BOT_TOKEN=example
+DISCORD_BOT_DEV # Define this one with anything you want, the value is not important as long as the env var is defined

package/dist/SimpleDiscordBotInfo.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleDiscordBotInfo = void 0;
+const package_json_1 = __importDefault(require("../package.json"));
+exports.SimpleDiscordBotInfo = {
+    name: package_json_1.default.name,
+    version: package_json_1.default.license,
+    author: package_json_1.default.author,
+    description: package_json_1.default.description,
+    license: package_json_1.default.license
+};

package/dist/bot/Bot.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = void 0;
+const discord_js_1 = require("discord.js");
+const UnitTime_1 = require("../utils/times/UnitTime");
+const Log_1 = require("../utils/Log");
+const InternetChecker_1 = require("../utils/network/InternetChecker");
+const BotLog_1 = require("./BotLog");
+const EmbedManager_1 = require("../manager/messages/EmbedManager");
+const BotMessage_1 = require("./BotMessage");
+const BotEnv_1 = require("./BotEnv");
+const BotInteraction_1 = require("./BotInteraction");
+class Bot {
+    get config() { return Bot._config; }
+    get client() { return Bot._client; }
+    static get client() { return Bot._client; }
+    static get config() { return Bot._config; }
+    constructor(client, config) {
+        Log_1.Log.info('----------------------------------------------------');
+        Log_1.Log.info("Starting Bot");
+        Bot.criticConfig = { dev: BotEnv_1.BotEnv.dev, token: BotEnv_1.BotEnv.token };
+        Bot._config = { ...config, clientId: BotEnv_1.BotEnv.clientId };
+        Bot._client = client;
+        (async () => {
+            Log_1.Log.info(`Using discord.js version: ${discord_js_1.version}`);
+            Log_1.Log.info('Trying to connect to Discord Servers');
+            await InternetChecker_1.InternetChecker.checkConnection(3);
+            await this.login();
+        })();
+    }
+    async login(maxTries = 3) {
+        let success = false;
+        let tries = 0;
+        while (!success && tries < maxTries) {
+            try {
+                await Bot._client.login(Bot.criticConfig.token);
+                success = true;
+                Bot._client.on(discord_js_1.Events.ClientReady, async () => {
+                    if (Bot._client.user) {
+                        await Bot.log.initDiscordLogging();
+                        Log_1.Log.info(`Connected on ${Bot._client.guilds.cache.size} servers as ${Bot._client.user.tag}`);
+                        //Bot._client.guilds.cache.forEach(g => console.log(` - ${g.name}`));
+                        Bot.log.info(EmbedManager_1.EmbedManager.description("Bot Started"));
+                    }
+                });
+            }
+            catch (error) {
+                Log_1.Log.error(`Connection error : ${error}. Trying again...`);
+                tries++;
+                await new Promise(resolve => setTimeout(resolve, UnitTime_1.Time.second.SEC_03.toMilliseconds()));
+            }
+        }
+        if (!success) {
+            Log_1.Log.error('Impossible to connect the bot after 3 attempts');
+            return false;
+        }
+        return true;
+    }
+    static setActivity(message, type) {
+        if (Bot._client.user) {
+            Bot._client.user.setActivity({ name: message, type });
+            Log_1.Log.info(`Activity defined : ${message}`);
+        }
+    }
+    static setRandomActivity(randomActivity, intervalMs = null) {
+        if (randomActivity.length == 0) {
+            Log_1.Log.error("Bot.randomActivity = [{}] is empty");
+            return;
+        }
+        const pickRandom = () => {
+            const random = randomActivity[Math.floor(Math.random() * randomActivity.length)];
+            Bot.setActivity(random.message, random.type);
+            return random;
+        };
+        if (intervalMs === null) {
+            pickRandom();
+            Log_1.Log.info(`Activity set ONCE`);
+            return;
+        }
+        pickRandom();
+        setInterval(async () => {
+            pickRandom();
+        }, intervalMs);
+        Log_1.Log.info(`Random activity started (every ${Math.round(intervalMs / 60000)}min)`);
+        return;
+    }
+}
+exports.Bot = Bot;
+// Static ref
+Bot.log = BotLog_1.BotLog;
+Bot.message = BotMessage_1.BotMessage;
+Bot.interaction = BotInteraction_1.BotInteraction;

package/dist/bot/BotEnv.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotEnv = void 0;
+const DiscordRegex_1 = require("../utils/DiscordRegex");
+exports.BotEnv = {
+    get token() {
+        const token = process.env.DISCORD_BOT_TOKEN;
+        if (!token)
+            throw new Error('Missing environment variable : DISCORD_BOT_TOKEN');
+        return token;
+    },
+    get dev() {
+        return process.env.DEV === 'true';
+    },
+    get clientId() {
+        const token = process.env.DISCORD_BOT_CLIENTID;
+        if (!token)
+            throw new Error('Missing environment variable : DISCORD_BOT_CLIENTID');
+        if (!DiscordRegex_1.DiscordRegex.BOT_ID.test(token)) {
+            throw new Error("Invalid token format");
+        }
+        return token;
+    }
+};

package/dist/bot/BotInteraction.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotInteraction = void 0;
+const SendableComponentBuilder_1 = require("../manager/builder/SendableComponentBuilder");
+class BotInteraction {
+    /**
+     * InteractionReplyOptions && InteractionUpdateOptions
+     * The two have "content", "embeds" & "flags" field, so an internal cast is ok, unless discord/discordjs deprecate it
+     */
+    static buildReplyOptions(content, component, ephemeral) {
+        return this._buildOptions(content, component, ephemeral);
+    }
+    static buildUpdateOptions(content, component) {
+        return this._buildOptions(content, component, false);
+    }
+    static _buildOptions(content, component, ephemeral) {
+        return SendableComponentBuilder_1.SendableComponentBuilder.buildInteraction(content, component, ephemeral);
+    }
+    static async send(interaction, content, component = false, ephemeral = false) {
+        if (!interaction.isRepliable())
+            return false;
+        const options = this.buildReplyOptions(typeof content === 'string' ? content : "", typeof content === 'string' ? component : content, typeof content === 'string' ? ephemeral : component);
+        if (!interaction.deferred && !interaction.replied) {
+            return await interaction.reply(options);
+        }
+        else {
+            return await interaction.followUp(options);
+        }
+    }
+    static async reply(interaction, content, component = false, ephemeral = false) {
+        if (!interaction.isRepliable())
+            return false;
+        const options = this.buildReplyOptions(typeof content === 'string' ? content : "", typeof content === 'string' ? component : content, typeof content === 'string' ? ephemeral : component);
+        return interaction.reply(options);
+    }
+    static async followUp(interaction, content, component = false, ephemeral = false) {
+        if (!interaction.isRepliable())
+            return false;
+        const options = this.buildReplyOptions(typeof content === 'string' ? content : "", typeof content === 'string' ? component : content, typeof content === 'string' ? ephemeral : component);
+        return interaction.followUp(options);
+    }
+    static async defer(interaction) {
+        if (!interaction.isRepliable())
+            return;
+        if (interaction.isChatInputCommand() || interaction.isContextMenuCommand()) {
+            if (!interaction.deferred && !interaction.replied) {
+                await interaction.deferReply();
+            }
+            return;
+        }
+        if (interaction.isButton() ||
+            interaction.isAnySelectMenu() ||
+            interaction.isModalSubmit()) {
+            if (!interaction.deferred && !interaction.replied) {
+                await interaction.deferUpdate();
+            }
+        }
+    }
+    static async update(interaction, content, component) {
+        if (!interaction.isRepliable())
+            return false;
+        const options = this.buildUpdateOptions(typeof content === 'string' ? content : "", typeof content === 'string' ? component : content);
+        // MessageComponent → update()
+        if (interaction.isMessageComponent()) {
+            return await interaction.update(options);
+        }
+        // Slash commands → editReply()
+        if (interaction.deferred || interaction.replied) {
+            return await interaction.editReply(options);
+        }
+        return false;
+    }
+}
+exports.BotInteraction = BotInteraction;

package/dist/bot/BotLog.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotLog = void 0;
+// src/utils/BotLog.ts
+const discord_js_1 = require("discord.js");
+const Log_1 = require("../utils/Log");
+const Bot_1 = require("./Bot");
+class BotLog {
+    constructor() { }
+    static config() {
+        return Bot_1.Bot.config.log;
+    }
+    /**
+     * Initialize Discord logging channels and update Bot.log references
+     */
+    static async initDiscordLogging() {
+        if (!Bot_1.Bot.client.isReady()) {
+            Log_1.Log.warn('Client not ready for Discord logging init');
+            return;
+        }
+        if (Bot_1.Bot.config.log?.logChannelId) {
+            try {
+                const logCh = await Bot_1.Bot.client.channels.fetch(Bot_1.Bot.config.log.logChannelId);
+                if (logCh?.isTextBased()) {
+                    BotLog.logChannel = logCh;
+                }
+                else {
+                    Log_1.Log.warn(`❌ Log channel ${Bot_1.Bot.config.log.logChannelId} invalid`);
+                }
+            }
+            catch (error) {
+                Log_1.Log.error(`❌ Log channel fetch failed: ${error}`);
+            }
+        }
+        if (Bot_1.Bot.config.log?.errorChannelId) {
+            try {
+                const errorCh = await Bot_1.Bot.client.channels.fetch(Bot_1.Bot.config.log.errorChannelId);
+                if (errorCh?.isTextBased()) {
+                    BotLog.errorChannel = errorCh;
+                }
+                else {
+                    Log_1.Log.warn(`❌ Error channel ${Bot_1.Bot.config.log.errorChannelId} invalid`);
+                }
+            }
+            catch (error) {
+                Log_1.Log.error(`❌ Error channel fetch failed: ${error}`);
+            }
+        }
+    }
+    /**
+     * Send content to specific Discord channel
+     */
+    static async _sendToChannel(channel, content, prefix = 'info') {
+        if (!channel)
+            return;
+        let msg;
+        try {
+            if (content instanceof discord_js_1.EmbedBuilder) {
+                msg = await channel.send({ embeds: [content] });
+            }
+            else {
+                const timestamp = `\`${new Date().toISOString()}\``;
+                msg = await channel.send(`${prefix.toUpperCase()} ${timestamp} ${content}`);
+            }
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to send to Discord channel: ${error}`);
+        }
+        return msg;
+    }
+    /**
+     * Send INFO log - TEXT or EMBED ! Respecte config.log.info
+     */
+    static async info(content) {
+        const logConfig = Bot_1.Bot.config.log;
+        // 1. CONSOLE selon config (ou défaut ON)
+        if (!logConfig || logConfig.info.console) {
+            if (!(content instanceof discord_js_1.EmbedBuilder)) {
+                Log_1.Log.info(content);
+            }
+        }
+        // 2. Discord seulement si config + channel
+        if (logConfig?.info.discord && this.logChannel) {
+            return await this._sendToChannel(this.logChannel, content, 'info');
+        }
+    }
+    /**
+     * Send ERROR log - TEXT or EMBED ! Respecte config.log.error
+     */
+    static async error(content) {
+        const logConfig = Bot_1.Bot.config.log;
+        // 1. CONSOLE selon config (ou défaut ON)
+        if (!logConfig || logConfig.error.console) {
+            if (!(content instanceof discord_js_1.EmbedBuilder)) {
+                Log_1.Log.error(content);
+            }
+        }
+        // 2. Discord seulement si config + channel
+        if (logConfig?.error.discord && this.errorChannel) {
+            return await this._sendToChannel(this.errorChannel, content, 'error');
+        }
+    }
+    /**
+     * Send WARNING log - TEXT or EMBED ! Respecte config.log.warn
+     */
+    static async warn(content) {
+        const logConfig = Bot_1.Bot.config.log;
+        if (!logConfig || logConfig?.warn.console) {
+            if (!(content instanceof discord_js_1.EmbedBuilder)) {
+                Log_1.Log.warn(content);
+            }
+        }
+        if (logConfig?.warn.discord && this.logChannel) {
+            return await this._sendToChannel(this.logChannel, content, 'warn');
+        }
+    }
+    /**
+     * Send DEBUG log - TEXT or EMBED ! Respecte config.log.debug
+     */
+    static async debug(content) {
+        const logConfig = Bot_1.Bot.config.log;
+        if (!logConfig || logConfig?.debug.console) {
+            if (!(content instanceof discord_js_1.EmbedBuilder)) {
+                Log_1.Log.debug(content);
+            }
+        }
+        if (logConfig?.debug.discord && this.logChannel) {
+            return await this._sendToChannel(this.logChannel, content, 'debug');
+        }
+    }
+}
+exports.BotLog = BotLog;
+BotLog.logChannel = null;
+BotLog.errorChannel = null;

package/dist/bot/BotMessage.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotMessage = void 0;
+const discord_js_1 = require("discord.js");
+const Log_1 = require("../utils/Log");
+const Bot_1 = require("./Bot");
+const EmbedManager_1 = require("../manager/messages/EmbedManager");
+const SendableComponentBuilder_1 = require("../manager/builder/SendableComponentBuilder");
+class BotMessage {
+    static async send(channel, content, component) {
+        try {
+            if (!channel) {
+                Log_1.Log.warn('Cannot send message: invalid channel');
+                return null;
+            }
+            if (typeof channel === "string") {
+                const fetchedChannel = Bot_1.Bot.client.channels.cache.get(channel);
+                if (!fetchedChannel?.isTextBased()) {
+                    Log_1.Log.warn(`Invalid channel ID: ${channel}`);
+                    return null;
+                }
+                channel = fetchedChannel;
+            }
+            let messageCreate;
+            if (typeof content !== "string" && !component) {
+                if (SendableComponentBuilder_1.SendableComponentBuilder.isSendableComponent(content)) {
+                    messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content);
+                }
+                else {
+                    messageCreate = content;
+                }
+            }
+            else {
+                content = content;
+                if (content && component) {
+                    messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content, component);
+                }
+                else if (content) {
+                    messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content);
+                }
+                else if (component) {
+                    messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(component);
+                }
+                else {
+                    throw new Error("content and component cannot be null at the same time");
+                }
+            }
+            try {
+                return await channel.send(messageCreate);
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        catch (e) {
+            Log_1.Log.error(`Failed to send message : ${e}`);
+            return null;
+        }
+    }
+    static async sendDM(user, content, component) {
+        try {
+            let targetUser;
+            if (user instanceof discord_js_1.User || user instanceof discord_js_1.GuildMember) {
+                targetUser = user instanceof discord_js_1.GuildMember ? user.user : user;
+            }
+            else {
+                targetUser = await Bot_1.Bot.client.users.fetch(user);
+            }
+            let messageCreate;
+            if (content && component) {
+                messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content, component);
+            }
+            else if (content) {
+                messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content);
+            }
+            else if (component) {
+                messageCreate = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(component);
+            }
+            else {
+                throw new Error("content and component cannot be null at the same time");
+            }
+            return await targetUser.send(messageCreate);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to send message to ${user}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Quick success message
+     */
+    static success(channel, message) {
+        const embed = EmbedManager_1.EmbedManager.success(message);
+        if (channel instanceof discord_js_1.User || channel instanceof discord_js_1.GuildMember) {
+            return this.sendDM(channel, message, embed);
+        }
+        return this.send(channel, message, embed);
+    }
+    /**
+     * Quick error message
+     */
+    static error(channel, message) {
+        const embed = EmbedManager_1.EmbedManager.error(message);
+        if (channel instanceof discord_js_1.User || channel instanceof discord_js_1.GuildMember) {
+            return this.sendDM(channel, message, embed);
+        }
+        return this.send(channel, message, embed);
+    }
+}
+exports.BotMessage = BotMessage;

package/dist/manager/FileManager.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+// src/filesystem/FileManager.ts
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const Log_1 = require("../utils/Log");
+const Bot_1 = require("../bot/Bot");
+const EmbedManager_1 = require("./messages/EmbedManager");
+class FileManager {
+    /**
+     * Reads a JSON file synchronously.
+     * @param filePath Full path to the JSON file
+     * @returns Parsed JSON object or 'Error' string on failure
+     */
+    static async readJsonFile(filePath) {
+        try {
+            const data = await promises_1.default.readFile(filePath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read JSON file ${filePath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists all directories in a given path.
+     * @param directoryPath Path to scan for directories
+     * @returns Array of directory names or false on error
+     */
+    static async listDirectories(directoryPath) {
+        try {
+            const files = await promises_1.default.readdir(directoryPath, { withFileTypes: true });
+            const directories = files
+                .filter(file => file.isDirectory())
+                .map(dir => dir.name);
+            return directories;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists all JSON files in a directory.
+     * @param directoryPath Path to scan for JSON files
+     * @returns Array of JSON filenames or false on error
+     */
+    static async listJsonFiles(directoryPath) {
+        try {
+            const files = await promises_1.default.readdir(directoryPath);
+            return files.filter(file => path_1.default.extname(file) === '.json');
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists files with specific extension in a directory.
+     * @param directoryPath Path to scan
+     * @param extension File extension (with or without dot)
+     * @returns Array of matching filenames or 'Error' string on failure
+     */
+    static async listFiles(directoryPath, extension) {
+        if (typeof directoryPath !== 'string' || typeof extension !== 'string') {
+            Log_1.Log.error('Directory path and extension must be strings');
+            return false;
+        }
+        try {
+            let ext = extension;
+            if (ext.startsWith('.')) {
+                ext = ext.slice(1);
+            }
+            const files = await promises_1.default.readdir(directoryPath);
+            return files.filter(file => path_1.default.extname(file) === `.${ext}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Creates directory structure and writes JSON data to file.
+     * @param directoryPath Full directory path (creates if missing)
+     * @param filename Filename without extension
+     * @param data Data to write (JSON serializable)
+     * @param sendErrorToErrorChannel Send error to the error channel
+     * @returns true on success, false on failure
+     */
+    static async writeJsonFile(directoryPath, filename, data, sendErrorToErrorChannel = true) {
+        // Skip if data is an Error array
+        if (Array.isArray(data) && data.length === 1 && data[0] === 'Error') {
+            Log_1.Log.error(`Cannot save data for ${filename}: data contains 'Error'`);
+            return false;
+        }
+        try {
+            // Create directory structure recursively
+            const directories = directoryPath.split(path_1.default.sep).filter(Boolean);
+            let currentPath = '';
+            for (const dir of directories) {
+                currentPath = path_1.default.join(currentPath, dir);
+                try {
+                    await promises_1.default.access(currentPath);
+                }
+                catch {
+                    await promises_1.default.mkdir(currentPath, { recursive: true });
+                }
+            }
+            if (!filename || filename.trim() === '') {
+                Log_1.Log.error('Cannot write JSON file: empty filename');
+                return false;
+            }
+            const cleanFilename = filename.replace(/\.json$/i, '');
+            const filePath = path_1.default.join(directoryPath, `${cleanFilename}.json`);
+            const jsonContent = JSON.stringify(data, null, 2);
+            await promises_1.default.writeFile(filePath, jsonContent);
+            Log_1.Log.info(`Successfully wrote data to ${filePath}`);
+            return true;
+        }
+        catch (error) {
+            const cleanFilename = filename.replace(/\.json$/i, '') || 'unknown';
+            if (sendErrorToErrorChannel) {
+                await Bot_1.Bot.log.info(EmbedManager_1.EmbedManager.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`));
+            }
+            else {
+                Log_1.Log.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`);
+            }
+            return false;
+        }
+    }
+}
+exports.FileManager = FileManager;

package/dist/manager/builder/SendableComponentBuilder.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendableComponentBuilder = void 0;
+const discord_js_1 = require("discord.js");
+class SendableComponentBuilder {
+    static isSendableComponent(thing) {
+        return thing instanceof discord_js_1.EmbedBuilder || thing instanceof discord_js_1.ActionRowBuilder;
+    }
+    static build(base, content, components) {
+        if (content) {
+            base.content = content;
+        }
+        const comps = Array.isArray(components) ? components : [components].filter(Boolean);
+        for (const comp of comps) {
+            if (comp instanceof discord_js_1.EmbedBuilder) {
+                base.embeds = base.embeds || [];
+                base.embeds.push(comp);
+            }
+            if (comp instanceof discord_js_1.ActionRowBuilder) {
+                base.components = base.components || [];
+                base.components.push(comp);
+            }
+        }
+        return base;
+    }
+    static buildInteraction(contentOrComponent, component, ephemeral = false) {
+        let base = {};
+        // Case 1
+        if (typeof contentOrComponent === 'string' && !component) {
+            base = this.build(base, contentOrComponent);
+        }
+        // Case 2
+        if (typeof contentOrComponent !== 'string' && !component) {
+            base = this.build(base, null, contentOrComponent);
+        }
+        // Cas 3: content and component not null
+        if (contentOrComponent && typeof contentOrComponent === 'string' && component) {
+            base = this.build(base, contentOrComponent, component);
+        }
+        if (ephemeral) {
+            base.flags = [discord_js_1.MessageFlags.Ephemeral];
+        }
+        return base;
+    }
+    static buildMessage(contentOrComponent, component) {
+        let base = {};
+        // Case 1
+        if (typeof contentOrComponent === 'string' && !component) {
+            return this.build(base, contentOrComponent);
+        }
+        // Case 2
+        if (typeof contentOrComponent !== 'string' && !component) {
+            return this.build(base, null, contentOrComponent);
+        }
+        // Case 3
+        if (typeof contentOrComponent == 'string' && component) {
+            return this.build(base, contentOrComponent, component);
+        }
+        throw new Error("At least content or component need to be defined to build a message");
+    }
+}
+exports.SendableComponentBuilder = SendableComponentBuilder;