@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/agent-registry/dist/index.js

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { cloneSetupManifest, cloneSetupState, projectAgentStatus, projectSetupState, } from "./setup.js";
+const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+export class AgentRegistry {
+    profiles = new Map();
+    database;
+    constructor(options = {}) {
+        const databasePath = options.databasePath ?? ":memory:";
+        if (databasePath !== ":memory:")
+            fs.mkdirSync(path.dirname(databasePath), { recursive: true });
+        this.database = new DatabaseSync(databasePath);
+        this.database.exec(`
+      CREATE TABLE IF NOT EXISTS agent_health (
+        agent_id TEXT PRIMARY KEY,
+        status TEXT NOT NULL,
+        checked_at TEXT,
+        error TEXT
+      );
+    `);
+    }
+    register(profile) {
+        const persisted = this.getHealth(profile.agentId);
+        const existing = this.profiles.get(profile.agentId);
+        const setup = cloneSetupState(profile.setup ?? existing?.setup);
+        const setupManifest = cloneSetupManifest(profile.setupManifest ?? existing?.setupManifest);
+        const nextSetup = setup ? mergeSetupWithHealth(setup, persisted) : undefined;
+        const status = nextSetup ? projectAgentStatus(nextSetup) : persisted?.status ?? profile.status;
+        this.profiles.set(profile.agentId, {
+            ...profile,
+            status,
+            setup: nextSetup,
+            setupManifest,
+            capabilities: [...profile.capabilities],
+            models: [...profile.models],
+            sessionFeatures: [...profile.sessionFeatures],
+        });
+        return this.get(profile.agentId);
+    }
+    async refresh(adapter) {
+        const profile = this.get(adapter.agentId);
+        if (!profile)
+            return undefined;
+        let runtime;
+        let error = null;
+        try {
+            runtime = await adapter.health();
+        }
+        catch (cause) {
+            runtime = "unavailable";
+            error = cause instanceof Error ? cause.message : String(cause);
+        }
+        if (profile.setup) {
+            const diagnostic = runtime === "healthy"
+                ? undefined
+                : {
+                    stage: "health",
+                    code: error ? "health_check_failed" : "runtime_unavailable",
+                    message: error ?? "Agent runtime unavailable",
+                    details: error ?? undefined,
+                };
+            return this.updateSetup(profile.agentId, {
+                installation: profile.setup.installation,
+                configuration: profile.setup.configuration,
+                runtime,
+                version: profile.setup.version,
+                executablePath: profile.setup.executablePath,
+                diagnostic,
+            });
+        }
+        const status = runtime === "healthy" ? "healthy" : "unavailable";
+        this.persistHealth(profile.agentId, status, error);
+        profile.status = status;
+        return this.register(profile);
+    }
+    updateSetup(agentId, setup) {
+        const existing = this.profiles.get(agentId);
+        if (!existing)
+            return undefined;
+        const nextSetup = projectSetupState(setup);
+        const next = {
+            ...existing,
+            status: projectAgentStatus(nextSetup),
+            setup: nextSetup,
+            setupManifest: cloneSetupManifest(existing.setupManifest),
+            capabilities: [...existing.capabilities],
+            models: [...existing.models],
+            sessionFeatures: [...existing.sessionFeatures],
+        };
+        this.profiles.set(agentId, next);
+        this.persistHealth(agentId, next.status, nextSetup.diagnostic?.message ?? null);
+        return this.get(agentId);
+    }
+    getHealth(agentId) {
+        const row = this.database.prepare("SELECT * FROM agent_health WHERE agent_id = ?").get(agentId);
+        if (!row)
+            return undefined;
+        return {
+            agentId: String(row.agent_id),
+            status: String(row.status),
+            checkedAt: row.checked_at === null ? null : String(row.checked_at),
+            error: row.error === null ? null : String(row.error),
+        };
+    }
+    startHealthChecks(adapters, intervalMs = 30_000) {
+        const refresh = () => { for (const adapter of adapters)
+            void this.refresh(adapter); };
+        refresh();
+        const timer = setInterval(refresh, intervalMs);
+        timer.unref?.();
+        return () => clearInterval(timer);
+    }
+    get(agentId) {
+        const profile = this.profiles.get(agentId);
+        return profile ? clone(profile) : undefined;
+    }
+    list() {
+        return [...this.profiles.values()].map(clone);
+    }
+    close() {
+        if (this.database.isOpen)
+            this.database.close();
+    }
+    persistHealth(agentId, status, error) {
+        this.database
+            .prepare(`INSERT INTO agent_health (agent_id, status, checked_at, error)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(agent_id) DO UPDATE SET status = excluded.status,
+           checked_at = excluded.checked_at, error = excluded.error`)
+            .run(agentId, status, new Date().toISOString(), error);
+    }
+}
+function clone(profile) {
+    return {
+        ...profile,
+        capabilities: [...profile.capabilities],
+        models: [...profile.models],
+        sessionFeatures: [...profile.sessionFeatures],
+        setup: cloneSetupState(profile.setup),
+        setupManifest: cloneSetupManifest(profile.setupManifest),
+    };
+}
+function mergeSetupWithHealth(setup, persisted) {
+    if (!persisted)
+        return projectSetupState({
+            installation: setup.installation,
+            configuration: setup.configuration,
+            runtime: setup.runtime,
+            version: setup.version,
+            executablePath: setup.executablePath,
+            diagnostic: cloneDiagnostic(setup.diagnostic),
+        });
+    const runtime = persisted.status === "healthy" || persisted.status === "unavailable"
+        ? persisted.status
+        : setup.runtime;
+    return projectSetupState({
+        installation: setup.installation,
+        configuration: setup.configuration,
+        runtime,
+        version: setup.version,
+        executablePath: setup.executablePath,
+        diagnostic: persisted.error
+            ? {
+                stage: "health",
+                code: persisted.status === "healthy" ? "healthy" : "runtime_unavailable",
+                message: persisted.error,
+                details: persisted.error,
+            }
+            : cloneDiagnostic(setup.diagnostic),
+    });
+}
+function cloneDiagnostic(diagnostic) {
+    return diagnostic ? { ...diagnostic } : undefined;
+}
+export { cloneSetupManifest, cloneSetupState, getSupportedAgentSetupManifest, projectAgentStatus, projectSetupState, supportedAgentSetupManifestMap, supportedAgentSetupManifests, } from "./setup.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/agent-registry/dist/setup.d.ts

@@ -0,0 +1,9 @@
+import type { AgentProfile, AgentSetupManifest, AgentSetupState } from "@codebridge/session-catalog";
+export declare const supportedAgentSetupManifests: AgentSetupManifest[];
+export declare const supportedAgentSetupManifestMap: Map<string, AgentSetupManifest>;
+export declare function getSupportedAgentSetupManifest(agentId: string): AgentSetupManifest | undefined;
+export declare function projectSetupState(state: Omit<AgentSetupState, "canSelectDefault" | "canCreateSession">): AgentSetupState;
+export declare function projectAgentStatus(state: Pick<AgentSetupState, "installation" | "configuration" | "runtime">): AgentProfile["status"];
+export declare function cloneSetupState(state: AgentSetupState | undefined): AgentSetupState | undefined;
+export declare function cloneSetupManifest(manifest: AgentSetupManifest | undefined): AgentSetupManifest | undefined;
+//# sourceMappingURL=setup.d.ts.map

package/node_modules/@codebridge/agent-registry/dist/setup.js

@@ -0,0 +1,115 @@
+export const supportedAgentSetupManifests = [
+    {
+        agentId: "codex",
+        displayName: "Codex",
+        adapter: "acp",
+        installStrategies: [
+            {
+                id: "npm-global",
+                label: "Install Codex globally",
+                command: "npm",
+                args: ["install", "-g", "@openai/codex"],
+                available: true,
+                requiresConfirmation: true,
+            },
+        ],
+        configurationOwner: "agent",
+        documentationUrl: "https://developers.openai.com/codex/",
+        supportsManagedConfiguration: false,
+    },
+    {
+        agentId: "pi",
+        displayName: "Pi",
+        adapter: "sdk",
+        installStrategies: [],
+        configurationOwner: "codebridge",
+        configurationPath: "~/.pi/agent/models.json",
+        documentationUrl: "https://docs.orchestration/agent-providers#pi",
+        supportsManagedConfiguration: true,
+    },
+    {
+        agentId: "cursor",
+        displayName: "Cursor",
+        adapter: "acp",
+        installStrategies: [],
+        configurationOwner: "agent",
+        documentationUrl: "https://cursor.com/",
+        supportsManagedConfiguration: false,
+    },
+    {
+        agentId: "claude",
+        displayName: "Claude Code",
+        adapter: "acp",
+        installStrategies: [
+            {
+                id: "npm-global",
+                label: "Install Claude Code globally",
+                command: "npm",
+                args: ["install", "-g", "@anthropic-ai/claude-code"],
+                available: true,
+                requiresConfirmation: true,
+            },
+        ],
+        configurationOwner: "agent",
+        documentationUrl: "https://docs.anthropic.com/en/docs/claude-code",
+        supportsManagedConfiguration: false,
+    },
+    {
+        agentId: "opencode",
+        displayName: "OpenCode",
+        adapter: "acp",
+        installStrategies: [
+            {
+                id: "npm-global",
+                label: "Install OpenCode globally",
+                command: "npm",
+                args: ["install", "-g", "opencode-ai"],
+                available: true,
+                requiresConfirmation: true,
+            },
+        ],
+        configurationOwner: "agent",
+        configurationPath: "~/.config/opencode/opencode.json",
+        documentationUrl: "https://opencode.ai/docs/cli/",
+        supportsManagedConfiguration: false,
+    },
+];
+export const supportedAgentSetupManifestMap = new Map(supportedAgentSetupManifests.map((manifest) => [manifest.agentId, manifest]));
+export function getSupportedAgentSetupManifest(agentId) {
+    return supportedAgentSetupManifestMap.get(agentId);
+}
+export function projectSetupState(state) {
+    const canSelectDefault = state.installation === "installed" &&
+        state.configuration === "configured";
+    return {
+        ...state,
+        canSelectDefault,
+        canCreateSession: canSelectDefault && state.runtime === "healthy",
+    };
+}
+export function projectAgentStatus(state) {
+    if (state.installation !== "installed" || state.configuration !== "configured") {
+        return "needs_setup";
+    }
+    return state.runtime === "healthy" ? "healthy" : "unavailable";
+}
+export function cloneSetupState(state) {
+    if (!state)
+        return undefined;
+    return {
+        ...state,
+        diagnostic: state.diagnostic ? { ...state.diagnostic } : undefined,
+    };
+}
+export function cloneSetupManifest(manifest) {
+    if (!manifest)
+        return undefined;
+    return {
+        ...manifest,
+        installStrategies: manifest.installStrategies.map((strategy) => ({
+            ...strategy,
+            args: [...strategy.args],
+        })),
+    };
+}
+//# sourceMappingURL=setup.js.map

package/node_modules/@codebridge/agent-registry/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@codebridge/agent-registry",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/session-catalog": "0.1.0"
+  }
+}

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

@@ -0,0 +1,12 @@
+import { type ActiveSession, type ClientConnection, type McpServer } from "@agentclientprotocol/sdk";
+import type { BackendProfile, RunContext } from "@codebridge/core";
+export declare const ACP_LOAD_TIMEOUT_MS = 60000;
+export interface OpenActiveSessionOptions {
+    isAborted?: () => boolean;
+    loadTimeoutMs?: number;
+    supportsAdditionalDirectories?: boolean;
+    mcpServers?: readonly McpServer[];
+}
+/** 与 Zed 一致：new / load / resume 后均使用 ActiveSession */
+export declare function openActiveSession(connection: ClientConnection, ctx: RunContext, backendConfig: BackendProfile, options?: OpenActiveSessionOptions): Promise<ActiveSession>;
+//# sourceMappingURL=acp-active-session.d.ts.map

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

@@ -0,0 +1,57 @@
+import { methods, } from "@agentclientprotocol/sdk";
+import { acpContinueMethod } from "./acp-spawn-profiles.js";
+import { raceWithAbort } from "./acp-race.js";
+export const ACP_LOAD_TIMEOUT_MS = 60_000;
+function attachActiveSession(agent, sessionId, response) {
+    const attach = agent.attachSession;
+    if (typeof attach !== "function") {
+        throw new Error("ACP SDK 缺少 attachSession，无法续聊");
+    }
+    // claude 的 session/resume 会回传 configOptions（实测 keys: sessionId/modes/configOptions）。
+    // 用完整响应 attach，让 newSessionResponse.configOptions 非空、与新建会话对称，后续
+    // applySessionConfigOptions 才能在续聊时重设 model/effort/permission（续聊到新适配器进程
+    // model 会退回默认）。cursor 的 session/load 响应为空则退回仅带 sessionId。
+    const full = response && typeof response === "object" && "configOptions" in response
+        ? { ...response, sessionId }
+        : { sessionId };
+    return attach.call(agent, full);
+}
+/** 与 Zed 一致：new / load / resume 后均使用 ActiveSession */
+export async function openActiveSession(connection, ctx, backendConfig, options = {}) {
+    const agent = connection.agent;
+    const isAborted = options.isAborted ?? (() => false);
+    const loadTimeoutMs = options.loadTimeoutMs ?? ACP_LOAD_TIMEOUT_MS;
+    const additionalDirectories = ctx.additionalDirectories?.length
+        ? ctx.additionalDirectories
+        : undefined;
+    const mcpServers = [...(options.mcpServers ?? [])];
+    if (additionalDirectories && !options.supportsAdditionalDirectories) {
+        throw new Error("ACP agent 未声明 additionalDirectories 支持，无法扩展工作目录。");
+    }
+    const startNewSession = () => {
+        const builder = additionalDirectories || mcpServers.length
+            ? agent.buildSession({
+                cwd: ctx.cwd,
+                ...(additionalDirectories ? { additionalDirectories } : {}),
+                mcpServers,
+            })
+            : agent.buildSession(ctx.cwd);
+        return raceWithAbort(builder.start(), isAborted, loadTimeoutMs, "ACP session 创建超时");
+    };
+    if (!ctx.resumeSessionId) {
+        return startNewSession();
+    }
+    const sessionId = ctx.resumeSessionId;
+    const params = {
+        sessionId,
+        cwd: ctx.cwd,
+        ...(additionalDirectories ? { additionalDirectories } : {}),
+        mcpServers,
+    };
+    const loadMethod = acpContinueMethod(backendConfig) === "session/load"
+        ? methods.agent.session.load
+        : methods.agent.session.resume;
+    const response = await raceWithAbort(agent.request(loadMethod, params), isAborted, loadTimeoutMs, "ACP session 续聊超时");
+    return attachActiveSession(agent, sessionId, response);
+}
+//# sourceMappingURL=acp-active-session.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * claude 会话的磁盘活动标记（drain 精确信号，借鉴 codeg 的 background-watch 思路）：
+ * 后台子 agent 的输出写在 `<projectDir>/<sessionId>/subagents/*.jsonl`（独立文件，
+ * ACP wire 上可能长时间静默），唤醒与汇总写回主 `<sessionId>.jsonl`。两者合计字节数
+ * 单调递增，任何增长都代表后台仍在工作——drain 用它刷新静默计时，避免子 agent
+ * 静默期超过 quiet 窗被误切。读取失败返回 undefined（不影响 wire 信号）。
+ */
+export declare function createClaudeSessionActivityMarker(cwd: string, sessionId: string): () => number | undefined;
+//# sourceMappingURL=acp-claude-activity.d.ts.map

package/node_modules/@codebridge/backends/dist/acp/acp-claude-activity.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { encodeClaudeProjectDir } from "../session-discovery.js";
+/**
+ * claude 会话的磁盘活动标记（drain 精确信号，借鉴 codeg 的 background-watch 思路）：
+ * 后台子 agent 的输出写在 `<projectDir>/<sessionId>/subagents/*.jsonl`（独立文件，
+ * ACP wire 上可能长时间静默），唤醒与汇总写回主 `<sessionId>.jsonl`。两者合计字节数
+ * 单调递增，任何增长都代表后台仍在工作——drain 用它刷新静默计时，避免子 agent
+ * 静默期超过 quiet 窗被误切。读取失败返回 undefined（不影响 wire 信号）。
+ */
+export function createClaudeSessionActivityMarker(cwd, sessionId) {
+    const projectDir = path.join(os.homedir(), ".claude", "projects", encodeClaudeProjectDir(cwd));
+    const mainFile = path.join(projectDir, `${sessionId}.jsonl`);
+    const sessionDir = path.join(projectDir, sessionId);
+    return () => {
+        let total;
+        try {
+            total = fs.statSync(mainFile).size;
+        }
+        catch {
+            // 主文件还没建（会话尚未写盘）
+        }
+        try {
+            const stack = [sessionDir];
+            while (stack.length > 0) {
+                const dir = stack.pop();
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    const full = path.join(dir, entry.name);
+                    if (entry.isDirectory())
+                        stack.push(full);
+                    else {
+                        try {
+                            total = (total ?? 0) + fs.statSync(full).size;
+                        }
+                        catch {
+                            // 文件在 stat 前被移走，忽略
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // 子目录不存在（无后台子 agent）
+        }
+        return total;
+    };
+}
+//# sourceMappingURL=acp-claude-activity.js.map

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

@@ -0,0 +1,46 @@
+import { type ClientConnection, type SessionConfigOption } from "@agentclientprotocol/sdk";
+import type { AcpPermissionPolicy, BackendConfigOption, RunContext } from "@codebridge/core";
+type Agent = ClientConnection["agent"];
+export interface DesiredSessionConfig {
+    model?: string;
+    effort?: string;
+    permissionMode?: string;
+    /** true 时，想要的 model 不在适配器可选值内会直接抛错中止本轮，而非静默沿用适配器默认 */
+    strictModel?: boolean;
+}
+export type CustomSessionConfig = Record<string, string | boolean>;
+export declare function matchConfigValue(option: SessionConfigOption, desired: string): string | undefined;
+/**
+ * 由 RunContext + 全局 permission 策略解析本轮想要的三项 ACP 配置：
+ * - model/effort：有则设、无则不设（尊重适配器默认）；
+ * - mode：三个后端都接受 `/permission` 的显式会话覆盖；Claude 未覆盖时再使用兼容配置或
+ *   acpPermissionPolicy 推导默认值，让 requestPermission 处理器与全局策略保持一致。
+ */
+export declare function resolveDesiredConfig(ctx: RunContext, permissionPolicy: AcpPermissionPolicy): DesiredSessionConfig;
+/**
+ * 把 SDK 的 configOptions（含分组 select）映射为跨包共享的精简形态，供 /model 等
+ * 动态列表展示。select 和 boolean 都保留，供 /model 与通用 /config 使用。
+ */
+export declare function mapSessionConfigOptions(options: SessionConfigOption[]): BackendConfigOption[];
+/**
+ * 会话打开后、首个 prompt 之前，用 ACP 标准 `session/set_config_option`（Zed 同款机制）把
+ * 想要的 model/effort/permission 应用到会话上。适配器 advertise 的选项来自
+ * `newSessionResponse.configOptions`（新建 + claude 续聊均带）。每次运行都要重设：续聊到新
+ * 适配器进程时 model 会退回适配器默认（实测 Fable 5）。匹配不到的项只收集非致命 warning、不中断
+ * ——适配器没有对应 category 时就自然跳过（除非 desired.strictModel 对 model 字段要求硬失败）。
+ */
+export declare function applySessionConfigOptions(agent: Agent, sessionId: string, configOptions: SessionConfigOption[], desired: DesiredSessionConfig, custom?: CustomSessionConfig): Promise<{
+    warnings: string[];
+    configOptions: SessionConfigOption[];
+    /** model 分类选项在本轮 set-config 回合后的实际 currentValue（可能与 desired.model 不同） */
+    effectiveModel?: string;
+    /** desired.model 未被适配器采纳时的请求值/实际生效值对照，供上层告知用户。
+     *  effective 缺省表示适配器没有报告实际模型，此时不要编造一个名字。 */
+    modelMismatch?: {
+        requested: string;
+        effective?: string;
+        effectiveName?: string;
+    };
+}>;
+export {};
+//# sourceMappingURL=acp-config-options.d.ts.map