pi-web-ui 0.36.0 → 0.44.0

package/dist/server/plugins.js

@@ -17,11 +17,116 @@
  * - activate 抛错只标记 error 字段并记日志，绝不影响主进程。
  */
 import { readdir, readFile, stat } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
+import { PluginStorage, PluginSecrets, ensurePluginDeps, WorkspaceFS } from "./plugin-facilities.js";
+import { createHash } from "node:crypto";
 /** 合法插件 id：字母/数字/下划线/连字符，防路径穿越（同 themes.ts 的做法）。 */
 const ID_RE = /^[A-Za-z0-9_-]+$/;
+/** 宿主提供的插件设施版本——manifest 声明的 apiVersion 高于此值则拒绝激活，
+ *  插件能拿到明确的「请升级 pi-web-ui」而不是在新接口上莫名 undefined。 */
+export const PLUGIN_API_VERSION = 1;
+/** 消息处理器超时：仅作为不再等待的日志阈值（响应由 handler 自己发出）。 */
+const MESSAGE_TIMEOUT_MS = 30_000;
+/** host.fs 被能力门控拒绝时的共享 rejected promise（类型对齐用）。 */
+const NO_FS_PROMISE = Promise.reject(new Error('插件未声明能力 "fs"（manifest.permissions）——请求被拒'));
+NO_FS_PROMISE.catch(() => { }); // 避免未处理 rejection 噪音；调用方 await 时拿到错误
+// ---------------------------------------------------------------------------
+// 声明式设置 schema（manifest "settings"）
+// ---------------------------------------------------------------------------
+const SETTING_TYPES = new Set(["text", "password", "number", "boolean", "select"]);
+/** 解析 manifest.settings → 合法 schema（坏字段跳过，最多 32 个）。 */
+function parseSettingsSchema(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const f of raw) {
+        if (!f || typeof f !== "object")
+            continue;
+        const o = f;
+        const key = typeof o.key === "string" ? o.key.trim() : "";
+        const type = typeof o.type === "string" ? o.type : "";
+        if (!key || !SETTING_TYPES.has(type) || out.some((x) => x.key === key))
+            continue;
+        const field = {
+            key,
+            type: type,
+            label: typeof o.label === "string" && o.label ? o.label : key,
+            ...(o.default !== undefined ? { default: o.default } : {}),
+            ...(typeof o.min === "number" ? { min: o.min } : {}),
+            ...(typeof o.max === "number" ? { max: o.max } : {}),
+            ...(Array.isArray(o.options)
+                ? { options: o.options.filter((x) => typeof x === "string") }
+                : {}),
+            ...(typeof o.hint === "string" ? { hint: o.hint } : {}),
+        };
+        out.push(field);
+        if (out.length >= 32)
+            break;
+    }
+    return out;
+}
+/** 从 <pluginDir>/storage.json 读 settings 存值，按 schema 并默认值。 */
+function storedSettingsValues(dir, schema) {
+    const out = {};
+    let stored = {};
+    try {
+        const parsed = JSON.parse(readFileSync(join(dir, "storage.json"), "utf8"));
+        if (parsed && typeof parsed === "object" && parsed.settings && typeof parsed.settings === "object") {
+            stored = parsed.settings;
+        }
+    }
+    catch {
+        /* 无存储文件 = 全默认 */
+    }
+    for (const f of schema)
+        out[f.key] = stored[f.key] ?? f.default;
+    return out;
+}
+/** 校验并写回 settings（storage.json 的 settings 键，原子写）；返回错误信息或 null。 */
+function saveSettingsValues(dir, schema, values) {
+    const clean = {};
+    for (const f of schema) {
+        const v = values?.[f.key];
+        if (f.type === "number") {
+            const n = v === undefined ? Number(f.default ?? 0) : Number(v);
+            if (!Number.isFinite(n) || (f.min !== undefined && n < f.min) || (f.max !== undefined && n > f.max)) {
+                return { error: `${f.label} 超出范围`, clean };
+            }
+            clean[f.key] = n;
+        }
+        else if (f.type === "boolean") {
+            clean[f.key] = v === undefined ? Boolean(f.default) : Boolean(v);
+        }
+        else if (f.type === "select") {
+            if (v !== undefined && !f.options?.includes(String(v)))
+                return { error: `${f.label} 值非法`, clean };
+            clean[f.key] = v === undefined ? f.default : String(v);
+        }
+        else {
+            clean[f.key] = v === undefined ? (f.default ?? "") : String(v);
+        }
+    }
+    try {
+        // 保留 storage.json 里其它键（插件自己的数据），只动 settings。
+        const file = join(dir, "storage.json");
+        let existing = {};
+        try {
+            existing = JSON.parse(readFileSync(file, "utf8"));
+        }
+        catch {
+            /* 首次 */
+        }
+        const tmp = `${file}.tmp-${process.pid}`;
+        writeFileSync(tmp, JSON.stringify({ ...existing, settings: clean }));
+        renameSync(tmp, file);
+    }
+    catch (err) {
+        console.error(`[plugins] settings persist failed (${dir}):`, err);
+    }
+    return { clean };
+}
 export class PluginManager {
     dataDir;
     loaded = new Map();
@@ -33,6 +138,14 @@ export class PluginManager {
     agentTools = new Map();
     /** AI 工具集合变化回调（index.ts 接到 AgentService，把新工具推入活跃会话）。 */
     onAgentToolsChanged = undefined;
+    /** 插件斜杠命令注册表：pluginId → (name → 定义)。宿主经 listCommands() 读取。 */
+    pluginCommands = new Map();
+    /** 命令集合变化回调（index.ts 接到 AgentService，刷新各客户端命令目录）。 */
+    onCommandsChanged = undefined;
+    /** 插件常驻任务：pluginId → Map<taskId, PluginBgTask>。宿主经 bgTasks() 读取。 */
+    pluginBgTasks = new Map();
+    /** 任务集合变化回调（index.ts 接到 AgentService，重推 bg_servers）。 */
+    onBgTasksChanged = undefined;
     /** 服务端重载纪元：每次 reload() +1，前端用作 import 缓存击穿参数。 */
     epochCounter = 0;
     /** 当前全局工作区（host.cwd 的背后存储）——随 notifyCwd 更新。 */
@@ -62,6 +175,88 @@ export class PluginManager {
     get pluginsDir() {
         return join(this.dataDir, "plugins");
     }
+    /** 全部插件注册的斜杠命令（按插件 id 稳定排序）。 */
+    listCommands() {
+        const out = [];
+        for (const id of [...this.pluginCommands.keys()].sort()) {
+            out.push(...this.pluginCommands.get(id).values());
+        }
+        return out;
+    }
+    /** 按名查找命令（供 prompt() 拦截执行；找不到返回 null）。 */
+    findCommand(name) {
+        for (const [pluginId, table] of this.pluginCommands) {
+            if (table.has(name))
+                return { def: table.get(name), pluginId };
+        }
+        return null;
+    }
+    /** 全部插件注册的常驻后台任务（扁平化为 BgServer 形状）。 */
+    bgTasks() {
+        const out = [];
+        for (const [pluginId, table] of this.pluginBgTasks) {
+            for (const t of table.values()) {
+                out.push({
+                    taskId: t.id,
+                    plugin: pluginId,
+                    since: t.since,
+                    name: t.label,
+                    ...(t.status ? { status: t.status } : {}),
+                });
+            }
+        }
+        return out;
+    }
+    /** 停止一个插件任务（kill_background_server with taskId）；返回是否命中。 */
+    stopPluginBgTask(taskId) {
+        for (const [pluginId, table] of this.pluginBgTasks) {
+            const t = table.get(taskId);
+            if (!t)
+                continue;
+            try {
+                t.stop?.();
+            }
+            catch (err) {
+                console.error(`[plugin:${pluginId}] background task ${taskId} stop failed:`, err);
+            }
+            table.delete(taskId);
+            if (table.size === 0)
+                this.pluginBgTasks.delete(pluginId);
+            try {
+                this.onBgTasksChanged?.();
+            }
+            catch { }
+            return true;
+        }
+        return false;
+    }
+    /** 保存某插件的声明式设置（⚙ 面板 → plugin_settings 消息）：按 schema 校验、
+     *  原子写 storage.json 的 settings 键、通知插件 onSettingsChanged、重推清单
+     *  让前端回显。返回错误信息或 null（成功）。 */
+    savePluginSettings(pluginId, values) {
+        if (!ID_RE.test(pluginId))
+            return { error: "非法的插件 id" };
+        const dir = join(this.pluginsDir, pluginId);
+        const info = this.loaded.get(pluginId)?.info;
+        const schema = info?.settingsSchema ?? [];
+        if (!schema.length)
+            return { error: "该插件没有声明式设置（manifest 未声明 settings）" };
+        const { error, clean } = saveSettingsValues(dir, schema, values);
+        if (error)
+            return { error };
+        // 通知插件（异常隔离）
+        for (const h of this.loaded.get(pluginId)?.settingsHandlers ?? []) {
+            try {
+                h(clean);
+            }
+            catch (err) {
+                console.error(`[plugin:${pluginId}] onSettingsChanged handler failed:`, err);
+            }
+        }
+        // 重推 plugins 清单（含新 settingsValues），前端回显。
+        void this.pushToAll().catch(() => { });
+        return {};
+    }
     /** 当前重载纪元（随 plugins 消息下发）。 */
     get epoch() {
         return this.epochCounter;
@@ -87,6 +282,12 @@ export class PluginManager {
                     ret.catch((err) => {
                         console.error(`[plugin:${pluginId}] async message handler failed:`, err);
                     });
+                    // 超时护栏：响应由 handler 自己 sendTo/broadcast 发出，超时只是记
+                    // 日志不再等待——绝不能让单条消息把客户端 pending 管线无限拖死。
+                    const timer = setTimeout(() => {
+                        console.error(`[plugin:${pluginId}] message handler 超时（>${MESSAGE_TIMEOUT_MS}ms），已不再等待`);
+                    }, MESSAGE_TIMEOUT_MS);
+                    void ret.finally(() => clearTimeout(timer));
                 }
             }
             catch (err) {
@@ -94,6 +295,53 @@ export class PluginManager {
             }
         }
     }
+    /** 首次安装/能力变更时提醒在线用户（marker 文件记录上次激活时的声明）。 */
+    async maybeConsentNotice(info, dir, perms) {
+        try {
+            const markerFile = join(dir, ".pi-approved");
+            const key = createHash("sha256").update(JSON.stringify(perms)).digest("hex").slice(0, 32);
+            let prev = "";
+            try {
+                prev = JSON.parse(readFileSync(markerFile, "utf8"))?.key ?? "";
+            }
+            catch {
+                /* 无 marker = 首次安装 */
+            }
+            if (prev === key)
+                return; // 同版本能力清单，不再打扰
+            const list = perms.length ? perms.join(", ") : "无";
+            this.notifyAll(perms.length ? "warning" : "info", `插件「${info.name}」已激活（${prev ? "能力清单变更" : "首次安装"}；声明能力：${list}）——请确认来源可信`);
+            writeFileSync(markerFile, JSON.stringify({ v: 1, key, perms }), "utf8");
+        }
+        catch (err) {
+            console.error(`[plugin:${info.id}] consent notice failed:`, err);
+        }
+    }
+    /** index.ts 的 /plugins-api/:id/* 挂载点转发到这里：找到对应插件的已注册
+     *  路由并执行；未知插件/路径 → 404，handler 抛错 → 500（不炸进程）。 */
+    handleHttp(pluginId, method, pathIn, req, res) {
+        if (!ID_RE.test(pluginId)) {
+            res.status(404).end("plugin not found");
+            return;
+        }
+        const table = this.loaded.get(pluginId)?.httpRoutes;
+        const path = "/" + pathIn.replace(/^\/+/, "");
+        const handler = table?.get(`${method.toUpperCase()} ${path}`);
+        if (!handler) {
+            res.status(404).end("not found");
+            return;
+        }
+        try {
+            handler(req, res);
+        }
+        catch (err) {
+            console.error(`[plugin:${pluginId}] http ${method} ${path} failed:`, err);
+            if (!res.headersSent)
+                res.status(500).end("internal error");
+            else
+                res.end();
+        }
+    }
     broadcast(pluginId, payload) {
         this.deliverAll({ type: "plugin_data", pluginId, payload });
     }
@@ -202,6 +450,52 @@ export class PluginManager {
             }
         };
     }
+    /** 注册斜杠命令：跨插件重名拒绝（先注册者胜出），onCommandsChanged 通知目录刷新。 */
+    registerCommand(pluginId, cmd) {
+        const name = String(cmd?.name ?? "").replace(/^\/+/, ""); // 容忍误带的前导 /
+        if (!/^[a-zA-Z][a-zA-Z0-9:_-]*$/.test(name)) {
+            console.error(`[plugin:${pluginId}] registerCommand: 非法名称「${cmd?.name}」（需字母开头，允许字母数字:_-），忽略`);
+            return () => { };
+        }
+        if (typeof cmd?.run !== "function") {
+            console.error(`[plugin:${pluginId}] registerCommand: ${name} 缺少 run，忽略`);
+            return () => { };
+        }
+        for (const [pid, table] of this.pluginCommands) {
+            if (table.has(name) && pid !== pluginId) {
+                console.error(`[plugin:${pluginId}] 命令 /${name} 已被插件 ${pid} 注册，忽略重复`);
+                return () => { };
+            }
+        }
+        let table = this.pluginCommands.get(pluginId);
+        if (!table)
+            this.pluginCommands.set(pluginId, (table = new Map()));
+        if (table.has(name)) {
+            console.error(`[plugin:${pluginId}] 命令 /${name} 重复注册，忽略`);
+            return () => { };
+        }
+        const def = { ...cmd, name };
+        table.set(name, def);
+        console.log(`[plugin:${pluginId}] registered command: /${name}`);
+        try {
+            this.onCommandsChanged?.();
+        }
+        catch (err) {
+            console.error("[plugins] onCommandsChanged failed:", err);
+        }
+        return () => {
+            if (table.delete(name)) {
+                if (table.size === 0)
+                    this.pluginCommands.delete(pluginId);
+                try {
+                    this.onCommandsChanged?.();
+                }
+                catch {
+                    /* shutting down */
+                }
+            }
+        };
+    }
     deliverAll(msg) {
         for (const s of this.senders) {
             try {
@@ -266,7 +560,7 @@ export class PluginManager {
             catch (err) {
                 console.error(`[plugin:${id}] deactivate failed:`, err);
             }
-            for (const off of [...(p.agentToolUnsubscribers ?? [])]) {
+            for (const off of [...(p.agentToolUnsubscribers ?? []), ...(p.commandUnsubscribers ?? [])]) {
                 try {
                     off();
                 }
@@ -274,7 +568,15 @@ export class PluginManager {
                     /* shutting down */
                 }
             }
+            // 反激活时停掉它注册的常驻后台任务（轮询器等），不留孤儿计时器。
+            for (const t of this.pluginBgTasks.get(id)?.values() ?? []) {
+                try {
+                    t.stop?.();
+                }
+                catch { }
+            }
         }
+        this.pluginBgTasks.clear();
         this.loaded.clear();
         this.messageHandlers.clear();
     }
@@ -305,6 +607,13 @@ export class PluginManager {
                     icon: typeof m.icon === "string" && m.icon.trim() ? m.icon.trim() : undefined,
                     hasClient: existsSync(join(dir, "client", "entry.mjs")),
                     error: this.loaded.get(name)?.info.error,
+                    // manifest 声明的能力清单（fs/net/tools…）——设置面板展示用
+                    permissions: Array.isArray(m.permissions)
+                        ? m.permissions.filter((p) => typeof p === "string" && p.length > 0).slice(0, 16)
+                        : undefined,
+                    // 声明式设置 schema + 当前存值（⚙ 面板自动渲染表单用）
+                    settingsSchema: parseSettingsSchema(m.settings),
+                    settingsValues: storedSettingsValues(dir, parseSettingsSchema(m.settings)),
                     // 安装来源（pi-web-ui install 写入的 .pi-source.json）——
                     // 设置面板据此显示「更新」按钮；手工拷入的插件没有此文件。
                     source: await readFile(join(dir, ".pi-source.json"), "utf8")
@@ -334,8 +643,53 @@ export class PluginManager {
         const toolHandlers = new Set();
         const attachHandlers = new Set();
         const cwdHandlers = new Set();
+        const httpRoutes = new Map();
         const unregisterTools = [];
-        const p = { info, toolHandlers, attachHandlers, cwdHandlers };
+        const unregisterCommands = [];
+        const bgTaskTable = new Map();
+        const settingsHandlers = new Set();
+        // 宿主 API 版本协商：插件要的比宿主新 → 明确拒绝（而不是让它在运行期
+        // 撞 undefined 接口莫名其妙地坏）。与激活失败同一处理：error 字段 + 置灰。
+        let apiVersion = 1;
+        try {
+            apiVersion = Number(JSON.parse(readFileSync(join(dir, "manifest.json"), "utf8")).apiVersion ?? 1) || 1;
+        }
+        catch { }
+        if (apiVersion > PLUGIN_API_VERSION) {
+            const msg = `插件要求宿主 API v${apiVersion}，当前宿主 v${PLUGIN_API_VERSION} —— 请升级 pi-web-ui`;
+            console.error(`[plugin:${info.id}] ${msg}`);
+            this.loaded.set(info.id, { info: { ...info, error: msg }, toolHandlers, attachHandlers, cwdHandlers, httpRoutes, settingsHandlers: new Set() });
+            return;
+        }
+        // 能力声明：写了 permissions → 严格模式（受控宿主 API 按声明族强制执行）；
+        // 未写且 apiVersion < 2 → 旧全权模式（首次使用受控 API 时警告一次，v2 起默认拒绝）。
+        const permsDeclared = (info.permissions ?? []).slice();
+        const strict = permsDeclared.length > 0 || apiVersion >= 2;
+        const permFamilies = new Set(permsDeclared.map((x) => x.split(":")[0]));
+        const p = { info, toolHandlers, attachHandlers, cwdHandlers, commandUnsubscribers: unregisterCommands, httpRoutes, settingsHandlers };
+        p.permsDeclared = permsDeclared;
+        p.permFamilies = permFamilies;
+        p.legacyWarned = false;
+        // 每插件的私有设施：KV 存储 + 加密 secrets + 依赖自动补装（单飞）。
+        const storage = new PluginStorage(join(dir, "storage.json"));
+        const secrets = new PluginSecrets(this.dataDir, dir);
+        // 受限工作区文件访问（能力 "fs" 门控；根随 set_cwd 活值移动）。
+        const workspaceFs = new WorkspaceFS(() => self.cwdValue);
+        /** 能力门控：严格模式下查声明族；旧模式放行但每个激活期只警告一次。
+         *  返回 false = 已记日志，调用方应拒绝。 */
+        const can = (family) => {
+            if (permFamilies.has(family))
+                return true;
+            if (!strict) {
+                if (!p.legacyWarned) {
+                    p.legacyWarned = true;
+                    console.warn(`[plugin:${info.id}] manifest 未声明 permissions（旧格式全权模式）——已放行 "${family}"；apiVersion 2 起将默认拒绝，请尽快声明`);
+                }
+                return true;
+            }
+            console.error(`[plugin:${info.id}] 缺少能力声明 "${family}"（manifest.permissions）——请求被拒`);
+            return false;
+        };
         const self = this; // 对象字面量 getter 里不能用插件宿主的 this
         const host = {
             broadcast: (payload) => this.broadcast(info.id, payload),
@@ -357,8 +711,34 @@ export class PluginManager {
                 cwdHandlers.add(h);
                 return () => cwdHandlers.delete(h);
             },
+            registerCommand: (cmd) => {
+                const off = this.registerCommand(info.id, cmd);
+                unregisterCommands.push(off);
+                return () => {
+                    const i = unregisterCommands.indexOf(off);
+                    if (i >= 0)
+                        unregisterCommands.splice(i, 1);
+                    off();
+                };
+            },
+            storage,
+            secrets,
+            ensureDeps: (specs, opts) => ensurePluginDeps(dir, specs ?? [], opts?.onProgress),
+            route: (method, path, handler) => {
+                if (!can("http"))
+                    return () => { };
+                const m = String(method ?? "GET").toUpperCase();
+                if (!["GET", "POST", "PUT", "DELETE"].includes(m) || typeof path !== "string" || !path.startsWith("/") || typeof handler !== "function") {
+                    console.error(`[plugin:${info.id}] route: 非法参数（method=${method} path=${path}），忽略`);
+                    return () => { };
+                }
+                httpRoutes.set(`${m} ${path}`, handler);
+                return () => httpRoutes.delete(`${m} ${path}`);
+            },
             // 包一层：插件反激活时自动注销它注册的全部 AI 工具，不留悬挂项。
             registerAgentTool: (tool) => {
+                if (!can("tools"))
+                    return () => { };
                 const off = this.registerAgentTool(info.id, tool);
                 unregisterTools.push(off);
                 return () => {
@@ -373,6 +753,61 @@ export class PluginManager {
             get cwd() {
                 return self.cwdValue;
             },
+            fs: {
+                list: (relDir) => (can("fs") ? workspaceFs.list(relDir) : NO_FS_PROMISE),
+                read: (p) => (can("fs") ? workspaceFs.read(p) : NO_FS_PROMISE),
+                readText: (p, max) => (can("fs") ? workspaceFs.readText(p, max) : NO_FS_PROMISE),
+                write: (p, data) => (can("fs") ? workspaceFs.write(p, data) : NO_FS_PROMISE),
+                remove: (p) => (can("fs") ? workspaceFs.remove(p) : NO_FS_PROMISE),
+            },
+            registerBackgroundTask: (task) => {
+                const id = String(task?.id ?? "").trim();
+                if (!id || bgTaskTable.has(id)) {
+                    console.error(`[plugin:${info.id}] registerBackgroundTask: 非法/重复 id「${task?.id}」，忽略`);
+                    return { update: () => { }, unregister: () => { } };
+                }
+                const entry = {
+                    id,
+                    label: String(task?.label ?? id),
+                    since: Date.now(),
+                    ...(typeof task?.stop === "function" ? { stop: task.stop } : {}),
+                    ...(typeof task?.status === "string" ? { status: task.status } : {}),
+                };
+                bgTaskTable.set(id, entry);
+                this.pluginBgTasks.set(info.id, bgTaskTable);
+                const fire = () => {
+                    try {
+                        this.onBgTasksChanged?.();
+                    }
+                    catch { }
+                };
+                fire();
+                return {
+                    update: (next) => {
+                        if (!bgTaskTable.has(id))
+                            return;
+                        if (next.label !== undefined)
+                            entry.label = String(next.label);
+                        if (next.status !== undefined)
+                            entry.status = next.status;
+                        if (typeof next.stop === "function")
+                            entry.stop = next.stop;
+                        fire();
+                    },
+                    unregister: () => {
+                        if (bgTaskTable.delete(id)) {
+                            if (bgTaskTable.size === 0)
+                                this.pluginBgTasks.delete(info.id);
+                            fire();
+                        }
+                    },
+                };
+            },
+            getSettings: () => storedSettingsValues(dir, info.settingsSchema ?? []),
+            onSettingsChanged: (h) => {
+                settingsHandlers.add(h);
+                return () => settingsHandlers.delete(h);
+            },
             log: (...args) => console.log(`[plugin:${info.id}]`, ...args),
         };
         try {
@@ -387,15 +822,25 @@ export class PluginManager {
                 attachHandlers,
                 cwdHandlers,
                 agentToolUnsubscribers: unregisterTools,
+                commandUnsubscribers: unregisterCommands,
+                httpRoutes,
+                settingsHandlers,
             });
             console.log(`[plugin:${info.id}] activated (v${info.version ?? "?"})`);
+            // 首次安装/能力变更提醒（尽力而为）：<dir>/.pi-approved 记录上次激活时
+            // 的能力清单——新装或 permissions 变更后向在线客户端推一条警告通知，
+            // 用户装前可见、日常启动不打扰。
+            void this.maybeConsentNotice(info, dir, permsDeclared);
         }
         catch (err) {
+            httpRoutes.clear();
             this.loaded.set(info.id, {
                 info: { ...info, error: err.message },
                 toolHandlers,
                 attachHandlers,
                 cwdHandlers,
+                httpRoutes,
+                settingsHandlers: new Set(),
             });
             console.error(`[plugin:${info.id}] activate failed:`, err);
         }

package/dist/server/settings-service.js

@@ -102,6 +102,7 @@ export class SettingsService {
                 terminalToolsEnabled: this.settings.terminalToolsEnabled,
                 terminalBash: this.settings.terminalBash,
                 terminalBashIdleMs: this.settings.terminalBashIdleMs,
+                thinkingWrap: this.settings.thinkingWrap,
                 visionBridgeEnabled: this.settings.visionBridgeEnabled,
                 visionBridgeModel: this.settings.visionBridgeModel,
                 visionBridgePromptMode: this.settings.visionBridgePromptMode,
@@ -170,6 +171,9 @@ export class SettingsService {
         if (partial.terminalBashIdleMs !== undefined) {
             this.settings.terminalBashIdleMs = Math.max(0, Math.floor(partial.terminalBashIdleMs) || 0);
         }
+        if (partial.thinkingWrap !== undefined) {
+            this.settings.thinkingWrap = partial.thinkingWrap;
+        }
         if (partial.visionBridgeEnabled !== undefined) {
             this.settings.visionBridgeEnabled = partial.visionBridgeEnabled;
         }
@@ -243,6 +247,8 @@ export class SettingsService {
             ],
             // Presets don't capture vision-bridge prefs — keep the current ones.
             visionBridgeEnabled: this.settings.visionBridgeEnabled,
+            // 纯 UI 偏好不进预设——保留当前值。
+            thinkingWrap: this.settings.thinkingWrap,
             visionBridgeModel: this.settings.visionBridgeModel,
             visionBridgePromptMode: this.settings.visionBridgePromptMode,
             visionBridgePrompt: this.settings.visionBridgePrompt,

package/dist/server/slash-commands.js

@@ -84,11 +84,26 @@ export class SlashCommandsService {
                     description: skill.description,
                     source: "skill",
                 });
+                seen.add(name);
             }
         }
         catch {
             // Session not ready yet — native-only catalog still serves the picker.
         }
+        // UI 插件注册的命令（host.registerCommand）——全局，不依赖会话就绪。
+        for (const cmd of this.host.pluginCommands?.() ?? []) {
+            if (seen.has(cmd.name))
+                continue; // 与内置/扩展重名时先到先得（内置优先）
+            commands.push({
+                name: cmd.name,
+                description: cmd.description,
+                descriptionEn: cmd.descriptionEn,
+                argumentHint: cmd.argumentHint,
+                argumentHintEn: cmd.argumentHintEn,
+                source: "plugin",
+            });
+            seen.add(cmd.name);
+        }
         this.host.emit({ type: "slash_commands", commands });
     }
     /** Run a native slash command (see NATIVE_COMMANDS). Returns false when the
@@ -241,7 +256,8 @@ export class SlashCommandsService {
                 // swallow here so the SDK never sees them as plain prompt text.
                 return true;
             default:
-                return false;
+                // 插件命令：拦截执行（纯配置动作，与内置命令同级，不到 SDK）。
+                return (await this.host.execPluginCommand?.(name, args)) ?? false;
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-web-ui",
-  "version": "0.36.0",
+  "version": "0.44.0",
   "description": "Web chat interface for the pi coding agent, powered by the pi SDK (@earendil-works/pi-coding-agent) — one-command run, Docker/systemd/launchd deployable",
   "license": "MIT",
   "type": "module",