pi-web-ui 0.28.2 → 0.29.0

package/dist/server/slash-commands.js

@@ -0,0 +1,245 @@
+/** Slash commands implemented natively by the web server (the pi CLI's built-in
+ * interactive commands like /model and /new are NOT handled by the SDK's
+ * prompt() — without this they'd be sent to the model as plain text). Keep in
+ * sync with exec(). */
+export const NATIVE_COMMANDS = [
+    { name: "new", description: "新建对话", descriptionEn: "New chat" },
+    { name: "model", description: "切换模型", descriptionEn: "Switch model", argumentHint: "[名称]", argumentHintEn: "[name]" },
+    { name: "compact", description: "压缩上下文", descriptionEn: "Compact context", argumentHint: "[说明]", argumentHintEn: "[instructions]" },
+    { name: "cwd", description: "切换工作目录", descriptionEn: "Switch workspace", argumentHint: "<路径>", argumentHintEn: "<path>" },
+    {
+        name: "thinking",
+        description: "设置思考强度",
+        descriptionEn: "Set thinking level",
+        argumentHint: "<off|low|medium|high|xhigh|max>",
+        argumentHintEn: "<off|low|medium|high|xhigh|max>",
+    },
+    { name: "resume", description: "刷新会话列表", descriptionEn: "Refresh session list" },
+    { name: "reload", description: "重新加载扩展、技能与模板", descriptionEn: "Reload extensions, skills & templates" },
+    { name: "help", description: "显示全部命令", descriptionEn: "Show all commands" },
+    { name: "copy", description: "复制上一条助手回复", descriptionEn: "Copy last assistant reply" },
+    { name: "pi-web-ui:quit", description: "退出服务", descriptionEn: "Quit server (supervisor will restart)" },
+];
+/** Parse a prompt into "/command args" — returns null when it isn't one. */
+export function parseSlash(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const m = trimmed.match(/^\/([^\s]+)\s*([\s\S]*)$/);
+    if (!m || !m[1])
+        return null;
+    return { name: m[1], args: m[2].trim() };
+}
+export class SlashCommandsService {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Catalog of slash commands for the chat input: web-native builtins first,
+     * then the SDK's invokable commands for the ACTIVE conversation (extension
+     * commands, prompt templates, skills) — the same set the SDK expands when a
+     * prompt text starts with "/" (see AgentSession.prompt).
+     */
+    async push() {
+        const commands = [];
+        const seen = new Set();
+        for (const c of NATIVE_COMMANDS) {
+            commands.push({ ...c, source: "builtin" });
+            seen.add(c.name);
+        }
+        try {
+            const s = this.host.getSession();
+            // Extension commands — the SDK already suffixes collisions with builtin
+            // names ("new:2"), and those still reach the SDK since exec() only
+            // intercepts the exact native names.
+            for (const cmd of s.extensionRunner.getRegisteredCommands()) {
+                if (seen.has(cmd.invocationName))
+                    continue;
+                commands.push({
+                    name: cmd.invocationName,
+                    description: cmd.description,
+                    source: "extension",
+                });
+                seen.add(cmd.invocationName);
+            }
+            // Prompt templates: /templatename args
+            for (const t of s.promptTemplates) {
+                if (seen.has(t.name))
+                    continue;
+                commands.push({
+                    name: t.name,
+                    description: t.description,
+                    source: "prompt",
+                });
+                seen.add(t.name);
+            }
+            // Skills: /skill:name args
+            for (const skill of s.resourceLoader.getSkills().skills) {
+                const name = `skill:${skill.name}`;
+                if (seen.has(name))
+                    continue;
+                commands.push({
+                    name,
+                    description: skill.description,
+                    source: "skill",
+                });
+            }
+        }
+        catch {
+            // Session not ready yet — native-only catalog still serves the picker.
+        }
+        this.host.emit({ type: "slash_commands", commands });
+    }
+    /** Run a native slash command (see NATIVE_COMMANDS). Returns false when the
+     *  name is not a native command (the prompt falls through to the SDK). */
+    async exec(name, args) {
+        switch (name) {
+            case "new":
+                await this.host.newChat();
+                return true;
+            case "model": {
+                if (!args) {
+                    const current = this.host.getSession().model;
+                    this.host.emit({
+                        type: "notice",
+                        level: "info",
+                        text: current
+                            ? `当前模型：${current.name}（${current.provider}/${current.id}）。用法：/model <名称>`
+                            : `用法：/model <名称>`,
+                    });
+                    return true;
+                }
+                const query = args.toLowerCase();
+                const available = await this.host.getSession().modelRuntime.getAvailable();
+                // Prefer an exact "provider/id" match, else id/name substring.
+                const exact = available.find((m) => m.provider + "/" + m.id === args.trim());
+                const matches = exact
+                    ? [exact]
+                    : available.filter((m) => m.id.toLowerCase().includes(query) ||
+                        m.name.toLowerCase().includes(query) ||
+                        m.provider.toLowerCase().includes(query));
+                if (matches.length === 0) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `没有匹配到模型：${args}（可用模型见顶栏模型列表）`,
+                    });
+                    return true;
+                }
+                const pick = matches[0];
+                if (matches.length > 1) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `找到 ${matches.length} 个匹配模型，已选用：${pick.name}（精确匹配请用 provider/id）`,
+                    });
+                }
+                await this.host.setModel(`${pick.provider}/${pick.id}`);
+                return true;
+            }
+            case "compact":
+                try {
+                    await this.host.getSession().compact(args || undefined);
+                }
+                catch (err) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `压缩上下文失败：${err.message}`,
+                    });
+                }
+                return true;
+            case "cwd":
+                if (!args) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "info",
+                        text: `当前工作目录：${this.host.cwd()}。用法：/cwd <路径>`,
+                    });
+                }
+                else {
+                    await this.host.setCwd(args);
+                }
+                return true;
+            case "thinking": {
+                const ALIAS = {
+                    off: "off",
+                    minimal: "minimal",
+                    low: "low",
+                    medium: "medium",
+                    high: "high",
+                    xhigh: "xhigh",
+                    max: "max",
+                    关闭: "off",
+                    极简: "minimal",
+                    低: "low",
+                    中: "medium",
+                    高: "high",
+                    极高: "xhigh",
+                    最大: "max",
+                };
+                const level = ALIAS[args.trim().toLowerCase()];
+                if (!level) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `无效的思考强度：${args || "（空）"}。可用：off / minimal / low / medium / high / xhigh / max`,
+                    });
+                    return true;
+                }
+                this.host.setThinking(level);
+                return true;
+            }
+            case "resume":
+                await this.host.refreshSessions();
+                this.host.emit({
+                    type: "notice",
+                    level: "info",
+                    text: "会话列表已刷新，请在左侧「历史对话」中选择",
+                });
+                return true;
+            case "reload":
+                try {
+                    // Re-discovers extensions / skills / prompt templates from disk and
+                    // re-pushes the picker catalog (the CLI's /reload semantics).
+                    await this.host.getSession().reload();
+                    await this.push();
+                    this.host.emit({
+                        type: "notice",
+                        level: "info",
+                        text: "已重新加载扩展、技能与提示模板",
+                    });
+                }
+                catch (err) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `重新加载失败：${err.message}`,
+                    });
+                }
+                return true;
+            case "pi-web-ui:quit": {
+                this.host.emit({
+                    type: "notice",
+                    level: "info",
+                    text: "正在退出 pi-web-ui… supervisor 将自动重启服务",
+                });
+                setTimeout(() => {
+                    const didSchedule = this.host.onQuit?.() ?? false;
+                    if (!didSchedule) {
+                        setTimeout(() => process.exit(0), 100);
+                    }
+                }, 300);
+                return true;
+            }
+            case "help":
+            case "copy":
+                // Client-side UI actions — the client handles them before sending;
+                // swallow here so the SDK never sees them as plain prompt text.
+                return true;
+            default:
+                return false;
+        }
+    }
+}

package/dist/server/terminals.js

@@ -22,6 +22,8 @@ import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 // module itself for details).
 import "./patch-node-pty.js";
 import { spawn } from "node-pty";
+import { defineTool, } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
 /** Location of the command list for a project: <workspaceRoot>/.pi/commands.json */
 export function commandsFilePath(workspaceRoot) {
     return join(workspaceRoot, ".pi", "commands.json");
@@ -741,3 +743,99 @@ export class TerminalManager {
         this.emitList();
     }
 }
+/** Build the agent-facing persistent terminal tools for one conversation. */
+export function makePersistentTerminalTools(terminals, cwd) {
+    const result = (text, details = {}) => ({ content: [{ type: "text", text }], details });
+    const failIf = (error) => {
+        if (error)
+            throw new Error(error);
+    };
+    return [
+        defineTool({
+            name: "terminal_create",
+            label: "Create terminal",
+            description: "Create a named persistent interactive PTY in the current workspace. Use terminal_input or terminal_key to interact with it and terminal_read to inspect incremental output.",
+            promptSnippet: "create persistent interactive PTY terminals",
+            parameters: Type.Object({
+                terminalId: Type.String({ description: "Stable terminal name" }),
+                cwd: Type.Optional(Type.String({ description: "Workspace-relative directory" })),
+                cols: Type.Optional(Type.Integer({ minimum: 2, maximum: 500 })),
+                rows: Type.Optional(Type.Integer({ minimum: 2, maximum: 200 })),
+            }),
+            execute: async (_id, p) => {
+                const info = terminals.create(p.terminalId, p.cwd ?? cwd, p.cols ?? 120, p.rows ?? 40, cwd, p.terminalId);
+                if (!info)
+                    throw new Error(`创建终端失败：${p.terminalId}`);
+                return result(`终端已创建：${JSON.stringify(info)}`, info);
+            },
+        }),
+        defineTool({
+            name: "terminal_list",
+            label: "List terminals",
+            description: "List all persistent PTY terminals owned by this conversation.",
+            promptSnippet: "list persistent terminals",
+            parameters: Type.Object({}),
+            execute: async () => result(JSON.stringify(terminals.list()), terminals.list()),
+        }),
+        defineTool({
+            name: "terminal_close",
+            label: "Close terminal",
+            description: "Close a persistent PTY and terminate its process tree.",
+            parameters: Type.Object({ terminalId: Type.String() }),
+            execute: async (_id, p) => {
+                if (!terminals.has(p.terminalId))
+                    throw new Error(`终端不存在：${p.terminalId}`);
+                terminals.kill(p.terminalId);
+                return result(`终端已关闭：${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_input",
+            label: "Send terminal input",
+            description: "Send arbitrary text to a persistent PTY. Include newline when a command should be submitted.",
+            parameters: Type.Object({ terminalId: Type.String(), data: Type.String() }),
+            execute: async (_id, p) => {
+                failIf(terminals.inputChecked(p.terminalId, p.data));
+                return result(`已发送 ${p.data.length} 个字符到 ${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_key",
+            label: "Send terminal key",
+            description: "Send Enter, Tab, arrows, function keys, or Ctrl/Alt combinations to a persistent PTY.",
+            parameters: Type.Object({
+                terminalId: Type.String(),
+                key: Type.String({ description: "Enter, Tab, ArrowUp, c, etc." }),
+                modifiers: Type.Optional(Type.Object({
+                    ctrl: Type.Optional(Type.Boolean()),
+                    alt: Type.Optional(Type.Boolean()),
+                    shift: Type.Optional(Type.Boolean()),
+                })),
+            }),
+            execute: async (_id, p) => {
+                failIf(terminals.key(p.terminalId, p.key, p.modifiers));
+                return result(`已发送按键 ${p.key} 到 ${p.terminalId}`);
+            },
+        }),
+        defineTool({
+            name: "terminal_read",
+            label: "Read terminal output",
+            description: "Read incremental output from a persistent PTY. Keep the returned cursor and pass it on the next read; optionally wait for new output or process exit.",
+            parameters: Type.Object({
+                terminalId: Type.String(),
+                cursor: Type.Optional(Type.Integer({ minimum: 0 })),
+                maxBytes: Type.Optional(Type.Integer({ minimum: 1, maximum: 100000 })),
+                waitMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 120000 })),
+            }),
+            execute: async (_id, p, signal) => {
+                const cursor = p.cursor ?? 0;
+                if (p.waitMs)
+                    await terminals.waitForOutput(p.terminalId, cursor, p.waitMs, signal);
+                const read = terminals.read(p.terminalId, cursor, p.maxBytes ?? 20000);
+                if (!read)
+                    throw new Error(`终端不存在：${p.terminalId}`);
+                return result(JSON.stringify(read), read);
+            },
+        }),
+    ];
+}

package/dist/server/text-sniff.js

@@ -0,0 +1,268 @@
+/**
+ * text-sniff — 文件预览相关的纯函数：扩展名分类、内容嗅探、文本解码
+ * （UTF-8 → GBK → latin1 回退）、十六进制视图、行数统计。
+ *
+ * 全部无副作用、不碰 fs —— 便于单元测试（tests/unit/text-sniff.test.ts）。
+ * 从 agent-service.ts 抽出，行为保持不变。
+ */
+const PREVIEW_IMAGE_EXTS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "svg",
+    "bmp",
+    "ico",
+    "avif",
+    "jfif",
+    "tif",
+    "tiff",
+]);
+const PREVIEW_VIDEO_EXTS = new Set([
+    "mp4",
+    "webm",
+    "mov",
+    "mkv",
+    "avi",
+    "m4v",
+    "ogv",
+    "mpg",
+    "mpeg",
+    "wmv",
+    "flv",
+]);
+const PREVIEW_TEXT_EXTS = new Set([
+    // code
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "jsm",
+    "es6",
+    "vue",
+    "svelte",
+    "py",
+    "pyw",
+    "ipynb",
+    "go",
+    "rs",
+    "c",
+    "h",
+    "cpp",
+    "hpp",
+    "cc",
+    "cxx",
+    "hh",
+    "csh",
+    "java",
+    "kt",
+    "kts",
+    "scala",
+    "sc",
+    "cs",
+    "fs",
+    "fsx",
+    "fsi",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "bat",
+    "cmd",
+    "ps1",
+    "psd1",
+    "psm1",
+    "rb",
+    "php",
+    "pl",
+    "pm",
+    "tcl",
+    "lua",
+    "r",
+    "rmd",
+    "sql",
+    "swift",
+    "dart",
+    "groovy",
+    "gradle",
+    "tf",
+    "tfvars",
+    "hcl",
+    "nim",
+    "zig",
+    "v",
+    "vala",
+    "d",
+    "clj",
+    "cljs",
+    "cljc",
+    "edn",
+    "ex",
+    "exs",
+    "erl",
+    "hrl",
+    "ml",
+    "mli",
+    // markup / config / data
+    "json",
+    "jsonc",
+    "json5",
+    "jsonl",
+    "md",
+    "mdx",
+    "markdown",
+    "html",
+    "htm",
+    "xhtml",
+    "css",
+    "scss",
+    "sass",
+    "less",
+    "styl",
+    "xml",
+    "dtd",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "conf",
+    "properties",
+    "env",
+    "log",
+    "txt",
+    "text",
+    "csv",
+    "tsv",
+    "lock",
+    "sqlite",
+    "graphql",
+    "gql",
+    "proto",
+    "prisma",
+    "asm",
+    "s",
+]);
+/**
+ * Classify a file name into its preview category. Files with no extension
+ * (README, Makefile, .gitignore, …) are treated as text. Everything not in an
+ * allowlist (exe, jar, dll, zip, …) is "none" — never previewed.
+ */
+export function previewKind(name) {
+    const dot = name.lastIndexOf(".");
+    // A leading dot with nothing after it (.gitignore, .env) counts as no ext.
+    const ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+    if (PREVIEW_IMAGE_EXTS.has(ext))
+        return "image";
+    if (PREVIEW_VIDEO_EXTS.has(ext))
+        return "video";
+    if (ext === "" || PREVIEW_TEXT_EXTS.has(ext))
+        return "text";
+    return "none";
+}
+/**
+ * Content sniff for the preview: any data that has no NUL bytes and no
+ * meaningful control-char ratio is treated as text — so files with unknown
+ * or absent extensions (jsonl, .log.1, …) still open as text. NULs catch
+ * zip/sqlite/png/… even when the extension claims text.
+ */
+export function looksLikeText(buf) {
+    if (buf.length === 0)
+        return true;
+    if (buf.includes(0))
+        return false;
+    const text = buf.toString("utf8");
+    let control = 0;
+    for (const ch of text) {
+        const c = ch.charCodeAt(0);
+        // Keep \t \n \r \f (and \b); everything else < 0x20 is binary-ish.
+        if (c < 0x20 && c !== 9 && c !== 10 && c !== 12 && c !== 13)
+            control++;
+    }
+    return control / Math.max(text.length, 1) < 0.02;
+}
+/** Decode bytes: strict UTF-8 first, falling back to GBK (Windows legacy
+ *  Chinese files), then latin1 as a last resort — so previews and inline
+ *  attachments never show mojibake for GBK/GB2312 encoded files. */
+export function decodeText(buf) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(buf);
+    }
+    catch {
+        try {
+            return new TextDecoder("gbk").decode(buf);
+        }
+        catch {
+            return buf.toString("latin1");
+        }
+    }
+}
+/** Sniff an image MIME type from magic bytes (extension is only a hint).
+ *  Returns null when the bytes don't look like a known raster format —
+ *  callers keep such files as plain path references. */
+export function sniffImageMime(buf, ext) {
+    if (buf.length >= 8 &&
+        buf[0] === 0x89 &&
+        buf[1] === 0x50 &&
+        buf[2] === 0x4e &&
+        buf[3] === 0x47) {
+        return "image/png";
+    }
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+        return "image/jpeg";
+    }
+    const head = buf.slice(0, 6).toString("ascii");
+    if (head === "GIF87a" || head === "GIF89a")
+        return "image/gif";
+    if (buf.length >= 12 &&
+        buf.slice(0, 4).toString("ascii") === "RIFF" &&
+        buf.slice(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    if (buf.length >= 2 && buf[0] === 0x42 && buf[1] === 0x4d)
+        return "image/bmp";
+    // Unknown but raster-looking extension — trust the extension so existing
+    // image attachments keep working.
+    const known = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".bmp": "image/bmp",
+    };
+    return known[ext] ?? null;
+}
+/** First few KB of binary data as a classic hex + ASCII dump (preview only). */
+export function hexDump(buf, maxBytes = 4096) {
+    const data = buf.subarray(0, Math.min(buf.length, maxBytes));
+    const rows = [];
+    for (let off = 0; off < data.length; off += 16) {
+        const chunk = data.subarray(off, off + 16);
+        const hex = [...chunk]
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join(" ");
+        const ascii = [...chunk]
+            .map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : "."))
+            .join("");
+        rows.push(`${off.toString(16).padStart(8, "0")}  ${hex.padEnd(47, " ")}  ${ascii}`);
+    }
+    return rows.join("\n");
+}
+/** Count lines in a buffer; a trailing newline terminates the last line
+ *  instead of starting an empty one — matches the client preview's
+ *  split-based line numbering. */
+export function countLines(buf) {
+    if (buf.length === 0)
+        return 0;
+    const hasTrailingNewline = buf[buf.length - 1] === 10; /* \n */
+    let lines = 0;
+    for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 10)
+            lines++;
+    }
+    return hasTrailingNewline ? lines : lines + 1;
+}