oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/session/client-view.js

@@ -0,0 +1,82 @@
+/**
+ * 每个客户端「自己正在看哪个会话」（ADR-0033）。
+ *
+ * 纪律：**每个浏览器只认自己那一份**。客户端有记录就看它自己的；
+ * 没记录就是「空」（界面回到欢迎页），**绝不回落到 `state.activeId`** ——
+ * 那份全局值只是服务端给 stats / models / 文件树用的「最近操作过的会话」，
+ * 一旦拿它当别人的默认视图，多标签 / 多设备就会互相拽着跳（真实症状：
+ * 电脑上切会话，手机上也跟着换）。
+ *
+ * 这里只存「谁在看哪」和「谁收过哪一版会话清单」，**不复制任何会话内容**：内容的事实源仍是
+ * `state.messages`，快照在发送时按客户端的这个值覆盖 `active` 字段即可
+ * （`buildSnapshot(state, limit, activeId)`）。
+ */
+/** 会话清单最多隔这么久重发一次（防丢帧：中间被合并 / 丢掉的帧自己长回来） */
+export const PROJECTS_RESEND_MS = 30_000;
+/** 视图表上限：断线不再删视图，就得防止无限增长（正常人也就几个标签页 / 设备） */
+export const MAX_CLIENT_VIEWS = 200;
+export function createClientView() {
+    /** clientId → 它自己在看的会话（null = 明确「什么都不看」，比如刚打开的新标签页） */
+    const active = new Map();
+    /** 能接受「省略会话清单」的客户端 */
+    const slim = new Set();
+    /** 这个客户端上次收到会话清单是哪个版本、什么时候 */
+    const projectsSent = new Map();
+    /** 记一条视图：重插到末尾当「最近使用」，超上限就把最久没动的丢掉 */
+    const remember = (clientId, conversationId) => {
+        active.delete(clientId);
+        active.set(clientId, conversationId);
+        if (active.size > MAX_CLIENT_VIEWS) {
+            const oldest = active.keys().next().value;
+            if (oldest !== undefined)
+                active.delete(oldest);
+        }
+    };
+    return {
+        activeFor: (clientId, fallback) => {
+            // 服务端内部（没有 clientId）：用全局那份
+            if (!clientId)
+                return fallback;
+            // 认识这个客户端：**只认它自己的**（null 也照原样返回 = 空视图）
+            if (active.has(clientId))
+                return active.get(clientId) ?? null;
+            // 第一次见：记成「空」。之后它自己点会话 / 发消息会把记录填上
+            remember(clientId, null);
+            return null;
+        },
+        setActive: (clientId, conversationId) => {
+            remember(clientId, conversationId);
+        },
+        forget: (conversationId) => {
+            for (const [clientId, id] of active)
+                if (id === conversationId)
+                    active.delete(clientId);
+        },
+        drop: (clientId) => {
+            // 视图（active）**故意保留**：重连后还要认自己看过哪个会话，见类型注释
+            slim.delete(clientId);
+            projectsSent.delete(clientId);
+        },
+        reset: () => {
+            active.clear();
+            projectsSent.clear();
+        },
+        size: () => [...active.values()].filter((id) => id !== "").length,
+        setSlim: (clientId, next) => {
+            if (next)
+                slim.add(clientId);
+            else
+                slim.delete(clientId);
+        },
+        needsProjects: (clientId, version, now) => {
+            // 不认识的客户端（全局快照 / WS）一律带：宁可多发，不能让人家列表变空
+            if (!clientId || !slim.has(clientId))
+                return true;
+            const previous = projectsSent.get(clientId);
+            const shouldSend = !previous || previous.version !== version || now - previous.at >= PROJECTS_RESEND_MS;
+            if (shouldSend)
+                projectsSent.set(clientId, { version, at: now });
+            return shouldSend;
+        },
+    };
+}

package/dist/server/session/conversation-create.js

@@ -0,0 +1,65 @@
+export function createConversationFactory(options) {
+    return {
+        async create(seedText, workspaceOverride) {
+            const { state } = options;
+            const id = options.newConversationId();
+            // 新会话沿用「当前会话/当前工作区」的目录（多项目：不把新会话丢回默认根）
+            const previousWorkspace = state.activeId
+                ? state.conversations.find((item) => item.id === state.activeId)?.workspace
+                : undefined;
+            // 优先级：显式指定（项目行上的「+」）> 当前会话的目录 > 当前工作区
+            const workspace = workspaceOverride ?? previousWorkspace ?? state.files?.root ?? state.workspace;
+            const title = seedText.replace(/\s+/g, " ").trim().slice(0, options.titleChars) || "新对话";
+            const { sessionPath, engineSessionId } = await options.engine.createSession({ sessionId: id, workspace });
+            // SDK 建会话时用的是**引擎默认模型**，必须显式切一下，否则就是「选的 A、跑的 B」。
+            // 优先级：本项目的默认模型（用户设过）> 本项目最近一个会话用的 > 界面上选着的
+            const wanted = options.defaultModelFor?.(workspace) ?? state.model;
+            if (wanted) {
+                const switched = (await options.engine.switchModel?.(id, wanted)) ?? false;
+                if (switched)
+                    state.model = wanted; // 选择器跟着真值走
+                else {
+                    // 切不过去（模型被删/没鉴权）：让选择器回到真实值，别继续骗人
+                    const current = (await options.engine.currentModel?.(id)) ?? null;
+                    state.model = current ? `${current.provider}/${current.model}` : null;
+                }
+            }
+            options.opener.register({ id, sessionPath, engineSessionId, title, workspace });
+            state.messages[id] = [];
+            state.conversations = [
+                { id, title, createdAt: options.now(), updatedAt: options.now(), workspace, messageCount: 0 },
+                ...state.conversations,
+            ];
+            state.activeId = id;
+            // 新会话从 0 开始：不先把统计清掉，第一帧快照还会带着上一个会话的上下文用量
+            state.sessionStats = null;
+            state.actions = []; // 建议不跟着新会话走
+            state.files = { root: workspace, treeVersion: (state.files?.treeVersion ?? 0) + 1 };
+            await options.onReady?.(id);
+            return id;
+        },
+    };
+}
+/**
+ * 「新建会话」这个请求的处理（含错误归一化）。
+ *
+ * 从 runtime 抽出来：新建会话要顺带把**发起者自己的视图**指过去（ADR-0033），
+ * 这几句放回 runtime 会破 400 行护栏。
+ */
+export function newConversationWith(deps) {
+    return async (workspace, clientId) => {
+        try {
+            const id = await deps.create("新对话", workspace);
+            // 每个客户端各记各的视图：不把发起者的指过来，它收到的快照仍是旧会话
+            if (clientId)
+                deps.clientView.setActive(clientId, id);
+            deps.pushSnapshot(); // ← 少了这一句，侧栏不会更新（冒烟抓到过）
+            return { ok: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.notice(`新建会话失败：${message}`, "error");
+            return { ok: false, error: { code: "session.create_failed", message } };
+        }
+    };
+}

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

@@ -0,0 +1,84 @@
+/**
+ * 删除会话（侧栏 ⋯ → 删除 / 归档视图的批量删除）。
+ *
+ * 两条路，按引擎能力选：
+ *   1. 引擎有原生删除（codex 的 `thread/delete`）→ 交给引擎，Codex Desktop 里也会消失；
+ *   2. 否则（pi）→ 沿用原来的做法：把会话文件改名成 `<名字>.deleted-<时间戳>`，
+ *      扫描不到（列表里消失），但文件还在磁盘上，误删可以手动改回来。
+ *
+ * 这里刻意**不真删文件**：删除是不可逆操作，工作台还没有废纸篓。
+ */
+import { rename } from "node:fs/promises";
+/** 引擎侧「本来就没有」的错误文案（codex：no rollout / thread not found）→ 统一当作未找到 */
+function isMissingError(message) {
+    return /no rollout|not found|不存在|已删除/i.test(message);
+}
+export function createSessionDeleter(deps) {
+    return async (conversationId) => {
+        const session = deps
+            .projects()
+            .flatMap((project) => project.sessions)
+            .find((item) => item.id === conversationId);
+        if (!session) {
+            // 侧栏没列出来（比如引擎自己隐藏的会话：codex 临时目录里的随手跑）：
+            // 只要宿主还知道它的句柄，仍然允许删 —— 否则界面上「删不掉也找不到」
+            const handle = deps.handleOf(conversationId);
+            if (!handle || !deps.engine.deleteSession) {
+                return { ok: false, error: { code: "session.not_found", message: "找不到这条会话（可能已被清理）" } };
+            }
+            try {
+                await deps.engine.deleteSession(handle);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    ok: false,
+                    error: isMissingError(message)
+                        ? { code: "session.not_found", message: "这条会话已经不在了" }
+                        : { code: "session.delete_failed", message },
+                };
+            }
+            deps.discard(conversationId);
+            await deps.refresh().catch(() => undefined);
+            deps.pushSnapshot();
+            return { ok: true, mode: "engine" };
+        }
+        const engineHandle = session.engineSessionId ?? null;
+        if (engineHandle && deps.engine.deleteSession) {
+            try {
+                await deps.engine.deleteSession(engineHandle);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    ok: false,
+                    error: isMissingError(message)
+                        ? { code: "session.not_found", message: "这条会话已经不在了" }
+                        : { code: "session.delete_failed", message },
+                };
+            }
+            deps.discard(conversationId);
+            await deps.refresh().catch(() => undefined);
+            deps.pushSnapshot();
+            return { ok: true, mode: "engine" };
+        }
+        const sessionPath = session.sessionPath ?? deps.handleOf(conversationId);
+        if (!sessionPath) {
+            return { ok: false, error: { code: "session.not_found", message: "这条会话没有可删除的落盘文件" } };
+        }
+        const target = `${sessionPath}.deleted-${Date.now()}`;
+        try {
+            await rename(sessionPath, target);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: { code: "session.delete_failed", message: error instanceof Error ? error.message : String(error) },
+            };
+        }
+        deps.discard(conversationId);
+        await deps.refresh().catch(() => undefined);
+        deps.pushSnapshot();
+        return { ok: true, mode: "file", movedTo: target };
+    };
+}

package/dist/server/session/engine-switch.js

@@ -0,0 +1,108 @@
+import { emptyRunning } from "../snapshot/state.js";
+/**
+ * 注册项 → 快照里的可选引擎（badge 缺省用大写名字）。
+ * `active` 用来兜底：当前引擎即使标了 hidden（比如测试用的 fake）也要出现在列表里。
+ */
+export function engineOptions(descriptors, active) {
+    return descriptors
+        .filter((descriptor) => descriptor.hidden !== true || descriptor.name === active)
+        .map((descriptor) => ({
+        name: descriptor.name,
+        label: descriptor.label,
+        badge: descriptor.badge ?? descriptor.name.toUpperCase(),
+        description: descriptor.description ?? "",
+        capabilities: { ...descriptor.capabilities },
+    }));
+}
+/**
+ * 快照里的引擎清单：有目录就用目录的全部注册项；没有目录（单测 / 最小启动）
+ * 就退化成「只有当前这一个」，切换请求会被拒 —— 界面不会出现一个点不动的列表。
+ */
+export function engineOptionsFor(name, capabilities, descriptors) {
+    if (descriptors)
+        return engineOptions(descriptors, name);
+    return [
+        {
+            name,
+            label: name,
+            badge: name.toUpperCase(),
+            description: "",
+            capabilities: { ...capabilities },
+        },
+    ];
+}
+export function createEngineSwitcher(deps) {
+    const { state } = deps;
+    /**
+     * 清掉「属于某个引擎」的状态。
+     * 刻意**保留**的东西：approvalMode（宿主策略，不是引擎的）、settings（客户端偏好）、
+     * workspace（目录）、terminal/files（那是磁盘与 PTY，跟引擎无关）。
+     */
+    const clearEngineScopedState = () => {
+        state.conversations = [];
+        state.messages = {};
+        state.activeId = null;
+        state.queued = [];
+        state.running = emptyRunning();
+        state.runningByConversation = {};
+        state.statsByConversation = {};
+        state.sessionStats = null;
+        state.models = [];
+        state.model = null;
+        state.thinkingLevel = null;
+        state.thinkingLevels = [];
+        state.pendingApproval = null;
+        state.actions = [];
+        state.notices = [];
+        state.piProjects = [];
+        state.piProjectsVersion += 1; // 清单变了 → 下一帧必须带上（不能沿用旧引擎的那份）
+        state.providers = [];
+        state.enabledModels = [];
+    };
+    return async (name) => {
+        if (deps.isBusy()) {
+            return { ok: false, error: { code: "engine.busy", message: "还有回合在跑，先等它结束或中断再切引擎" } };
+        }
+        const entry = deps.engines?.get(name) ?? null;
+        if (!entry) {
+            return { ok: false, error: { code: "engine.unknown", message: `没有这个引擎：${name}` } };
+        }
+        if (entry.descriptor.name === state.engine)
+            return { ok: true };
+        // 先收掉旧引擎的外部资源（codex：关 app-server → 释放它持有的全部写锁），
+        // 再换指针。收不掉也不影响切换本身。
+        const previousEngine = deps.slot.current();
+        if (previousEngine !== entry.engine) {
+            await Promise.resolve(previousEngine.dispose?.()).catch(() => undefined);
+        }
+        deps.slot.use(entry.engine);
+        state.engine = entry.descriptor.name;
+        state.engineCapabilities = { ...entry.descriptor.capabilities };
+        state.engines = engineOptionsFor(entry.descriptor.name, entry.descriptor.capabilities, deps.engines?.descriptors());
+        state.versions = { ...state.versions, engine: entry.engine.version?.() ?? null };
+        clearEngineScopedState();
+        deps.clientView.reset();
+        deps.clearSessions();
+        deps.sessionsSlot.current = deps.engines?.sessionsFor(entry.descriptor.name) ?? null;
+        entry.engine.setApprovalHandler(deps.approvalHandler);
+        // 先推一帧「已经切过去、还是空的」：前端立刻把侧栏与模型换掉，不用等扫描
+        deps.pushSnapshot();
+        try {
+            await deps.refreshModels();
+            // 懒启动的引擎（codex/dsh）在 refreshModels 里才真正连上 → 版本号这时才有
+            state.versions = { ...state.versions, engine: entry.engine.version?.() ?? null };
+            if (entry.descriptor.providerConfig !== false && deps.loadProviders) {
+                state.providers = await deps.loadProviders();
+            }
+        }
+        catch (error) {
+            deps.notice(`切换后加载模型失败：${error instanceof Error ? error.message : String(error)}`, "warn");
+        }
+        deps.pushSnapshot();
+        await deps.refreshSessions(true).catch((error) => {
+            deps.notice(`读取历史会话失败：${error instanceof Error ? error.message : String(error)}`, "warn");
+        });
+        deps.notice(`已切换到 ${entry.descriptor.label}`, "info");
+        return { ok: true };
+    };
+}

package/dist/server/session/lock.js

@@ -0,0 +1,82 @@
+/**
+ * 单实例锁：`<dataDir>/server.lock`（ADR-0007）。
+ *
+ * 为什么是数据完整性的一部分：ADR-0005 的「只有一个写入者」是整套持久化推理的前提。
+ * 两个进程同时追加同一批 jsonl = 转录损坏。所以「终端 A 忘关、又开终端 B」这件事
+ * 必须在启动时被拦住，而不是等数据坏了才发现。
+ *
+ * 三态（ADR-0007 守卫 1）：
+ *   - 无锁            → 建锁，启动；
+ *   - 有锁且 pid 存活 → 拒绝启动，并把对方是谁告诉用户；
+ *   - 有锁但 pid 已死 → **陈旧锁，自动接管**（否则崩一次之后服务就永远起不来了）。
+ */
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const LOCK_FILE = "server.lock";
+export function lockPath(dataDir) {
+    return join(dataDir, LOCK_FILE);
+}
+export function parseLock(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return null;
+    const candidate = parsed;
+    if (typeof candidate.pid !== "number" || typeof candidate.port !== "number")
+        return null;
+    return {
+        pid: candidate.pid,
+        port: candidate.port,
+        startedAt: typeof candidate.startedAt === "number" ? candidate.startedAt : 0,
+    };
+}
+/** 默认的存活判断：`process.kill(pid, 0)` 不抛就是活着（EPERM 也算活着，只是不归我们管） */
+export function defaultIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export async function readLock(dataDir) {
+    try {
+        return parseLock(await readFile(lockPath(dataDir), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeLock(dataDir, info) {
+    const target = lockPath(dataDir);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify(info)}\n`, "utf8");
+}
+export async function acquireLock(dataDir, info, deps = { isAlive: defaultIsAlive }) {
+    const existing = await readLock(dataDir);
+    if (existing && existing.pid !== info.pid && deps.isAlive(existing.pid)) {
+        return { ok: false, holder: existing };
+    }
+    const stale = existing !== null;
+    await writeLock(dataDir, info);
+    return { ok: true, stale, previous: existing };
+}
+/** 释放锁：只有锁还属于自己时才删（避免把接管者的锁删掉） */
+export async function releaseLock(dataDir, pid) {
+    const existing = await readLock(dataDir);
+    if (!existing || existing.pid !== pid)
+        return;
+    await rm(lockPath(dataDir), { force: true });
+}
+export function describeHolder(holder) {
+    const started = holder.startedAt > 0 ? new Date(holder.startedAt).toLocaleString() : "未知时间";
+    return `pid ${holder.pid} · 端口 ${holder.port} · 启动于 ${started}`;
+}

package/dist/server/session/model-controller.js

@@ -0,0 +1,111 @@
+export function createModelController(options) {
+    return {
+        async refresh(conversationId) {
+            // 取不到就**保留旧列表**，绝不清空。
+            // 原因：切会话 / 引擎刚启动的那一瞬间 listModels 会返回空或抛错，
+            // 一旦清空，输入区的模型选择器与侧栏「模型」面板里的内置 provider 会一起消失
+            // （用户看到的就是「刚才还有，怎么又不见了」）。
+            try {
+                const list = (await options.engine.listModels?.(conversationId ?? undefined)) ?? [];
+                if (list.length > 0 || options.state.models.length === 0) {
+                    options.state.models = list.map((model) => ({ id: model.id, label: model.label }));
+                }
+                // 还没有当前模型（刚建会话 / 刚切引擎）：用引擎标的默认项，别让选择器空着
+                if (!options.state.model && list.length > 0) {
+                    const preferred = list.find((model) => model.current) ?? list[0];
+                    if (preferred)
+                        options.state.model = preferred.id;
+                }
+            }
+            catch {
+                // 保留旧值：下次刷新成功自然会更新
+            }
+        },
+        async reload(conversationId) {
+            await options.engine.reloadModels?.().catch(() => undefined);
+            await this.refresh(conversationId);
+            await this.refreshThinking(conversationId ?? null);
+            options.onChanged();
+        },
+        async refreshThinking(conversationId) {
+            // 与模型列表同一套纪律：取不到就保留旧值，别让控件闪没
+            try {
+                const levels = (await options.engine.listThinkingLevels?.(conversationId ?? undefined)) ?? [];
+                const current = (await options.engine.getThinkingLevel?.(conversationId ?? undefined)) ?? null;
+                if (levels.length === 0 && options.state.thinkingLevels.length > 0)
+                    return;
+                options.state.thinkingLevels = levels;
+                options.state.thinkingLevel = current;
+            }
+            catch {
+                // 保留旧值
+            }
+        },
+        async setThinking(conversationId, level) {
+            if (!conversationId)
+                return { ok: false, error: { code: "session.none", message: "先打开一个会话" } };
+            const applied = (await options.engine.setThinkingLevel?.(conversationId, level)) ?? false;
+            if (!applied) {
+                const reason = options.engine.lastError?.();
+                return {
+                    ok: false,
+                    error: {
+                        code: "thinking.unsupported",
+                        message: reason ? `切换思考档位失败：${reason}` : `这个模型不支持档位：${level}`,
+                    },
+                };
+            }
+            options.state.thinkingLevel = level;
+            options.onChanged();
+            return { ok: true };
+        },
+        async switchTo(conversationId, modelId) {
+            if (!conversationId)
+                return { ok: false, error: { code: "session.none", message: "先打开一个会话" } };
+            const switched = (await options.engine.switchModel?.(conversationId, modelId)) ?? false;
+            if (!switched) {
+                const reason = options.engine.lastError?.();
+                return {
+                    ok: false,
+                    error: { code: "model.switch_failed", message: reason ? `切换模型失败：${reason}` : `切换模型失败：${modelId}` },
+                };
+            }
+            options.state.model = modelId;
+            // 不再推提示：输入区的模型选择器已经在显示当前模型（提示条太占地方）
+            options.onChanged();
+            return { ok: true };
+        },
+    };
+}
+/**
+ * 「重读模型表」的独立入口（切引擎与 provider 热重载共用）：
+ * prewarm（有的引擎要先把模型表挂到会话上）→ reloadModels → listModels。
+ * 取不到就**保留旧表**：模型下拉宁可短暂显示旧的，也不能整块消失。
+ */
+export function createModelRefresher(options) {
+    return async () => {
+        try {
+            await options.engine.prewarm?.();
+            await options.engine.reloadModels?.();
+        }
+        catch {
+            return; // 引擎没起起来（比如 codex 没装）：保留旧表，别把切换流程打断
+        }
+        let list = [];
+        try {
+            list = (await options.engine.listModels?.()) ?? [];
+        }
+        catch {
+            return;
+        }
+        if (list.length > 0) {
+            options.state.models = list.map((model) => ({ id: model.id, label: model.label }));
+            // 还没有当前模型（刚切引擎 / 还没开会话）：用引擎给的默认项，别让选择器空着
+            if (!options.state.model) {
+                const preferred = list.find((model) => model.current) ?? list[0];
+                if (preferred)
+                    options.state.model = preferred.id;
+            }
+        }
+    };
+}

package/dist/server/session/notices.js

@@ -0,0 +1,31 @@
+export function createNoticeSink(options) {
+    const dedupeMs = options.dedupeMs ?? 5000;
+    const max = options.max ?? 20;
+    const recent = new Map();
+    let notices = [];
+    return {
+        push(text, level, noticeKey) {
+            const key = `${level}:${text}`;
+            const ts = options.now();
+            const last = recent.get(key);
+            if (last !== undefined && ts - last < dedupeMs)
+                return null;
+            recent.set(key, ts);
+            // 同 key 原地替换：保留 id 与位置，只换文案/级别/时间戳
+            const existing = noticeKey ? notices.find((notice) => notice.key === noticeKey) : undefined;
+            const notice = {
+                id: existing?.id ?? options.nextId("notice"),
+                level,
+                text,
+                ts,
+                ...(noticeKey ? { key: noticeKey } : {}),
+            };
+            notices = existing
+                ? notices.map((item) => (item.id === existing.id ? notice : item))
+                : [...notices, notice].slice(-max);
+            options.onNotice(notice);
+            return notice;
+        },
+        all: () => notices,
+    };
+}