@yvhitxcel/opencode-remote 0.16.3 → 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

@@ -1,9 +1,9 @@
 import * as lark from '@larksuiteoapi/node-sdk';
-import { initSessionManager } from '../core/session.js';
 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;
@@ -46,8 +46,8 @@ export async function startFeishuBot(botConfig) {
         appId: config.feishuAppId,
         appSecret: config.feishuAppSecret,
     });
-    initSessionManager(config);
-    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();
@@ -86,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 };