pi-web-ui 0.1.1

package/dist/server/agent-service.js

@@ -0,0 +1,1155 @@
+/**
+ * AgentService — wraps the pi SDK (@earendil-works/pi-coding-agent) for the web
+ * frontend. Each browser client (identified by a persistent clientId) gets its
+ * own AgentSessionRuntime with a private session directory, so multiple users /
+ * tabs never share a transcript file.
+ *
+ * Streaming model: the SDK emits AgentSessionEvents; we forward lightweight
+ * `tool_delta` messages for live tool output and schedule throttled full-state
+ * snapshots. The frontend is snapshot-driven (server is the source of truth),
+ * so reconnects just re-request a snapshot.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { serializeMessage } from "./serialize.js";
+import { loadCommands, saveCommandsFile, TerminalManager, } from "./terminals.js";
+const SNAPSHOT_INTERVAL_MS = 60;
+const WIDGET_REFRESH_MS = 2000;
+const WIDGET_WIDTH = 80;
+// ---------------------------------------------------------------------------
+// Web UI context adapter — bridges extension UI calls (setWidget/notify) to the
+// browser. Extensions like rpiv-todo render a TUI widget via
+// `ui.setWidget(key, (tui, theme) => comp)`; we capture the component, render it
+// with a mock theme to plain text lines, and push them to the client.
+// ---------------------------------------------------------------------------
+/** Mock theme: TUI color functions degrade to identity so widget text survives. */
+const mockTheme = new Proxy({
+    fg: (_color, text) => text,
+    bold: (text) => text,
+    strikethrough: (text) => text,
+    dim: (text) => text,
+}, {
+    get(target, prop) {
+        if (prop in target)
+            return target[prop];
+        // Unknown theme methods → no-op passthrough.
+        return (_arg, text) => text !== undefined ? text : "";
+    },
+});
+/** Mock TUI: any method call is a safe no-op. */
+const mockTui = new Proxy({
+    requestRender: () => { },
+    render: () => { },
+}, {
+    get(target, prop) {
+        if (prop in target)
+            return target[prop];
+        return () => { };
+    },
+});
+/**
+ * Implements the subset of ExtensionUIContext that makes sense for a web UI.
+ * TUI-only affordances (select/confirm/input dialogs, terminal input, custom
+ * footer) are inert: dialogs resolve to cancellation instead of blocking.
+ */
+export class WebUIContext {
+    theme = mockTheme;
+    widgets = new Map();
+    lastLines = new Map();
+    emit;
+    constructor(emit) {
+        this.emit = emit;
+    }
+    // -- widgets -------------------------------------------------------------
+    /** Matches ExtensionUIContext's overloaded setWidget exactly. */
+    setWidget = (key, content, options) => {
+        void options;
+        if (content === undefined) {
+            this.widgets.delete(key);
+            this.lastLines.delete(key);
+            this.push();
+            return;
+        }
+        if (typeof content === "function") {
+            let comp;
+            try {
+                // Mock TUI/theme: extensions only read a handful of theme helpers;
+                // everything else is a no-op, so the widget renders to plain text.
+                comp = content(mockTui, mockTheme);
+            }
+            catch {
+                comp = undefined;
+            }
+            this.widgets.set(key, {
+                render: (w) => comp?.render?.(w),
+                dispose: comp?.dispose,
+            });
+        }
+        else {
+            this.widgets.set(key, { render: () => content });
+        }
+        this.push();
+    };
+    /** Re-render all widgets and push when content changed (polled + on demand). */
+    refresh() {
+        let changed = false;
+        for (const [key, w] of this.widgets) {
+            let lines;
+            try {
+                lines = w.render(WIDGET_WIDTH);
+            }
+            catch {
+                lines = undefined;
+            }
+            const prev = this.lastLines.get(key);
+            if (JSON.stringify(lines ?? null) !== JSON.stringify(prev ?? null)) {
+                this.lastLines.set(key, lines ?? []);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.push();
+    }
+    push() {
+        const widgets = this.snapshot();
+        this.emit({ type: "widgets", widgets });
+    }
+    /** Render all widgets to their current text lines (without emitting). */
+    snapshot() {
+        return [...this.widgets.entries()].map(([key, w]) => {
+            let lines;
+            try {
+                lines = w.render(WIDGET_WIDTH);
+            }
+            catch {
+                lines = undefined;
+            }
+            this.lastLines.set(key, lines ?? []);
+            return { key, lines: lines ?? [] };
+        });
+    }
+    // -- notifications --------------------------------------------------------
+    notify(message, type) {
+        this.emit({ type: "notice", level: type ?? "info", text: message });
+    }
+    // -- footer status (pi-lens "LSP Inactive", pi-cache-optimizer cache stats) --
+    statuses = new Map();
+    setStatus(key, text) {
+        if (text === undefined || text === "") {
+            this.statuses.delete(key);
+        }
+        else {
+            this.statuses.set(key, text);
+        }
+        this.pushStatuses();
+    }
+    pushStatuses() {
+        this.emit({
+            type: "statuses",
+            statuses: [...this.statuses.entries()].map(([k, v]) => ({
+                key: k,
+                text: v,
+            })),
+        });
+    }
+    /** Current footer status entries (for replay on socket attach). */
+    statusSnapshot() {
+        return [...this.statuses.entries()].map(([k, v]) => ({ key: k, text: v }));
+    }
+    // -- dialogs (select/confirm/input bridged to the browser) ---------------
+    dialogSeq = 0;
+    pendingDialogs = new Map();
+    select = (title, options) => this.openDialog("select", title, [options]);
+    confirm = (title, message) => this.openDialog("confirm", title, [message]);
+    input = (title, placeholder) => this.openDialog("input", title, [placeholder ?? ""]);
+    openDialog(kind, title, args) {
+        return new Promise((resolve) => {
+            const id = ++this.dialogSeq;
+            this.pendingDialogs.set(id, resolve);
+            this.emit({ type: "dialog", id, kind, title, args });
+        });
+    }
+    /** Resolve a pending dialog with the user's choice (called from the client). */
+    resolveDialog(id, value) {
+        const resolve = this.pendingDialogs.get(id);
+        if (resolve) {
+            this.pendingDialogs.delete(id);
+            resolve(value);
+            this.emit({ type: "dialog_closed", id });
+        }
+    }
+    // -- inert TUI-only affordances ------------------------------------------
+    onTerminalInput = () => () => { };
+    setWorkingMessage = () => { };
+    setWorkingVisible = () => { };
+    setWorkingIndicator = () => { };
+    setHiddenThinkingLabel = () => { };
+    setFooter = () => { };
+    setHeader = () => { };
+    setTitle = () => { };
+    custom = (_factory, _done) => new Promise(() => { });
+    pasteToEditor = () => { };
+    setEditorText = () => { };
+    getEditorText = () => "";
+    editor = async () => undefined;
+    addAutocompleteProvider = () => { };
+    setEditorComponent = () => { };
+    getEditorComponent = () => undefined;
+    getAllThemes = () => [];
+    getTheme = () => undefined;
+    setTheme = () => ({ success: false });
+    getToolsExpanded = () => false;
+    setToolsExpanded = () => { };
+    /** Dispose all widgets (extension reload / session teardown). */
+    dispose() {
+        for (const w of this.widgets.values()) {
+            try {
+                w.dispose?.();
+            }
+            catch {
+                // best effort
+            }
+        }
+        this.widgets.clear();
+        this.lastLines.clear();
+        // Cancel any pending dialogs.
+        for (const [id, resolve] of this.pendingDialogs) {
+            resolve(null);
+            this.emit({ type: "dialog_closed", id });
+        }
+        this.pendingDialogs.clear();
+    }
+}
+/** Sanitize a clientId (UUID) for use as a directory name. */
+function sanitizeId(id) {
+    return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80) || "anon";
+}
+const IGNORED_ENTRIES = new Set([
+    "node_modules",
+    ".git",
+    ".svn",
+    ".hg",
+    "dist",
+    ".next",
+    ".nuxt",
+    ".cache",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "coverage",
+    ".pi-web",
+    ".DS_Store",
+    "Thumbs.db",
+]);
+function countLines(buf) {
+    let lines = 0;
+    for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 10 /* \n */)
+            lines++;
+    }
+    return lines + (buf.length > 0 ? 1 : 0);
+}
+function extractPartialText(partial) {
+    const content = partial
+        ?.content;
+    if (Array.isArray(content)) {
+        const text = content
+            .map((c) => c?.type === "text"
+            ? c.text
+            : "")
+            .join("");
+        return text.length > 0 ? text : null;
+    }
+    return null;
+}
+export class ClientSession {
+    clientId;
+    cwd;
+    /** Immutable workspace root the commands file (.pi/commands.json) is anchored to. */
+    workspaceRoot;
+    /** Absolute per-client session directory. */
+    sessionDir;
+    /** pi config dir (auth/models/skills). */
+    agentDir;
+    runtime;
+    session;
+    /** PTY terminals for this client (killed when the last socket detaches). */
+    terminals = new TerminalManager((msg) => this.emit(msg));
+    /** Web-facing extension UI context (widgets, notifications). */
+    webUi = new WebUIContext((msg) => this.emit(msg));
+    widgetsTimer = null;
+    /** Connected sockets for this client (multiple tabs share the session). */
+    sinks = new Set();
+    pendingNotices = [];
+    unsubscribe;
+    snapshotTimer = null;
+    sessionsTimer = null;
+    version = 0;
+    seq = 0;
+    queueSteering = 0;
+    queueFollowUp = 0;
+    disposed = false;
+    constructor(clientId, cwd, sessionDir, agentDir, runtime) {
+        this.clientId = clientId;
+        this.cwd = cwd;
+        this.workspaceRoot = cwd;
+        this.sessionDir = sessionDir;
+        this.agentDir = agentDir;
+        this.runtime = runtime;
+        this.session = runtime.session;
+    }
+    static async create(clientId, cwd, sessionDir) {
+        const agentDir = process.env.PI_CODING_AGENT_DIR ?? getAgentDir();
+        const runtime = await createAgentSessionRuntime(ClientSession.runtimeFactory, {
+            cwd,
+            agentDir,
+            // Resume the most recent session for this client's private session dir,
+            // or start a fresh one on first visit.
+            sessionManager: SessionManager.continueRecent(cwd, sessionDir),
+        });
+        const cs = new ClientSession(clientId, cwd, sessionDir, agentDir, runtime);
+        for (const d of runtime.diagnostics) {
+            if (d.type !== "info") {
+                cs.pendingNotices.push({
+                    type: "notice",
+                    level: d.type,
+                    text: d.message,
+                });
+            }
+        }
+        await cs.bindSession();
+        return cs;
+    }
+    /** Builds a full cwd-bound runtime for the given working directory. */
+    static runtimeFactory = async ({ cwd: effectiveCwd, sessionManager, }) => {
+        const services = await createAgentSessionServices({ cwd: effectiveCwd });
+        return {
+            ...(await createAgentSessionFromServices({ services, sessionManager })),
+            services,
+            diagnostics: services.diagnostics,
+        };
+    };
+    /** Add a socket to this client's broadcast set; flushes buffered startup notices. */
+    attachSink(send) {
+        this.sinks.add(send);
+        for (const msg of this.pendingNotices)
+            send(msg);
+        this.pendingNotices = [];
+        // Replay current extension widgets (setWidget may have fired during
+        // session creation, before any socket was attached).
+        const widgets = this.webUi.snapshot();
+        if (widgets.length > 0)
+            send({ type: "widgets", widgets });
+        const statuses = this.webUi.statusSnapshot();
+        if (statuses.length > 0)
+            send({ type: "statuses", statuses });
+    }
+    detachSink(send) {
+        this.sinks.delete(send);
+        // No sockets left for this client — kill its terminals so processes don't
+        // survive a closed tab / dropped connection.
+        if (this.sinks.size === 0)
+            this.terminals.killAll();
+    }
+    /** Broadcast to every connected socket of this client. */
+    emit(msg) {
+        if (this.disposed)
+            return;
+        for (const sink of [...this.sinks])
+            sink(msg);
+    }
+    /** (Re)attach event plumbing to the active session — also used after new_chat. */
+    async bindSession() {
+        this.unsubscribe?.();
+        this.session = this.runtime.session;
+        await this.session.bindExtensions({
+            mode: "rpc",
+            uiContext: this.webUi,
+            onError: (err) => {
+                this.emit({ type: "notice", level: "error", text: err.error });
+            },
+        });
+        this.unsubscribe = this.session.subscribe((event) => this.onEvent(event));
+        this.scheduleSnapshot();
+        this.webUi.refresh();
+        this.startWidgetsTimer();
+    }
+    /** Poll extension widgets so TUI-only overlays (e.g. rpiv-todo) stay live. */
+    startWidgetsTimer() {
+        if (this.widgetsTimer)
+            return;
+        this.widgetsTimer = setInterval(() => {
+            if (!this.disposed)
+                this.webUi.refresh();
+        }, WIDGET_REFRESH_MS);
+    }
+    onEvent(event) {
+        switch (event.type) {
+            case "bash_execution_update": {
+                if (event.id) {
+                    this.emit({
+                        type: "tool_delta",
+                        toolCallId: event.id,
+                        toolName: "bash",
+                        delta: event.delta,
+                    });
+                }
+                break;
+            }
+            case "tool_execution_update": {
+                const text = extractPartialText(event.partialResult);
+                if (text) {
+                    this.emit({
+                        type: "tool_delta",
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        delta: text,
+                    });
+                }
+                break;
+            }
+            case "queue_update":
+                this.queueSteering = event.steering.length;
+                this.queueFollowUp = event.followUp.length;
+                break;
+            // A run finished or a new entry was persisted — keep the session list fresh
+            // (new chat + first message, completed turns, compaction, etc.).
+            case "agent_end":
+            case "entry_appended":
+                this.scheduleSessionsRefresh();
+                break;
+            default:
+                break;
+        }
+        this.scheduleSnapshot();
+    }
+    /** Debounced push of the persisted session list to the client. */
+    scheduleSessionsRefresh() {
+        if (this.sessionsTimer)
+            return;
+        this.sessionsTimer = setTimeout(() => {
+            this.sessionsTimer = null;
+            if (!this.disposed)
+                void this.pushSessions();
+        }, 800);
+    }
+    snapshot() {
+        const state = this.session.agent.state;
+        const model = state.model;
+        let stats = {
+            totalMessages: 0,
+            tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            cost: 0,
+            contextUsage: { tokens: null, contextWindow: 0, percent: null },
+        };
+        try {
+            const s = this.session.getSessionStats();
+            stats = {
+                totalMessages: s.totalMessages,
+                tokens: s.tokens,
+                cost: s.cost,
+                contextUsage: s.contextUsage
+                    ? {
+                        tokens: s.contextUsage.tokens,
+                        contextWindow: s.contextUsage.contextWindow,
+                        percent: s.contextUsage.percent,
+                    }
+                    : stats.contextUsage,
+            };
+        }
+        catch {
+            // stats are best-effort
+        }
+        return {
+            clientId: this.clientId,
+            cwd: this.cwd,
+            sessionId: this.session.sessionId,
+            sessionFile: this.session.sessionFile,
+            messages: state.messages
+                .map((m) => serializeMessage(m, ++this.seq))
+                .filter((m) => m !== null),
+            isStreaming: this.session.isStreaming,
+            model: model
+                ? { id: model.id, name: model.name, provider: model.provider }
+                : null,
+            thinkingLevel: state.thinkingLevel,
+            queue: { steering: this.queueSteering, followUp: this.queueFollowUp },
+            errorMessage: state.errorMessage,
+            tools: state.tools.map((t) => t.name),
+            version: ++this.version,
+            stats,
+        };
+    }
+    /** Resolve a browser-bridged dialog (select/confirm/input) for this session. */
+    resolveDialog(id, value) {
+        this.webUi.resolveDialog(id, value);
+    }
+    /** Send a snapshot immediately (cancels any pending throttled one). */
+    flushSnapshot() {
+        if (this.snapshotTimer) {
+            clearTimeout(this.snapshotTimer);
+            this.snapshotTimer = null;
+        }
+        if (!this.disposed)
+            this.emit({ type: "snapshot", state: this.snapshot() });
+    }
+    scheduleSnapshot() {
+        if (this.snapshotTimer || this.disposed)
+            return;
+        this.snapshotTimer = setTimeout(() => {
+            this.snapshotTimer = null;
+            if (!this.disposed)
+                this.emit({ type: "snapshot", state: this.snapshot() });
+        }, SNAPSHOT_INTERVAL_MS);
+    }
+    // ---------------------------------------------------------------------------
+    // Commands
+    // ---------------------------------------------------------------------------
+    async prompt(text, attachments) {
+        try {
+            const s = this.session;
+            // Attach files as independent nextTurn context messages (asides) so the
+            // user message stays clean; they render as separate attachment cards.
+            const asides = await this.buildAttachmentMessages(attachments);
+            for (const aside of asides) {
+                await s.sendCustomMessage(aside.message, { deliverAs: "nextTurn" });
+            }
+            if (s.isStreaming) {
+                // Queue for delivery after the current run finishes.
+                await s.prompt(text, { streamingBehavior: "followUp" });
+            }
+            else {
+                await s.prompt(text);
+            }
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `提示发送失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /**
+     * Turn attached files into custom-message payloads.
+     *
+     * Text files are size-aware: small files are inlined into the message so the
+     * model sees them immediately; large files are passed as a <file path="...">
+     * reference and the model reads them on demand with its read tool (which has
+     * built-in truncation). Images are always passed as image content.
+     */
+    async buildAttachmentMessages(attachments) {
+        if (!attachments || attachments.length === 0)
+            return [];
+        const fs = await import("node:fs/promises");
+        const { resolve, sep, relative, extname } = await import("node:path");
+        const root = resolve(this.cwd);
+        const MAX_ATTACHMENT_BYTES = 200 * 1024;
+        // Files at or below this size are inlined; larger files are referenced by
+        // path only (the model reads them on demand — saves tokens for small edits).
+        const MAX_INLINE_BYTES = Number(process.env.PI_WEB_INLINE_FILE_MAX ?? 12 * 1024);
+        const IMAGE_EXT = new Set([
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".webp",
+            ".bmp",
+            ".svg",
+        ]);
+        const MIME = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".bmp": "image/bmp",
+            ".svg": "image/svg+xml",
+        };
+        const out = [];
+        for (const att of attachments) {
+            const abs = resolve(root, att.path);
+            const rel = relative(root, abs);
+            if (rel.startsWith("..") || rel.includes(`${sep}..`)) {
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `附件路径超出工作区：${att.path}`,
+                });
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fs.stat(abs);
+            }
+            catch {
+                this.emit({
+                    type: "notice",
+                    level: "error",
+                    text: `附件不存在：${att.path}`,
+                });
+                continue;
+            }
+            const name = att.path.split("/").pop() ?? att.path;
+            // Folders can't be inlined — always a path reference the model browses
+            // on demand with its own tools (ls/read).
+            if (stat.isDirectory()) {
+                out.push({
+                    message: {
+                        customType: "file",
+                        content: [{ type: "text", text: `<folder path="${rel}" />` }],
+                        display: true,
+                        details: {
+                            name,
+                            path: rel,
+                            mode: "reference",
+                            type: "folder",
+                        },
+                    },
+                });
+                continue;
+            }
+            if (!stat.isFile()) {
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `跳过非文件附件：${att.path}`,
+                });
+                continue;
+            }
+            const ext = extname(att.path).toLowerCase();
+            if (IMAGE_EXT.has(ext)) {
+                // Images can't be referenced — they must be inlined, so keep a hard cap.
+                if (stat.size > MAX_ATTACHMENT_BYTES) {
+                    this.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `图片附件过大已跳过（>200KB）：${att.path}`,
+                    });
+                    continue;
+                }
+                const data = await fs.readFile(abs, "base64");
+                out.push({
+                    message: {
+                        customType: "file",
+                        content: [
+                            { type: "image", data, mimeType: MIME[ext] ?? "image/png" },
+                        ],
+                        display: true,
+                        details: { name, path: rel, mode: "image", size: stat.size },
+                    },
+                });
+                continue;
+            }
+            const makeReference = () => ({
+                message: {
+                    customType: "file",
+                    content: [
+                        {
+                            type: "text",
+                            text: `<file path="${rel}" size="${stat.size}" />`,
+                        },
+                    ],
+                    display: true,
+                    details: { name, path: rel, mode: "reference", size: stat.size },
+                },
+            });
+            const makeInline = (buf) => {
+                const lines = countLines(buf);
+                return {
+                    message: {
+                        customType: "file",
+                        content: [
+                            {
+                                type: "text",
+                                text: `\n<file path="${rel}">\n\`\`\`\n${buf.toString("utf8")}\n\`\`\`\n</file>`,
+                            },
+                        ],
+                        display: true,
+                        details: {
+                            name,
+                            path: rel,
+                            mode: "inline",
+                            size: stat.size,
+                            lines,
+                        },
+                    },
+                };
+            };
+            // Reference mode is always honored and never reads the file.
+            if (att.mode === "reference") {
+                out.push(makeReference());
+                continue;
+            }
+            // Forced inline has a hard cap to protect the model context.
+            if (att.mode === "inline") {
+                if (stat.size > MAX_INLINE_BYTES) {
+                    this.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `文件过大，已改为仅引用：${att.path}`,
+                    });
+                    out.push(makeReference());
+                    continue;
+                }
+                const buf = await fs.readFile(abs);
+                if (buf.includes(0)) {
+                    this.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `二进制文件已改为仅引用：${att.path}`,
+                    });
+                    out.push(makeReference());
+                    continue;
+                }
+                out.push(makeInline(buf));
+                continue;
+            }
+            // Auto: small files inline, large files reference by path.
+            if (stat.size > MAX_INLINE_BYTES) {
+                out.push(makeReference());
+                continue;
+            }
+            const buf = await fs.readFile(abs);
+            if (buf.includes(0)) {
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `二进制文件已跳过（仅引用路径）：${att.path}`,
+                });
+                out.push(makeReference());
+                continue;
+            }
+            out.push(makeInline(buf));
+        }
+        return out;
+    }
+    async abort() {
+        try {
+            await this.session.abort();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `中止失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    async newChat() {
+        try {
+            await this.runtime.newSession();
+            await this.bindSession();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `新建对话失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** List persisted sessions for this client, newest first. */
+    /** Push the persisted session list to the client (client-requested). */
+    async refreshSessions() {
+        await this.pushSessions();
+    }
+    async pushSessions() {
+        try {
+            const { resolve } = await import("node:path");
+            // The pi CLI/TUI keeps sessions in <agentDir>/sessions/--<cwd-sanitized>--
+            // (encoded per working directory). List those too, so the conversation
+            // panel shows every conversation of the current folder — not just the
+            // ones created in this web UI.
+            const safePath = `--${resolve(this.cwd)
+                .replace(/^[/\\]/, "")
+                .replace(/[/\\:]/g, "-")}--`;
+            const tuiSessionDir = join(this.agentDir, "sessions", safePath);
+            const [webInfos, tuiInfos] = await Promise.all([
+                SessionManager.list(this.cwd, this.sessionDir),
+                existsSync(tuiSessionDir)
+                    ? SessionManager.list(this.cwd, tuiSessionDir).catch(() => [])
+                    : Promise.resolve([]),
+            ]);
+            const sessions = new Map();
+            for (const s of webInfos) {
+                sessions.set(s.path, {
+                    path: s.path,
+                    name: s.name,
+                    firstMessage: s.firstMessage,
+                    messageCount: s.messageCount,
+                    modified: s.modified.getTime(),
+                    source: "web",
+                });
+            }
+            for (const s of tuiInfos) {
+                sessions.set(s.path, {
+                    path: s.path,
+                    name: s.name,
+                    firstMessage: s.firstMessage,
+                    messageCount: s.messageCount,
+                    modified: s.modified.getTime(),
+                    source: "tui",
+                });
+            }
+            const sorted = [...sessions.values()].sort((a, b) => b.modified - a.modified);
+            this.emit({ type: "sessions", sessions: sorted });
+        }
+        catch {
+            this.emit({ type: "sessions", sessions: [] });
+        }
+    }
+    /** Switch the active session to a persisted one (from listSessions). */
+    async switchSession(path) {
+        try {
+            await this.runtime.switchSession(path);
+            await this.bindSession();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换会话失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** List a workspace directory (relative to the configured cwd). */
+    async listFiles(relPath) {
+        try {
+            const fs = await import("node:fs/promises");
+            const { resolve, sep, relative } = await import("node:path");
+            const root = resolve(this.cwd);
+            const target = relPath ? resolve(root, relPath) : root;
+            const rel = relative(root, target);
+            if (rel.startsWith("..") || rel.includes(`${sep}..`)) {
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `路径超出工作区：${relPath ?? ""}`,
+                });
+                return;
+            }
+            const dirents = await fs.readdir(target, { withFileTypes: true });
+            const entries = dirents
+                .filter((d) => !IGNORED_ENTRIES.has(d.name))
+                .map((d) => ({
+                name: d.name,
+                path: rel === "" ? d.name : `${rel}/${d.name}`,
+                type: (d.isDirectory() ? "dir" : "file"),
+            }))
+                .sort((a, b) => a.type === b.type
+                ? a.name.localeCompare(b.name)
+                : a.type === "dir"
+                    ? -1
+                    : 1)
+                .slice(0, 500);
+            this.emit({
+                type: "files",
+                path: rel === "" ? "" : rel,
+                parent: rel === ""
+                    ? null
+                    : rel.includes("/")
+                        ? rel.slice(0, rel.lastIndexOf("/"))
+                        : "",
+                entries,
+            });
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `读取目录失败：${err.message}`,
+            });
+        }
+    }
+    async cycleModel() {
+        try {
+            await this.session.cycleModel();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换模型失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /**
+     * Path completion for the cwd input: expand ~/relative paths, list the parent
+     * directory, and return prefix matches (dirs first, capped).
+     */
+    async completePath(input) {
+        const empty = () => this.emit({ type: "path_completions", completions: [] });
+        try {
+            const fs = await import("node:fs/promises");
+            const { resolve, sep } = await import("node:path");
+            const { homedir } = await import("node:os");
+            const home = homedir();
+            // Expand ~ and relative inputs to an absolute path.
+            let expanded = input.trim();
+            if (expanded === "") {
+                empty();
+                return;
+            }
+            if (expanded === "~")
+                expanded = `${home}${sep}`;
+            else if (expanded.startsWith("~/"))
+                expanded = home + expanded.slice(1);
+            else if (!expanded.startsWith("/"))
+                expanded = resolve(this.cwd, expanded);
+            // Split into parent dir + prefix (handle trailing slash = browse a dir).
+            const lastSlash = expanded.lastIndexOf("/");
+            const dirPart = lastSlash >= 0 ? expanded.slice(0, lastSlash + 1) : "/";
+            const prefix = lastSlash >= 0 ? expanded.slice(lastSlash + 1) : expanded;
+            const dirents = await fs
+                .readdir(dirPart, { withFileTypes: true })
+                .catch(() => null);
+            if (!dirents) {
+                empty();
+                return;
+            }
+            const completions = dirents
+                .filter((d) => d.name.startsWith(prefix) && !IGNORED_ENTRIES.has(d.name))
+                .map((d) => ({
+                name: d.name,
+                path: dirPart + d.name,
+                type: (d.isDirectory() ? "dir" : "file"),
+            }))
+                .sort((a, b) => {
+                const aHidden = a.name.startsWith(".");
+                const bHidden = b.name.startsWith(".");
+                if (aHidden !== bHidden)
+                    return aHidden ? 1 : -1;
+                if (a.type !== b.type)
+                    return a.type === "dir" ? -1 : 1;
+                return a.name.localeCompare(b.name);
+            })
+                .slice(0, 30);
+            this.emit({ type: "path_completions", completions });
+        }
+        catch {
+            empty();
+        }
+    }
+    /**
+     * Switch the agent's working directory by rebuilding the runtime for the new
+     * cwd (services are cwd-bound). Resumes that directory's most recent session;
+     * refreshes snapshot, session list, and file tree.
+     */
+    async setCwd(newCwd) {
+        try {
+            const { resolve } = await import("node:path");
+            const fs = await import("node:fs/promises");
+            const abs = resolve(newCwd);
+            const st = await fs.stat(abs);
+            if (!st.isDirectory()) {
+                throw new Error("路径不是目录");
+            }
+            if (abs === this.cwd) {
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `已在工作目录：${abs}`,
+                });
+                this.flushSnapshot();
+                return;
+            }
+            // Build the new runtime first — only swap on success.
+            const newRuntime = await createAgentSessionRuntime(ClientSession.runtimeFactory, {
+                cwd: abs,
+                agentDir: this.agentDir,
+                sessionManager: SessionManager.continueRecent(abs, this.sessionDir),
+            });
+            const oldRuntime = this.runtime;
+            this.runtime = newRuntime;
+            this.cwd = abs;
+            this.unsubscribe?.();
+            this.unsubscribe = undefined;
+            await this.bindSession();
+            await oldRuntime.dispose().catch(() => { });
+            for (const d of newRuntime.diagnostics) {
+                if (d.type !== "info") {
+                    this.emit({ type: "notice", level: d.type, text: d.message });
+                }
+            }
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `已切换到工作目录：${abs}`,
+            });
+            void this.refreshSessions();
+            void this.listFiles(undefined);
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换工作目录失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** List models that have valid authentication configured. */
+    async listModels() {
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const available = await mr.getAvailable();
+            const models = available.map((m) => ({
+                id: `${m.provider}/${m.id}`,
+                name: m.name,
+                provider: m.provider,
+                reasoning: m.reasoning,
+            }));
+            this.emit({ type: "models", models });
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `获取模型列表失败：${err.message}`,
+            });
+        }
+    }
+    /** Switch to a specific model by "provider/id" (e.g. "anthropic/claude-sonnet-5"). */
+    async setModel(modelId) {
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const slash = modelId.indexOf("/");
+            if (slash <= 0 || slash === modelId.length - 1) {
+                throw new Error(`无效的模型 ID：${modelId}`);
+            }
+            const provider = modelId.slice(0, slash);
+            const id = modelId.slice(slash + 1);
+            const model = mr.getModel(provider, id);
+            if (!model)
+                throw new Error(`模型不存在：${modelId}`);
+            await this.session.setModel(model);
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换模型失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** Set the thinking level for future turns. */
+    setThinking(level) {
+        try {
+            this.session.setThinkingLevel(level);
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换思考强度失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    cycleThinking() {
+        try {
+            this.session.cycleThinkingLevel();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `切换思考强度失败：${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** Push the user command list (.pi/commands.json) to the client. */
+    async listCommands() {
+        const { commands, path, warning } = await loadCommands(this.workspaceRoot);
+        if (warning) {
+            this.emit({ type: "notice", level: "warning", text: warning });
+        }
+        this.emit({ type: "commands", commands, path });
+    }
+    /** Persist the user command list (.pi/commands.json). */
+    async saveCommands(commands) {
+        const { path, error } = await saveCommandsFile(this.workspaceRoot, commands);
+        if (error) {
+            this.emit({ type: "notice", level: "error", text: error });
+            return;
+        }
+        this.emit({ type: "commands", commands, path });
+        this.emit({ type: "notice", level: "info", text: `命令已保存：${path}` });
+    }
+    async dispose() {
+        this.disposed = true;
+        this.terminals.killAll();
+        if (this.snapshotTimer) {
+            clearTimeout(this.snapshotTimer);
+            this.snapshotTimer = null;
+        }
+        if (this.sessionsTimer) {
+            clearTimeout(this.sessionsTimer);
+            this.sessionsTimer = null;
+        }
+        if (this.widgetsTimer) {
+            clearInterval(this.widgetsTimer);
+            this.widgetsTimer = null;
+        }
+        this.webUi.dispose();
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        try {
+            await this.runtime.dispose();
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export class AgentService {
+    cwd;
+    sessionDirRoot;
+    clients = new Map();
+    pending = new Map();
+    constructor(cwd, sessionDirRoot) {
+        this.cwd = cwd;
+        this.sessionDirRoot = sessionDirRoot;
+    }
+    /** Get or create the session for a client, racing attach calls safely. */
+    async attach(clientId, send) {
+        let cs = this.clients.get(clientId);
+        if (!cs) {
+            const inflight = this.pending.get(clientId);
+            if (inflight) {
+                cs = await inflight;
+            }
+            else {
+                const creating = ClientSession.create(clientId, this.cwd, join(this.sessionDirRoot, sanitizeId(clientId))).finally(() => {
+                    this.pending.delete(clientId);
+                });
+                this.pending.set(clientId, creating);
+                cs = await creating;
+                this.clients.set(clientId, cs);
+            }
+        }
+        cs.attachSink(send);
+        return cs;
+    }
+    /** Remove a socket from a client's broadcast set (called on socket close). */
+    detach(clientId, send) {
+        this.clients.get(clientId)?.detachSink(send);
+    }
+    get(clientId) {
+        return this.clients.get(clientId);
+    }
+    async disposeAll() {
+        const all = [...this.clients.values()];
+        this.clients.clear();
+        await Promise.all(all.map((cs) => cs.dispose()));
+    }
+}