lark-remote 0.1.10 → 0.1.12

package/dist/runner/kimi/acp/runner.js

@@ -11,19 +11,31 @@
  * pattern, same forceFinish/stopRequested semantics, same turn idle timeout,
  * same ConnectionLostError retry.
  */
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager as KimiAcpConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
-import { RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
+import { NotificationMethod, RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
 import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import { ProcessStopper } from '../../common/process-stopper.js';
 /** R2: how long to wait for the background compaction record after the
  *  /compact prompt settles (design doc §6.1). Real kimi 0.36.0 lands
  *  context.apply_compaction ~8s after end_turn. */
 const COMPACT_POLL_TIMEOUT_MS = 30_000;
 /** Poll interval for the wire.jsonl compaction record. */
 const COMPACT_POLL_INTERVAL_MS = 1_000;
+// =============================================================================
+// kimi terminal 工具（Bash 执行下放客户端）
+// 契约：kimi-code/packages/acp-server/src/acp-terminal/acpTerminalRunner.ts
+//   一次性 bash -c <script>，非交互 PTY、无 stdin；服务端每 250ms 轮询
+//   terminal/output，客户端只回累计 stdout。创建/轮询/等待/杀/释放五个
+//   reverse RPC 全部由本 runner 本地 spawn 子进程实现。
+// =============================================================================
+/** terminal/create 未显式给 outputByteLimit 时的缓冲上限（对齐服务端默认 4MB）。 */
+const TERMINAL_DEFAULT_OUTPUT_LIMIT = 4 * 1024 * 1024;
 /**
  * Map user-facing permission mode to ACP mode id.
  *
@@ -162,6 +174,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     compactPollTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     pendingApprovals = new Map();
+    /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    terminals = new Map();
+    /** terminalId 自增序号（term-1, term-2, …）。 */
+    terminalSeq = 0;
+    /**
+     * kimi 服务端对 Bash 工具的 tool_call/tool_call_update 通知（title='Bash'）。
+     * Bash 的真实执行走 terminal/* reverse RPC 下放客户端，tool 事件由本 runner
+     * 自产（tool_use 带命令、tool_result 带本地输出）；这些通知必须过滤，否则
+     * 卡片出现双份 Bash 面板（通知版无 rawInput、terminal embed 无 rawOutput，
+     * 只能渲染「_无输出_」）。收集到的 toolCallId 用于过滤对应的 update。
+     */
+    bashToolCallIds = new Set();
+    /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
+    activeCwd = null;
+    processStopper = new ProcessStopper({ graceMs: 2_000 });
     /** Tracker for the in-flight prompt request — needed for cancellation. */
     promptSettled = false;
     constructor(opts) {
@@ -178,8 +205,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             initializeParams: {
                 protocolVersion: 1,
                 clientCapabilities: {
+                    // fs 保持关闭：kimi 服务端在 fs 能力为 false 时走本地磁盘兜底
+                    // （acpFsService.ts AcpHostFileSystem.inner），kimi 是本地子进程，
+                    // 本地盘即工作区盘，读写正常；声明 true 则服务端改发 fs/* reverse
+                    // RPC，lark-remote 未实现该面，文件读写会 METHOD_NOT_FOUND 失败。
                     fs: { readTextFile: false, writeTextFile: false },
-                    terminal: false,
+                    // terminal 常开：yolo/auto 自主跑命令；manual 走 session/request_permission 审批。
+                    terminal: true,
                     // AskUserQuestion 走 elicitation form（原生多题+多选；form 失败时
                     // kimi 服务端自动回退 request_permission 桥，客户端两者都处理）。
                     // 注意：ACP SDK 对 elicitation.form 的 zod schema 是对象
@@ -223,6 +255,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.currentTranslator = null;
         this.promptSettled = false;
         this.activeSessionId = null;
+        this.activeCwd = null;
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -231,6 +264,8 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.connectionManager.notifyIdle(cwd);
     }
     async disposeConnections() {
+        // 关闭前 kill/release 所有存活 terminal，避免孤儿 bash 进程。
+        await this.cleanupTerminals();
         await this.connectionManager.disposeAll();
     }
     /**
@@ -245,10 +280,14 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             const client = await this.connectionManager.acquire(opts.cwd);
             this.connectionManager.notifyActivity(opts.cwd);
             this.currentClient = client;
+            this.activeCwd = opts.cwd;
             client.setHooks({
                 onNotification: (method, params) => this.handleNotification(method, params),
                 onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-                onClose: () => this.failTurn('Kimi ACP connection closed'),
+                onClose: () => {
+                    void this.cleanupTerminals();
+                    this.failTurn('Kimi ACP connection closed');
+                },
             });
             const sessionId = opts.sessionId;
             if (!sessionId) {
@@ -382,11 +421,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         const client = await this.connectionManager.acquire(opts.cwd);
         this.connectionManager.notifyActivity(opts.cwd);
         this.currentClient = client;
+        this.activeCwd = opts.cwd;
         client.setHooks({
             onNotification: (method, params) => this.handleNotification(method, params),
             onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
             onClose: () => {
                 getLogger().warn(`[${this.logTag}] client connection closed`);
+                void this.cleanupTerminals();
                 this.failTurn('Kimi ACP connection closed');
             },
         });
@@ -494,10 +535,61 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         getLogger().warn(`[${this.logTag}] compaction record not observed within ${this.compactPollTimeoutMs}ms (baseline=${baselineCount}); proceeding without confirmation`);
     }
     handleNotification(method, params) {
+        // Terminal-backed Bash 的通知走 runner 自产事件（见 bashToolCallIds），
+        // 不交给 translator；其余通知（Read/Edit/text/thinking）正常翻译。
+        if (method === NotificationMethod.SESSION_UPDATE && this.filterBashNotifications(params)) {
+            return;
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }
+    /**
+     * Filter kimi's own Bash tool notifications so the run card doesn't get a
+     * duplicate, output-less Bash panel alongside the runner-produced one.
+     *
+     * - tool_call title='Bash' → remember the toolCallId, drop the notification
+     *   (the tool_use comes from terminal/create with the real command).
+     * - tool_call_update for a remembered id → drop (streaming args deltas and
+     *   the terminal embed final update; the tool_result is emitted locally).
+     * Returns true when the notification should be swallowed.
+     */
+    filterBashNotifications(params) {
+        if (typeof params !== 'object' || params === null)
+            return false;
+        const update = params.update;
+        if (!update || typeof update !== 'object')
+            return false;
+        if (update.sessionUpdate === 'tool_call') {
+            if (update.title === 'Bash') {
+                if (typeof update.toolCallId === 'string') {
+                    this.bashToolCallIds.add(update.toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        if (update.sessionUpdate === 'tool_call_update') {
+            const toolCallId = update.toolCallId;
+            if (typeof toolCallId === 'string' && this.bashToolCallIds.has(toolCallId)) {
+                // 终态后清掉 id，避免集合随会话无限增长（漏清无碍：id 全局唯一）。
+                if (update.status === 'completed' || update.status === 'failed') {
+                    this.bashToolCallIds.delete(toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
     handleServerRequest(id, method, params) {
+        // kimi terminal 工具：Bash 执行下放客户端（acp-terminal reverse RPC）。
+        // 请求本身是纯 request/response I/O，不交给 translator（避免落入下方
+        // 「空事件 → 拒绝」兜底）；对应的 tool_use/tool_result 事件由
+        // handleTerminalCreate 自产（带本地命令与输出，见 bashToolCallIds）。
+        if (method.startsWith('terminal/')) {
+            void this.handleTerminalRequest(id, method, params);
+            return;
+        }
         const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
         if (events.length === 0) {
             // Unhandled/unsupported server request must be explicitly responded to
@@ -527,5 +619,221 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         }
         this.pushEvents(events);
     }
+    /**
+     * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
+     *
+     * 契约（kimi-code acp-terminal/acpTerminalRunner.ts）：
+     *   create → 立即回 {terminalId}，进程异步跑，不阻塞 RPC；
+     *   output → 回累计 stdout（非增量，服务端按 emitted 偏移切片）；
+     *   wait_for_exit → 未退出则等 exit 再回 {exitCode, signal}；
+     *   kill/release → 杀进程并回 {}。
+     */
+    async handleTerminalRequest(id, method, params) {
+        try {
+            switch (method) {
+                case ServerRequestMethod.TERMINAL_CREATE:
+                    this.handleTerminalCreate(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_OUTPUT:
+                    this.handleTerminalOutput(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_WAIT_FOR_EXIT:
+                    await this.handleTerminalWaitForExit(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_KILL:
+                    await this.handleTerminalKill(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_RELEASE:
+                    await this.handleTerminalRelease(id, params);
+                    return;
+                default:
+                    this.currentClient?.respondError(id, RpcErrorCode.METHOD_NOT_FOUND, `Unsupported server request: ${method}`);
+            }
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] terminal request failed method=${method}: ${err.message}`);
+            this.currentClient?.respondError(id, RpcErrorCode.INTERNAL_ERROR, `Terminal request failed: ${err.message}`);
+        }
+    }
+    /**
+     * terminal/create: spawn 一次性进程（bash -c <script>），流式累积
+     * stdout(+stderr) 到缓冲，立即回 {terminalId}。
+     */
+    handleTerminalCreate(id, params) {
+        const env = params.env
+            ? Object.fromEntries(params.env.map((e) => [e.name, e.value]))
+            : undefined;
+        const cwd = params.cwd ?? this.activeCwd ?? undefined;
+        const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
+        const proc = spawn(params.command, params.args ?? [], {
+            cwd,
+            env: env ? { ...process.env, ...env } : undefined,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // ProcessStopper 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
+            // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
+            // 与 JsonlRpcTransport / spawning-runner 的 detached:true 同模式。
+            detached: true,
+        });
+        // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
+        // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
+        const stdoutDecoder = new StringDecoder('utf8');
+        const stderrDecoder = new StringDecoder('utf8');
+        const append = (chunk, decoder) => {
+            if (handle.truncated)
+                return;
+            const remaining = handle.outputLimit - handle.outputBytes;
+            if (remaining > 0 && chunk.length <= remaining) {
+                handle.output += decoder.write(chunk);
+                handle.outputBytes += chunk.length;
+            }
+            else if (remaining > 0) {
+                // 只喂 remaining 字节；decoder 内部保留末尾不完整序列，不会在字节
+                // 边界产生替换符。outputBytes 按「喂入字节」计，保证不超过上限。
+                handle.output += decoder.write(chunk.subarray(0, remaining));
+                handle.outputBytes += remaining;
+            }
+            // 契约（手册）：truncated = 缓冲 >= limit——恰好填满也标 true。
+            if (handle.outputBytes >= handle.outputLimit)
+                handle.truncated = true;
+        };
+        proc.stdout?.on('data', (chunk) => append(chunk, stdoutDecoder));
+        proc.stderr?.on('data', (chunk) => append(chunk, stderrDecoder));
+        // spawn 失败（如 ENOENT）只发 'error' 不发 'exit'——一并 resolve，防止
+        // wait_for_exit 永久挂起（runner 层 ENOENT 兜底红线）。
+        // 用 resolveExit 承接，避免回调在 handle 初始化前引用它（TDZ）。
+        let resolveExit;
+        const exitPromise = new Promise((resolve) => {
+            resolveExit = resolve;
+        });
+        // 与 resolveExit 同款 TDZ 规避：tool_result 发射闭包在 terminalId 初始化
+        // 后赋值，exit/error 回调执行时经 emitResult 间接调用。
+        let emitTerminalResult = undefined;
+        const emitResult = () => {
+            emitTerminalResult?.();
+        };
+        const handle = {
+            proc,
+            output: '',
+            outputBytes: 0,
+            outputLimit,
+            truncated: false,
+            exitCode: null,
+            signal: null,
+            exitPromise,
+        };
+        proc.once('exit', (code, signal) => {
+            handle.exitCode = code;
+            handle.signal = signal;
+            resolveExit?.();
+            emitResult();
+        });
+        proc.once('error', (err) => {
+            getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
+            if (handle.exitCode === null && handle.signal === null) {
+                handle.exitCode = 1;
+                handle.signal = null;
+            }
+            resolveExit?.();
+            emitResult();
+        });
+        const terminalId = `term-${++this.terminalSeq}`;
+        this.terminals.set(terminalId, handle);
+        // Bash 工具事件由本 runner 自产（kimi 通知已过滤）：create 即推 tool_use
+        // 带真实命令，让 run 卡立刻出现可识别的 Bash 面板。
+        const script = Array.isArray(params.args) && params.args.length > 1 ? params.args[1] : params.command;
+        let resultEmitted = false;
+        emitTerminalResult = () => {
+            if (resultEmitted)
+                return;
+            resultEmitted = true;
+            this.pushEvents([
+                {
+                    type: 'user',
+                    message: {
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: terminalId,
+                                content: handle.output,
+                                is_error: handle.exitCode !== 0,
+                            },
+                        ],
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+            ]);
+        };
+        this.pushEvents([
+            {
+                type: 'assistant',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: terminalId,
+                            name: 'Bash',
+                            input: { command: script, cwd },
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ]);
+        getLogger().info(`[${this.logTag}] terminal created id=${terminalId} command=${params.command} args=${JSON.stringify(params.args ?? [])}`);
+        this.currentClient?.respond(id, { terminalId });
+    }
+    /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
+    handleTerminalOutput(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.currentClient?.respond(id, {
+            output: handle.output,
+            truncated: handle.truncated,
+            exitStatus: { exitCode: handle.exitCode, signal: handle.signal },
+        });
+    }
+    /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */
+    async handleTerminalWaitForExit(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await handle.exitPromise;
+        this.currentClient?.respond(id, { exitCode: handle.exitCode, signal: handle.signal });
+    }
+    /** terminal/kill: 立即杀进程组，回 {}。 */
+    async handleTerminalKill(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
+    async handleTerminalRelease(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.terminals.delete(params.terminalId);
+        // stop 对已退出进程是 no-op；仍在跑则立即 SIGTERM+SIGKILL。
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
+    async cleanupTerminals() {
+        const handles = [...this.terminals.values()];
+        this.terminals.clear();
+        for (const handle of handles) {
+            await this.processStopper.stop(handle.proc, { immediate: true });
+        }
+    }
 }
 //# sourceMappingURL=runner.js.map

package/dist/runner/opencode/acp/error-monitor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
+ * errors of the active ACP session and reports them immediately.
+ *
+ * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * to the client over the ACP protocol. Its session/update notifications are
+ * limited to content deltas (agent_message_chunk / agent_thought_chunk /
+ * tool_call / tool_call_update), usage and available-commands updates — there
+ * is no error/retry/status event type, and session/list carries no status.
+ * When a retryable provider error hits (e.g. opencode-go "Weekly usage limit
+ * reached"), the session enters a retry backoff (often the full reset time,
+ * ~1h) and session/prompt stays pending with zero events, so the client would
+ * hang until its own idle watchdog.
+ *
+ * The only channel that carries the real error is opencode's own log file
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`), where every LLM stream
+ * failure is written as `message="stream error" ... session.id=<id>
+ * small=false ... error.error="<reason>"`.
+ *
+ * This monitor tails the log (delta from the turn-start offset), scoped to
+ * the active sessionId + `small=false` (main turn; the `small=true` title
+ * stream must not kill the turn). Only limit/quota-class errors trigger the
+ * callback — they are the ones opencode backs off for a long time; transient
+ * 5xx/network errors retry in seconds and must be left to opencode's own
+ * retry loop (the idle watchdog remains the fallback for silent hangs).
+ */
+export interface OpencodeLogErrorMonitorOptions {
+    /** Path to opencode's own log file (default: resolveOpencodeLogPath()). */
+    logPath: string;
+    /** Tail poll interval in milliseconds. Defaults to 2000. */
+    pollIntervalMs?: number;
+}
+/**
+ * Resolve opencode's log file path from the XDG data dir
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
+ * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
+ * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ */
+export declare function resolveOpencodeLogPath(): string;
+export declare class OpencodeLogErrorMonitor {
+    private readonly logPath;
+    private readonly pollIntervalMs;
+    private offset;
+    private pendingTail;
+    private timer;
+    private sessionId;
+    private onError;
+    constructor(opts: OpencodeLogErrorMonitorOptions);
+    /**
+     * Start monitoring the given session. Replaces any previous monitor state;
+     * the log offset is snapshotted now, so pre-existing entries never fire.
+     */
+    start(sessionId: string, onError: (message: string) => void): void;
+    /** Stop monitoring and clear all state. Safe to call multiple times. */
+    stop(): void;
+    private currentSize;
+    private poll;
+    /** Match a main-turn stream error line for the monitored session with a
+     *  limit/quota reason; returns the extracted error text or null. */
+    private matchLimitError;
+}

package/dist/runner/opencode/acp/error-monitor.js

@@ -0,0 +1,150 @@
+/**
+ * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
+ * errors of the active ACP session and reports them immediately.
+ *
+ * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * to the client over the ACP protocol. Its session/update notifications are
+ * limited to content deltas (agent_message_chunk / agent_thought_chunk /
+ * tool_call / tool_call_update), usage and available-commands updates — there
+ * is no error/retry/status event type, and session/list carries no status.
+ * When a retryable provider error hits (e.g. opencode-go "Weekly usage limit
+ * reached"), the session enters a retry backoff (often the full reset time,
+ * ~1h) and session/prompt stays pending with zero events, so the client would
+ * hang until its own idle watchdog.
+ *
+ * The only channel that carries the real error is opencode's own log file
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`), where every LLM stream
+ * failure is written as `message="stream error" ... session.id=<id>
+ * small=false ... error.error="<reason>"`.
+ *
+ * This monitor tails the log (delta from the turn-start offset), scoped to
+ * the active sessionId + `small=false` (main turn; the `small=true` title
+ * stream must not kill the turn). Only limit/quota-class errors trigger the
+ * callback — they are the ones opencode backs off for a long time; transient
+ * 5xx/network errors retry in seconds and must be left to opencode's own
+ * retry loop (the idle watchdog remains the fallback for silent hangs).
+ */
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Error text we fail fast on: quota/limit conditions opencode backs off on. */
+const LIMIT_ERROR_RE = /usage limit|quota|rate limit|rate_limit|too many requests|insufficient balance|free usage/i;
+const STREAM_ERROR_RE = /message="stream error"/;
+const MAIN_TURN_RE = /small=false/;
+const ERROR_MESSAGE_RE = /error\.error="((?:[^"\\]|\\.)*)"/;
+/**
+ * Resolve opencode's log file path from the XDG data dir
+ * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
+ * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
+ * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ */
+export function resolveOpencodeLogPath() {
+    const dataHome = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+    return join(dataHome, 'opencode', 'log', 'opencode.log');
+}
+export class OpencodeLogErrorMonitor {
+    logPath;
+    pollIntervalMs;
+    offset = 0;
+    pendingTail = '';
+    timer = null;
+    sessionId = null;
+    onError = null;
+    constructor(opts) {
+        this.logPath = opts.logPath;
+        this.pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    }
+    /**
+     * Start monitoring the given session. Replaces any previous monitor state;
+     * the log offset is snapshotted now, so pre-existing entries never fire.
+     */
+    start(sessionId, onError) {
+        this.stop();
+        this.sessionId = sessionId;
+        this.onError = onError;
+        this.offset = this.currentSize();
+        this.pendingTail = '';
+        this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+        this.timer.unref?.();
+    }
+    /** Stop monitoring and clear all state. Safe to call multiple times. */
+    stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.sessionId = null;
+        this.onError = null;
+        this.pendingTail = '';
+    }
+    currentSize() {
+        try {
+            return statSync(this.logPath).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    poll() {
+        if (this.sessionId === null || this.onError === null)
+            return;
+        const size = this.currentSize();
+        if (size < this.offset) {
+            // Log rotated/truncated: restart from the top of the current file.
+            this.offset = 0;
+            this.pendingTail = '';
+        }
+        if (size > this.offset) {
+            let chunk;
+            try {
+                const fd = openSync(this.logPath, 'r');
+                try {
+                    const buf = Buffer.alloc(size - this.offset);
+                    readSync(fd, buf, 0, buf.length, this.offset);
+                    chunk = buf.toString('utf8');
+                }
+                finally {
+                    closeSync(fd);
+                }
+            }
+            catch {
+                return;
+            }
+            this.offset = size;
+            this.pendingTail += chunk;
+        }
+        // Scan complete lines (and any trailing line without newline).
+        for (const line of this.pendingTail.split('\n')) {
+            const message = this.matchLimitError(line);
+            if (message === null)
+                continue;
+            const onError = this.onError;
+            this.stop();
+            onError(message);
+            return;
+        }
+        // Keep only the last partial line (everything before the last '\n' was
+        // fully scanned above and did not match).
+        const lastNewline = this.pendingTail.lastIndexOf('\n');
+        if (lastNewline >= 0) {
+            this.pendingTail = this.pendingTail.slice(lastNewline + 1);
+        }
+    }
+    /** Match a main-turn stream error line for the monitored session with a
+     *  limit/quota reason; returns the extracted error text or null. */
+    matchLimitError(line) {
+        if (this.sessionId === null)
+            return null;
+        if (!line.includes(this.sessionId))
+            return null;
+        if (!STREAM_ERROR_RE.test(line))
+            return null;
+        if (!MAIN_TURN_RE.test(line))
+            return null;
+        const message = ERROR_MESSAGE_RE.exec(line)?.[1];
+        if (!message || !LIMIT_ERROR_RE.test(message))
+            return null;
+        return message;
+    }
+}
+//# sourceMappingURL=error-monitor.js.map

package/dist/runner/opencode/acp/runner.d.ts

@@ -43,6 +43,10 @@ export interface OpencodeAcpRunnerOptions {
     model?: string;
     /** Configured session mode: 'build' (default) or 'plan' (opencode agent names). */
     mode?: 'build' | 'plan';
+    /** Path to opencode's own log file (default: resolveOpencodeLogPath()). */
+    errorMonitorLogPath?: string;
+    /** Tail poll interval for the opencode log error monitor. Defaults to 2000ms. */
+    errorMonitorPollIntervalMs?: number;
 }
 export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClient, OpencodeAcpTranslatorEvent> {
     private connectionManager;
@@ -55,6 +59,9 @@ export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClie
     private currentModeId?;
     /** Current model value (`provider/model`), parsed from configOptions. */
     private currentModelValue?;
+    /** Tails opencode's own log to surface LLM stream errors the ACP protocol
+     *  never forwards (quota/limit errors back off for ~1h → turn would hang). */
+    private readonly errorMonitor;
     /** Pending approval requests: requestId → kind + view + options. */
     private pendingApprovals;
     /** Tracker for the in-flight prompt request — needed for cancellation. */
@@ -71,6 +78,16 @@ export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClie
     protected shouldDeferStop(): boolean;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;
+    /**
+     * Start watching opencode's own log for LLM stream errors of the active
+     * session. opencode ACP does not surface retry/error state to the client
+     * (no error/status notification type, session/list has no status field), so
+     * the log is the only channel that carries the real provider error. Without
+     * this, a quota error (e.g. opencode-go weekly limit) leaves session/prompt
+     * pending for the full retry-after backoff (~1h) and the Feishu card hangs
+     * until the idle watchdog.
+     */
+    private startErrorMonitor;
     protected releaseConnection(cwd: string): Promise<void>;
     protected notifyIdle(cwd: string): void;
     protected disposeConnections(): Promise<void>;