@yvhitxcel/opencode-remote 0.15.1 → 0.16.1

package/dist/opencode/client.js

@@ -172,6 +172,9 @@ export async function initFetchConfig() {
 }
 let opencodeInstance = null;
 let opencodeServer = null;
+let lastStdoutTime = 0;
+let lastStdoutLine = '';
+let lastReportedStatus = '';
 const PORTS_TO_TRY = [4096, 4097, 4098];
 
 // TCP-level port probe: true = occupied, false = free
@@ -241,8 +244,9 @@ export async function initOpenCode() {
                 windowsHide: isWindows,
             });
             opencodeServer.stdout.on('data', (d) => {
+                lastStdoutTime = Date.now();
                 const msg = d.toString().trim();
-                if (msg) console.log(`[opencode] ${msg}`);
+                if (msg) { lastStdoutLine = msg.slice(0, 120); console.log(`[opencode] ${msg}`); }
             });
             opencodeServer.stderr.on('data', (d) => {
                 const msg = d.toString().trim();
@@ -389,13 +393,12 @@ export async function sendMessage(session, message, callbacks) {
             body: promptBody,
         });
 
-        // Poll for new response - multi-turn: continue until truly idle
+        // Poll for new response - keep going as long as new content keeps arriving
         const startTime = Date.now();
         let responseText = '';
         let hasToolActivity = false;
+        let idleSince = 0; // 最后一次收到新内容的时间戳
         let lastStatus = '';
-        let idleCycles = 0;
-        const IDLE_THRESHOLD = 3; // Exit after 3 idle polls (no new content, not processing)
 
         while (Date.now() - startTime < TIMEOUT_MS) {
             await new Promise(r => setTimeout(r, POLL_INTERVAL));
@@ -405,93 +408,62 @@ export async function sendMessage(session, message, callbacks) {
                     path: { id: session.sessionId }
                 });
 
-                if (msgsResult.error) {
-                    console.error('[sendMessage] Messages error:', msgsResult.error);
-                    break;
-                }
-
-                if (!msgsResult.data?.length) {
-                    continue;
-                }
+                if (msgsResult.error) { console.error('[sendMessage] Messages error:', msgsResult.error); break; }
+                if (!msgsResult.data?.length) continue;
 
                 const messages = msgsResult.data;
-                const newMsgCount = messages.length;
-
-                // Check session status
-                const latestMsg = messages[messages.length - 1];
-                const currentStatus = latestMsg?.info?.status;
-                if (currentStatus !== lastStatus) {
-                    lastStatus = currentStatus;
-                    if (lastStatus) {
-                        console.log(`[sendMessage] Session status: ${lastStatus}`);
-                    }
-                }
 
-                // If actively processing, reset idle counter and wait
-                if (lastStatus === 'pending_tool' || lastStatus === 'thinking') {
-                    idleCycles = 0;
-                    continue;
-                }
-
-                // Check if there was tool activity and notify via callback
-                if (newMsgCount > msgCountBefore) {
-                    for (let i = msgCountBefore; i < newMsgCount; i++) {
-                        const msg = messages[i];
-                        if (msg.parts) {
-                            for (const part of msg.parts) {
-                                if (part.type === 'tool_use' || part.type === 'tool_result') {
-                                    hasToolActivity = true;
-                                    callbacks?.onEvent?.({
-                                        type: 'tool.call',
-                                        properties: {
-                                            name: part.name || part.tool_name || 'unknown',
-                                            input: part.input || {}
-                                        }
-                                    });
-                                    break;
-                                }
-                            }
+                // 工具活动
+                for (let i = msgCountBefore; i < messages.length; i++) {
+                    const msg = messages[i];
+                    if (msg.parts) for (const part of msg.parts) {
+                        if (part.type === 'tool_use' || part.type === 'tool_result') {
+                            hasToolActivity = true;
+                            callbacks?.onEvent?.({ type: 'tool.call', properties: { name: part.name || part.tool_name || 'unknown', input: part.input || {} } });
+                            break;
                         }
-                        if (hasToolActivity) break;
                     }
+                    if (hasToolActivity) break;
                 }
 
-                // Find messages after our last message
-                let startIdx = 0;
+                // 收集所有新的 assistant 回复（累加，不丢内容）
                 if (lastMsgId) {
                     const idx = messages.findIndex(m => m.info?.id === lastMsgId);
-                    if (idx >= 0) startIdx = idx + 1;
-                }
-
-                // Collect the latest assistant response text
-                let newText = '';
-                for (let i = messages.length - 1; i >= startIdx; i--) {
-                    const msg = messages[i];
-                    if (msg.info?.role === 'assistant') {
-                        const textParts = msg.parts
-                            ?.filter(p => p.type === 'text' && p.text)
-                            .map(p => p.text) || [];
-
-                        if (textParts.length > 0) {
-                            newText = textParts.join('\n');
-                            break;
+                    const startIdx = idx >= 0 ? idx + 1 : 0;
+                    const newParts = [];
+                    for (let i = startIdx; i < messages.length; i++) {
+                        const msg = messages[i];
+                        if (msg.info?.role === 'assistant' && msg.parts) {
+                            for (const p of msg.parts) {
+                                if (p.type === 'text' && p.text) newParts.push(p.text);
+                            }
                         }
                     }
+                    const fullText = newParts.join('\n');
+                    if (fullText && fullText !== responseText) {
+                        const delta = fullText.slice(responseText.length);
+                        responseText = fullText;
+                        callbacks?.onTextDelta?.(delta);
+                        callbacks?.onNewContent?.(delta);
+                        idleSince = Date.now();
+                        continue;
+                    }
                 }
 
-                if (newText && newText !== responseText) {
-                    const delta = newText.slice(responseText.length);
-                    responseText = newText;
-                    callbacks?.onTextDelta?.(delta);
-                    idleCycles = 0;
+                // 检查 AI 是否还在忙（thinking/pending_tool 说明还没干完）
+                const latestStatus = msgsResult.data?.length ? msgsResult.data[msgsResult.data.length - 1]?.info?.status : '';
+                if (latestStatus === 'thinking' || latestStatus === 'pending_tool') {
+                    idleSince = Date.now();
+                }
+                if (latestStatus) lastStatus = latestStatus;
+                if (latestStatus && latestStatus !== lastReportedStatus) {
+                    lastReportedStatus = latestStatus;
+                    console.log(`[AI状态] ${latestStatus}`);
                 }
 
-                // Exit only when truly idle: have response, not processing, no new text for N cycles
-                if (responseText && lastStatus !== 'pending_tool' && lastStatus !== 'thinking') {
-                    idleCycles++;
-                    if (idleCycles >= IDLE_THRESHOLD) {
-                        break;
-                    }
+                // 有回复后：等 30 秒无新内容且 AI 不忙才退出
+                if (responseText && Date.now() - idleSince > 30000) {
+                    break;
                 }
             } catch (e) {
                 console.warn('Poll error:', e.message);
@@ -523,7 +495,6 @@ export async function sendMessage(session, message, callbacks) {
         }
         
         callbacks?.onStatusChange?.({ type: 'idle', hasToolActivity });
-        console.log(`💬 Response: ${responseText.slice(0, 100)}...`);
         return responseText;
     }
     catch (error) {

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

@@ -2,6 +2,13 @@
 import { spawn } from 'child_process';
 import { platform } from 'os';
 
+const LIUV_CRASH_PATTERNS = [
+    'Assertion failed',
+    'UV_HANDLE_CLOSING',
+    'src\\win\\async.c',
+    'libuv',
+];
+
 export class ClaudeCodeAgentAdapter {
     name = 'claude-code';
     aliases = ['cc', 'claude'];
@@ -19,9 +26,7 @@ export class ClaudeCodeAgentAdapter {
         const projectDir = options.projectDir;
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
 
-        // 构建命令参数
         const args = ['--print', contextualPrompt];
-        // `cwd` is set via spawn opts below, no need for --project flag
 
         return this.callClaude(args, projectDir);
     }
@@ -32,13 +37,40 @@ export class ClaudeCodeAgentAdapter {
         return `Previous:\n${historyText}\n\n${prompt}`;
     }
 
+    isCrashNoise(line) {
+        return LIUV_CRASH_PATTERNS.some(p => line.includes(p));
+    }
+
+    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
+        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 关键词
+        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) {
         return new Promise((resolve) => {
             const opts = {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             };
-            // 如果指定了项目目录，在该目录下执行
             if (projectDir) {
                 opts.cwd = projectDir;
             }
@@ -57,7 +89,17 @@ export class ClaudeCodeAgentAdapter {
             proc.on('close', (code) => {
                 clearTimeout(timeout);
                 console.log(`[claude-code] Process exited with code ${code}, stdout=${stdout.length} bytes, stderr=${stderr.length} bytes`);
-                resolve(code === 0 ? stdout.trim() : `❌ Claude Code 错误: ${stderr}`);
+
+                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}`);
             });
             proc.on('error', (err) => {
                 clearTimeout(timeout);

package/dist/telegram/adapter.js

@@ -0,0 +1,75 @@
+import { Bot } from 'grammy';
+import { splitMessage } from '../utils/message-split.js';
+
+export class TelegramAdapter {
+    name = 'telegram';
+    bot = null;
+    config = null;
+    messageHandler = null;
+    isRunning = false;
+    typingIntervals = new Map();
+
+    async start(config) {
+        this.config = config;
+        if (!config.telegramBotToken || config.telegramBotToken === 'your_bot_token_here') {
+            throw new Error('Telegram bot token not configured');
+        }
+        this.bot = new Bot(config.telegramBotToken);
+        this.isRunning = true;
+        console.log('🚀 Telegram adapter started');
+    }
+
+    async stop() {
+        this.isRunning = false;
+        for (const interval of this.typingIntervals.values()) clearInterval(interval);
+        this.typingIntervals.clear();
+        if (this.bot) { await this.bot.stop(); this.bot = null; }
+        console.log('👋 Telegram adapter stopped');
+    }
+
+    onMessage(handler) { this.messageHandler = handler; }
+
+    async sendMessage(threadId, text, opts = {}) {
+        if (!this.bot) throw new Error('Telegram adapter not started');
+        const chunks = splitMessage(text, { maxLength: 4000, addContinuationMarker: false });
+        for (const chunk of chunks) await this.bot.api.sendMessage(threadId, chunk, { parse_mode: 'Markdown', ...opts });
+    }
+
+    async sendCommandMenu(threadId, title) {
+        if (!this.bot) return;
+        const groups = [
+            ['🟢 常用', ['/help', '/status', '/start', '/reset']],
+            ['🔄 任务', ['/loop', '/refresh', '/restart']],
+            ['🤖 AI', ['/model', '/agents', '/oc', '/cc']],
+            ['🧠 专家', ['/tutorial', '/z', '/diagnose']],
+            ['📂 会话', ['/sessions', '/delsessions', '/copy', '/revert']],
+            ['⬆️ 文件', ['/upload', '/delete']],
+        ];
+        const keyboard = [];
+        for (const [, cmds] of groups) {
+            const row = cmds.map(cmd => ({ text: cmd, callback_data: `cmd:${cmd.slice(1)}` }));
+            keyboard.push(row);
+        }
+        await this.bot.api.sendMessage(threadId, title || '📱 选择指令：', {
+            reply_markup: { inline_keyboard: keyboard },
+        });
+    }
+
+    async sendTyping(threadId, isTyping) {
+        if (!this.bot) return;
+        if (isTyping) {
+            try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+            const existing = this.typingIntervals.get(threadId);
+            if (existing) clearInterval(existing);
+            const interval = setInterval(async () => {
+                try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+            }, 4000);
+            this.typingIntervals.set(threadId, interval);
+        } else {
+            const interval = this.typingIntervals.get(threadId);
+            if (interval) { clearInterval(interval); this.typingIntervals.delete(threadId); }
+        }
+    }
+}
+
+export const telegramAdapter = new TelegramAdapter();