@yvhitxcel/opencode-remote 0.17.0 → 0.18.0

package/dist/core/handler.js

@@ -0,0 +1,293 @@
+// Unified handler — platform-agnostic. Created via createHandler(deps).
+//   deps: { handleCommand, replyTo, wrapAdapterForShared }
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { splitMessage } from './notifications.js';
+import { createSession, sendMessage as sendToOpenCode, checkConnection, shareSession, listOpenCodeSessions, resumeSession, initOpenCode, resetOpenCode } from '../opencode/client.js';
+import { isAuthorized, hasOwner } from './auth.js';
+import { threadHistory, threadAgent } from './state.js';
+import { retryTransient, isTransientError } from './retry.js';
+import { detectCommand, EXPERT_SYSTEM_PROMPT, startTypingPing } from './router.js';
+import { hasPendingDecision, resolveDecision } from '../autonomous/decisions.js';
+import { registry } from './registry.js';
+import { incr, incrKey } from './stats.js';
+
+const IDLE_MODEL_HINT_MS = 5 * 60 * 1000;
+const threadLastActive = new Map();
+const threadLock = new Set();
+const THREAD_LOCK_TIMEOUT_MS = 10 * 60 * 1000; // 10 分钟线程锁超时
+
+// 定期清理超过 10 分钟的线程锁（防卡死）
+setInterval(() => {
+    const now = Date.now();
+    const staleLock = [];
+    for (const tid of threadLock) {
+        const lastActive = threadLastActive.get(tid) || 0;
+        if (lastActive > 0 && now - lastActive > THREAD_LOCK_TIMEOUT_MS) {
+            staleLock.push(tid);
+        }
+    }
+    for (const tid of staleLock) {
+        threadLock.delete(tid);
+        threadLastActive.delete(tid);
+        console.log(`[handler] Force-unlocked stale thread ${tid.slice(0, 8)} (>${THREAD_LOCK_TIMEOUT_MS / 1000}s)`);
+    }
+    // 清理超过 1 小时的 threadLastActive 条目
+    const cutoff = now - 3600_000;
+    for (const [tid, ts] of threadLastActive) {
+        if (ts < cutoff) threadLastActive.delete(tid);
+    }
+}, 60_000).unref?.();
+
+export function createHandler(deps) {
+    const { handleCommand, replyTo, wrapAdapterForShared } = deps;
+
+    async function fwdToOpenCode(adapter, ctx, text, openCodeSessions, expertPrompt) {
+        adapter.sendTypingIndicator(ctx.threadId).catch(() => {});
+        let openCodeSession = null;
+        let pendingModelHint = null;
+
+        const isShared = deps.isSharedMember ? deps.isSharedMember(ctx.threadId) : false;
+        const sharedRoom = deps.sharedRoom || { busy: false, session: null, members: [] };
+
+        if (isShared) {
+            if (sharedRoom.busy) { await adapter.reply(ctx.threadId, '⏳ 当前有人在用，请稍等...'); return; }
+            if (sharedRoom.session) { openCodeSession = sharedRoom.session; }
+            else {
+                openCodeSession = await createSession(`shared-${Date.now()}`, '共享会话');
+                if (!openCodeSession) { await adapter.reply(ctx.threadId, '❌ 无法创建共享会话'); return; }
+                sharedRoom.session = openCodeSession;
+                console.log(`✅ 共享会话已创建: ${openCodeSession.sessionId.slice(0, 8)}`);
+            }
+            sharedRoom.busy = true;
+        } else {
+            const lastActive = threadLastActive.get(ctx.threadId) || 0;
+            const isIdle = !expertPrompt && lastActive > 0 && (Date.now() - lastActive) > IDLE_MODEL_HINT_MS;
+            if (isIdle) pendingModelHint = true;
+
+            if (expertPrompt) {
+                openCodeSession = await createSession(`expert-${Date.now()}`, `专家评审 ${Date.now()}`);
+                if (!openCodeSession) { await adapter.reply(ctx.threadId, '❌ 无法创建评审会话'); return; }
+                console.log(`✅ 新建评审会话: ${openCodeSession.sessionId.slice(0, 8)}`);
+            } else {
+                openCodeSession = openCodeSessions.get(ctx.threadId);
+                if (!openCodeSession) {
+                    console.log(`[fwdToOpenCode] no session, trying to resume...`);
+                    try {
+                        const sessions = await listOpenCodeSessions();
+                        if (sessions.length > 0) {
+                            const latest = sessions.sort((a, b) => (b.lastActivity || 0) - (a.lastActivity || 0))[0];
+                            const resumed = await resumeSession(latest.id);
+                            if (resumed) { openCodeSession = resumed; openCodeSessions.set(ctx.threadId, openCodeSession); console.log(`[fwdToOpenCode] resumed session ${latest.id.slice(0, 8)}`); }
+                        }
+                    } catch (e) { console.log(`[fwdToOpenCode] failed to resume: ${e.message}`); }
+                    if (!openCodeSession) {
+                        console.log(`[fwdToOpenCode] creating new session for thread=${ctx.threadId}`);
+                        openCodeSession = await createSession(ctx.threadId, `Session ${ctx.threadId}`);
+                        if (!openCodeSession) { await adapter.reply(ctx.threadId, '❌ 无法创建 OpenCode 会话'); return; }
+                        openCodeSessions.set(ctx.threadId, openCodeSession);
+                    }
+                }
+            }
+        }
+
+        console.log(`📤 Message: → ${text}`);
+        let scopedText = text;
+        if (expertPrompt) scopedText = `${expertPrompt}\n\n${scopedText}`;
+
+        const typingPing = startTypingPing(adapter, ctx.threadId);
+        const startTs = Date.now();
+        const projectDir = globalThis.__autoProjectDir || process.cwd();
+        const inOpenchat = existsSync(`${projectDir}/bridge/bin/lab.mjs`);
+
+        const runLabStatus = async () => {
+            if (!inOpenchat) return;
+            try {
+                const out = execSync('node bridge/bin/lab.mjs status', { cwd: projectDir, encoding: 'utf8', timeout: 5000 });
+                replyTo(ctx.threadId, `⏳ ${formatLabOutput(out, 'status')}`, adapter).catch(() => {});
+            } catch (e) { replyTo(ctx.threadId, `⏳ lab status 失败: ${e.message}`, adapter).catch(() => {}); }
+        };
+        const heartbeat = setInterval(runLabStatus, 50_000);
+
+        const isConnError = (e) => /ECONNREFUSED|ECONNRESET|fetch failed|socket hang up|EHOSTUNREACH|ENETUNREACH/i.test(e?.message || '');
+
+        const result = await retryTransient(async () => {
+            try {
+                return await sendToOpenCode(openCodeSession, scopedText, {
+                    idleThreshold: expertPrompt ? 30 : 10,
+                    onNewContent: () => typingPing.poke(),
+                    onResponseMeta: (meta) => { if (pendingModelHint && meta.modelID) pendingModelHint = `🧠 ${meta.providerID}/${meta.modelID}`; },
+                    onEvent: (event) => {
+                        if (event.type === 'tool.call') {
+                            const props = event.properties || {};
+                            const tn = props.name || props.tool_name || 'unknown';
+                            const inp = props.input || {};
+                            let desc = `🔧 ${tn}${inp.path ? ` 📁${inp.path}` : ''}${inp.command ? ` 💻${inp.command}` : ''}`;
+                            console.log(`[→tool] ${desc}`);
+                            (isShared ? [...sharedRoom.members] : [ctx.threadId]).forEach(tid => replyTo(tid, desc, adapter).catch(e => console.error('[→tool] fail:', e.message)));
+                            typingPing.poke();
+                        }
+                    },
+                }, ctx.threadId);
+            } catch (e) {
+                if (isConnError(e)) {
+                    console.warn('[fwdToOpenCode] Connection error, reinit OpenCode...');
+                    try { const fresh = await initOpenCode(); if (fresh?.client && openCodeSession) { openCodeSession.client = fresh.client; openCodeSession.server = fresh.server; } } catch (e) { console.debug('[fwdToOpenCode] reinit failed:', e.message); }
+                }
+                throw e;
+            }
+        }, {
+            maxAttempts: 2, baseDelayMs: 2000,
+            onRetry: (err, attempt, delay) => {
+                incr('retries');
+                incrKey('errorsByCode', err.name || err.code || 'Unknown');
+                console.log(`[retry] error, attempt ${attempt}, retry in ${delay}ms: ${err.message}`);
+                adapter.reply(ctx.threadId, `⚠️ 请求失败，${Math.round(delay/1000)}s 后重试 (${attempt}/2)`).catch(() => {});
+            },
+        }).catch(e => {
+            console.error('[fwdToOpenCode] error:', e.message);
+            incrKey('errorsByCode', e.name || e.code || 'Unknown');
+            // 客户端超时 / AbortError → 自动重启 OpenCode 服务（防卡死）
+            if (/AbortError|aborted/i.test(e.message)) {
+                incr('opencodeRestarts');
+                resetOpenCode();  // 清空缓存 singleton，initOpenCode 才能真正重启
+                try { globalThis.__opencodeServer?.kill?.('SIGKILL'); } catch {}
+                setTimeout(() => initOpenCode().catch(() => {}), 1000);
+            }
+            return `❌ ${e.message || e}`;
+        });
+
+        clearInterval(heartbeat);
+        typingPing.done();
+
+        const replyTargets = isShared ? [...sharedRoom.members] : [ctx.threadId];
+        if (isShared) sharedRoom.busy = false;
+
+        const finalText = (result || '').trim();
+        console.log(`📥 AI response (${finalText.length} chars): ${finalText.slice(0, 200)}...`);
+        const displayText = typeof pendingModelHint === 'string' ? `${pendingModelHint}\n${finalText}` : finalText;
+
+        if (!finalText || finalText.startsWith('⏰') || finalText.startsWith('❌')) {
+            if (!isShared) openCodeSessions.delete(ctx.threadId);
+            // 不替 LLM 编空响应消息：sendToOpenCode 已透传真实错误或返回空字符串
+            if (finalText) replyTargets.forEach(tid => replyTo(tid, finalText, adapter).catch(e => console.error('[reply] fail:', e.message)));
+        } else {
+            splitMessage(displayText).forEach(m => m.trim() && replyTargets.forEach(tid => replyTo(tid, m, adapter).catch(e => console.error('[reply] fail:', e.message))));
+        }
+
+        threadLastActive.set(ctx.threadId, Date.now());
+
+        if (finalText.length > 0 && !finalText.startsWith('❌') && !finalText.startsWith('⏰')) {
+            const shareUrl = await shareSession(openCodeSession);
+            if (shareUrl) { try { await adapter.reply(ctx.threadId, `🔗 ${shareUrl}`); } catch (e) { console.error('[fwdToOpenCode] share URL reply failed:', e.message); } }
+        }
+    }
+
+    async function handleMsg(adapter, ctx, text, openCodeSessions, platform = 'weixin') {
+        // Stats: count every incoming message
+        incr('messagesReceived');
+
+        // 阶段 1: 所有系统指令都不阻塞，先于 lock 处理
+        // - /z 调用 fwdToOpenCode（不 acquire lock）
+        // - detectCommand 命中任何命令都直接处理
+        const trimmedLower = text.trim().toLowerCase();
+
+        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) {
+                await adapter.reply(ctx.threadId, `✅ 自定义专家 prompt (${arg.length}字)，本消息生效`);
+                await fwdToOpenCode(adapter, ctx, text, openCodeSessions, arg);
+            } else {
+                await adapter.reply(ctx.threadId, '✅ 专家评审已启动');
+                await fwdToOpenCode(adapter, ctx, text, openCodeSessions, EXPERT_SYSTEM_PROMPT);
+            }
+            return;
+        }
+
+        const detected = detectCommand(text);
+        if (detected) {
+            const cmdAdapter = deps.isSharedMember ? wrapAdapterForShared(adapter, ctx.threadId) : adapter;
+            const handled = await handleCommand(cmdAdapter, ctx, platform, detected.name, detected.arg, openCodeSessions);
+            if (handled) return;
+        }
+
+        // 阶段 2: 普通消息才加 lock
+        if (threadLock.has(ctx.threadId)) {
+            console.log(`[handler] thread ${ctx.threadId.slice(0, 8)} busy, skipping`);
+            return;
+        }
+        threadLock.add(ctx.threadId);
+        try {
+        const expertTriggers = ['z', 'Z', '叫全部专家', '叫所有专家', '呼叫专家点评', '专家点评', '专家意见', 'call all experts', 'expert review', '专家会诊', '团队评审', '代码审查', '全员review', 'review all', '请专家', '叫专家', '找专家', 'expert'];
+        let expertPrompt = null;
+
+        if (expertTriggers.some(t => trimmedLower.includes(t))) expertPrompt = EXPERT_SYSTEM_PROMPT;
+
+        if (hasPendingDecision(ctx.threadId)) {
+            if (/^\d+$/.test(text.trim())) { if (resolveDecision(ctx.threadId, text.trim())) return; }
+            if (/^\/(\d+)$/.test(text.trim())) { if (resolveDecision(ctx.threadId, text.trim().slice(1))) return; }
+        }
+
+        if (!isAuthorized(platform, ctx.userId)) {
+            incr('authRejections');
+            if (!hasOwner(platform)) { await adapter.reply(ctx.threadId, '🔐 请先发送 /start 进行安全认证'); return; }
+            if (!deps.isSharedMember?.(ctx.threadId)) { await adapter.reply(ctx.threadId, '🚫 你无权使用此 bot'); return; }
+        }
+
+        const activeAgentName = threadAgent.get(ctx.threadId);
+
+        if (activeAgentName && activeAgentName !== 'opencode') {
+            const agent = registry.findAgent(activeAgentName);
+            if (agent) {
+                const available = await agent.isAvailable().catch(() => false);
+                if (available) {
+                    adapter.sendTypingIndicator(ctx.threadId).catch(() => {});
+                    const t0 = Date.now();
+                    const hbDir = globalThis.__autoProjectDir || process.cwd();
+                    const hbLab = existsSync(`${hbDir}/bridge/bin/lab.mjs`);
+                    const heartbeat = setInterval(() => {
+                        if (hbLab) { try { const out = execSync('node bridge/bin/lab.mjs status', { cwd: hbDir, encoding: 'utf8', timeout: 5000 }); adapter.reply(ctx.threadId, `⏳ ${activeAgentName} · ${formatLabOutput(out, 'status')}`).catch(() => {}); return; } catch (e) { adapter.reply(ctx.threadId, `⏳ ${activeAgentName} lab status 失败: ${e.message}`).catch(() => {}); return; } }
+                    }, 50_000);
+
+                    const history = threadHistory.get(ctx.threadId) || [];
+
+                    try {
+                        const response = await retryTransient(() => agent.sendPrompt(activeAgentName, text, history, { projectDir: globalThis.__autoProjectDir, threadId: ctx.threadId }), {
+                            maxAttempts: 2, baseDelayMs: 2000, onRetry: (err, attempt, delay) => { adapter.reply(ctx.threadId, `⚠️ ${activeAgentName} 失败，${Math.round(delay/1000)}s 后重试 (${attempt}/2)`).catch(() => {}); },
+                        });
+                        clearInterval(heartbeat);
+                        console.log(`📥 AI response (${(response || '').length} chars): ${(response || '').slice(0, 200)}...`);
+                        history.push({ role: 'user', content: text }, { role: 'assistant', content: response || '' });
+                        threadHistory.set(ctx.threadId, history);
+                        splitMessage(response || '无响应').forEach(chunk => adapter.reply(ctx.threadId, chunk));
+                    } catch (error) {
+                        clearInterval(heartbeat);
+                        console.error(`[${activeAgentName}] ❌ ${error.message}`);
+                        await adapter.reply(ctx.threadId, `❌ ${activeAgentName} 错误: ${error.message}`);
+                    }
+                    return;
+                }
+            }
+            threadAgent.delete(ctx.threadId);
+        }
+
+        const connected = await checkConnection();
+        if (!connected) { await adapter.reply(ctx.threadId, '❌ OpenCode 离线，请检查服务是否运行'); return; }
+        await fwdToOpenCode(adapter, ctx, text, openCodeSessions);
+        } finally { threadLock.delete(ctx.threadId); }
+    }
+
+    return { handleMessage: handleMsg, forwardToOpenCode: fwdToOpenCode };
+}
+
+export function formatLabOutput(out, subCmd) {
+    const trimmed = (out || '').trim();
+    if (!trimmed) return '(空)';
+    try {
+        const obj = JSON.parse(trimmed);
+        if (obj && typeof obj.total === 'number') return `总计 ${obj.total} · 待 ${obj.pending || 0} · 跑 ${obj.running || 0} · 完成 ${obj.done || 0} · 失败 ${obj.failed || 0}`;
+    } catch (e) { console.debug('[formatLabOutput] Not JSON:', e.message); }
+    const oneline = trimmed.replace(/\s+/g, ' ').trim();
+    return oneline.length > 1800 ? oneline.slice(0, 1800) + '...' : oneline;
+}

package/dist/core/log.js

@@ -0,0 +1,92 @@
+// File-based logger with daily rotation
+// Writes to ~/.opencode-remote/logs/bot-YYYY-MM-DD.log
+import { existsSync, mkdirSync, statSync, createWriteStream, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const LOG_DIR = join(homedir(), '.opencode-remote', 'logs');
+const MAX_LOG_SIZE = 5 * 1024 * 1024;  // 5MB per file, rotate
+const KEEP_FILES = 7;                    // 保留最近 7 天
+
+let currentDate = '';
+let currentStream = null;
+let currentSize = 0;
+
+function getDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+
+function ensureLogFile() {
+    if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+    const today = getDate();
+    if (currentDate === today && currentStream) return;
+    if (currentStream) {
+        try { currentStream.end(); } catch {}
+    }
+    currentDate = today;
+    const logPath = join(LOG_DIR, `bot-${today}.log`);
+    if (existsSync(logPath)) {
+        currentSize = statSync(logPath).size;
+    } else {
+        currentSize = 0;
+    }
+    currentStream = createWriteStream(logPath, { flags: 'a' });
+}
+
+function rotate() {
+    if (currentStream) {
+        try { currentStream.end(); } catch {}
+        currentStream = null;
+    }
+    ensureLogFile();
+}
+
+function format(level, msg, meta) {
+    const ts = new Date().toISOString();
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+    return `${ts} [${level}] ${msg}${metaStr}\n`;
+}
+
+function write(level, msg, meta) {
+    try {
+        ensureLogFile();
+        const line = format(level, msg, meta);
+        if (currentSize + line.length > MAX_LOG_SIZE) {
+            rotate();
+            ensureLogFile();
+        }
+        currentStream.write(line);
+        currentSize += line.length;
+    } catch (e) {
+        // 写日志失败不能崩主进程
+        console.error('[log] Write failed:', e.message);
+    }
+}
+
+export const logger = {
+    info(msg, meta) { write('INFO', msg, meta); },
+    warn(msg, meta) { write('WARN', msg, meta); },
+    error(msg, meta) { write('ERROR', msg, meta); },
+    debug(msg, meta) { write('DEBUG', msg, meta); },
+};
+
+export function initLogger() {
+    ensureLogFile();
+    console.log(`[log] Writing to ${LOG_DIR}/bot-${getDate()}.log`);
+}
+
+// 清理旧日志
+export function cleanOldLogs() {
+    if (!existsSync(LOG_DIR)) return;
+    const files = readdirSync(LOG_DIR);
+    const today = new Date();
+    for (const f of files) {
+        const m = f.match(/^bot-(\d{4}-\d{2}-\d{2})\.log$/);
+        if (!m) continue;
+        const fileDate = new Date(m[1]);
+        const daysAgo = Math.floor((today.getTime() - fileDate.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysAgo > KEEP_FILES) {
+            try { unlinkSync(join(LOG_DIR, f)); } catch {}
+        }
+    }
+}

package/dist/core/lru.js

@@ -0,0 +1,98 @@
+// LRU + TTL Map for session storage
+// - Caps total size to prevent memory leaks
+// - Evicts least recently used when over capacity
+// - Auto-expires entries that haven't been touched in TTL ms
+export class LRUSessionMap {
+    constructor({ maxSize = 100, ttlMs = 30 * 60 * 1000, name = 'sessions' } = {}) {
+        this.maxSize = maxSize;
+        this.ttlMs = ttlMs;
+        this.name = name;
+        this._map = new Map();  // key -> { value, lastUsed }
+    }
+
+    _isExpired(entry) {
+        return Date.now() - entry.lastUsed > this.ttlMs;
+    }
+
+    _evictExpired() {
+        for (const [k, v] of this._map.entries()) {
+            if (this._isExpired(v)) this._map.delete(k);
+        }
+    }
+
+    get(key) {
+        const entry = this._map.get(key);
+        if (!entry) return undefined;
+        if (this._isExpired(entry)) {
+            this._map.delete(key);
+            return undefined;
+        }
+        entry.lastUsed = Date.now();
+        // 移到队尾 (LRU)
+        this._map.delete(key);
+        this._map.set(key, entry);
+        return entry.value;
+    }
+
+    set(key, value) {
+        if (this._map.has(key)) this._map.delete(key);
+        this._map.set(key, { value, lastUsed: Date.now() });
+        // 超上限淘汰最旧
+        while (this._map.size > this.maxSize) {
+            const oldest = this._map.keys().next().value;
+            this._map.delete(oldest);
+            console.log(`[lru:${this.name}] evicted ${oldest} (size > ${this.maxSize})`);
+        }
+    }
+
+    delete(key) {
+        return this._map.delete(key);
+    }
+
+    has(key) {
+        const entry = this._map.get(key);
+        if (!entry) return false;
+        if (this._isExpired(entry)) {
+            this._map.delete(key);
+            return false;
+        }
+        return true;
+    }
+
+    get size() {
+        return this._map.size;
+    }
+
+    keys() {
+        this._evictExpired();
+        return this._map.keys();
+    }
+
+    values() {
+        this._evictExpired();
+        const out = [];
+        for (const v of this._map.values()) out.push(v.value);
+        return out;
+    }
+
+    entries() {
+        this._evictExpired();
+        const out = [];
+        for (const [k, v] of this._map.entries()) out.push([k, v.value]);
+        return out;
+    }
+
+    clear() {
+        this._map.clear();
+    }
+
+    // 定期清理 (调用方负责 setInterval)
+    cleanup() {
+        const before = this._map.size;
+        this._evictExpired();
+        const after = this._map.size;
+        if (before !== after) {
+            console.log(`[lru:${this.name}] cleaned ${before - after} expired entries`);
+        }
+    }
+}

package/dist/core/qiniu.js

@@ -238,10 +238,10 @@ export function findBuildOutputs(projectDir, maxDepth = 5) {
                             time: stat.mtime.getTime(),
                             relativePath: fullPath.replace(projectDir, '').replace(/^[\\\/]/, '')
                         });
-                    } catch (e) {}
+                    } catch (e) { console.debug('[qiniu] stat error:', e.message); }
                 }
             }
-        } catch (e) {}
+        } catch (e) { console.debug('[qiniu] scan error:', e.message); }
     }
 
     for (const pattern of searchDirPatterns) {

package/dist/core/retry.js

@@ -0,0 +1,46 @@
+// Retry helper — exponential backoff for transient errors
+const TRANSIENT_PATTERNS = [
+    'AbortError', 'aborted',
+    'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE',
+    'fetch failed', 'socket hang up',
+    'rate limit', '429', '502', '503', '504',
+    'Free usage exceeded', 'quota exceeded',
+    'retry attempt', 'retrying in',
+    'insufficient_quota', 'Payment Required',
+    'timeout', 'Timeout',
+];
+
+export function isTransientError(err) {
+    if (!err) return false;
+    const msg = (err.message || String(err)).toLowerCase();
+    return TRANSIENT_PATTERNS.some(p => msg.includes(p.toLowerCase()));
+}
+
+/**
+ * Retry an async function with exponential backoff.
+ * Only retries on transient errors. Resolves on first success.
+ * @template T
+ * @param {() => Promise<T>} fn
+ * @param {object} [opts]
+ * @param {number} [opts.maxAttempts=3]
+ * @param {number} [opts.baseDelayMs=1000]
+ * @param {number} [opts.maxDelayMs=8000]
+ * @param {(err: any, attempt: number, nextDelay: number) => void} [opts.onRetry]
+ * @returns {Promise<T>}
+ */
+export async function retryTransient(fn, opts = {}) {
+    const { maxAttempts = 3, baseDelayMs = 1000, maxDelayMs = 8000, onRetry } = opts;
+    let lastErr;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        } catch (err) {
+            lastErr = err;
+            if (attempt >= maxAttempts || !isTransientError(err)) throw err;
+            const delay = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt - 1));
+            if (onRetry) onRetry(err, attempt, delay);
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+    throw lastErr;
+}

package/dist/core/router.js

@@ -2,6 +2,7 @@
 import { registry } from './registry.js';
 import { initOpenCode, checkConnection, setThreadModel, getThreadModel, getRecentModels, setRawDebug, isRawDebug } from '../opencode/client.js';
 import { formatTaskCompletion } from './notifications.js';
+import { existsSync } from 'fs';
 
 export const COMMAND_ALIASES = {
     start: ['start'],
@@ -14,15 +15,18 @@ export const COMMAND_ALIASES = {
     cx: ['cx'],
     copilot: ['copilot'],
     model: ['model'],
-    expert: ['expert', 'z', 'Z', 'review'],
     raw: ['raw'],
     think: ['think'],
     share: ['share'],
-    invite: ['invite'],
+    bind: ['bind'],
     push: ['push'],
     who: ['who'],
     deploy: ['deploy', 'gitpush'],
     auto: ['auto'],
+    lab: ['lab'],
+    esc: ['esc', 'abort', 'stop'],
+    status: ['status'],
+    info: ['info', 'stats', 'health'],
 };
 
 export const EXPERT_SYSTEM_PROMPT = `你是一个专家评审系统。用户消息含触发词（z/c/叫全部专家/专家点评）时启动评审，前后可带具体问题则聚焦该问题。
@@ -120,7 +124,6 @@ const COMMAND_HELP = {
     cx: '使用 Codex',
     copilot: '使用 Copilot',
     model: '切换模型',
-    expert: '专家评审(z/叫全部专家)',
     raw: '开启/关闭 RAW 调试输出',
     think: '开启/关闭思考过程显示',
     share: '共享会话管理',
@@ -129,6 +132,10 @@ const COMMAND_HELP = {
     who: '查看在线用户',
     deploy: '推送代码到所有 Git 镜像',
     auto: '自主开发模式',
+    lab: '实验室（状态/队列/历史等）',
+    esc: '中断当前活跃任务',
+    status: '查看 OpenCode 会话状态',
+    info: 'bot 状态/统计/版本/内存',
 };
 
 const COMMAND_MAP = {};
@@ -157,13 +164,16 @@ export function startTypingPing(adapter, threadId) {
 
 export function getHelpText() {
     const lines = ['📖 指令\n'];
+    const hasLab = existsSync('bridge/bin/lab.mjs');
     const groups = [
         ['start', 'help'],                    // 系统
-        ['reset', 'restart', 'diagnose'],     // 会话
+        ['reset', 'restart', 'diagnose', 'esc', 'status', 'info'],     // 会话
         ['oc', 'cc', 'cx', 'copilot'],        // Agent
         ['model', 'raw', 'think'],            // 配置
         ['share', 'bind', 'push', 'who'],  // 协作
-        ['expert', 'deploy', 'auto'],       // 专家+部署+自主
+        hasLab
+            ? ['deploy', 'auto', 'lab']
+            : ['deploy', 'auto'],   // 专家+部署+自主
     ];
     let first = true;
     for (const group of groups) {
@@ -178,6 +188,7 @@ export function getHelpText() {
         }
     }
     lines.push('');
+    lines.push('🤖 专家评审: 发"z"或"叫全部专家"即可');
     lines.push('💬 直接发消息给 AI!');
     return lines.join('\n');
 }
@@ -188,7 +199,8 @@ export function detectCommand(text) {
         return { name: 'help', arg: '' };
     }
     if (/^[.。\/]/.test(trimmed)) {
-        const cmd = trimmed.slice(1).trim();
+        let cmd = trimmed.slice(1).trim();
+        if (cmd.startsWith('/')) cmd = cmd.slice(1).trim();
         const parts = cmd.split(/\s+/);
         const name = COMMAND_MAP[parts[0].toLowerCase()];
         if (name) {