@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/backends/dist/acp/acp-config-options.js

@@ -0,0 +1,220 @@
+import { methods, } from "@agentclientprotocol/sdk";
+/** 展平 select 选项（可能是「分组」结构），拿到全部可选值 */
+function flattenSelectOptions(option) {
+    if (option.type !== "select")
+        return [];
+    const out = [];
+    for (const entry of option.options) {
+        if ("group" in entry)
+            out.push(...entry.options);
+        else
+            out.push(entry);
+    }
+    return out;
+}
+/**
+ * 把用户输入（如 `sonnet` / `opus` / `medium`）匹配到 advertise 的某个 value id：
+ * 精确 value → 大小写不敏感 name → 大小写不敏感 value 前缀（把 `opus` 映射到 `opus[1m]`）。
+ * 匹配不到返回 undefined。
+ */
+const TRAILING_BRACKET_HINT = /\[[^\]]*\]$/;
+/** 去掉末尾一个方括号提示（如 `[1m]`），供上下文窗口变体不一致时兜底匹配 */
+function stripTrailingHint(value) {
+    return value.replace(TRAILING_BRACKET_HINT, "");
+}
+export function matchConfigValue(option, desired) {
+    const opts = flattenSelectOptions(option);
+    const want = desired.trim().toLowerCase();
+    const wantStripped = stripTrailingHint(want);
+    return (opts.find((o) => o.value.toLowerCase() === want)?.value ??
+        opts.find((o) => o.name.toLowerCase() === want)?.value ??
+        opts.find((o) => o.value.toLowerCase().startsWith(want))?.value ??
+        opts.find((o) => stripTrailingHint(o.value.toLowerCase()) === wantStripped)
+            ?.value);
+}
+/**
+ * 由 RunContext + 全局 permission 策略解析本轮想要的三项 ACP 配置：
+ * - model/effort：有则设、无则不设（尊重适配器默认）；
+ * - mode：三个后端都接受 `/permission` 的显式会话覆盖；Claude 未覆盖时再使用兼容配置或
+ *   acpPermissionPolicy 推导默认值，让 requestPermission 处理器与全局策略保持一致。
+ */
+export function resolveDesiredConfig(ctx, permissionPolicy) {
+    const bc = ctx.backendConfig;
+    const desired = {
+        model: ctx.model ?? bc.model,
+        effort: ctx.effort ?? bc.effort,
+        permissionMode: ctx.mode,
+        strictModel: bc.strictModel ?? false,
+    };
+    if (bc.type === "claude-code") {
+        // prompt_deny / prompt_feishu 都需要适配器真的「发问」（default 模式）：
+        // prompt_deny 由客户端 handler 拒，prompt_feishu 转发飞书等 /approve。
+        // 只有 auto_allow 才使用 bypassPermissions（不问直接放行）。
+        desired.permissionMode ??=
+            ctx.claudePermissionMode ??
+                bc.claudePermissionMode ??
+                (permissionPolicy === "auto_allow" ? "bypassPermissions" : "default");
+    }
+    return desired;
+}
+/**
+ * 把 SDK 的 configOptions（含分组 select）映射为跨包共享的精简形态，供 /model 等
+ * 动态列表展示。select 和 boolean 都保留，供 /model 与通用 /config 使用。
+ */
+export function mapSessionConfigOptions(options) {
+    const out = [];
+    for (const option of options) {
+        if (option.type === "boolean") {
+            out.push({
+                id: option.id,
+                name: option.name,
+                type: "boolean",
+                category: option.category ?? undefined,
+                currentValue: String(option.currentValue),
+                values: [
+                    { value: "true", name: "On" },
+                    { value: "false", name: "Off" },
+                ],
+            });
+            continue;
+        }
+        out.push({
+            id: option.id,
+            name: option.name,
+            type: "select",
+            category: option.category ?? undefined,
+            currentValue: option.currentValue,
+            values: flattenSelectOptions(option).map((v) => ({
+                value: v.value,
+                name: v.name || undefined,
+                description: v.description ?? undefined,
+            })),
+        });
+    }
+    return out;
+}
+/** desired 里想设的项与 advertise 选项的 category 映射 */
+const CATEGORY_BY_FIELD = {
+    model: "model",
+    effort: "thought_level",
+    permissionMode: "mode",
+};
+/**
+ * 会话打开后、首个 prompt 之前，用 ACP 标准 `session/set_config_option`（Zed 同款机制）把
+ * 想要的 model/effort/permission 应用到会话上。适配器 advertise 的选项来自
+ * `newSessionResponse.configOptions`（新建 + claude 续聊均带）。每次运行都要重设：续聊到新
+ * 适配器进程时 model 会退回适配器默认（实测 Fable 5）。匹配不到的项只收集非致命 warning、不中断
+ * ——适配器没有对应 category 时就自然跳过（除非 desired.strictModel 对 model 字段要求硬失败）。
+ */
+export async function applySessionConfigOptions(agent, sessionId, configOptions, desired, custom = {}) {
+    const warnings = [];
+    let currentOptions = configOptions;
+    let modelMismatch;
+    for (const [field, category] of Object.entries(CATEGORY_BY_FIELD)) {
+        const wanted = desired[field];
+        if (!wanted || typeof wanted !== "string")
+            continue;
+        const option = currentOptions.find((o) => o.category === category);
+        if (!option) {
+            if (field === "model" && desired.strictModel) {
+                throw new Error(`ACP model=${wanted} 未生效：当前会话未提供 model 配置项（strictModel 已启用，本轮已终止）。`);
+            }
+            warnings.push(`ACP 会话未提供 ${field} 选项，${field}=${wanted} 未生效。`);
+            if (field === "model")
+                modelMismatch = { requested: wanted };
+            continue;
+        }
+        const value = matchConfigValue(option, wanted);
+        if (!value) {
+            const offered = flattenSelectOptions(option).map((o) => o.value);
+            const offeredText = offered.length > 0 ? offered.join("、") : "（空）";
+            console.warn(`[acp-config-options] session=${sessionId} field=${field} wanted=${wanted} offered=[${offeredText}] currentValue=${String(option.currentValue)}`);
+            if (field === "model" && desired.strictModel) {
+                throw new Error(`ACP model=${wanted} 不在可选值内（strictModel 已启用，本轮已终止）。 适配器本次提供：${offeredText}。`);
+            }
+            warnings.push(`ACP ${field}=${wanted} 不在可选值内，未生效。 适配器本次提供：${offeredText}。`);
+            if (field === "model") {
+                modelMismatch = {
+                    requested: wanted,
+                    ...(typeof option.currentValue === "string"
+                        ? { effective: option.currentValue }
+                        : {}),
+                };
+            }
+            continue;
+        }
+        try {
+            const response = await agent.request(methods.agent.session.setConfigOption, {
+                sessionId,
+                configId: option.id,
+                value,
+            });
+            currentOptions = response.configOptions;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`ACP 设置 ${field}=${value} 失败：${msg}`);
+            if (field === "model") {
+                modelMismatch = {
+                    requested: wanted,
+                    ...(typeof option.currentValue === "string"
+                        ? { effective: option.currentValue }
+                        : {}),
+                };
+            }
+        }
+    }
+    for (const [configId, wanted] of Object.entries(custom)) {
+        const option = currentOptions.find((candidate) => candidate.id === configId);
+        if (!option) {
+            warnings.push(`ACP config=${configId} 未在当前会话能力中找到，未生效。`);
+            continue;
+        }
+        let params;
+        if (option.type === "boolean") {
+            if (typeof wanted !== "boolean") {
+                warnings.push(`ACP config=${configId} 需要 boolean 值，未生效。`);
+                continue;
+            }
+            params = { sessionId, configId, type: "boolean", value: wanted };
+        }
+        else {
+            if (typeof wanted !== "string") {
+                warnings.push(`ACP config=${configId} 需要 select 值，未生效。`);
+                continue;
+            }
+            const value = matchConfigValue(option, wanted);
+            if (!value) {
+                warnings.push(`ACP config=${configId}=${wanted} 不在可选值内，未生效。`);
+                continue;
+            }
+            params = { sessionId, configId, value };
+        }
+        try {
+            const response = (await agent.request(methods.agent.session.setConfigOption, params));
+            currentOptions = response.configOptions;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`ACP 设置 config=${configId} 失败：${msg}`);
+        }
+    }
+    // 读回本轮 set-config 回合后 model 分类的实际 currentValue：适配器可能规范化了 value，
+    // 或（未 strictModel 时）压根没采纳 desired.model，这里给上层一个真相来源而非「想要的值」。
+    const modelOption = currentOptions.find((o) => o.category === "model");
+    const modelCurrentValue = modelOption?.currentValue;
+    const effectiveModel = typeof modelCurrentValue === "string" ? modelCurrentValue : undefined;
+    if (modelMismatch && effectiveModel !== undefined) {
+        modelMismatch = { ...modelMismatch, effective: effectiveModel };
+    }
+    // 适配器的 value 是机器口径（`opus[1m]`、`grok-4.6[effort=high,fast=true]`），
+    // 同一条目自带可读的 name（`Opus 5`、`grok-4.6`）。带上 name，让上层能说人话。
+    if (modelMismatch?.effective && modelOption) {
+        const name = flattenSelectOptions(modelOption).find((candidate) => candidate.value === modelMismatch.effective)?.name;
+        if (name && name !== modelMismatch.effective) {
+            modelMismatch = { ...modelMismatch, effectiveName: name };
+        }
+    }
+    return { warnings, configOptions: currentOptions, effectiveModel, modelMismatch };
+}
+//# sourceMappingURL=acp-config-options.js.map

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

@@ -0,0 +1,3 @@
+import type { BackendProfile, DoctorResult } from "@codebridge/core";
+export declare function detectBackend(id: string, profile: BackendProfile, cwd: string): Promise<DoctorResult>;
+//# sourceMappingURL=acp-doctor.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-doctor.js

@@ -0,0 +1,18 @@
+import { probeAcpInitialize } from "./acp-session-list.js";
+import { probePiSdk } from "../pi-session-runner.js";
+export async function detectBackend(id, profile, cwd) {
+    const acp = profile.type === "pi-sdk"
+        ? await probePiSdk(cwd)
+        : await probeAcpInitialize(profile, cwd);
+    return {
+        ok: acp.ok,
+        checks: [
+            {
+                name: `${id}:${profile.type === "pi-sdk" ? "sdk" : "acp-initialize"}`,
+                ok: acp.ok,
+                message: acp.message,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=acp-doctor.js.map

package/node_modules/@codebridge/backends/dist/acp/acp-event-mapper.d.ts

@@ -0,0 +1,5 @@
+import type { AgentEvent } from "@codebridge/core";
+import type { SessionUpdate } from "@agentclientprotocol/sdk";
+/** Map ACP session/update payloads to bridge AgentEvent stream. */
+export declare function mapSessionUpdate(update: SessionUpdate): AgentEvent[];
+//# sourceMappingURL=acp-event-mapper.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-event-mapper.js

@@ -0,0 +1,136 @@
+import { mapSessionConfigOptions } from "./acp-config-options.js";
+function codexMessagePhase(update) {
+    const phase = update._meta?.codex?.phase;
+    return phase === "commentary" || phase === "final_answer"
+        ? phase
+        : undefined;
+}
+function textFromContent(content) {
+    if (content.type === "text" && typeof content.text === "string") {
+        return content.text;
+    }
+    return undefined;
+}
+/** Map ACP session/update payloads to bridge AgentEvent stream. */
+export function mapSessionUpdate(update) {
+    switch (update.sessionUpdate) {
+        case "agent_message_chunk": {
+            const text = textFromContent(update.content);
+            const phase = codexMessagePhase(update);
+            return text
+                ? [
+                    {
+                        type: "text_delta",
+                        text,
+                        ...(update.messageId ? { messageId: update.messageId } : {}),
+                        ...(phase ? { phase } : {}),
+                    },
+                ]
+                : [];
+        }
+        case "agent_thought_chunk": {
+            const text = textFromContent(update.content);
+            return text
+                ? [
+                    {
+                        type: "thought_delta",
+                        text,
+                        ...(update.messageId ? { messageId: update.messageId } : {}),
+                    },
+                ]
+                : [];
+        }
+        case "tool_call": {
+            const name = update.title || update.kind || "tool";
+            return [
+                {
+                    type: "tool_start",
+                    toolCallId: update.toolCallId,
+                    name,
+                    ...(update.kind ? { kind: update.kind } : {}),
+                    ...(update.status ? { status: update.status } : {}),
+                    input: update.rawInput ?? update,
+                    ...(update.content ? { content: update.content } : {}),
+                    ...(update.locations ? { locations: update.locations } : {}),
+                },
+            ];
+        }
+        case "tool_call_update": {
+            const name = update.title || update.kind;
+            if (update.status === "completed" || update.status === "failed") {
+                return [
+                    {
+                        type: "tool_end",
+                        toolCallId: update.toolCallId,
+                        ...(name ? { name } : {}),
+                        ...(update.status ? { status: update.status } : {}),
+                        ...(update.rawOutput !== undefined
+                            ? { output: update.rawOutput }
+                            : {}),
+                        ...(update.content ? { content: update.content } : {}),
+                        ...(update.locations ? { locations: update.locations } : {}),
+                    },
+                ];
+            }
+            return [
+                {
+                    type: "tool_update",
+                    toolCallId: update.toolCallId,
+                    ...(name ? { name } : {}),
+                    ...(update.status ? { status: update.status } : {}),
+                    ...(update.content ? { content: update.content } : {}),
+                    ...(update.locations ? { locations: update.locations } : {}),
+                    ...(update.rawOutput !== undefined
+                        ? { output: update.rawOutput }
+                        : {}),
+                },
+            ];
+        }
+        case "plan":
+            return [{ type: "plan", entries: update.entries }];
+        case "plan_update":
+            return [{ type: "plan_update", plan: update.plan }];
+        case "plan_removed":
+            return [{ type: "plan_removed", planId: update.planId }];
+        case "available_commands_update":
+            return [
+                {
+                    type: "available_commands_update",
+                    availableCommands: update.availableCommands,
+                },
+            ];
+        case "current_mode_update":
+            return [
+                { type: "current_mode_update", currentModeId: update.currentModeId },
+            ];
+        case "config_option_update":
+            return [
+                {
+                    type: "config_option_update",
+                    configOptions: mapSessionConfigOptions(update.configOptions),
+                },
+            ];
+        case "session_info_update":
+            return [
+                {
+                    type: "session_info_update",
+                    ...(update.title !== undefined ? { title: update.title } : {}),
+                    ...(update.updatedAt !== undefined
+                        ? { updatedAt: update.updatedAt }
+                        : {}),
+                },
+            ];
+        case "usage_update":
+            return [
+                {
+                    type: "usage_update",
+                    used: update.used,
+                    size: update.size,
+                    ...(update.cost !== undefined ? { cost: update.cost } : {}),
+                },
+            ];
+        default:
+            return [];
+    }
+}
+//# sourceMappingURL=acp-event-mapper.js.map

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

@@ -0,0 +1,10 @@
+import type { ChildProcess } from "node:child_process";
+/**
+ * 杀掉 agent 子进程的整棵进程树。适配器链常有孙进程（如 codex-acp 底下的
+ * `codex app-server`）：SIGTERM 会沿链转发、全树退出，但 SIGKILL 不转发——
+ * 兜底升级到 SIGKILL 时只杀包装进程会把孙进程留成孤儿。因此 spawn 时用
+ * `detached: true` 让子进程自成进程组，这里对整组（-pid）发信号；万一组
+ * 信号失败（进程已死/平台差异）退回单进程 kill。
+ */
+export declare function killProcessTree(child: ChildProcess, signal: NodeJS.Signals): void;
+//# sourceMappingURL=acp-kill.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-kill.js

@@ -0,0 +1,24 @@
+/**
+ * 杀掉 agent 子进程的整棵进程树。适配器链常有孙进程（如 codex-acp 底下的
+ * `codex app-server`）：SIGTERM 会沿链转发、全树退出，但 SIGKILL 不转发——
+ * 兜底升级到 SIGKILL 时只杀包装进程会把孙进程留成孤儿。因此 spawn 时用
+ * `detached: true` 让子进程自成进程组，这里对整组（-pid）发信号；万一组
+ * 信号失败（进程已死/平台差异）退回单进程 kill。
+ */
+export function killProcessTree(child, signal) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // 进程已不存在
+        }
+    }
+}
+//# sourceMappingURL=acp-kill.js.map

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

@@ -0,0 +1,6 @@
+export declare class AcpTimeoutError extends Error {
+    constructor(message: string);
+}
+/** 轮询 abort + 总超时，避免 session/load 等 RPC 永久挂起 */
+export declare function raceWithAbort<T>(promise: Promise<T>, isAborted: () => boolean, timeoutMs: number, timeoutMessage: string): Promise<T>;
+//# sourceMappingURL=acp-race.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-race.js

@@ -0,0 +1,29 @@
+export class AcpTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AcpTimeoutError";
+    }
+}
+async function sleep(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+}
+/** 轮询 abort + 总超时，避免 session/load 等 RPC 永久挂起 */
+export async function raceWithAbort(promise, isAborted, timeoutMs, timeoutMessage) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        if (isAborted()) {
+            throw new Error("aborted");
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            throw new AcpTimeoutError(timeoutMessage);
+        }
+        const result = await Promise.race([
+            promise,
+            sleep(Math.min(remaining, 40)).then(() => "tick"),
+        ]);
+        if (result !== "tick")
+            return result;
+    }
+}
+//# sourceMappingURL=acp-race.js.map

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

@@ -0,0 +1,32 @@
+import { type ListSessionsRequest, type ListSessionsResponse, type SessionUpdate } from "@agentclientprotocol/sdk";
+import type { BackendConfigOption, BackendProfile } from "@codebridge/core";
+import type { CliSessionSummary, ProviderSessionHistoryEvent } from "../session-discovery.js";
+export declare function collectAcpSessionHistory(updates: Array<{
+    sessionId: string;
+    update: SessionUpdate;
+}>): ProviderSessionHistoryEvent[];
+export declare function loadAcpSessionHistory(backendId: string, profile: BackendProfile, cwd: string, sessionId: string, options?: {
+    additionalDirectories?: string[];
+}): Promise<ProviderSessionHistoryEvent[]>;
+export declare function hasAcpSessionCapability(response: unknown, capability: "close" | "delete" | "resume"): boolean;
+export declare function deleteAcpSession(profile: BackendProfile, cwd: string, sessionId: string, timeoutMs?: number): Promise<void>;
+export declare function listAcpSessions(backendId: string, profile: BackendProfile, cwd: string, options?: {
+    limit?: number;
+    all?: boolean;
+}): Promise<CliSessionSummary[]>;
+export declare function collectAcpSessions(backendId: string, cwd: string, requestPage: (params: ListSessionsRequest) => Promise<ListSessionsResponse>, options?: {
+    limit?: number;
+    all?: boolean;
+}): Promise<CliSessionSummary[]>;
+/**
+ * 拉取 ACP 适配器 advertise 的会话配置项（/model 动态列表用）：短暂 spawn 适配器，
+ * initialize + session/new 读 configOptions 后立即销毁。不发 prompt，无推理成本；
+ * claude 适配器对未发过 prompt 的会话不持久化（实测 resume 报 Resource not found）。
+ * 超时/失败直接抛出，调用方展示 adapter 的真实错误，不回退到过期静态列表。
+ */
+export declare function listAcpConfigOptions(profile: BackendProfile, cwd: string, timeoutMs?: number): Promise<BackendConfigOption[]>;
+export declare function probeAcpInitialize(profile: BackendProfile, cwd: string, timeoutMs?: number): Promise<{
+    ok: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=acp-session-list.d.ts.map