spacecommands 1.0.0

package/dist/get-all-files.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const fs_1 = __importDefault(require("fs"));
+const getAllFiles = (dir, extension) => {
+    const files = fs_1.default.readdirSync(dir, {
+        withFileTypes: true,
+    });
+    let jsFiles = [];
+    for (const file of files) {
+        if (file.isDirectory()) {
+            jsFiles = [...jsFiles, ...getAllFiles(`${dir}/${file.name}`, extension)];
+        }
+        else if (file.name.endsWith(extension || '.js') &&
+            !file.name.startsWith('!')) {
+            let fileName = file.name.replace(/\\/g, '/').split('/');
+            fileName = fileName[fileName.length - 1];
+            fileName = fileName.split('.')[0].toLowerCase();
+            jsFiles.push([`${dir}/${file.name}`, fileName]);
+        }
+    }
+    return jsFiles;
+};
+module.exports = getAllFiles;

package/dist/handlers/AutoModHandler.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+/**
+ * Handler for Discord AutoMod features
+ * Provides utilities for creating, managing, and listening to AutoMod rules and actions
+ */
+class AutoModHandler {
+    _client;
+    _instance;
+    _actionHandlers = [];
+    _ruleCache = new Map(); // guildId -> ruleId -> rule
+    constructor(instance) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp();
+    }
+    setUp() {
+        // Listen for AutoMod action executions
+        this._client.on('autoModerationActionExecution', async (execution) => {
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > AutoMod action executed in guild ${execution.guild.id}, rule: ${execution.ruleId}`);
+            }
+            await this.triggerActionHandlers(execution);
+        });
+        // Listen for AutoMod rule creation
+        this._client.on('autoModerationRuleCreate', (rule) => {
+            this.cacheRule(rule);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > AutoMod rule created: ${rule.name} (${rule.id}) in guild ${rule.guild.id}`);
+            }
+        });
+        // Listen for AutoMod rule updates
+        this._client.on('autoModerationRuleUpdate', (oldRule, newRule) => {
+            this.cacheRule(newRule);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > AutoMod rule updated: ${newRule.name} (${newRule.id}) in guild ${newRule.guild.id}`);
+            }
+        });
+        // Listen for AutoMod rule deletion
+        this._client.on('autoModerationRuleDelete', (rule) => {
+            this.uncacheRule(rule.guild.id, rule.id);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > AutoMod rule deleted: ${rule.name} (${rule.id}) in guild ${rule.guild.id}`);
+            }
+        });
+    }
+    /**
+     * Create an AutoMod rule in a guild
+     */
+    async createRule(guild, config) {
+        try {
+            const rule = await guild.autoModerationRules.create({
+                name: config.name,
+                eventType: config.eventType,
+                triggerType: config.triggerType,
+                triggerMetadata: config.triggerMetadata,
+                actions: config.actions,
+                enabled: config.enabled ?? true,
+                exemptRoles: config.exemptRoles,
+                exemptChannels: config.exemptChannels,
+            });
+            this.cacheRule(rule);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Created AutoMod rule: ${rule.name} (${rule.id}) in guild ${guild.id}`);
+            }
+            return rule;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error creating AutoMod rule:', error);
+            return null;
+        }
+    }
+    /**
+     * Update an existing AutoMod rule
+     */
+    async updateRule(guild, ruleId, config) {
+        try {
+            const rule = await guild.autoModerationRules.edit(ruleId, {
+                name: config.name,
+                eventType: config.eventType,
+                triggerMetadata: config.triggerMetadata,
+                actions: config.actions,
+                enabled: config.enabled,
+                exemptRoles: config.exemptRoles,
+                exemptChannels: config.exemptChannels,
+            });
+            this.cacheRule(rule);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Updated AutoMod rule: ${rule.name} (${rule.id}) in guild ${guild.id}`);
+            }
+            return rule;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error updating AutoMod rule:', error);
+            return null;
+        }
+    }
+    /**
+     * Delete an AutoMod rule
+     */
+    async deleteRule(guild, ruleId) {
+        try {
+            await guild.autoModerationRules.delete(ruleId);
+            this.uncacheRule(guild.id, ruleId);
+            if (this._instance.debug) {
+                console.log(`SpaceCommands > Deleted AutoMod rule: ${ruleId} in guild ${guild.id}`);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error deleting AutoMod rule:', error);
+            return false;
+        }
+    }
+    /**
+     * Fetch all AutoMod rules for a guild
+     */
+    async fetchGuildRules(guild, useCache = true) {
+        try {
+            const rules = await guild.autoModerationRules.fetch();
+            if (useCache) {
+                // Update cache
+                for (const rule of rules.values()) {
+                    this.cacheRule(rule);
+                }
+            }
+            return rules;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error fetching AutoMod rules:', error);
+            return new discord_js_1.Collection();
+        }
+    }
+    /**
+     * Fetch a specific AutoMod rule
+     */
+    async fetchRule(guild, ruleId, useCache = true) {
+        try {
+            // Check cache first
+            if (useCache) {
+                const cachedRule = this.getCachedRule(guild.id, ruleId);
+                if (cachedRule)
+                    return cachedRule;
+            }
+            const rule = await guild.autoModerationRules.fetch(ruleId);
+            if (useCache) {
+                this.cacheRule(rule);
+            }
+            return rule;
+        }
+        catch (error) {
+            console.error('SpaceCommands > Error fetching AutoMod rule:', error);
+            return null;
+        }
+    }
+    /**
+     * Register a handler for AutoMod action executions
+     */
+    registerActionHandler(handler) {
+        this._actionHandlers.push(handler);
+        if (this._instance.debug) {
+            console.log(`SpaceCommands > Registered AutoMod action handler${handler.ruleId ? ` for rule: ${handler.ruleId}` : ''}`);
+        }
+        return this;
+    }
+    /**
+     * Trigger all matching action handlers
+     */
+    async triggerActionHandlers(execution) {
+        for (const handler of this._actionHandlers) {
+            let matches = false;
+            if (!handler.ruleId) {
+                // Handler for all rules
+                matches = true;
+            }
+            else if (typeof handler.ruleId === 'string') {
+                matches = handler.ruleId === execution.ruleId;
+            }
+            else {
+                matches = handler.ruleId.test(execution.ruleId);
+            }
+            if (matches) {
+                try {
+                    await handler.callback(execution, this._instance);
+                }
+                catch (error) {
+                    console.error('SpaceCommands > Error executing AutoMod action handler:', error);
+                }
+            }
+        }
+    }
+    /**
+     * Cache a rule
+     */
+    cacheRule(rule) {
+        const guildId = rule.guild.id;
+        if (!this._ruleCache.has(guildId)) {
+            this._ruleCache.set(guildId, new Map());
+        }
+        this._ruleCache.get(guildId).set(rule.id, rule);
+    }
+    /**
+     * Remove a rule from cache
+     */
+    uncacheRule(guildId, ruleId) {
+        if (this._ruleCache.has(guildId)) {
+            this._ruleCache.get(guildId).delete(ruleId);
+        }
+    }
+    /**
+     * Get a cached rule
+     */
+    getCachedRule(guildId, ruleId) {
+        return this._ruleCache.get(guildId)?.get(ruleId) || null;
+    }
+    /**
+     * Clear the rule cache for a guild
+     */
+    clearGuildCache(guildId) {
+        this._ruleCache.delete(guildId);
+    }
+    /**
+     * Clear all rule caches
+     */
+    clearAllCaches() {
+        this._ruleCache.clear();
+    }
+    /**
+     * Helper: Create a keyword filter rule
+     */
+    async createKeywordRule(guild, name, keywords, actions, options) {
+        return this.createRule(guild, {
+            name,
+            eventType: discord_js_1.AutoModerationRuleEventType.MessageSend,
+            triggerType: discord_js_1.AutoModerationRuleTriggerType.Keyword,
+            triggerMetadata: {
+                keywordFilter: keywords,
+                allowList: options?.allowList,
+            },
+            actions,
+            enabled: options?.enabled,
+            exemptRoles: options?.exemptRoles,
+            exemptChannels: options?.exemptChannels,
+        });
+    }
+    /**
+     * Helper: Create a spam rule
+     */
+    async createSpamRule(guild, name, actions, options) {
+        return this.createRule(guild, {
+            name,
+            eventType: discord_js_1.AutoModerationRuleEventType.MessageSend,
+            triggerType: discord_js_1.AutoModerationRuleTriggerType.Spam,
+            actions,
+            enabled: options?.enabled,
+            exemptRoles: options?.exemptRoles,
+            exemptChannels: options?.exemptChannels,
+        });
+    }
+    /**
+     * Helper: Create a mention spam rule
+     */
+    async createMentionSpamRule(guild, name, mentionLimit, actions, options) {
+        return this.createRule(guild, {
+            name,
+            eventType: discord_js_1.AutoModerationRuleEventType.MessageSend,
+            triggerType: discord_js_1.AutoModerationRuleTriggerType.MentionSpam,
+            triggerMetadata: {
+                mentionTotalLimit: mentionLimit,
+                mentionRaidProtectionEnabled: options?.raidProtection ?? false,
+            },
+            actions,
+            enabled: options?.enabled,
+            exemptRoles: options?.exemptRoles,
+            exemptChannels: options?.exemptChannels,
+        });
+    }
+    /**
+     * Helper: Create a regex pattern rule
+     */
+    async createRegexRule(guild, name, patterns, actions, options) {
+        return this.createRule(guild, {
+            name,
+            eventType: discord_js_1.AutoModerationRuleEventType.MessageSend,
+            triggerType: discord_js_1.AutoModerationRuleTriggerType.Keyword,
+            triggerMetadata: {
+                regexPatterns: patterns,
+                allowList: options?.allowList,
+            },
+            actions,
+            enabled: options?.enabled,
+            exemptRoles: options?.exemptRoles,
+            exemptChannels: options?.exemptChannels,
+        });
+    }
+    /**
+     * Helper: Create preset keyword rule (profanity, slurs, etc.)
+     */
+    async createPresetRule(guild, name, presets, actions, options) {
+        return this.createRule(guild, {
+            name,
+            eventType: discord_js_1.AutoModerationRuleEventType.MessageSend,
+            triggerType: discord_js_1.AutoModerationRuleTriggerType.KeywordPreset,
+            triggerMetadata: {
+                presets,
+                allowList: options?.allowList,
+            },
+            actions,
+            enabled: options?.enabled,
+            exemptRoles: options?.exemptRoles,
+            exemptChannels: options?.exemptChannels,
+        });
+    }
+}
+exports.default = AutoModHandler;

package/dist/handlers/ComponentHandler.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_all_files_1 = __importDefault(require("../get-all-files"));
+class ComponentHandler {
+    _client;
+    _instance;
+    _buttonHandlers = new Map();
+    _selectMenuHandlers = new Map();
+    constructor(instance, componentsDir, typeScript = false) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp(componentsDir, typeScript);
+    }
+    async setUp(componentsDir, typeScript = false) {
+        // Listen for component interactions
+        this._client.on('interactionCreate', async (interaction) => {
+            if (!interaction.isButton() && !interaction.isAnySelectMenu()) {
+                return;
+            }
+            const customId = interaction.customId;
+            if (interaction.isButton()) {
+                await this.handleButton(interaction, customId);
+            }
+            else if (interaction.isAnySelectMenu()) {
+                await this.handleSelectMenu(interaction, customId);
+            }
+        });
+        // Load custom component handlers if directory provided
+        if (componentsDir) {
+            await this.loadComponentHandlers(componentsDir, typeScript);
+        }
+    }
+    async loadComponentHandlers(dir, typeScript) {
+        const files = (0, get_all_files_1.default)(dir, typeScript ? '.ts' : '');
+        for (const [file, fileName] of files) {
+            const handler = require(file);
+            const config = handler.default || handler;
+            if (config.type === 'button') {
+                this.registerButtonHandler(config);
+            }
+            else if (config.type === 'selectMenu') {
+                this.registerSelectMenuHandler(config);
+            }
+        }
+    }
+    registerButtonHandler(handler) {
+        const key = typeof handler.customId === 'string'
+            ? handler.customId
+            : handler.customId.source;
+        this._buttonHandlers.set(key, handler);
+    }
+    registerSelectMenuHandler(handler) {
+        const key = typeof handler.customId === 'string'
+            ? handler.customId
+            : handler.customId.source;
+        this._selectMenuHandlers.set(key, handler);
+    }
+    async handleButton(interaction, customId) {
+        for (const [key, handler] of this._buttonHandlers.entries()) {
+            const regex = handler.customId instanceof RegExp ? handler.customId : null;
+            if ((regex && regex.test(customId)) ||
+                (!regex && handler.customId === customId)) {
+                try {
+                    await handler.callback(interaction, this._instance);
+                }
+                catch (error) {
+                    console.error(`SpaceCommands > Error handling button "${customId}":`, error);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({
+                            content: 'An error occurred while processing this button.',
+                            ephemeral: true,
+                        });
+                    }
+                }
+                return;
+            }
+        }
+    }
+    async handleSelectMenu(interaction, customId) {
+        for (const [key, handler] of this._selectMenuHandlers.entries()) {
+            const regex = handler.customId instanceof RegExp ? handler.customId : null;
+            if ((regex && regex.test(customId)) ||
+                (!regex && handler.customId === customId)) {
+                try {
+                    await handler.callback(interaction, this._instance);
+                }
+                catch (error) {
+                    console.error(`SpaceCommands > Error handling select menu "${customId}":`, error);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({
+                            content: 'An error occurred while processing this menu.',
+                            ephemeral: true,
+                        });
+                    }
+                }
+                return;
+            }
+        }
+    }
+    get buttonHandlers() {
+        return this._buttonHandlers;
+    }
+    get selectMenuHandlers() {
+        return this._selectMenuHandlers;
+    }
+}
+exports.default = ComponentHandler;

package/dist/handlers/ContextMenuHandler.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const get_all_files_1 = __importDefault(require("../get-all-files"));
+class ContextMenuHandler {
+    _client;
+    _instance;
+    _contextMenus = new Map();
+    constructor(instance, contextMenusDir, typeScript = false) {
+        this._instance = instance;
+        this._client = instance.client;
+        this.setUp(contextMenusDir, typeScript);
+    }
+    async setUp(contextMenusDir, typeScript = false) {
+        // Listen for context menu interactions
+        this._client.on('interactionCreate', async (interaction) => {
+            if (!interaction.isContextMenuCommand()) {
+                return;
+            }
+            const commandName = interaction.commandName;
+            await this.handleContextMenu(interaction, commandName);
+        });
+        // Load custom context menu commands if directory provided
+        if (contextMenusDir) {
+            await this.loadContextMenus(contextMenusDir, typeScript);
+        }
+    }
+    async loadContextMenus(dir, typeScript) {
+        const files = (0, get_all_files_1.default)(dir, typeScript ? '.ts' : '');
+        for (const [file, fileName] of files) {
+            const command = require(file);
+            const config = command.default || command;
+            if (config.type && config.callback) {
+                await this.registerContextMenu(config);
+            }
+        }
+    }
+    async registerContextMenu(command) {
+        this._contextMenus.set(command.name, command);
+        // Register with Discord
+        const contextMenuCommand = new discord_js_1.ContextMenuCommandBuilder()
+            .setName(command.name)
+            .setType(command.type);
+        if (command.testOnly && this._instance.testServers.length) {
+            // Register to test servers only
+            for (const guildId of this._instance.testServers) {
+                const guild = this._client.guilds.cache.get(guildId);
+                if (guild) {
+                    await guild.commands.create(contextMenuCommand.toJSON());
+                }
+            }
+        }
+        else {
+            // Register globally
+            await this._client.application?.commands.create(contextMenuCommand.toJSON());
+        }
+        console.log(`SpaceCommands > Registered context menu command: ${command.name}`);
+    }
+    async handleContextMenu(interaction, commandName) {
+        const command = this._contextMenus.get(commandName);
+        if (!command) {
+            return;
+        }
+        // Check owner-only
+        if (command.ownerOnly &&
+            !this._instance.botOwner.includes(interaction.user.id)) {
+            await interaction.reply({
+                content: 'This command is only available to bot owners.',
+                ephemeral: true,
+            });
+            return;
+        }
+        // Check guild-only
+        if (command.guildOnly && !interaction.guild) {
+            await interaction.reply({
+                content: 'This command can only be used in servers.',
+                ephemeral: true,
+            });
+            return;
+        }
+        // Check permissions
+        if (command.permissions && interaction.guild && interaction.member) {
+            const member = interaction.member;
+            const hasPermission = command.permissions.every((perm) => member.permissions.has(perm));
+            if (!hasPermission) {
+                await interaction.reply({
+                    content: 'You do not have permission to use this command.',
+                    ephemeral: true,
+                });
+                return;
+            }
+        }
+        try {
+            await command.callback(interaction, this._instance);
+        }
+        catch (error) {
+            console.error(`SpaceCommands > Error handling context menu "${commandName}":`, error);
+            if (!interaction.replied && !interaction.deferred) {
+                await interaction.reply({
+                    content: 'An error occurred while executing this command.',
+                    ephemeral: true,
+                });
+            }
+        }
+    }
+    get contextMenus() {
+        return this._contextMenus;
+    }
+}
+exports.default = ContextMenuHandler;