@yvhitxcel/opencode-remote 0.17.0 → 0.18.0

package/dist/opencode/client.js

@@ -14,7 +14,7 @@ const CONFIG_FILE = join(CONFIG_DIR, '.env');
 const threadModels = new Map();
 const recentModels = [];
 let rawDebugEnabled = false;
-let thinkVisibleEnabled = false;
+let thinkVisibleEnabled = true;
 
 export function setRawDebug(enabled) {
     rawDebugEnabled = enabled;
@@ -332,6 +332,18 @@ export async function initOpenCode() {
     }
     return null;
 }
+
+/**
+ * Reset the cached OpenCode instance + server reference.
+ * Call before retrying initOpenCode() after an AbortError or fatal disconnect
+ * to force a fresh server spawn instead of returning the stale singleton.
+ */
+export function resetOpenCode() {
+    opencodeInstance = null;
+    opencodeServer = null;
+    console.log('[opencode] reset cached instance (forced fresh start next call)');
+}
+
 export async function verifyOpenCodeInstalled() {
     return new Promise((resolve) => {
         const isWindows = platform() === 'win32';
@@ -400,55 +412,58 @@ export async function createSession(_threadId, title = `Remote control session`)
 }
 // Send message - use promptAsync then poll for response
 export async function sendMessage(session, message, callbacks, threadId) {
-    const TIMEOUT_MS = 5 * 60 * 1000;
+    const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '180', 10) * 1000;
 
+    // Verify session is valid first
     try {
-        // Verify session is valid first
-        try {
-            const sessionCheck = await session.client.session.get({ sessionID: session.sessionId });
-            if (sessionCheck.error) {
-                console.error('[sendMessage] Session error:', sessionCheck.error);
-                return '❌ 会话无效，请发送 /restart 重启';
-            }
-        } catch (e) {
-            console.error('[sendMessage] Session check failed:', e.message);
-            return '❌ 会话连接失败，请发送 /restart 重启';
+        const sessionCheck = await session.client.session.get({ sessionID: session.sessionId });
+        if (sessionCheck.error) {
+            console.error('[sendMessage] Session error:', sessionCheck.error);
+            throw new Error(`session invalid: ${sessionCheck.error}`);
         }
+    } catch (e) {
+        console.error('[sendMessage] Session check failed:', e.message);
+        throw new Error(`session check failed: ${e.message}`);
+    }
 
-        // Build prompt body
-        const promptBody = {
-            parts: [{ type: 'text', text: message }]
+    // Build prompt body
+    const promptBody = {
+        parts: [{ type: 'text', text: message }]
+    };
+    // Inject local model preference if set
+    if (threadId && threadModels.has(threadId)) {
+        session.model = threadModels.get(threadId);
+        pushRecent(session.model);
+    }
+    // Per-message model override if set on session
+    if (session.model?.providerID && session.model?.modelID) {
+        promptBody.model = {
+            providerID: session.model.providerID,
+            modelID: session.model.modelID,
         };
-        // Inject local model preference if set
-        if (threadId && threadModels.has(threadId)) {
-            session.model = threadModels.get(threadId);
-            pushRecent(session.model);
-        }
-        // Per-message model override if set on session
-        if (session.model?.providerID && session.model?.modelID) {
-            promptBody.model = {
-                providerID: session.model.providerID,
-                modelID: session.model.modelID,
-            };
-        }
+    }
 
-        // Stream the response via session.prompt (POST /session/{sessionID}/message)
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => abortController.abort(), TIMEOUT_MS);
-
-        try {
-            const response = await session.client.session.prompt({
-                sessionID: session.sessionId,
-                parts: promptBody.parts,
-                ...(promptBody.model ? { model: promptBody.model } : {}),
-            }, {
-                parseAs: 'stream',
-                signal: abortController.signal,
-            });
+    // Stream the response via session.prompt (POST /session/{sessionID}/message)
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), TIMEOUT_MS);
 
-            if (response.error) {
-                return `❌ 发送失败: ${response.error}`;
+    try {
+        const response = await session.client.session.prompt({
+            sessionID: session.sessionId,
+            parts: promptBody.parts,
+            ...(promptBody.model ? { model: promptBody.model } : {}),
+        }, {
+            parseAs: 'stream',
+            signal: abortController.signal,
+        });
+
+        if (response.error) {
+            if (/abort/i.test(response.error)) {
+                console.warn('[sendMessage] SDK returned AbortError');
+                throw new Error(response.error || 'AbortError');
             }
+            throw new Error(response.error);
+        }
 
             const stream = response.data;
             if (!stream) {
@@ -472,6 +487,11 @@ export async function sendMessage(session, message, callbacks, threadId) {
             if (isRawDebug()) console.log('[RAW]', rawJson);
             try {
                 const parsed = JSON.parse(rawJson);
+                // 顶层 error → 透传真实错误
+                if (parsed.error) {
+                    const errMsg = typeof parsed.error === 'string' ? parsed.error : (parsed.error.message || JSON.stringify(parsed.error));
+                    throw new Error(errMsg);
+                }
                 const t = parsed.info?.tokens || {};
                 const time = parsed.info?.time || {};
                 const elapsed = time.completed && time.created ? `${(time.completed - time.created) / 1000}s` : '?';
@@ -498,13 +518,23 @@ export async function sendMessage(session, message, callbacks, threadId) {
                         }
                     }
                 }
+                // info.error 字段 → 透传
+                if (!responseText && parsed.info?.error) {
+                    throw new Error(parsed.info.error);
+                }
+                // 非正常结束 → 透传 finish 原因
+                if (!responseText && parsed.info?.finish && parsed.info.finish !== 'stop') {
+                    throw new Error(`finish=${parsed.info.finish}`);
+                }
                 if (!responseText && parsed.info?.finish) {
-                    responseText = '[empty response]';
+                    throw new Error(`Empty response (finish=${parsed.info.finish}, tokens=${t.total || 0})`);
                 }
             } catch (e) {
+                if (e.message && !e.message.startsWith('Unexpected')) throw e;
                 console.error('[sendMessage] Failed to parse response:', e.message);
                 console.log('[RAW]', rawJson.slice(0, 1000));
-                responseText = rawJson;
+                if (rawJson.trim()) responseText = rawJson;
+                else throw new Error('Empty response (no stream data)');
             }
 
             callbacks?.onStatusChange?.({ type: 'idle' });
@@ -513,14 +543,6 @@ export async function sendMessage(session, message, callbacks, threadId) {
         } finally {
             clearTimeout(timeoutId);
         }
-    } catch (error) {
-        if (error.name === 'AbortError') {
-            console.warn('[sendMessage] 5min timeout, aborting stream');
-            return '⏰ 请求超时，请重试';
-        }
-        console.error('[sendMessage] Error:', error);
-        return `❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
-    }
 }
 export async function getSession(session) {
     try {
@@ -620,8 +642,8 @@ export async function listOpenCodeSessions() {
             id: s.id,
             title: s.title || 'Untitled',
             directory: s.directory || '',
-            createdAt: s.created_at || s.time?.created || 0,
-            lastActivity: s.updated_at || s.time?.updated || 0,
+            createdAt: s.time?.created || 0,
+            lastActivity: s.time?.updated || 0,
         }));
     }
     catch (error) {
@@ -644,8 +666,8 @@ export async function listOpenCodeSessionsFromServer(baseUrl) {
             id: s.id,
             title: s.title || 'Untitled',
             directory: s.directory || '',
-            createdAt: s.created_at || s.time?.created || 0,
-            lastActivity: s.updated_at || s.time?.updated || 0,
+            createdAt: s.time?.created || 0,
+            lastActivity: s.time?.updated || 0,
         }));
     }
     catch (error) {

package/dist/patch_spawn.js

@@ -1,3 +1,4 @@
+// @ts-nocheck — patches internal Module._load which is private API
 import { createRequire } from 'node:module';
 import Module from 'node:module';
 import { platform } from 'os';

package/dist/plugins/agents/claude-code/index.js

@@ -1,6 +1,10 @@
-// Claude Code CLI agent adapter
+// Claude Code CLI agent adapter — --print + explicit context prompt
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const LIUV_CRASH_PATTERNS = [
     'Assertion failed',
@@ -23,22 +27,13 @@ export class ClaudeCodeAgentAdapter {
     }
 
     async sendPrompt(_sessionId, prompt, history, options = {}) {
-        const projectDir = options.projectDir;
-        let cleanPrompt = prompt;
-        if (prompt.startsWith('-c')) {
-            cleanPrompt = prompt.slice(2).trim();
-        }
-        const contextualPrompt = this.buildContextualPrompt(cleanPrompt, history);
-
-        const args = ['--print', '-c', contextualPrompt];
-
-        return this.callClaude(args, projectDir);
-    }
-
-    buildContextualPrompt(prompt, history) {
-        if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Previous:\n${historyText}\n\n${prompt}`;
+        const threadId = options.threadId;
+        const contextualPrompt = buildContextualPrompt(prompt, history);
+        // 跑在临时目录，避免 claude 扫描项目源码崩在 misc-lib.mjs
+        const safeCwd = join(tmpdir(), 'opencode-remote-claude');
+        const { mkdirSync, existsSync } = await import('fs');
+        if (!existsSync(safeCwd)) mkdirSync(safeCwd, { recursive: true });
+        return this.callClaude(['--print', contextualPrompt], safeCwd, threadId);
     }
 
     isCrashNoise(line) {
@@ -46,70 +41,83 @@ export class ClaudeCodeAgentAdapter {
     }
 
     extractErrorMessage(stdout, stderr, code) {
-        // 先检查 stdout：--print 模式把错误也输出到 stdout
         const stdoutLines = stdout.trim().split('\n').map(l => l.trim()).filter(Boolean);
         const stdoutErrors = stdoutLines.filter(l => !this.isCrashNoise(l));
-        if (stdoutErrors.length > 0) {
-            return stdoutErrors.join('\n');
-        }
-
-        // 再检查 stderr
+        if (stdoutErrors.length > 0) return stdoutErrors.join('\n');
         const stderrLines = stderr.trim().split('\n').map(l => l.trim()).filter(Boolean);
         const stderrReal = stderrLines.filter(l => !this.isCrashNoise(l));
-        if (stderrReal.length > 0) {
-            return stderrReal.join('\n');
-        }
-
-        // 如果全是崩溃噪音，尝试从任一流中找 Error 关键词
+        if (stderrReal.length > 0) return stderrReal.join('\n');
         const all = [...stdoutLines, ...stderrLines];
         const firstRelevant = all.find(l => /Error|error|ERROR|^\d{3}/.test(l));
         if (firstRelevant) return firstRelevant;
-
-        // 兜底
         return `进程异常退出 (code: ${code})`;
     }
 
-    callClaude(args, projectDir) {
+    callClaude(args, safeCwd, threadId) {
         return new Promise((resolve) => {
             const opts = {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
+                cwd: safeCwd,
             };
-            if (projectDir) {
-                opts.cwd = projectDir;
-            }
-
-            console.log(`[claude-code] Spawning: claude ${args.join(' ')} in ${opts.cwd || process.cwd()}`);
-            const proc = spawn('claude', args, opts);
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues:
+//   \n \r — command separator (cmd.exe), treated as command end
+//   & | < > ^ — command separator / pipe / redirect / escape
+//   " ' ` — quote chars (could break out of intended argument)
+// We strip rather than escape to avoid platform-specific escape syntax.
+const safeArgs = args.map(a => {
+    if (typeof a !== 'string') return a;
+    return a
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+});
+            console.log(`[claude-code] ${safeArgs.join(' ')}`);
+            const proc = spawn('claude', safeArgs, opts);
+            if (threadId) registerAgentProcess(threadId, proc, 'claude-code');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
 
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
             const timeout = setTimeout(() => {
-                console.log(`[claude-code] Process still running after 30s, stderr so far: ${stderr.slice(-200)}`);
-            }, 30000);
+                killed = true;
+                console.warn(`[claude-code] Timeout ${TIMEOUT_MS / 1000}s`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Claude Code 超时 (${TIMEOUT_MS / 1000}s)`);
+            }, TIMEOUT_MS);
 
             proc.on('close', (code) => {
                 clearTimeout(timeout);
-                console.log(`[claude-code] Process exited with code ${code}, stdout=${stdout.length} bytes, stderr=${stderr.length} bytes`);
-
-                if (code === 0) {
-                    resolve(stdout.trim());
-                    return;
-                }
-
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
+                console.log(`[claude-code] exit ${code}, ${stdout.length} bytes`);
+                if (code === 0) { resolve(stdout.trim()); return; }
                 const errorMsg = this.extractErrorMessage(stdout, stderr, code);
-                console.log(`[claude-code] Process failed, raw stderr:\n${stderr.trim().slice(-1000)}`);
-                console.log(`[claude-code] Error detail:\n${errorMsg}`);
-
-                resolve(`❌ Claude Code 错误 (exit code ${code}): ${errorMsg}`);
+                resolve(`❌ Claude Code 错误 (exit ${code}): ${errorMsg}`);
             });
             proc.on('error', (err) => {
                 clearTimeout(timeout);
-                console.log(`[claude-code] Spawn error: ${err.message}`);
+                if (threadId) unregisterAgentProcess(threadId);
                 resolve(`❌ Claude Code 启动失败: ${err.message}`);
             });
         });
     }
 }
+
+function buildContextualPrompt(prompt, history) {
+    if (!history || history.length === 0) return prompt;
+    const lines = history.slice(-10).map(m => {
+        const label = m.role === 'user' ? 'User' : 'Assistant';
+        return `${label}: ${m.content}`;
+    }).join('\n');
+    return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
+}
+
+// Exported for tests
+export { buildContextualPrompt };

package/dist/plugins/agents/codex/index.js

@@ -1,6 +1,8 @@
 // OpenAI Codex CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -22,15 +24,18 @@ export class CodexAgentAdapter {
         });
     }
     
-    async sendPrompt(_sessionId, prompt, history) {
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
-        return this.callCodex(contextualPrompt);
+        return this.callCodex(contextualPrompt, options.threadId);
     }
     
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Context:\n${historyText}\n\n${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
 
     extractErrorMessage(stdout, stderr) {
@@ -43,17 +48,38 @@ export class CodexAgentAdapter {
         return first || null;
     }
     
-    callCodex(prompt) {
+callCodex(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('codex', ['--prompt', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ').trim()
+    : prompt;
+            const proc = spawn('codex', ['exec', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'codex');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[codex] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Codex 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
             proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
                 if (code === 0) {
                     resolve(stdout.trim());
                 } else {

package/dist/plugins/agents/copilot/index.js

@@ -1,6 +1,8 @@
 // GitHub Copilot CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -22,15 +24,18 @@ export class CopilotAgentAdapter {
         });
     }
     
-    async sendPrompt(_sessionId, prompt, history) {
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
-        return this.callCopilot(contextualPrompt);
+        return this.callCopilot(contextualPrompt, options.threadId);
     }
     
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Context:\n${historyText}\n\n${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
 
     extractErrorMessage(stdout, stderr) {
@@ -43,17 +48,38 @@ export class CopilotAgentAdapter {
         return first || null;
     }
     
-    callCopilot(prompt) {
+callCopilot(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('copilot', ['suggest', '--prompt', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ').trim()
+    : prompt;
+            const proc = spawn('copilot', ['-p', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'copilot');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[copilot] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Copilot 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
             proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
                 if (code === 0) {
                     resolve(stdout.trim());
                 } else {

package/dist/plugins/agents/opencode/index.js

@@ -1,6 +1,8 @@
 // OpenCode CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -23,20 +25,18 @@ export class OpenCodeAgentAdapter {
     }
     
     async sendPrompt(_sessionId, prompt, history, options = {}) {
-        let cleanPrompt = prompt;
-        if (prompt.startsWith('-c')) {
-            cleanPrompt = prompt.slice(2).trim();
-        }
-        const contextualPrompt = this.buildContextualPrompt(cleanPrompt, history);
-        return this.callOpenCode(contextualPrompt);
+        const threadId = options.threadId;
+        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+        return this.callOpenCode(contextualPrompt, threadId);
     }
 
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history
-            .map(msg => `[${msg.role === 'user' ? 'User' : 'Assistant'}]: ${msg.content}`)
-            .join('\n\n');
-        return `Previous conversation:\n${historyText}\n\nCurrent request: ${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
 
     extractErrorMessage(stdout, stderr) {
@@ -50,17 +50,37 @@ export class OpenCodeAgentAdapter {
         return first || null;
     }
 
-    callOpenCode(prompt) {
+    callOpenCode(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('opencode', ['run', '--format', 'json', '-c', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+    : prompt;
+            const proc = spawn('opencode', ['run', '--format', 'json', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'opencode');
 
             let stdout = '';
             let stderr = '';
             let fullText = '';
             let resigned = false;
+            let killed = false;
+
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[opencode-agent] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ OpenCode 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
 
             const STUCK_PATTERNS = [
                 'Free usage exceeded', 'quota exceeded', 'rate limit',
@@ -92,7 +112,7 @@ export class OpenCodeAgentAdapter {
                     try {
                         const event = JSON.parse(line);
                         if (event.text) fullText += event.text;
-                    } catch {}
+                    } catch (e) { console.debug('[opencode-agent] stdout parse:', e.message); }
                 }
             });
 
@@ -102,7 +122,9 @@ export class OpenCodeAgentAdapter {
             });
 
             proc.on('close', (code) => {
-                if (resigned) return;
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (resigned || killed) return;
                 if (code !== 0) {
                     const detail = this.extractErrorMessage(stdout, stderr);
                     const hint = detail

package/dist/telegram/adapter.js

@@ -43,7 +43,7 @@ export class TelegramAdapter {
             ['/cx', '/copilot'],
         ];
         const keyboard = [];
-        for (const [, cmds] of groups) {
+        for (const cmds of groups) {
             const row = cmds.map(cmd => ({ text: cmd, callback_data: `cmd:${cmd.slice(1)}` }));
             keyboard.push(row);
         }
@@ -52,14 +52,30 @@ export class TelegramAdapter {
         });
     }
 
+    // BotAdapter 接口方法
+    async reply(threadId, text) { return this.sendMessage(threadId, text); }
+    async sendTypingIndicator(threadId) { return this.sendTyping(threadId, true); }
+    async sendTypingEnd(threadId) { return this.sendTyping(threadId, false); }
+    async updateMessage(threadId, messageId, text) {
+        if (!this.bot || !messageId) return;
+        try { await this.bot.api.editMessageText(threadId, Number(messageId), text); } catch (e) { console.warn('[telegram] updateMessage failed:', e.message); }
+    }
+    async deleteMessage(threadId, messageId) {
+        if (!this.bot || !messageId) return;
+        try { await this.bot.api.deleteMessage(threadId, Number(messageId)); }
+        catch (e) { console.debug('[telegram] deleteMessage failed:', e.message); }
+    }
+
     async sendTyping(threadId, isTyping) {
         if (!this.bot) return;
         if (isTyping) {
-            try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+            try { await this.bot.api.sendChatAction(threadId, 'typing'); }
+            catch (e) { console.debug('[telegram] sendChatAction failed:', e.message); }
             const existing = this.typingIntervals.get(threadId);
             if (existing) clearInterval(existing);
             const interval = setInterval(async () => {
-                try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+                try { await this.bot.api.sendChatAction(threadId, 'typing'); }
+                catch (e) { console.debug('[telegram] typing-tick failed:', e.message); }
             }, 4000);
             this.typingIntervals.set(threadId, interval);
         } else {