pi-web-ui 0.86.2 → 0.87.0

package/dist/server/files-service.js

@@ -5,7 +5,8 @@
  * 全部为无状态 fs 操作 + 两个自持的 watcher（当前列出目录、git dir），
  * 经 FilesHost 回调与 ClientSession 解耦。
  */
-import { mkdirSync, statSync, writeFileSync, watch } from "node:fs";
+import { mkdirSync, readFileSync, statSync, writeFileSync, watch } from "node:fs";
+import { homedir } from "node:os";
 import { resolve, relative, sep } from "node:path";
 import { pick } from "./i18n.js";
 import { previewKind, looksLikeText, decodeText, hexDump, countLines } from "./text-sniff.js";
@@ -14,6 +15,36 @@ export const IS_WIN32 = process.platform === "win32";
 /** 机器根虚拟路径：工作区「上一级」到达此处，列出所有盘符（Windows）/ "/"（posix）。
  *  这是 wire 字面量，前端 web/src/components/{RightPanel,FooterBar}.tsx 里同值使用。 */
 export const MACHINE_ROOT = "@root";
+/** 桌面目录（wire 格式）：存在且为目录才返回，否则空串（前端不渲染 🖥️）。
+ *  Linux 优先读 XDG user-dirs（中文环境可能是 ~/桌面），其余平台即 ~/Desktop。 */
+export function desktopDirWire(homeWire) {
+    const cands = [];
+    if (process.platform === "linux") {
+        try {
+            const conf = readFileSync(resolve(homedir(), ".config", "user-dirs.dirs"), "utf8");
+            const m = /XDG_DESKTOP_DIR="([^"]+)"/.exec(conf);
+            if (m) {
+                const dir = m[1].replace(/\$HOME/g, homeWire);
+                if (dir.startsWith("/"))
+                    cands.push(dir);
+            }
+        }
+        catch {
+            // 无 XDG 配置就回落 ~/Desktop
+        }
+    }
+    cands.push(`${homeWire}/Desktop`);
+    for (const c of cands) {
+        try {
+            if (statSync(wireToAbs(c)).isDirectory())
+                return c;
+        }
+        catch {
+            // 不存在就试下一个
+        }
+    }
+    return "";
+}
 /** wire 路径统一用 "/"。绝对 = posix "/..."；win32 还有 "C:/..." / 裸 "C:"。
  *  机器浏览（越过工作区根换盘符）发送这些路径；工作区相对树不会产生它们（Windows
  *  文件名不能含 ":"，相对路径经 relative() 归一化后也不以 "/" 开头）。 */
@@ -918,6 +949,233 @@ export class FilesService {
             });
         }
     }
+    /* ---- 文件树右键菜单的文件操作（`contextmenu.file`，见 protocol.ts file_*） ---- */
+    /** 右键文件操作共用的路径解析：绝对 wire（机器浏览）直接转原生绝对路径；
+     *  相对路径限定在工作区内（越界 → null，与 readFile/writeFile 同口径）。
+     *  空串（工作区根须由调用方特判）与机器根 "@root" 本身不可作为操作对象 → null。 */
+    resolveOpTarget(raw) {
+        const wire = normWirePath(raw.trim());
+        if (!wire || wire === MACHINE_ROOT)
+            return null;
+        if (isAbsoluteWirePath(wire))
+            return { abs: wireToAbs(wire) };
+        const w = workspacePath(resolve(this.host.getCwd()), wire);
+        return w ? { abs: w.abs } : null;
+    }
+    /** 文件名清洗（与 uploadFile 同口径再收紧）：只取 basename，去 Windows 非法字符；
+     *  空/纯点/尾点空格/Windows 保留名 → null（建了删不掉的东西不如直接拒绝）。 */
+    sanitizeName(name) {
+        const base = name.split(/[\\/]/).pop() ?? "";
+        const safe = base
+            .replace(/[/:*?"<>|\x00-\x1f]/g, "_")
+            .trim()
+            .slice(0, 200);
+        if (!safe || safe === "." || safe === ".." || /[. ]$/.test(safe))
+            return null;
+        if (IS_WIN32 && /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i.test(safe))
+            return null;
+        return safe;
+    }
+    /** wire 路径的父目录（wire 字符串层面切分，保证 file_changed 与前端 currentPath 同形）。
+     *  工作区根 "" / 机器根 / posix 根 "/" / 盘符根 → null（这些不可重命名/删除/作复制源）。 */
+    wireParent(wire) {
+        const w = normWirePath(wire.trim());
+        if (!w || w === MACHINE_ROOT || w === "/" || /^[A-Za-z]:$/.test(w))
+            return null;
+        const i = w.lastIndexOf("/");
+        if (i < 0)
+            return ""; // 工作区相对单层 → 工作区根
+        if (i === 0)
+            return "/"; // "/a" → "/"
+        return w.slice(0, i);
+    }
+    /** destDir（wire，空串 = 工作区根）→ 原生绝对目录；不存在/非目录 → null（调用方报错）。 */
+    async resolveOpDir(dir) {
+        const fsp = await import("node:fs/promises");
+        if (!dir.trim())
+            return { abs: resolve(this.host.getCwd()), wire: "" };
+        const t = this.resolveOpTarget(dir);
+        if (!t)
+            return null;
+        const st = await fsp.stat(t.abs).catch(() => null);
+        if (!st?.isDirectory())
+            return null;
+        return { abs: t.abs, wire: normWirePath(dir.trim()) };
+    }
+    /** 在 dir 下新建空文件或空文件夹。已存在不覆盖（报错）；成功后对 dir 推 file_changed。 */
+    async createEntry(dir, name, kind) {
+        const err = (text, textEn) => this.host.emit({ type: "notice", level: "error", text, textEn });
+        try {
+            const fsp = await import("node:fs/promises");
+            const { join } = await import("node:path");
+            const safe = this.sanitizeName(name);
+            if (!safe) {
+                err(`文件名不合法：${name}`, `Invalid name: ${name}`);
+                return;
+            }
+            const target = await this.resolveOpDir(dir);
+            if (!target) {
+                err(`目录不存在或超出工作区：${dir || "根目录"}`, `Directory not found: ${dir || "root"}`);
+                return;
+            }
+            const abs = join(target.abs, safe);
+            if (await fsp.stat(abs).catch(() => null)) {
+                err(`已存在：${safe}`, `Already exists: ${safe}`);
+                return;
+            }
+            if (kind === "dir")
+                await fsp.mkdir(abs);
+            else
+                await fsp.writeFile(abs, "");
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: kind === "dir" ? `已新建文件夹：${safe}` : `已新建文件：${safe}`,
+                textEn: kind === "dir" ? `Folder created: ${safe}` : `File created: ${safe}`,
+            });
+            this.host.emit({ type: "file_changed", path: target.wire });
+        }
+        catch (e) {
+            err(`新建失败：${e.message}`, `Create failed: ${e.message}`);
+        }
+    }
+    /** 同目录内重命名（newName 只取 basename，不跨目录）。成功后对父目录推 file_changed。 */
+    async renameEntry(path, newName) {
+        const err = (text, textEn) => this.host.emit({ type: "notice", level: "error", text, textEn });
+        try {
+            const fsp = await import("node:fs/promises");
+            const { join, dirname } = await import("node:path");
+            const t = this.resolveOpTarget(path);
+            const parent = this.wireParent(path);
+            if (!t || parent === null) {
+                err(`此处不可重命名：${path}`, `Cannot rename here: ${path}`);
+                return;
+            }
+            const safe = this.sanitizeName(newName);
+            if (!safe) {
+                err(`新名称不合法：${newName}`, `Invalid name: ${newName}`);
+                return;
+            }
+            const dest = join(dirname(t.abs), safe);
+            if (await fsp.stat(dest).catch(() => null)) {
+                err(`已存在：${safe}`, `Already exists: ${safe}`);
+                return;
+            }
+            await fsp.rename(t.abs, dest);
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: `已重命名为：${safe}`,
+                textEn: `Renamed to: ${safe}`,
+            });
+            this.host.emit({ type: "file_changed", path: parent });
+        }
+        catch (e) {
+            err(`重命名失败：${e.message}`, `Rename failed: ${e.message}`);
+        }
+    }
+    /** 删除文件或目录（目录递归删）。工作区根/机器根/盘符根拒绝；成功后对父目录推 file_changed。 */
+    async deleteEntry(path) {
+        const err = (text, textEn) => this.host.emit({ type: "notice", level: "error", text, textEn });
+        try {
+            const fsp = await import("node:fs/promises");
+            const t = this.resolveOpTarget(path);
+            const parent = this.wireParent(path);
+            if (!t || parent === null) {
+                err(`此处不可删除：${path}`, `Cannot delete here: ${path}`);
+                return;
+            }
+            await fsp.rm(t.abs, { recursive: true, force: true });
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: `已删除：${path.split(/[\\/]/).pop() ?? path}`,
+                textEn: `Deleted: ${path.split(/[\\/]/).pop() ?? path}`,
+            });
+            this.host.emit({ type: "file_changed", path: parent });
+        }
+        catch (e) {
+            err(`删除失败：${e.message}`, `Delete failed: ${e.message}`);
+        }
+    }
+    /** 复制或移动（move=true 即剪切粘贴）。destDir 与源同目录即「创建副本」；
+     *  重名自动加 " copy" 后缀；目录搬进自身/子目录拒绝；跨盘移动回落为复制+删源。 */
+    async copyEntry(src, destDir, move) {
+        const err = (text, textEn) => this.host.emit({ type: "notice", level: "error", text, textEn });
+        try {
+            const fsp = await import("node:fs/promises");
+            const { join, basename, sep } = await import("node:path");
+            const s = this.resolveOpTarget(src);
+            const srcParent = this.wireParent(src);
+            if (!s || srcParent === null) {
+                err(`此处不可${move ? "移动" : "复制"}：${src}`, `Cannot ${move ? "move" : "copy"}: ${src}`);
+                return;
+            }
+            const target = await this.resolveOpDir(destDir);
+            if (!target) {
+                err(`目标目录不存在：${destDir || "根目录"}`, `Target directory not found: ${destDir || "root"}`);
+                return;
+            }
+            // 目录搬进自身或子目录 → 无限递归，必须拒绝（文件无此问题，但统一判一次）。
+            if (target.abs === s.abs || target.abs.startsWith(s.abs + sep)) {
+                err("不可复制/移动到自身或子目录", "Cannot copy/move into itself");
+                return;
+            }
+            const base = basename(s.abs);
+            let dest = join(target.abs, base);
+            if (!move)
+                dest = await this.dedupeCopyDest(dest);
+            else if (await fsp.stat(dest).catch(() => null)) {
+                err(`目标已存在：${base}`, `Already exists at target: ${base}`);
+                return;
+            }
+            const verb = move ? ["已移动", "Moved"] : ["已复制", "Copied"];
+            if (move) {
+                try {
+                    await fsp.rename(s.abs, dest);
+                }
+                catch (e) {
+                    // 跨盘/跨挂载点 rename 报 EXDEV → 回落复制+删源（与文件管理器同行为）。
+                    if (e.code !== "EXDEV")
+                        throw e;
+                    await fsp.cp(s.abs, dest, { recursive: true, force: false });
+                    await fsp.rm(s.abs, { recursive: true, force: true });
+                }
+            }
+            else {
+                await fsp.cp(s.abs, dest, { recursive: true, force: false });
+            }
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: `${verb[0]}：${base}`,
+                textEn: `${verb[1]}: ${base}`,
+            });
+            this.host.emit({ type: "file_changed", path: target.wire });
+            if (move && target.wire !== srcParent)
+                this.host.emit({ type: "file_changed", path: srcParent });
+        }
+        catch (e) {
+            err(`${move ? "移动" : "复制"}失败：${e.message}`, `${move ? "Move" : "Copy"} failed: ${e.message}`);
+        }
+    }
+    /** 副本目标去重："a.txt" → "a copy.txt" → "a copy 2.txt"…（目录/无后缀同理）。 */
+    async dedupeCopyDest(dest) {
+        const fsp = await import("node:fs/promises");
+        const { join, dirname, basename, extname } = await import("node:path");
+        if (!(await fsp.stat(dest).catch(() => null)))
+            return dest;
+        const dir = dirname(dest);
+        const base = basename(dest);
+        const ext = extname(base);
+        const stem = ext ? base.slice(0, -ext.length) : base;
+        for (let i = 1; i < 100; i++) {
+            const cand = join(dir, `${stem} copy${i === 1 ? "" : ` ${i}`}${ext}`);
+            if (!(await fsp.stat(cand).catch(() => null)))
+                return cand;
+        }
+        return join(dir, `${stem} copy ${Date.now()}${ext}`);
+    }
     /**
      * Path completion for the cwd input: expand ~/relative paths, list the parent
      * directory, and return prefix matches (dirs first, capped).

package/dist/server/index.js

@@ -44,6 +44,7 @@ import { PluginManager, resolvePluginClientFile, } from "./plugins.js";
 import { PluginInstaller } from "./plugin-installer.js";
 import { syncPluginCatalog } from "./plugin-catalog-sync.js";
 import { McpBridge } from "./mcp-bridge.js";
+import { createMcpHotReload } from "./mcp-hot-reload.js";
 /** 从 CLI 参数中取 flag 值：支持 --flag value 与 --flag=value 两种写法。
  *  让 `node dist/server/index.js --host 0.0.0.0 --port 9000` 这类直接启动也能生效，
  *  而不只是经由 bin/pi-web-ui.mjs 的 env 转发。bin 仍是主入口，此处仅作兜底。 */
@@ -223,8 +224,8 @@ if (AUTH_TOKEN) {
             : "unauthorized: PI_WEB_TOKEN required (?token=…)");
     });
 }
-/** 引擎选择：PI_WEB_ENGINE=pi|dsh（默认 pi）。重启生效。 */
-const ENGINE = process.env.PI_WEB_ENGINE === "dsh" ? "dsh" : "pi";
+/** 引擎选择：--engine pi|dsh > PI_WEB_ENGINE > 默认 pi。重启生效。 */
+const ENGINE = (cliFlag("--engine") ?? process.env.PI_WEB_ENGINE) === "dsh" ? "dsh" : "pi";
 /** PI_WEB_MANAGED=1: this instance is updated by whoever deploys it. */
 const MANAGED = isManaged();
 /** Who started this process: a platform service manager (launchd / systemd /
@@ -490,6 +491,12 @@ app.all(["/plugins-api/:id/*", "/plugins-api/:id"], (req, res) => {
 app.get("/plugins/:id/client/*", (req, res) => {
     // express 4 的通配参数在运行时落在 params[0]，但类型声明里没有 —— 显式取
     const rest = String(req.params[0] ?? "");
+    // 特权 DOM 门禁：声明了 dom 能力的插件，其 bundle 需用户逐个授权后才下发
+    // （同源 bundle 技术上拦不住 DOM 访问，门只能放在这里；见 server/plugin-dom.ts）。
+    if (pluginMgr.isDomBundleBlocked(String(req.params.id ?? ""))) {
+        res.status(403).end("dom access not granted (settings > plugins > grant)");
+        return;
+    }
     const abs = resolvePluginClientFile(PLUGINS_DIR, req.params.id, rest);
     if (!abs) {
         res.status(404).end("plugin not found");
@@ -733,12 +740,37 @@ pluginMgr.pathAccessRequester = (pluginId, dir, reason) => new Promise((resolve)
 });
 // 用户点了「允许」→ 授权表变了 → 立刻重推给所有在线客户端（设置面板「已授权目录」即时可见）。
 pluginMgr.onGrantsChanged = () => pushPluginGrants();
+/** 广播通知条给全部在线客户端（全局事件，不属于某个 ClientSession —— 如 mcp.json 坏）。 */
+function pushNoticeToAll(level, text, textEn) {
+    const payload = JSON.stringify({ type: "notice", level, text, textEn });
+    for (const client of wss.clients) {
+        if (client.readyState !== WebSocket.OPEN)
+            continue;
+        try {
+            client.send(payload);
+        }
+        catch {
+            /* 死连接：index.ts 自己会清理 */
+        }
+    }
+}
 // MCP 工具桥：读取 <dataDir>/mcp.json 启动外部 MCP 服务器（stdio），把它们的
 // 工具并入与插件工具相同的 customTools 管线；单服务器失败不炸进程。
 const mcpBridge = new McpBridge(DATA_DIR, (...a) => console.log("[mcp]", ...a));
+// mcp.json 热加载：保存文件即生效，改完不必再重启服务。两半都在这里收口 —— reload 换入
+// 新的服务器集合（只重启规格真变了的），applyPluginAgentTools 把新工具推给已有会话。
+const mcpHotReload = createMcpHotReload({
+    dataDir: DATA_DIR,
+    reload: () => mcpBridge.reload(),
+    onToolsChanged: () => service.applyPluginAgentTools(),
+    onNotice: (level, text, textEn) => pushNoticeToAll(level, text, textEn),
+    log: (...a) => console.log(...a),
+});
 void mcpBridge.load().then(() => {
     if (mcpBridge.getTools().length)
         service.applyPluginAgentTools();
+    // 播种在 load 之后：否则指纹可能记在 load 读到的版本之前，白重载一次。
+    mcpHotReload.start();
 });
 // 插件扩展点：SDK 工具执行事件（bash/读文件等 start+end）转发给已注册的插件。
 service.onToolEvent = (ev) => pluginMgr.emitToolEvent(ev);
@@ -761,6 +793,107 @@ service.pluginCommandsProvider = () => pluginMgr.listCommands();
 pluginMgr.onBgTasksChanged = () => service.refreshBackgroundServers();
 service.pluginBgTasksProvider = () => pluginMgr.bgTasks();
 service.pluginStopBgTask = (taskId) => pluginMgr.stopPluginBgTask(taskId);
+// ---------------------------------------------------------------------------
+// 插件扩展点 v2（并行任务在 server/plugins.ts 加 host.conversations/prompt/
+// steer/abortRun/chatWait/fs.watch/scm/bash/schedule/models/onStats/onStreaming/
+// net.fetch/events + conversationLister/conversationSearcher/conversationWriter/
+// runSteerer/runAborter/modelLister + emitStats/emitStreaming 注入点，web/ 侧加
+// plugin-host v8 与新 slot/kind/messageWidget）。本文件只做接线，不实现宿主方法
+// 本身：下面全是注入函数（读 service 现有逻辑组装数据），PluginManager 那边
+// 存在即用、不存在即跳过。约束：全部用 (pm as any).xxx 赋值 + typeof 防御，绝不
+// 假设 PluginManager 已有这些字段（并行任务可能还没合入）；每个注入内部再
+// try/catch，DSH 引擎（无 pluginClient/各 ForPlugins 方法）回退空列表或
+// {ok:false}，绝不抛错炸进程。
+// ---------------------------------------------------------------------------
+{
+    const pm = pluginMgr;
+    /** 挑一个客户端会话：标准 pi 引擎走 service.pluginClient()，DSH/未知引擎无此方法即 undefined。 */
+    const pickClient = () => {
+        try {
+            const svc = service;
+            return typeof svc.pluginClient === "function" ? svc.pluginClient() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // conversationLister：本客户端运行中对话 + 当前项目历史会话摘要，只读组装
+    // {id,title,cwd,kind,isStreaming}。无客户端/方法缺失回空数组（插件显示空态）。
+    pm.conversationLister = async () => {
+        try {
+            const cs = pickClient();
+            if (!cs)
+                return [];
+            const running = typeof cs.listRunningForPlugins === "function" ? cs.listRunningForPlugins() : [];
+            const history = typeof cs.listHistoryForPlugins === "function" ? await cs.listHistoryForPlugins(50) : [];
+            return [...running, ...history];
+        }
+        catch {
+            return [];
+        }
+    };
+    // conversationSearcher：复用 search_sessions 逻辑，返回前 N 个 {id,title}。
+    pm.conversationSearcher = async (query, limit) => {
+        try {
+            const cs = pickClient();
+            if (!cs || typeof cs.searchForPlugins !== "function")
+                return [];
+            return await cs.searchForPlugins(query, limit ?? 20);
+        }
+        catch {
+            return [];
+        }
+    };
+    // conversationWriter：向指定对话投递 prompt（复用 prompt 路径）；找不到对话回 {ok:false,error}。
+    pm.conversationWriter = async (id, text) => {
+        try {
+            const cs = pickClient();
+            if (!cs || typeof cs.writeForPlugins !== "function")
+                return { ok: false, error: "当前引擎不支持对话投递（仅标准 pi 引擎）" };
+            return await cs.writeForPlugins(id, text);
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    };
+    // modelLister：复用现有模型列表，映射 {id,provider,vision}。
+    pm.modelLister = async () => {
+        try {
+            const cs = pickClient();
+            if (!cs || typeof cs.listModelsForPlugins !== "function")
+                return [];
+            return await cs.listModelsForPlugins();
+        }
+        catch {
+            return [];
+        }
+    };
+    // runSteerer：复用 ClientSession.steerForPlugins（sendUserMessage + deliverAs:'steer'，
+    // 跨客户端查找由方法内部兜底）；DSH/未知引擎无此方法即 not supported。
+    pm.runSteerer = async (id, text) => {
+        try {
+            const cs = pickClient();
+            if (!cs || typeof cs.steerForPlugins !== "function")
+                return { ok: false, error: "not supported" };
+            return await cs.steerForPlugins(id, text);
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    };
+    // runAborter：有现成 abort 路径（interruptRun，卡住/空转强制重置语义继承）。
+    pm.runAborter = async (id) => {
+        try {
+            const cs = pickClient();
+            if (!cs || typeof cs.abortForPlugins !== "function")
+                return { ok: false, error: "not supported" };
+            return await cs.abortForPlugins(id);
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    };
+}
 // 插件宿主工作区实时跟随当前项目：任意客户端 set_cwd 成功后同步给
 // PluginManager，编辑器等工作区跟随型插件随即切根（详见 plugins.ts notifyCwd）。
 service.onClientCwdChanged = (cwd, roots) => {
@@ -912,6 +1045,9 @@ wss.on("connection", (ws) => {
             case "queue_remove":
                 cs.removeQueued(msg.kind, msg.text);
                 break;
+            case "draft_update":
+                cs.saveDraft?.(msg.sessionId, msg.text, msg.ts);
+                break;
             case "abort":
                 void cs.abort();
                 break;
@@ -931,7 +1067,7 @@ wss.on("connection", (ws) => {
                 void cs.listBgServers();
                 break;
             case "new_chat":
-                void cs.newChat();
+                void cs.newChat(msg.preset);
                 break;
             case "edit_message":
                 void cs.editMessage(msg.messageId, msg.text, msg.attachments);
@@ -1010,6 +1146,18 @@ wss.on("connection", (ws) => {
             case "upload_file":
                 void cs.uploadFile(msg.dirPath, msg.name, msg.data);
                 break;
+            case "file_create":
+                void cs.createEntry(msg.dir, msg.name, msg.kind);
+                break;
+            case "file_rename":
+                void cs.renameEntry(msg.path, msg.newName);
+                break;
+            case "file_delete":
+                void cs.deleteEntry(msg.path);
+                break;
+            case "file_copy":
+                void cs.copyEntry(msg.src, msg.destDir, msg.move);
+                break;
             case "list_models":
                 void cs.listModels();
                 break;
@@ -1080,6 +1228,21 @@ wss.on("connection", (ws) => {
             case "clear_provider_api_key":
                 void cs.clearProviderApiKey(msg.provider);
                 break;
+            case "provider_oauth_start":
+                cs.startProviderOAuth(msg.provider);
+                break;
+            case "provider_oauth_reply":
+                cs.replyProviderOAuth(msg.flowId, msg.promptId, msg.value);
+                break;
+            case "provider_oauth_cancel":
+                cs.cancelProviderOAuth(msg.flowId);
+                break;
+            case "list_provider_oauth_flows":
+                cs.listProviderOAuthFlows();
+                break;
+            case "provider_oauth_logout":
+                void cs.logoutProviderOAuth(msg.provider);
+                break;
             case "list_models_config":
                 void cs.listModelsConfig();
                 break;
@@ -1265,6 +1428,7 @@ wss.on("connection", (ws) => {
                     id: pluginId,
                     source: msg.source,
                     build: msg.build === true,
+                    noBuild: msg.noBuild === true,
                 }, {
                     lang: jobLang,
                     emit: (m) => send(m),
@@ -1305,6 +1469,22 @@ wss.on("connection", (ws) => {
                 }
                 break;
             }
+            case "plugin_dom_consent": {
+                void pluginMgr
+                    .setDomConsent(msg.pluginId, msg.granted === true)
+                    .then((r) => {
+                    if (r.error)
+                        cs?.emitNotice("warning", `DOM 授权失败：${r.error}`, `DOM consent failed: ${r.error}`);
+                    else if (r.changed)
+                        cs?.emitNotice("info", msg.granted === true
+                            ? `已授权插件「${msg.pluginId}」完全 DOM 访问`
+                            : `已撤销插件「${msg.pluginId}」完全 DOM 访问`, msg.granted === true
+                            ? `Granted full DOM access to plugin "${msg.pluginId}"`
+                            : `Revoked full DOM access from plugin "${msg.pluginId}"`);
+                })
+                    .catch(() => { });
+                break;
+            }
             case "plugin_path_revoke": {
                 const removed = pluginMgr.grants.revoke(typeof msg.pluginId === "string" ? msg.pluginId : undefined, typeof msg.path === "string" ? msg.path : undefined);
                 cs?.emitNotice("info", `已撤销 ${removed} 条插件目录授权`, `Revoked ${removed} plugin path grant(s)`);
@@ -1336,6 +1516,21 @@ wss.on("connection", (ws) => {
             case "dsh_patches_list":
                 void cs.listDshPatches?.();
                 break;
+            case "dsh_preset_list":
+                void cs.refreshAgentPresets?.();
+                break;
+            case "dsh_preset_select":
+                void cs.selectAgentPreset?.(msg.preset);
+                break;
+            case "dsh_preset_default":
+                void cs.setDefaultAgentPreset?.(msg.preset);
+                break;
+            case "dsh_permission_set":
+                void cs.setPermissionPreset?.(msg.preset);
+                break;
+            case "dsh_permission_default":
+                void cs.setDefaultPermissionPreset?.(msg.preset);
+                break;
             case "dsh_patches_rescan":
                 void cs.rescanDshPatches?.();
                 break;
@@ -1514,6 +1709,26 @@ httpServer.listen(PORT, HOST, () => {
 });
 // 上传文件保留期清理：启动扫一次 + 每 6 小时一次（best-effort，见 uploads.ts）
 scheduleUploadCleanup();
+// 开机目录预同步（issue #165）：PI_WEB_PLUGIN_CATALOG_URL 指向一份插件市场目录文档
+// （headless/预置场景，不开浏览器也能装插件）。只跑一次、失败只告警不阻断启动；
+// 条目逐条安装/更新（托管实例上安装会被安装器拒绝，但列表本身仍会更新）。
+const BOOT_CATALOG_URL = (process.env.PI_WEB_PLUGIN_CATALOG_URL ?? "").trim();
+if (BOOT_CATALOG_URL) {
+    void syncPluginCatalog(BOOT_CATALOG_URL, { install: true }, {
+        customCatalogPath: pluginMgr.customCatalogPath,
+        pluginsDir: join(DATA_DIR, "plugins"),
+        installer: pluginInstaller,
+        afterWrite: () => reloadPluginsAndPush(),
+    }).then((r) => {
+        if (!r.ok) {
+            console.warn(`[catalog] PI_WEB_PLUGIN_CATALOG_URL 同步失败（不阻断启动）: ${r.error}`);
+            return;
+        }
+        const bad = (r.installed ?? []).filter((i) => !i.ok);
+        console.log(`[catalog] PI_WEB_PLUGIN_CATALOG_URL 同步完成：安装 ${(r.installed ?? []).length - bad.length} 成功 / ${bad.length} 失败` +
+            (bad.length ? `：${bad.map((i) => `${i.id}(${i.error ?? "?"})`).join("；")}` : ""));
+    });
+}
 // Local control socket (status / quiesce / unquiesce) — same data dir the
 // CLI uses, so `pi-web-ui server status|quiesce|unquiesce` just works.
 const stopControl = startControlServer({ service, dataDir: DATA_DIR, port: PORT });
@@ -1527,6 +1742,7 @@ async function shutdown() {
     stopControl();
     pluginMgr.dispose();
     pluginInstaller.dispose();
+    mcpHotReload.dispose();
     mcpBridge.dispose();
     await service.disposeAll();
     wss.close();