@graychennpm/codebridge 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,218 @@
+import { Readable, Writable } from "node:stream";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { methods, ndJsonStream, PROTOCOL_VERSION, client, } from "@agentclientprotocol/sdk";
+import { killProcessTree } from "./acp-kill.js";
+import { acpContinueMethod, resolveAcpSpawn } from "./acp-spawn-profiles.js";
+import { mapSessionConfigOptions } from "./acp-config-options.js";
+import { mapSessionUpdate } from "./acp-event-mapper.js";
+import { ACP_CLIENT_CAPABILITIES } from "./headless-client.js";
+import { raceWithAbort } from "./acp-race.js";
+const ACP_SESSION_DELETE_TIMEOUT_MS = 30_000;
+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 withAcpConnection(profile, cwd, op, onSessionUpdate, timeoutMs = 60_000) {
+    const spawnProfile = resolveAcpSpawn(profile);
+    const child = spawn(spawnProfile.command, spawnProfile.args, {
+        cwd,
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true, // 自成进程组，退出时全组一起杀，避免适配器的孙进程残留
+    });
+    const spawnError = new Promise((_, reject) => {
+        child.once("error", reject);
+    });
+    const app = client({ name: "codebridge" }).onNotification(methods.client.session.update, ({ params }) => onSessionUpdate?.(params.sessionId, params.update));
+    const stream = childToStream(child);
+    const connection = app.connect(stream);
+    try {
+        const initializeResponse = await raceWithAbort(Promise.race([
+            connection.agent.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: ACP_CLIENT_CAPABILITIES,
+                clientInfo: { name: "codebridge", version: "0.1.0" },
+            }),
+            spawnError,
+        ]), () => false, timeoutMs, "ACP initialize timeout");
+        return await raceWithAbort(Promise.race([op(connection.agent, initializeResponse), spawnError]), () => false, timeoutMs, "ACP operation timeout");
+    }
+    finally {
+        connection.close();
+        if (!child.killed)
+            killProcessTree(child, "SIGTERM");
+    }
+}
+export function collectAcpSessionHistory(updates) {
+    const result = [];
+    let previousUserMessageId;
+    for (const { update } of updates) {
+        if (update.sessionUpdate === "user_message_chunk") {
+            const text = textFromContent(update.content);
+            if (!text)
+                continue;
+            const previous = result.at(-1);
+            if (previous?.kind === "message" && previousUserMessageId === update.messageId)
+                previous.text += text;
+            else
+                result.push({ kind: "message", text });
+            previousUserMessageId = update.messageId;
+            continue;
+        }
+        previousUserMessageId = undefined;
+        for (const event of mapSessionUpdate(update)) {
+            result.push({ kind: "agent_event", event });
+        }
+    }
+    return result;
+}
+function textFromContent(content) {
+    return content.type === "text" && typeof content.text === "string" ? content.text : undefined;
+}
+export async function loadAcpSessionHistory(backendId, profile, cwd, sessionId, options) {
+    const updates = [];
+    await withAcpConnection(profile, cwd, async (agent) => {
+        const params = {
+            sessionId,
+            cwd,
+            ...(options?.additionalDirectories?.length
+                ? { additionalDirectories: options.additionalDirectories }
+                : {}),
+            mcpServers: [],
+        };
+        const method = acpContinueMethod(profile) === "session/load"
+            ? methods.agent.session.load
+            : methods.agent.session.resume;
+        await raceWithAbort(agent.request(method, params), () => false, 60_000, `ACP session history load timeout for ${backendId}`);
+    }, (notificationSessionId, update) => {
+        if (notificationSessionId === sessionId)
+            updates.push({ sessionId: notificationSessionId, update });
+    }, 15_000);
+    return collectAcpSessionHistory(updates);
+}
+export function hasAcpSessionCapability(response, capability) {
+    const sessionCapabilities = response?.agentCapabilities?.sessionCapabilities;
+    return sessionCapabilities?.[capability] != null;
+}
+export async function deleteAcpSession(profile, cwd, sessionId, timeoutMs = ACP_SESSION_DELETE_TIMEOUT_MS) {
+    return withAcpConnection(profile, cwd, async (agent, initializeResponse) => {
+        if (!hasAcpSessionCapability(initializeResponse, "delete")) {
+            throw new Error("ACP agent 未声明 session/delete 支持");
+        }
+        await raceWithAbort(agent.request(methods.agent.session.delete, { sessionId }), () => false, timeoutMs, "ACP session/delete 超时");
+    });
+}
+export async function listAcpSessions(backendId, profile, cwd, options) {
+    return withAcpConnection(profile, cwd, (agent) => collectAcpSessions(backendId, cwd, (params) => agent.request(methods.agent.session.list, params), options));
+}
+function cwdUnderScope(sessionCwd, scopeCwd) {
+    const session = path.resolve(sessionCwd);
+    const scope = path.resolve(scopeCwd);
+    return session === scope || session.startsWith(`${scope}${path.sep}`);
+}
+export async function collectAcpSessions(backendId, cwd, requestPage, options) {
+    const sessions = [];
+    let cursor;
+    do {
+        const page = await requestPage(cursor ? { cursor } : {});
+        sessions.push(...page.sessions);
+        cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+    const scoped = options?.all
+        ? sessions
+        : sessions.filter((session) => cwdUnderScope(session.cwd, cwd));
+    return scoped
+        .map((session) => ({
+        id: session.sessionId,
+        backend: backendId,
+        cwd: session.cwd,
+        ...(session.additionalDirectories?.length
+            ? { additionalDirectories: session.additionalDirectories }
+            : {}),
+        preview: session.title ?? "(no preview)",
+        updatedAt: session.updatedAt ?? "1970-01-01T00:00:00.000Z",
+    }))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .slice(0, options?.limit ?? 20);
+}
+const ACP_CONFIG_OPTIONS_TIMEOUT_MS = 15_000;
+/**
+ * 拉取 ACP 适配器 advertise 的会话配置项（/model 动态列表用）：短暂 spawn 适配器，
+ * initialize + session/new 读 configOptions 后立即销毁。不发 prompt，无推理成本；
+ * claude 适配器对未发过 prompt 的会话不持久化（实测 resume 报 Resource not found）。
+ * 超时/失败直接抛出，调用方展示 adapter 的真实错误，不回退到过期静态列表。
+ */
+export async function listAcpConfigOptions(profile, cwd, timeoutMs = ACP_CONFIG_OPTIONS_TIMEOUT_MS) {
+    return withAcpConnection(profile, cwd, (agent) => {
+        // 超时放在 op 内：reject 后 withAcpConnection 的 finally 负责 close + kill
+        const timeout = new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error("ACP config options timeout")), timeoutMs);
+            timer.unref?.();
+        });
+        const fetchOptions = (async () => {
+            const active = await agent.buildSession(cwd).start();
+            const options = active.newSessionResponse.configOptions ?? [];
+            active.dispose();
+            return mapSessionConfigOptions(options);
+        })();
+        return Promise.race([fetchOptions, timeout]);
+    });
+}
+export async function probeAcpInitialize(profile, cwd, timeoutMs = 30_000) {
+    const spawnProfile = resolveAcpSpawn(profile);
+    return new Promise((resolve) => {
+        const child = spawn(spawnProfile.command, spawnProfile.args, {
+            cwd,
+            env: { ...process.env },
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: true,
+        });
+        const spawnError = new Promise((_, reject) => {
+            child.once("error", reject);
+        });
+        const timer = setTimeout(() => {
+            killProcessTree(child, "SIGTERM");
+            resolve({ ok: false, message: "ACP initialize timeout" });
+        }, timeoutMs);
+        (async () => {
+            try {
+                const app = client({ name: "codebridge" });
+                const stream = childToStream(child);
+                const connection = app.connect(stream);
+                const init = await Promise.race([
+                    connection.agent.request(methods.agent.initialize, {
+                        protocolVersion: PROTOCOL_VERSION,
+                        clientCapabilities: ACP_CLIENT_CAPABILITIES,
+                        clientInfo: { name: "codebridge", version: "0.1.0" },
+                    }),
+                    spawnError,
+                ]);
+                connection.close();
+                const caps = init.agentCapabilities;
+                const parts = [
+                    `protocol=${init.protocolVersion}`,
+                    caps?.promptCapabilities?.image ? "image" : null,
+                    caps?.sessionCapabilities?.list ? "list" : null,
+                    caps?.sessionCapabilities?.resume ? "resume" : null,
+                    caps?.loadSession ? "load" : null,
+                ].filter(Boolean);
+                resolve({ ok: true, message: parts.join(", ") });
+            }
+            catch (err) {
+                resolve({
+                    ok: false,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            finally {
+                clearTimeout(timer);
+                if (!child.killed)
+                    killProcessTree(child, "SIGTERM");
+            }
+        })();
+    });
+}
+//# sourceMappingURL=acp-session-list.js.map

package/node_modules/@codebridge/backends/dist/acp/acp-session-pool.d.ts

@@ -0,0 +1,85 @@
+import type { ChildProcess } from "node:child_process";
+import type { ActiveSession, ActiveSessionMessage, ClientConnection, SessionConfigOption } from "@agentclientprotocol/sdk";
+/** 每轮由 runner 重绑的会话运行时：per-run 闭包绝不能跨轮沿用（否则第二轮权限请求会调到第一轮的死闭包） */
+export interface AcpSessionRuntime {
+    requestDecision?: (info: {
+        title: string;
+    }) => Promise<boolean>;
+}
+/**
+ * 一个长驻 ACP 会话的全部资源。池命中时整个对象跨轮复用——尤其 `active` 与 `carrier`：
+ * 同一连接上对同一 sessionId 再 attach 会造成双队列重复投递（SDK SessionUpdateRouter 是
+ * Set 追加），被抛弃的 nextUpdate waiter 会吞掉下一条消息（FIFO 且无注销 API），
+ * 所以 ActiveSession 对象与挂起的 waiter 都必须原样接力，绝不能重建或丢弃。
+ */
+export interface AcpSessionResources {
+    sessionId: string;
+    child: ChildProcess;
+    connection: ClientConnection;
+    active: ActiveSession;
+    /** 复用匹配键：cwd/spawn 命令/env 任一变了都不能复用（进程启动时已冻结） */
+    cwd: string;
+    spawnKey: string;
+    envKey: string;
+    additionalDirectoriesKey: string;
+    mcpServersKey: string;
+    supportsSteering: boolean;
+    supportsClose: boolean;
+    configOptions: SessionConfigOption[];
+    /** stderr 尾部缓冲，跨轮累积 */
+    readStderr: () => string;
+    /** 跨轮接力的 nextUpdate waiter */
+    carrier: {
+        pending: Promise<ActiveSessionMessage> | null;
+    };
+    runtime: AcpSessionRuntime;
+}
+export interface AcpSessionPoolOptions {
+    enabled: boolean;
+    /** 空闲这么久后回收（ms） */
+    idleMs: number;
+    /** 池内最多保留多少个空闲会话进程 */
+    maxPooled: number;
+}
+export declare function resourcesAlive(r: AcpSessionResources): boolean;
+/**
+ * 完整拆除一个会话：dispose 路由、关连接、杀整棵进程树。默认 SIGTERM + 2s SIGKILL
+ * 兜底；shutdown 路径传 SIGKILL 直杀——runner 马上 process.exit，unref 的兜底定时器
+ * 活不到触发，等宽限毫无意义。
+ */
+export declare function teardownResources(r: AcpSessionResources, signal?: NodeJS.Signals): void;
+/**
+ * 长驻 ACP 会话池（check-out/check-in 模型）：
+ * - acquire 命中即把条目从池里取走（运行期不在池内）——同一 sessionId 的并发第二个
+ *   认领者（/resume 可让两个会话绑同一 id）自然 miss、走独立冷启动，无需 busy 锁；
+ * - release 在健康轮末把资源放回（池满先淘汰最久未用的）；
+ * - 出错/中断/超时一律不归还（由调用方 teardown），池只保留干净收尾的会话；
+ * - idle sweep 回收长时间没人用的进程；shutdown 必须在 runner 退出前调用
+ *  （子进程 detached，不会随 runner 死）。
+ */
+export declare class AcpSessionPool {
+    private readonly options;
+    private readonly idle;
+    private readonly sweepTimer?;
+    constructor(options: AcpSessionPoolOptions);
+    get enabled(): boolean;
+    size(): number;
+    /** detached ACP 进程是进程组组长；用于识别其 Codex 子进程是否属于本 Runner。 */
+    ownerProcessGroupId(sessionId: string): number | undefined;
+    acquire(sessionId: string, match: {
+        cwd: string;
+        spawnKey: string;
+        envKey: string;
+        additionalDirectoriesKey: string;
+        mcpServersKey: string;
+    }): AcpSessionResources | null;
+    release(r: AcpSessionResources): void;
+    remove(sessionId: string): boolean;
+    close(sessionId: string, timeoutMs?: number): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    sweep(now?: number): void;
+    shutdown(): void;
+}
+//# sourceMappingURL=acp-session-pool.d.ts.map

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

@@ -0,0 +1,165 @@
+import { methods } from "@agentclientprotocol/sdk";
+import { killProcessTree } from "./acp-kill.js";
+import { raceWithAbort } from "./acp-race.js";
+const ACP_SESSION_CLOSE_TIMEOUT_MS = 30_000;
+const SWEEP_INTERVAL_MS = 60_000;
+export function resourcesAlive(r) {
+    return r.child.exitCode === null && r.child.signalCode === null;
+}
+/**
+ * 完整拆除一个会话：dispose 路由、关连接、杀整棵进程树。默认 SIGTERM + 2s SIGKILL
+ * 兜底；shutdown 路径传 SIGKILL 直杀——runner 马上 process.exit，unref 的兜底定时器
+ * 活不到触发，等宽限毫无意义。
+ */
+export function teardownResources(r, signal = "SIGTERM") {
+    try {
+        r.active.dispose();
+    }
+    catch {
+        // 已 dispose / 连接已死
+    }
+    try {
+        r.connection.close();
+    }
+    catch {
+        // 已关闭
+    }
+    killProcessTree(r.child, signal);
+    if (signal !== "SIGKILL") {
+        const child = r.child;
+        setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null) {
+                killProcessTree(child, "SIGKILL");
+            }
+        }, 2000).unref();
+    }
+}
+/**
+ * 长驻 ACP 会话池（check-out/check-in 模型）：
+ * - acquire 命中即把条目从池里取走（运行期不在池内）——同一 sessionId 的并发第二个
+ *   认领者（/resume 可让两个会话绑同一 id）自然 miss、走独立冷启动，无需 busy 锁；
+ * - release 在健康轮末把资源放回（池满先淘汰最久未用的）；
+ * - 出错/中断/超时一律不归还（由调用方 teardown），池只保留干净收尾的会话；
+ * - idle sweep 回收长时间没人用的进程；shutdown 必须在 runner 退出前调用
+ *  （子进程 detached，不会随 runner 死）。
+ */
+export class AcpSessionPool {
+    options;
+    idle = new Map();
+    sweepTimer;
+    constructor(options) {
+        this.options = options;
+        if (options.enabled) {
+            this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
+            this.sweepTimer.unref();
+        }
+    }
+    get enabled() {
+        return this.options.enabled;
+    }
+    size() {
+        return this.idle.size;
+    }
+    /** detached ACP 进程是进程组组长；用于识别其 Codex 子进程是否属于本 Runner。 */
+    ownerProcessGroupId(sessionId) {
+        return this.idle.get(sessionId)?.resources.child.pid;
+    }
+    acquire(sessionId, match) {
+        if (!this.options.enabled)
+            return null;
+        const entry = this.idle.get(sessionId);
+        if (!entry)
+            return null;
+        this.idle.delete(sessionId);
+        const r = entry.resources;
+        if (!resourcesAlive(r) ||
+            r.cwd !== match.cwd ||
+            r.spawnKey !== match.spawnKey ||
+            r.envKey !== match.envKey ||
+            r.additionalDirectoriesKey !== match.additionalDirectoriesKey
+            || r.mcpServersKey !== match.mcpServersKey) {
+            teardownResources(r);
+            return null;
+        }
+        return r;
+    }
+    release(r) {
+        if (!this.options.enabled || !resourcesAlive(r)) {
+            teardownResources(r);
+            return;
+        }
+        // 并发认领的旁路进程后到：同 id 已有空闲条目时不覆盖（否则先到者被泄漏），拆掉后来的
+        if (this.idle.has(r.sessionId)) {
+            teardownResources(r);
+            return;
+        }
+        while (this.idle.size >= this.options.maxPooled) {
+            let oldestId;
+            let oldestAt = Infinity;
+            for (const [id, entry] of this.idle) {
+                if (entry.lastUsedAt < oldestAt) {
+                    oldestAt = entry.lastUsedAt;
+                    oldestId = id;
+                }
+            }
+            if (oldestId === undefined)
+                break;
+            const evicted = this.idle.get(oldestId);
+            this.idle.delete(oldestId);
+            teardownResources(evicted.resources);
+        }
+        this.idle.set(r.sessionId, { resources: r, lastUsedAt: Date.now() });
+    }
+    remove(sessionId) {
+        const entry = this.idle.get(sessionId);
+        if (!entry)
+            return false;
+        this.idle.delete(sessionId);
+        teardownResources(entry.resources);
+        return true;
+    }
+    async close(sessionId, timeoutMs = ACP_SESSION_CLOSE_TIMEOUT_MS) {
+        const entry = this.idle.get(sessionId);
+        if (!entry)
+            return { ok: false, error: "not_owned" };
+        this.idle.delete(sessionId);
+        try {
+            if (!entry.resources.supportsClose) {
+                return {
+                    ok: false,
+                    error: "ACP agent 未声明 session/close 支持",
+                };
+            }
+            await raceWithAbort(entry.resources.connection.agent.request(methods.agent.session.close, { sessionId }), () => false, timeoutMs, "ACP session/close 超时");
+            return { ok: true };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        finally {
+            teardownResources(entry.resources);
+        }
+    }
+    sweep(now = Date.now()) {
+        for (const [id, entry] of [...this.idle.entries()]) {
+            if (!resourcesAlive(entry.resources) ||
+                now - entry.lastUsedAt >= this.options.idleMs) {
+                this.idle.delete(id);
+                teardownResources(entry.resources);
+            }
+        }
+    }
+    shutdown() {
+        if (this.sweepTimer)
+            clearInterval(this.sweepTimer);
+        for (const [id, entry] of [...this.idle.entries()]) {
+            this.idle.delete(id);
+            // runner 即将退出：直接 SIGKILL（空闲进程无在途工作，宽限期定时器也活不到）
+            teardownResources(entry.resources, "SIGKILL");
+        }
+    }
+}
+//# sourceMappingURL=acp-session-pool.js.map

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

@@ -0,0 +1,78 @@
+import { type ChildProcess } from "node:child_process";
+import { type ActiveSession, type ActiveSessionMessage, type ContentBlock, type SessionConfigOption } from "@agentclientprotocol/sdk";
+import type { AgentEvent, AcpPermissionPolicy, RunContext } from "@codebridge/core";
+import { type AcpSessionPool } from "./acp-session-pool.js";
+export interface AcpRunHandle {
+    child: ChildProcess;
+    cancel: () => void;
+    steer?: (prompt: string) => Promise<unknown>;
+}
+export interface AcpRunOptions {
+    permissionPolicy: AcpPermissionPolicy;
+    isAborted: () => boolean;
+    /** 子进程 stderr 快照，用于超时/失败时给出真实原因 */
+    readStderr?: () => string;
+    /** 测试用：覆盖下方三个超时常量 */
+    promptTimeoutMs?: number;
+    noOutputTimeoutMs?: number;
+    stallTimeoutMs?: number;
+    /** 主轮 stop 后，本轮起过 tool 时进入 drain；这么久内无“真实后台活动”视为无后台，返回 */
+    postStopProbeMs?: number;
+    /** drain 确认有后台后，这么久无新的真实活动视为后台真正结束 */
+    postStopQuietMs?: number;
+    /** drain 阶段独立硬上限（与主轮 20min deadline 各自计时） */
+    postStopMaxMs?: number;
+    /** drain 总开关，默认 true */
+    drainBackgroundWork?: boolean;
+    /**
+     * drain 磁盘活动标记（可选）：返回单调递增的数值（如会话文件合计字节数），
+     * 变化即视为后台仍在工作、刷新静默计时。wire 静默但磁盘在写时避免误切。
+     */
+    drainActivityMarker?: () => number | undefined;
+    /** prompt_feishu 权限模式：把权限请求交给外界决策（runner 的 broker 注入） */
+    requestDecision?: (info: {
+        title: string;
+    }) => Promise<boolean>;
+    /**
+     * 带外事件源（可选）：每个轮询 tick 取一批插入事件流。权限请求这类发生在
+     * 连接回调里的事件没法直接 yield，经它汇入 SSE。
+     */
+    pollOutOfBandEvents?: () => AgentEvent[];
+    /**
+     * 长驻会话池（可选）：命中即复用适配器进程，省每轮 spawn+initialize+resume。
+     * 未传 = 每轮 spawn/杀（旧行为）。
+     */
+    sessionPool?: AcpSessionPool;
+    /**
+     * 跨轮接力的 nextUpdate waiter（池模式必传池条目的 carrier）：SDK 队列 FIFO 且
+     * waiter 无法注销，被抛弃的 waiter 会吞掉下一条消息，必须原样接力。
+     */
+    updateCarrier?: {
+        pending: Promise<ActiveSessionMessage> | null;
+    };
+    /**
+     * 本轮结束后资源不可入池的信号（如 drain 硬上限放弃了仍在跑的后台任务）：
+     * fatal 标志驱动退出码/用户提示，不能复用它表达“别复用这个进程”。
+     */
+    markUnpoolable?: () => void;
+    /** session/update config_option_update 的原始快照回写（池复用跨轮保留） */
+    onConfigOptionsUpdate?: (options: SessionConfigOption[]) => void;
+    /** 预排干队列后、发新 prompt 前执行的配置应用钩子 */
+    beforePrompt?: () => Promise<AgentEvent[]>;
+}
+export declare function supportsAcpSteering(response: unknown): boolean;
+export declare function steerAcpSession(agent: {
+    request: (method: string, params: unknown) => Promise<unknown>;
+}, sessionId: string, prompt: string): Promise<unknown>;
+export declare function runActivePromptTurn(active: ActiveSession, blocks: ContentBlock[], options: AcpRunOptions): AsyncGenerator<AgentEvent>;
+/** 复用匹配键：spawn 命令与关键 env 在进程启动时冻结，任一变化都不能复用 */
+export declare function buildSessionMatchKeys(ctx: RunContext): {
+    spawnKey: string;
+    envKey: string;
+    additionalDirectoriesKey: string;
+    mcpServersKey: string;
+};
+export declare function runAcpSession(ctx: RunContext, options: AcpRunOptions, outHandle: {
+    current?: AcpRunHandle;
+}): AsyncGenerator<AgentEvent>;
+//# sourceMappingURL=acp-session-runner.d.ts.map