oh-my-agent-web 0.4.0 → 0.5.0

package/dist/server/engine/opencode-projects.js

@@ -0,0 +1,61 @@
+/**
+ * opencode 的「会话目录清单」——只回答一个问题：侧栏该向哪些目录点名。
+ *
+ * 为什么需要它：ACP 的 `session/list` 是**目录作用域**的（opencode-sessions.ts 文件头有实测）：
+ *   - 不带 cwd：只拿 acp 子进程自己那个目录的会话；
+ *   - 带 `{cwd}`：只拿 `directory` **精确等于** cwd 的会话（不是整棵项目树）。
+ * 所以「全部历史」= 把「有过会话的目录」逐个报给它。目录从哪来？
+ *   - 工作台自己的工作区 + pi 的历史会话项目：只覆盖「在 pi 里也用过」的目录；
+ *   - **opencode 自己的 `session.directory`**：这是全量答案（只在 opencode 里用过的目录差别很大）。
+ * 所以这里读一次 SQLite —— **只读、只取目录一列、失败就算了**（返回空数组）。
+ *
+ * 为什么可以读：`export` 是会话正文的稳定出口（正文结构会变，所以走 CLI），
+ * 而「有哪些目录有过会话」只是个索引，读不到就退化到前两个来源，不会让侧栏整体失败。
+ * 依赖也现成：Node ≥22.19 自带 `node:sqlite`（实验性，但不需要装包）。
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** opencode 的库文件：跟随 XDG（它自己也是这么找数据的） */
+export function opencodeDbFile(env = process.env, home = homedir()) {
+    const xdg = env.XDG_DATA_HOME?.trim();
+    const dataHome = xdg && xdg !== "" ? xdg : join(home, ".local", "share");
+    return join(dataHome, "opencode", "opencode.db");
+}
+/**
+ * 读「有过会话的目录」（`SELECT DISTINCT directory FROM session`）。
+ *
+ * 失败一律返回空数组：库文件不存在、被锁（opencode 正在写 WAL）、表结构变了、`node:sqlite` 用不了……
+ * 这些都只该让「目录发现」退化成「只知道工作区 + pi 项目」，不该冒泡。
+ */
+export async function readOpencodeSessionDirs(options = {}) {
+    const dbFile = options.dbFile ?? opencodeDbFile();
+    if (!existsSync(dbFile))
+        return [];
+    try {
+        const { DatabaseSync } = await import("node:sqlite");
+        const db = new DatabaseSync(dbFile, { readOnly: true });
+        try {
+            // 只读连接也可能撞上写锁（opencode 正在写 WAL）：等一下就走，别把侧栏刷新卡住
+            try {
+                db.exec("PRAGMA busy_timeout = 500");
+            }
+            catch {
+                // PRAGMA 不被允许也不影响这次只读查询
+            }
+            const rows = db
+                .prepare("SELECT DISTINCT directory FROM session WHERE directory IS NOT NULL AND directory <> ''")
+                .all();
+            return rows
+                .map((row) => (typeof row.directory === "string" ? row.directory.trim() : ""))
+                .filter((directory) => directory !== "");
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        options.log?.(`读取 opencode 会话目录清单失败（退回工作区 + pi 项目）：${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}

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

@@ -0,0 +1,195 @@
+/**
+ * opencode 的「项目 / 会话清单」提供者 + 历史数据的读取口（export / delete）。
+ *
+ * 数据来源两条，各管一件事：
+ *   1. **清单**：走 ACP 的 `session/list`（同一个子进程，零额外开销），返回
+ *      `{sessionId, cwd, title, updatedAt}` —— 没有 startedAt / model（这两个只能给 null）。
+ *
+ *      **`session/list` 是「目录作用域」的（opencode 1.19.0 实测）**：
+ *        - 不带参数：只返回 acp 子进程 cwd 那个目录的会话；
+ *        - 带 `{cwd}`：只返回 `directory` **精确等于**它的会话（不是整棵项目树，也不按 git 根合并）。
+ *      曾经以为不带参就是全局的，于是侧栏只看得到「宿主从哪个目录启动」那一个目录，其余全丢。
+ *      现在的做法是**逐个目录点名**：宿主给出「有过会话的目录集合」
+ *      （见 wiring.ts 的 opencodeWorkspaces / opencode-projects.ts），这里并发点名 + 按 sessionId 去重。
+ *   2. **转录与统计**：走 CLI `opencode export <sid>`（stdout 是纯 JSON，日志走 stderr）。
+ *      为什么不自己读 SQLite：会话正文的结构会变，`export` 是它自己给的稳定出口
+ *      （「有哪些目录有过会话」这种索引才敢只读一次，见 opencode-projects.ts）。
+ *
+ * 分组规则与 codex / dsh 保持一致：按 cwd 分组、组名取目录名、临时目录里的会话不进侧栏。
+ */
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+import { isScratchCwd } from "./scratch.js";
+/** 单个项目的 `session/list` 超时：侧栏刷新不该被一个卡住的项目拖死 */
+const PROJECT_LIST_TIMEOUT_MS = 10_000;
+const timestampOf = (value) => {
+    if (!value)
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+};
+/**
+ * 纯分组：`session/list` 的行 → 侧栏形状（单测直接覆盖）。
+ *
+ * - 临时目录（/tmp、/var/folders…）里的一次性会话丢掉，别塞噪音进侧栏；
+ * - 同 cwd 归一组，组内按更新时间倒序；组之间按「最近一条会话」倒序；
+ * - 没有标题的会话不编名字（opencode 自己会给「New session - …」，照它的原文显示）。
+ */
+export function groupOpencodeSessions(rows) {
+    // 逐个项目点名时同一条会话会被问到多次（项目根与它的子目录都解析到同一个项目），先去重：
+    // 同一个 sessionId 只留 updatedAt 最新的一条。
+    const byId = new Map();
+    for (const row of rows) {
+        const id = row.sessionId;
+        if (!id)
+            continue;
+        const previous = byId.get(id);
+        if (!previous || timestampOf(row.updatedAt) >= timestampOf(previous.updatedAt))
+            byId.set(id, row);
+    }
+    const groups = new Map();
+    for (const row of byId.values()) {
+        const id = row.sessionId;
+        if (!id)
+            continue;
+        const cwd = row.cwd ?? "";
+        if (isScratchCwd(cwd))
+            continue;
+        const updatedAt = timestampOf(row.updatedAt);
+        const group = groups.get(cwd) ?? {
+            cwd,
+            name: basename(cwd) || cwd || "未分项目",
+            sessions: [],
+        };
+        group.sessions.push({
+            id,
+            engineSessionId: id,
+            title: (row.title ?? "").trim() || "(未命名会话)",
+            // ACP 不给创建时间：用更新时间兜底（侧栏只按 updatedAt 排序，不会显示错）
+            startedAt: updatedAt,
+            updatedAt,
+            cwd,
+            model: null,
+        });
+        groups.set(cwd, group);
+    }
+    return [...groups.values()]
+        .map((group) => ({
+        cwd: group.cwd,
+        name: group.name,
+        sessions: [...group.sessions].sort((left, right) => right.updatedAt - left.updatedAt),
+    }))
+        .sort((left, right) => (right.sessions[0]?.updatedAt ?? 0) - (left.sessions[0]?.updatedAt ?? 0));
+}
+export function createOpencodeSessionsProvider(options) {
+    const cacheMs = options.cacheMs ?? 0;
+    const now = options.now ?? Date.now;
+    let cached = null;
+    /**
+     * 候选目录：去掉空串与重复。
+     *
+     * 故意**不**过滤「目录已经不存在」的：历史会话还在，点不开是用户自己删了目录的事；
+     * pi / codex / dsh 的侧栏也是这个口径（按会话里记的 cwd 分组）。实测点名不存在的目录
+     * 也不会在 opencode 的库里留下任何记录（就是空结果）。
+     */
+    const targets = async () => {
+        let raw = [];
+        try {
+            raw = (await options.workspaces?.()) ?? [];
+        }
+        catch (error) {
+            options.log?.(`枚举 opencode 候选项目目录失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+        const dirs = [...new Set(raw.map((dir) => dir.trim()).filter((dir) => dir !== ""))];
+        return dirs.length > 0 ? dirs : [undefined];
+    };
+    /** 并发点名所有项目。单个项目失败不影响其它项目（侧栏能显示多少是多少） */
+    const fetchAll = async () => {
+        const list = await targets();
+        const settled = await Promise.allSettled(list.map((cwd) => options.client.request("session/list", cwd ? { cwd } : {}, {
+            timeoutMs: PROJECT_LIST_TIMEOUT_MS,
+        })));
+        const rows = [];
+        for (const [index, item] of settled.entries()) {
+            if (item.status === "fulfilled") {
+                rows.push(...(item.value?.sessions ?? []));
+                continue;
+            }
+            const cwd = list[index] ?? "(默认)";
+            const reason = item.reason instanceof Error ? item.reason.message : String(item.reason);
+            options.log?.(`读取 opencode 会话清单失败（${cwd}）：${reason}`);
+        }
+        return groupOpencodeSessions(rows);
+    };
+    return async () => {
+        if (cacheMs > 0 && cached && now() - cached.at < cacheMs)
+            return cached.value;
+        let value;
+        try {
+            value = await fetchAll();
+        }
+        catch (error) {
+            // 清单读不到不该让侧栏整体失败：给出上一次的结果（可能为空），并留一条日志
+            options.log?.(`读取 opencode 会话清单失败：${error instanceof Error ? error.message : String(error)}`);
+            return cached?.value ?? [];
+        }
+        cached = { at: now(), value };
+        return value;
+    };
+}
+// ---------------------------------------------------------------------------
+// CLI 出口：export / delete
+// ---------------------------------------------------------------------------
+/**
+ * 跑一次 `opencode <args>`，收 stdout（`export` 的日志走 stderr，不混进来）。
+ * 失败返回 null / 抛错由调用方决定 —— 历史读不到不该让对话区崩掉。
+ */
+function runOpencode(bin, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, { cwd: options.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(`opencode ${args[0]} 超时`));
+        }, options.timeoutMs ?? 30_000);
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr = `${stderr}${chunk}`.slice(-2000);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(new Error(`opencode ${args[0]} 启动失败：${error.message}`));
+        });
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+                return;
+            }
+            reject(new Error(`opencode ${args[0]} 退出（code ${code ?? "?"}）${stderr.trim() ? `：${stderr.trim()}` : ""}`));
+        });
+    });
+}
+/** 读一条会话的完整导出（JSON）。读不到返回 null（界面上就是「暂无历史」） */
+export async function readOpencodeExport(bin, sessionId, options = {}) {
+    try {
+        const stdout = await runOpencode(bin, ["export", sessionId], { timeoutMs: options.timeoutMs });
+        const start = stdout.indexOf("{");
+        if (start < 0)
+            return null;
+        return JSON.parse(stdout.slice(start));
+    }
+    catch (error) {
+        options.log?.(`读取 opencode 会话导出失败（${sessionId}）：${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/** 删一条会话（opencode 原生删除：`opencode session delete <sid>`） */
+export async function deleteOpencodeSession(bin, sessionId) {
+    await runOpencode(bin, ["session", "delete", sessionId], { timeoutMs: 20_000 });
+}

package/dist/server/engine/opencode-transport.js

@@ -0,0 +1,48 @@
+/**
+ * opencode ACP 客户端 = 通用 JSON-RPC stdio + ACP 握手。
+ *
+ * 为什么走 ACP（`opencode acp`）而不是 SDK / `opencode run --format json`：
+ *   - `opencode run` 是「一次性回合」：没有权限问询、没有 `session/cancel`（打断只能杀进程）、
+ *     也没法在一次进程里换模型 —— 只能当兜底，不能当引擎；
+ *   - HTTP（`opencode serve`）+ `@opencode-ai/sdk` 能力最全，但要多管一个带鉴权的子进程 +
+ *     自己解析 SSE，且审批要在 HTTP 上回包；
+ *   - ACP 原生给了我们端口需要的全部动作：`session/new|list|resume|load|close`、
+ *     `session/set_config_option`（模型 / 思考档 / 模式）、`session/cancel`、
+ *     `session/request_permission`，外加带分桶的 usage。与 dsh 走的是同一套协议，
+ *     所以复用 `jsonrpc-stdio.ts`（换的只有可执行文件与握手参数）。
+ *
+ * 实测（opencode 1.19.0）：
+ *   initialize → `{protocolVersion:1, agentCapabilities:{loadSession:true, sessionCapabilities:{list,resume,fork,close},
+ *                 promptCapabilities:{image:true, embeddedContext:true}}, agentInfo:{name:"OpenCode", version:"1.19.0"}}`
+ */
+import { createJsonRpcStdioClient } from "./jsonrpc-stdio.js";
+/**
+ * 握手时声明的客户端能力。
+ *
+ * 全部 `false`：工具都在 opencode 自己的进程里跑，我们不当它的 fs / terminal 桥
+ * （与 dsh 一致）。opencode 的 `promptCapabilities.image` 是**它**收图，不需要我们这边声明。
+ */
+const CLIENT_CAPABILITIES = {
+    fs: { readTextFile: false, writeTextFile: false },
+    terminal: false,
+};
+export function createOpencodeClient(options = {}) {
+    return createJsonRpcStdioClient({
+        bin: options.bin ?? "opencode",
+        args: ["acp", ...(options.args ?? [])],
+        env: options.env,
+        cwd: options.cwd,
+        name: "opencode",
+        log: options.log ?? (() => { }),
+        timeoutMs: options.timeoutMs,
+        // ACP 是标准 JSON-RPC 2.0：帧里必须带 jsonrpc 字段
+        jsonrpc: true,
+        async handshake(call) {
+            const result = (await call("initialize", {
+                protocolVersion: 1,
+                clientCapabilities: CLIENT_CAPABILITIES,
+            }));
+            return { version: result?.agentInfo?.version ?? null };
+        },
+    });
+}