@graychennpm/codebridge 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,460 @@
+import { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import fs from "node:fs/promises";
+import { fileAttachmentPromptSuffix, partitionAttachments } from "./attachment-prompt.js";
+/** Match ACP's SIGKILL upgrade delay: abort() waits for idle and can hang on live bash. */
+const PI_ABORT_SETTLE_MS = 2_000;
+function abortPiSession(session) {
+    session.abortBash?.();
+    return Promise.race([
+        session.abort().then(() => undefined, () => undefined),
+        new Promise((resolve) => {
+            setTimeout(resolve, PI_ABORT_SETTLE_MS).unref();
+        }),
+    ]);
+}
+/** Map Pi's event stream to CodeBridge's provider-neutral event contract. */
+export function mapPiEvent(event) {
+    const value = event;
+    if (value.type === "message_update") {
+        const update = value.assistantMessageEvent;
+        if (update?.type === "text_delta" && update.delta) {
+            return [{ type: "text_delta", text: update.delta }];
+        }
+        if (update?.type === "thinking_delta" && update.delta) {
+            return [{ type: "thought_delta", text: update.delta }];
+        }
+        return [];
+    }
+    if (value.type === "tool_execution_start") {
+        return [
+            {
+                type: "tool_start",
+                toolCallId: value.toolCallId,
+                name: value.toolName ?? "tool",
+                input: value.args,
+            },
+        ];
+    }
+    if (value.type === "tool_execution_update") {
+        return [
+            {
+                type: "tool_update",
+                toolCallId: value.toolCallId ?? "unknown-tool-call",
+                name: value.toolName,
+                status: "running",
+                output: value.partialResult,
+            },
+        ];
+    }
+    if (value.type === "tool_execution_end") {
+        return [
+            {
+                type: "tool_end",
+                toolCallId: value.toolCallId,
+                name: value.toolName,
+                status: value.isError ? "failed" : "completed",
+                output: value.result,
+            },
+        ];
+    }
+    if (value.type === "agent_end" && value.willRetry === false) {
+        const assistant = [...(value.messages ?? [])]
+            .reverse()
+            .find((message) => message.role === "assistant");
+        if (assistant?.stopReason === "error") {
+            return [{
+                    type: "error",
+                    message: assistant.errorMessage || "Pi model request failed without an error message",
+                    fatal: true,
+                }];
+        }
+    }
+    // Provider/transport failures must surface as real error events instead of
+    // silently ending the run (auto-retry exhaustion carries the final error).
+    if (value.type === "auto_retry_end") {
+        const retry = value;
+        if (retry.success === false && retry.finalError) {
+            return [{ type: "error", message: retry.finalError, fatal: true }];
+        }
+    }
+    return [];
+}
+/** Execute one prompt on a native Pi AgentSession. */
+export async function* runPiSession(ctx, options) {
+    const session = await (options.createSession?.(ctx) ?? createNativePiSession(ctx));
+    const handleRef = options.handleRef;
+    let wake;
+    let finished = false;
+    let promptError;
+    const pending = [];
+    const seenErrors = new Set();
+    let sawOutput = false;
+    let sawError = false;
+    const notify = () => {
+        const current = wake;
+        wake = undefined;
+        current?.();
+    };
+    const unsubscribe = session.subscribe((event) => {
+        for (const mapped of mapPiEvent(event)) {
+            if (mapped.type === "error") {
+                if (seenErrors.has(mapped.message))
+                    continue;
+                seenErrors.add(mapped.message);
+                sawError = true;
+            }
+            else {
+                sawOutput = true;
+            }
+            pending.push(mapped);
+        }
+        notify();
+    });
+    let aborting;
+    const handle = {
+        cancel: () => {
+            aborting ??= abortPiSession(session);
+            return aborting;
+        },
+        steer: (prompt) => session.steer(prompt),
+    };
+    if (handleRef)
+        handleRef.current = handle;
+    try {
+        const prompt = await buildPrompt(ctx);
+        const promptPromise = session
+            .prompt(prompt.text, prompt.options)
+            .catch((error) => {
+            promptError = error;
+        })
+            .finally(() => {
+            finished = true;
+            notify();
+        });
+        while (!finished || pending.length > 0) {
+            if (pending.length > 0) {
+                yield pending.shift();
+                continue;
+            }
+            if (options.isAborted())
+                break;
+            await new Promise((resolve) => {
+                wake = resolve;
+            });
+        }
+        if (!options.isAborted())
+            await promptPromise;
+        if (promptError !== undefined && !options.isAborted()) {
+            yield {
+                type: "error",
+                message: promptError instanceof Error ? promptError.message : String(promptError),
+                fatal: true,
+            };
+        }
+        else if (!options.isAborted()) {
+            if (!sawOutput && !sawError) {
+                yield {
+                    type: "error",
+                    message: "Pi run completed without assistant output or a provider error",
+                    fatal: true,
+                };
+            }
+            else {
+                yield { type: "session", sessionId: session.sessionId };
+            }
+        }
+    }
+    finally {
+        unsubscribe();
+        if (options.isAborted() && !finished) {
+            await (aborting ?? abortPiSession(session));
+        }
+        session.dispose();
+        if (handleRef?.current === handle)
+            handleRef.current = undefined;
+    }
+}
+export async function listPiSessions(backendId, cwd, options) {
+    const sessions = await SessionManager.list(cwd);
+    return sessions
+        .map((session) => ({
+        id: session.id,
+        backend: backendId,
+        cwd: session.cwd || cwd,
+        preview: session.firstMessage || "(no preview)",
+        updatedAt: session.modified.toISOString(),
+    }))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .slice(0, options?.limit ?? 20);
+}
+export async function loadPiSessionHistory(cwd, sessionId) {
+    const match = await findPiSession(cwd, sessionId);
+    if (!match)
+        throw new Error(`Pi session not found in ${cwd}: ${sessionId}`);
+    const manager = SessionManager.open(match.path, undefined, cwd);
+    return collectPiSessionHistory(manager.getBranch());
+}
+export function collectPiSessionHistory(entries) {
+    const result = [];
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object" || entry.type !== "message")
+            continue;
+        const value = entry;
+        const message = value.message;
+        if (!message)
+            continue;
+        if (message.role === "user") {
+            const text = textFromPiContent(message.content);
+            if (text)
+                result.push({ kind: "message", text });
+        }
+        else if (message.role === "assistant") {
+            const blocks = Array.isArray(message.content) ? message.content : [message.content];
+            for (const block of blocks) {
+                if (typeof block === "string" && block) {
+                    result.push({
+                        kind: "agent_event",
+                        event: { type: "text_delta", text: block, ...(typeof value.id === "string" ? { messageId: value.id } : {}) },
+                    });
+                    continue;
+                }
+                if (!block || typeof block !== "object")
+                    continue;
+                const content = block;
+                if (content.type === "thinking" && content.thinking) {
+                    result.push({ kind: "agent_event", event: { type: "thought_delta", text: content.thinking } });
+                }
+                else if (content.type === "text" && content.text) {
+                    result.push({
+                        kind: "agent_event",
+                        event: { type: "text_delta", text: content.text, ...(typeof value.id === "string" ? { messageId: value.id } : {}) },
+                    });
+                }
+            }
+        }
+        else if (message.role === "toolResult") {
+            const text = textFromPiContent(message.content);
+            if (!text)
+                continue;
+            result.push({
+                kind: "agent_event",
+                event: {
+                    type: "tool_end",
+                    toolCallId: message.toolCallId,
+                    status: message.isError ? "failed" : "completed",
+                    output: text,
+                },
+            });
+        }
+    }
+    return result;
+}
+function textFromPiContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        if (!block || typeof block !== "object")
+            return "";
+        const value = block;
+        if (value.type === "text" && typeof value.text === "string")
+            return value.text;
+        if (value.type === "thinking" && typeof value.thinking === "string")
+            return value.thinking;
+        return "";
+    })
+        .join("");
+}
+export async function probePiSdk(cwd) {
+    try {
+        await SessionManager.list(cwd);
+        return { ok: true, message: "Pi SDK available" };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+const ALL_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const LEVEL_LABEL = {
+    off: "Off", minimal: "Minimal", low: "Low", medium: "Medium", high: "High", xhigh: "Extra high", max: "Max",
+};
+/** 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 function piThinkingLevelsForModel(model) {
+    if (model && model.reasoning === false)
+        return [];
+    const map = model?.thinkingLevelMap;
+    if (!map)
+        return [...ALL_THINKING_LEVELS];
+    const levels = ALL_THINKING_LEVELS.filter((level) => typeof map[level] === "string" && map[level]);
+    return levels.length ? levels : [...ALL_THINKING_LEVELS];
+}
+export async function listPiConfigOptions(runtime, currentModel) {
+    const activeRuntime = runtime ?? await createPiModelRuntime();
+    const values = activeRuntime.getModels()
+        .filter((model) => activeRuntime.hasConfiguredAuth(model.provider))
+        .map((model) => ({
+        value: `${model.provider}/${model.id}`,
+        name: model.name,
+        description: model.api,
+    }));
+    // Derive the thinking-level control from the *selected* model's declared
+    // capabilities: hidden for non-reasoning models, restricted to the mapped
+    // levels otherwise (docs/orchestration/agent-providers.md §2.6).
+    let selected;
+    if (currentModel && activeRuntime.getModel) {
+        const separator = currentModel.includes("/") ? "/" : ":";
+        const [provider, ...rest] = currentModel.split(separator);
+        if (provider && rest.length)
+            selected = activeRuntime.getModel(provider, rest.join(separator));
+    }
+    const levels = piThinkingLevelsForModel(selected);
+    // Surface Pi's configured defaults so "Agent 默认" shows what it resolves to
+    // (settings.json defaultProvider/defaultModel/defaultThinkingLevel).
+    let defaultModelValue;
+    let defaultThinkingLevel;
+    if (!runtime) {
+        const settings = SettingsManager.create(process.cwd(), getAgentDir());
+        const provider = settings.getDefaultProvider();
+        const modelId = settings.getDefaultModel();
+        if (provider && modelId && values.some((v) => v.value === `${provider}/${modelId}`)) {
+            defaultModelValue = `${provider}/${modelId}`;
+        }
+        const thinking = settings.getDefaultThinkingLevel();
+        if (thinking && levels.includes(thinking))
+            defaultThinkingLevel = thinking;
+    }
+    return [
+        ...(values.length ? [{
+                id: "model",
+                name: "Model",
+                type: "select",
+                category: "model",
+                values,
+                currentValue: defaultModelValue,
+            }] : []),
+        ...(levels.length ? [{
+                id: "thinking_level",
+                name: "Reasoning",
+                type: "select",
+                category: "thought_level",
+                values: levels.map((value) => ({ value, name: LEVEL_LABEL[value] ?? value })),
+                currentValue: defaultThinkingLevel,
+            }] : []),
+    ];
+}
+export async function listPiCommands(cwd) {
+    const agentDir = getAgentDir();
+    const loader = new DefaultResourceLoader({
+        cwd,
+        agentDir,
+        settingsManager: SettingsManager.create(cwd, agentDir),
+    });
+    await loader.reload();
+    const result = loader.getSkills();
+    return result.skills.map((skill) => ({
+        name: `skill:${skill.name}`,
+        description: skill.description,
+    }));
+}
+export async function closePiSession(cwd, sessionId) {
+    const session = await findPiSession(cwd, sessionId);
+    return session ? { ok: true } : { ok: false, error: "Pi session not found" };
+}
+export async function forkPiSession(sourceCwd, sessionId, targetCwd) {
+    const source = await findPiSession(sourceCwd, sessionId);
+    if (!source)
+        return { ok: false, error: "Pi session not found" };
+    const fork = SessionManager.forkFrom(source.path, targetCwd);
+    return {
+        ok: true,
+        sessionId: fork.getSessionId(),
+        cwd: targetCwd,
+        title: source.name ?? (source.firstMessage || null),
+    };
+}
+export async function deletePiSession(cwd, sessionId) {
+    const session = await findPiSession(cwd, sessionId);
+    if (!session)
+        return { ok: false, error: "Pi session not found" };
+    await fs.rm(session.path, { force: true });
+    return { ok: true };
+}
+export async function createNativePiSession(ctx, dependencies = {}) {
+    const modelRuntime = await (dependencies.createModelRuntime ?? createPiModelRuntime)();
+    const sessionManager = await (dependencies.resolveSessionManager ?? resolvePiSessionManager)(ctx);
+    const model = resolveModel(modelRuntime, ctx.backendConfig.model ?? ctx.model);
+    const createSession = dependencies.createAgentSession ?? createAgentSession;
+    const runEnv = { ...ctx.extraEnv };
+    const { session } = await createSession({
+        cwd: ctx.cwd,
+        sessionManager,
+        model,
+        thinkingLevel: resolveThinkingLevel(ctx.effort),
+        modelRuntime,
+        customTools: [
+            ...(ctx.extraEnv ? [createBashToolDefinition(ctx.cwd, {
+                    spawnHook: (spawn) => ({ ...spawn, env: { ...spawn.env, ...runEnv } }),
+                })] : []),
+        ],
+    });
+    return session;
+}
+export async function resolvePiSessionManager(ctx) {
+    if (!ctx.resumeSessionId)
+        return SessionManager.create(ctx.cwd);
+    const sessions = await SessionManager.list(ctx.cwd);
+    const match = sessions.find((session) => session.id === ctx.resumeSessionId);
+    if (!match)
+        return SessionManager.create(ctx.cwd);
+    return SessionManager.open(match.path, undefined, ctx.cwd);
+}
+export function createPiModelRuntime(options = {}) {
+    return ModelRuntime.create({ ...options, allowModelNetwork: false });
+}
+function resolveModel(runtime, raw) {
+    if (!raw)
+        return undefined;
+    const separator = raw.includes("/") ? "/" : ":";
+    const [provider, ...modelParts] = raw.split(separator);
+    const modelId = modelParts.join(separator);
+    if (!provider || !modelId) {
+        throw new Error(`Pi model must use provider/model format: ${raw}`);
+    }
+    const model = runtime.getModel(provider, modelId);
+    if (!model)
+        throw new Error(`Pi model is not available: ${raw}`);
+    return model;
+}
+async function findPiSession(cwd, sessionId) {
+    const sessions = await SessionManager.list(cwd);
+    return sessions.find((session) => session.id === sessionId);
+}
+function resolveThinkingLevel(raw) {
+    const levels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+    return raw && levels.has(raw)
+        ? raw
+        : undefined;
+}
+async function buildPrompt(ctx) {
+    if (!ctx.attachments?.length)
+        return { text: ctx.prompt };
+    const { images, files } = partitionAttachments(ctx.attachments);
+    const text = ctx.prompt + fileAttachmentPromptSuffix(files);
+    if (!images.length)
+        return { text };
+    // Pi 的 ImageContent 把 mimeType/data 放在顶层，不是 Anthropic 的 source 嵌套结构。
+    const imageBlocks = await Promise.all(images.map(async (attachment) => ({
+        type: "image",
+        mimeType: attachment.mimeType ?? "image/png",
+        data: await fs.readFile(attachment.path, "base64"),
+    })));
+    return { text, options: { images: imageBlocks } };
+}
+//# sourceMappingURL=pi-session-runner.js.map

package/node_modules/@codebridge/backends/dist/provider-connection.d.ts

@@ -0,0 +1,17 @@
+/** Generic third-party model endpoint probe (OpenAI-compatible HTTP APIs).
+ *  Used by Pi provider settings today; reusable by any agent's custom provider config. */
+export interface ProviderConnectionProbe {
+    baseUrl: string;
+    apiKey?: string;
+    authHeader?: boolean;
+    /** Wire protocol, e.g. "openai-completions" / "openai-responses". */
+    api?: string;
+    /** A concrete model id enables real protocol verification. */
+    model?: string;
+}
+export declare function testProviderConnection(provider: ProviderConnectionProbe): Promise<{
+    ok: boolean;
+    detail: string;
+    compatSuggestion?: Record<string, unknown>;
+}>;
+//# sourceMappingURL=provider-connection.d.ts.map

package/node_modules/@codebridge/backends/dist/provider-connection.js

@@ -0,0 +1,99 @@
+/** Minimal real request per wire protocol; returns a failure result, or undefined on success. */
+const PROTOCOL_PROBE = {
+    "openai-completions": async (baseUrl, headers, model) => {
+        const post = (messages) => fetch(`${baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: { ...headers, "content-type": "application/json" },
+            // Some reasoning-model gateways reject max_tokens <= 2.
+            body: JSON.stringify({ model, messages, max_tokens: 16 }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        // Pi sends the system prompt as a `developer` role message; probe that first.
+        const response = await post([{ role: "developer", content: "ping" }]);
+        if (response.ok)
+            return { ok: true, detail: `连接成功，模型 ${model} 的 Chat Completions API 可用` };
+        const body = await response.text().catch(() => "");
+        if (/developer/.test(body) && /unknown variant|unsupported|not supported|invalid/i.test(body)) {
+            const retry = await post([{ role: "system", content: "ping" }]);
+            if (retry.ok) {
+                return {
+                    ok: true,
+                    detail: `连接成功，但端点不支持 developer 角色；已建议写入 compat.supportsDeveloperRole=false`,
+                    compatSuggestion: { supportsDeveloperRole: false },
+                };
+            }
+            const retryBody = await retry.text().catch(() => "");
+            return { ok: false, detail: `Chat Completions API 不可用(HTTP ${retry.status}): ${retryBody.slice(0, 200) || "无错误详情"}` };
+        }
+        return { ok: false, detail: `Chat Completions API 不可用(HTTP ${response.status}): ${body.slice(0, 200) || "无错误详情"}` };
+    },
+    "openai-responses": async (baseUrl, headers, model) => {
+        const response = await fetch(`${baseUrl}/responses`, {
+            method: "POST",
+            headers: { ...headers, "content-type": "application/json" },
+            body: JSON.stringify({ model, input: "ping", max_output_tokens: 16 }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (response.ok)
+            return { ok: true, detail: `连接成功，模型 ${model} 的 Responses API 可用` };
+        const body = await response.text().catch(() => "");
+        return { ok: false, detail: `Responses API 不可用(HTTP ${response.status}): ${body.slice(0, 200) || "无错误详情"}` };
+    },
+    "anthropic-messages": async (baseUrl, headers, model) => {
+        const response = await fetch(`${baseUrl}/messages`, {
+            method: "POST",
+            headers: { ...headers, "content-type": "application/json", "anthropic-version": "2023-06-01" },
+            body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (response.ok)
+            return { ok: true, detail: `连接成功，模型 ${model} 的 Messages API 可用` };
+        const body = await response.text().catch(() => "");
+        return { ok: false, detail: `Messages API 不可用(HTTP ${response.status}): ${body.slice(0, 200) || "无错误详情"}` };
+    },
+};
+export async function testProviderConnection(provider) {
+    const baseUrl = provider.baseUrl.replace(/\/+$/, "");
+    const headers = {};
+    if (provider.apiKey) {
+        if (provider.authHeader)
+            headers["authorization"] = `Bearer ${provider.apiKey}`;
+        else
+            headers["x-api-key"] = provider.apiKey;
+    }
+    try {
+        const response = await fetch(`${baseUrl}/models`, { headers, signal: AbortSignal.timeout(5_000) });
+        if (!response.ok) {
+            const hint = response.status === 401 || response.status === 403 ? "API key 无效或无权限" : `HTTP ${response.status}`;
+            return { ok: false, detail: hint };
+        }
+    }
+    catch (error) {
+        return { ok: false, detail: networkHint(error) };
+    }
+    // /models only proves reachability; verify the selected wire protocol with a real call.
+    if (provider.model) {
+        const probe = PROTOCOL_PROBE[provider.api ?? "openai-completions"];
+        if (probe) {
+            try {
+                const result = await probe(baseUrl, headers, provider.model);
+                if (result)
+                    return result;
+            }
+            catch (error) {
+                return { ok: false, detail: networkHint(error) };
+            }
+        }
+    }
+    const protocol = provider.api ?? "openai-completions";
+    return { ok: true, detail: "连接成功(HTTP 200)" + (PROTOCOL_PROBE[protocol] && !provider.model ? "，但未配置模型，协议未验证" : "") };
+}
+function networkHint(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("ENOTFOUND"))
+        return "域名无法解析,检查 baseUrl";
+    if (message.includes("TimeoutError") || message.includes("timed out"))
+        return "连接超时";
+    return message;
+}
+//# sourceMappingURL=provider-connection.js.map

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

@@ -0,0 +1,23 @@
+import type { AgentEvent } from "@codebridge/core";
+export interface CliSessionSummary {
+    id: string;
+    backend: string;
+    cwd: string;
+    additionalDirectories?: string[];
+    preview: string;
+    updatedAt: string;
+}
+export type ProviderSessionHistoryEvent = {
+    kind: "message";
+    text: string;
+} | {
+    kind: "agent_event";
+    event: AgentEvent;
+};
+/** Claude Code: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl */
+export declare function encodeClaudeProjectDir(cwd: string): string;
+export declare function collectClaudeSessionHistory(entries: unknown[]): ProviderSessionHistoryEvent[];
+export declare function loadClaudeSessionHistory(cwd: string, sessionId: string): Promise<ProviderSessionHistoryEvent[]>;
+export declare function collectCodexSessionHistory(entries: unknown[]): ProviderSessionHistoryEvent[];
+export declare function loadCodexSessionHistory(sessionId: string): Promise<ProviderSessionHistoryEvent[]>;
+//# sourceMappingURL=session-discovery.d.ts.map