@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/backends/dist/acp/acp-session-runner.js

@@ -0,0 +1,550 @@
+import fs from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { Readable, Writable } from "node:stream";
+import { spawn } from "node:child_process";
+import { methods, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import { mapSessionUpdate } from "./acp-event-mapper.js";
+import { openActiveSession } from "./acp-active-session.js";
+import { raceWithAbort } from "./acp-race.js";
+import { createClaudeSessionActivityMarker } from "./acp-claude-activity.js";
+import { ACP_CLIENT_CAPABILITIES, createHeadlessClientApp, } from "./headless-client.js";
+import { killProcessTree } from "./acp-kill.js";
+import { fileAttachmentPromptSuffix, partitionAttachments, } from "../attachment-prompt.js";
+import { resolveAcpSpawn } from "./acp-spawn-profiles.js";
+import { applySessionConfigOptions, resolveDesiredConfig, } from "./acp-config-options.js";
+import { friendlyAuthErrorMessage } from "../auth-error-hints.js";
+import { resourcesAlive, teardownResources, } from "./acp-session-pool.js";
+export function supportsAcpSteering(response) {
+    const meta = response?._meta;
+    return meta?.steering?.supported === true;
+}
+export function steerAcpSession(agent, sessionId, prompt) {
+    return agent.request("_session/steering", {
+        sessionId,
+        prompt: [{ type: "text", text: prompt }],
+    });
+}
+async function buildPromptBlocks(ctx) {
+    const { images, files } = partitionAttachments(ctx.attachments);
+    const blocks = [];
+    for (const att of images) {
+        const data = await fs.readFile(att.path, { encoding: "base64" });
+        blocks.push({
+            type: "image",
+            mimeType: att.mimeType ?? "image/png",
+            data,
+            uri: att.path,
+        });
+    }
+    blocks.push({
+        type: "text",
+        text: ctx.prompt + fileAttachmentPromptSuffix(files),
+    });
+    return blocks;
+}
+function childToStream(child) {
+    if (!child.stdin || !child.stdout) {
+        throw new Error("ACP agent stdio pipes unavailable");
+    }
+    return ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+}
+async function waitMs(ms, isAborted) {
+    const start = Date.now();
+    while (Date.now() - start < ms) {
+        if (isAborted())
+            return;
+        await new Promise((r) => setTimeout(r, 10));
+    }
+}
+/** 长任务总上限；无输出与中途停滞由下面两个更短的 watchdog 独立处理。 */
+const ACP_PROMPT_TIMEOUT_MS = 6 * 60 * 60 * 1000;
+/** 从发 prompt 起这么久仍无任何输出，视为卡住（常见于 session/load 或看图）；可经 config 覆盖 */
+const ACP_NO_OUTPUT_TIMEOUT_MS = 10 * 60 * 1000;
+/** 已有输出后这么久没有新事件，视为 mid-turn 卡死（如 tool 调用卡死）；可经 config 覆盖 */
+const ACP_STALL_TIMEOUT_MS = 30 * 60 * 1000;
+const ACP_INIT_TIMEOUT_MS = 30_000;
+// 后台子 agent（run_in_background）的 Task 工具在“启动即返回”时就 completed，stop 时并无
+// 未闭合 tool_call；后台工作作为独立任务在 stop 之后继续产出 session_update。因此靠“探测”
+// 判定是否真有后台：主轮起过 tool 才进 drain，probe 短窗内出现真实活动则切 quiet 长窗直到静默。
+// 实测：首个后台事件约在 stop 后 +0.8s；后台过程内可静默十几秒（如 sub-agent 跑 sleep）。
+const ACP_POST_STOP_PROBE_MS = 8 * 1000;
+const ACP_POST_STOP_QUIET_MS = 75 * 1000;
+const ACP_POST_STOP_MAX_MS = 20 * 60 * 1000;
+function isActivityEvent(event) {
+    return (event.type === "text_delta" ||
+        event.type === "thought_delta" ||
+        event.type === "tool_start" ||
+        event.type === "tool_update" ||
+        event.type === "tool_end" ||
+        event.type === "plan" ||
+        event.type === "plan_update" ||
+        // 等用户 /approve 期间 wire 必然静默，权限请求本身算活动，免得 watchdog 误杀
+        event.type === "permission_request");
+}
+function withStderr(message, options) {
+    const stderr = options.readStderr?.().trim();
+    return stderr ? `${message}\n\n${stderr}` : message;
+}
+export async function* runActivePromptTurn(active, blocks, options) {
+    // 池模式跨轮接力同一个 carrier；非池模式局部（行为与旧版一致）
+    const carrier = options.updateCarrier ?? {
+        pending: null,
+    };
+    // 池复用：发新 prompt 之前先排干队列里已排队的消息——上一轮 drain 退出后仍到达的
+    // 后台产出（内容合法，照常 yield）与可能残留的陈旧 stop（丢弃，否则会被误判为新轮结束）。
+    // 有总时限：残余后台若持续以 <15ms 间隔产出，无上限的排干会把新 prompt 无限推迟、
+    // 且外部 /stop 也打不断（实测复现过）。到时限就带着残余进主循环，主循环本就能消化。
+    if (options.updateCarrier) {
+        const preDrainDeadline = Date.now() + 1_500;
+        while (!options.isAborted() && Date.now() < preDrainDeadline) {
+            carrier.pending ??= active.nextUpdate();
+            const got = await Promise.race([
+                carrier.pending.then((message) => ({ message }), () => "failed"),
+                new Promise((r) => setTimeout(() => r("empty"), 15)),
+            ]);
+            if (got === "empty")
+                break;
+            carrier.pending = null;
+            if (got === "failed")
+                break; // 队列已失效，让主循环去暴露真实错误
+            if (got.message.kind === "session_update") {
+                if (got.message.update.sessionUpdate === "config_option_update") {
+                    options.onConfigOptionsUpdate?.(got.message.update.configOptions);
+                }
+                for (const event of mapSessionUpdate(got.message.update)) {
+                    yield event;
+                }
+            }
+            // kind === "stop"：陈旧的上一轮结束信号，丢弃
+            // 队列可能持续有已就绪消息；让出一个 macrotask，保证 /stop 的 abort
+            // 以及进程信号能在预排干阶段被观察到，不被连续 resolved Promise 饿死。
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        if (options.isAborted())
+            return;
+    }
+    for (const event of (await options.beforePrompt?.()) ?? []) {
+        yield event;
+    }
+    if (options.isAborted())
+        return;
+    void active.prompt(blocks);
+    const promptTimeoutMs = options.promptTimeoutMs ?? ACP_PROMPT_TIMEOUT_MS;
+    const noOutputTimeoutMs = options.noOutputTimeoutMs ?? ACP_NO_OUTPUT_TIMEOUT_MS;
+    const stallTimeoutMs = options.stallTimeoutMs ?? ACP_STALL_TIMEOUT_MS;
+    const postStopProbeMs = options.postStopProbeMs ?? ACP_POST_STOP_PROBE_MS;
+    const postStopQuietMs = options.postStopQuietMs ?? ACP_POST_STOP_QUIET_MS;
+    const postStopMaxMs = options.postStopMaxMs ?? ACP_POST_STOP_MAX_MS;
+    const drainEnabled = options.drainBackgroundWork ?? true;
+    let sawOutput = false;
+    const promptStartedAt = Date.now();
+    let lastActivityAt = promptStartedAt;
+    const noOutputTimeout = () => !sawOutput && Date.now() - promptStartedAt >= noOutputTimeoutMs;
+    // sawOutput 之后 120s watchdog 就不再生效，需要单独的 mid-turn 卡死检测
+    const stallTimeout = () => sawOutput && Date.now() - lastActivityAt >= stallTimeoutMs;
+    // "main" = 主 prompt 轮；"drain" = 主轮 stop 后续读后台子 agent 的 between-turn 输出。
+    // 只有本轮起过 tool（后台必经 Task 工具）才在 stop 后进 drain；纯对话轮 stop 即返回、零延迟。
+    let phase = "main";
+    let sawToolCall = false;
+    let drainStartAt = 0;
+    let lastDrainActivityAt = 0;
+    let drainConfirmed = false;
+    // 磁盘活动标记：节流读取（stat 很便宜但没必要每 40ms 一次）
+    let lastMarkerValue;
+    let lastMarkerCheckAt = 0;
+    const DRAIN_MARKER_INTERVAL_MS = 500;
+    let mainDeadline = promptStartedAt + promptTimeoutMs;
+    while (!options.isAborted()) {
+        // 带外事件（如权限请求）：发生在连接回调里，经队列汇入本事件流
+        for (const oob of options.pollOutOfBandEvents?.() ?? []) {
+            if (isActivityEvent(oob)) {
+                sawOutput = true;
+                lastActivityAt = Date.now();
+            }
+            if (oob.type === "permission_request") {
+                // 等人回复不该撞总超时：至少留出比权限超时（8 分钟）更长的余量
+                mainDeadline = Math.max(mainDeadline, Date.now() + 10 * 60 * 1000);
+            }
+            yield oob;
+        }
+        if (phase === "main") {
+            if (Date.now() > mainDeadline) {
+                yield {
+                    type: "error",
+                    message: withStderr(`ACP 响应超时（${Math.round(promptTimeoutMs / 60000)} 分钟无结束信号）`, options),
+                    fatal: true,
+                };
+                break;
+            }
+            if (noOutputTimeout()) {
+                yield {
+                    type: "error",
+                    message: withStderr("ACP 长时间无任何输出（可能 agent 未登录、模型不可用或看图任务过慢）。", options),
+                    fatal: true,
+                };
+                break;
+            }
+            if (stallTimeout()) {
+                yield {
+                    type: "error",
+                    message: withStderr(`ACP 超过 ${Math.round(stallTimeoutMs / 60000)} 分钟无新事件（可能 tool 调用卡死）`, options),
+                    fatal: true,
+                };
+                break;
+            }
+        }
+        else {
+            // drain 阶段：未确认前用 probe 短窗探后台；确认后用 quiet 长窗等静默；独立硬上限兜底。
+            // stall/noOutput 这类主轮 watchdog 不进入 drain：drain 期的静默是预期的（如 sub-agent 跑 sleep）。
+            // 磁盘活动标记：后台子 agent 写盘但 wire 静默时（transcript 在长、事件没来），
+            // 标记增长同样算活动——既能在 probe 窗内确认后台，也能刷新 quiet 计时防误切。
+            if (options.drainActivityMarker &&
+                Date.now() - lastMarkerCheckAt >= DRAIN_MARKER_INTERVAL_MS) {
+                lastMarkerCheckAt = Date.now();
+                const marker = options.drainActivityMarker();
+                if (marker !== undefined && marker !== lastMarkerValue) {
+                    if (lastMarkerValue !== undefined) {
+                        drainConfirmed = true;
+                        lastDrainActivityAt = Date.now();
+                    }
+                    lastMarkerValue = marker;
+                }
+            }
+            if (!drainConfirmed && Date.now() - drainStartAt >= postStopProbeMs) {
+                break; // 探不到真实后台活动 → 本轮无后台，干净返回
+            }
+            if (drainConfirmed && Date.now() - lastDrainActivityAt >= postStopQuietMs) {
+                break; // 后台真正静默 → 结束
+            }
+            if (Date.now() - drainStartAt >= postStopMaxMs) {
+                // 放弃仍在跑的后台任务：进程不可入池（否则失控任务借池续命，文案也成谎话）
+                options.markUnpoolable?.();
+                yield {
+                    type: "error",
+                    message: withStderr("ACP 后台任务超过 20 分钟仍未结束，已停止跟踪并终止该会话进程。", options),
+                    fatal: false, // 主答已成功，这里只是停止跟踪，不算失败
+                };
+                break;
+            }
+        }
+        // 必须跨迭代复用同一个 nextUpdate()：每次调用都会在 SDK AsyncQueue 里注册一个
+        // waiter，被 race 抛弃的 waiter 仍排在 FIFO 前面，会把后续事件全部吞掉。
+        carrier.pending ??= active.nextUpdate();
+        const next = await Promise.race([
+            carrier.pending.then((message) => ({ message }), (err) => {
+                // /stop 拆资源会同步 fail 队列，rejection 必然抢在 isAborted 轮询前；
+                // 已中止时按干净退出处理，不把 dispose 噪音当成 fatal 错误往上抛。
+                if (options.isAborted())
+                    return "aborted";
+                throw err;
+            }),
+            waitMs(40, options.isAborted).then(() => null),
+        ]);
+        if (!next)
+            continue;
+        carrier.pending = null;
+        if (next === "aborted")
+            break;
+        if (next.message.kind === "session_update") {
+            const update = next.message.update;
+            if (update.sessionUpdate === "tool_call")
+                sawToolCall = true;
+            if (update.sessionUpdate === "config_option_update") {
+                options.onConfigOptionsUpdate?.(update.configOptions);
+            }
+            const events = mapSessionUpdate(update);
+            // drain 活动信号：映射出真实事件，或后台工具的进行中进度（in-progress tool_call_update
+            // 映射为空却代表后台工具仍在跑，须刷新静默计时，否则单个长工具会被 quiet 窗误切）。
+            // session_info_update / usage_update 这类噪音仍不算，避免普通轮次被尾随噪音误判为有后台。
+            const isDrainActivity = events.some(isActivityEvent) || update.sessionUpdate === "tool_call_update";
+            if (phase === "drain" && isDrainActivity) {
+                drainConfirmed = true;
+                lastDrainActivityAt = Date.now();
+            }
+            for (const event of events) {
+                if (isActivityEvent(event)) {
+                    sawOutput = true;
+                    lastActivityAt = Date.now();
+                }
+                yield event;
+            }
+        }
+        else if (next.message.kind === "stop") {
+            if (phase !== "main")
+                break; // drain 期再遇 stop → 结束
+            if (drainEnabled && sawToolCall) {
+                phase = "drain";
+                drainStartAt = Date.now();
+                lastDrainActivityAt = drainStartAt;
+                drainConfirmed = false;
+                // 不 break，继续循环续读后台事件
+            }
+            else {
+                break; // 无 tool（不可能有后台）或 drain 关闭 → 今天的即时返回行为
+            }
+        }
+    }
+    if (!options.updateCarrier) {
+        // 非池模式：进程即将被杀，pending 稍后因 dispose() reject，防御性吞掉。
+        // 池模式绝不能走到这：pending 已存在共享 carrier 上，由下一轮接力消费。
+        carrier.pending?.catch(() => { });
+    }
+}
+/** 复用匹配键：spawn 命令与关键 env 在进程启动时冻结，任一变化都不能复用 */
+export function buildSessionMatchKeys(ctx) {
+    const profile = resolveAcpSpawn(ctx.backendConfig);
+    const canonicalMcpServers = (ctx.mcpServers ?? [])
+        .map((server) => ({
+        name: server.name,
+        command: server.command,
+        args: [...server.args],
+        env: Object.entries(server.env).sort(([left], [right]) => left.localeCompare(right)),
+    }))
+        .map((server) => JSON.stringify(server))
+        .sort();
+    return {
+        spawnKey: `${profile.command} ${profile.args.join(" ")}`,
+        envKey: `${ctx.extraEnv?.FCB_CHAT_ID ?? ""}|${ctx.extraEnv?.FCB_TOPIC_ID ?? ""}|${ctx.extraEnv?.FCB_RUN_ID ?? ""}`,
+        additionalDirectoriesKey: (ctx.additionalDirectories ?? []).join("\0"),
+        mcpServersKey: `sha256:${createHash("sha256")
+            .update(JSON.stringify(canonicalMcpServers))
+            .digest("hex")}`,
+    };
+}
+function acpMcpServers(ctx) {
+    return (ctx.mcpServers ?? []).map((server) => ({
+        name: server.name,
+        command: server.command,
+        args: [...server.args],
+        env: Object.entries(server.env).map(([name, value]) => ({ name, value })),
+    }));
+}
+/**
+ * 冷启动一个 ACP 会话的全部资源：spawn 适配器 → 连接 → initialize → 建/续会话。
+ * 权限决策器经 runtime 盒子间接读取——连接上的 handler 无法换装，而 requestDecision
+ * 是 per-run 闭包，必须每轮重绑（否则池复用后第二轮权限请求会调到第一轮的死闭包）。
+ * 失败时自行清理（杀进程/关连接）并把 stderr 摘要附在错误里抛出。
+ */
+async function openAcpSessionResources(ctx, options, onSpawn) {
+    const spawnProfile = resolveAcpSpawn(ctx.backendConfig);
+    const { spawnKey, envKey, additionalDirectoriesKey, mcpServersKey, } = buildSessionMatchKeys(ctx);
+    const child = spawn(spawnProfile.command, spawnProfile.args, {
+        cwd: ctx.cwd,
+        env: { ...process.env, ...ctx.extraEnv },
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true, // 自成进程组，killProcessTree 可 -pid 全组兜底（SIGKILL 不转发）
+    });
+    let stderr = "";
+    // 长时间任务下 stderr 会无界增长，只保留末尾 8 KiB 用于排障
+    const appendStderr = (chunk) => {
+        stderr += chunk;
+        if (stderr.length > 8192)
+            stderr = stderr.slice(-8192);
+    };
+    // 未监听 'error' 事件时 spawn 失败（如 ENOENT）会以 uncaught exception 炸掉整个进程
+    child.on("error", (err) => {
+        appendStderr(`${err.message}\n`);
+    });
+    child.stderr?.on("data", (d) => {
+        appendStderr(d.toString());
+    });
+    const childAlive = () => child.exitCode === null && child.signalCode === null;
+    const killChild = () => {
+        if (childAlive())
+            killProcessTree(child, "SIGTERM");
+        setTimeout(() => {
+            if (childAlive())
+                killProcessTree(child, "SIGKILL");
+        }, 2000).unref();
+    };
+    onSpawn(child, killChild);
+    let connection;
+    try {
+        const runtime = {
+            requestDecision: options.requestDecision,
+        };
+        const app = createHeadlessClientApp({
+            permissionPolicy: options.permissionPolicy,
+            requestDecision: (info) => runtime.requestDecision
+                ? runtime.requestDecision(info)
+                : Promise.resolve(false),
+        });
+        const stream = childToStream(child);
+        connection = app.connect(stream);
+        const initializeResponse = await raceWithAbort(connection.agent.request(methods.agent.initialize, {
+            protocolVersion: PROTOCOL_VERSION,
+            clientCapabilities: ACP_CLIENT_CAPABILITIES,
+            clientInfo: {
+                name: "codebridge",
+                version: "0.1.0",
+            },
+        }), options.isAborted, ACP_INIT_TIMEOUT_MS, "ACP initialize 超时");
+        const active = await openActiveSession(connection, ctx, ctx.backendConfig, {
+            isAborted: options.isAborted,
+            supportsAdditionalDirectories: initializeResponse.agentCapabilities?.sessionCapabilities
+                ?.additionalDirectories != null,
+            mcpServers: acpMcpServers(ctx),
+        });
+        const resources = {
+            sessionId: active.sessionId,
+            child,
+            connection,
+            active,
+            cwd: ctx.cwd,
+            spawnKey,
+            envKey,
+            additionalDirectoriesKey,
+            mcpServersKey,
+            supportsSteering: supportsAcpSteering(initializeResponse),
+            supportsClose: initializeResponse.agentCapabilities?.sessionCapabilities?.close != null,
+            configOptions: [...(active.newSessionResponse.configOptions ?? [])],
+            readStderr: () => stderr,
+            carrier: { pending: null },
+            runtime,
+        };
+        return { resources };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const detail = stderr.trim();
+        try {
+            connection?.close();
+        }
+        catch {
+            // 已关闭
+        }
+        killChild();
+        throw new Error(detail ? `${message}\n\n${detail}` : message);
+    }
+}
+export async function* runAcpSession(ctx, options, outHandle) {
+    const pool = options.sessionPool;
+    const { spawnKey, envKey, additionalDirectoriesKey, mcpServersKey, } = buildSessionMatchKeys(ctx);
+    let resources;
+    if (pool?.enabled && ctx.resumeSessionId) {
+        resources =
+            pool.acquire(ctx.resumeSessionId, {
+                cwd: ctx.cwd,
+                spawnKey,
+                envKey,
+                additionalDirectoriesKey,
+                mcpServersKey,
+            }) ??
+                undefined;
+    }
+    const reused = resources !== undefined;
+    // healthy 只在轮子完整走完且无 fatal/abort 时为真；其余一律拆除（不归还池）
+    let healthy = false;
+    // drain 硬上限等路径会标记本轮资源不可入池（进程还活着但已不可信）
+    let poolable = true;
+    try {
+        if (!resources) {
+            const opened = await openAcpSessionResources(ctx, options, (child, kill) => {
+                // spawn 后立刻可取消（initialize/续聊阶段 /stop 也要能杀掉）
+                outHandle.current = { child, cancel: kill };
+            });
+            resources = opened.resources;
+        }
+        const r = resources;
+        outHandle.current = {
+            child: r.child,
+            ...(r.supportsSteering
+                ? {
+                    steer: (prompt) => steerAcpSession(r.connection.agent, r.sessionId, prompt),
+                }
+                : {}),
+            cancel: () => {
+                void r.connection.agent
+                    .notify(methods.agent.session.cancel, { sessionId: r.sessionId })
+                    .catch(() => { });
+                // 只杀进程，不在此处 dispose/close：同步 fail 队列会抢在 isAborted 轮询前
+                // 把循环炸成伪 fatal（"Active session disposed"）。dispose/close 交给 finally
+                // 的 teardown（本轮已中止，healthy=false 必走拆除）。
+                killProcessTree(r.child, "SIGTERM");
+                const child = r.child;
+                setTimeout(() => {
+                    if (child.exitCode === null && child.signalCode === null) {
+                        killProcessTree(child, "SIGKILL");
+                    }
+                }, 2000).unref();
+            },
+        };
+        yield { type: "session", sessionId: r.sessionId };
+        // 每轮重绑权限决策器（per-run 闭包；池复用时旧闭包已随上一轮失效）
+        r.runtime.requestDecision = options.requestDecision;
+        const blocks = await buildPromptBlocks(ctx);
+        let sawFatal = false;
+        for await (const event of runActivePromptTurn(r.active, blocks, {
+            ...options,
+            markUnpoolable: () => {
+                poolable = false;
+            },
+            readStderr: r.readStderr,
+            // 池模式跨轮接力 pending waiter；复用轮先排干队列残留
+            updateCarrier: pool?.enabled ? r.carrier : undefined,
+            // claude 的后台子 agent 写盘不走 wire，用会话文件增长作 drain 的补充活动信号
+            drainActivityMarker: options.drainActivityMarker ??
+                (ctx.backendConfig.type === "claude-code"
+                    ? createClaudeSessionActivityMarker(ctx.cwd, r.sessionId)
+                    : undefined),
+            onConfigOptionsUpdate: (configOptions) => {
+                r.configOptions = [...configOptions];
+            },
+            beforePrompt: async () => {
+                // 预排干会先消费跨轮残留的 config_option_update，之后再应用本轮 model/effort/mode；
+                // 这样池复用时使用的是最新能力快照，而非首次 session/new 的旧列表。
+                const desired = resolveDesiredConfig(ctx, options.permissionPolicy);
+                const result = await applySessionConfigOptions(r.connection.agent, r.sessionId, r.configOptions, desired, ctx.acpConfig);
+                r.configOptions = [...result.configOptions];
+                const events = result.warnings.map((message) => ({
+                    type: "error",
+                    message,
+                    fatal: false,
+                }));
+                if (result.modelMismatch) {
+                    events.push({
+                        type: "model_resolved",
+                        requested: result.modelMismatch.requested,
+                        effective: result.modelMismatch.effective,
+                        effectiveName: result.modelMismatch.effectiveName,
+                    });
+                }
+                return events;
+            },
+        })) {
+            if (event.type === "error" && event.fatal)
+                sawFatal = true;
+            // 认证失败（OAuth 过期/未登录）常年只表现为一条不可操作的原始报错；这里就地改写成
+            // 「哪个后端 + 该在宿主机跑什么命令」，detail 保留原文不吞。命中的后端才有具体命令。
+            yield event.type === "error"
+                ? { ...event, message: friendlyAuthErrorMessage(ctx.backendConfig.type, event.message) }
+                : event;
+        }
+        healthy = !sawFatal && !options.isAborted() && resourcesAlive(r);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const detail = resources?.readStderr().trim() ?? "";
+        const combined = detail && !message.includes(detail) ? `${message}\n\n${detail}` : message;
+        yield {
+            type: "error",
+            message: friendlyAuthErrorMessage(ctx.backendConfig.type, combined),
+            fatal: true,
+        };
+    }
+    finally {
+        if (resources) {
+            // 防跨轮死闭包：轮末即解绑，池空闲期的权限请求直接按拒绝处理
+            resources.runtime.requestDecision = undefined;
+            if (healthy && poolable && pool?.enabled) {
+                pool.release(resources);
+            }
+            else {
+                teardownResources(resources);
+            }
+        }
+    }
+    // reused 变量供将来遥测（冷/热轮次统计），当前无消费者
+    void reused;
+}
+//# sourceMappingURL=acp-session-runner.js.map

package/node_modules/@codebridge/backends/dist/acp/acp-spawn-profiles.d.ts

@@ -0,0 +1,9 @@
+import { type BackendProfile } from "@codebridge/core";
+export interface AcpSpawnProfile {
+    command: string;
+    args: string[];
+}
+export declare function resolveAcpSpawn(profile: BackendProfile): AcpSpawnProfile;
+/** Cursor 无 session/resume，续聊用 load；其余优先 resume */
+export declare function acpContinueMethod(profile: BackendProfile): "session/load" | "session/resume";
+//# sourceMappingURL=acp-spawn-profiles.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-spawn-profiles.js

@@ -0,0 +1,28 @@
+import { ACP_CLAUDE_AGENT_ACP_VERSION, ACP_CODEX_ACP_VERSION, } from "@codebridge/core";
+const DEFAULTS = {
+    "cursor-cli": { command: "cursor-agent", args: ["acp"] },
+    "claude-code": {
+        command: "npx",
+        args: ["-y", `@agentclientprotocol/claude-agent-acp@${ACP_CLAUDE_AGENT_ACP_VERSION}`],
+    },
+    codex: {
+        command: "npx",
+        args: ["-y", `@agentclientprotocol/codex-acp@${ACP_CODEX_ACP_VERSION}`],
+    },
+    "generic-spawn": { command: "npx", args: [] },
+};
+export function resolveAcpSpawn(profile) {
+    if (profile.type === "pi-sdk") {
+        throw new Error("Pi SDK backend does not use an ACP spawn command");
+    }
+    const defaults = DEFAULTS[profile.type] ?? DEFAULTS["generic-spawn"];
+    return {
+        command: profile.acpCommand ?? defaults.command,
+        args: profile.acpArgs ?? defaults.args,
+    };
+}
+/** Cursor 无 session/resume，续聊用 load；其余优先 resume */
+export function acpContinueMethod(profile) {
+    return profile.type === "cursor-cli" ? "session/load" : "session/resume";
+}
+//# sourceMappingURL=acp-spawn-profiles.js.map

package/node_modules/@codebridge/backends/dist/acp/headless-client.d.ts

@@ -0,0 +1,19 @@
+import { type ClientApp, type ClientCapabilities, type RequestPermissionRequest, type RequestPermissionResponse } from "@agentclientprotocol/sdk";
+import type { AcpPermissionPolicy } from "@codebridge/core";
+export interface HeadlessClientOptions {
+    permissionPolicy: AcpPermissionPolicy;
+    /**
+     * prompt_feishu 模式的决策等待器：把权限请求交给外界（飞书 /approve /deny），
+     * resolve true=允许 false=拒绝（含超时）。未提供时 prompt_feishu 退化为拒绝。
+     */
+    requestDecision?: (info: {
+        title: string;
+    }) => Promise<boolean>;
+}
+export declare const ACP_CLIENT_CAPABILITIES: ClientCapabilities;
+/** 从权限请求里提取给用户看的操作描述 */
+export declare function permissionRequestTitle(params: RequestPermissionRequest): string;
+export declare function pickAllowOption(params: RequestPermissionRequest): RequestPermissionResponse;
+/** 流式 session/update 由 ActiveSession.nextUpdate() 接收，此处只处理权限 */
+export declare function createHeadlessClientApp(options: HeadlessClientOptions): ClientApp;
+//# sourceMappingURL=headless-client.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/headless-client.js

@@ -0,0 +1,47 @@
+import { client, methods, } from "@agentclientprotocol/sdk";
+export const ACP_CLIENT_CAPABILITIES = {
+    fs: { readTextFile: false, writeTextFile: false },
+    plan: {},
+    session: { configOptions: { boolean: {} } },
+};
+/** 从权限请求里提取给用户看的操作描述 */
+export function permissionRequestTitle(params) {
+    const toolCall = params.toolCall;
+    return toolCall?.title || toolCall?.kind || "工具操作";
+}
+export function pickAllowOption(params) {
+    const options = params.options ?? [];
+    const byKind = (kind) => options.find((o) => o.kind === kind);
+    const allow = byKind("allow_once") ?? byKind("allow_always");
+    if (!allow) {
+        return {
+            outcome: { outcome: "cancelled" },
+        };
+    }
+    return {
+        outcome: {
+            outcome: "selected",
+            optionId: allow.optionId,
+        },
+    };
+}
+/** 流式 session/update 由 ActiveSession.nextUpdate() 接收，此处只处理权限 */
+export function createHeadlessClientApp(options) {
+    return client({ name: "codebridge" })
+        .onRequest(methods.client.session.requestPermission, async (ctx) => {
+        if (options.permissionPolicy === "auto_allow") {
+            return pickAllowOption(ctx.params);
+        }
+        if (options.permissionPolicy === "prompt_feishu" &&
+            options.requestDecision) {
+            const approved = await options.requestDecision({
+                title: permissionRequestTitle(ctx.params),
+            });
+            return approved
+                ? pickAllowOption(ctx.params)
+                : { outcome: { outcome: "cancelled" } };
+        }
+        return { outcome: { outcome: "cancelled" } };
+    });
+}
+//# sourceMappingURL=headless-client.js.map

package/node_modules/@codebridge/backends/dist/acp/index.d.ts

@@ -0,0 +1,9 @@
+export { resolveAcpSpawn, acpContinueMethod, type AcpSpawnProfile, } from "./acp-spawn-profiles.js";
+export { mapSessionUpdate } from "./acp-event-mapper.js";
+export { createHeadlessClientApp } from "./headless-client.js";
+export { runAcpSession, type AcpRunHandle, type AcpRunOptions, } from "./acp-session-runner.js";
+export { deleteAcpSession, loadAcpSessionHistory, listAcpConfigOptions, listAcpSessions, probeAcpInitialize, } from "./acp-session-list.js";
+export { detectBackend } from "./acp-doctor.js";
+export { killProcessTree } from "./acp-kill.js";
+export { AcpSessionPool, type AcpSessionPoolOptions, type AcpSessionResources, } from "./acp-session-pool.js";
+//# sourceMappingURL=index.d.ts.map