oh-my-agent-web 0.4.0 → 0.5.0

package/dist/server/engine/opencode.js

@@ -0,0 +1,394 @@
+import { isScratchCwd } from "./scratch.js";
+import { currentModelId, currentThinkingLevel, exportStats, exportToTranscript, exportToUiMessages, friendlyOpencodeError, hasPendingUsage, hasUsableToolFacts, isFinalToolStatus, modelOptions, modelValueFor, parseModelValue, permissionApprovalRequest, permissionOptionId, stopReasonToTurnEnd, textEventOf, thinkingConfigId, thinkingLevels, toolEndEvent, toolStartEvent, usageEventOf, } from "./opencode-map.js";
+import { deleteOpencodeSession, readOpencodeExport } from "./opencode-sessions.js";
+import { createOpencodeClient } from "./opencode-transport.js";
+const MAX_TOOL_FACTS = 200;
+/** 历史导出缓存时长：`sessionStats` 会被快照频繁调用，不能每次都起子进程 */
+const EXPORT_CACHE_MS = 3000;
+/**
+ * 回合刚结束后多久内，「读统计」要等一下再读。
+ *
+ * 为什么必须有它：`session/prompt` 一返回，宿主立刻调 `sessionStats`；而 opencode
+ * 是**先返回再落库**，这一瞬间 `opencode export` 还看不到最后一条 assistant
+ * （实测：续聊一轮后数字停在前一轮，要等一会儿才对）。所以这一小段窗口里
+ * 先让出 600ms 再读，并且不吃缓存。
+ */
+const EXPORT_SETTLE_MS = 3000;
+export function createOpencodeEngine(options = {}) {
+    const bin = options.bin ?? "opencode";
+    const client = options.client ?? createOpencodeClient({ bin, args: options.args, log: options.log ?? (() => { }) });
+    const bindings = new Map();
+    const byEngineSession = new Map();
+    const active = new Map();
+    /** toolCallId → 工具事实（权限请求兜底 / 延迟开卡片用） */
+    const toolFacts = new Map();
+    const exportCache = new Map();
+    /** conversationId → 最近一次回合结束的时刻（用于 EXPORT_SETTLE_MS 的等待） */
+    const settledAt = new Map();
+    let approvalHandler = null;
+    let lastError = null;
+    /**
+     * 最近一次拿到的 configOptions（模型 / 思考档目录）。
+     * 历史会话在 resume 之前没有 config，但选择器不该是空的 —— 用它兜底；
+     * 真正切模型时仍会先 resume（拿不到就报可读错误）。
+     */
+    let lastConfig = [];
+    const rememberTool = (facts) => {
+        const previous = toolFacts.get(facts.toolCallId);
+        // 后到的 update 更详细（title 从 "bash" 变成真命令），合并而不是覆盖
+        toolFacts.set(facts.toolCallId, { ...previous, ...facts });
+        if (toolFacts.size > MAX_TOOL_FACTS) {
+            const oldest = toolFacts.keys().next().value;
+            if (oldest)
+                toolFacts.delete(oldest);
+        }
+    };
+    const applyConfig = (binding, config) => {
+        if (!Array.isArray(config) || config.length === 0)
+            return;
+        lastConfig = config;
+        if (binding)
+            binding.config = lastConfig;
+    };
+    const bindingOf = (conversationId) => bindings.get(conversationId) ?? null;
+    const anyConfig = (conversationId) => {
+        const binding = conversationId ? bindingOf(conversationId) : undefined;
+        if (binding && binding.config.length > 0)
+            return binding.config;
+        return [...bindings.values()].find((item) => item.config.length > 0)?.config ?? lastConfig;
+    };
+    const invalidateExport = (conversationId) => {
+        const binding = bindingOf(conversationId);
+        if (binding)
+            exportCache.delete(binding.engineSessionId);
+    };
+    /** 回合结束：先失效缓存（下一次读必须重新取），并记下时刻供 sessionStats 等待 */
+    const markTurnSettled = (conversationId) => {
+        invalidateExport(conversationId);
+        settledAt.set(conversationId, Date.now());
+    };
+    /** 历史会话首次使用时才 resume（ACP 的 resume 会拿写句柄，所以按需） */
+    const ensureLive = async (conversationId) => {
+        const binding = bindingOf(conversationId);
+        if (!binding)
+            return null;
+        if (binding.live)
+            return binding;
+        const result = await client.request("session/resume", {
+            sessionId: binding.engineSessionId,
+            cwd: binding.cwd,
+            mcpServers: [],
+        });
+        binding.live = true;
+        applyConfig(binding, result?.configOptions);
+        return binding;
+    };
+    const setOption = async (conversationId, configId, value) => {
+        lastError = null;
+        try {
+            const binding = await ensureLive(conversationId);
+            if (!binding) {
+                lastError = "先打开一个会话";
+                return false;
+            }
+            const result = await client.request("session/set_config_option", {
+                sessionId: binding.engineSessionId,
+                configId,
+                value,
+            });
+            applyConfig(binding, result?.configOptions);
+            return true;
+        }
+        catch (error) {
+            lastError = friendlyOpencodeError(error);
+            return false;
+        }
+    };
+    const handleToolUpdate = (conversationId, update) => {
+        const toolCallId = update.toolCallId;
+        if (typeof toolCallId !== "string" || toolCallId === "")
+            return;
+        const facts = { toolCallId };
+        if (typeof update.title === "string")
+            facts.title = update.title;
+        if (typeof update.kind === "string")
+            facts.kind = update.kind;
+        if (update.rawInput !== undefined)
+            facts.rawInput = update.rawInput;
+        rememberTool(facts);
+        const merged = toolFacts.get(toolCallId) ?? facts;
+        const turn = active.get(conversationId);
+        if (!turn || turn.ended)
+            return;
+        // 延迟开卡片：等「有真参数」那一条（否则先显示成 `bash {"cwd":…}`）
+        if (!turn.started.has(toolCallId)) {
+            const final = isFinalToolStatus(update.status);
+            if (!hasUsableToolFacts(merged) && !final)
+                return;
+            turn.started.add(toolCallId);
+            turn.onEvent(toolStartEvent(merged));
+        }
+        if (!isFinalToolStatus(update.status) || turn.finished.has(toolCallId))
+            return;
+        turn.finished.add(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 === "config_option_update") {
+            applyConfig(bindingOf(conversationId) ?? undefined, update.configOptions);
+            return;
+        }
+        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 facts = params.toolCall?.toolCallId ? toolFacts.get(params.toolCall.toolCallId) : undefined;
+        const request = permissionApprovalRequest(params, facts);
+        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;
+        }
+        // 认不出的服务端请求必须回包，否则 opencode 那一轮会一直等
+        client.respondError(request.id, -32601, `agent-web 未实现的服务端请求：${request.method}`);
+    });
+    /** 读一条会话的导出（带缓存）：历史回放与统计共用 */
+    const exportOf = async (conversationId, readOptions = {}) => {
+        const binding = bindingOf(conversationId);
+        const engineSessionId = binding?.engineSessionId ?? conversationId;
+        if (!readOptions.fresh) {
+            const cached = exportCache.get(engineSessionId);
+            if (cached && Date.now() - cached.at < EXPORT_CACHE_MS)
+                return cached.value;
+        }
+        const value = await readOpencodeExport(bin, engineSessionId, { log: options.log });
+        // 读失败（opencode 忙 / 会话刚建还没落库）不写缓存，否则 3 秒内都拿不到真数据
+        if (value)
+            exportCache.set(engineSessionId, { at: Date.now(), value });
+        return value;
+    };
+    return {
+        client,
+        version: () => client.version(),
+        async prewarm() {
+            await client.ensureStarted();
+        },
+        async createSession(sessionOptions) {
+            const created = await client
+                .request("session/new", {
+                cwd: sessionOptions.workspace,
+                mcpServers: [],
+            })
+                .catch((error) => {
+                throw new Error(friendlyOpencodeError(error));
+            });
+            const engineSessionId = created?.sessionId;
+            if (!engineSessionId)
+                throw new Error("opencode 没有返回 sessionId");
+            const binding = {
+                engineSessionId,
+                cwd: sessionOptions.workspace,
+                live: true,
+                config: created.configOptions ?? [],
+            };
+            bindings.set(sessionOptions.sessionId, binding);
+            byEngineSession.set(engineSessionId, sessionOptions.sessionId);
+            applyConfig(binding, created.configOptions);
+            exportCache.delete(engineSessionId);
+            // 默认模型：只尊重显式配置（AGENT_WEB_OPENCODE_MODEL），否则用 opencode 自己的默认
+            const wanted = options.model?.trim();
+            if (wanted) {
+                const value = modelValueFor(binding.config, wanted);
+                if (value && value !== currentModelId(binding.config)) {
+                    await setOption(sessionOptions.sessionId, "model", value);
+                }
+                else if (!value) {
+                    options.log?.(`opencode：默认模型不在可选列表里，已忽略：${wanted}`);
+                }
+            }
+            return { sessionPath: null, engineSessionId };
+        },
+        async openSession(openOptions) {
+            const engineSessionId = openOptions.engineSessionId ?? openOptions.sessionPath ?? openOptions.sessionId;
+            const binding = {
+                engineSessionId,
+                cwd: openOptions.cwd ?? "",
+                live: false,
+                config: [],
+            };
+            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(friendlyOpencodeError(error));
+            });
+            if (!binding)
+                throw new Error("opencode 会话还没准备好（先新建一个会话）");
+            const turn = { onEvent, ended: false, started: new Set(), finished: new Set() };
+            active.set(sessionId, turn);
+            const model = currentModelId(binding.config);
+            if (model)
+                onEvent({ type: "model", 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 });
+                markTurnSettled(sessionId);
+                const usage = usageEventOf(result);
+                if (usage && !turn.ended)
+                    onEvent(usage);
+                if (!turn.ended)
+                    onEvent({ type: "turn_end", reason: stopReasonToTurnEnd(result?.stopReason) });
+            }
+            catch (error) {
+                invalidateExport(sessionId);
+                throw new Error(friendlyOpencodeError(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 });
+        },
+        /** 不看了：关掉会话释放写句柄（opencode 自己的 TUI / CLI 才能打开它） */
+        async parkSession(sessionId) {
+            const binding = bindingOf(sessionId);
+            if (!binding || !binding.live)
+                return;
+            binding.live = false;
+            await client.request("session/close", { sessionId: binding.engineSessionId }).catch(() => undefined);
+        },
+        async closeSession(sessionId) {
+            await this.parkSession?.(sessionId);
+            const binding = bindingOf(sessionId);
+            bindings.delete(sessionId);
+            if (binding) {
+                byEngineSession.delete(binding.engineSessionId);
+                exportCache.delete(binding.engineSessionId);
+            }
+        },
+        async dispose() {
+            // 注意：**不清 lastConfig** —— 它只是「opencode 有哪些模型/档位」的目录快照，
+            // 切走再切回时模型选择器不该空着；真正切模型时会先 resume 拿最新 configOptions。
+            bindings.clear();
+            byEngineSession.clear();
+            active.clear();
+            toolFacts.clear();
+            exportCache.clear();
+            settledAt.clear();
+            client.close();
+        },
+        setApprovalHandler(handler) {
+            approvalHandler = handler;
+        },
+        async listModels(sessionId) {
+            return modelOptions(anyConfig(sessionId));
+        },
+        async switchModel(sessionId, modelId) {
+            const value = modelValueFor(anyConfig(sessionId), modelId);
+            if (!value) {
+                lastError = `这个模型不在 opencode 的可选列表里：${modelId}`;
+                return false;
+            }
+            return setOption(sessionId, "model", value);
+        },
+        async currentModel(sessionId) {
+            return parseModelValue(currentModelId(anyConfig(sessionId)));
+        },
+        async sessionModel(sessionId) {
+            return this.currentModel?.(sessionId) ?? null;
+        },
+        async listThinkingLevels(sessionId) {
+            return thinkingLevels(anyConfig(sessionId));
+        },
+        async getThinkingLevel(sessionId) {
+            return currentThinkingLevel(anyConfig(sessionId));
+        },
+        async setThinkingLevel(sessionId, level) {
+            // configId 随引擎/模型而变（opencode = effort），从当前 configOptions 里取
+            return setOption(sessionId, thinkingConfigId(anyConfig(sessionId)), level);
+        },
+        lastError: () => lastError,
+        /** 历史回放：走 `opencode export`（ACP 的 load 会重放事件但会占写句柄，不适合只读） */
+        async readUiMessages(sessionId) {
+            return exportToUiMessages(await exportOf(sessionId));
+        },
+        async readTranscript(sessionId) {
+            return exportToTranscript(await exportOf(sessionId));
+        },
+        /** 用量统计：四桶来自每条 assistant 的 `info.tokens`（opencode 自己按次记账） */
+        async sessionStats(sessionId) {
+            // 回合刚结束的一小段时间：opencode 可能「消息已存、tokens 未存」→ 验证 + 重试，
+            // 直到拿到已记账的那一版（理由见 EXPORT_SETTLE_MS / hasPendingUsage）
+            const at = settledAt.get(sessionId);
+            const settling = at !== undefined && Date.now() - at < EXPORT_SETTLE_MS;
+            if (!settling) {
+                const exported = await exportOf(sessionId);
+                return exported ? exportStats(exported) : null;
+            }
+            let last = null;
+            for (let attempt = 0; attempt < 4; attempt += 1) {
+                await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? 400 : 600));
+                invalidateExport(sessionId);
+                last = await exportOf(sessionId, { fresh: true });
+                if (last && !hasPendingUsage(last))
+                    return exportStats(last);
+            }
+            // 还没落完（或这一轮真的没有任何用量）：给最后一次的读数，不编数字
+            return last ? exportStats(last) : null;
+        },
+        /** opencode 原生删除（`opencode session delete <sid>`）；改名没接（ACP 无此方法） */
+        async deleteSession(handle) {
+            await deleteOpencodeSession(bin, handle);
+            exportCache.delete(handle);
+        },
+    };
+}
+/** 侧栏过滤的判定也对外暴露一份：会话清单与「刚建的会话在不在侧栏」要用同一套规则 */
+export { isScratchCwd };