oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/engine/jsonrpc-stdio.js

@@ -0,0 +1,241 @@
+/**
+ * 通用「子进程 + stdio JSON-RPC」客户端（codex / dsh 共用）。
+ *
+ * 为什么需要它：codex 的 `app-server` 和 dsh 的 `--profile acp` 是**同一种东西**——
+ * 每行一个 JSON-RPC 帧、stdout 只走协议、服务端会反过来向我们发请求（审批/权限）。
+ * 差异只有三处，全部参数化：
+ *   1. 启动命令（`codex app-server` / `dsh --profile acp`）；
+ *   2. 握手方法（都是 `initialize`，但参数/返回值不同）；
+ *   3. 帧里带不带 `"jsonrpc":"2.0"`（ACP 要求；codex 不带）。
+ *
+ * 生命周期纪律（两个引擎一致）：
+ *   - **懒启动**：第一次 request 才 spawn —— 机器上没装某个 CLI 不该让工作台起不来；
+ *   - **挂了就重来**：子进程退出 → 拒掉所有在飞请求 → 下次请求重新拉起；
+ *   - **退出即收**：`close()` 杀掉子进程（codex 由此释放它持有的全部 thread 写锁）。
+ *
+ * 帧格式：
+ *   请求   → `{"id":1,"method":"…","params":{…}}\n`
+ *   响应   → `{"id":1,"result":{…}}` / `{"id":1,"error":{"code":-32602,"message":"…"}}`
+ *   通知   → `{"method":"…","params":{…}}`（无 id）
+ *   服务端请求 → `{"id":9,"method":"…","params":{…}}`（有 id + method，**必须回包**否则对端一直等）
+ */
+import { spawn } from "node:child_process";
+export function createJsonRpcStdioClient(options) {
+    const baseTimeout = options.timeoutMs ?? 30_000;
+    const prefix = options.name;
+    let child = null;
+    let starting = null;
+    let initialized = false;
+    let seq = 0;
+    let version = null;
+    let buffer = "";
+    const pending = new Map();
+    const notificationListeners = new Set();
+    const serverRequestListeners = new Set();
+    const exitListeners = new Set();
+    const rejectAll = (error) => {
+        for (const [id, entry] of pending) {
+            clearTimeout(entry.timer);
+            entry.reject(error);
+            pending.delete(id);
+        }
+    };
+    const send = (payload) => {
+        if (!child)
+            throw new Error(`${prefix} 未连接`);
+        child.stdin.write(`${JSON.stringify(options.jsonrpc ? { jsonrpc: "2.0", ...payload } : payload)}\n`);
+    };
+    const respond = (id, result) => {
+        try {
+            send({ id, result });
+        }
+        catch (error) {
+            options.log?.(`${prefix}: 回包失败（${id}）：${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const handleLine = (line) => {
+        if (line.trim() === "")
+            return;
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            options.log?.(`${prefix}: 收到非 JSON 帧（已忽略）：${line.slice(0, 120)}`);
+            return;
+        }
+        const id = typeof message.id === "number" ? message.id : null;
+        const method = typeof message.method === "string" ? message.method : null;
+        if (method && id !== null) {
+            const request = { id, method, params: (message.params ?? {}) };
+            if (serverRequestListeners.size === 0) {
+                // 没人接也得回一个：不回包对端会一直等下去
+                respond(id, { decision: "decline" });
+                return;
+            }
+            for (const listener of serverRequestListeners)
+                listener(request);
+            return;
+        }
+        if (method) {
+            const notification = { method, params: (message.params ?? {}) };
+            for (const listener of notificationListeners)
+                listener(notification);
+            return;
+        }
+        if (id === null)
+            return;
+        const entry = pending.get(id);
+        if (!entry)
+            return;
+        pending.delete(id);
+        clearTimeout(entry.timer);
+        const error = message.error;
+        if (error) {
+            const detail = error.data && typeof error.data === "object" && "details" in error.data
+                ? `：${String(error.data.details)}`
+                : "";
+            entry.reject(new Error(`${error.message ?? `${prefix} 请求失败`}${detail}`));
+        }
+        else
+            entry.resolve(message.result);
+    };
+    const wire = (process) => {
+        process.stdout.setEncoding("utf8");
+        process.stdout.on("data", (chunk) => {
+            buffer += chunk;
+            let index;
+            while ((index = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, index);
+                buffer = buffer.slice(index + 1);
+                handleLine(line);
+            }
+        });
+        process.stderr.setEncoding("utf8");
+        process.stderr.on("data", (chunk) => {
+            const text = chunk.trim();
+            // 两边都会在 stderr 打启动信息，别把日志刷满
+            if (text !== "" && !/^(WARNING|note:)/.test(text))
+                options.log?.(`${prefix}: ${text.slice(0, 400)}`);
+        });
+        const onGone = (reason) => {
+            if (child !== process)
+                return;
+            child = null;
+            initialized = false;
+            version = null;
+            starting = null;
+            buffer = "";
+            const error = new Error(reason);
+            rejectAll(error);
+            for (const listener of exitListeners)
+                listener(error);
+        };
+        process.on("exit", (code) => onGone(`${prefix} 已退出（code ${code ?? "?"}）`));
+        process.on("error", (error) => onGone(`${prefix} 启动失败：${error.message}`));
+    };
+    const requestRaw = (method, params, timeoutMs = baseTimeout) => {
+        const id = ++seq;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`${prefix} 请求超时：${method}`));
+            }, timeoutMs);
+            pending.set(id, { method, resolve: (value) => resolve(value), reject, timer });
+            try {
+                send({ id, method, params: params ?? {} });
+            }
+            catch (error) {
+                pending.delete(id);
+                clearTimeout(timer);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    };
+    const ensureStarted = async () => {
+        if (initialized && child)
+            return;
+        if (starting)
+            return starting;
+        starting = (async () => {
+            if (!child) {
+                const env = { ...process.env };
+                for (const [key, value] of Object.entries(options.env ?? {})) {
+                    if (value === undefined)
+                        delete env[key];
+                    else
+                        env[key] = value;
+                }
+                const next = spawn(options.bin, options.args, { env, stdio: ["pipe", "pipe", "pipe"] });
+                child = next;
+                wire(next);
+            }
+            const result = await options.handshake((method, params) => requestRaw(method, params));
+            version = result.version ?? null;
+            initialized = true;
+        })();
+        try {
+            await starting;
+        }
+        catch (error) {
+            const process = child;
+            child = null;
+            initialized = false;
+            version = null;
+            process?.kill("SIGTERM");
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            starting = null;
+        }
+    };
+    return {
+        async request(method, params, requestOptions) {
+            await ensureStarted();
+            return requestRaw(method, params, requestOptions?.timeoutMs);
+        },
+        notify: (method, params) => {
+            try {
+                // 通知也要求「已连接」：没连上就没人收，静默丢掉即可
+                if (!child)
+                    return;
+                send({ method, params: params ?? {} });
+            }
+            catch (error) {
+                options.log?.(`${prefix}: 通知发送失败（${method}）：${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        respond,
+        respondError: (id, code, message) => {
+            try {
+                send({ id, error: { code, message } });
+            }
+            catch {
+                /* 进程没了就算了 */
+            }
+        },
+        onNotification: (listener) => {
+            notificationListeners.add(listener);
+            return () => notificationListeners.delete(listener);
+        },
+        onServerRequest: (listener) => {
+            serverRequestListeners.add(listener);
+            return () => serverRequestListeners.delete(listener);
+        },
+        onExit: (listener) => {
+            exitListeners.add(listener);
+            return () => exitListeners.delete(listener);
+        },
+        ensureStarted,
+        version: () => version,
+        isReady: () => initialized && child !== null,
+        close: () => {
+            const process = child;
+            child = null;
+            initialized = false;
+            version = null;
+            rejectAll(new Error(`${prefix} 已关闭`));
+            process?.kill("SIGTERM");
+        },
+    };
+}

package/dist/server/engine/model-registry-reload.js

@@ -0,0 +1,115 @@
+/**
+ * 让「刚加进去的自定义 provider / 模型」立刻对 pi 生效。
+ *
+ * 为什么需要这一层（实测出来的）：
+ *   - pi 的模型注册表是**进程内缓存**；
+ *   - `ModelRuntime.refresh()` 只重新拉「动态 provider 的远端目录」，
+ *     不会重新读 `models.json` 里的 provider 定义；
+ *   - 于是「界面上加了 abc，但模型选择器里没有」—— 因为活着的会话里根本没有这个 provider。
+ *
+ * 所以除了重建预热会话，还要对**每个活着的会话**调 `registerProvider()` 把配置推过去。
+ * 这些都是 pi 的公开 API（registerProvider / unregisterProvider）。
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { setPriceIndex } from "../util/pricing-index.js";
+async function readJson(path, fallback) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+/** 把 pi 的两份配置读成「可直接 registerProvider 的形状」 */
+export async function readProviderConfigs(agentDir) {
+    const catalog = await readJson(join(agentDir, "models.json"), {});
+    const store = await readJson(join(agentDir, "models-store.json"), {});
+    const auth = await readJson(join(agentDir, "auth.json"), {});
+    const configs = [];
+    for (const [id, entry] of Object.entries(catalog.providers ?? {})) {
+        configs.push({
+            id,
+            ...(typeof entry.api === "string" ? { api: entry.api } : {}),
+            ...(typeof entry.baseUrl === "string" ? { baseUrl: entry.baseUrl } : {}),
+            ...(typeof entry.apiKey === "string" ? { apiKey: entry.apiKey } : {}),
+            ...(entry.headers ? { headers: entry.headers } : {}),
+            models: entry.models ?? [],
+        });
+    }
+    for (const [id, entry] of Object.entries(store)) {
+        const models = Array.isArray(entry.models) ? entry.models : [];
+        const template = models.find((model) => model.api && model.baseUrl);
+        if (!template)
+            continue;
+        configs.push({
+            id,
+            api: template.api,
+            baseUrl: template.baseUrl,
+            ...(auth[id]?.key ? { apiKey: auth[id].key } : {}),
+            ...(template.headers ? { headers: template.headers } : {}),
+            models,
+        });
+    }
+    return configs;
+}
+/** pi 认的模型字段（缺省给安全值，避免 provider 被拒） */
+function toProviderModel(model) {
+    return {
+        id: model.id,
+        name: model.name ?? model.id,
+        reasoning: model.reasoning === true,
+        input: Array.isArray(model.input) ? model.input : ["text"],
+        contextWindow: model.contextWindow ?? 128_000,
+        maxTokens: model.maxTokens ?? 8_192,
+        cost: model.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        ...(model.headers ? { headers: model.headers } : {}),
+    };
+}
+/** 我们通过 registerProvider 推给运行时的 provider（用来在改名/删除后注销旧的） */
+const pushed = new Set();
+export async function reloadModelRegistry(sessions, prewarmId, prewarm, agentDir) {
+    const warm = sessions.get(prewarmId);
+    if (warm) {
+        try {
+            warm.unsubscribe();
+            warm.session.dispose();
+        }
+        catch {
+            // 预热会话无关紧要，dispose 失败忽略
+        }
+        sessions.delete(prewarmId);
+    }
+    await prewarm();
+    const configs = await readProviderConfigs(agentDir);
+    // 分时价格索引（ADR-0026 D 期）：反正这两份配置刚读过，顺手把「时段 → 价格」也刷一遍，
+    // 不然用户刚改完价格，下一轮的消息花费还是按旧价算的。
+    setPriceIndex(configs.map((config) => ({ provider: config.id, models: config.models })));
+    for (const handle of sessions.values()) {
+        const runtime = handle.session.modelRuntime;
+        await runtime?.refresh?.({ allowNetwork: false }).catch(() => undefined);
+        // 配置里已经没有的（改名 / 删除）：从运行时注销，否则旧名字会一直挂在模型表里。
+        // 先收集再删：在遍历 `pushed` 时 delete 会让后续会话跳过这些 id（旧的注销不干净）。
+        const stale = [...pushed].filter((id) => !configs.some((config) => config.id === id));
+        for (const id of stale)
+            runtime?.unregisterProvider?.(id);
+        if (sessions.size > 0)
+            for (const id of stale)
+                pushed.delete(id);
+        for (const config of configs) {
+            try {
+                runtime?.registerProvider?.(config.id, {
+                    ...(config.api ? { api: config.api } : {}),
+                    ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+                    ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+                    ...(config.headers ? { headers: config.headers } : {}),
+                    models: config.models.map(toProviderModel),
+                });
+                pushed.add(config.id);
+            }
+            catch {
+                // 单个 provider 注册失败不该拖垮整次刷新（它只是不出现在列表里）
+            }
+        }
+    }
+}

package/dist/server/engine/pi-events.js

@@ -0,0 +1,148 @@
+/**
+ * SDK 会话事件 → 端口事件的映射（ADR-0003 的端口实现里最容易出错的一层）。
+ *
+ * 从 `pi-sdk.ts` 拆出（400 行护栏）：这是**纯映射**，与「怎么建会话、怎么订阅」无关，
+ * 所以可以脱离 SDK 用合成事件直接测（单测覆盖整张映射表，不烧 token）。
+ */
+import { parseUsage } from "../util/usage.js";
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : {};
+}
+/** 把工具结果里的文本抽出来（content 是 {type:"text",text} 数组） */
+export function resultText(result) {
+    const content = asRecord(result).content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        const record = asRecord(part);
+        return typeof record.text === "string" ? record.text : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+/** 把 bash 工具结果的退出码抠出来（不同工具 details 形状不同，取不到就不给） */
+export function resultExitCode(result) {
+    const details = asRecord(asRecord(result).details);
+    const value = details.exitCode ?? asRecord(asRecord(result).structuredContent).exitCode;
+    return typeof value === "number" ? value : undefined;
+}
+/** 一行预览的长度：超过就截（参数再长，抬头也只有一行） */
+const SUMMARY_CHARS = 200;
+/** 完整参数的上限：不能让一条快照因参数膨胀（正常命令远小于这个数） */
+export const FULL_ARGS_CHARS = 4000;
+/** 把任意参数变成文本（字符串原样返回：有的引擎直接给命令串，不是 JSON） */
+function argsText(args) {
+    if (typeof args === "string")
+        return args;
+    try {
+        return JSON.stringify(args ?? {});
+    }
+    catch {
+        return "(无法序列化的参数)";
+    }
+}
+/** 参数摘要（给界面一行预览与审批用） */
+export function summarizeArgs(args) {
+    const text = argsText(args);
+    return text.length > SUMMARY_CHARS ? `${text.slice(0, SUMMARY_CHARS)}…` : text;
+}
+/** 完整参数（给界面「展开了看全 + 复制」）；跟摘要一样短时调用方可以丢掉它 */
+export function fullArgs(args) {
+    const text = argsText(args);
+    return text.length > FULL_ARGS_CHARS ? `${text.slice(0, FULL_ARGS_CHARS)}…` : text;
+}
+/** 同一类失败的统一出口：能把原因带给用户就带，拿不到给一句可读的兜底 */
+function providerError(raw) {
+    const text = typeof raw === "string" && raw.trim() !== ""
+        ? raw.trim()
+        : typeof asRecord(raw).message === "string" && asRecord(raw).message !== ""
+            ? String(asRecord(raw).message)
+            : "模型调用失败（provider 没有给出原因）";
+    return { type: "error", code: "engine.provider_error", message: text };
+}
+/**
+ * 纯函数：把 SDK 会话事件翻译成端口事件。返回 null 表示这个事件不影响 UI。
+ * （单测用合成事件直接覆盖这张映射表 —— 不需要真的连模型。）
+ */
+export function mapSessionEvent(event) {
+    const record = asRecord(event);
+    const type = record.type;
+    if (type === "message_update") {
+        const message = asRecord(record.message);
+        const assistantEvent = asRecord(record.assistantMessageEvent);
+        // ⚠️ 正文 / 思考的增量**必须优先**：SDK 的 message_update 里一旦带上 usage，
+        // 之前那种「先看 usage 就 return」会把后面的每一个正文增量全吞掉 ——
+        // 表现就是「只调工具、不回复」。所以先在前面处理 delta，usage 只在非 delta 更新上取。
+        if (assistantEvent.type === "text_delta" &&
+            typeof assistantEvent.delta === "string" &&
+            assistantEvent.delta !== "") {
+            return { type: "text_delta", text: assistantEvent.delta };
+        }
+        // 模型的思考过程：单独一类事件，界面上折叠展示（不是正文）
+        if (assistantEvent.type === "thinking_delta" &&
+            typeof assistantEvent.delta === "string" &&
+            assistantEvent.delta !== "") {
+            return { type: "thinking_delta", text: assistantEvent.delta };
+        }
+        // 思考 / 正文之外的另一种增量：provider 直接报错（有的 provider 走这条，不走 message_end）
+        if (assistantEvent.type === "error")
+            return providerError(assistantEvent.error ?? assistantEvent.message);
+        // 用量：SDK 的 message 上带 usage（各 provider 字段名不一样，统一解析）。
+        // 这是**过程值**（final:false）：宿主只拿 message_end 那份求和，不能两边都算。
+        const usage = parseUsage(message.usage);
+        if (usage)
+            return { type: "usage", ...usage, final: false };
+        // 模型：**放最后**。有的 provider 每一帧 message 上都带 provider/model，
+        // 一旦先返回它，后面的正文增量就全被吞了 —— 表现就是「助手不回复，只有用量」。
+        if (typeof message.model === "string" && message.model !== "") {
+            const provider = typeof message.provider === "string" ? message.provider : "";
+            return { type: "model", model: provider ? `${provider}/${message.model}` : message.model };
+        }
+        return null; // tool_use 等：v1 不展示
+    }
+    // 一条消息开始：这一帧上带着 provider/model（拿它当「当前模型」的来源之一）
+    if (type === "message_start") {
+        const message = asRecord(record.message);
+        if (typeof message.model === "string" && message.model !== "") {
+            const provider = typeof message.provider === "string" ? message.provider : "";
+            return { type: "model", model: provider ? `${provider}/${message.model}` : message.model };
+        }
+        return null;
+    }
+    // 一条消息结束：**最终**用量在这里（output 才统计全），同一条 message_update 上的是过程值
+    if (type === "message_end") {
+        const message = asRecord(record.message);
+        // provider / 鉴权 / 网络的失败**不会抛异常**：SDK 会合成一条 stopReason=error 的消息
+        // （带 errorMessage）然后正常 resolve。不在这里翻译成 error 事件，界面就是
+        // 「空回复 + 没有任何报错 + 回合算完成」—— 用户根本不知道出了什么事。
+        if (message.stopReason === "error")
+            return providerError(message.errorMessage);
+        // 一次模型调用的**最终**用量：宿主把一轮里的这些加起来 = 本轮总量（含工具轮次）
+        const usage = parseUsage(message.usage);
+        return usage ? { type: "usage", ...usage, final: true } : null;
+    }
+    if (type === "tool_execution_start") {
+        const toolCallId = String(record.toolCallId ?? "");
+        const name = String(record.toolName ?? "");
+        return {
+            type: "tool_start",
+            toolCallId,
+            name,
+            argsSummary: summarizeArgs(record.args),
+            argsFull: fullArgs(record.args),
+        };
+    }
+    if (type === "tool_execution_end") {
+        const toolCallId = String(record.toolCallId ?? "");
+        const exitCode = resultExitCode(record.result);
+        return {
+            type: "tool_end",
+            toolCallId,
+            status: record.isError === true ? "failed" : "ok",
+            output: resultText(record.result),
+            ...(exitCode === undefined ? {} : { exitCode }),
+        };
+    }
+    return null;
+}

package/dist/server/engine/pi-rename.js

@@ -0,0 +1,14 @@
+/**
+ * 改会话显示名：往会话文件追加一条 `session_info`（pi 自己的「会话名」条目）。
+ *
+ * 已打开的会话直接用它的 sessionManager（同一个文件句柄）；没打开的临时 open 一次再追加。
+ * 单独成文件：ADR-0003 规定只有 `server/engine` 能碰 SDK，而 pi-sdk.ts 已贴近行数上限。
+ */
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+export async function renameSessionIn(sessions, sessionPath, name, sessionDir) {
+    const opened = [...sessions.values()].find((handle) => handle.sessionManager.getSessionFile() === sessionPath);
+    const manager = opened
+        ? opened.sessionManager
+        : SessionManager.open(sessionPath, sessionDir);
+    manager.appendSessionInfo(name);
+}