oh-my-agent-web 0.3.0 → 0.4.0

package/dist/server/engine/codex.js

@@ -0,0 +1,314 @@
+import { friendlyCodexError, itemsToTranscript, itemsToUiMessages, mapModels, thinkingLevelsOf, toolEndOf, toolStartOf, turnTs, } from "./codex-map.js";
+import { createCodexClient } from "./codex-transport.js";
+import { registerCodexApprovals } from "./codex-approvals.js";
+import { sanitizeHistoricalActions } from "../markers/actions.js";
+import { ensureCodexProject } from "./codex-sessions.js";
+export function createCodexEngine(options = {}) {
+    const client = options.client ?? createCodexClient({ bin: options.bin, home: options.home, log: options.log ?? (() => { }) });
+    const bindings = new Map();
+    const byThread = new Map();
+    const active = new Map();
+    let models = null;
+    let approvalHandler = null;
+    /** 最近一次可预期失败的原因（给界面用，见 EnginePort.lastError） */
+    let lastError = null;
+    const threadOf = (sessionId) => {
+        const binding = bindings.get(sessionId);
+        if (binding)
+            return binding;
+        // 历史会话：侧栏给的 id 就是 threadId（provider 保证），直接认
+        if (/^[0-9a-f-]{36}$/i.test(sessionId)) {
+            const adopted = { threadId: sessionId, workspace: "", live: false };
+            bindings.set(sessionId, adopted);
+            byThread.set(sessionId, sessionId);
+            return adopted;
+        }
+        return null;
+    };
+    const loadModels = async () => {
+        if (models)
+            return models;
+        const result = await client.request("model/list", {});
+        models = result?.data ?? [];
+        return models;
+    };
+    const handleNotification = (notification) => {
+        const params = notification.params;
+        const threadId = typeof params.threadId === "string" ? params.threadId : "";
+        const conversationId = byThread.get(threadId);
+        const turn = conversationId ? active.get(conversationId) : undefined;
+        const emit = (event) => {
+            if (turn && !turn.ended)
+                turn.onEvent(event);
+        };
+        switch (notification.method) {
+            case "item/agentMessage/delta":
+                emit({ type: "text_delta", text: typeof params.delta === "string" ? params.delta : "" });
+                return;
+            case "item/reasoning/textDelta":
+            case "item/reasoning/summaryTextDelta":
+                emit({ type: "thinking_delta", text: typeof params.delta === "string" ? params.delta : "" });
+                return;
+            case "item/started": {
+                const event = toolStartOf((params.item ?? {}));
+                if (event)
+                    emit(event);
+                return;
+            }
+            case "item/completed": {
+                const event = toolEndOf((params.item ?? {}));
+                if (event)
+                    emit(event);
+                return;
+            }
+            case "thread/tokenUsage/updated": {
+                const usage = params.tokenUsage;
+                const last = usage?.last;
+                if (!last)
+                    return;
+                emit({
+                    type: "usage",
+                    input: last.inputTokens ?? 0,
+                    output: last.outputTokens ?? 0,
+                    cacheRead: last.cachedInputTokens ?? 0,
+                    cacheWrite: last.cacheWriteInputTokens ?? 0,
+                });
+                return;
+            }
+            case "turn/completed": {
+                if (!turn)
+                    return;
+                const completed = (params.turn ?? {});
+                if (turn.turnId && completed.id && completed.id !== turn.turnId)
+                    return;
+                const reason = completed.status === "interrupted" ? "interrupted" : completed.status === "failed" ? "error" : "done";
+                emit({ type: "turn_end", reason });
+                turn.ended = true;
+                turn.finish();
+                return;
+            }
+            case "error": {
+                // willRetry=true 是 codex 内部的瞬时重试（断流、429…）：不该在对话里留一条红色错误
+                if (params.willRetry === true)
+                    return;
+                const error = params.error;
+                const message = error?.message ?? "codex 报错";
+                emit({ type: "error", code: "engine.codex_error", message });
+                if (turn) {
+                    emit({ type: "turn_end", reason: "error" });
+                    turn.ended = true;
+                    turn.finish();
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    client.onNotification(handleNotification);
+    registerCodexApprovals({ client, getHandler: () => approvalHandler });
+    /** 当前模型（provider/model 口径）：thread/read 是最准的来源 */
+    const currentModelOf = async (sessionId) => {
+        const binding = threadOf(sessionId);
+        if (!binding)
+            return null;
+        const result = await client.request("thread/read", { threadId: binding.threadId });
+        const model = result?.thread?.model ?? null;
+        if (!model)
+            return null;
+        // provider 留空 = 「id 本身就是全名」：codex 的模型 id 就是 slug，界面上不该显示 `codex/xxx`
+        return { provider: "", model };
+    };
+    /** 读最近若干轮（codex 默认倒序分页 → 翻正序；40 轮够对话区与侧栏用） */
+    const loadTurns = async (sessionId) => {
+        const binding = threadOf(sessionId);
+        if (!binding)
+            return [];
+        const result = await client.request("thread/turns/list", {
+            threadId: binding.threadId,
+            limit: 40,
+            sortDirection: "desc",
+        });
+        return [...(result?.data ?? [])].reverse();
+    };
+    /** 确保这个会话对应的 thread 已加载（历史会话要先 resume，否则无法开回合 / 改设置） */
+    const ensureLive = async (sessionId) => {
+        const binding = threadOf(sessionId);
+        if (!binding)
+            return null;
+        if (binding.live)
+            return binding;
+        await client.request("thread/resume", { threadId: binding.threadId, excludeTurns: true });
+        binding.live = true;
+        return binding;
+    };
+    return {
+        client,
+        version: () => client.version(),
+        async createSession(sessionOptions) {
+            // 对齐原生：新会话落在 codex 的 project 里（没有就建一个，幂等键按目录）
+            const projectId = await ensureCodexProject(client, sessionOptions.workspace);
+            const response = await client.request("thread/start", {
+                cwd: sessionOptions.workspace,
+                ...(projectId ? { projectId } : {}),
+            });
+            const threadId = response?.thread?.id;
+            if (!threadId)
+                throw new Error("codex 没有返回 thread id");
+            const binding = { threadId, workspace: sessionOptions.workspace, live: true };
+            bindings.set(sessionOptions.sessionId, binding);
+            byThread.set(threadId, sessionOptions.sessionId);
+            return { sessionPath: null, engineSessionId: threadId };
+        },
+        async openSession(openOptions) {
+            const threadId = openOptions.engineSessionId ?? openOptions.sessionPath ?? openOptions.sessionId;
+            const binding = { threadId, workspace: "", live: false };
+            bindings.set(openOptions.sessionId, binding);
+            byThread.set(threadId, openOptions.sessionId);
+            // 不在打开时 resume：历史会话常常只需要读；真要发消息时再 resume（少一次加载）
+        },
+        async sendMessage(sessionId, text, onEvent) {
+            const binding = await ensureLive(sessionId).catch((error) => {
+                throw new Error(friendlyCodexError(error));
+            });
+            if (!binding)
+                throw new Error("codex 会话还没准备好（先新建或打开一个会话）");
+            let finish = () => { };
+            const done = new Promise((resolve) => {
+                finish = resolve;
+            });
+            const turn = { turnId: null, onEvent, finish, ended: false };
+            active.set(sessionId, turn);
+            try {
+                const response = await client.request("turn/start", { threadId: binding.threadId, input: [{ type: "text", text, text_elements: [] }] }, { timeoutMs: 120_000 });
+                turn.turnId = response?.turn?.id ?? null;
+                await done;
+            }
+            finally {
+                turn.ended = true;
+                active.delete(sessionId);
+            }
+        },
+        async interrupt(sessionId) {
+            const binding = threadOf(sessionId);
+            const turn = active.get(sessionId);
+            if (!binding || !turn?.turnId)
+                return;
+            // 停止按钮是 fire-and-forget（看门狗也会直接 void 调它）：RPC 失败不能让
+            // Promise 拒绝一路飘到进程级（Node 默认会直接把服务带走）。
+            try {
+                await client.request("turn/interrupt", { threadId: binding.threadId, turnId: turn.turnId });
+            }
+            catch (error) {
+                // 只记日志：停止失败最坏是「这一轮继续跑」，不该把进程一起带走
+                options.log?.(`停止失败：${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async closeSession(sessionId) {
+            const binding = bindings.get(sessionId);
+            bindings.delete(sessionId);
+            if (!binding)
+                return;
+            byThread.delete(binding.threadId);
+            await client.request("thread/unsubscribe", { threadId: binding.threadId }).catch(() => undefined);
+        },
+        async readUiMessages(sessionId) {
+            const turns = await loadTurns(sessionId);
+            const now = Date.now();
+            return sanitizeHistoricalActions(turns.flatMap((turn) => itemsToUiMessages(turn.items ?? [], turnTs(turn, now))));
+        },
+        async readTranscript(sessionId) {
+            const turns = await loadTurns(sessionId);
+            const now = Date.now();
+            return turns.flatMap((turn) => itemsToTranscript(turn.items ?? [], turnTs(turn, now)));
+        },
+        renameSession: (handle, name) => client.request("thread/name/set", { threadId: handle, name }).then(() => undefined),
+        deleteSession: (handle) => client.request("thread/delete", { threadId: handle }).then(() => undefined),
+        /**
+         * 不看了就放开写锁（`thread/unsubscribe`）：Codex 桌面端随即可以打开这条会话。
+         * 下次再发消息会重新 resume（几毫秒），换来「两端不会互相锁死」。
+         */
+        async parkSession(sessionId) {
+            const binding = bindings.get(sessionId);
+            if (!binding || !binding.live)
+                return;
+            binding.live = false;
+            await client.request("thread/unsubscribe", { threadId: binding.threadId }).catch(() => undefined);
+        },
+        /**
+         * 换引擎 / 退出：关掉 app-server 子进程。
+         * 它持有我们 resume 过的**全部** thread 的写锁，不关就会一直挡着 Codex 桌面端。
+         */
+        async dispose() {
+            bindings.clear();
+            byThread.clear();
+            active.clear();
+            models = null;
+            client.close();
+        },
+        setApprovalHandler(handler) {
+            approvalHandler = handler;
+        },
+        async prewarm() {
+            await client.ensureStarted();
+            await loadModels().catch(() => []); // 模型表拿不到不影响会话，只是下拉为空
+        },
+        reloadModels: async () => {
+            models = null;
+        },
+        async listModels() {
+            return mapModels(await loadModels());
+        },
+        currentModel: currentModelOf,
+        sessionModel: currentModelOf,
+        async switchModel(sessionId, modelId) {
+            lastError = null;
+            try {
+                // 历史会话要先 resume：没加载的 thread 改不了设置，发回合也不行
+                const binding = await ensureLive(sessionId);
+                if (!binding) {
+                    lastError = "先打开一个会话";
+                    return false;
+                }
+                await client.request("thread/settings/update", { threadId: binding.threadId, model: modelId });
+                return true;
+            }
+            catch (error) {
+                lastError = friendlyCodexError(error);
+                return false;
+            }
+        },
+        lastError: () => lastError,
+        async listThinkingLevels(sessionId) {
+            const catalog = await loadModels().catch(() => []);
+            return thinkingLevelsOf(catalog, sessionId ? ((await currentModelOf(sessionId))?.model ?? null) : null);
+        },
+        async getThinkingLevel(sessionId) {
+            if (!sessionId)
+                return null;
+            const binding = threadOf(sessionId);
+            if (!binding)
+                return null;
+            const result = await client.request("thread/read", {
+                threadId: binding.threadId,
+            });
+            return result?.thread?.reasoningEffort ?? null;
+        },
+        async setThinkingLevel(sessionId, level) {
+            lastError = null;
+            try {
+                const binding = await ensureLive(sessionId);
+                if (!binding) {
+                    lastError = "先打开一个会话";
+                    return false;
+                }
+                await client.request("thread/settings/update", { threadId: binding.threadId, effort: level });
+                return true;
+            }
+            catch (error) {
+                lastError = friendlyCodexError(error);
+                return false;
+            }
+        },
+    };
+}

package/dist/server/engine/dsh-history.js

@@ -0,0 +1,195 @@
+/**
+ * DSH 会话日志 → 工作台的对话区消息 / 转录 / 统计（纯函数，单测直接覆盖）。
+ *
+ * 与 `dsh-log.ts` 分工：那边只管**怎么把文件读出来**（多帧 zstd、定位、标题素材），
+ * 这里只管**怎么映射成我们的形状**（消息块 / 工具状态 / 四桶用量）。
+ *
+ * 两条纪律：
+ *   1. `source.kind !== "user"` 的 user/message 是系统注入（runtime-context / skill-catalog / goal…），
+ *      不进对话区、不参与计数；
+ *   2. 工具块先立成 running，由 `tool/result` 收口；没有结果的（被中断）最后标 failed，
+ *      不能一直转圈骗人。
+ */
+import { TOOL_EXCERPT_CHARS } from "../protocol.js";
+import { isInternalUserMessage } from "./dsh-log.js";
+/** 取 content[] 里的文本（user 消息与工具结果共用） */
+function textOf(blocks) {
+    if (!Array.isArray(blocks))
+        return "";
+    return blocks
+        .map((block) => {
+        const item = block;
+        return item?.type === "text" && typeof item.text === "string" ? item.text : "";
+    })
+        .join("");
+}
+/** 日志 → 对话区消息（历史回放）。工具块先立成 running，由 tool/result 收口 */
+export function logToUiMessages(log) {
+    const messages = [];
+    const toolBlocks = new Map();
+    for (const event of log.events) {
+        const ts = typeof event.time === "number" ? event.time : 0;
+        if (event.type === "user/message") {
+            if (isInternalUserMessage(event.data))
+                continue;
+            const text = textOf(event.data?.content);
+            if (text.trim() === "")
+                continue;
+            const id = typeof event.data?.id === "string" ? event.data.id : `u-${event.seq ?? messages.length}`;
+            messages.push({ id: `u-${id}`, role: "user", ts, blocks: [{ kind: "text", text }] });
+            continue;
+        }
+        if (event.type === "assistant/message") {
+            const message = event.data?.message;
+            if (!message)
+                continue;
+            const id = message.id ?? `a-${event.seq ?? messages.length}`;
+            const blocks = [];
+            for (const block of message.content ?? []) {
+                if (block.type === "reasoning" && typeof block.text === "string" && block.text !== "") {
+                    blocks.push({ kind: "thinking", text: block.text });
+                    continue;
+                }
+                if (block.type === "text" && typeof block.text === "string" && block.text !== "") {
+                    blocks.push({ kind: "text", text: block.text });
+                    continue;
+                }
+                if (block.type === "tool-call") {
+                    const toolCallId = block.id ?? `tool-${event.seq ?? 0}`;
+                    const args = block.arguments ?? "";
+                    const toolBlock = {
+                        kind: "tool",
+                        toolCallId,
+                        name: block.name ?? "tool",
+                        argsSummary: args.length > 300 ? `${args.slice(0, 300)}…` : args,
+                        argsFull: args,
+                        status: "running",
+                        outputExcerpt: "",
+                        truncated: false,
+                        startedAt: ts,
+                    };
+                    blocks.push(toolBlock);
+                    continue;
+                }
+            }
+            if (blocks.length === 0)
+                continue;
+            const ui = {
+                id: `a-${id}`,
+                role: "assistant",
+                ts,
+                endedAt: ts,
+                blocks,
+                ...(typeof message.model === "string" ? { model: message.model } : {}),
+            };
+            messages.push(ui);
+            for (const block of blocks)
+                if (block.kind === "tool")
+                    toolBlocks.set(block.toolCallId, { message: ui, block });
+            continue;
+        }
+        if (event.type === "tool/result") {
+            const result = event.data?.message;
+            const toolCallId = result?.toolCallId;
+            if (!toolCallId)
+                continue;
+            const found = toolBlocks.get(toolCallId);
+            if (!found)
+                continue;
+            const raw = textOf(result?.content);
+            const clipped = raw.length > TOOL_EXCERPT_CHARS ? `${raw.slice(0, TOOL_EXCERPT_CHARS)}…` : raw;
+            found.block.status = result?.isError === true ? "failed" : "ok";
+            found.block.outputExcerpt = clipped;
+            found.block.truncated = raw.length > TOOL_EXCERPT_CHARS;
+            found.block.endedAt = ts;
+        }
+    }
+    // 没有结果的工具调用（被中断/崩溃）：不能留在 running 上骗人
+    for (const { block } of toolBlocks.values()) {
+        if (block.status === "running")
+            block.status = "failed";
+    }
+    return messages;
+}
+/** 日志 → 引擎转录（只留正文，给需要纯文本的地方用） */
+export function logToTranscript(log) {
+    const out = [];
+    const source = log.events;
+    for (const event of source) {
+        if (event.type === "user/message") {
+            if (isInternalUserMessage(event.data))
+                continue;
+            const text = textOf(event.data?.content).trim();
+            if (text !== "")
+                out.push({ role: "user", text, ts: typeof event.time === "number" ? event.time : 0 });
+            continue;
+        }
+        if (event.type === "assistant/message") {
+            const message = event.data?.message;
+            const text = (message?.content ?? [])
+                .filter((block) => block.type === "text")
+                .map((block) => block.text ?? "")
+                .join("");
+            if (text.trim() !== "")
+                out.push({ role: "assistant", text, ts: typeof event.time === "number" ? event.time : 0 });
+        }
+    }
+    return out;
+}
+/** 日志 → 会话统计（用量来自 assistant/message.data.usage，四桶互斥） */
+export function statsFromLog(log) {
+    const stats = {
+        userMessages: 0,
+        assistantMessages: 0,
+        toolCalls: 0,
+        toolResults: 0,
+        totalMessages: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        contextTokens: 0,
+    };
+    let seen = false;
+    for (const event of log.events) {
+        if (event.type === "user/message") {
+            if (isInternalUserMessage(event.data))
+                continue;
+            stats.userMessages += 1;
+            seen = true;
+            continue;
+        }
+        if (event.type === "assistant/message") {
+            stats.assistantMessages += 1;
+            seen = true;
+            const content = event.data?.message?.content ?? [];
+            stats.toolCalls += content.filter((block) => block.type === "tool-call").length;
+            const usage = event.data?.usage;
+            if (usage) {
+                const input = number(usage.inputTokens);
+                const output = number(usage.outputTokens);
+                const cacheRead = number(usage.cacheReadTokens);
+                const cacheWrite = number(usage.cacheWriteTokens);
+                stats.inputTokens += input;
+                stats.outputTokens += output;
+                stats.cacheRead += cacheRead;
+                stats.cacheWrite += cacheWrite;
+                stats.contextTokens = input + cacheRead + cacheWrite;
+            }
+            continue;
+        }
+        if (event.type === "tool/result") {
+            stats.toolResults += 1;
+            seen = true;
+        }
+    }
+    if (!seen)
+        return null;
+    stats.totalMessages = stats.userMessages + stats.assistantMessages;
+    stats.totalTokens = stats.inputTokens + stats.outputTokens + stats.cacheRead + stats.cacheWrite;
+    return stats;
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+}