oh-my-agent-web 0.3.0 → 0.5.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, cwd: options.cwd, 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/narrate-guidance.js

@@ -0,0 +1,22 @@
+/**
+ * 教模型「动手之前先说人话」。
+ *
+ * 为什么必须有：对话区里的「过程」容器默认是**折叠**的 —— 用户一眼只看到
+ * 「1 段思考 1 次工具 过程 2 步」。模型要是连着调五个工具、一句正文都不写，
+ * 用户全程不知道它在查什么、改什么、碰到什么问题，只能干等。
+ *
+ * 所以：每一步动作前先给一两句「我发现了什么 / 我准备做什么」，
+ * 工具结果推翻计划时也说一句。界面侧同时有「正在运行 bash…」那行实时状态（见 LiveActivity），
+ * 两者合起来才是「看得懂在跑什么」。
+ *
+ * 同样写得短：这段会在**每一次**请求里重复计费。
+ */
+export const NARRATE_GUIDANCE = [
+    "## Narrate before acting",
+    "The user watches this conversation live, and tool cards are collapsed by default — they only see",
+    '"1 thinking segment, 1 tool call" unless you write prose. So:',
+    "- Before the first tool call of a task, write 1-2 sentences: what you found and what you are about to do.",
+    "- Before modifying, writing or deleting files, say which files and why (1-2 sentences), then call the tools.",
+    "- When a tool result changes your plan (failure, unexpected output, a discovery), say what it means before the next call.",
+    "- Keep it short and in the user's language; never paste tool arguments back as prose.",
+].join("\n");