pi-web-ui 0.35.1 → 0.43.0

package/bin/pi-web-ui.mjs

@@ -27,6 +27,12 @@
 import { spawnSync } from "node:child_process";
 import { createConnection } from "node:net";
 import { get as httpGet } from "node:http";
+import {
+	ensureBackup as ensurePluginBackup,
+	restoreBackup as restorePluginBackup,
+	checkPluginUpdates,
+	resolveRemoteSha,
+} from "../dist/server/plugin-updater.js";
 import {
 	chmodSync,
 	copyFileSync,
@@ -140,6 +146,8 @@ function parseFlags(argv) {
 		print: false,
 		noBrowser: false,
 		force: false,
+		checkUpdates: false,
+		rollback: undefined,
 		help: false,
 	};
 	const positionals = [];
@@ -178,6 +186,12 @@ function parseFlags(argv) {
 			case "--force":
 				opts.force = true;
 				break;
+			case "--check-updates":
+				opts.checkUpdates = true;
+				break;
+			case "--rollback":
+				opts.rollback = take("--rollback");
+				break;
 			case "--help":
 			case "-h":
 				opts.help = true;
@@ -1354,7 +1368,11 @@ const PLUGIN_HELP = `用法:
 install 选项:
   --name <id>       插件目录名/id（默认取仓库名或 manifest.id，仅限字母数字-_）
   --data-dir <dir>  数据目录（默认 ~/.pi-web 或 $PI_WEB_DATA_DIR）
-  --force           目标目录已存在时覆盖
+  --force           目标目录已存在时覆盖（覆盖前自动备份旧版本）
+
+plugins 选项:
+  --check-updates   逐个对比最近安装版本与远端 HEAD，列出可更新插件
+  --rollback <id>   回滚到最近一份更新前备份（<dataDir>/plugin-backups/）
 `;
 
 function pluginDataDir(opts) {
@@ -1498,6 +1516,7 @@ async function pluginInstallCmd(argv) {
 	const isLocal = existsSync(localCandidate);
 	const src = isLocal ? null : parsePluginSource(rawSpec);
 	const tmp = mkdtempSync(join(tmpdir(), "pi-web-ui-plugin-"));
+	let backupTs = null;
 	try {
 		let checkout;
 		try {
@@ -1532,6 +1551,9 @@ async function pluginInstallCmd(argv) {
 		if (existsSync(target)) {
 			if (!opts.force)
 				fail(`插件目录已存在：${target}\n  加 --force 覆盖，或用 --name <id> 换个名字。`);
+			// 更新前备份旧版本（<dataDir>/plugin-backups/<id>-<ts>/，保留最近 3 份），
+			// 失败时自动回滚。备份与安装同 filter：不带 .git/node_modules。
+			backupTs = ensurePluginBackup(pluginDataDir(opts), id, { source: rawSpec });
 			// 插件凭据/配置不因升级丢失：先取出旧 config.json，拷完新文件后原样放回
 			try {
 				prevConfig = readFileSync(join(target, CONFIG_NAME), "utf8");
@@ -1541,10 +1563,18 @@ async function pluginInstallCmd(argv) {
 			rmSync(target, { recursive: true, force: true });
 		}
 		mkdirSync(target, { recursive: true });
-		cpSync(pluginRoot, target, {
-			recursive: true,
-			filter: (s) => !/(^|[\\/])(\.git|node_modules)([\\/]|$)/.test(s),
-		});
+		try {
+			cpSync(pluginRoot, target, {
+				recursive: true,
+				filter: (s) => !/(^|[\\/])(\.git|node_modules)([\\/]|$)/.test(s),
+			});
+		} catch (err) {
+			// 拷贝失败 → 有备份则自动回滚，保持旧版本可用
+			if (backupTs && restorePluginBackup(pluginDataDir(opts), id)) {
+				fail(`插件更新失败：${err?.message ?? err}\n  已自动回滚到更新前版本。`);
+			}
+			fail(`插件更新失败：${err?.message ?? err}\n  （无可用备份，请重新 install --force）`);
+		}
 		if (prevConfig !== null && !existsSync(join(target, CONFIG_NAME))) {
 			writeFileSync(join(target, CONFIG_NAME), prevConfig);
 		}
@@ -1557,6 +1587,14 @@ async function pluginInstallCmd(argv) {
 		} catch {
 			/* 尽力而为：没有来源信息只是不显示更新按钮 */
 		}
+		// 记录本次安装的远端 sha（git ls-remote HEAD，离线也支持本地 git 源）：
+		// 供 `pi-web-ui plugins --check-updates` 对比更新。失败静默（无 sha = 保守可更新）。
+		try {
+			const sha = await resolveRemoteSha(rawSpec);
+			if (sha) writeFileSync(join(target, ".pi-git-sha"), sha + "\n");
+		} catch {
+			/* 尽力而为 */
+		}
 		console.log(
 			`✔ 已安装插件 ${id}${manifest.name && manifest.name !== id ? `（${manifest.name}）` : ""}${manifest.version ? ` v${manifest.version}` : ""}`,
 		);
@@ -1584,12 +1622,28 @@ function pluginUninstallCmd(argv) {
 }
 
 function pluginListCmd(argv) {
-	const { opts } = parseFlags(argv);
+	const { opts, positionals } = parseFlags(argv);
 	if (opts.help) {
 		console.log(PLUGIN_HELP);
 		return;
 	}
-	const pluginsDir = join(pluginDataDir(opts), "plugins");
+	const dataDir = pluginDataDir(opts);
+	// --rollback <id>：回滚到最近一份更新前备份
+	if (opts.rollback) {
+		const id = String(opts.rollback);
+		if (!PLUGIN_ID_RE.test(id)) fail(`非法插件 id: ${id}`);
+		const target = join(dataDir, "plugins", id);
+		if (!existsSync(target)) fail(`未安装插件 "${id}"（pi-web-ui plugins 查看已装列表）`);
+		const ts = restorePluginBackup(dataDir, id);
+		if (!ts) fail(`插件 "${id}" 没有更新备份（从未覆盖安装 / 备份已用完）`);
+		console.log(`✔ 已回滚插件 ${id} 到 ${ts} 的快照 —— 运行中的服务刷新浏览器后生效。`);
+		return;
+	}
+	// --check-updates：对比各插件记录的最后安装 sha 与远端 HEAD（git ls-remote）
+	if (opts.checkUpdates) {
+		return checkUpdatesCmd(dataDir).then(() => {});
+	}
+	const pluginsDir = join(dataDir, "plugins");
 	const rows = [];
 	let names = [];
 	try {
@@ -1613,6 +1667,34 @@ function pluginListCmd(argv) {
 	console.log(`已安装的界面插件（${pluginsDir}）:\n${rows.join("\n")}`);
 }
 
+async function checkUpdatesCmd(dataDir) {
+	console.log("检查界面插件更新（git ls-remote 对比最近安装版本）…\n");
+	let rows;
+	try {
+		rows = await checkPluginUpdates(dataDir);
+	} catch (err) {
+		fail(`更新检查失败：${err?.message ?? err}`);
+	}
+	if (rows.length === 0) {
+		console.log(`尚未安装任何带来源记录的界面插件（目录: ${join(dataDir, "plugins")}）`);
+		return;
+	}
+	let any = false;
+	for (const r of rows) {
+		const label = r.name && r.name !== r.id ? `${r.id}（${r.name}）` : r.id;
+		if (r.updatable) {
+			console.log(`  🔄 ${label}${r.version ? ` v${r.version}` : ""}  可更新（已装 ${r.localSha ?? "未知"} → 远端 ${r.remoteSha}）`);
+			console.log(`     更新: pi-web-ui install ${r.source} --name ${r.id} --force`);
+			any = true;
+		} else if (r.remoteSha) {
+			console.log(`  ✓ ${label}${r.version ? ` v${r.version}` : ""}  已是最新（${r.remoteSha}）`);
+		} else {
+			console.log(`  ? ${label}  ${r.error ?? "无法检查"}（来源: ${r.source}）`);
+		}
+	}
+	if (!any) console.log("\n全部插件均为最新版本。");
+}
+
 async function serverCmd(argv) {
 	const { opts, positionals } = parseFlags(argv);
 	if (opts.help) {

package/dist/server/agent-service.js

@@ -314,12 +314,20 @@ export class ClientSession {
         emit: (msg) => this.emit(msg),
         flushSnapshot: () => this.flushSnapshot(),
         isDisposed: () => this.disposed,
+        // 插件注册的常驻任务（host.registerBackgroundTask）并入同一「后台任务」面板。
+        pluginTasks: () => this.pluginBgTasksProvider?.() ?? [],
     });
     /** index.ts 注入（经 AgentService 拷贝到每个新会话）：把 SDK 工具执行事件转发给
      *  插件（PluginManager.emitToolEvent）。未设置时不做任何事。 */
     onToolEvent = undefined;
     /** index.ts 注入：读取插件当前注册的 AI 工具（attach 时拷贝到每个新会话）。 */
     pluginToolsProvider = undefined;
+    /** index.ts 注入：读取插件当前注册的斜杠命令（目录展示 + prompt 拦截执行）。 */
+    pluginCommandsProvider = undefined;
+    /** index.ts 注入：读取插件注册的常驻后台任务（并入 bg_servers 面板）。 */
+    pluginBgTasksProvider = undefined;
+    /** index.ts 注入：停止插件任务（kill_background_server with taskId）。 */
+    pluginStopBgTask = undefined;
     /** 上一轮注入会话的插件工具名集合（用于检测注销/移除）。 */
     appliedPluginToolNames = new Set();
     /** The active conversation (all session operations target it). */
@@ -1399,6 +1407,10 @@ export class ClientSession {
     }
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
+    /** 本客户端成功切换工作区（set_cwd）后触发，参数为新绝对路径。
+     *  attach 时由 AgentService 接到全局 onClientCwdChanged —— 编辑器等
+     *  工作区跟随型插件借此把根目录切到用户当前项目。 */
+    onCwdChanged = undefined;
     /** Ask the npm registry for the latest pi-web-ui version and report it. */
     async checkUpdate() {
         const current = ClientSession.currentAppVersion();
@@ -1510,6 +1522,27 @@ export class ClientSession {
         setThinking: (level) => this.setThinking(level),
         refreshSessions: () => this.refreshSessions(),
         afterReload: () => this.applyTerminalToolGating(this.session),
+        pluginCommands: () => this.pluginCommandsProvider?.() ?? [],
+        execPluginCommand: async (name, args) => {
+            const def = this.pluginCommandsProvider?.().find((c) => c.name === name);
+            if (!def)
+                return false;
+            try {
+                const result = await def.run(args, { clientId: this.clientId });
+                // 字符串返回值 → 通知条回显给发起人；富展示用 broadcast/sendTo。
+                if (typeof result === "string" && result.trim()) {
+                    this.emit({ type: "notice", level: "info", text: result });
+                }
+            }
+            catch (err) {
+                this.emit({
+                    type: "notice",
+                    level: "error",
+                    text: `插件命令 /${name} 执行失败：${err.message}`,
+                });
+            }
+            return true;
+        },
         onQuit: () => this.onQuit?.() ?? false,
     });
     /** Catalog push — index.ts get_commands / attach / cwd 切换等都会调用。 */
@@ -1775,8 +1808,33 @@ export class ClientSession {
     async listBgServers() {
         await this.bg.listAndPush();
     }
+    /** 插件任务集合变化时由宿主调用：重推一次 bg_servers（含插件任务）。 */
+    refreshBgTasks() {
+        this.bg.push();
+    }
+    /** 插件设置保存结果等需要从 index.ts 发 notice 时用（emit 是私有的）。 */
+    emitNotice(level, text) {
+        this.emit({ type: "notice", level, text });
+    }
     /** Kill ONE background server (by port); returns whether anything was killed. */
-    async killBackgroundServer(port) {
+    /** Kill ONE background server (by port) OR a plugin task (by taskId). */
+    async killBackgroundServer(port, taskId) {
+        if (taskId) {
+            // 插件任务：交给插件管理器 stop 回调（不杀进程树——任务在宿主进程内）。
+            const ok = this.pluginStopBgTask?.(taskId) ?? false;
+            if (!ok) {
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `后台任务「${taskId}」不存在或已结束`,
+                });
+            }
+            this.bg.push();
+            this.flushSnapshot();
+            return ok;
+        }
+        if (typeof port !== "number")
+            return false;
         return this.bg.killOne(port);
     }
     /** Kill every background server the agent started; returns the freed ports. */
@@ -1940,6 +1998,9 @@ export class ClientSession {
         // lifecycle. Removal is deferred until the new chat exists so the active
         // conversation stays valid during the (async) runtime creation.
         const displaced = this.displaceActive();
+        // Carry the model chosen in the active chat over to the new chat so it
+        // doesn't silently revert to the ModelRuntime default model.
+        const prevModel = this.conv.session.agent.state.model ?? null;
         try {
             const conversationId = this.nextConversationId();
             const terminals = this.makeTerminalManager(conversationId, this.cwd);
@@ -1954,6 +2015,16 @@ export class ClientSession {
             if (displaced)
                 this.removeConversation(displaced.id);
             await this.bindSession();
+            // New session seeds with the ModelRuntime default model — restore the
+            // model the user had selected in the previous chat.
+            if (prevModel && this.sharedModelRuntime) {
+                try {
+                    await this.session.setModel(prevModel);
+                }
+                catch {
+                    // model no longer resolvable — keep the default
+                }
+            }
             this.emitConversations();
             this.goalSvc.emitGoalStatus();
             this.pushTerminals();
@@ -2243,6 +2314,9 @@ export class ClientSession {
             return;
         }
         try {
+            // Preserve the model the user had selected — fork() seeds a new
+            // branch with the ModelRuntime default model otherwise.
+            const prevModel = this.session.agent.state.model ?? null;
             const result = await this.runtime.fork(entryId);
             if (result.cancelled) {
                 this.emit({
@@ -2254,6 +2328,15 @@ export class ClientSession {
                 return;
             }
             await this.bindSession();
+            // Restore the previously-selected model on the forked branch.
+            if (prevModel && this.sharedModelRuntime) {
+                try {
+                    await this.session.setModel(prevModel);
+                }
+                catch {
+                    // model no longer resolvable — keep the default
+                }
+            }
             await this.prompt(trimmed, attachments);
             this.emit({
                 type: "notice",
@@ -2408,6 +2491,13 @@ export class ClientSession {
             this.conv.promptedSinceActive = false;
             this.conv.lastActiveAt = Date.now();
             this.cwd = abs;
+            // 工作区跟随型插件（编辑器文件树等）同步切根。
+            try {
+                this.onCwdChanged?.(abs);
+            }
+            catch {
+                /* 钩子异常不影响主流程 */
+            }
             // Remember the new workspace (restore target + recent-project entry).
             this.stateStore.remember(this.clientId, abs);
             void this.pushProjects();
@@ -2597,6 +2687,12 @@ export class AgentService {
     onToolEvent = undefined;
     /** index.ts 注入：读取插件当前注册的 AI 工具（attach 时拷贝到每个新会话）。 */
     pluginToolsProvider = undefined;
+    /** index.ts 注入：读取插件当前注册的斜杠命令（attach 时拷贝到每个新会话）。 */
+    pluginCommandsProvider = undefined;
+    /** index.ts 注入：读取插件注册的常驻后台任务（并入 bg_servers 面板）。 */
+    pluginBgTasksProvider = undefined;
+    /** index.ts 注入：停止插件任务（kill_background_server with taskId）。 */
+    pluginStopBgTask = undefined;
     clients = new Map();
     /** Quiesce (draining) state — the service refuses NEW work (prompts, forks,
      *  session resumes, new clients) so a deploy/upgrade/backup can stop cleanly
@@ -2611,6 +2707,9 @@ export class AgentService {
     stateStore;
     /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
     onQuit = undefined;
+    /** 任意客户端成功切换工作区后触发（新绝对路径）。index.ts 接到
+     *  PluginManager.notifyCwd，让插件宿主的 host.cwd 实时跟随当前项目。 */
+    onClientCwdChanged = undefined;
     constructor(cwd, stateFile) {
         this.cwd = cwd;
         this.stateStore = new ClientStateStore(stateFile);
@@ -2725,7 +2824,14 @@ export class AgentService {
         cs.onQuit = this.onQuit;
         cs.onToolEvent = this.onToolEvent;
         cs.pluginToolsProvider = this.pluginToolsProvider;
+        cs.pluginCommandsProvider = this.pluginCommandsProvider;
+        cs.pluginBgTasksProvider = this.pluginBgTasksProvider;
+        cs.pluginStopBgTask = this.pluginStopBgTask;
         cs.isQuiesced = () => this.quiesced;
+        // 插件宿主工作区跟随：初次接入也同步一次（恢复的 lastCwd 可能≠服务启动目录），
+        // notifyCwd 幂等去重；此后 set_cwd 成功时由 cs.onCwdChanged 继续驱动。
+        cs.onCwdChanged = (abs) => this.onClientCwdChanged?.(abs);
+        this.onClientCwdChanged?.(cs.cwd);
         return cs;
     }
     /** 插件 AI 工具集合变化（注册/注销）时由 index.ts 触发：推送到所有客户端的全部会话。 */
@@ -2733,6 +2839,16 @@ export class AgentService {
         for (const cs of this.clients.values())
             cs.refreshPluginTools();
     }
+    /** 插件斜杠命令集合变化时由 index.ts 触发：重推各客户端的命令目录。 */
+    applyPluginCommandCatalog() {
+        for (const cs of this.clients.values())
+            void cs.pushSlashCommands();
+    }
+    /** 插件常驻后台任务变化时由 index.ts 触发：重推各客户端的 bg_servers。 */
+    refreshBackgroundServers() {
+        for (const cs of this.clients.values())
+            cs.refreshBgTasks();
+    }
     /** Remove a socket from a client's broadcast set (called on socket close). */
     detach(clientId, send) {
         this.clients.get(clientId)?.detachSink(send);

package/dist/server/attachments.js

@@ -1,5 +1,5 @@
 import { countLines, decodeText, looksLikeText, sniffImageMime, } from "./text-sniff.js";
-import { saveUpload } from "./uploads.js";
+import { saveUpload, uploadsRoot } from "./uploads.js";
 import { buildVisionBridgePrompt, findVisionModels, transcribeImages, } from "./vision-bridge.js";
 /** 跨快照的视觉转写缓存：批次 hash（名称 + base64 头 + 提示词）→ 转写文本。
  *  编辑重问重发相同图片不再重复耗视觉 token。进程级共享即可。 */
@@ -17,7 +17,7 @@ export async function buildAttachmentMessages(ctx, attachments) {
     if (!attachments || attachments.length === 0)
         return [];
     const fs = await import("node:fs/promises");
-    const { resolve, sep, relative, extname, join } = await import("node:path");
+    const { resolve, sep, relative, extname, join, basename } = await import("node:path");
     const root = resolve(ctx.cwd);
     const MAX_ATTACHMENT_BYTES = 200 * 1024;
     // Files at or below this size are inlined; larger files are referenced by
@@ -42,6 +42,57 @@ export async function buildAttachmentMessages(ctx, attachments) {
         ".svg": "image/svg+xml",
     };
     const out = [];
+    /** Push the aside for a raw uploaded file (fresh fileData or a restored
+     *  uploadPath re-read from disk). Small text files are inlined so the
+     *  model sees them immediately; everything else becomes a path reference.
+     *  `upload: true` marks the card as a restorable upload — the browser
+     *  re-sends it by path when editing & re-asking a question. */
+    const pushUploadAside = (name, wirePath, buf) => {
+        if (buf.length <= MAX_INLINE_BYTES && looksLikeText(buf)) {
+            const lines = countLines(buf);
+            out.push({
+                message: {
+                    customType: "file",
+                    content: [
+                        {
+                            type: "text",
+                            text: `\n<file path="${wirePath}">\n\`\`\`\n${decodeText(buf)}\n\`\`\`\n</file>`,
+                        },
+                    ],
+                    display: true,
+                    details: {
+                        name,
+                        path: wirePath,
+                        mode: "inline",
+                        size: buf.length,
+                        lines,
+                        upload: true,
+                    },
+                },
+            });
+        }
+        else {
+            out.push({
+                message: {
+                    customType: "file",
+                    content: [
+                        {
+                            type: "text",
+                            text: `<file path="${wirePath}" size="${buf.length}" />`,
+                        },
+                    ],
+                    display: true,
+                    details: {
+                        name,
+                        path: wirePath,
+                        mode: "reference",
+                        size: buf.length,
+                        upload: true,
+                    },
+                },
+            });
+        }
+    };
     // -- Vision bridge ------------------------------------------------------
     // When the active model can't accept images (DeepSeek, GLM, …), pasted
     // images are transcribed by a configured vision model first and the
@@ -288,48 +339,48 @@ export async function buildAttachmentMessages(ctx, attachments) {
             // Wire format: forward-slash absolute path (the read tool accepts
             // absolute paths; Windows uses "C:/..." — safe inside the XML-ish tag).
             const wirePath = abs.split(sep).join("/");
-            if (buf.length <= MAX_INLINE_BYTES && looksLikeText(buf)) {
-                const lines = countLines(buf);
-                out.push({
-                    message: {
-                        customType: "file",
-                        content: [
-                            {
-                                type: "text",
-                                text: `\n<file path="${wirePath}">\n\`\`\`\n${decodeText(buf)}\n\`\`\`\n</file>`,
-                            },
-                        ],
-                        display: true,
-                        details: {
-                            name: safeName,
-                            path: wirePath,
-                            mode: "inline",
-                            size: buf.length,
-                            lines,
-                        },
-                    },
+            pushUploadAside(safeName, wirePath, buf);
+            continue;
+        }
+        // Restored upload from edit-and-re-ask: the browser re-sends the
+        // server-generated absolute path of a previously uploaded (fileData)
+        // file instead of the original base64 (the fork drops the original
+        // aside card, so the bytes must be re-read from the uploads dir).
+        // Validate the path stays inside THIS client's uploads/ folder, then
+        // re-read the persisted bytes and attach by the same path — no
+        // re-save (the file already exists; retention sweeping governs its
+        // lifetime, same as the original card).
+        if (att.uploadPath) {
+            const rootDir = uploadsRoot();
+            const abs = resolve(rootDir, att.uploadPath);
+            const relToRoot = relative(rootDir, abs);
+            const inClientDir = !relToRoot.startsWith("..") &&
+                !relToRoot.includes(`${sep}..`) &&
+                (relToRoot === ctx.clientId ||
+                    relToRoot.startsWith(`${ctx.clientId}${sep}`));
+            if (!inClientDir) {
+                ctx.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `无法恢复已上传文件（路径不在本客户端上传目录）：${att.name ?? att.uploadPath}`,
                 });
+                continue;
             }
-            else {
-                out.push({
-                    message: {
-                        customType: "file",
-                        content: [
-                            {
-                                type: "text",
-                                text: `<file path="${wirePath}" size="${buf.length}" />`,
-                            },
-                        ],
-                        display: true,
-                        details: {
-                            name: safeName,
-                            path: wirePath,
-                            mode: "reference",
-                            size: buf.length,
-                        },
-                    },
+            let buf;
+            try {
+                buf = await fs.readFile(abs);
+            }
+            catch {
+                ctx.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `无法恢复已上传文件（已被清理或不可读）：${att.name ?? att.uploadPath}`,
                 });
+                continue;
             }
+            if (buf.length === 0)
+                continue;
+            pushUploadAside(att.name ?? basename(abs), abs.split(sep).join("/"), buf);
             continue;
         }
         const abs = resolve(root, att.path);

package/dist/server/bg-servers.js

@@ -69,9 +69,9 @@ export class BgServerTracker {
         if (added)
             this.push();
     }
-    /** The current background-server list, oldest first. */
+    /** The current background-server list, oldest first. 合并插件任务。 */
     list() {
-        return [...this.servers.entries()]
+        const out = [...this.servers.entries()]
             .map(([port, v]) => ({
             port,
             pid: v.pid,
@@ -80,6 +80,9 @@ export class BgServerTracker {
             ...(v.command ? { command: v.command } : {}),
         }))
             .sort((a, b) => a.since - b.since);
+        for (const t of this.opts.pluginTasks?.() ?? [])
+            out.push(t);
+        return out;
     }
     /** Push the current background-task list to every connected socket. */
     push() {

package/dist/server/index.js

@@ -36,6 +36,7 @@ import { scheduleUploadCleanup } from "./uploads.js";
 import { ensureWindowsBash, windowsBashDir } from "./ensure-bash.js";
 import { listThemes, resolveThemeFile } from "./themes.js";
 import { PluginManager, resolvePluginClientFile } from "./plugins.js";
+import { McpBridge } from "./mcp-bridge.js";
 const PORT = Number(process.env.PORT ?? 8787);
 const CWD = resolve(process.env.PI_WEB_CWD ?? process.cwd());
 const DATA_DIR = resolve(process.env.PI_WEB_DATA_DIR ?? join(homedir(), ".pi-web"));
@@ -216,6 +217,13 @@ app.get("/themes/:id.css", (req, res) => {
 // (which may hold credentials) never leave the machine. Registered BEFORE the
 // SPA catch-all below.
 const PLUGINS_DIR = join(DATA_DIR, "plugins");
+// 插件 HTTP 路由挂载点：host.route("GET", "/inbox") 实际暴露为
+// /plugins-api/<id>/inbox。PI_WEB_TOKEN 鉴权（上方 app.use）自动覆盖；
+// 响应已在前面过了 express.json。注意不要在此 catch-all 里消费 body。
+app.all(["/plugins-api/:id/*", "/plugins-api/:id"], (req, res) => {
+    const rest = String(req.params[0] ?? "");
+    pluginMgr.handleHttp(String(req.params.id ?? ""), req.method, rest, req, res);
+});
 app.get("/plugins/:id/client/*", (req, res) => {
     // express 4 的通配参数在运行时落在 params[0]，但类型声明里没有 —— 显式取
     const rest = String(req.params[0] ?? "");
@@ -368,12 +376,29 @@ join(DATA_DIR, "client-state.json"));
 // Optional UI plugins (<dataDir>/plugins/<id>/): scanned on every client
 // attach so freshly dropped plugins appear without a server restart.
 const pluginMgr = new PluginManager(DATA_DIR, CWD);
+// MCP 工具桥：读取 <dataDir>/mcp.json 启动外部 MCP 服务器（stdio），把它们的
+// 工具并入与插件工具相同的 customTools 管线；单服务器失败不炸进程。
+const mcpBridge = new McpBridge(DATA_DIR, (...a) => console.log("[mcp]", ...a));
+void mcpBridge.load().then(() => {
+    if (mcpBridge.getTools().length)
+        service.applyPluginAgentTools();
+});
 // 插件扩展点：SDK 工具执行事件（bash/读文件等 start+end）转发给已注册的插件。
 service.onToolEvent = (ev) => pluginMgr.emitToolEvent(ev);
-// 插件扩展点：插件注册的 AI 工具（registerAgentTool）→ 会话创建时带上 +
-// 变化时动态注入/移除已有会话。
-service.pluginToolsProvider = () => pluginMgr.getAgentTools();
+// 插件扩展点：插件注册的 AI 工具（registerAgentTool）+ MCP 桥工具 → 会话创建时
+// 带上 + 变化时动态注入/移除已有会话。
+service.pluginToolsProvider = () => [...pluginMgr.getAgentTools(), ...mcpBridge.getTools()];
 pluginMgr.onAgentToolsChanged = () => service.applyPluginAgentTools();
+// 插件扩展点：插件斜杠命令（registerCommand）→ 命令选择器目录 + prompt 拦截执行。
+pluginMgr.onCommandsChanged = () => service.applyPluginCommandCatalog();
+service.pluginCommandsProvider = () => pluginMgr.listCommands();
+// 插件扩展点：插件常驻后台任务（registerBackgroundTask）→ 并入「后台任务」面板。
+pluginMgr.onBgTasksChanged = () => service.refreshBackgroundServers();
+service.pluginBgTasksProvider = () => pluginMgr.bgTasks();
+service.pluginStopBgTask = (taskId) => pluginMgr.stopPluginBgTask(taskId);
+// 插件宿主工作区实时跟随当前项目：任意客户端 set_cwd 成功后同步给
+// PluginManager，编辑器等工作区跟随型插件随即切根（详见 plugins.ts notifyCwd）。
+service.onClientCwdChanged = (cwd) => pluginMgr.notifyCwd(cwd);
 // ---------------------------------------------------------------------------
 // Self-update
 // ---------------------------------------------------------------------------
@@ -509,7 +534,7 @@ wss.on("connection", (ws) => {
                 void cs.abortBash();
                 break;
             case "kill_background_server":
-                void cs.killBackgroundServer(msg.port);
+                void cs.killBackgroundServer(msg.port, msg.taskId);
                 break;
             case "kill_background_servers":
                 void cs.killAllBackgroundServers();
@@ -705,6 +730,16 @@ wss.on("connection", (ws) => {
             case "plugin_message":
                 pluginMgr.handleMessage(msg.pluginId, msg.payload, clientId ?? undefined);
                 break;
+            case "plugin_settings": {
+                const r = pluginMgr.savePluginSettings(msg.pluginId, msg.values ?? {});
+                if (r.error) {
+                    cs?.emitNotice("error", `插件设置保存失败：${r.error}`);
+                }
+                else {
+                    cs?.emitNotice("info", "插件设置已保存");
+                }
+                break;
+            }
             case "plugins_reload":
                 void pluginMgr.reload().then(() => pluginMgr.pushToAll());
                 break;
@@ -753,6 +788,9 @@ wss.on("connection", (ws) => {
                     // 让各插件向新接入的客户端推送自身初始状态（onAttach 钩子）——
                     // 插件不要依赖客户端挂载后自己拉（见 plugins.ts onAttach 注释）。
                     pluginMgr.notifyAttach(cid);
+                    // 插件命令可能在本客户端 attach 过程中才注册（首载竞态）——
+                    // 重推一次目录，保证选择器完整。
+                    service.applyPluginCommandCatalog();
                 })
                     .catch(() => { });
                 // Replay anything that arrived while the session was starting.
@@ -845,6 +883,7 @@ async function shutdown() {
     clearInterval(heartbeatTimer);
     stopControl();
     pluginMgr.dispose();
+    mcpBridge.dispose();
     await service.disposeAll();
     wss.close();
     httpServer.close();