pi-web-ui 0.28.2 → 0.29.0

package/dist/server/uploads.js

@@ -0,0 +1,107 @@
+/**
+ * uploads — 文件对话上传的存储与清理。
+ *
+ * 上传文件落在 <dataDir>/uploads/<clientId>/<ts>-<name>（模型以绝对路径
+ * reference 读取）。此前这里硬编码 ~/.pi-web，不吃 PI_WEB_DATA_DIR —— 已改为
+ * 与 index.ts 相同的解析逻辑。清理策略：默认保留 14 天，启动时扫一次 +
+ * 每 6 小时扫一次；PI_WEB_UPLOAD_RETENTION_DAYS 覆盖保留天数，0 = 关闭清理。
+ * 全程 best-effort：清理失败绝不影响服务。
+ */
+import { readdir, rm, stat } from "node:fs/promises";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/** Same resolution as index.ts DATA_DIR — kept in sync by env contract. */
+export function resolveDataDir() {
+    return resolve(process.env.PI_WEB_DATA_DIR ?? join(homedir(), ".pi-web"));
+}
+export function uploadsRoot(dataDir = resolveDataDir()) {
+    return join(dataDir, "uploads");
+}
+/** Retention in days; 0 disables sweeping. */
+export function uploadRetentionDays() {
+    const v = Number(process.env.PI_WEB_UPLOAD_RETENTION_DAYS);
+    return Number.isFinite(v) && v >= 0 ? v : 14;
+}
+/** Persist an uploaded buffer; returns the absolute path + sanitized display name. */
+export function saveUpload(clientId, name, buf, dataDir = resolveDataDir()) {
+    const dir = join(uploadsRoot(dataDir), clientId);
+    mkdirSync(dir, { recursive: true });
+    const displayName = name
+        .replace(/[\\/:*?"<>|\x00-\x1f]/g, "_")
+        .slice(0, 80) || "file";
+    const abs = join(dir, `${Date.now()}-${displayName}`);
+    writeFileSync(abs, buf);
+    return { abs, displayName };
+}
+/**
+ * Delete uploaded files older than the retention window, then prune client
+ * dirs left empty. Returns { files, bytes, dirs } removed (best-effort:
+ * individual failures are skipped).
+ */
+export async function cleanupUploads(dataDir = resolveDataDir(), retentionDays = uploadRetentionDays()) {
+    const out = { files: 0, bytes: 0, dirs: 0 };
+    if (retentionDays <= 0)
+        return out;
+    const root = uploadsRoot(dataDir);
+    if (!existsSync(root))
+        return out;
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    let clients;
+    try {
+        clients = await readdir(root);
+    }
+    catch {
+        return out;
+    }
+    for (const clientId of clients) {
+        const dir = join(root, clientId);
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            continue; // not a dir / vanished
+        }
+        for (const entry of entries) {
+            const abs = join(dir, entry);
+            try {
+                const st = await stat(abs);
+                if (st.mtimeMs >= cutoff)
+                    continue;
+                await rm(abs, { recursive: true });
+                out.files++;
+                out.bytes += st.size;
+            }
+            catch {
+                // skip on any per-file failure
+            }
+        }
+        try {
+            if ((await readdir(dir)).length === 0) {
+                await rmdirSafe(dir);
+                out.dirs++;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return out;
+}
+async function rmdirSafe(dir) {
+    try {
+        await rm(dir, { recursive: false });
+    }
+    catch {
+        // non-empty or race — fine
+    }
+}
+/** Startup sweep + periodic re-sweep. Timer is unref'd so it never blocks exit. */
+export function scheduleUploadCleanup(intervalMs = 6 * 60 * 60 * 1000) {
+    void cleanupUploads().catch(() => { });
+    const timer = setInterval(() => {
+        void cleanupUploads().catch(() => { });
+    }, intervalMs);
+    timer.unref?.();
+}

package/dist/server/webui-context.js

@@ -0,0 +1,208 @@
+const WIDGET_WIDTH = 80;
+/** 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 });
+        }
+    }
+    /** Close every pending dialog as cancelled (used when a goal wizard aborts —
+     *  its unanswered browser dialogs must vanish, not linger). */
+    cancelPendingDialogs() {
+        for (const [id, resolve] of this.pendingDialogs) {
+            this.pendingDialogs.delete(id);
+            resolve(null);
+            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();
+    }
+}