@yvhitxcel/opencode-remote 0.17.0 → 0.18.0

package/dist/core/state.js

@@ -0,0 +1,190 @@
+// Persistent state manager — saves threadHistory + threadAgent to disk
+// Bot restart preserves conversation context and agent routing
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync, renameSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { killAllAgentProcesses } from './agent-registry.js';
+
+const STATE_DIR = join(homedir(), '.opencode-remote', 'state');
+const STATE_FILE = join(STATE_DIR, 'state.json');
+const STATE_TMP = join(STATE_DIR, 'state.json.tmp');
+const STATE_BAK = join(STATE_DIR, 'state.json.bak');
+
+const MAX_HISTORY_PER_THREAD = 20;  // 同步 threadHistory 上限
+const MAX_THREADS = 1000;            // 总 thread 上限
+const WRITE_DEBOUNCE_MS = 2000;      // 写盘防抖
+
+let writeTimer = null;
+let dirty = false;
+
+function ensureDir() {
+    if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+}
+
+export function loadState() {
+    ensureDir();
+    let raw = null;
+    if (existsSync(STATE_FILE)) raw = readFileSync(STATE_FILE, 'utf8');
+    else if (existsSync(STATE_BAK)) raw = readFileSync(STATE_BAK, 'utf8');
+    if (!raw) return { threadHistory: {}, threadAgent: {} };
+    try {
+        const s = JSON.parse(raw);
+        return {
+            threadHistory: s.threadHistory || {},
+            threadAgent: s.threadAgent || {},
+        };
+    } catch (e) {
+        console.error('[state] Corrupt state, starting fresh:', e.message);
+        return { threadHistory: {}, threadAgent: {} };
+    }
+}
+
+function doWrite() {
+    ensureDir();
+    const snapshot = {
+        threadHistory: Object.fromEntries(threadHistoryMap),
+        threadAgent: Object.fromEntries(threadAgentMap),
+    };
+    const json = JSON.stringify(snapshot);
+    try {
+        writeFileSync(STATE_TMP, json, 'utf8');
+        if (existsSync(STATE_FILE)) {
+            try { renameSync(STATE_FILE, STATE_BAK); } catch {}
+        }
+        renameSync(STATE_TMP, STATE_FILE);
+    } catch (e) {
+        console.error('[state] Write failed:', e.message);
+    }
+}
+
+export function scheduleWrite() {
+    dirty = true;
+    if (writeTimer) return;
+    writeTimer = setTimeout(() => {
+        writeTimer = null;
+        if (dirty) {
+            dirty = false;
+            doWrite();
+        }
+    }, WRITE_DEBOUNCE_MS);
+}
+
+export function flushWrite() {
+    if (writeTimer) {
+        clearTimeout(writeTimer);
+        writeTimer = null;
+    }
+    if (dirty) {
+        dirty = false;
+        doWrite();
+    }
+}
+
+// In-memory mirror of persistent state
+const threadHistoryMap = new Map();  // threadId -> [{role, content}]
+const threadAgentMap = new Map();     // threadId -> agentName
+
+export const threadHistory = {
+    get(threadId) {
+        const h = threadHistoryMap.get(threadId);
+        return h ? h.slice() : [];
+    },
+    set(threadId, history) {
+        if (!Array.isArray(history) || history.length === 0) {
+            threadHistoryMap.delete(threadId);
+        } else {
+            const trimmed = history.slice(-MAX_HISTORY_PER_THREAD);
+            threadHistoryMap.set(threadId, trimmed);
+            // 上限淘汰: 删最旧的不活跃
+            if (threadHistoryMap.size > MAX_THREADS) {
+                const first = threadHistoryMap.keys().next().value;
+                threadHistoryMap.delete(first);
+            }
+        }
+        scheduleWrite();
+    },
+    delete(threadId) {
+        threadHistoryMap.delete(threadId);
+        scheduleWrite();
+    },
+    has(threadId) {
+        return threadHistoryMap.has(threadId);
+    },
+    size() {
+        return threadHistoryMap.size;
+    },
+};
+
+export const threadAgent = {
+    get(threadId) { return threadAgentMap.get(threadId); },
+    set(threadId, agentName) { threadAgentMap.set(threadId, agentName); scheduleWrite(); },
+    delete(threadId) { threadAgentMap.delete(threadId); scheduleWrite(); },
+    size() { return threadAgentMap.size; },
+};
+
+// 启动时加载
+export function initState() {
+    const s = loadState();
+    let loaded = 0;
+    for (const [k, v] of Object.entries(s.threadHistory)) {
+        if (loaded >= MAX_THREADS) break;
+        if (Array.isArray(v)) { threadHistoryMap.set(k, v); loaded++; }
+    }
+    for (const [k, v] of Object.entries(s.threadAgent)) {
+        threadAgentMap.set(k, v);
+    }
+    console.log(`[state] Loaded ${threadHistoryMap.size} history, ${threadAgentMap.size} agent routes`);
+}
+
+// 退出时刷盘（exit 事件自动触发，无需额外信号处理）
+process.on('exit', () => flushWrite());
+
+// beforeExit: 异步清理窗口。所有 setImmediate / Promise 微任务完成时触发。
+// 比 'exit' 更早，能在进程自然结束时先清理资源（杀 OpenCode server、刷状态）
+process.on('beforeExit', () => {
+    flushWrite();
+    try { globalThis.__opencodeServer?.kill?.(); } catch {}
+});
+
+// 未捕获异常：写日志 + 尝试刷盘 + 退出（让父进程决定是否重启）
+process.on('uncaughtException', (err) => {
+    console.error('[FATAL] uncaughtException:', err);
+    try {
+        const crashLog = join(STATE_DIR, 'crash.log');
+        const line = `[${new Date().toISOString()}] ${err.stack || err.message}\n`;
+        appendFileSync(crashLog, line);
+    } catch {}
+    flushWrite();
+    try { globalThis.__opencodeServer?.kill?.(); } catch {}
+    // 给 logger 一点时间刷盘，然后退出（非 0 表示异常，父进程会重启）
+    setTimeout(() => process.exit(1), 100);
+});
+
+process.on('unhandledRejection', (reason) => {
+    console.error('[ERROR] unhandledRejection:', reason);
+    // 不退出：unhandled rejection 不一定致命
+});
+
+// SIGTERM/SIGINT: 优雅关停（PM2 重启、Ctrl+C、kill <pid>）
+// beforeExit 在 kill -9 / 异常崩溃时不可靠，必须独立处理信号
+function gracefulShutdown(signal) {
+    console.log(`[shutdown] received ${signal}`);
+    try { flushWrite(); } catch (e) { console.error('[shutdown] flushWrite failed:', e); }
+    try { globalThis.__opencodeServer?.kill?.(); } catch (e) { console.error('[shutdown] kill OpenCode failed:', e); }
+    // 杀掉所有 agent 子进程（claude-code/copilot/codex/opencode plugins）
+    // 不杀的话，bot 重启后它们会变孤儿进程
+    try {
+        const killed = killAllAgentProcesses(1000);
+        if (killed.length > 0) {
+            console.log(`[shutdown] killed ${killed.length} agent subprocess(es):`,
+                killed.map(k => `${k.agentName}@${k.threadId}`).join(', '));
+        }
+    } catch (e) { console.error('[shutdown] killAllAgentProcesses failed:', e); }
+    // 给 logger / agent-registry / agent children 一点时间清理
+    setTimeout(() => process.exit(0), 500);
+}
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+// Windows 没有 SIGTERM 但 npm start 转发 Ctrl+C 事件走 SIGINT
+// SIGBREAK 是 Windows Ctrl+Break（PM2 偶尔发）
+process.on('SIGBREAK', () => gracefulShutdown('SIGBREAK'));

package/dist/core/stats.js

@@ -0,0 +1,115 @@
+// In-memory runtime stats — exposed via /info command for self-diagnostics.
+// Reset only on process restart. Cheap to read, safe to write from any handler.
+
+const counters = {
+    startedAt: Date.now(),
+    messagesReceived: 0,
+    messagesSent: 0,
+    errorsByCode: {},        // error type → count (last 24h, capped)
+    opencodeRestarts: 0,
+    retries: 0,
+    authRejections: 0,
+    commandsByType: {},      // command name → count
+};
+
+/**
+ * Increment a named counter. Safe to call from any handler.
+ * @param {string} name
+ * @param {number} [by=1]
+ */
+export function incr(name, by = 1) {
+    if (typeof counters[name] !== 'number') counters[name] = 0;
+    counters[name] += by;
+}
+
+/**
+ * Increment a nested counter (e.g., errorsByCode['AbortError']).
+ * @param {string} group
+ * @param {string} key
+ */
+export function incrKey(group, key) {
+    if (!counters[group] || typeof counters[group] !== 'object') counters[group] = {};
+    counters[group][key] = (counters[group][key] || 0) + 1;
+}
+
+/**
+ * Snapshot of all counters + computed uptime/memory.
+ * Cheap to call. Returns a fresh object each time so callers can mutate freely.
+ */
+export function snapshot() {
+    const mem = process.memoryUsage();
+    return {
+        ...counters,
+        uptimeSec: Math.round((Date.now() - counters.startedAt) / 1000),
+        memoryMB: {
+            rss: Math.round(mem.rss / 1024 / 1024),
+            heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
+            heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
+            external: Math.round(mem.external / 1024 / 1024),
+        },
+        nodeVersion: process.version,
+        pid: process.pid,
+    };
+}
+
+/**
+ * Render a human-readable status block for /info reply.
+ * @param {object} [extra] - additional fields to include (e.g., bot version, agent children count)
+ * @returns {string}
+ */
+export function formatInfo(extra = {}) {
+    const s = snapshot();
+    const fmt = (n) => n.toLocaleString();
+    const lines = [
+        `📊 opencode-remote 状态`,
+        ``,
+        `⏱️  启动时间: ${new Date(s.startedAt).toISOString().slice(0, 19)}Z`,
+        `⏳ 运行: ${formatDuration(s.uptimeSec)}`,
+        `🆔 PID: ${s.pid} · Node ${s.nodeVersion}`,
+        ``,
+        `📨 收到消息: ${fmt(s.messagesReceived)}`,
+        `📤 已回复: ${fmt(s.messagesSent)}`,
+        `🔄 OpenCode 重启: ${fmt(s.opencodeRestarts)}`,
+        `♻️  重试次数: ${fmt(s.retries)}`,
+        `🚫 auth 拒绝: ${fmt(s.authRejections)}`,
+    ];
+
+    if (Object.keys(s.commandsByType).length > 0) {
+        lines.push('', '📋 命令统计:');
+        const top = Object.entries(s.commandsByType)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        for (const [cmd, count] of top) {
+            lines.push(`   /${cmd}: ${fmt(count)}`);
+        }
+    }
+
+    if (Object.keys(s.errorsByCode).length > 0) {
+        lines.push('', '⚠️ 错误类型:');
+        const top = Object.entries(s.errorsByCode)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        for (const [err, count] of top) {
+            lines.push(`   ${err}: ${fmt(count)}`);
+        }
+    }
+
+    lines.push(
+        '',
+        `💾 内存: heap ${s.memoryMB.heapUsed}/${s.memoryMB.heapTotal}MB · rss ${s.memoryMB.rss}MB`,
+    );
+
+    if (extra.version) lines.push(`📦 版本: ${extra.version}`);
+    if (typeof extra.activeThreads === 'number') lines.push(`💬 活跃线程: ${fmt(extra.activeThreads)}`);
+    if (typeof extra.agentChildren === 'number') lines.push(`🧒 agent 子进程: ${fmt(extra.agentChildren)}`);
+
+    return lines.join('\n');
+}
+
+function formatDuration(sec) {
+    if (sec < 60) return `${sec}秒`;
+    if (sec < 3600) return `${Math.floor(sec / 60)}分${sec % 60}秒`;
+    const h = Math.floor(sec / 3600);
+    const m = Math.floor((sec % 3600) / 60);
+    return `${h}小时${m}分`;
+}

package/dist/feishu/adapter.js

@@ -69,4 +69,3 @@ function createFeishuAdapter(client) {
 }
 
 export { createFeishuAdapter };
-export default createFeishuAdapter;

package/dist/feishu/bot.js

@@ -3,6 +3,7 @@ import { initOpenCode } from '../opencode/client.js';
 import { getAuthStatus } from '../core/auth.js';
 import { createFeishuAdapter } from './adapter.js';
 import { handleMessage } from './handler.js';
+import { LRUSessionMap } from '../core/lru.js';
 
 let feishuClient = null;
 let wsClient = null;
@@ -45,7 +46,8 @@ export async function startFeishuBot(botConfig) {
         appId: config.feishuAppId,
         appSecret: config.feishuAppSecret,
     });
-    openCodeSessions = new Map();
+    openCodeSessions = new LRUSessionMap({ maxSize: 100, ttlMs: 30 * 60 * 1000, name: 'feishu-sessions' });
+    setInterval(() => openCodeSessions.cleanup(), 5 * 60 * 1000).unref();
     console.log('🔧 正在初始化 OpenCode...');
     try {
         await initOpenCode();
@@ -84,7 +86,7 @@ export async function startFeishuBot(botConfig) {
                     return { code: 0 };
                 }
                 const ctx = feishuEventToContext(data);
-                handleMessage(adapter, ctx, text, openCodeSessions).catch(error => {
+                handleMessage(adapter, ctx, text, openCodeSessions, 'feishu').catch(error => {
                     console.error('处理飞书消息失败:', error);
                 });
                 return { code: 0 };

package/dist/feishu/commands.js

@@ -7,10 +7,10 @@ import { registry } from '../core/registry.js';
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 
-async function handleCommand(adapter, ctx, command, arg, openCodeSessions) {
+async function handleCommand(adapter, ctx, platform, command, arg, openCodeSessions) {
     switch (command) {
         case 'start': {
-            const result = claimOwnership('feishu', ctx.userId);
+            const result = claimOwnership(platform, ctx.userId);
             if (result.success) {
                 if (result.message === 'claimed') {
                     await adapter.reply(ctx.threadId, `🔐 **安全设置完成！**

package/dist/feishu/handler.js

@@ -1,180 +1,11 @@
-import { splitMessage } from '../core/notifications.js';
-import { createSession, sendMessage, checkConnection, listOpenCodeSessions, resumeSession } from '../opencode/client.js';
-import { isAuthorized, hasOwner } from '../core/auth.js';
-import { detectCommand, EXPERT_SYSTEM_PROMPT } from '../core/router.js';
+import { createHandler } from '../core/handler.js';
 import { handleCommand } from './commands.js';
 
-async function handleMessage(adapter, ctx, text, openCodeSessions) {
-    const expertTriggers = ['z', 'Z', '叫全部专家', '叫所有专家', '呼叫专家点评', '专家点评', '专家意见', 'call all experts', 'expert review', '专家会诊', '团队评审', '代码审查', '全员review', 'review all', '请专家', '叫专家', '找专家'];
-    let expertPrompt = null;
+const handler = createHandler({
+    handleCommand,
+    replyTo: (userId, text, fallbackAdapter) => fallbackAdapter.reply(userId, text),
+    wrapAdapterForShared: (adapter) => adapter,
+});
 
-    if (text.startsWith('/z')) {
-        const arg = text.slice(2).trim();
-        if (arg === 'off' || arg === 'reset' || arg === '关闭') {
-            await adapter.reply(ctx.threadId, '⏹️ 自定义 prompt 已清除');
-            return;
-        }
-        if (arg) {
-            expertPrompt = arg;
-        } else {
-            expertPrompt = EXPERT_SYSTEM_PROMPT;
-        }
-        await forwardToOpenCode(adapter, ctx, text, openCodeSessions, expertPrompt);
-        return;
-    }
-
-    if (expertTriggers.some(t => text.trim().toLowerCase().includes(t))) {
-        expertPrompt = EXPERT_SYSTEM_PROMPT;
-    }
-
-    const parsed = detectCommand(text);
-    if (parsed) {
-        await handleCommand(adapter, ctx, parsed.name, parsed.arg, openCodeSessions);
-        return;
-    }
-    if (!isAuthorized('feishu', ctx.userId)) {
-        if (!hasOwner('feishu')) {
-            await adapter.reply(ctx.threadId, `🔐 **需要认证**
-
-此 bot 尚未绑定。
-
-请发送 /start 进行首次认证。`);
-        } else {
-            await adapter.reply(ctx.threadId, `🚫 **拒绝访问**
-
-你无权使用此 bot。`);
-        }
-        return;
-    }
-    const connected = await checkConnection();
-    if (!connected) {
-        await adapter.reply(ctx.threadId, `❌ OpenCode 离线
-
-无法连接 OpenCode 服务。
-
-🔄 /retry — 重试连接`);
-        return;
-    }
-    await forwardToOpenCode(adapter, ctx, text, openCodeSessions);
-}
-
-async function forwardToOpenCode(adapter, ctx, text, openCodeSessions, expertPrompt) {
-    await adapter.sendTypingIndicator(ctx.threadId);
-    let openCodeSession = openCodeSessions.get(ctx.threadId);
-    if (!openCodeSession) {
-        console.log(`[feishu-forward] no in-memory session, trying to resume most recent...`);
-        try {
-            const sessions = await listOpenCodeSessions();
-            if (sessions.length > 0) {
-                const latest = sessions.sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0))[0];
-                const resumed = await resumeSession(latest.id);
-                if (resumed) {
-                    openCodeSession = resumed;
-                    openCodeSessions.set(ctx.threadId, openCodeSession);
-                    console.log(`[feishu-forward] resumed session ${latest.id.slice(0, 8)}`);
-                }
-            }
-        } catch (e) {
-            console.log(`[feishu-forward] failed to resume: ${e.message}`);
-        }
-        if (!openCodeSession) {
-            openCodeSession = await createSession(ctx.threadId, `Feishu ${ctx.threadId}`);
-            if (!openCodeSession) {
-                await adapter.reply(ctx.threadId, '❌ 无法创建 OpenCode 会话');
-                return;
-            }
-            openCodeSessions.set(ctx.threadId, openCodeSession);
-        }
-    }
-
-    let scopedText = text;
-
-    if (expertPrompt) {
-        scopedText = `${expertPrompt}\n\n${scopedText}`;
-    }
-
-    console.log(`📤 Forwarding to OpenCode: ${text.substring(0, 80)}...`);
-    try {
-        let response = await sendMessage(openCodeSession, scopedText, {
-            idleThreshold: expertPrompt ? 30 : 10,
-            onEvent: (event) => {
-                if (event.type === 'tool.call') {
-                    const props = event.properties || {};
-                    const toolName = props.name || props.tool_name || 'unknown';
-                    const input = props.input || {};
-                    let toolDesc = `🔧 执行工具: ${toolName}`;
-                    if (input.path) {
-                        toolDesc += `\n📁 ${input.path}`;
-                    }
-                    if (input.command) {
-                        toolDesc += `\n💻 ${input.command}`;
-                    }
-                    adapter.reply(ctx.threadId, toolDesc).catch(() => {});
-                    console.log(`[feishu-tool] Executing: ${toolName}`);
-                }
-                if (event.type && !event.type.includes('delta')) {
-                    console.log(`📡 Feishu Event: ${event.type}`);
-                }
-            },
-            onTextDelta: () => {},
-        }, ctx.threadId);
-        if (!response || typeof response !== 'string') {
-            await adapter.reply(ctx.threadId, '...');
-            return;
-        }
-        const trimmedResponse = response.trim();
-        if (!trimmedResponse) {
-            await adapter.reply(ctx.threadId, '...');
-            return;
-        }
-        // 超时/错误 → 清除 session 让下次重建
-        if (trimmedResponse.startsWith('⏰') || trimmedResponse.startsWith('❌')) {
-            console.error('[feishu-forward] Error response:', trimmedResponse);
-            openCodeSessions.delete(ctx.threadId);
-            await adapter.reply(ctx.threadId, trimmedResponse);
-            return;
-        }
-        if (trimmedResponse.endsWith(':') || trimmedResponse.endsWith('...')) {
-            console.log('[feishu-forward] 检测到不完整响应，等待补充...');
-            await new Promise(r => setTimeout(r, 5000));
-            try {
-                const msgsResult = await openCodeSession.client.session.messages({
-                    sessionID: openCodeSession.sessionId,
-                    limit: 5,
-                });
-                if (!msgsResult.error && msgsResult.data && msgsResult.data.length > 0) {
-                    for (let i = msgsResult.data.length - 1; i >= 0; i--) {
-                        const msg = msgsResult.data[i];
-                        if (msg.info?.role === 'assistant' && msg.parts) {
-                            const textParts = msg.parts.filter(p => p.type === 'text' && p.text).map(p => p.text);
-                            if (textParts.length > 0) {
-                                const newResponse = textParts.join('\n').trim();
-                                if (newResponse && newResponse !== trimmedResponse) {
-                                    response = newResponse;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            } catch (e) {
-                console.log('[feishu-forward] 无法检查额外响应');
-            }
-        }
-        const responseMsgs = splitMessage(response);
-        for (const m of responseMsgs) {
-            const trimmed = m.trim();
-            if (!trimmed) continue;
-            try {
-                await adapter.reply(ctx.threadId, m);
-            } catch (replyErr) {
-                console.error('[feishu-forward] 回复失败:', replyErr.message);
-            }
-        }
-    } catch (error) {
-        console.error('❌ Feishu 错误:', error);
-        await adapter.reply(ctx.threadId, `❌ 错误: ${error instanceof Error ? error.message : '未知错误'}`);
-    }
-}
-
-export { handleMessage, forwardToOpenCode };
+export const handleMessage = handler.handleMessage;
+export const forwardToOpenCode = handler.forwardToOpenCode;