@neomei/opencode-feishu 0.2.6 → 0.2.8

package/dist/core/message-handler.js

@@ -10,18 +10,54 @@ export class MessageHandler {
     opencode;
     dedup;
     fileDownloader;
-    docService;
     botName;
-    thinkingTimers = new Map();
-    constructor(config, sessionManager, feishuApi, opencode, docService, botName = '点点') {
+    availableCommands = new Map();
+    constructor(config, sessionManager, feishuApi, opencode, botName = '点点') {
         this.config = config;
         this.sessionManager = sessionManager;
         this.feishuApi = feishuApi;
         this.opencode = opencode;
-        this.docService = docService;
         this.botName = botName;
         this.dedup = new MessageDeduplicator(config.dedupTtl || 600_000);
         this.fileDownloader = new FileDownloader();
+        // Load available commands on startup
+        this.loadAvailableCommands();
+    }
+    async loadAvailableCommands() {
+        try {
+            log.info('Loading available commands from OpenCode');
+            const commands = await this.opencode.getCommands();
+            if (commands && Array.isArray(commands)) {
+                for (const cmd of commands) {
+                    if (cmd.name) {
+                        this.availableCommands.set(cmd.name, {
+                            type: cmd.source === 'mcp' ? 'custom' : 'session',
+                            description: cmd.description
+                        });
+                        log.info({ name: cmd.name, source: cmd.source, description: cmd.description }, 'Loaded command');
+                    }
+                }
+                log.info({ count: this.availableCommands.size }, 'Loaded available commands');
+            }
+            else {
+                log.warn({ commands }, 'No commands loaded from OpenCode');
+            }
+            // Also add known TUI commands
+            const tuiCommands = [
+                'session.list', 'session.new', 'session.share', 'session.interrupt', 'session.compact',
+                'session.page.up', 'session.page.down', 'session.line.up', 'session.line.down',
+                'session.half.page.up', 'session.half.page.down', 'session.first', 'session.last',
+                'prompt.clear', 'prompt.submit', 'agent.cycle'
+            ];
+            for (const cmd of tuiCommands) {
+                if (!this.availableCommands.has(cmd)) {
+                    this.availableCommands.set(cmd, { type: 'tui' });
+                }
+            }
+        }
+        catch (err) {
+            log.error({ err }, 'Failed to load available commands');
+        }
     }
     async handleMessage(message) {
         try {
@@ -85,6 +121,9 @@ export class MessageHandler {
                 await this.feishuApi.sendText(chatId, '⏳ 正在处理上一条消息，请稍候...');
                 return;
             }
+            // Clear previous turn's card reference so a new card is created for this turn.
+            // (EventHandler no longer clears this on session.idle to avoid race conditions.)
+            this.sessionManager.clearCurrentMessage(chatId);
             // Resolve sender name (with cache)
             const senderUnionId = message.sender.sender_id?.union_id || 'unknown';
             const senderName = await this.feishuApi.getUserName(senderUnionId);
@@ -98,18 +137,34 @@ export class MessageHandler {
                     case 'text':
                         text = content.text || '';
                         break;
-                    case 'image':
-                        text = await this.downloadMedia(message.message_id, content.image_key, 'image', 'image.jpg', 'image/jpeg', '图片');
+                    case 'image': {
+                        const result = await this.downloadMedia(message.message_id, content.image_key, 'image', 'image.jpg', 'image/jpeg', '图片');
+                        text = result.text;
+                        if (result.file)
+                            files.push(result.file);
                         break;
-                    case 'file':
-                        text = await this.downloadMedia(message.message_id, content.file_key, 'file', content.file_name || 'unknown', 'application/octet-stream', '文件');
+                    }
+                    case 'file': {
+                        const result = await this.downloadMedia(message.message_id, content.file_key, 'file', content.file_name || 'unknown', 'application/octet-stream', '文件');
+                        text = result.text;
+                        if (result.file)
+                            files.push(result.file);
                         break;
-                    case 'audio':
-                        text = await this.downloadMedia(message.message_id, content.file_key, 'file', 'audio.opus', 'audio/opus', '语音');
+                    }
+                    case 'audio': {
+                        const result = await this.downloadMedia(message.message_id, content.file_key, 'file', 'audio.opus', 'audio/opus', '语音');
+                        text = result.text;
+                        if (result.file)
+                            files.push(result.file);
                         break;
-                    case 'media':
-                        text = await this.downloadMedia(message.message_id, content.file_key, 'file', content.file_name || 'video.mp4', 'video/mp4', '视频');
+                    }
+                    case 'media': {
+                        const result = await this.downloadMedia(message.message_id, content.file_key, 'file', content.file_name || 'video.mp4', 'video/mp4', '视频');
+                        text = result.text;
+                        if (result.file)
+                            files.push(result.file);
                         break;
+                    }
                     case 'sticker':
                         text = `[表情消息]`;
                         break;
@@ -138,30 +193,26 @@ export class MessageHandler {
                 return;
             }
             log.info({ chatType, chatId, text: text.substring(0, 100) }, 'Message content');
-            // Check for document creation intent
-            if (this.docService) {
-                const docIntent = this.detectDocCreationIntent(text);
-                if (docIntent.intent) {
-                    log.info({ title: docIntent.title }, 'Document creation intent detected');
-                    try {
-                        const doc = await this.docService.createDocumentFromMarkdown(docIntent.title, `# ${docIntent.title}\n\n> 由 OpenCode AI 助手创建\n\n请在此处编辑文档内容...\n`);
-                        await this.feishuApi.sendText(chatId, `✅ 已为您创建文档「${doc.title}」\n🔗 ${doc.url}\n\n您可以点击链接查看和编辑文档。`);
-                        // Continue to OpenCode to let AI generate a friendly response
-                        text = `${text}\n\n[系统提示：已为用户创建飞书文档「${doc.title}」，链接：${doc.url}。请告诉用户文档已创建，并简要说明可以如何使用。]`;
-                    }
-                    catch (err) {
-                        log.error({ err, title: docIntent.title }, 'Failed to create document');
-                        await this.feishuApi.sendText(chatId, '❌ 创建文档失败，请确认已开通文档相关权限（docx:document、docx:document:readonly）');
-                    }
-                }
-            }
             // Check for pending interaction reply before proceeding with normal message flow
             const pendingInteraction = this.sessionManager.getPendingInteraction?.(chatId);
             if (pendingInteraction) {
-                const handled = await this.handleInteractionReply(chatId, text.trim(), pendingInteraction);
-                if (handled)
-                    return;
-                // If not handled as interaction reply, fall through to normal processing
+                try {
+                    const handled = await this.handleInteractionReply(chatId, text.trim(), pendingInteraction);
+                    if (handled)
+                        return;
+                    // The user's message does not match an interaction reply pattern.
+                    // Do NOT clear the pending interaction — the user may still click the
+                    // card buttons. Instead, tell them to finish the interaction first.
+                }
+                catch {
+                    // Error handling interaction reply: clear to prevent the user from
+                    // getting permanently stuck.
+                    this.sessionManager.clearPendingInteraction(chatId);
+                }
+                await this.feishuApi.sendText(chatId, pendingInteraction.kind === 'permission'
+                    ? '⏳ 请先处理上方的权限请求（点击卡片按钮），或等待当前任务完成。'
+                    : '⏳ 请先处理上方的选择（点击卡片按钮或回复选项），或等待当前任务完成。');
+                return;
             }
             // Atomically check and set busy status to prevent race conditions
             const currentSession = this.sessionManager.getSession(chatId);
@@ -171,53 +222,126 @@ export class MessageHandler {
             }
             this.sessionManager.updateStatus(chatId, 'busy');
             // Show thinking card immediately before sending prompt
-            if (!this.config.showProcess) {
-                const dots = ['.', '..', '...', '....'];
-                let frame = 0;
-                const thinkingCard = FeishuCard.createThinkingCard(this.botName, dots[frame]);
+            if (this.config.showProcess !== 'none') {
+                const thinkingCard = FeishuCard.createThinkingCard(this.botName);
+                log.info({ chatId }, 'Sending thinking card');
                 const msg = await this.feishuApi.sendCard(chatId, thinkingCard);
+                log.info({ chatId, messageId: msg?.message_id }, 'Thinking card sent result');
                 if (msg?.message_id) {
-                    this.sessionManager.setCurrentMessage?.(chatId, msg.message_id);
-                    // Animate the ellipsis until content arrives
-                    const timer = setInterval(async () => {
-                        const session = this.sessionManager.getSession(chatId);
-                        if (!session?.currentMessageId || !this.thinkingTimers.has(chatId)) {
-                            clearInterval(timer);
-                            return;
-                        }
-                        if (session.currentContent) {
-                            this.stopThinkingAnimation(chatId);
-                            return;
-                        }
-                        frame = (frame + 1) % dots.length;
-                        try {
-                            await this.feishuApi.updateCard(session.currentMessageId, FeishuCard.createThinkingCard(this.botName, dots[frame]));
-                        }
-                        catch { /* best-effort */ }
-                    }, 500);
-                    this.thinkingTimers.set(chatId, timer);
+                    this.sessionManager.setCurrentMessage(chatId, msg.message_id);
                 }
             }
             // Send message to OpenCode
             try {
                 const slashCommand = this.parseSlashCommand(text);
                 if (slashCommand) {
-                    log.info({ sessionId: session.id, command: slashCommand.command, args: slashCommand.args }, 'Sending command to OpenCode');
-                    await this.opencode.sendCommand(session.id, slashCommand.command, slashCommand.args);
-                    log.info('Command sent successfully');
+                    // Map common shortcuts to TUI commands
+                    const commandMappings = {
+                        'new': 'session.new',
+                        'share': 'session.share',
+                        'interrupt': 'session.interrupt',
+                        'compact': 'session.compact',
+                        'pageup': 'session.page.up',
+                        'pagedown': 'session.page.down',
+                        'lineup': 'session.line.up',
+                        'linedown': 'session.line.down',
+                        'halfpageup': 'session.half.page.up',
+                        'halfpagedown': 'session.half.page.down',
+                        'first': 'session.first',
+                        'last': 'session.last',
+                        'clear': 'prompt.clear',
+                        'submit': 'prompt.submit',
+                        'nextagent': 'agent.cycle',
+                    };
+                    // Apply mapping if exists
+                    const mappedCommand = commandMappings[slashCommand.command] || slashCommand.command;
+                    if (mappedCommand !== slashCommand.command) {
+                        log.info({ original: slashCommand.command, mapped: mappedCommand }, 'Mapped command');
+                    }
+                    // Check if command needs special handling (list queries)
+                    const listCommands = ['models', 'agents', 'commands', 'sessions', 'tools', 'worktrees', 'files', 'status', 'config'];
+                    if (listCommands.includes(slashCommand.command)) {
+                        // Handle list commands by fetching data from OpenCode
+                        await this.handleListCommand(chatId, session.id, slashCommand.command, slashCommand.args);
+                    }
+                    else {
+                        // Check command type from cached commands
+                        const commandInfo = this.availableCommands.get(mappedCommand);
+                        if (commandInfo?.type === 'tui') {
+                            // TUI commands are executed via tui.executeCommand
+                            log.info({ sessionId: session.id, command: mappedCommand }, 'Executing TUI command');
+                            await this.opencode.executeTuiCommand(mappedCommand);
+                            log.info('TUI command executed successfully');
+                            // Send confirmation and set session to idle
+                            await this.feishuApi.sendText(chatId, `✅ 已执行命令: /${slashCommand.command}`);
+                            this.sessionManager.updateStatus(chatId, 'idle');
+                            this.sessionManager.clearCurrentMessage(chatId);
+                        }
+                        else {
+                            // All other commands (session commands and custom commands)
+                            // are sent as session commands
+                            log.info({ sessionId: session.id, command: slashCommand.command, args: slashCommand.args, type: commandInfo?.type || 'unknown' }, 'Sending command to OpenCode');
+                            await this.opencode.sendCommand(session.id, slashCommand.command, slashCommand.args);
+                            log.info('Command sent successfully');
+                        }
+                    }
                 }
                 else {
                     log.info({ sessionId: session.id, files: files.length }, 'Sending prompt to OpenCode');
-                    await this.opencode.sendPrompt(session.id, text, files.length > 0 ? files : undefined);
+                    // Inject chat context so the AI knows the current chat_id for Feishu operations
+                    const contextPrefix = `[系统上下文] 当前飞书对话ID: ${chatId}\n\n` +
+                        `你配置了飞书 MCP 工具，可以使用以下工具来操作飞书文档、日历等：\n` +
+                        `- docx.v1.document.create — 创建飞书文档\n` +
+                        `- docx.v1.documentBlockChildren.create — 在文档中插入内容\n` +
+                        `- docx.v1.documentBlock.patch — 更新文档块\n` +
+                        `- drive.v1.file.createFolder — 创建文件夹\n` +
+                        `- drive.v1.media.uploadPrepare/uploadFinish — 上传文件\n` +
+                        `当用户请求创建飞书文档时，请直接调用 MCP 工具创建，不要在回复中询问。\n` +
+                        `重要：飞书文档的访问链接必须使用 https://www.feishu.cn/docx/ 域名，不要使用 https://open.feishu.cn/docx/ 域名。\n\n`;
+                    await this.opencode.sendPrompt(session.id, contextPrefix + text, files.length > 0 ? files : undefined);
                     log.info('Prompt sent successfully');
                 }
             }
             catch (err) {
                 log.error({ err }, 'Failed to send prompt');
-                await this.feishuApi.sendCard(chatId, FeishuCard.createErrorCard(`发送消息失败: ${err instanceof Error ? err.message : String(err)}`));
+                // Extract meaningful error message from various error formats
+                let errorMessage;
+                if (err instanceof Error) {
+                    errorMessage = err.message;
+                }
+                else if (typeof err === 'object' && err !== null) {
+                    const errObj = err;
+                    if (errObj.data?.message) {
+                        errorMessage = errObj.data.message;
+                    }
+                    else if (errObj.message) {
+                        errorMessage = errObj.message;
+                    }
+                    else {
+                        try {
+                            errorMessage = JSON.stringify(err);
+                        }
+                        catch {
+                            errorMessage = String(err);
+                        }
+                    }
+                }
+                else {
+                    errorMessage = String(err);
+                }
+                log.info({ errorMessage, errType: typeof err }, 'Creating error card with message');
+                const errorCard = FeishuCard.createErrorCard(errorMessage);
+                log.info({ cardContent: errorCard.elements[0]?.text?.content }, 'Error card content');
+                // Set status to idle BEFORE sending the error card to prevent
+                // EventHandler from sending a duplicate error card via session.error event.
                 this.sessionManager.updateStatus(chatId, 'idle');
                 this.sessionManager.clearCurrentMessage(chatId);
-                this.stopThinkingAnimation(chatId);
+                // Mark error as handled to prevent duplicate error cards
+                const session = this.sessionManager.getSession(chatId);
+                if (session) {
+                    session.errorHandled = true;
+                }
+                await this.feishuApi.sendCard(chatId, errorCard);
             }
         }
         catch (err) {
@@ -230,13 +354,6 @@ export class MessageHandler {
             }
         }
     }
-    stopThinkingAnimation(chatId) {
-        const timer = this.thinkingTimers.get(chatId);
-        if (timer) {
-            clearInterval(timer);
-            this.thinkingTimers.delete(chatId);
-        }
-    }
     /**
      * Try to parse the user message as a reply to a pending interaction.
      * Returns true if handled.
@@ -260,10 +377,7 @@ export class MessageHandler {
                 log.info({ chatId, permissionId: perm.id, reply }, 'Replying to permission');
                 await this.opencode.replyPermission(perm.id, reply);
                 this.sessionManager.clearPendingInteraction(chatId);
-                // Show confirmation in a new card (or update existing if we track the id)
-                const confirmText = reply === 'reject' ? '已拒绝该权限请求。' :
-                    reply === 'always' ? '已永久授权该权限。' : '已授权一次该权限。';
-                await this.feishuApi.sendCard(chatId, FeishuCard.createErrorCard(confirmText));
+                await this.feishuApi.sendCard(chatId, FeishuCard.createInteractionRepliedCard('permission', reply));
                 return true;
             }
             if (interaction.kind === 'question') {
@@ -317,6 +431,396 @@ export class MessageHandler {
             return false;
         }
     }
+    /**
+     * Handle a card button click (card.action.trigger event).
+     * Parses the button value and routes to the appropriate OpenCode API.
+     * Returns a card callback response for Feishu (toast / updated card).
+     */
+    async handleCardAction(action) {
+        const { chatId, messageId } = action;
+        const value = action.action.value;
+        if (!value || typeof value !== 'object') {
+            log.warn({ chatId, messageId, value }, 'Card action missing value');
+            return { toast: { type: 'error', content: '无效操作' } };
+        }
+        const actionType = value.action || value._oc;
+        log.info({ chatId, messageId, actionType, value }, 'Card action received');
+        // Handle navigation commands (TUI operations)
+        if (actionType === 'nav') {
+            return this.handleNavigationCardAction(chatId, messageId, value);
+        }
+        if (actionType !== 'perm' && actionType !== 'q') {
+            log.warn({ chatId, actionType, value }, 'Unknown card action type');
+            return { toast: { type: 'error', content: '不支持的操作' } };
+        }
+        // Verify there is a pending interaction for this chat
+        const pending = this.sessionManager.getPendingInteraction(chatId);
+        const session = this.sessionManager.getSession(chatId);
+        log.info({ chatId, messageId, hasPending: !!pending, pendingKind: pending?.kind, currentMessageId: session?.currentMessageId }, 'Checking pending interaction');
+        if (!pending) {
+            log.info({ chatId, messageId, currentMessageId: session?.currentMessageId }, 'No pending interaction for this chat, ignoring card action');
+            const valueId = (value.id || '').toString();
+            // If the button looks like an AI-generated permission card (not from OpenCode's permission.asked event),
+            // simulate a text reply so the AI can continue processing.
+            const isAiGeneratedPerm = actionType === 'perm' && valueId.startsWith('perm-');
+            if (isAiGeneratedPerm) {
+                const replyMap = {
+                    once: '确认',
+                    always: '始终允许',
+                    reject: '拒绝',
+                };
+                const replyText = replyMap[value.reply] || '确认';
+                const confirmMap = {
+                    once: '已授权一次',
+                    always: '已永久授权',
+                    reject: '已拒绝',
+                };
+                const confirmText = confirmMap[value.reply] || '已授权';
+                try {
+                    // Wait for card update to complete before sending prompt,
+                    // so the user sees the confirmation state immediately.
+                    await this.feishuApi.updateCard(messageId, FeishuCard.createInteractionRepliedCard('permission', value.reply));
+                    log.info({ chatId, messageId }, 'Updated AI-generated perm card to confirmed state');
+                }
+                catch (err) {
+                    log.warn({ err, chatId, messageId }, 'Failed to update AI-generated perm card');
+                }
+                // Re-bind currentMessageId to the clicked card so subsequent
+                // flushCard calls update the same card instead of creating a new one.
+                if (session) {
+                    this.sessionManager.setCurrentMessage(chatId, messageId);
+                    log.info({ chatId, messageId }, 'Re-bound currentMessageId to clicked card');
+                }
+                // Simulate user text reply to OpenCode so the AI continues
+                if (session) {
+                    try {
+                        await this.opencode.sendPrompt(session.id, replyText);
+                        log.info({ chatId, replyText }, 'Simulated permission reply sent to OpenCode');
+                    }
+                    catch (err) {
+                        log.error({ err, chatId, replyText }, 'Failed to send simulated permission reply');
+                    }
+                }
+                return { toast: { type: 'success', content: confirmText } };
+            }
+            // Real OpenCode permission IDs are `per_*`. If we see one with no pending,
+            // it's almost always a duplicate event (Feishu re-delivery or quick re-click)
+            // for a request we already handled. The card is already in confirmation state
+            // from the first click — return success silently rather than misleading
+            // "已过期" warning.
+            const isRealOpencodePerm = actionType === 'perm' && valueId.startsWith('per_');
+            if (isRealOpencodePerm) {
+                log.info({ chatId, messageId, valueId }, 'Permission already processed (likely duplicate event), returning success');
+                return { toast: { type: 'success', content: '已处理' } };
+            }
+            // Update the card to remove stale buttons so the user doesn't keep clicking
+            this.feishuApi.updateCard(messageId, FeishuCard.createExpiredCard())
+                .then(() => log.info({ chatId, messageId }, 'Updated stale card to expired state'))
+                .catch((err) => log.warn({ err, chatId, messageId }, 'Failed to update stale card to expired'));
+            return { toast: { type: 'warning', content: '该操作已过期' } };
+        }
+        // Route to the appropriate handler
+        if (actionType === 'perm') {
+            return this.handlePermissionCardAction(chatId, messageId, value, pending);
+        }
+        return this.handleQuestionCardAction(chatId, messageId, value, pending);
+    }
+    async handlePermissionCardAction(chatId, messageId, value, pending) {
+        if (pending.kind !== 'permission') {
+            return { toast: { type: 'error', content: '当前不是权限请求' } };
+        }
+        const reply = value.reply;
+        if (!reply || !['once', 'always', 'reject'].includes(reply)) {
+            return { toast: { type: 'error', content: '无效的权限响应' } };
+        }
+        const perm = pending.data;
+        log.info({ chatId, permissionId: perm.id, reply }, 'Card action: replying to permission');
+        const confirmText = reply === 'reject'
+            ? '已拒绝该权限请求。'
+            : reply === 'always'
+                ? '已永久授权该权限。'
+                : '已授权一次该权限。';
+        const confirmCard = FeishuCard.createInteractionRepliedCard('permission', reply);
+        // Update in-memory state synchronously so concurrent flushCard / re-clicks
+        // see the new state immediately. This must happen BEFORE we return so the
+        // caller doesn't process duplicate events.
+        this.sessionManager.clearPendingInteraction(chatId);
+        const session = this.sessionManager.getSession(chatId);
+        if (session) {
+            // Re-bind currentMessageId to the clicked card so subsequent flushCard
+            // calls update the same card the user sees (AI may have sent cards via
+            // MCP, causing currentMessageId to diverge from the clicked messageId).
+            if (messageId !== session.currentMessageId) {
+                this.sessionManager.setCurrentMessage(chatId, messageId);
+            }
+            // Mark that the interaction was handled via card click so flushCard
+            // won't overwrite the confirmation state with AI streaming output.
+            session.interactionReplied = true;
+        }
+        this.sessionManager.updateStatus(chatId, 'idle');
+        // Fire the network calls in the background and return the toast immediately.
+        // Feishu's UI has a strict callback timeout — awaiting both replyPermission
+        // and updateCard (~500ms total) was overrunning it and causing the client
+        // to display its own error popup despite our handler succeeding.
+        void (async () => {
+            try {
+                await this.opencode.replyPermission(perm.id, reply);
+                log.info({ chatId, permissionId: perm.id }, 'replyPermission relayed to OpenCode');
+            }
+            catch (err) {
+                log.error({ err, chatId, permissionId: perm.id }, 'replyPermission failed (background)');
+            }
+            try {
+                await this.feishuApi.updateCard(messageId, confirmCard);
+                log.info({ chatId, messageId, permissionId: perm.id }, 'Confirmation card updated');
+            }
+            catch (err) {
+                log.error({ err, chatId, messageId }, 'updateCard for confirmation failed (background)');
+            }
+        })();
+        // NOTE: do NOT include the `card` field in the response. Feishu requires
+        // it wrapped as `{ type: 'raw'|'template', data: {...} }`; passing the raw
+        // CardContent directly is treated as a malformed response and the client
+        // shows its own error popup. We update the card via API in the background
+        // call above, so the response only needs a toast.
+        return { toast: { type: 'success', content: confirmText } };
+    }
+    async handleQuestionCardAction(chatId, messageId, value, pending) {
+        if (pending.kind !== 'question') {
+            return { toast: { type: 'error', content: '当前不是问题选择' } };
+        }
+        const answers = value.ans;
+        if (!answers || !Array.isArray(answers)) {
+            return { toast: { type: 'error', content: '无效的选择' } };
+        }
+        const q = pending.data;
+        log.info({ chatId, requestId: q.id, answers }, 'Card action: replying to question');
+        const label = answers.map(a => a.join(', ')).join('; ');
+        const confirmCard = FeishuCard.createInteractionRepliedCard('question', label);
+        // Update in-memory state synchronously and return immediately, doing the
+        // network calls in the background — see handlePermissionCardAction for the
+        // rationale on returning fast.
+        this.sessionManager.clearPendingInteraction(chatId);
+        const session = this.sessionManager.getSession(chatId);
+        if (session) {
+            if (messageId !== session.currentMessageId) {
+                this.sessionManager.setCurrentMessage(chatId, messageId);
+            }
+            session.interactionReplied = true;
+        }
+        this.sessionManager.updateStatus(chatId, 'idle');
+        void (async () => {
+            try {
+                await this.opencode.replyQuestion(q.id, answers);
+                log.info({ chatId, requestId: q.id }, 'replyQuestion relayed to OpenCode');
+            }
+            catch (err) {
+                log.error({ err, chatId, requestId: q.id }, 'replyQuestion failed (background)');
+            }
+            try {
+                await this.feishuApi.updateCard(messageId, confirmCard);
+                log.info({ chatId, messageId, requestId: q.id }, 'Confirmation card updated');
+            }
+            catch (err) {
+                log.error({ err, chatId, messageId }, 'updateCard for confirmation failed (background)');
+            }
+        })();
+        // See note in handlePermissionCardAction about omitting the `card` field.
+        return { toast: { type: 'success', content: `已提交选择：${label}` } };
+    }
+    async handleNavigationCardAction(chatId, messageId, value) {
+        const cmd = value.cmd;
+        const sessionId = value.sessionId;
+        if (!cmd) {
+            log.warn({ chatId, messageId, value }, 'Navigation action missing cmd');
+            return { toast: { type: 'error', content: '无效的导航操作' } };
+        }
+        log.info({ chatId, messageId, cmd, sessionId }, 'Card action: navigation command');
+        try {
+            await this.opencode.sendCommand(sessionId || chatId, cmd);
+            log.info({ chatId, messageId, cmd }, 'Navigation command sent to OpenCode');
+            return { toast: { type: 'success', content: '已执行' } };
+        }
+        catch (err) {
+            log.error({ err, chatId, messageId, cmd }, 'Failed to send navigation command');
+            return { toast: { type: 'error', content: '执行失败' } };
+        }
+    }
+    /**
+     * Handle list commands (models, agents, commands, sessions) by fetching data from OpenCode.
+     */
+    async handleListCommand(chatId, sessionId, command, args) {
+        log.info({ sessionId, command, args }, `Fetching ${command} list from OpenCode`);
+        try {
+            let message = '';
+            switch (command) {
+                case 'models': {
+                    const providers = await this.opencode.getProviders();
+                    message = '**🤖 可用模型列表**\n\n';
+                    if (providers && Array.isArray(providers)) {
+                        for (const provider of providers) {
+                            message += `**${provider.name || provider.id || 'Unknown'}**\n`;
+                            if (provider.models && Array.isArray(provider.models)) {
+                                for (const model of provider.models) {
+                                    message += `- ${model.id || model.name || 'Unknown'}`;
+                                    if (model.default)
+                                        message += ' (默认)';
+                                    message += '\n';
+                                }
+                            }
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无模型信息\n';
+                    }
+                    break;
+                }
+                case 'agents': {
+                    const agents = await this.opencode.getAgents();
+                    message = '**🎯 可用代理列表**\n\n';
+                    if (agents && Array.isArray(agents)) {
+                        for (const agent of agents) {
+                            message += `- ${agent.name || agent.id || 'Unknown'}`;
+                            if (agent.description)
+                                message += `: ${agent.description}`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无代理信息\n';
+                    }
+                    break;
+                }
+                case 'commands': {
+                    const commands = await this.opencode.getCommands();
+                    message = '**⌨️ 可用命令列表**\n\n';
+                    if (commands && Array.isArray(commands)) {
+                        for (const cmd of commands) {
+                            message += `- /${cmd.name || cmd.id || 'Unknown'}`;
+                            if (cmd.description)
+                                message += `: ${cmd.description}`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无命令信息\n';
+                    }
+                    break;
+                }
+                case 'sessions': {
+                    const sessions = await this.opencode.getSessions();
+                    message = '**💬 会话列表**\n\n';
+                    if (sessions && Array.isArray(sessions)) {
+                        for (const sess of sessions) {
+                            message += `- ${sess.title || sess.id || 'Unknown'}`;
+                            if (sess.createdAt)
+                                message += ` (${new Date(sess.createdAt).toLocaleString()})`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无会话信息\n';
+                    }
+                    break;
+                }
+                case 'tools': {
+                    const tools = await this.opencode.getTools();
+                    message = '**🔧 可用工具列表**\n\n';
+                    if (tools && Array.isArray(tools)) {
+                        for (const tool of tools) {
+                            message += `- ${tool.name || tool.id || 'Unknown'}`;
+                            if (tool.description)
+                                message += `: ${tool.description}`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无工具信息\n';
+                    }
+                    break;
+                }
+                case 'worktrees': {
+                    const worktrees = await this.opencode.getWorktrees();
+                    message = '**🌳 工作树列表**\n\n';
+                    if (worktrees && Array.isArray(worktrees)) {
+                        for (const wt of worktrees) {
+                            message += `- ${wt.name || wt.id || 'Unknown'}`;
+                            if (wt.path)
+                                message += ` (${wt.path})`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无工作树信息\n';
+                    }
+                    break;
+                }
+                case 'files': {
+                    const files = await this.opencode.getFiles(args);
+                    message = `**📁 文件列表${args ? ` (${args})` : ''}**\n\n`;
+                    if (files && Array.isArray(files)) {
+                        for (const file of files) {
+                            message += `- ${file.name || file.id || 'Unknown'}`;
+                            if (file.type)
+                                message += ` [${file.type}]`;
+                            message += '\n';
+                        }
+                    }
+                    else {
+                        message += '暂无文件信息\n';
+                    }
+                    break;
+                }
+                case 'status': {
+                    const status = await this.opencode.getStatus();
+                    message = '**📊 项目状态**\n\n';
+                    if (status) {
+                        message += `- 分支: ${status.branch || 'Unknown'}\n`;
+                        message += `- 提交: ${status.commit || 'Unknown'}\n`;
+                        if (status.files && Array.isArray(status.files)) {
+                            message += `- 变更文件: ${status.files.length}\n`;
+                            for (const file of status.files) {
+                                message += `  ${file.status || '?'} ${file.name || 'Unknown'}\n`;
+                            }
+                        }
+                    }
+                    else {
+                        message += '暂无状态信息\n';
+                    }
+                    break;
+                }
+                case 'config': {
+                    const config = await this.opencode.getConfig();
+                    message = '**⚙️ 配置信息**\n\n';
+                    if (config) {
+                        message += `- 项目: ${config.name || 'Unknown'}\n`;
+                        message += `- 目录: ${config.directory || 'Unknown'}\n`;
+                        if (config.providers && Array.isArray(config.providers)) {
+                            message += `- Providers: ${config.providers.length}\n`;
+                        }
+                        if (config.agents && Array.isArray(config.agents)) {
+                            message += `- Agents: ${config.agents.length}\n`;
+                        }
+                    }
+                    else {
+                        message += '暂无配置信息\n';
+                    }
+                    break;
+                }
+            }
+            await this.feishuApi.sendText(chatId, message);
+            this.sessionManager.updateStatus(chatId, 'idle');
+            this.sessionManager.clearCurrentMessage(chatId);
+            log.info({ command }, `${command} list sent successfully`);
+        }
+        catch (err) {
+            log.error({ err, command }, `Failed to fetch ${command} list`);
+            await this.feishuApi.sendText(chatId, `❌ 获取${command}列表失败`);
+            this.sessionManager.updateStatus(chatId, 'idle');
+            this.sessionManager.clearCurrentMessage(chatId);
+        }
+    }
     /**
      * Parse a slash command from text.
      * Returns { command, args } if text starts with /, otherwise null.
@@ -335,48 +839,31 @@ export class MessageHandler {
         const args = withoutPrefix.slice(firstSpace + 1).trim();
         return { command, args: args || undefined };
     }
-    /**
-     * Detect document creation intent from user message.
-     * Supports patterns like: "创建文档 XXX", "新建一个文档", "写个文档"
-     */
-    detectDocCreationIntent(text) {
-        const patterns = [
-            /(?:创建|新建|写个?)(?:一个|个)?(?:飞书)?(?:云)?文档[，：:]?\s*["「『【]([^"」』】]+)["」』】]/i,
-            /(?:创建|新建|写个?)(?:一个|个)?(?:飞书)?(?:云)?文档[，：:]?\s*(.+?)(?:\n|$)/i,
-            /(?:创建|新建|写个?)(?:一个|个)?(.+?)(?:的|的)?(?:飞书)?(?:云)?文档/i,
-            /(?:帮我|请)?(?:创建|新建|写)(?:一个|个)?(.+)/i,
-        ];
-        for (const pattern of patterns) {
-            const match = text.match(pattern);
-            if (match && match[1]) {
-                const title = match[1].trim().replace(/^(?:一个|个|这份|这个|的)\s*/, '');
-                if (title && title.length > 0 && title.length < 100) {
-                    return { intent: true, title };
-                }
-            }
-        }
-        // Simple keyword detection as fallback
-        if (/^(?:创建|新建|写个?)文档/.test(text.trim())) {
-            return { intent: true, title: '未命名文档' };
-        }
-        return { intent: false, title: '' };
-    }
     /**
      * Unified media download handler for images, files, audio, and video.
+     * Returns a text placeholder for the message and optionally the file info
+     * for forwarding to OpenCode.
      */
     async downloadMedia(messageId, fileKey, resourceType, fileName, mimeType, typeLabel) {
         if (!fileKey) {
-            return `[${typeLabel}消息]`;
+            return { text: `[${typeLabel}消息]` };
         }
         try {
             log.info({ messageId, fileKey, fileName }, `Downloading ${typeLabel}...`);
             const buffer = await this.feishuApi.downloadMedia(messageId, fileKey, resourceType);
             const downloaded = await this.fileDownloader.saveBuffer(buffer, fileName, mimeType);
-            return `[${typeLabel}已上传: ${downloaded.filePath}]`;
+            return {
+                text: `[${typeLabel}已上传: ${downloaded.filePath}]`,
+                file: {
+                    filePath: downloaded.filePath,
+                    fileName: downloaded.fileName,
+                    mimeType,
+                },
+            };
         }
         catch (err) {
             log.error({ err, messageId, fileKey }, `Failed to download ${typeLabel}`);
-            return `[${typeLabel}消息（下载失败）]`;
+            return { text: `[${typeLabel}消息（下载失败）]` };
         }
     }
 }