@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/backends/dist/codex-skill-commands.js

@@ -0,0 +1,88 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+const CODEX_SKILLS_TIMEOUT_MS = 5_000;
+export async function listCodexSkillCommands(cwd) {
+    const child = spawn(process.env.CODEX_PATH || "codex", ["app-server", "--stdio"], {
+        cwd,
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        child.kill();
+        throw new Error("Codex app-server stdio unavailable");
+    }
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+        stderr = (stderr + chunk.toString()).slice(-2_000);
+    });
+    const lines = createInterface({ input: child.stdout });
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error, commands) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            lines.close();
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(commands ?? []);
+        };
+        const send = (value) => child.stdin?.write(`${JSON.stringify(value)}\n`);
+        const timeout = setTimeout(() => finish(new Error("Codex skills/list timeout")), CODEX_SKILLS_TIMEOUT_MS);
+        child.once("error", (error) => finish(error));
+        child.once("exit", (code) => {
+            if (!settled)
+                finish(new Error(stderr.trim() || `Codex app-server exited with code ${code}`));
+        });
+        lines.on("line", (line) => {
+            let response;
+            try {
+                response = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (response.id === 1) {
+                if (response.error) {
+                    finish(new Error(String(response.error.message ?? "Codex initialize failed")));
+                    return;
+                }
+                send({ id: 2, method: "skills/list", params: { cwds: [cwd] } });
+                return;
+            }
+            if (response.id !== 2)
+                return;
+            if (response.error) {
+                finish(new Error(String(response.error.message ?? "Codex skills/list failed")));
+                return;
+            }
+            const commands = new Map();
+            for (const entry of response.result?.data ?? []) {
+                for (const skill of entry.skills ?? []) {
+                    if (skill.enabled === false || typeof skill.name !== "string" || !skill.name)
+                        continue;
+                    const name = `$${skill.name}`;
+                    const description = typeof skill.shortDescription === "string"
+                        ? skill.shortDescription
+                        : typeof skill.description === "string"
+                            ? skill.description
+                            : skill.name;
+                    commands.set(name, { name, description });
+                }
+            }
+            finish(undefined, [...commands.values()]);
+        });
+        send({
+            id: 1,
+            method: "initialize",
+            params: {
+                clientInfo: { name: "codebridge", title: "CodeBridge", version: "0.1.0" },
+                capabilities: { experimentalApi: true, requestAttestation: false },
+            },
+        });
+    });
+}
+//# sourceMappingURL=codex-skill-commands.js.map

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

@@ -0,0 +1,18 @@
+import type { BackendProfile, DoctorResult } from "@codebridge/core";
+export declare class BackendRegistry {
+    private readonly profiles;
+    register(id: string, profile: BackendProfile): void;
+    getProfile(id: string): BackendProfile | undefined;
+    ids(): string[];
+    doctor(cwd: string): Promise<DoctorResult>;
+}
+export { resolveAcpSpawn, acpContinueMethod, runAcpSession, deleteAcpSession, loadAcpSessionHistory, listAcpConfigOptions, listAcpSessions, killProcessTree, mapSessionUpdate, AcpSessionPool, type AcpSessionPoolOptions, } from "./acp/index.js";
+export { type CliSessionSummary, type ProviderSessionHistoryEvent, collectCodexSessionHistory, encodeClaudeProjectDir, loadCodexSessionHistory, loadClaudeSessionHistory, } from "./session-discovery.js";
+export { testProviderConnection, type ProviderConnectionProbe } from "./provider-connection.js";
+export { listCodexSkillCommands } from "./codex-skill-commands.js";
+export { SKILL_AGENT_IDS, SkillControlPlane, SkillControlPlaneError, type SkillAgentId, type SkillCatalogEntry, type SkillCatalogSnapshot, type SkillControlPlaneErrorCode, type SkillControlPlaneOptions, type SkillDeliveryMode, type SkillGlobalState, type SkillMutationKind, type SkillMutationPlan, type SkillMutationResult, type SkillMutationStep, type SkillOwnership, type SkillProjectionState, type SkillSourceKind, type SkillTargetDefinition, type SkillTargetView, } from "./skill-control-plane.js";
+export { closePiSession, deletePiSession, forkPiSession, loadPiSessionHistory, listPiSessions, listPiConfigOptions, listPiCommands, mapPiEvent, probePiSdk, runPiSession, type PiRunHandle, type PiRunHandleRef, type PiSession, type PiSessionLifecycleResult, type PiSessionRunnerOptions, } from "./pi-session-runner.js";
+export { AgentSetupService, redactSetupOutput, type AgentAuthProbe, type AgentCommandResult, type AgentSetupInstallResult, type AgentSetupRecord, type AgentSetupServiceOptions, } from "./agent-setup.js";
+export { isAuthErrorMessage, friendlyAuthErrorMessage, } from "./auth-error-hints.js";
+export { PI_PROVIDER_PRESETS, piModelsPath, readPiProviders, validateProviders, writePiProviders, type PiProvider, type PiProviderModel, type PiProviderPreset, type PiProvidersFile, } from "./pi-providers.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/backends/dist/index.js

@@ -0,0 +1,34 @@
+import { detectBackend } from "./acp/acp-doctor.js";
+export class BackendRegistry {
+    profiles = new Map();
+    register(id, profile) {
+        this.profiles.set(id, profile);
+    }
+    getProfile(id) {
+        return this.profiles.get(id);
+    }
+    ids() {
+        return [...this.profiles.keys()];
+    }
+    async doctor(cwd) {
+        const all = [];
+        let ok = true;
+        for (const [id, profile] of this.profiles) {
+            const result = await detectBackend(id, profile, cwd);
+            all.push(...result.checks);
+            if (!result.ok)
+                ok = false;
+        }
+        return { ok, checks: all };
+    }
+}
+export { resolveAcpSpawn, acpContinueMethod, runAcpSession, deleteAcpSession, loadAcpSessionHistory, listAcpConfigOptions, listAcpSessions, killProcessTree, mapSessionUpdate, AcpSessionPool, } from "./acp/index.js";
+export { collectCodexSessionHistory, encodeClaudeProjectDir, loadCodexSessionHistory, loadClaudeSessionHistory, } from "./session-discovery.js";
+export { testProviderConnection } from "./provider-connection.js";
+export { listCodexSkillCommands } from "./codex-skill-commands.js";
+export { SKILL_AGENT_IDS, SkillControlPlane, SkillControlPlaneError, } from "./skill-control-plane.js";
+export { closePiSession, deletePiSession, forkPiSession, loadPiSessionHistory, listPiSessions, listPiConfigOptions, listPiCommands, mapPiEvent, probePiSdk, runPiSession, } from "./pi-session-runner.js";
+export { AgentSetupService, redactSetupOutput, } from "./agent-setup.js";
+export { isAuthErrorMessage, friendlyAuthErrorMessage, } from "./auth-error-hints.js";
+export { PI_PROVIDER_PRESETS, piModelsPath, readPiProviders, validateProviders, writePiProviders, } from "./pi-providers.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/backends/dist/pi-providers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pi provider management: validated read/write of `~/.pi/agent/models.json`
+ * plus the built-in vendor preset catalog. See docs/orchestration/agent-providers.md.
+ *
+ * Security boundary: this module runs on the Runner host only; credentials
+ * never leave the machine and must not be logged by callers.
+ */
+export type ThinkingLevelKey = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export interface PiProviderModel {
+    id: string;
+    name?: string;
+    api?: string;
+    baseUrl?: string;
+    reasoning?: boolean;
+    thinkingLevelMap?: Partial<Record<ThinkingLevelKey, string | null>>;
+    input?: Array<"text" | "image">;
+    contextWindow?: number;
+    maxTokens?: number;
+    [key: string]: unknown;
+}
+export interface PiProvider {
+    baseUrl: string;
+    api: string;
+    apiKey?: string;
+    authHeader?: boolean;
+    models: PiProviderModel[];
+    [key: string]: unknown;
+}
+export interface PiProvidersFile {
+    providers: Record<string, PiProvider>;
+}
+export interface PiProviderPreset {
+    id: string;
+    name: string;
+    baseUrl: string;
+    api: string;
+    models: PiProviderModel[];
+}
+/** Vendor presets: templates only — never include credentials. */
+export declare const PI_PROVIDER_PRESETS: PiProviderPreset[];
+export declare function piModelsPath(): string;
+export declare function validateProviders(input: unknown): string[];
+export declare function readPiProviders(modelsPath?: string): PiProvidersFile;
+export declare function writePiProviders(file: PiProvidersFile, modelsPath?: string): void;
+//# sourceMappingURL=pi-providers.d.ts.map

package/node_modules/@codebridge/backends/dist/pi-providers.js

@@ -0,0 +1,148 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+const OPENAI_LEVEL_MAP = {
+    off: "none",
+    minimal: "minimal",
+    low: "low",
+    medium: "medium",
+    high: "high",
+};
+/** Vendor presets: templates only — never include credentials. */
+export const PI_PROVIDER_PRESETS = [
+    {
+        id: "deepseek",
+        name: "DeepSeek",
+        baseUrl: "https://api.deepseek.com/v1",
+        api: "openai-completions",
+        models: [
+            { id: "deepseek-chat", name: "DeepSeek Chat", reasoning: false, contextWindow: 1000000, maxTokens: 8192, input: ["text"] },
+            { id: "deepseek-reasoner", name: "DeepSeek Reasoner", reasoning: true, contextWindow: 1000000, maxTokens: 65536, input: ["text"], thinkingLevelMap: { off: null, low: "low", medium: "medium", high: "high" } },
+        ],
+    },
+    {
+        id: "glm",
+        name: "智谱 GLM",
+        baseUrl: "https://open.bigmodel.cn/api/paas/v4",
+        api: "openai-completions",
+        models: [
+            { id: "glm-4.6", name: "GLM-4.6", reasoning: true, contextWindow: 200000, maxTokens: 131072, input: ["text"], thinkingLevelMap: OPENAI_LEVEL_MAP },
+            { id: "glm-4.6-air", name: "GLM-4.6 Air", reasoning: true, contextWindow: 131072, maxTokens: 131072, input: ["text"], thinkingLevelMap: OPENAI_LEVEL_MAP },
+        ],
+    },
+    {
+        id: "kimi",
+        name: "Kimi(月之暗面)",
+        baseUrl: "https://api.moonshot.cn/v1",
+        api: "openai-completions",
+        models: [
+            { id: "kimi-k2-0905-preview", name: "Kimi K2", reasoning: false, contextWindow: 262144, maxTokens: 16384, input: ["text"] },
+        ],
+    },
+    {
+        id: "qwen",
+        name: "通义 Qwen",
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        api: "openai-completions",
+        models: [
+            { id: "qwen3-max", name: "Qwen3 Max", reasoning: false, contextWindow: 262144, maxTokens: 65536, input: ["text"] },
+        ],
+    },
+    {
+        id: "openrouter",
+        name: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        api: "openai-completions",
+        models: [],
+    },
+];
+const PROVIDER_ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
+export function piModelsPath() {
+    return path.join(getAgentDir(), "models.json");
+}
+export function validateProviders(input) {
+    const issues = [];
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return ["providers 必须是对象"];
+    const file = input;
+    if (!file.providers || typeof file.providers !== "object" || Array.isArray(file.providers)) {
+        return ["缺少 providers 对象"];
+    }
+    for (const [id, raw] of Object.entries(file.providers)) {
+        if (!PROVIDER_ID_RE.test(id))
+            issues.push(`provider id 不合法: ${id}(小写字母/数字/连字符/下划线,且以字母或数字开头)`);
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            issues.push(`${id}: 必须是对象`);
+            continue;
+        }
+        const provider = raw;
+        if (typeof provider.baseUrl !== "string" || !/^https?:\/\//.test(provider.baseUrl)) {
+            issues.push(`${id}: baseUrl 必须是 http(s) URL`);
+        }
+        if (typeof provider.api !== "string" || !provider.api.trim())
+            issues.push(`${id}: 缺少 api 协议`);
+        if (!Array.isArray(provider.models)) {
+            issues.push(`${id}: models 必须是数组`);
+            continue;
+        }
+        const modelIds = new Set();
+        for (const [index, modelRaw] of provider.models.entries()) {
+            const model = modelRaw;
+            const label = `${id}.models[${index}]`;
+            if (typeof model?.id !== "string" || !model.id.trim()) {
+                issues.push(`${label}: 缺少 id`);
+                continue;
+            }
+            if (modelIds.has(model.id))
+                issues.push(`${label}: 模型 id 重复: ${model.id}`);
+            modelIds.add(model.id);
+            // reasoning without a map is legal: Pi falls back to its default levels.
+            // Only a *present but empty* map is a configuration mistake.
+            if (model.reasoning === true && model.thinkingLevelMap !== undefined) {
+                const map = model.thinkingLevelMap;
+                const usable = Object.values(map).some((value) => typeof value === "string" && value);
+                if (!usable)
+                    issues.push(`${label}: thinkingLevelMap 存在但没有任何有效档位`);
+            }
+        }
+    }
+    return issues;
+}
+export function readPiProviders(modelsPath = piModelsPath()) {
+    if (!fs.existsSync(modelsPath))
+        return { providers: {} };
+    const raw = fs.readFileSync(modelsPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const issues = validateProviders(parsed);
+    if (issues.length)
+        throw new Error(`models.json 校验失败: ${issues.join("; ")}`);
+    return parsed;
+}
+export function writePiProviders(file, modelsPath = piModelsPath()) {
+    const issues = validateProviders(file);
+    if (issues.length)
+        throw new Error(issues.join("; "));
+    normalizeProviderCompat(file);
+    fs.mkdirSync(path.dirname(modelsPath), { recursive: true });
+    if (fs.existsSync(modelsPath)) {
+        fs.copyFileSync(modelsPath, `${modelsPath}.bak`);
+    }
+    const tmp = `${modelsPath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n");
+    fs.renameSync(tmp, modelsPath);
+}
+/** Default custom endpoints to the most conservative wire shape: `system`
+ *  works everywhere (OpenAI included), `developer` does not. Explicitly set
+ *  compat values are never overridden. */
+function normalizeProviderCompat(file) {
+    for (const provider of Object.values(file.providers)) {
+        const api = provider.api;
+        if (api !== "openai-completions" && api !== "openai-responses")
+            continue;
+        for (const model of provider.models) {
+            const compat = (model.compat ??= {});
+            compat.supportsDeveloperRole ??= false;
+        }
+    }
+}
+//# sourceMappingURL=pi-providers.js.map

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

@@ -0,0 +1,85 @@
+import type { AgentAvailableCommand, AgentEvent, BackendConfigOption, RunContext } from "@codebridge/core";
+import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, ModelRuntime, SessionManager } from "@earendil-works/pi-coding-agent";
+import type { CliSessionSummary, ProviderSessionHistoryEvent } from "./session-discovery.js";
+/** The small native-session surface used by the runner and by adapter tests. */
+export interface PiSession {
+    readonly sessionId: string;
+    readonly sessionFile?: string;
+    subscribe(listener: (event: unknown) => void): () => void;
+    prompt(text: string, options?: {
+        images?: unknown[];
+    }): Promise<void>;
+    steer(text: string): Promise<void>;
+    abort(): Promise<void>;
+    /** Kill in-flight bash process groups. Native AgentSession has this; abort() does not call it. */
+    abortBash?: () => void;
+    dispose(): void;
+}
+export interface PiRunHandle {
+    cancel(): Promise<void>;
+    steer(prompt: string): Promise<unknown>;
+}
+export interface PiRunHandleRef {
+    current?: PiRunHandle;
+}
+export interface PiSessionRunnerOptions {
+    isAborted: () => boolean;
+    handleRef?: PiRunHandleRef;
+    createSession?: (ctx: RunContext) => Promise<PiSession>;
+}
+export interface PiSessionLifecycleResult {
+    ok: boolean;
+    error?: string;
+    sessionId?: string;
+    cwd?: string;
+    title?: string | null;
+}
+/** Map Pi's event stream to CodeBridge's provider-neutral event contract. */
+export declare function mapPiEvent(event: unknown): AgentEvent[];
+/** Execute one prompt on a native Pi AgentSession. */
+export declare function runPiSession(ctx: RunContext, options: PiSessionRunnerOptions): AsyncGenerator<AgentEvent>;
+export declare function listPiSessions(backendId: string, cwd: string, options?: {
+    limit?: number;
+}): Promise<CliSessionSummary[]>;
+export declare function loadPiSessionHistory(cwd: string, sessionId: string): Promise<ProviderSessionHistoryEvent[]>;
+export declare function collectPiSessionHistory(entries: unknown[]): ProviderSessionHistoryEvent[];
+export declare function probePiSdk(cwd: string): Promise<{
+    ok: boolean;
+    message: string;
+}>;
+type PiModelLike = {
+    provider: string;
+    id: string;
+    name?: string;
+    api?: string;
+    reasoning?: boolean;
+    thinkingLevelMap?: Record<string, string | null | undefined>;
+};
+type PiConfigRuntime = {
+    getModels: () => PiModelLike[];
+    hasConfiguredAuth: (provider: string) => boolean;
+    getModel?: (provider: string, modelId: string) => PiModelLike | undefined;
+};
+/** Thinking levels supported by a specific model: keys of thinkingLevelMap
+ *  with a non-null mapping, in canonical order. Falls back to all levels for
+ *  reasoning models without a map; empty for non-reasoning models. */
+export declare function piThinkingLevelsForModel(model: Pick<PiModelLike, "reasoning" | "thinkingLevelMap"> | undefined | null): string[];
+export declare function listPiConfigOptions(runtime?: PiConfigRuntime, currentModel?: string | null): Promise<BackendConfigOption[]>;
+export declare function listPiCommands(cwd: string): Promise<AgentAvailableCommand[]>;
+export declare function closePiSession(cwd: string, sessionId: string): Promise<PiSessionLifecycleResult>;
+export declare function forkPiSession(sourceCwd: string, sessionId: string, targetCwd: string): Promise<PiSessionLifecycleResult>;
+export declare function deletePiSession(cwd: string, sessionId: string): Promise<PiSessionLifecycleResult>;
+interface NativePiSessionDependencies {
+    createAgentSession?: (options: CreateAgentSessionOptions) => ReturnType<typeof createAgentSession>;
+    createModelRuntime?: typeof createPiModelRuntime;
+    resolveSessionManager?: typeof resolvePiSessionManager;
+}
+export declare function createNativePiSession(ctx: RunContext, dependencies?: NativePiSessionDependencies): Promise<PiSession>;
+export declare function resolvePiSessionManager(ctx: RunContext): Promise<SessionManager>;
+export declare function createPiModelRuntime(options?: {
+    authPath?: string;
+    modelsPath?: string | null;
+}): Promise<ModelRuntime>;
+export {};
+//# sourceMappingURL=pi-session-runner.d.ts.map