@yvhitxcel/opencode-remote 0.16.3 → 0.18.0

package/dist/core/crypto.js

@@ -0,0 +1,80 @@
+// AES-256-GCM credential encryption
+// Key derived from machine fingerprint + user-level salt
+// Format: {iv, tag, data} all base64
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash } from 'crypto';
+import { hostname, userInfo, homedir, platform } from 'os';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const SALT_FILE = join(homedir(), '.opencode-remote', '.cred_salt');
+
+function getMachineFingerprint() {
+    const parts = [
+        hostname(),
+        userInfo().username,
+        platform(),
+        homedir(),
+        process.env.COMPUTERNAME || '',
+    ].join('|');
+    return createHash('sha256').update(parts).digest('hex');
+}
+
+function getOrCreateSalt() {
+    const dir = join(homedir(), '.opencode-remote');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    if (existsSync(SALT_FILE)) {
+        return readFileSync(SALT_FILE);
+    }
+    const salt = randomBytes(32);
+    writeFileSync(SALT_FILE, salt, { mode: 0o600 });
+    return salt;
+}
+
+function deriveKey() {
+    const fp = getMachineFingerprint();
+    const salt = getOrCreateSalt();
+    return scryptSync(fp, salt, 32, { N: 16384, r: 8, p: 1 });
+}
+
+/**
+ * Encrypt a plain string with AES-256-GCM
+ * @param {string} plaintext
+ * @returns {string} JSON envelope {iv, tag, data} all base64
+ */
+export function encryptCredential(plaintext) {
+    if (plaintext == null) return null;
+    const key = deriveKey();
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return JSON.stringify({
+        v: 1,
+        iv: iv.toString('base64'),
+        tag: tag.toString('base64'),
+        data: enc.toString('base64'),
+    });
+}
+
+export function decryptCredential(envelope) {
+    if (envelope == null) return null;
+    // 兼容旧明文 (不是 JSON envelope)
+    if (typeof envelope === 'string' && !envelope.startsWith('{')) {
+        return envelope;
+    }
+    try {
+        const obj = typeof envelope === 'string' ? JSON.parse(envelope) : envelope;
+        if (obj.v !== 1) return null;
+        const key = deriveKey();
+        const iv = Buffer.from(obj.iv, 'base64');
+        const tag = Buffer.from(obj.tag, 'base64');
+        const data = Buffer.from(obj.data, 'base64');
+        const decipher = createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        const dec = Buffer.concat([decipher.update(data), decipher.final()]);
+        return dec.toString('utf8');
+    } catch (e) {
+        console.error('[crypto] decrypt failed:', e.message);
+        return null;
+    }
+}

package/dist/core/git-push.js

@@ -0,0 +1,143 @@
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DEFAULT_MIRRORS = [
+    'gh-proxy.com',
+    'ghfast.top',
+    'mirror.ghproxy.com',
+    'ghproxy.com',
+    'github.akams.cn',
+    'gh-proxy.ygxz.in',
+    'codeload.github.com',
+    'github.com',
+];
+
+function loadCustomMirrors() {
+    const localMirrors = join(process.cwd(), '.gitmirrors');
+    if (existsSync(localMirrors)) {
+        return readFileSync(localMirrors, 'utf-8').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+    }
+    const globalEnv = join(homedir(), '.opencode-remote', '.env');
+    if (existsSync(globalEnv)) {
+        const m = readFileSync(globalEnv, 'utf-8').match(/GIT_MIRRORS=(.+)/);
+        if (m) return m[1].split(',').map(s => s.trim()).filter(Boolean);
+    }
+    if (process.env.GIT_MIRRORS) return process.env.GIT_MIRRORS.split(',').map(s => s.trim()).filter(Boolean);
+    return DEFAULT_MIRRORS;
+}
+
+function parseOriginUrl(url) {
+    // HTTPS:  https://TOKEN@github.com/user/repo.git
+    //         https://github.com/user/repo.git
+    // SSH:    git@github.com:user/repo.git
+    let auth = '';
+    let host = '';
+    let userRepo = '';
+
+    if (url.includes('://')) {
+        const match = url.match(/^(https?:\/\/)([^@]*@)?([^\/]+)(\/.*)$/);
+        if (!match) return null;
+        const protocol = match[1];
+        const token = match[2] || '';
+        host = match[3];
+        userRepo = match[4];
+        auth = protocol + token;
+    } else {
+        const match = url.match(/^([^@]+@)?([^:]+):(.+)$/);
+        if (!match) return null;
+        auth = match[1] || '';
+        host = match[2];
+        userRepo = '/' + match[3];
+    }
+
+    return { auth, host, userRepo };
+}
+
+// Whitelist validation for git refs (branch names, remote names). Git itself
+// also validates these, but we add a defensive check so a malicious caller
+// can't pass things like "main && rm -rf /" (even though execFileSync + args
+// array would block shell injection on its own, this is defense in depth).
+function isValidGitRef(s) {
+    return typeof s === 'string' && /^[a-zA-Z0-9._\/-]+$/.test(s) && s.length > 0 && s.length < 256;
+}
+
+/**
+ * @param {{ message?: string, branch?: string }} [opts]
+ */
+export function gitPush(opts) {
+    const { message, branch } = opts || {};
+    const cwd = process.cwd();
+
+    let currentBranch;
+    try {
+        currentBranch = execFileSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf-8' }).trim();
+    } catch (e) {
+        return { ok: false, error: '不在 git 仓库中' };
+    }
+    const targetBranch = branch || currentBranch;
+
+    // Defensive validation of branch name (caller-supplied)
+    if (branch && !isValidGitRef(branch)) {
+        return { ok: false, error: `非法 branch 名称: ${branch}` };
+    }
+
+    const status = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8' }).trim();
+    if (status) {
+        execFileSync('git', ['add', '-A'], { cwd });
+        const msg = (message || `auto update ${new Date().toISOString().slice(0, 19)}`).replace(/"/g, '\\"');
+        // execFileSync with args array — msg is passed as a single argv element
+        // to git, never interpreted by shell. Even if msg contains `;` or `&`
+        // or shell metachars, git just stores it as the commit message.
+        execFileSync('git', ['commit', '-m', msg], { cwd, stdio: 'pipe' });
+    }
+
+    let originUrl;
+    try {
+        originUrl = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd, encoding: 'utf-8' }).trim();
+    } catch (e) {
+        return { ok: false, error: '没有找到 remote origin' };
+    }
+
+    const parsed = parseOriginUrl(originUrl);
+    if (!parsed) {
+        return { ok: false, error: `无法解析 remote URL: ${originUrl}` };
+    }
+
+    // 从 gh CLI 提取 token（如果 remote URL 里没有的话）
+    let pushAuth = parsed.auth;
+    if (originUrl.startsWith('https://') && !originUrl.includes('@')) {
+        try {
+            const ghToken = execFileSync('gh', ['auth', 'token'], { encoding: 'utf-8' }).trim();
+            if (ghToken) {
+                pushAuth = `https://${ghToken}@`;
+            }
+        } catch (_) { /* gh not available */ }
+    }
+
+    const mirrors = loadCustomMirrors();
+    const results = [];
+
+    for (const host of mirrors) {
+        const pushUrl = pushAuth + host + parsed.userRepo;
+        const remoteName = `m_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        console.log(`[git-push] trying ${host}...`);
+        try {
+            // All execFileSync calls below use args arrays — no shell interpolation.
+            // remoteName, pushUrl, targetBranch, branch are passed as argv elements,
+            // never interpreted by shell.
+            execFileSync('git', ['remote', 'add', remoteName, pushUrl], { cwd, stdio: 'pipe' });
+            execFileSync('git', ['push', remoteName, targetBranch, '--follow-tags'], { cwd, stdio: 'pipe', timeout: 30000 });
+            execFileSync('git', ['remote', 'remove', remoteName], { cwd, stdio: 'pipe' });
+            results.push({ host, ok: true, url: pushUrl });
+            return { ok: true, results, successUrl: pushUrl };
+        } catch (e) {
+            try { execFileSync('git', ['remote', 'remove', remoteName], { cwd, stdio: 'pipe' }); } catch (_) {}
+            const msg = e.stderr?.toString()?.trim() || e.message || '';
+            results.push({ host, ok: false, url: pushUrl, error: msg.slice(0, 150) });
+        }
+    }
+
+    return { ok: false, results };
+}

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 {}
+        }
+    }
+}