cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/discord.js

@@ -0,0 +1,975 @@
+"use strict";
+/**
+ * Discord Channel Adapter
+ *
+ * Implements the ChannelAdapter interface using discord.js for Discord Bot API.
+ * Supports slash commands, direct messages, button components, embeds, and threads.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordAdapter = void 0;
+exports.createDiscordAdapter = createDiscordAdapter;
+const discord_js_1 = require("discord.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Embed color constants for different message types
+ */
+const EMBED_COLORS = {
+    pending: 0xffa500, // Orange
+    success: 0x57f287, // Green
+    error: 0xed4245, // Red
+    info: 0x5865f2, // Blue (Discord blurple)
+    warning: 0xfee75c, // Yellow
+    neutral: 0x99aab5, // Gray
+};
+class DiscordAdapter {
+    constructor(config) {
+        this.type = 'discord';
+        this.client = null;
+        this._status = 'disconnected';
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.statusHandlers = [];
+        this.callbackQueryHandlers = [];
+        this.selectMenuHandlers = [];
+        // Track pending interactions that need reply (chatId -> interaction)
+        this.pendingInteractions = new Map();
+        // Track thread starters for context (threadId -> starter info)
+        this.threadStarterCache = new Map();
+        this.config = config;
+    }
+    get status() {
+        return this._status;
+    }
+    get botUsername() {
+        return this._botUsername;
+    }
+    /**
+     * Connect to Discord
+     */
+    async connect() {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        try {
+            // Create client instance with required intents and partials
+            // Partials.Channel is required to receive DM messages
+            this.client = new discord_js_1.Client({
+                intents: [
+                    discord_js_1.GatewayIntentBits.Guilds,
+                    discord_js_1.GatewayIntentBits.GuildMessages,
+                    discord_js_1.GatewayIntentBits.DirectMessages,
+                    discord_js_1.GatewayIntentBits.MessageContent,
+                ],
+                partials: [
+                    discord_js_1.Partials.Channel, // Required to receive DMs
+                    discord_js_1.Partials.Message, // Required for uncached message events
+                ],
+            });
+            // Set up event handlers
+            this.client.once(discord_js_1.Events.ClientReady, async (client) => {
+                this._botUsername = client.user.username;
+                this._botId = client.user.id;
+                console.log(`Discord bot @${this._botUsername} is ready`);
+                // Register slash commands
+                await this.registerSlashCommands();
+                this.setStatus('connected');
+            });
+            // Handle regular messages (for conversations)
+            this.client.on(discord_js_1.Events.MessageCreate, async (message) => {
+                // Ignore bot messages
+                if (message.author.bot)
+                    return;
+                // Handle DMs and mentions in guilds
+                const isDM = message.channel.type === discord_js_1.ChannelType.DM;
+                const isMentioned = message.mentions.has(this.client.user);
+                const isThread = message.channel.isThread();
+                console.log(`Discord message received: isDM=${isDM}, isMentioned=${isMentioned}, isThread=${isThread}, content="${message.content.slice(0, 50)}"`);
+                if (isDM || isMentioned) {
+                    const incomingMessage = this.mapMessageToIncoming(message);
+                    console.log(`Processing Discord message from ${message.author.username}: ${incomingMessage.text.slice(0, 50)}`);
+                    await this.handleIncomingMessage(incomingMessage);
+                }
+            });
+            // Handle slash command, button, and select menu interactions
+            this.client.on(discord_js_1.Events.InteractionCreate, async (interaction) => {
+                // Handle button interactions
+                if (interaction.isButton()) {
+                    await this.handleButtonInteraction(interaction);
+                    return;
+                }
+                // Handle select menu interactions
+                if (interaction.isStringSelectMenu()) {
+                    await this.handleSelectMenuInteraction(interaction);
+                    return;
+                }
+                if (!interaction.isChatInputCommand())
+                    return;
+                // Defer the reply FIRST to avoid interaction timeout (Discord requires response within 3 seconds)
+                try {
+                    await interaction.deferReply();
+                }
+                catch (error) {
+                    console.error('Failed to defer reply:', error);
+                    return;
+                }
+                // Store the interaction so sendMessage can use editReply for the first response
+                if (interaction.channelId) {
+                    this.pendingInteractions.set(interaction.channelId, interaction);
+                    // Auto-clear after 14 minutes (interactions expire after 15 minutes)
+                    setTimeout(() => {
+                        this.pendingInteractions.delete(interaction.channelId);
+                    }, 14 * 60 * 1000);
+                }
+                // Convert slash command to message format
+                const incomingMessage = this.mapInteractionToIncoming(interaction);
+                await this.handleIncomingMessage(incomingMessage);
+            });
+            // Handle errors
+            this.client.on(discord_js_1.Events.Error, (error) => {
+                console.error('Discord client error:', error);
+                this.handleError(error, 'client.error');
+            });
+            // Login
+            await this.client.login(this.config.botToken);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.setStatus('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Handle button interaction (callback query equivalent)
+     */
+    async handleButtonInteraction(interaction) {
+        const customId = interaction.customId;
+        // Create callback query object matching our interface
+        const callbackQuery = {
+            id: interaction.id,
+            userId: interaction.user.id,
+            userName: interaction.user.displayName || interaction.user.username,
+            chatId: interaction.channelId,
+            messageId: interaction.message.id,
+            data: customId,
+            threadId: interaction.channel?.isThread() ? interaction.channelId : undefined,
+            raw: interaction,
+        };
+        // Notify all registered handlers
+        for (const handler of this.callbackQueryHandlers) {
+            try {
+                await handler(callbackQuery);
+            }
+            catch (error) {
+                console.error('Error in callback query handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'callbackQueryHandler');
+            }
+        }
+    }
+    /**
+     * Register slash commands with Discord
+     */
+    async registerSlashCommands() {
+        if (!this.client?.user)
+            return;
+        const commands = [
+            new discord_js_1.SlashCommandBuilder()
+                .setName('start')
+                .setDescription('Start the bot and get help'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('help')
+                .setDescription('Show available commands'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('workspaces')
+                .setDescription('List available workspaces'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('workspace')
+                .setDescription('Select or show current workspace')
+                .addStringOption(option => option.setName('path')
+                .setDescription('Workspace path to select')
+                .setRequired(false)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('addworkspace')
+                .setDescription('Add a new workspace by path')
+                .addStringOption(option => option.setName('path')
+                .setDescription('Path to the workspace folder')
+                .setRequired(true)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('newtask')
+                .setDescription('Start a fresh task/conversation'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('provider')
+                .setDescription('Change or show current LLM provider')
+                .addStringOption(option => option.setName('name')
+                .setDescription('Provider name (anthropic, gemini, openrouter, bedrock, ollama)')
+                .setRequired(false)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('providers')
+                .setDescription('List all available providers'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('models')
+                .setDescription('List available AI models'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('model')
+                .setDescription('Change or show current model')
+                .addStringOption(option => option.setName('name')
+                .setDescription('Model name to use')
+                .setRequired(false)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('status')
+                .setDescription('Check bot status'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('cancel')
+                .setDescription('Cancel current task'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('task')
+                .setDescription('Run a task')
+                .addStringOption(option => option.setName('prompt')
+                .setDescription('Task description')
+                .setRequired(true)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('pair')
+                .setDescription('Pair with a pairing code to gain access')
+                .addStringOption(option => option.setName('code')
+                .setDescription('The pairing code from CoWork OS app')
+                .setRequired(true)),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('approve')
+                .setDescription('Approve the pending action'),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('deny')
+                .setDescription('Deny the pending action'),
+        ];
+        const rest = new discord_js_1.REST().setToken(this.config.botToken);
+        try {
+            console.log('Registering Discord slash commands...');
+            // Register commands globally or to specific guilds
+            if (this.config.guildIds && this.config.guildIds.length > 0) {
+                // Register to specific guilds (faster for development)
+                for (const guildId of this.config.guildIds) {
+                    await rest.put(discord_js_1.Routes.applicationGuildCommands(this.config.applicationId, guildId), { body: commands.map(c => c.toJSON()) });
+                }
+            }
+            else {
+                // Register globally (takes up to 1 hour to propagate)
+                await rest.put(discord_js_1.Routes.applicationCommands(this.config.applicationId), { body: commands.map(c => c.toJSON()) });
+            }
+            console.log('Discord slash commands registered');
+        }
+        catch (error) {
+            console.error('Failed to register Discord slash commands:', error);
+        }
+    }
+    /**
+     * Disconnect from Discord
+     */
+    async disconnect() {
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+        this._botUsername = undefined;
+        this._botId = undefined;
+        this.setStatus('disconnected');
+    }
+    /**
+     * Send a message to a Discord channel
+     */
+    async sendMessage(message) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        // Process text for Discord compatibility
+        let processedText = message.text;
+        if (message.parseMode === 'markdown') {
+            processedText = this.convertMarkdownForDiscord(message.text);
+        }
+        // Build button components if inline keyboard is provided
+        const components = message.inlineKeyboard && message.inlineKeyboard.length > 0
+            ? this.buildButtonComponents(message.inlineKeyboard)
+            : [];
+        // Use smart chunking that preserves code fences
+        const chunks = this.splitMessageSmart(processedText, 2000);
+        let lastMessageId = '';
+        // Check if there's a pending interaction for this chat that needs reply
+        const pendingInteraction = this.pendingInteractions.get(message.chatId);
+        // Determine target channel (could be a thread)
+        let targetChannelId = message.chatId;
+        if (message.threadId) {
+            targetChannelId = message.threadId;
+        }
+        try {
+            for (let i = 0; i < chunks.length; i++) {
+                const chunk = chunks[i];
+                const isLastChunk = i === chunks.length - 1;
+                // Only add buttons to the last chunk
+                const chunkComponents = isLastChunk ? components : [];
+                // First chunk: use interaction reply if available
+                if (i === 0 && pendingInteraction) {
+                    try {
+                        const reply = await pendingInteraction.editReply({
+                            content: chunk,
+                            components: chunkComponents,
+                        });
+                        lastMessageId = typeof reply === 'object' && 'id' in reply ? reply.id : pendingInteraction.id;
+                        // Clear the pending interaction after first reply
+                        this.pendingInteractions.delete(message.chatId);
+                        continue;
+                    }
+                    catch (interactionError) {
+                        // Interaction may have expired, fall back to channel.send
+                        console.warn('Interaction reply failed, falling back to channel.send:', interactionError);
+                        this.pendingInteractions.delete(message.chatId);
+                    }
+                }
+                // Regular channel message
+                const channel = await this.client.channels.fetch(targetChannelId);
+                if (!channel || !this.isTextBasedChannel(channel)) {
+                    throw new Error('Invalid channel or channel is not text-based');
+                }
+                const sent = await channel.send({
+                    content: chunk,
+                    components: chunkComponents,
+                    reply: message.replyTo && i === 0 ? { messageReference: message.replyTo } : undefined,
+                });
+                lastMessageId = sent.id;
+            }
+        }
+        catch (error) {
+            // If markdown parsing fails, retry without formatting
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('parse') || errorMessage.includes('format')) {
+                console.log('Markdown parsing failed, retrying without formatting');
+                return this.sendMessagePlain(targetChannelId, message.text, message.replyTo, components);
+            }
+            throw error;
+        }
+        return lastMessageId;
+    }
+    /**
+     * Send a message with an embed (rich format)
+     */
+    async sendEmbed(chatId, options, buttons) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const embed = new discord_js_1.EmbedBuilder();
+        if (options.title)
+            embed.setTitle(options.title);
+        if (options.description)
+            embed.setDescription(options.description);
+        if (options.color)
+            embed.setColor(EMBED_COLORS[options.color]);
+        if (options.fields) {
+            for (const field of options.fields) {
+                embed.addFields({ name: field.name, value: field.value, inline: field.inline });
+            }
+        }
+        if (options.footer)
+            embed.setFooter({ text: options.footer });
+        if (options.timestamp)
+            embed.setTimestamp();
+        const components = buttons ? this.buildButtonComponents(buttons) : [];
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const sent = await channel.send({
+            embeds: [embed],
+            components,
+        });
+        return sent.id;
+    }
+    /**
+     * Build Discord button components from our button format
+     */
+    buildButtonComponents(buttons) {
+        const rows = [];
+        for (const rowButtons of buttons) {
+            if (rowButtons.length === 0)
+                continue;
+            const row = new discord_js_1.ActionRowBuilder();
+            let buttonCount = 0;
+            for (const button of rowButtons) {
+                if (buttonCount >= 5)
+                    break; // Discord max 5 buttons per row
+                const discordButton = new discord_js_1.ButtonBuilder()
+                    .setLabel(button.text.substring(0, 80)); // Discord max 80 chars
+                if (button.url) {
+                    discordButton.setStyle(discord_js_1.ButtonStyle.Link);
+                    discordButton.setURL(button.url);
+                }
+                else if (button.callbackData) {
+                    // Determine button style based on callback data
+                    if (button.callbackData.startsWith('approve')) {
+                        discordButton.setStyle(discord_js_1.ButtonStyle.Success);
+                    }
+                    else if (button.callbackData.startsWith('deny')) {
+                        discordButton.setStyle(discord_js_1.ButtonStyle.Danger);
+                    }
+                    else {
+                        discordButton.setStyle(discord_js_1.ButtonStyle.Primary);
+                    }
+                    discordButton.setCustomId(button.callbackData.substring(0, 100)); // Discord max 100 chars
+                }
+                else {
+                    continue; // Skip buttons without action
+                }
+                row.addComponents(discordButton);
+                buttonCount++;
+            }
+            if (buttonCount > 0) {
+                rows.push(row);
+            }
+            if (rows.length >= 5)
+                break; // Discord max 5 rows
+        }
+        return rows;
+    }
+    /**
+     * Send a plain text message without formatting
+     */
+    async sendMessagePlain(chatId, text, replyTo, components = []) {
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const chunks = this.splitMessageSmart(text, 2000);
+        let lastMessageId = '';
+        for (let i = 0; i < chunks.length; i++) {
+            const isLastChunk = i === chunks.length - 1;
+            const sent = await channel.send({
+                content: chunks[i],
+                components: isLastChunk ? components : [],
+                reply: replyTo && i === 0 ? { messageReference: replyTo } : undefined,
+            });
+            lastMessageId = sent.id;
+        }
+        return lastMessageId;
+    }
+    /**
+     * Convert GitHub-flavored markdown to Discord-compatible format
+     */
+    convertMarkdownForDiscord(text) {
+        let result = text;
+        // Convert markdown headers (## Header) to bold (**Header**)
+        result = result.replace(/^#{1,6}\s+(.+)$/gm, '**$1**');
+        // Convert horizontal rules (---, ***) to a line
+        result = result.replace(/^[-*]{3,}$/gm, '───────────────────');
+        return result;
+    }
+    /**
+     * Smart message splitting that preserves code fences
+     */
+    splitMessageSmart(text, maxLength) {
+        if (text.length <= maxLength) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        let inCodeBlock = false;
+        let codeBlockLang = '';
+        while (remaining.length > 0) {
+            if (remaining.length <= maxLength) {
+                // Close any open code block at the end
+                if (inCodeBlock) {
+                    chunks.push(remaining);
+                }
+                else {
+                    chunks.push(remaining);
+                }
+                break;
+            }
+            // Find the best breaking point
+            let breakIndex = this.findBreakPoint(remaining, maxLength, inCodeBlock);
+            let chunk = remaining.substring(0, breakIndex);
+            // Check if we're entering or leaving a code block
+            const codeBlockMatches = chunk.match(/```(\w*)/g) || [];
+            for (const match of codeBlockMatches) {
+                if (inCodeBlock) {
+                    inCodeBlock = false;
+                    codeBlockLang = '';
+                }
+                else {
+                    inCodeBlock = true;
+                    codeBlockLang = match.replace('```', '');
+                }
+            }
+            // If we're in a code block and the chunk doesn't close it, close it manually
+            if (inCodeBlock && !chunk.endsWith('```')) {
+                chunk += '\n```';
+            }
+            chunks.push(chunk);
+            remaining = remaining.substring(breakIndex).trimStart();
+            // If we closed a code block, reopen it in the next chunk
+            if (inCodeBlock && remaining.length > 0) {
+                remaining = '```' + codeBlockLang + '\n' + remaining;
+            }
+        }
+        return chunks;
+    }
+    /**
+     * Find the best break point for message splitting
+     */
+    findBreakPoint(text, maxLength, inCodeBlock) {
+        // Reserve space for potential code fence closure
+        const reservedSpace = inCodeBlock ? 4 : 0;
+        const effectiveMax = maxLength - reservedSpace;
+        // Try to break at a newline
+        let breakIndex = text.lastIndexOf('\n', effectiveMax);
+        if (breakIndex > effectiveMax / 2) {
+            return breakIndex + 1;
+        }
+        // Try to break at a space
+        breakIndex = text.lastIndexOf(' ', effectiveMax);
+        if (breakIndex > effectiveMax / 2) {
+            return breakIndex + 1;
+        }
+        // Force break at max length
+        return effectiveMax;
+    }
+    /**
+     * Legacy split method for compatibility
+     */
+    splitMessage(text, maxLength) {
+        return this.splitMessageSmart(text, maxLength);
+    }
+    /**
+     * Edit an existing message
+     */
+    async editMessage(chatId, messageId, text) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const message = await channel.messages.fetch(messageId);
+        await message.edit(text);
+    }
+    /**
+     * Delete a message
+     */
+    async deleteMessage(chatId, messageId) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const message = await channel.messages.fetch(messageId);
+        await message.delete();
+    }
+    /**
+     * Send a document/file to a channel
+     */
+    async sendDocument(chatId, filePath, caption) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const fileName = path.basename(filePath);
+        const attachment = new discord_js_1.AttachmentBuilder(filePath, { name: fileName });
+        const sent = await channel.send({
+            content: caption,
+            files: [attachment],
+        });
+        return sent.id;
+    }
+    /**
+     * Register a message handler
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a callback query handler (for button interactions)
+     */
+    onCallbackQuery(handler) {
+        this.callbackQueryHandlers.push(handler);
+    }
+    /**
+     * Answer a callback query (acknowledge button press)
+     * For Discord, this updates the message or sends an ephemeral response
+     */
+    async answerCallbackQuery(queryId, text, showAlert) {
+        // In Discord, we need to use the interaction object stored in the raw field
+        // The queryId is the interaction ID, but we need the actual interaction object
+        // This is typically handled directly in handleButtonInteraction
+        // This method provides API compatibility with Telegram
+        console.log(`answerCallbackQuery called: ${queryId}, text: ${text}, showAlert: ${showAlert}`);
+    }
+    /**
+     * Edit a message with a new inline keyboard
+     */
+    async editMessageWithKeyboard(chatId, messageId, text, inlineKeyboard) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const message = await channel.messages.fetch(messageId);
+        const components = inlineKeyboard ? this.buildButtonComponents(inlineKeyboard) : [];
+        await message.edit({
+            content: text || message.content,
+            components,
+        });
+    }
+    // ============================================================================
+    // Extended Features
+    // ============================================================================
+    /**
+     * Send typing indicator
+     */
+    async sendTyping(chatId) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        await channel.sendTyping();
+    }
+    /**
+     * Add reaction to a message
+     */
+    async addReaction(chatId, messageId, emoji) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const message = await channel.messages.fetch(messageId);
+        await message.react(emoji);
+    }
+    /**
+     * Remove reaction from a message
+     */
+    async removeReaction(chatId, messageId, emoji) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const message = await channel.messages.fetch(messageId);
+        const reaction = message.reactions.cache.get(emoji);
+        if (reaction && this._botId) {
+            await reaction.users.remove(this._botId);
+        }
+    }
+    /**
+     * Send a poll (Discord native polls)
+     */
+    async sendPoll(chatId, poll) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        // Discord polls require specific formatting
+        const pollData = {
+            question: { text: poll.question },
+            answers: poll.options.map(opt => ({ text: opt.text })),
+            duration: poll.openPeriod ? Math.ceil(poll.openPeriod / 3600) : 24, // Convert seconds to hours
+            allow_multiselect: poll.allowsMultipleAnswers ?? false,
+        };
+        const sent = await channel.send({
+            poll: pollData,
+        });
+        return sent.id;
+    }
+    /**
+     * Send a message with a select menu (dropdown)
+     */
+    async sendWithSelectMenu(chatId, text, menu) {
+        if (!this.client || this._status !== 'connected') {
+            throw new Error('Discord bot is not connected');
+        }
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !this.isTextBasedChannel(channel)) {
+            throw new Error('Invalid channel');
+        }
+        const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+            .setCustomId(menu.customId)
+            .setPlaceholder(menu.placeholder || 'Select an option')
+            .setMinValues(menu.minValues ?? 1)
+            .setMaxValues(menu.maxValues ?? 1)
+            .addOptions(menu.options.map(opt => ({
+            label: opt.label,
+            value: opt.value,
+            description: opt.description,
+            emoji: opt.emoji ? { name: opt.emoji } : undefined,
+            default: opt.default,
+        })));
+        if (menu.disabled) {
+            selectMenu.setDisabled(true);
+        }
+        const row = new discord_js_1.ActionRowBuilder().addComponents(selectMenu);
+        const sent = await channel.send({
+            content: text,
+            components: [row],
+        });
+        return sent.id;
+    }
+    /**
+     * Register a select menu handler
+     */
+    onSelectMenu(handler) {
+        this.selectMenuHandlers.push(handler);
+    }
+    /**
+     * Handle select menu interaction
+     */
+    async handleSelectMenuInteraction(interaction) {
+        const customId = interaction.customId;
+        const values = interaction.values;
+        // Acknowledge the interaction
+        try {
+            await interaction.deferUpdate();
+        }
+        catch (error) {
+            console.error('Failed to defer select menu update:', error);
+        }
+        // Notify all registered handlers
+        for (const handler of this.selectMenuHandlers) {
+            try {
+                await handler(customId, values, interaction.user.id, interaction.channelId, interaction.message.id, interaction);
+            }
+            catch (error) {
+                console.error('Error in select menu handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'selectMenuHandler');
+            }
+        }
+    }
+    // ============================================================================
+    // Handler Registration
+    // ============================================================================
+    /**
+     * Register an error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Register a status change handler
+     */
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    /**
+     * Get channel info
+     */
+    async getInfo() {
+        return {
+            type: 'discord',
+            status: this._status,
+            botId: this._botId,
+            botUsername: this._botUsername,
+            botDisplayName: this._botUsername,
+            extra: {
+                applicationId: this.config.applicationId,
+                guildIds: this.config.guildIds,
+            },
+        };
+    }
+    // Private methods
+    isTextBasedChannel(channel) {
+        const ch = channel;
+        return ch.type === discord_js_1.ChannelType.GuildText ||
+            ch.type === discord_js_1.ChannelType.DM ||
+            ch.type === discord_js_1.ChannelType.PublicThread ||
+            ch.type === discord_js_1.ChannelType.PrivateThread;
+    }
+    mapMessageToIncoming(message) {
+        // Remove bot mention from the text if present
+        let text = message.content;
+        if (this._botId) {
+            text = text.replace(new RegExp(`<@!?${this._botId}>\\s*`, 'g'), '').trim();
+        }
+        // Map Discord message to command format if it looks like a command
+        const commandText = this.parseCommand(text);
+        // Check for thread context
+        const isThread = message.channel.isThread();
+        const threadId = isThread ? message.channelId : undefined;
+        return {
+            messageId: message.id,
+            channel: 'discord',
+            userId: message.author.id,
+            userName: message.author.displayName || message.author.username,
+            chatId: isThread ? message.channel.parentId : message.channelId,
+            text: commandText || text,
+            timestamp: message.createdAt,
+            replyTo: message.reference?.messageId,
+            threadId,
+            isForumTopic: isThread,
+            raw: message,
+        };
+    }
+    mapInteractionToIncoming(interaction) {
+        const commandName = interaction.commandName;
+        let text = `/${commandName}`;
+        // Add options to the command text
+        const options = interaction.options;
+        // Handle specific commands with their options
+        switch (commandName) {
+            case 'workspace': {
+                const wsPath = options.getString('path');
+                if (wsPath)
+                    text += ` ${wsPath}`;
+                break;
+            }
+            case 'addworkspace': {
+                const addPath = options.getString('path');
+                if (addPath)
+                    text += ` ${addPath}`;
+                break;
+            }
+            case 'provider': {
+                const provider = options.getString('name');
+                if (provider)
+                    text += ` ${provider}`;
+                break;
+            }
+            case 'model': {
+                const model = options.getString('name');
+                if (model)
+                    text += ` ${model}`;
+                break;
+            }
+            case 'task': {
+                const prompt = options.getString('prompt');
+                if (prompt)
+                    text = prompt; // Task prompt becomes the text directly
+                break;
+            }
+            case 'pair': {
+                const code = options.getString('code');
+                if (code)
+                    text += ` ${code}`;
+                break;
+            }
+        }
+        // Check for thread context
+        const isThread = interaction.channel?.isThread() ?? false;
+        return {
+            messageId: interaction.id,
+            channel: 'discord',
+            userId: interaction.user.id,
+            userName: interaction.user.displayName || interaction.user.username,
+            chatId: interaction.channelId,
+            text,
+            timestamp: new Date(interaction.createdTimestamp),
+            threadId: isThread ? interaction.channelId : undefined,
+            isForumTopic: isThread,
+            raw: interaction,
+        };
+    }
+    /**
+     * Parse text to see if it's a command (starts with /)
+     */
+    parseCommand(text) {
+        // Check if text starts with a command
+        const commandMatch = text.match(/^\/(\w+)(?:\s+(.*))?$/);
+        if (commandMatch) {
+            return text; // Already in command format
+        }
+        return null;
+    }
+    async handleIncomingMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(message);
+            }
+            catch (error) {
+                console.error('Error in message handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageHandler');
+            }
+        }
+    }
+    handleError(error, context) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, context);
+            }
+            catch (e) {
+                console.error('Error in error handler:', e);
+            }
+        }
+    }
+    setStatus(status, error) {
+        this._status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, error);
+            }
+            catch (e) {
+                console.error('Error in status handler:', e);
+            }
+        }
+    }
+}
+exports.DiscordAdapter = DiscordAdapter;
+/**
+ * Create a Discord adapter from configuration
+ */
+function createDiscordAdapter(config) {
+    if (!config.botToken) {
+        throw new Error('Discord bot token is required');
+    }
+    if (!config.applicationId) {
+        throw new Error('Discord application ID is required');
+    }
+    return new DiscordAdapter(config);
+}