ralph-cli-sandboxed 0.4.0 → 0.4.2

package/dist/providers/discord.js

@@ -0,0 +1,697 @@
+/**
+ * Discord chat client implementation.
+ * Uses discord.js for WebSocket-based real-time messaging via the Discord Gateway.
+ *
+ * Required packages (must be installed separately):
+ *   npm install discord.js
+ */
+import { parseCommand, } from "../utils/chat-client.js";
+import { ResponderMatcher } from "../utils/responder.js";
+import { loadConfig } from "../utils/config.js";
+import { executeLLMResponder } from "../responders/llm-responder.js";
+import { executeClaudeCodeResponder } from "../responders/claude-code-responder.js";
+import { executeCLIResponder } from "../responders/cli-responder.js";
+// Discord.js classes loaded dynamically
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ClientConstructor = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let GatewayIntentBits = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ActionRowBuilder = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ButtonBuilder = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ButtonStyle = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let SlashCommandBuilder = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let REST = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let Routes = null;
+async function loadDiscordModules() {
+    try {
+        // Dynamic import to avoid compile-time errors when packages aren't installed
+        const dynamicImport = new Function("specifier", "return import(specifier)");
+        const discordJs = await dynamicImport("discord.js");
+        ClientConstructor = discordJs.Client;
+        GatewayIntentBits = discordJs.GatewayIntentBits;
+        ActionRowBuilder = discordJs.ActionRowBuilder;
+        ButtonBuilder = discordJs.ButtonBuilder;
+        ButtonStyle = discordJs.ButtonStyle;
+        SlashCommandBuilder = discordJs.SlashCommandBuilder;
+        REST = discordJs.REST;
+        Routes = discordJs.Routes;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class DiscordChatClient {
+    provider = "discord";
+    settings;
+    connected = false;
+    debug;
+    client = null;
+    onCommand = null;
+    onMessage = null;
+    responderMatcher = null;
+    respondersConfig = null;
+    botUserId = null;
+    constructor(settings, debug = false) {
+        this.settings = settings;
+        this.debug = debug;
+        // Initialize responders from config if available
+        this.initializeResponders();
+    }
+    /**
+     * Initialize responder matching from config.
+     */
+    initializeResponders() {
+        try {
+            const config = loadConfig();
+            if (config.chat?.responders) {
+                this.respondersConfig = config.chat.responders;
+                this.responderMatcher = new ResponderMatcher(config.chat.responders);
+                if (this.debug) {
+                    console.log(`[discord] Initialized ${Object.keys(config.chat.responders).length} responders`);
+                }
+            }
+        }
+        catch {
+            // Config not available or responders not configured
+            if (this.debug) {
+                console.log("[discord] No responders configured");
+            }
+        }
+    }
+    /**
+     * Execute a responder and return the result.
+     */
+    async executeResponder(match, message) {
+        const { responder } = match;
+        switch (responder.type) {
+            case "llm":
+                return executeLLMResponder(message, responder);
+            case "claude-code":
+                return executeClaudeCodeResponder(message, responder);
+            case "cli":
+                return executeCLIResponder(message, responder);
+            default:
+                return {
+                    success: false,
+                    response: "",
+                    error: `Unknown responder type: ${responder.type}`,
+                };
+        }
+    }
+    /**
+     * Handle a message that might match a responder.
+     * Returns true if a responder was matched and executed.
+     */
+    async handleResponderMessage(originalMessage, cleanedText) {
+        if (!this.responderMatcher) {
+            return false;
+        }
+        const match = this.responderMatcher.matchResponder(cleanedText);
+        if (!match) {
+            return false;
+        }
+        if (this.debug) {
+            console.log(`[discord] Matched responder: ${match.name} (type: ${match.responder.type})`);
+        }
+        // Execute the responder
+        const result = await this.executeResponder(match, match.args || cleanedText);
+        // Send the response (reply to the original message for context)
+        try {
+            if (result.success) {
+                // Truncate to Discord's 2000 char limit
+                const responseText = result.response.substring(0, 2000);
+                await originalMessage.reply(responseText);
+            }
+            else {
+                const errorMsg = result.error
+                    ? `Error: ${result.error}`
+                    : "An error occurred while processing your message.";
+                await originalMessage.reply(errorMsg);
+            }
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[discord] Failed to send responder reply: ${err}`);
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if the bot is mentioned in a message.
+     */
+    isBotMentioned(message) {
+        if (!this.botUserId) {
+            return false;
+        }
+        // Check if the message mentions the bot user
+        if (message.mentions && typeof message.mentions.has === "function") {
+            return message.mentions.has(this.botUserId);
+        }
+        // Fallback: check text for <@BOT_ID> pattern
+        return message.content?.includes(`<@${this.botUserId}>`) || false;
+    }
+    /**
+     * Remove bot mention from message text.
+     */
+    removeBotMention(text) {
+        if (!this.botUserId) {
+            return text;
+        }
+        // Remove <@BOT_ID> and any surrounding whitespace
+        // Also handles <@!BOT_ID> format (with nickname)
+        return text.replace(new RegExp(`<@!?${this.botUserId}>\\s*`, "g"), "").trim();
+    }
+    /**
+     * Check if this is a DM (direct message) channel.
+     */
+    isDMChannel(message) {
+        // DM channels have type 1 (DM) or could check if guild is null
+        return message.channel?.type === 1 || !message.guild;
+    }
+    /**
+     * Check if a guild ID is allowed.
+     */
+    isGuildAllowed(guildId) {
+        // If no allowed guild IDs specified, allow all
+        if (!this.settings.allowedGuildIds || this.settings.allowedGuildIds.length === 0) {
+            return true;
+        }
+        if (!guildId)
+            return false;
+        return this.settings.allowedGuildIds.includes(guildId);
+    }
+    /**
+     * Check if a channel ID is allowed.
+     */
+    isChannelAllowed(channelId) {
+        // If no allowed channel IDs specified, allow all
+        if (!this.settings.allowedChannelIds || this.settings.allowedChannelIds.length === 0) {
+            return true;
+        }
+        return this.settings.allowedChannelIds.includes(channelId);
+    }
+    /**
+     * Convert a Discord message to our ChatMessage format.
+     */
+    toMessage(message) {
+        return {
+            text: message.content || "",
+            chatId: message.channel.id,
+            senderId: message.author?.id,
+            senderName: message.author?.username,
+            timestamp: message.createdAt || new Date(),
+            raw: message,
+        };
+    }
+    /**
+     * Register slash commands with Discord.
+     */
+    async registerSlashCommands() {
+        if (!this.client || !REST || !Routes || !SlashCommandBuilder)
+            return;
+        const commands = [
+            {
+                name: "run",
+                description: "Start ralph automation",
+                hasArgs: true,
+                argName: "category",
+                argDesc: "Optional category filter",
+            },
+            { name: "status", description: "Show PRD progress", hasArgs: false },
+            {
+                name: "add",
+                description: "Add new task to PRD",
+                hasArgs: true,
+                argName: "description",
+                argDesc: "Task description",
+                required: true,
+            },
+            {
+                name: "exec",
+                description: "Execute shell command",
+                hasArgs: true,
+                argName: "command",
+                argDesc: "Shell command to run",
+                required: true,
+            },
+            { name: "stop", description: "Stop running ralph process", hasArgs: false },
+            { name: "help", description: "Show help", hasArgs: false },
+            {
+                name: "action",
+                description: "Run daemon action",
+                hasArgs: true,
+                argName: "name",
+                argDesc: "Action name",
+            },
+            {
+                name: "claude",
+                description: "Run Claude Code with prompt",
+                hasArgs: true,
+                argName: "prompt",
+                argDesc: "Prompt for Claude Code",
+                required: true,
+            },
+        ];
+        const slashCommands = commands.map((cmd) => {
+            const builder = new SlashCommandBuilder().setName(cmd.name).setDescription(cmd.description);
+            if (cmd.hasArgs && cmd.argName) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                builder.addStringOption((option) => option
+                    .setName(cmd.argName)
+                    .setDescription(cmd.argDesc || "Argument")
+                    .setRequired(cmd.required || false));
+            }
+            return builder;
+        });
+        const rest = new REST({ version: "10" }).setToken(this.settings.botToken);
+        try {
+            const clientId = this.client.user?.id;
+            if (!clientId) {
+                if (this.debug) {
+                    console.log("[discord] Cannot register slash commands: client ID not available");
+                }
+                return;
+            }
+            if (this.debug) {
+                console.log("[discord] Registering slash commands...");
+            }
+            await rest.put(Routes.applicationCommands(clientId), {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                body: slashCommands.map((cmd) => cmd.toJSON()),
+            });
+            if (this.debug) {
+                console.log("[discord] Slash commands registered successfully");
+            }
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[discord] Failed to register slash commands: ${err}`);
+            }
+        }
+    }
+    /**
+     * Handle incoming Discord messages.
+     */
+    async handleMessage(message) {
+        // Ignore messages from bots (including self)
+        if (message.author?.bot)
+            return;
+        // Check if guild is allowed (null guild is ok for DMs)
+        if (!this.isGuildAllowed(message.guild?.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring message from unauthorized guild: ${message.guild?.id}`);
+            }
+            return;
+        }
+        // Check if channel is allowed
+        if (!this.isChannelAllowed(message.channel.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring message from unauthorized channel: ${message.channel.id}`);
+            }
+            return;
+        }
+        // Check if bot is mentioned or if this is a DM
+        const isMention = this.isBotMentioned(message);
+        const isDM = this.isDMChannel(message);
+        // Clean the message text (remove bot mention if present)
+        let messageText = message.content || "";
+        if (isMention) {
+            messageText = this.removeBotMention(messageText);
+        }
+        const chatMessage = {
+            text: messageText,
+            chatId: message.channel.id,
+            senderId: message.author?.id,
+            senderName: message.author?.username,
+            timestamp: message.createdAt || new Date(),
+            raw: message,
+        };
+        // Call raw message handler if provided
+        if (this.onMessage) {
+            try {
+                await this.onMessage(chatMessage);
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.error(`[discord] Message handler error: ${err}`);
+                }
+            }
+        }
+        // Try to parse as a command first
+        const command = parseCommand(messageText, chatMessage);
+        if (command && this.onCommand) {
+            try {
+                await this.onCommand(command);
+                return; // Command handled, don't process as responder message
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.error(`[discord] Command handler error: ${err}`);
+                }
+                // Send error message to channel
+                try {
+                    await message.reply(`Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`);
+                }
+                catch {
+                    // Ignore reply errors
+                }
+                return;
+            }
+        }
+        // For non-command messages, route through responders
+        // In guilds (servers): only respond if bot is mentioned
+        // In DMs: always respond if responders are configured
+        const shouldProcessAsResponder = isDM || isMention;
+        if (shouldProcessAsResponder && this.responderMatcher) {
+            // Check if there's a matching responder or a default responder
+            const match = this.responderMatcher.matchResponder(messageText);
+            if (match) {
+                try {
+                    const handled = await this.handleResponderMessage(message, messageText);
+                    if (handled) {
+                        return;
+                    }
+                }
+                catch (err) {
+                    if (this.debug) {
+                        console.error(`[discord] Responder error: ${err}`);
+                    }
+                    try {
+                        await message.reply(`Error processing message: ${err instanceof Error ? err.message : "Unknown error"}`);
+                    }
+                    catch {
+                        // Ignore reply errors
+                    }
+                    return;
+                }
+            }
+            else if (isMention && !this.responderMatcher.hasDefaultResponder()) {
+                // Bot was mentioned but no responder matched and no default responder
+                // Send a helpful message
+                try {
+                    await message.reply("I received your message, but no responders are configured. Use `/help` for available commands.");
+                }
+                catch {
+                    // Ignore reply errors
+                }
+            }
+        }
+    }
+    /**
+     * Handle slash command interactions.
+     */
+    async handleInteraction(interaction) {
+        // Handle button interactions
+        if (interaction.isButton && interaction.isButton()) {
+            await this.handleButtonInteraction(interaction);
+            return;
+        }
+        // Only handle slash commands
+        if (!interaction.isChatInputCommand || !interaction.isChatInputCommand())
+            return;
+        // Check if guild is allowed
+        if (!this.isGuildAllowed(interaction.guild?.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring interaction from unauthorized guild: ${interaction.guild?.id}`);
+            }
+            try {
+                await interaction.reply({
+                    content: "This server is not authorized to use ralph commands.",
+                    ephemeral: true,
+                });
+            }
+            catch {
+                // Ignore reply errors
+            }
+            return;
+        }
+        // Check if channel is allowed
+        if (!this.isChannelAllowed(interaction.channel?.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring interaction from unauthorized channel: ${interaction.channel?.id}`);
+            }
+            try {
+                await interaction.reply({
+                    content: "This channel is not authorized to use ralph commands.",
+                    ephemeral: true,
+                });
+            }
+            catch {
+                // Ignore reply errors
+            }
+            return;
+        }
+        const commandName = interaction.commandName;
+        const args = [];
+        // Extract arguments based on command
+        const argMappings = {
+            run: "category",
+            add: "description",
+            exec: "command",
+            action: "name",
+            claude: "prompt",
+        };
+        const argName = argMappings[commandName];
+        if (argName) {
+            const argValue = interaction.options?.getString(argName);
+            if (argValue) {
+                // Split the argument for commands that expect multiple args
+                if (commandName === "exec" || commandName === "add" || commandName === "claude") {
+                    args.push(...argValue.split(/\s+/));
+                }
+                else {
+                    args.push(argValue);
+                }
+            }
+        }
+        const chatMessage = {
+            text: `/${commandName} ${args.join(" ")}`.trim(),
+            chatId: interaction.channel?.id || "",
+            senderId: interaction.user?.id,
+            senderName: interaction.user?.username,
+            timestamp: new Date(),
+            raw: interaction,
+        };
+        const parsedCommand = {
+            projectId: "",
+            command: commandName,
+            args,
+            message: chatMessage,
+        };
+        // Acknowledge the interaction immediately (Discord requires response within 3 seconds)
+        try {
+            await interaction.deferReply();
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[discord] Failed to defer reply: ${err}`);
+            }
+            return;
+        }
+        if (this.onCommand) {
+            try {
+                await this.onCommand(parsedCommand);
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.error(`[discord] Slash command error: ${err}`);
+                }
+                try {
+                    await interaction.editReply(`Error executing /${commandName}: ${err instanceof Error ? err.message : "Unknown error"}`);
+                }
+                catch {
+                    // Ignore edit errors
+                }
+            }
+        }
+    }
+    /**
+     * Handle button interactions.
+     */
+    async handleButtonInteraction(interaction) {
+        // Check if guild is allowed
+        if (!this.isGuildAllowed(interaction.guild?.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring button from unauthorized guild: ${interaction.guild?.id}`);
+            }
+            return;
+        }
+        // Check if channel is allowed
+        if (!this.isChannelAllowed(interaction.channel?.id)) {
+            if (this.debug) {
+                console.log(`[discord] Ignoring button from unauthorized channel: ${interaction.channel?.id}`);
+            }
+            return;
+        }
+        // The custom_id contains the command (e.g., "/run feature")
+        const commandText = interaction.customId;
+        if (!commandText)
+            return;
+        const chatMessage = {
+            text: commandText,
+            chatId: interaction.channel?.id || "",
+            senderId: interaction.user?.id,
+            senderName: interaction.user?.username,
+            timestamp: new Date(),
+            raw: interaction,
+        };
+        // Parse and execute the command
+        const command = parseCommand(commandText, chatMessage);
+        // Acknowledge the button press
+        try {
+            await interaction.deferUpdate();
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[discord] Failed to defer button update: ${err}`);
+            }
+        }
+        if (command && this.onCommand) {
+            try {
+                await this.onCommand(command);
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.error(`[discord] Button action error: ${err}`);
+                }
+            }
+        }
+    }
+    async connect(onCommand, onMessage) {
+        if (this.connected) {
+            throw new Error("Already connected");
+        }
+        // Load Discord modules dynamically
+        const loaded = await loadDiscordModules();
+        if (!loaded || !ClientConstructor || !GatewayIntentBits) {
+            throw new Error("Failed to load Discord modules. Make sure discord.js is installed:\n" +
+                "  npm install discord.js");
+        }
+        this.onCommand = onCommand;
+        this.onMessage = onMessage || null;
+        try {
+            // Create Discord client with required intents
+            this.client = new ClientConstructor({
+                intents: [
+                    GatewayIntentBits.Guilds,
+                    GatewayIntentBits.GuildMessages,
+                    GatewayIntentBits.MessageContent,
+                    GatewayIntentBits.DirectMessages,
+                ],
+            });
+            // Setup event handlers
+            this.client.on("messageCreate", (message) => this.handleMessage(message));
+            this.client.on("interactionCreate", (interaction) => this.handleInteraction(interaction));
+            // Handle ready event
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error("Discord login timed out after 30 seconds"));
+                }, 30000);
+                this.client.once("ready", async () => {
+                    clearTimeout(timeout);
+                    // Store bot user ID for mention detection
+                    this.botUserId = this.client.user?.id || null;
+                    if (this.debug) {
+                        console.log(`[discord] Connected as ${this.client.user?.tag} (ID: ${this.botUserId})`);
+                    }
+                    // Register slash commands after login
+                    await this.registerSlashCommands();
+                    resolve();
+                });
+                this.client.once("error", (err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                });
+                // Login to Discord
+                this.client.login(this.settings.botToken).catch((err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                });
+            });
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`Failed to connect to Discord: ${err instanceof Error ? err.message : "Unknown error"}`);
+        }
+    }
+    async sendMessage(chatId, text, options) {
+        if (!this.connected || !this.client) {
+            throw new Error("Not connected");
+        }
+        // Get the channel
+        let channel;
+        try {
+            channel = await this.client.channels.fetch(chatId);
+        }
+        catch (err) {
+            throw new Error(`Failed to fetch channel ${chatId}: ${err instanceof Error ? err.message : "Unknown error"}`);
+        }
+        if (!channel || !channel.send) {
+            throw new Error(`Channel ${chatId} is not a text channel or doesn't exist`);
+        }
+        // Build message payload
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const payload = {
+            content: text.substring(0, 2000), // Discord has 2000 char limit
+        };
+        // Convert inline keyboard to Discord buttons
+        if (options?.inlineKeyboard &&
+            options.inlineKeyboard.length > 0 &&
+            ActionRowBuilder &&
+            ButtonBuilder &&
+            ButtonStyle) {
+            const components = [];
+            for (const row of options.inlineKeyboard) {
+                const actionRow = new ActionRowBuilder();
+                const buttons = [];
+                for (const button of row) {
+                    const discordButton = new ButtonBuilder();
+                    if (button.url) {
+                        // URL buttons use Link style
+                        discordButton
+                            .setLabel(button.text.substring(0, 80)) // Discord button label limit
+                            .setStyle(ButtonStyle.Link)
+                            .setURL(button.url);
+                    }
+                    else {
+                        // Regular buttons use Primary style with custom_id
+                        discordButton
+                            .setLabel(button.text.substring(0, 80))
+                            .setStyle(ButtonStyle.Primary)
+                            .setCustomId(button.callbackData || button.text);
+                    }
+                    buttons.push(discordButton);
+                }
+                actionRow.addComponents(...buttons);
+                components.push(actionRow);
+            }
+            payload.components = components;
+        }
+        await channel.send(payload);
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+        this.connected = false;
+        this.onCommand = null;
+        this.onMessage = null;
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+/**
+ * Create a Discord chat client from settings.
+ */
+export function createDiscordClient(settings, debug = false) {
+    return new DiscordChatClient(settings, debug);
+}