@neomei/opencode-feishu 0.4.2 → 0.6.1

package/dist/core/message-handler.js

@@ -13,6 +13,8 @@ export class MessageHandler {
     fileDownloader;
     botName;
     availableCommands = new Map();
+    chatModelOverrides = new Map();
+    lastKnownModel;
     constructor(config, sessionManager, feishuApi, opencode, botName = 'opencode') {
         this.config = config;
         this.sessionManager = sessionManager;
@@ -60,6 +62,30 @@ export class MessageHandler {
             log.error({ err }, 'Failed to load available commands');
         }
     }
+    async syncModelOverride(chatId) {
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const configPath = path.join(this.opencode.getDirectory(), '.opencode', 'config.json');
+            if (!fs.existsSync(configPath))
+                return;
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            const currentModel = config?.model;
+            if (!currentModel)
+                return;
+            if (this.lastKnownModel !== currentModel) {
+                const [providerID, modelID] = currentModel.split('/');
+                if (providerID && modelID) {
+                    this.chatModelOverrides.set(chatId, { providerID, modelID });
+                    log.info({ chatId, model: currentModel }, 'Model changed, override set');
+                }
+                this.lastKnownModel = currentModel;
+            }
+        }
+        catch (err) {
+            log.warn({ err }, 'Failed to sync model override');
+        }
+    }
     async handleMessage(message) {
         try {
             log.info({
@@ -199,7 +225,7 @@ export class MessageHandler {
             // Handle admin restart commands - only exact slash commands
             const trimmedText = text.trim().toLowerCase();
             if (trimmedText === '/restart' || trimmedText === '/重启') {
-                await this.handleRestartCommand(chatId, text.trim());
+                await this.handleRestartCommand(chatId, 'all');
                 return;
             }
             // Check for pending interaction reply before proceeding with normal message flow
@@ -230,16 +256,8 @@ export class MessageHandler {
                 return;
             }
             this.sessionManager.updateStatus(chatId, 'busy');
-            // Show thinking card immediately before sending prompt
-            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);
-                }
-            }
+            // Skip separate thinking card — the streaming card (created on first flushCard)
+            // already shows "💭 点点思考中..." as its header with no blank body.
             // Send message to OpenCode
             try {
                 const slashCommand = this.parseSlashCommand(text);
@@ -313,7 +331,13 @@ export class MessageHandler {
                         `- 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, this.config.thinkingLanguage);
+                    await this.syncModelOverride(chatId);
+                    const modelOverride = this.chatModelOverrides.get(chatId);
+                    if (modelOverride) {
+                        session.currentModel = `${modelOverride.providerID}/${modelOverride.modelID}`;
+                        log.info({ chatId, model: session.currentModel }, 'Sent prompt with model override');
+                    }
+                    await this.opencode.sendPrompt(session.id, contextPrefix + text, files.length > 0 ? files : undefined, this.config.thinkingLanguage, modelOverride);
                     log.info('Prompt sent successfully');
                 }
             }
@@ -464,6 +488,30 @@ export class MessageHandler {
         if (actionType === 'nav') {
             return this.handleNavigationCardAction(chatId, messageId, value);
         }
+        // Handle model selection
+        if (actionType === 'model') {
+            return this.handleModelCardAction(chatId, messageId, value, action.action.option);
+        }
+        // Handle agent selection
+        if (actionType === 'agent') {
+            return this.handleAgentCardAction(chatId, messageId, value, action.action.option);
+        }
+        // Handle session operations (switch/share/delete)
+        if (actionType === 'sess') {
+            return this.handleSessionCardAction(chatId, messageId, value);
+        }
+        // Handle status refresh
+        if (actionType === 'status') {
+            return this.handleStatusCardAction(chatId, messageId, value);
+        }
+        // Handle task control (interrupt/abort)
+        if (actionType === 'ctrl') {
+            return this.handleCtrlCardAction(chatId, messageId, value);
+        }
+        // Handle command execution
+        if (actionType === 'cmd') {
+            return this.handleCommandCardAction(chatId, messageId, value);
+        }
         if (actionType !== 'perm' && actionType !== 'q') {
             log.warn({ chatId, actionType, value }, 'Unknown card action type');
             return { toast: { type: 'error', content: '不支持的操作' } };
@@ -669,9 +717,259 @@ export class MessageHandler {
             return { toast: { type: 'error', content: '执行失败' } };
         }
     }
-    /**
-     * Handle list commands (models, agents, commands, sessions) by fetching data from OpenCode.
-     */
+    async handleModelCardAction(chatId, messageId, value, option) {
+        let modelKey;
+        if (option) {
+            modelKey = option;
+        }
+        else {
+            const providerID = value.providerID;
+            const modelID = value.modelID;
+            if (!providerID || !modelID) {
+                log.warn({ chatId, messageId, value }, 'Model action missing providerID or modelID');
+                return { toast: { type: 'error', content: '无效的模型选择' } };
+            }
+            modelKey = `${providerID}/${modelID}`;
+        }
+        const [providerID, modelID] = modelKey.split('/');
+        if (!providerID || !modelID) {
+            log.warn({ chatId, messageId, modelKey }, 'Invalid model key format');
+            return { toast: { type: 'error', content: '无效的模型格式' } };
+        }
+        log.info({ chatId, messageId, modelKey }, 'Switching model');
+        const session = this.sessionManager.getSession(chatId);
+        if (session) {
+            session.currentModel = modelKey;
+            session.modelSelection = undefined;
+            session.interactionReplied = true;
+            if (messageId !== session.currentMessageId) {
+                this.sessionManager.setCurrentMessage(chatId, messageId);
+            }
+        }
+        try {
+            await this.opencode.updateConfig({ model: modelKey });
+            this.chatModelOverrides.set(chatId, { providerID, modelID });
+            log.info({ chatId, modelKey }, 'Model switched, override set for next prompt');
+            const doneCard = FeishuCard.createStreamingCard({
+                content: '',
+                botName: this.botName,
+                done: true,
+                currentModel: modelKey,
+                showProcess: this.config.showProcess || 'none',
+            });
+            return { toast: { type: 'success', content: `已切换到 ${modelKey}` }, card: doneCard };
+        }
+        catch (err) {
+            log.error({ err, chatId, modelKey }, 'Failed to switch model');
+            return { toast: { type: 'error', content: '切换模型失败' } };
+        }
+    }
+    async handleAgentCardAction(chatId, messageId, value, option) {
+        const agentName = option || value.name;
+        if (!agentName) {
+            log.warn({ chatId, messageId, value }, 'Agent action missing name');
+            return { toast: { type: 'error', content: '无效的代理选择' } };
+        }
+        log.info({ chatId, messageId, agentName }, 'Switching agent');
+        const session = this.sessionManager.getSession(chatId);
+        if (session) {
+            session.currentAgent = agentName;
+            session.agentSelection = undefined;
+            session.interactionReplied = true;
+            if (messageId !== session.currentMessageId) {
+                this.sessionManager.setCurrentMessage(chatId, messageId);
+            }
+        }
+        try {
+            await this.opencode.updateConfig({ default_agent: agentName });
+            log.info({ chatId, agentName }, 'Agent switched');
+            const doneCard = FeishuCard.createStreamingCard({
+                content: '',
+                botName: this.botName,
+                done: true,
+                currentAgent: agentName,
+                showProcess: this.config.showProcess || 'none',
+            });
+            return { toast: { type: 'success', content: `已切换到代理 ${agentName}` }, card: doneCard };
+        }
+        catch (err) {
+            log.error({ err, chatId, agentName }, 'Failed to switch agent');
+            return { toast: { type: 'error', content: '切换代理失败' } };
+        }
+    }
+    deduplicateAndSortSessions(sessions) {
+        let sessList = Array.isArray(sessions)
+            ? sessions.map((s) => ({ id: s.id, title: s.title, created: s.time?.created || 0, updated: s.time?.updated || 0 }))
+            : [];
+        const titleMap = new Map();
+        for (const sess of sessList) {
+            const key = sess.title || sess.id;
+            const existing = titleMap.get(key);
+            if (!existing || sess.updated > existing.updated) {
+                titleMap.set(key, sess);
+            }
+        }
+        sessList = Array.from(titleMap.values());
+        sessList.sort((a, b) => b.updated - a.updated);
+        return sessList.slice(0, 20);
+    }
+    async handleSessionCardAction(chatId, messageId, value) {
+        const op = value.op;
+        const sessionId = value.id;
+        const title = value.title;
+        if (!op || !sessionId) {
+            return { toast: { type: 'error', content: '无效操作' } };
+        }
+        log.info({ chatId, messageId, op, sessionId }, 'Session card action');
+        try {
+            if (op === 'switch') {
+                await this.opencode.selectSession(sessionId);
+                const displayTitle = title || sessionId.substring(0, 16);
+                const doneCard = FeishuCard.createSessionSwitchedCard(displayTitle);
+                return { toast: { type: 'success', content: `已切换到 ${displayTitle}` }, card: doneCard };
+            }
+            if (op === 'delete') {
+                await this.opencode.deleteSession(sessionId);
+                const sessions = await this.opencode.getSessions();
+                const sessList = this.deduplicateAndSortSessions(sessions);
+                const currentSession = this.sessionManager.getSession(chatId);
+                const card = FeishuCard.createSessionsCard({
+                    sessions: sessList,
+                    currentSessionId: currentSession?.id || '',
+                });
+                return { toast: { type: 'success', content: `已删除 ${title || sessionId.substring(0, 8)}` }, card };
+            }
+            return { toast: { type: 'error', content: `未知操作: ${op}` } };
+        }
+        catch (err) {
+            log.error({ err, chatId, op, sessionId }, 'Session card action failed');
+            return { toast: { type: 'error', content: `操作失败: ${err instanceof Error ? err.message : String(err)}` } };
+        }
+    }
+    async handleStatusCardAction(chatId, messageId, value) {
+        const op = value.op;
+        log.info({ chatId, messageId, op }, 'Status card action');
+        try {
+            let branch;
+            let commit;
+            let files = [];
+            try {
+                const vcsInfo = await this.opencode.getVcsInfo();
+                branch = vcsInfo?.branch;
+                commit = vcsInfo?.commit || vcsInfo?.hash;
+            }
+            catch { /* vcs not available */ }
+            try {
+                const fileStatus = await this.opencode.getStatus();
+                if (Array.isArray(fileStatus)) {
+                    files = fileStatus;
+                }
+                else if (fileStatus?.files) {
+                    files = fileStatus.files;
+                }
+            }
+            catch { /* file status not available */ }
+            const card = FeishuCard.createStatusCard({ branch, commit, files });
+            await this.feishuApi.updateCard(messageId, card);
+            return { toast: { type: 'success', content: '状态已刷新' } };
+        }
+        catch (err) {
+            log.error({ err, chatId }, 'Status refresh failed');
+            return { toast: { type: 'error', content: '刷新失败' } };
+        }
+    }
+    async handleCtrlCardAction(chatId, messageId, value) {
+        const op = value.op;
+        if (!op) {
+            return { toast: { type: 'error', content: '无效操作' } };
+        }
+        const session = this.sessionManager.getSession(chatId);
+        if (!session) {
+            return { toast: { type: 'error', content: '无活跃会话' } };
+        }
+        log.info({ chatId, messageId, op, sessionId: session.id }, 'Task control action');
+        try {
+            if (op === 'interrupt') {
+                await this.opencode.abortSession(session.id);
+                return { toast: { type: 'info', content: '已暂停当前任务' } };
+            }
+            if (op === 'abort') {
+                await this.opencode.abortSession(session.id);
+                return { toast: { type: 'warning', content: '已终止任务' } };
+            }
+            return { toast: { type: 'error', content: `未知操作: ${op}` } };
+        }
+        catch (err) {
+            log.error({ err, chatId, op }, 'Task control failed');
+            return { toast: { type: 'error', content: `操作失败: ${err instanceof Error ? err.message : String(err)}` } };
+        }
+    }
+    async handleCommandCardAction(chatId, messageId, value) {
+        const cmdName = value.name;
+        if (!cmdName) {
+            return { toast: { type: 'error', content: '无效命令' } };
+        }
+        log.info({ chatId, messageId, cmdName }, 'Command card action');
+        // Handle /restart specially
+        if (cmdName === 'restart') {
+            await this.handleRestartCommand(chatId, 'all');
+            return { toast: { type: 'success', content: '正在重启全部服务...' } };
+        }
+        // Auto-create session if needed
+        let session = this.sessionManager.getSession(chatId);
+        if (!session) {
+            try {
+                session = await this.sessionManager.getOrCreateSession(chatId, 'p2p');
+            }
+            catch (err) {
+                return { toast: { type: 'error', content: `创建会话失败: ${err instanceof Error ? err.message : String(err)}` } };
+            }
+        }
+        // List commands
+        const listCommands = ['models', 'agents', 'commands', 'sessions', 'status'];
+        if (listCommands.includes(cmdName)) {
+            try {
+                await this.handleListCommand(chatId, session.id, cmdName, '');
+                return { toast: { type: 'success', content: `已执行 /${cmdName}` } };
+            }
+            catch (err) {
+                return { toast: { type: 'error', content: `执行失败: ${err instanceof Error ? err.message : String(err)}` } };
+            }
+        }
+        // Handle /new - create a new session
+        if (cmdName === 'new') {
+            try {
+                const newSession = await this.opencode.createSession('Feishu p2p ' + chatId);
+                return { toast: { type: 'success', content: `已创建新会话: ${(newSession.id || '').substring(0, 12)}...` } };
+            }
+            catch (err) {
+                return { toast: { type: 'error', content: `创建会话失败: ${err instanceof Error ? err.message : String(err)}` } };
+            }
+        }
+        const shortcuts = {
+            'share': 'session.share',
+            'interrupt': 'session.interrupt',
+            'compact': 'session.compact',
+        };
+        const fullCmdName = shortcuts[cmdName] || cmdName;
+        try {
+            const commandInfo = this.availableCommands.get(fullCmdName);
+            if (commandInfo?.type === 'tui') {
+                await this.opencode.executeTuiCommand(fullCmdName);
+            }
+            else if (commandInfo?.type === 'custom') {
+                await this.opencode.sendPrompt(session.id, `/${cmdName}`);
+            }
+            else {
+                await this.opencode.sendCommand(session.id, fullCmdName, '');
+            }
+            return { toast: { type: 'success', content: `已执行 /${cmdName}` } };
+        }
+        catch (err) {
+            log.error({ err, chatId, cmdName }, 'Command execution failed');
+            return { toast: { type: 'error', content: `执行失败: ${err instanceof Error ? err.message : String(err)}` } };
+        }
+    }
     /**
      * Handle list commands (models, agents, commands, sessions) by fetching data from OpenCode.
      */
@@ -681,74 +979,130 @@ export class MessageHandler {
             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';
-                        }
+                    const config = await this.opencode.getConfig();
+                    const currentModel = config?.model || undefined;
+                    const providerData = await this.opencode.listProviders();
+                    const allProviders = providerData?.all || providerData?.providers || [];
+                    const connected = new Set(providerData?.connected || []);
+                    const cardProviders = allProviders
+                        .filter((p) => connected.has(p.id))
+                        .map((p) => ({
+                        id: p.id,
+                        name: p.name || p.id,
+                        models: p.models
+                            ? Object.entries(p.models).map(([id, m]) => ({
+                                id,
+                                name: m.name || id,
+                            }))
+                            : [],
+                    }))
+                        .filter((p) => p.models.length > 0);
+                    if (cardProviders.length === 0) {
+                        message = '暂无可用模型';
+                        await this.feishuApi.sendText(chatId, message);
                     }
                     else {
-                        message += '暂无模型信息\n';
+                        const session = this.sessionManager.getSession(chatId);
+                        if (session) {
+                            session.modelSelection = { providers: cardProviders, currentModel };
+                        }
+                        const card = FeishuCard.createStreamingCard({
+                            content: '',
+                            botName: this.botName,
+                            done: false,
+                            showProcess: this.config.showProcess || 'none',
+                            modelSelection: { providers: cardProviders, currentModel },
+                        });
+                        if (session?.currentMessageId) {
+                            await this.feishuApi.updateCard(session.currentMessageId, card);
+                        }
+                        else {
+                            const msg = await this.feishuApi.sendCard(chatId, card);
+                            if (msg?.message_id && session) {
+                                this.sessionManager.setCurrentMessage(chatId, msg.message_id);
+                            }
+                        }
                     }
-                    break;
+                    this.sessionManager.updateStatus(chatId, 'idle');
+                    log.info({ command }, `${command} rendered in streaming card`);
+                    return;
                 }
                 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';
-                        }
+                    const agentList = Array.isArray(agents)
+                        ? agents.filter((a) => a.mode !== 'subagent' && !a.hidden)
+                        : [];
+                    if (agentList.length === 0) {
+                        message = '暂无可用代理';
+                        await this.feishuApi.sendText(chatId, message);
                     }
                     else {
-                        message += '暂无代理信息\n';
+                        const config = await this.opencode.getConfig();
+                        const currentAgent = config?.default_agent || config?.agent?.build?.name || 'build';
+                        const session = this.sessionManager.getSession(chatId);
+                        const agentItems = agentList.map((a) => ({
+                            name: a.name,
+                            description: a.description,
+                            mode: a.mode,
+                        }));
+                        if (session) {
+                            session.agentSelection = { agents: agentItems, currentAgent };
+                        }
+                        const card = FeishuCard.createStreamingCard({
+                            content: '',
+                            botName: this.botName,
+                            done: false,
+                            showProcess: this.config.showProcess || 'none',
+                            agentSelection: { agents: agentItems, currentAgent },
+                        });
+                        if (session?.currentMessageId) {
+                            await this.feishuApi.updateCard(session.currentMessageId, card);
+                        }
+                        else {
+                            const msg = await this.feishuApi.sendCard(chatId, card);
+                            if (msg?.message_id && session) {
+                                this.sessionManager.setCurrentMessage(chatId, msg.message_id);
+                            }
+                        }
                     }
-                    break;
+                    this.sessionManager.updateStatus(chatId, 'idle');
+                    log.info({ command }, `${command} rendered in streaming card`);
+                    return;
                 }
                 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;
+                    const cmdList = [
+                        { name: 'models', description: '选择模型' },
+                        { name: 'agents', description: '选择代理' },
+                        { name: 'commands', description: '查看所有命令' },
+                        { name: 'sessions', description: '管理会话' },
+                        { name: 'status', description: '项目状态' },
+                        { name: 'new', description: '创建新会话' },
+                        { name: 'compact', description: '压缩上下文' },
+                        { name: 'restart', description: '重启服务' },
+                        { name: 'init', description: '初始化 AGENTS.md' },
+                        { name: 'review', description: '审查代码变更' },
+                    ];
+                    await this.feishuApi.sendCard(chatId, FeishuCard.createCommandsCard(cmdList));
+                    this.sessionManager.updateStatus(chatId, 'idle');
+                    this.sessionManager.clearCurrentMessage(chatId);
+                    return;
                 }
                 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';
-                        }
+                    const sessList = this.deduplicateAndSortSessions(sessions);
+                    if (sessList.length === 0) {
+                        await this.feishuApi.sendText(chatId, '暂无会话');
                     }
                     else {
-                        message += '暂无会话信息\n';
+                        const currentSession = this.sessionManager.getSession(chatId);
+                        await this.feishuApi.sendCard(chatId, FeishuCard.createSessionsCard({
+                            sessions: sessList,
+                            currentSessionId: currentSession?.id || '',
+                        }));
                     }
-                    break;
+                    this.sessionManager.updateStatus(chatId, 'idle');
+                    this.sessionManager.clearCurrentMessage(chatId);
+                    return;
                 }
                 case 'tools': {
                     const tools = await this.opencode.getTools();
@@ -799,22 +1153,29 @@ export class MessageHandler {
                     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`;
-                            }
-                        }
+                    let branch;
+                    let commit;
+                    let files = [];
+                    try {
+                        const vcsInfo = await this.opencode.getVcsInfo();
+                        branch = vcsInfo?.branch;
+                        commit = vcsInfo?.commit || vcsInfo?.hash;
                     }
-                    else {
-                        message += '暂无状态信息\n';
+                    catch { /* vcs not available */ }
+                    try {
+                        const fileStatus = await this.opencode.getStatus();
+                        if (Array.isArray(fileStatus)) {
+                            files = fileStatus;
+                        }
+                        else if (fileStatus?.files) {
+                            files = fileStatus.files;
+                        }
                     }
-                    break;
+                    catch { /* file status not available */ }
+                    await this.feishuApi.sendCard(chatId, FeishuCard.createStatusCard({ branch, commit, files }));
+                    this.sessionManager.updateStatus(chatId, 'idle');
+                    this.sessionManager.clearCurrentMessage(chatId);
+                    return;
                 }
                 case 'config': {
                     const config = await this.opencode.getConfig();
@@ -892,84 +1253,72 @@ export class MessageHandler {
             };
         }
         catch (err) {
-            log.error({ err, messageId, fileKey }, `Failed to download ${typeLabel}`);
+            log.error({ err, messageId, fileKey, resourceType }, `Failed to download ${typeLabel}`);
             return { text: `[${typeLabel}消息（下载失败）]` };
         }
     }
     /**
      * Handle restart command from admin user.
-     * Restarts opencode serve and/or the feishu plugin.
+     * Supports: 'serve' (default), 'feishu', 'all'.
+     * Uses fire-and-forget detached spawn so the restart script can outlive this process.
      */
-    async handleRestartCommand(chatId, command) {
-        const { execSync } = await import('child_process');
+    async handleRestartCommand(chatId, target = 'serve') {
+        const { execSync, spawn } = await import('child_process');
+        const path = await import('path');
+        const targetLabels = {
+            serve: 'OpenCode 服务',
+            feishu: '飞书连接器',
+            all: '全部服务',
+        };
+        const label = targetLabels[target] || target;
+        // Map target to script name
+        const scriptNames = {
+            serve: 'restart-serve.sh',
+            feishu: 'restart-feishu.sh',
+            all: 'restart-all.sh',
+        };
+        const scriptName = scriptNames[target];
+        if (!scriptName) {
+            await this.feishuApi.sendText(chatId, `❌ 不支持的重启目标: ${target}`);
+            return;
+        }
         try {
-            await this.feishuApi.sendText(chatId, '🔄 正在重启服务...');
-            // Restart opencode serve
-            try {
-                // Kill existing opencode serve processes (excluding current process)
-                const currentPid = process.pid;
+            await this.feishuApi.sendText(chatId, `🔄 正在重启 ${label}...`);
+            // Find the restart script
+            const possiblePaths = [
+                path.join(process.cwd(), 'connectors', 'feishu', scriptName),
+                path.join(this.opencode.getDirectory(), 'connectors', 'feishu', scriptName),
+            ];
+            let scriptPath = '';
+            for (const p of possiblePaths) {
                 try {
-                    execSync(`pgrep -f "opencode serve" | grep -v "${currentPid}" | xargs -r kill 2>/dev/null || true`, {
-                        stdio: 'ignore'
-                    });
+                    execSync(`test -f "${p}"`, { stdio: 'ignore' });
+                    scriptPath = p;
+                    break;
                 }
                 catch {
-                    // Ignore errors from pgrep/kill
-                }
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                execSync('nohup opencode serve --port 19876 > /tmp/opencode-serve.log 2>&1 &', {
-                    stdio: 'ignore'
-                });
-                await new Promise(resolve => setTimeout(resolve, 3000));
-                // Verify opencode is running
-                const isRunning = await fetch('http://localhost:19876', {
-                    method: 'GET',
-                    signal: AbortSignal.timeout(5000)
-                }).then(r => r.ok || r.status === 404).catch(() => false);
-                if (isRunning) {
-                    await this.feishuApi.sendText(chatId, '✅ OpenCode 服务已重启');
-                }
-                else {
-                    await this.feishuApi.sendText(chatId, '⚠️ OpenCode 服务重启失败，请检查日志');
+                    continue;
                 }
             }
-            catch (err) {
-                log.error({ err }, 'Failed to restart opencode serve');
-                await this.feishuApi.sendText(chatId, '❌ OpenCode 重启失败');
-            }
-            // Restart feishu plugin if requested
-            if (command === '/restart') {
-                await this.feishuApi.sendText(chatId, '🔄 正在重启飞书插件...');
-                try {
-                    // Give time for message to be sent before restart
-                    setTimeout(() => {
-                        // Kill other opencode-feishu processes but exclude current process
-                        const currentPid = process.pid;
-                        try {
-                            execSync(`pgrep -f "opencode-feishu" | grep -v "${currentPid}" | xargs -r kill || true`, {
-                                stdio: 'ignore'
-                            });
-                        }
-                        catch {
-                            // Ignore errors from pgrep/kill
-                        }
-                        setTimeout(() => {
-                            execSync('nohup opencode-feishu start --daemon --serve > /tmp/feishu-plugin.log 2>&1 &', {
-                                stdio: 'ignore'
-                            });
-                        }, 2000);
-                    }, 1000);
-                    await this.feishuApi.sendText(chatId, '✅ 飞书插件重启指令已发送，插件将在几秒后恢复');
-                }
-                catch (err) {
-                    log.error({ err }, 'Failed to restart feishu plugin');
-                    await this.feishuApi.sendText(chatId, '❌ 飞书插件重启失败');
-                }
+            if (!scriptPath) {
+                log.error(`${scriptName} not found`);
+                await this.feishuApi.sendText(chatId, `❌ 找不到重启脚本 connectors/feishu/${scriptName}`);
+                return;
             }
+            // Fire-and-forget: spawn the restart script and don't wait for result
+            const child = spawn('bash', [scriptPath, '19876'], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            log.info({ scriptPath, target }, 'Restart script spawned');
         }
         catch (err) {
-            log.error({ err }, 'Restart command failed');
-            await this.feishuApi.sendText(chatId, '❌ 重启命令执行失败');
+            log.error({ err, target }, 'Restart command failed');
+            try {
+                await this.feishuApi.sendText(chatId, `❌ 重启失败：${err instanceof Error ? err.message : String(err)}`);
+            }
+            catch { /* ignore */ }
         }
     }
 }