oh-my-agent-web 0.7.0 → 1.0.2

package/dist/server/engine/claude.js

@@ -0,0 +1,414 @@
+import { CLAUDE_PROVIDER, currentModelId, currentModelOf, friendlyClaudeError, isFinalToolStatus, modelIdFor, modelOptions, permissionApprovalRequest, permissionOptionId, stopReasonToTurnEnd, textEventOf, toolEndEvent, toolFactsOf, toolStartEvent, } from "./claude-map.js";
+import { claudeSessionFile, deleteClaudeSession, lastTurnUsage, readTranscriptFile, sessionModelOf, transcriptStats, transcriptToTranscript, transcriptToUiMessages, } from "./claude-sessions.js";
+import { createClaudeClient, defaultClaudeBin } from "./claude-transport.js";
+import { withProbeCwd } from "./catalog-probe.js";
+import { isScratchCwd } from "./scratch.js";
+const MAX_TOOL_FACTS = 200;
+/** 回合结束后多久内「读统计」要等一下再读：Claude 是边聊边写 JSONL，最后一条可能还没落盘 */
+const SETTLE_MS = 3000;
+export function createClaudeEngine(options = {}) {
+    const bin = options.bin ?? defaultClaudeBin();
+    const client = options.client ?? createClaudeClient({ bin, args: options.args, log: options.log ?? (() => { }) });
+    const bindings = new Map();
+    const byEngineSession = new Map();
+    const active = new Map();
+    /** toolCallId → 工具事实（权限请求兜底用：请求体里只有 title，没有真工具名） */
+    const toolFacts = new Map();
+    /** conversationId → 最近一次回合结束的时刻（用于 SETTLE_MS 的等待） */
+    const settledAt = new Map();
+    let approvalHandler = null;
+    let lastError = null;
+    /**
+     * 最近一次拿到的模型表。历史会话在 resume 之前没有 models，但选择器不该是空的 ——
+     * 用它兜底；真正切模型时仍会先 resume（拿不到就报可读错误）。
+     */
+    let lastModels = {};
+    /** 目录探针跑过没有（每个实例只探一次；`reloadModels` / `dispose` 重置） */
+    let catalogProbed = false;
+    const rememberTool = (facts) => {
+        const previous = toolFacts.get(facts.toolCallId);
+        // 后到的 update 更详细（title 从占位变成真命令），合并而不是覆盖
+        toolFacts.set(facts.toolCallId, { ...previous, ...facts });
+        if (toolFacts.size > MAX_TOOL_FACTS) {
+            const oldest = toolFacts.keys().next().value;
+            if (oldest)
+                toolFacts.delete(oldest);
+        }
+    };
+    const applyModels = (binding, models) => {
+        if (!models)
+            return;
+        lastModels = models;
+        if (binding)
+            binding.models = models;
+    };
+    const bindingOf = (conversationId) => bindings.get(conversationId) ?? null;
+    const anyModels = (conversationId) => {
+        const binding = conversationId ? bindingOf(conversationId) : undefined;
+        if (binding && (binding.models.availableModels?.length ?? 0) > 0)
+            return binding.models;
+        const found = [...bindings.values()].find((item) => (item.models.availableModels?.length ?? 0) > 0);
+        return found?.models ?? lastModels;
+    };
+    /**
+     * 没有会话时把模型表弄进来（原因与代价见 catalog-probe.ts 文件头）：
+     * Claude 的模型只在 `session/new` 的 `models` 里 → 开个临时会话抄一份，再删掉它的 JSONL。
+     * 这套 ACP 面没有 `session/close`（parkSession 也知道这一点），所以收尾只能走文件。
+     */
+    const warmCatalog = async () => {
+        if (catalogProbed || (lastModels.availableModels?.length ?? 0) > 0)
+            return;
+        catalogProbed = true;
+        await withProbeCwd(async (cwd) => {
+            const created = await client.request("session/new", { cwd, mcpServers: [] });
+            const probeId = created?.sessionId;
+            if (!probeId)
+                return;
+            applyModels(undefined, created.models);
+            // 会话文件是**第一次说话时**才写的：找不到文件就是本来没留下东西（不该报警告）
+            const file = claudeSessionFile(probeId, { cwd, home: options.home });
+            if (file && !deleteClaudeSession(probeId, { home: options.home, cwd, sessionPath: file })) {
+                options.log?.(`claude：模型目录探针会话的文件没删掉：${file}`);
+            }
+        });
+    };
+    /** 会话文件：宿主给的路径优先，否则按 cwd 猜 / 扫目录 */
+    const fileOf = (conversationId) => {
+        const binding = bindingOf(conversationId);
+        if (!binding)
+            return null;
+        if (binding.sessionPath)
+            return binding.sessionPath;
+        const found = claudeSessionFile(binding.engineSessionId, { cwd: binding.cwd, home: options.home });
+        if (found)
+            binding.sessionPath = found;
+        return found;
+    };
+    const entriesOf = (conversationId) => {
+        const file = fileOf(conversationId);
+        return file ? readTranscriptFile(file) : [];
+    };
+    /**
+     * 历史会话首次使用时才 resume（ACP 的 resume 会挂一个活的 query）。
+     *
+     * 代价写在这里：**resume 之前这条会话的模型表是空的**（模型表只能从 `session/new|resume` 拿），
+     * 所以刚启动工作台就直接看历史会话时，模型选择器要等第一轮消息（resume）之后才有内容 ——
+     * 与 opencode 一致，不是一个可以在不挂活句柄的前提下解的问题。
+     *
+     * `session/load` 是备用路径：老版本适配器只注册了 load，它会**重放历史** ——
+     * 重放发生在 request 返回之前，此时该会话还没有 active turn，事件会被丢掉（不会串到界面里）。
+     */
+    const ensureLive = async (conversationId) => {
+        const binding = bindingOf(conversationId);
+        if (!binding)
+            return null;
+        if (binding.live)
+            return binding;
+        const params = { sessionId: binding.engineSessionId, cwd: binding.cwd, mcpServers: [] };
+        const resume = (method) => client.request(method, params, { timeoutMs: 120_000 }).catch((error) => {
+            throw error;
+        });
+        try {
+            applyModels(binding, (await resume("session/resume"))?.models);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/method not found|not implemented|-32601/i.test(message))
+                throw error;
+            options.log?.(`claude：session/resume 不可用，退回 session/load（${message.slice(0, 120)}）`);
+            applyModels(binding, (await resume("session/load"))?.models);
+        }
+        binding.live = true;
+        return binding;
+    };
+    const handleToolUpdate = (conversationId, update) => {
+        const facts = toolFactsOf(update);
+        if (!facts)
+            return;
+        rememberTool(facts);
+        const merged = toolFacts.get(facts.toolCallId) ?? facts;
+        const turn = active.get(conversationId);
+        if (!turn || turn.ended)
+            return;
+        // Claude 的 tool_call 第一条就带齐了 rawInput，不需要像 opencode 那样等第二条
+        if (!turn.started.has(facts.toolCallId)) {
+            turn.started.add(facts.toolCallId);
+            turn.onEvent(toolStartEvent(merged));
+        }
+        if (!isFinalToolStatus(update.status) || turn.finished.has(facts.toolCallId))
+            return;
+        turn.finished.add(facts.toolCallId);
+        turn.onEvent(toolEndEvent(update));
+    };
+    const handleNotification = (notification) => {
+        if (notification.method !== "session/update")
+            return;
+        const params = notification.params;
+        const engineSessionId = typeof params.sessionId === "string" ? params.sessionId : "";
+        const conversationId = byEngineSession.get(engineSessionId);
+        if (!conversationId)
+            return;
+        const update = (params.update ?? {});
+        if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+            handleToolUpdate(conversationId, update);
+            return;
+        }
+        const event = textEventOf(update);
+        if (!event)
+            return;
+        const turn = active.get(conversationId);
+        if (turn && !turn.ended)
+            turn.onEvent(event);
+    };
+    const handlePermission = async (id, params) => {
+        const toolCallId = params.toolCall?.toolCallId;
+        const facts = typeof toolCallId === "string" ? toolFacts.get(toolCallId) : undefined;
+        // 带上会话归属：宿主收尾时只收这个会话的审批（不然会误伤并行会话，见 approval-bridge）
+        const owner = params.sessionId ? byEngineSession.get(params.sessionId) : undefined;
+        const request = { ...permissionApprovalRequest(params, facts), ...(owner ? { conversationId: owner } : {}) };
+        let decision = "deny";
+        if (approvalHandler) {
+            try {
+                decision = await approvalHandler(request);
+            }
+            catch {
+                decision = "deny";
+            }
+        }
+        client.respond(id, {
+            outcome: { outcome: "selected", optionId: permissionOptionId(params.options, decision) },
+        });
+    };
+    client.onNotification(handleNotification);
+    client.onServerRequest((request) => {
+        if (request.method === "session/request_permission") {
+            void handlePermission(request.id, request.params);
+            return;
+        }
+        // 认不出的服务端请求必须回包，否则 Claude 那一轮会一直等
+        client.respondError(request.id, -32601, `agent-web 未实现的服务端请求：${request.method}`);
+    });
+    const engine = {
+        client,
+        version: () => client.version(),
+        async prewarm() {
+            await client.ensureStarted();
+            // 顺手把模型表也弄进来：否则切过来、还没开会话时下拉是空的（见 catalog-probe.ts）
+            await warmCatalog().catch((error) => {
+                options.log?.(`claude：读取模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
+        },
+        /** 重读模型表（改完 Claude 自己的配置后）：清掉快照，重新探一次 */
+        async reloadModels() {
+            lastModels = {};
+            catalogProbed = false;
+            await warmCatalog().catch((error) => {
+                options.log?.(`claude：重读模型目录失败：${error instanceof Error ? error.message : String(error)}`);
+            });
+        },
+        async createSession(sessionOptions) {
+            const created = await client
+                .request("session/new", { cwd: sessionOptions.workspace, mcpServers: [] }, { timeoutMs: 120_000 })
+                .catch((error) => {
+                throw new Error(friendlyClaudeError(error));
+            });
+            const engineSessionId = created?.sessionId;
+            if (!engineSessionId)
+                throw new Error("Claude Code 没有返回 sessionId");
+            const binding = {
+                engineSessionId,
+                cwd: sessionOptions.workspace,
+                live: true,
+                sessionPath: null,
+                models: created.models ?? {},
+            };
+            bindings.set(sessionOptions.sessionId, binding);
+            byEngineSession.set(engineSessionId, sessionOptions.sessionId);
+            applyModels(binding, created.models);
+            // 默认模型：只尊重显式配置（AGENT_WEB_CLAUDE_MODEL），否则用 Claude 自己的默认
+            const wanted = options.model?.trim();
+            if (wanted) {
+                const modelId = modelIdFor(binding.models, wanted);
+                if (modelId === null) {
+                    options.log?.(`claude：默认模型不在可选列表里，已忽略：${wanted}`);
+                }
+                else if (modelId !== currentModelId(binding.models)) {
+                    await client.request("session/set_model", { sessionId: engineSessionId, modelId }).catch((error) => {
+                        options.log?.(`claude：设置默认模型失败（${wanted}）：${friendlyClaudeError(error)}`);
+                    });
+                    applyModels(binding, { ...binding.models, currentModelId: modelId });
+                }
+            }
+            return { sessionPath: null, engineSessionId };
+        },
+        async openSession(openOptions) {
+            const engineSessionId = openOptions.engineSessionId ?? openOptions.sessionPath ?? openOptions.sessionId;
+            const binding = {
+                engineSessionId,
+                cwd: openOptions.cwd ?? "",
+                live: false,
+                sessionPath: openOptions.sessionPath ?? null,
+                models: {},
+            };
+            bindings.set(openOptions.sessionId, binding);
+            byEngineSession.set(engineSessionId, openOptions.sessionId);
+        },
+        async sendMessage(sessionId, text, onEvent, sendOptions) {
+            const binding = await ensureLive(sessionId).catch((error) => {
+                throw new Error(friendlyClaudeError(error));
+            });
+            if (!binding)
+                throw new Error("Claude Code 会话还没准备好（先新建一个会话）");
+            const turn = { onEvent, ended: false, started: new Set(), finished: new Set() };
+            active.set(sessionId, turn);
+            const model = currentModelId(binding.models);
+            if (model)
+                onEvent({ type: "model", model: `${CLAUDE_PROVIDER}/${model}` });
+            // ACP 的图片注入：适配器声明了 promptCapabilities.image = true（实测）
+            const prompt = [];
+            if (text.trim() !== "")
+                prompt.push({ type: "text", text });
+            for (const image of sendOptions?.images ?? []) {
+                prompt.push({ type: "image", data: image.data, mimeType: image.mimeType });
+            }
+            if (prompt.length === 0) {
+                active.delete(sessionId);
+                throw new Error("这条消息是空的（没有文本也没有图片）");
+            }
+            try {
+                const result = await client.request("session/prompt", { sessionId: binding.engineSessionId, prompt }, 
+                // 一轮跑很久是正常的（有工具调用）：给 30 分钟，别用默认 30 秒掐掉
+                { timeoutMs: 30 * 60 * 1000 });
+                settledAt.set(sessionId, Date.now());
+                // `session/prompt` 不返回 usage：从 JSONL 里把这一轮加起来，界面上的 token 才会动
+                const usage = lastTurnUsage(entriesOf(sessionId));
+                if (usage && !turn.ended)
+                    onEvent({ type: "usage", ...usage, final: true });
+                if (!turn.ended)
+                    onEvent({ type: "turn_end", reason: stopReasonToTurnEnd(result?.stopReason) });
+            }
+            catch (error) {
+                throw new Error(friendlyClaudeError(error));
+            }
+            finally {
+                turn.ended = true;
+                active.delete(sessionId);
+            }
+        },
+        async interrupt(sessionId) {
+            const binding = bindingOf(sessionId);
+            if (!binding)
+                return;
+            // ACP 里 cancel 是**通知**（无 id）：发成请求会被当成未知方法丢掉 → 停止按钮没反应
+            client.notify("session/cancel", { sessionId: binding.engineSessionId });
+        },
+        /** 「暂时不看了」：Claude 这套 ACP 面没有 close 方法，只需要停用绑定（resume 很便宜） */
+        async parkSession(sessionId) {
+            const binding = bindingOf(sessionId);
+            if (!binding)
+                return;
+            binding.live = false;
+        },
+        async closeSession(sessionId) {
+            const binding = bindingOf(sessionId);
+            bindings.delete(sessionId);
+            if (binding)
+                byEngineSession.delete(binding.engineSessionId);
+        },
+        async dispose() {
+            // 注意：**不清 lastModels** —— 它只是「Claude 有哪些模型」的目录快照，
+            // 切走再切回时模型选择器不该空着；真正切模型时会先 resume 拿最新模型表。
+            bindings.clear();
+            byEngineSession.clear();
+            active.clear();
+            toolFacts.clear();
+            settledAt.clear();
+            catalogProbed = false; // 探针会话随适配器进程一起没了：下次切回来重新探
+            client.close();
+        },
+        setApprovalHandler(handler) {
+            approvalHandler = handler;
+        },
+        async listModels(sessionId) {
+            return modelOptions(anyModels(sessionId));
+        },
+        async switchModel(sessionId, modelId) {
+            lastError = null;
+            const binding = await ensureLive(sessionId).catch((error) => {
+                lastError = friendlyClaudeError(error);
+                return null;
+            });
+            if (!binding) {
+                lastError ??= "先打开一个会话";
+                return false;
+            }
+            const target = modelIdFor(binding.models, modelId);
+            if (target === null) {
+                lastError = `这个模型不在 Claude Code 的可选列表里：${modelId}`;
+                return false;
+            }
+            try {
+                await client.request("session/set_model", { sessionId: binding.engineSessionId, modelId: target });
+                applyModels(binding, { ...binding.models, currentModelId: target });
+                return true;
+            }
+            catch (error) {
+                lastError = friendlyClaudeError(error);
+                return false;
+            }
+        },
+        async currentModel(sessionId) {
+            const binding = bindingOf(sessionId);
+            if (!binding) {
+                // 还没开会话（空状态）：用目录快照里的当前值，别让选择器与芯片显示成空的
+                return currentModelOf(anyModels());
+            }
+            if (!binding.live && (binding.models.availableModels?.length ?? 0) === 0) {
+                // 历史会话还没 resume：先用文件里最后一次用的模型，别显示成「当前默认」
+                return sessionModelOf(entriesOf(sessionId));
+            }
+            return currentModelOf(binding.models);
+        },
+        async sessionModel(sessionId) {
+            const persisted = sessionModelOf(entriesOf(sessionId));
+            if (persisted)
+                return persisted;
+            return engine.currentModel ? engine.currentModel(sessionId) : null;
+        },
+        lastError: () => lastError,
+        /** 历史回放：直接读 JSONL（ACP 的 load 会重放事件并占一个活句柄，不适合只读） */
+        async readUiMessages(sessionId) {
+            return transcriptToUiMessages(entriesOf(sessionId));
+        },
+        async readTranscript(sessionId) {
+            return transcriptToTranscript(entriesOf(sessionId));
+        },
+        /** 用量统计：四桶来自每条 assistant 的 `message.usage`；花费来自 `cost-state` */
+        async sessionStats(sessionId) {
+            const at = settledAt.get(sessionId);
+            const settling = at !== undefined && Date.now() - at < SETTLE_MS;
+            const first = transcriptStats(entriesOf(sessionId));
+            if (!settling)
+                return first;
+            // 回合刚结束的一瞬间 JSONL 可能还没写完最后一条：短暂重读几次，别把半截数字写进面板
+            let last = first;
+            for (let attempt = 0; attempt < 4; attempt += 1) {
+                await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? 400 : 600));
+                last = transcriptStats(entriesOf(sessionId));
+                if (last.contextTokens !== 0 || last.assistantMessages !== first.assistantMessages)
+                    break;
+            }
+            return last;
+        },
+        /** Claude 没有删除会话的命令（`/clear` 只是开新的）：直接删掉那个 JSONL */
+        async deleteSession(handle) {
+            const file = claudeSessionFile(handle, { home: options.home });
+            if (!deleteClaudeSession(handle, { home: options.home, sessionPath: file })) {
+                throw new Error(`找不到这条会话的文件：${handle}`);
+            }
+        },
+    };
+    return engine;
+}
+/** 侧栏过滤的判定也对外暴露一份：会话清单与「刚建的会话在不在侧栏」要用同一套规则 */
+export { isScratchCwd };

package/dist/server/engine/cli-version.js

@@ -0,0 +1,119 @@
+/**
+ * 引擎版本探测（切换面板上**每一项**都要显示自己的版本号，不只是当前那个）。
+ *
+ * 为什么不去问引擎自己：除了 pi（SDK 导出 `VERSION`）和 fake，其余引擎的版本号都是
+ * **握手时**给的（ACP 的 `agentInfo.version`、codex 的 `userAgent`）。要拿到握手结果就得
+ * 起一个子进程 —— 为了一行小字把 codex app-server / claude-code-acp 全拉起来，代价远大于
+ * 收益（codex 还会抢会话写锁、ACP 适配器要读一遍用户配置）。所以这里只做两件便宜事：
+ *
+ *   1. 跑一次 `<bin> --version`（dsh / opencode / codex 都认），带超时，输出里挑版本号；
+ *   2. ACP 适配器（claude-code-acp）**不认** `--version`（它会直接去握手），那就读它
+ *      bin 旁边的 `package.json` —— 面板上要显示的就是这个适配器版本（实测 0.16.2 与
+ *      握手给的 `agentInfo.version` 一致，换引擎前后是同一个数，不会跳）。
+ *
+ * 拿不到就返回 null：界面少一行字，绝不编一个版本号。
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { findExecutable, killTree, resolveCli } from "../util/spawn-cli.js";
+/** `codex-cli 0.162.1`、`0.2.0-rc.2`、`v1.19.0` 都能挑出来 */
+const VERSION_RE = /\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/;
+/** 版本探测超时：拿不到就当没有，不让面板等它 */
+const DEFAULT_TIMEOUT_MS = 4000;
+/** 从一整行输出里挑出版本号本体（`codex-cli 0.162.1` → `0.162.1`）；没有就 null */
+function parseVersionText(text) {
+    const match = VERSION_RE.exec(text ?? "");
+    return match ? match[0] : null;
+}
+/**
+ * 读 `<bin>` 所属 npm 包的 `package.json` 版本（同步、不开子进程）。
+ *
+ * 做法：解析出真实文件路径（`…/bin/claude-code-acp` 是指向
+ * `…/lib/node_modules/@zed-industries/claude-code-acp/dist/index.js` 的软链），
+ * 然后**从它所在目录往上**找最近的 package.json。找不到返回 null。
+ *
+ * Windows 上 npm 装出来的 `claude-code-acp.cmd` 是个 shim（不是软链），往上找不到包，
+ * 这里就返回 null —— 那种情况界面只显示名字，不显示错版本号。
+ */
+export function probePackageVersion(bin, env = process.env, exists = existsSync) {
+    const resolved = findExecutable(bin, env, process.platform, exists) ?? bin;
+    let file;
+    try {
+        file = realpathSync(resolved);
+    }
+    catch {
+        return null;
+    }
+    let dir = dirname(file);
+    for (let depth = 0; depth < 6; depth += 1) {
+        const manifest = join(dir, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+                if (typeof parsed.version === "string" && parsed.version.trim() !== "")
+                    return parsed.version.trim();
+            }
+            catch {
+                // 坏 JSON / 读不了：继续往上找，别把整个探测搞挂
+            }
+            return null; // 最近的 package.json 都没有版本号：再往上只会找到别人的
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * 跑 `<bin> --version` 并挑出版本号；超时 / 没装 / 不认这个参数都返回 null。
+ *
+ * 杀进程走 `killTree`：Windows 上经 cmd.exe 起的 `.cmd` 会再拉一层 node，只杀直接子进程
+ * 会留孤儿（见 util/spawn-cli.ts）。
+ */
+export function probeCliVersion(bin, options = {}) {
+    const args = options.args ?? ["--version"];
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const env = options.env ?? process.env;
+    return new Promise((resolve) => {
+        let timer;
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve(value);
+        };
+        let child;
+        try {
+            const resolved = resolveCli(bin, args, env);
+            child = spawn(resolved.file, resolved.args, {
+                ...resolved.options,
+                // stdin 给 null：`--version` 之后还等输入的实现（claude-code-acp）能立刻退出
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        const timerId = setTimeout(() => {
+            killTree(child);
+            finish(null);
+        }, timeoutMs);
+        timer = timerId;
+        let output = "";
+        child.stdout?.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        // 有的 CLI 把版本打到 stderr
+        child.stderr?.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.on("error", () => finish(null));
+        child.on("close", () => finish(parseVersionText(output)));
+    });
+}

package/dist/server/engine/codex-map.js

@@ -1,5 +1,5 @@
 /**
- * codex app-server 的**纯映射**（不碰网络/子进程，单测直接覆盖）。
+ * codex app-server 的**纯映射**（不碰网络/子进程）。
  *
  * 三件事：
  *   1. thread items → 工作台的 `UiMessage`（对话区与历史都靠它）；
@@ -56,7 +56,12 @@ export function itemsToUiMessages(items, ts) {
             const text = textOf(item.content);
             if (text.trim() === "")
                 continue;
-            messages.push({ id: item.id ?? `codex-user-${ts}-${messages.length}`, role: "user", ts, blocks: [{ kind: "text", text }] });
+            messages.push({
+                id: item.id ?? `codex-user-${ts}-${messages.length}`,
+                role: "user",
+                ts,
+                blocks: [{ kind: "text", text }],
+            });
             assistant = null;
             continue;
         }
@@ -70,7 +75,12 @@ export function itemsToUiMessages(items, ts) {
             continue;
         }
         if (type === "reasoning" || type === "plan") {
-            const text = type === "plan" ? (item.text ?? "") : [...(item.summary ?? []), ...(Array.isArray(item.content) ? item.content.filter((c) => typeof c === "string") : [])].join("\n");
+            const text = type === "plan"
+                ? (item.text ?? "")
+                : [
+                    ...(item.summary ?? []),
+                    ...(Array.isArray(item.content) ? item.content.filter((c) => typeof c === "string") : []),
+                ].join("\n");
             if (text.trim() === "")
                 continue;
             const target = ensureAssistant();
@@ -138,7 +148,11 @@ export function itemsToUiMessages(items, ts) {
         }
         if (type === "imageView" || type === "imageGeneration" || type === "webSearch") {
             const target = ensureAssistant();
-            const text = type === "webSearch" ? "（联网搜索）" : type === "imageView" ? `（查看图片：${item.path ?? ""}）` : "（生成图片）";
+            const text = type === "webSearch"
+                ? "（联网搜索）"
+                : type === "imageView"
+                    ? `（查看图片：${item.path ?? ""}）`
+                    : "（生成图片）";
             target.blocks = [...target.blocks, { kind: "text", text }];
         }
     }
@@ -182,7 +196,7 @@ export function thinkingLevelsOf(models, modelId) {
         .filter((effort) => typeof effort === "string" && effort !== "");
 }
 /** 命令行 → 「这类」的作用域键（与 pi 侧的 bash 规则同构，`总是允许这类` 才有意义） */
-export function commandScope(command) {
+function commandScope(command) {
     const first = command.trim().split(/\s+/)[0] ?? "";
     const clean = first.replace(/^.*\//, "");
     return { scopeKey: `bash|${clean}`, scopeHint: clean === "" ? command.trim().slice(0, 60) : clean };
@@ -220,24 +234,6 @@ export function approvalDecision(decision, kind) {
         return "acceptForSession";
     return kind === "command" ? "accept" : "accept";
 }
-/** 模型下拉里显示的当前模型（codex 的 provider 只有一个，给个稳定标签） */
-export function modelDisplay(provider, model) {
-    if (!model)
-        return null;
-    return `${provider ?? "codex"}/${model}`;
-}
-/** 给 `ModelOption` 用：把引擎模型表转成快照里的形状（保留顺序，去重） */
-export function toModelOptions(models) {
-    const seen = new Set();
-    const options = [];
-    for (const model of models) {
-        if (seen.has(model.id))
-            continue;
-        seen.add(model.id);
-        options.push({ id: model.id, label: model.label });
-    }
-    return options;
-}
 export function toolStartOf(item) {
     const id = item.id ?? `codex-tool-${item.type}`;
     if (item.type === "commandExecution") {

package/dist/server/engine/codex-sessions.js

@@ -32,10 +32,10 @@ function underRoot(cwd, root) {
     return cwd.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 /**
- * 纯分组：projects + threads → 侧栏形状（单测直接覆盖）。
+ * 纯分组：projects + threads → 侧栏形状。
  * 会话按 updatedAt 倒序；项目之间保持 codex 的 position 顺序。
  */
-export function groupThreads(projects, threads) {
+function groupThreads(projects, threads) {
     const byProjectId = new Map(projects.map((project) => [project.id, project]));
     const roots = projects.flatMap((project) => project.roots.map((root) => ({ projectId: project.id, path: root.path ?? "" })));
     const groups = new Map();
@@ -81,7 +81,7 @@ export function groupThreads(projects, threads) {
             model: thread.model ?? null,
         });
     }
-    return [...groups.values()]
+    return ([...groups.values()]
         .map((group) => ({
         cwd: group.cwd,
         name: group.project?.name?.trim() || basename(group.cwd) || "未分项目",
@@ -92,10 +92,10 @@ export function groupThreads(projects, threads) {
         const leftAt = left.sessions[0]?.updatedAt ?? 0;
         const rightAt = right.sessions[0]?.updatedAt ?? 0;
         return rightAt - leftAt;
-    });
+    }));
 }
 /** 分页拉全部会话（跟随 nextCursor；上限 5 页，避免超大库把首屏拖死） */
-export async function listAllThreads(client, pageSize = 200) {
+async function listAllThreads(client, pageSize = 200) {
     const rows = [];
     let cursor = null;
     for (let page = 0; page < 5; page += 1) {