pi-web-ui 0.28.2 → 0.29.0

package/dist/server/bg-servers.js

@@ -0,0 +1,138 @@
+import { killPidTree, lookupProcessName, snapshotListeningPorts } from "./process-utils.js";
+const BG_REFRESH_INTERVAL_MS = 30_000;
+/** bash 结束后等这么久再拍「后」快照——给后台服务绑定端口的时间。 */
+const BG_BIND_WAIT_MS = 1500;
+export class BgServerTracker {
+    opts;
+    servers = new Map();
+    /** bash 工具开始执行前拍的监听端口快照（tool_execution_start 时设置）。 */
+    listenBefore = null;
+    refreshTimer = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** 启动周期性存活检查（死项静默剔除）。 */
+    start() {
+        this.refreshTimer = setInterval(() => void this.refresh(), BG_REFRESH_INTERVAL_MS);
+        this.refreshTimer.unref?.();
+    }
+    stop() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    /** tool_execution_start(bash)：先记下「前」快照。 */
+    snapshotBefore() {
+        void snapshotListeningPorts().then((m) => {
+            this.listenBefore = m;
+        });
+    }
+    /** After a bash tool run, wait briefly for background servers to bind,
+     *  then diff the listening-port snapshot against the pre-run one and
+     *  remember anything new — those are servers the agent left running. */
+    async trackAfterBash() {
+        const before = this.listenBefore;
+        this.listenBefore = null;
+        if (!before)
+            return;
+        await new Promise((r) => setTimeout(r, BG_BIND_WAIT_MS));
+        const after = await snapshotListeningPorts();
+        let added = false;
+        for (const [port, pid] of after) {
+            if (!before.has(port) && !this.servers.has(port)) {
+                this.servers.set(port, { pid, since: Date.now() });
+                added = true;
+                // Best-effort process name so the panel shows something readable.
+                void lookupProcessName(pid).then((name) => {
+                    const cur = this.servers.get(port);
+                    if (cur && cur.pid === pid && name) {
+                        cur.name = name;
+                        this.push();
+                    }
+                });
+                this.opts.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `检测到 AI 启动的后台服务：端口 ${port}（pid ${pid}）——可在顶栏「后台任务」里单独停止或全部关闭`,
+                });
+            }
+        }
+        if (added)
+            this.push();
+    }
+    /** The current background-server list, oldest first. */
+    list() {
+        return [...this.servers.entries()]
+            .map(([port, v]) => ({
+            port,
+            pid: v.pid,
+            since: v.since,
+            ...(v.name ? { name: v.name } : {}),
+        }))
+            .sort((a, b) => a.since - b.since);
+    }
+    /** Push the current background-task list to every connected socket. */
+    push() {
+        this.opts.emit({ type: "bg_servers", servers: this.list() });
+    }
+    /** Re-snapshot listening ports and drop tracked entries that are no longer
+     *  listening — the process exited on its own, so it must leave the panel.
+     *  Port AND pid must both match: a port reused by an unrelated process is
+     *  not our server anymore. Silent (the list just updates). */
+    async refresh() {
+        if (this.opts.isDisposed() || this.servers.size === 0)
+            return;
+        const now = await snapshotListeningPorts();
+        let changed = false;
+        for (const [port, v] of [...this.servers]) {
+            if (now.get(port) !== v.pid) {
+                this.servers.delete(port);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.push();
+    }
+    /** Re-push the current list on request (panel opened); prunes dead entries first. */
+    async listAndPush() {
+        await this.refresh();
+        this.push();
+    }
+    /** Kill ONE background server (by port); returns whether anything was killed. */
+    async killOne(port) {
+        const entry = this.servers.get(port);
+        if (!entry) {
+            this.opts.emit({
+                type: "notice",
+                level: "info",
+                text: `端口 ${port} 不在后台任务列表中`,
+            });
+            this.opts.flushSnapshot();
+            return false;
+        }
+        killPidTree(entry.pid);
+        this.servers.delete(port);
+        this.push();
+        this.opts.emit({
+            type: "notice",
+            level: "info",
+            text: `已停止后台任务：端口 ${port}（pid ${entry.pid}）`,
+        });
+        this.opts.flushSnapshot();
+        return true;
+    }
+    /** Kill every background server the agent started; returns the freed ports. */
+    async killAll() {
+        if (this.servers.size === 0)
+            return [];
+        const killed = [];
+        for (const [port, { pid }] of [...this.servers]) {
+            killPidTree(pid);
+            killed.push(String(port));
+        }
+        this.servers.clear();
+        this.push();
+        return killed;
+    }
+}

package/dist/server/client-state.js

@@ -0,0 +1,148 @@
+/**
+ * client-state — 每浏览器客户端的持久化 UI 状态（<dataDir>/client-state.json）：
+ * 最近项目/工作目录、目标审查偏好、设置面板状态（提示词模式 + 技能/插件开关 +
+ * 视觉桥偏好）、命名预设。文件 I/O 一律 best-effort：持久化故障绝不能
+ * 弄崩 server 或阻塞会话。
+ *
+ * 从 agent-service.ts 抽出，行为保持不变。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** Stable identity of an extension for the enable/disable toggle: the npm
+ *  spec for packages (survives version bumps), the resolved entry path
+ *  otherwise. */
+export function extensionKey(e) {
+    const src = e.sourceInfo;
+    if (src?.origin === "package" && src.source)
+        return src.source;
+    return src?.path ?? e.path;
+}
+/**
+ * Persists which workspace each browser client last used + which workspaces it
+ * has opened, so a server restart / page reload restores the same project and
+ * the UI can offer a one-click recent-project list. File I/O is best-effort:
+ * persistence problems must never crash the server or block a session.
+ */
+export class ClientStateStore {
+    filePath;
+    cache = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        try {
+            const parsed = JSON.parse(readFileSync(this.filePath, "utf8"));
+            this.cache = parsed && typeof parsed === "object" ? parsed : {};
+        }
+        catch {
+            this.cache = {};
+        }
+        return this.cache;
+    }
+    save() {
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            // Atomic write (tmp + rename): a crash mid-write must never leave a
+            // half-written JSON — that would wipe ALL persisted state (recent
+            // projects / presets / settings / goal prefs) on next load.
+            const tmp = `${this.filePath}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify(this.cache, null, 2) + "\n");
+            renameSync(tmp, this.filePath);
+        }
+        catch {
+            // best effort
+        }
+    }
+    get(clientId) {
+        return this.load()[clientId] ?? { projects: [] };
+    }
+    /** Remember which workspace a client last used; bumps its project entry. */
+    remember(clientId, cwd) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.lastCwd = cwd;
+        const now = Date.now();
+        state.projects = [
+            { path: cwd, lastUsed: now },
+            ...state.projects.filter((p) => p.path !== cwd),
+        ].slice(0, 30);
+        this.save();
+    }
+    /** Last-used goal/review prefs for a client, or undefined if never set. */
+    getGoalPrefs(clientId) {
+        const s = this.load()[clientId];
+        if (!s?.goalPrefs)
+            return undefined;
+        return {
+            reviewModel: s.goalPrefs.reviewModel ?? null,
+            maxRounds: s.goalPrefs.maxRounds ?? 0,
+            locked: s.goalPrefs.locked ?? true,
+        };
+    }
+    /** Persist the client's goal/review preferences (model choice, rounds, lock). */
+    saveGoalPrefs(clientId, prefs) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.goalPrefs = {
+            reviewModel: prefs?.reviewModel ?? null,
+            maxRounds: prefs?.maxRounds ?? 0,
+            locked: prefs?.locked ?? true,
+        };
+        this.save();
+    }
+    /** Last-used settings-panel state for a client, or defaults. */
+    getSettings(clientId) {
+        const s = this.load()[clientId];
+        return {
+            promptMode: s?.settings?.promptMode === "replace" ? "replace" : "append",
+            customSystemPrompt: s?.settings?.customSystemPrompt ?? "",
+            disabledSkills: s?.settings?.disabledSkills ?? [],
+            disabledExtensions: s?.settings?.disabledExtensions ?? [],
+            visionBridgeEnabled: s?.settings?.visionBridgeEnabled ?? true,
+            visionBridgeModel: s?.settings?.visionBridgeModel ?? null,
+            visionBridgePromptMode: s?.settings?.visionBridgePromptMode === "replace" ? "replace" : "append",
+            visionBridgePrompt: s?.settings?.visionBridgePrompt ?? "",
+            reviewPrompt: s?.settings?.reviewPrompt ?? "",
+            reviewDisabledSkills: s?.settings?.reviewDisabledSkills ?? [],
+        };
+    }
+    /** Persist the client's settings-panel state (partial merge). */
+    saveSettings(clientId, settings) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        const cur = state.settings ?? {};
+        state.settings = {
+            promptMode: settings.promptMode ?? cur.promptMode ?? "append",
+            customSystemPrompt: settings.customSystemPrompt ?? cur.customSystemPrompt ?? "",
+            disabledSkills: settings.disabledSkills ?? cur.disabledSkills ?? [],
+            disabledExtensions: settings.disabledExtensions ?? cur.disabledExtensions ?? [],
+            visionBridgeEnabled: settings.visionBridgeEnabled ?? cur.visionBridgeEnabled ?? true,
+            visionBridgeModel: settings.visionBridgeModel ?? cur.visionBridgeModel ?? null,
+            visionBridgePromptMode: settings.visionBridgePromptMode ??
+                cur.visionBridgePromptMode ??
+                "append",
+            visionBridgePrompt: settings.visionBridgePrompt ?? cur.visionBridgePrompt ?? "",
+            reviewPrompt: settings.reviewPrompt ?? cur.reviewPrompt ?? "",
+            reviewDisabledSkills: settings.reviewDisabledSkills ?? cur.reviewDisabledSkills ?? [],
+        };
+        this.save();
+    }
+    /** Named settings presets for a client (empty if never saved). */
+    getPresets(clientId) {
+        return (this.load()[clientId]?.presets ?? []).map((p) => ({
+            ...p,
+            // Older client-state files predate review settings.
+            reviewPrompt: p.reviewPrompt ?? "",
+            reviewDisabledSkills: p.reviewDisabledSkills ?? [],
+        }));
+    }
+    /** Persist the client's named settings presets. */
+    savePresets(clientId, presets) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.presets = presets;
+        this.save();
+    }
+}