oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/session/pi-opener.js

@@ -0,0 +1,123 @@
+export function createPiSessionOpener(options) {
+    const pathById = new Map();
+    /** 引擎自己的会话 id（codex 的 threadId）：跟文件路径并行存，谁有用谁用 */
+    const engineIdById = new Map();
+    const infoById = new Map();
+    const opened = new Set();
+    /** workspace → 该项目最近一个会话用的模型（remember 时按 updatedAt 更新） */
+    const modelByWorkspace = new Map();
+    /**
+     * 告诉界面「这个会话现在用哪个模型」。
+     * 优先用**这个会话最后一条助手消息**上的模型：那是真的用过的；
+     * `currentModel` 只是进程默认模型（历史会话几乎都对不上，会显示成别的模型）。
+     */
+    const announceModel = async (conversationId, messages) => {
+        // ① 会话文件里的最后一次 model_change：用户在选择器上切过也写在这里，最准
+        const saved = (await options.engine.sessionModel?.(conversationId)) ?? null;
+        if (saved) {
+            options.onModel(saved.provider ? `${saved.provider}/${saved.model}` : saved.model);
+            return;
+        }
+        // ② 退一步用最后一条助手消息上的模型（它至少是真的用过）
+        const used = [...messages].reverse().find((message) => message.role === "assistant" && message.model)?.model;
+        if (used) {
+            options.onModel(used);
+            return;
+        }
+        // 新会话还没有回复：这时进程默认模型就是它接下来要用的
+        const current = (await options.engine.currentModel?.(conversationId)) ?? null;
+        if (current) {
+            options.onModel(current.provider ? `${current.provider}/${current.model}` : current.model);
+            return;
+        }
+        // ③ 最后用侧栏清单里记着的模型（dsh 的历史会话在 resume 之前拿不到 config，
+        //    但 projcache 里已经有这条会话最后用的模型）
+        const known = infoById.get(conversationId)?.model;
+        if (known)
+            options.onModel(known);
+    };
+    return {
+        register(input) {
+            if (input.sessionPath)
+                pathById.set(input.id, input.sessionPath);
+            if (input.engineSessionId)
+                engineIdById.set(input.id, input.engineSessionId);
+            infoById.set(input.id, { title: input.title, workspace: input.workspace, model: input.model ?? null });
+            opened.add(input.id); // createSession 已经把它建好了
+        },
+        remember(projects) {
+            for (const project of projects) {
+                for (const session of project.sessions) {
+                    const workspace = session.cwd || project.cwd;
+                    if (session.sessionPath)
+                        pathById.set(session.id, session.sessionPath);
+                    if (session.engineSessionId)
+                        engineIdById.set(session.id, session.engineSessionId);
+                    infoById.set(session.id, { title: session.title, workspace, model: session.model ?? null });
+                    if (!session.model)
+                        continue;
+                    // 只记「这个项目里最新那个会话」的模型：它就是项目的当前口味
+                    const known = modelByWorkspace.get(workspace);
+                    if (known && known.updatedAt >= session.updatedAt)
+                        continue;
+                    modelByWorkspace.set(workspace, { updatedAt: session.updatedAt, model: session.model });
+                }
+            }
+        },
+        projectModel: (workspace) => modelByWorkspace.get(workspace)?.model ?? null,
+        forget: (conversationId) => {
+            pathById.delete(conversationId);
+            engineIdById.delete(conversationId);
+            infoById.delete(conversationId);
+            opened.delete(conversationId);
+            // 项目级的「最近用过的模型」不按会话删：它只是新会话的起点，删一条不代表项目口味变了
+        },
+        clear: () => {
+            pathById.clear();
+            engineIdById.clear();
+            infoById.clear();
+            opened.clear();
+            modelByWorkspace.clear();
+        },
+        isOpen: (conversationId) => opened.has(conversationId),
+        infoOf: (conversationId) => infoById.get(conversationId) ?? null,
+        /** 会话文件路径（统计要读它；web 新建的会话也在这里登记过） */
+        pathOf: (conversationId) => pathById.get(conversationId) ?? null,
+        handleOf: (conversationId) => engineIdById.get(conversationId) ?? pathById.get(conversationId) ?? null,
+        async open(conversationId, refresh) {
+            if (opened.has(conversationId)) {
+                // 已经打开过也不能跳过「当前模型」：state.model 是全局一份，
+                // 切回来时不重读就会停留在别的会话的模型上（选择器显示错乱）。
+                const messages = await options.engine.readUiMessages(conversationId);
+                await announceModel(conversationId, messages);
+                return messages;
+            }
+            const handle = () => engineIdById.get(conversationId) ?? pathById.get(conversationId) ?? "";
+            let found = handle();
+            if (found === "") {
+                await refresh(true); // 可能是刚建的会话，刷新一次再找
+                found = handle();
+            }
+            if (found === "")
+                return null;
+            try {
+                const engineSessionId = engineIdById.get(conversationId);
+                const sessionPath = pathById.get(conversationId);
+                await options.engine.openSession({
+                    sessionId: conversationId,
+                    ...(engineSessionId ? { engineSessionId } : {}),
+                    ...(sessionPath ? { sessionPath } : {}),
+                    ...(infoById.get(conversationId)?.workspace ? { cwd: infoById.get(conversationId)?.workspace } : {}),
+                });
+            }
+            catch (error) {
+                options.onError(`打开会话失败：${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+            opened.add(conversationId);
+            const messages = await options.engine.readUiMessages(conversationId);
+            await announceModel(conversationId, messages);
+            return messages;
+        },
+    };
+}

package/dist/server/session/pi-refresh.js

@@ -0,0 +1,51 @@
+import { setPiProjects } from "../snapshot/state.js";
+export function createPiRefresher(options) {
+    const minIntervalMs = options.minIntervalMs ?? 10_000;
+    let lastScannedAt = Number.NEGATIVE_INFINITY;
+    let inFlight = null;
+    return {
+        async refresh(force = false) {
+            const stamp = options.now();
+            if (!force && stamp - lastScannedAt < minIntervalMs)
+                return;
+            if (inFlight)
+                return inFlight; // 并发刷新合并成一次
+            lastScannedAt = stamp;
+            inFlight = (async () => {
+                try {
+                    options.onLoaded(await options.list());
+                }
+                catch (error) {
+                    // 扫不到（pi 没装 / 目录被删）不该影响主流程
+                    options.onError(`读取历史会话失败：${error instanceof Error ? error.message : String(error)}`);
+                }
+                finally {
+                    inFlight = null;
+                }
+            })();
+            return inFlight;
+        },
+        lastScannedAt: () => lastScannedAt,
+    };
+}
+/**
+ * 会话清单刷新器（ADR-0021 §1）+ 可替换的「清单来源」。
+ *
+ * 切引擎时来源要跟着换（pi 扫磁盘 / 未来 codex 问 app-server），但**刷新节奏与缓存逻辑
+ * 完全相同**，所以来源放进一个可变槽，refresher 本身只建一次。
+ */
+export function createSessionsRefresher(options) {
+    const slot = { current: options.initial };
+    const refresher = createPiRefresher({
+        list: () => slot.current?.() ?? Promise.resolve([]),
+        minIntervalMs: options.minIntervalMs,
+        now: options.now,
+        onLoaded: (projects) => {
+            setPiProjects(options.state, projects);
+            options.remember(projects); // 记下每个会话的文件路径（ADR-0021 §2）
+            options.onChanged();
+        },
+        onError: options.onError,
+    });
+    return { slot, refresh: (force) => refresher.refresh(force) };
+}

package/dist/server/session/pi-sessions-provider.js

@@ -0,0 +1,46 @@
+/**
+ * pi 会话列表的「扫描 + 缓存」提供者（ADR-0021 §1）——从 index.ts 抽出（400 行护栏）。
+ *
+ * 首扫要读 247 个文件（实测 ~1s），之后靠 path+mtime 缓存（~7ms）；
+ * 缓存落在 `<dataDir>/pi-sessions-cache.json`，坏了就重扫（ADR-0005 的同款纪律）。
+ */
+import { PI_AGENT_DIR_ENV, readCacheFile, scanPiSessions, writeCacheFile, } from "./pi-sessions.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** pi 的配置目录（与 SDK 的 getAgentDir 默认值一致；这里不 import SDK —— 边界守则见 ADR-0003） */
+export function piAgentDir() {
+    return process.env[PI_AGENT_DIR_ENV] ?? join(homedir(), ".pi", "agent");
+}
+export function createPiSessionsProvider(options) {
+    let cache = { v: 1, entries: {} };
+    const cacheFile = join(options.dataDir, "pi-sessions-cache.json");
+    let loaded = false;
+    return async () => {
+        if (!loaded) {
+            cache = await readCacheFile(cacheFile);
+            loaded = true;
+        }
+        const result = await scanPiSessions({ sessionsRoot: join(options.agentDir, "sessions"), cache });
+        cache = result.cache;
+        if (result.read > 0)
+            await writeCacheFile(cacheFile, cache).catch(() => { });
+        options.logger.info("已读取 pi 已有会话", {
+            projects: result.groups.length,
+            sessions: result.total,
+            read: result.read,
+        });
+        return result.groups.map((group) => ({
+            cwd: group.cwd,
+            name: group.name,
+            sessions: group.sessions.map((session) => ({
+                id: session.id,
+                title: session.title,
+                startedAt: session.startedAt,
+                sessionPath: session.path,
+                updatedAt: session.updatedAt,
+                cwd: session.cwd,
+                model: session.model,
+            })),
+        }));
+    };
+}

package/dist/server/session/pi-sessions.js

@@ -0,0 +1,272 @@
+/**
+ * 读取 pi 已有的会话（ADR-0021 §1）：只读 + 缓存。
+ *
+ * pi 的存储布局（实测 2026-10-16，本机 17 个项目 / 247 个会话）：
+ *   ~/.pi/agent/sessions/<编码后的 cwd>/<ISO 时间>_<uuid>.jsonl
+ *   首行：{"type":"session","version":3,"id":…,"timestamp":…,"cwd":"/abs/path"}
+ *
+ * 关键取舍：**只读首行 header + 前若干行找标题**，不解析整个文件。
+ * 247 个文件全量解析会明显变慢，而列表只需要「项目 / 标题 / 时间」。
+ */
+import { readFile, readdir, stat, writeFile, rename, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const PI_AGENT_DIR_ENV = "PI_AGENT_DIR";
+export function defaultPiSessionsRoot(agentDir) {
+    return join(agentDir, "sessions");
+}
+/** 纯函数：解析首行 header；不是会话文件就返回 null */
+export function parseSessionHeader(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return null;
+    const record = parsed;
+    if (record.type !== "session")
+        return null;
+    const timestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN;
+    return {
+        id: typeof record.id === "string" ? record.id : "",
+        cwd: typeof record.cwd === "string" ? record.cwd : "",
+        startedAt: Number.isFinite(timestamp) ? timestamp : 0,
+    };
+}
+/**
+ * 纯函数：从会话内容行里抠出标题与模型。
+ *
+ * 标题只看开头（`headLimit` 行）：首条消息就够了，全量扫会慢。
+ * 模型**从末尾倒着找**最后一条 `model_change`：追加式文件里那就是「现在用哪个」，
+ * 只扫开头会把「中途换过模型」的会话报成最初那个（切回去时选择器就显示错了）。
+ * 会话名（session_info）也一样倒着找 —— **改名是往文件末尾追加一条**，
+ * 只扫开头的话，超过 60 行的会话改完名界面上永远看不到变化（"改名改不了"那个 bug）。
+ */
+export function extractListMeta(lines, headLimit = lines.length) {
+    let title = "";
+    let model = null;
+    for (const [index, line] of lines.entries()) {
+        // 标题只扫开头；模型 / 会话名在下面单独倒着找
+        if (index >= headLimit)
+            break;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (record.type === "model_change" && typeof record.modelId === "string") {
+            // 追加式文件：后来的 model_change 覆盖先前的 —— 会话中途换过模型就要取最后一次，
+            // 否则切回这个会话时选择器显示的还是它最初那个模型
+            const provider = typeof record.provider === "string" ? record.provider : "";
+            model = provider ? `${provider}/${record.modelId}` : record.modelId;
+        }
+        if (title)
+            continue;
+        if (record.type !== "message")
+            continue;
+        const message = record.message;
+        if (!message || message.role !== "user")
+            continue;
+        title = textOfMessageContent(message.content);
+    }
+    /** pi 自己的会话名（session_info.name）：有它就以它为准，首条消息只当兜底 */
+    const name = lastSessionName(lines);
+    // 模型：倒着找最后一条 model_change（只解析含关键字的行，避免整文件 JSON.parse）
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index] ?? "";
+        if (!line.includes("model_change"))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (record.type !== "model_change" || typeof record.modelId !== "string" || record.modelId === "")
+            continue;
+        const provider = typeof record.provider === "string" ? record.provider : "";
+        model = provider ? `${provider}/${record.modelId}` : record.modelId;
+        break;
+    }
+    // 列表只显示一行：折叠换行/连续空白（首条消息常是多行任务描述）
+    const display = (name || title).replace(/\s+/g, " ").trim();
+    return { title: display.slice(0, 60), model };
+}
+/**
+ * 最后一条 `session_info.name`（改名 = 往文件末尾再追加一条，所以要从后往前找）。
+ * 只对含关键字的行 JSON.parse —— 会话文件动辄几千行，全量解析太贵。
+ */
+function lastSessionName(lines) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index] ?? "";
+        if (!line.includes("session_info"))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (record.type !== "session_info")
+            continue;
+        if (typeof record.name !== "string" || record.name.trim() === "")
+            continue;
+        return record.name;
+    }
+    return "";
+}
+function textOfMessageContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        const record = typeof part === "object" && part !== null ? part : {};
+        return typeof record.text === "string" ? record.text : "";
+    })
+        .join(" ");
+}
+/** 纯函数：规范化 cwd —— 必须是绝对路径，否则视为「未知」（老会话里出现过 cwd=一句提示词） */
+export function normalizeCwd(cwd) {
+    const trimmed = cwd.trim();
+    if (trimmed.startsWith("/") || /^[A-Za-z]:[\\/]/.test(trimmed))
+        return trimmed;
+    return "";
+}
+/** 组名：cwd 的最后一段（`/a/b/inke.activity.service` → `inke.activity.service`） */
+export function projectNameOf(cwd) {
+    if (cwd === "")
+        return "（未知项目）";
+    const parts = cwd.split("/").filter(Boolean);
+    return parts[parts.length - 1] ?? cwd;
+}
+/**
+ * 纯函数：把扁平会话列表按 cwd 分组。
+ *
+ * 组内按 **startedAt（创建时间）倒序**：新会话在最上面，而**更新一个旧会话不会让它跳位置** ——
+ * 按 updatedAt 排的话，你在一个老会话里说一句话它就窜到最上面，整个列表跟着挪，很烦人。
+ * 组间仍按最新活动倒序（侧栏会用 projectPrefs 再排一次，这里只保证可预期的初始顺序）。
+ */
+export function groupByProject(sessions) {
+    const groups = new Map();
+    for (const session of sessions) {
+        const key = session.cwd;
+        const existing = groups.get(key);
+        if (existing) {
+            existing.sessions.push(session);
+            existing.updatedAt = Math.max(existing.updatedAt, session.updatedAt);
+        }
+        else {
+            groups.set(key, {
+                cwd: key,
+                name: projectNameOf(key),
+                sessions: [session],
+                updatedAt: session.updatedAt,
+            });
+        }
+    }
+    const list = [...groups.values()];
+    for (const group of list)
+        group.sessions.sort((a, b) => b.startedAt - a.startedAt);
+    return list.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export const CACHE_VERSION = 1;
+export function parseCache(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object" && parsed.v === CACHE_VERSION && parsed.entries)
+            return parsed;
+    }
+    catch {
+        // 坏缓存 = 没有缓存（ADR-0005 的同款纪律：缓存坏了不该致命）
+    }
+    return { v: CACHE_VERSION, entries: {} };
+}
+export async function scanPiSessions(options) {
+    const maxLines = options.maxLinesPerFile ?? 60;
+    const cache = { v: CACHE_VERSION, entries: {} };
+    const rows = [];
+    let read = 0;
+    let projectDirs = [];
+    try {
+        const entries = await readdir(options.sessionsRoot, { withFileTypes: true });
+        projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => join(options.sessionsRoot, entry.name));
+    }
+    catch {
+        // 目录不存在（没装 pi 或没跑过）= 空列表，不是错误
+        return { groups: [], cache, read: 0, total: 0 };
+    }
+    for (const dir of projectDirs) {
+        let files = [];
+        try {
+            files = (await readdir(dir)).filter((name) => name.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const name of files) {
+            const path = join(dir, name);
+            let mtimeMs = 0;
+            try {
+                mtimeMs = (await stat(path)).mtimeMs;
+            }
+            catch {
+                continue; // 文件刚被删（用户在 CLI 里清理过）→ 跳过而不是崩
+            }
+            const cached = options.cache?.entries[path];
+            if (cached && cached.mtimeMs === mtimeMs) {
+                cache.entries[path] = cached;
+                rows.push(cached.row);
+                continue;
+            }
+            read += 1;
+            let text = "";
+            try {
+                text = await readFile(path, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split("\n");
+            const header = parseSessionHeader(lines[0] ?? "");
+            if (!header)
+                continue; // 不是会话文件
+            const meta = extractListMeta(lines.filter((line, index) => index > 0), maxLines - 1);
+            const row = {
+                id: header.id || name,
+                path,
+                // 脏数据防御：老会话里出现过 cwd=一句提示词 → 非绝对路径一律当未知项目，避免侧栏出现「组名是一句话」
+                cwd: normalizeCwd(header.cwd),
+                startedAt: header.startedAt,
+                updatedAt: mtimeMs,
+                title: meta.title || new Date(mtimeMs || header.startedAt).toLocaleString(),
+                model: meta.model,
+            };
+            rows.push(row);
+            cache.entries[path] = { mtimeMs, row };
+        }
+    }
+    const limited = options.limit ? rows.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, options.limit) : rows;
+    return { groups: groupByProject(limited), cache, read, total: rows.length };
+}
+export async function readCacheFile(file) {
+    try {
+        return parseCache(await readFile(file, "utf8"));
+    }
+    catch {
+        return { v: CACHE_VERSION, entries: {} };
+    }
+}
+export async function writeCacheFile(file, cache) {
+    await mkdir(dirname(file), { recursive: true });
+    const temporary = `${file}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(cache)}\n`, "utf8");
+    await rename(temporary, file); // 原子替换（同 ADR-0005 的索引写法）
+}

package/dist/server/session/refresh-actions.js

@@ -0,0 +1,42 @@
+import { buildRefreshActionsPrompt } from "../markers/actions.js";
+export function createRefreshActions(deps) {
+    const { state } = deps;
+    const resolveTimeout = () => {
+        const value = typeof deps.timeoutMs === "function" ? deps.timeoutMs() : deps.timeoutMs;
+        return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 20_000;
+    };
+    return async (requested, count) => {
+        const conv = requested ?? state.activeId;
+        if (!conv)
+            return { ok: false, error: { code: "session.none", message: "先打开一个会话再要建议" } };
+        if (deps.turns.has(conv)) {
+            // 可能是真的在跑一轮，也可能是上一次「下一步」还没回来
+            return { ok: false, error: { code: "session.busy", message: "上一轮还在跑，等它结束再点「下一步」" } };
+        }
+        const labels = state.actions.map((action) => action.label);
+        const prompt = buildRefreshActionsPrompt(labels, count);
+        state.actions = [];
+        deps.pushSnapshot();
+        const timeoutMs = resolveTimeout();
+        let timedOut = false;
+        const timer = timeoutMs > 0
+            ? setTimeout(() => {
+                if (!deps.turns.has(conv))
+                    return;
+                timedOut = true;
+                void deps.engine.interrupt(conv).catch(() => undefined);
+            }, timeoutMs)
+            : null;
+        try {
+            const result = await deps.sendTurn(prompt, conv);
+            if (timedOut)
+                deps.notice(`「下一步」${Math.round(timeoutMs / 1000)} 秒没想出来，已取消（可以再点一次）`, "warn");
+            return result;
+        }
+        finally {
+            if (timer !== null)
+                clearTimeout(timer);
+            deps.pushSnapshot();
+        }
+    };
+}

package/dist/server/session/rename-session.js

@@ -0,0 +1,23 @@
+export function renameSessionWith(deps) {
+    return async (conversationId, title) => {
+        const handle = deps.handleOf(conversationId);
+        if (!handle) {
+            return { ok: false, error: { code: "session.not_found", message: `找不到这条会话：${conversationId}` } };
+        }
+        if (!deps.engine.renameSession) {
+            return { ok: false, error: { code: "session.rename_unsupported", message: "当前引擎不支持改会话名" } };
+        }
+        try {
+            await deps.engine.renameSession(handle, title);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.notice(`重命名失败：${message}`, "error");
+            return { ok: false, error: { code: "session.rename_failed", message } };
+        }
+        deps.onRenamed?.(conversationId, title);
+        await deps.refresh();
+        deps.pushSnapshot();
+        return { ok: true };
+    };
+}

package/dist/server/session/runtime-services.js

@@ -0,0 +1,28 @@
+import { createApprovalBridge } from "./approval-bridge.js";
+import { createNoticeSink } from "./notices.js";
+import { createRuntimeTurnWatchdog } from "./turn-watchdog.js";
+export function createRuntimeServices(options) {
+    const sink = createNoticeSink({
+        now: options.now,
+        nextId: options.nextId,
+        dedupeMs: options.options.noticeDedupeMs,
+        max: options.options.maxNotices,
+        onNotice: options.onNotice,
+    });
+    const notice = (text, level = "info", key) => void sink.push(text, level, key);
+    const approval = createApprovalBridge({
+        rules: options.options.rules,
+        now: options.now,
+        nextId: options.nextId,
+        onPending: options.onPending,
+        onNotice: (text, level) => notice(text, level),
+    });
+    options.options.engine.setApprovalHandler(approval.handler);
+    const watchdog = createRuntimeTurnWatchdog({
+        timeoutMs: options.options.turnTimeoutMs,
+        engine: options.options.engine,
+        isWaitingForUser: options.isWaitingForUser,
+        notice: (text, level) => notice(text, level),
+    });
+    return { notice, approval, watchdog };
+}

package/dist/server/session/runtime-types.js

@@ -0,0 +1 @@
+export {};