@mrrisega/dsh-remote 0.6.7-beta.2 → 0.6.7-beta.3

package/README.md

@@ -30,6 +30,12 @@ dsh-remote 是一个轻量的**隧道模式**远程控制方案：电脑端运
 
 ## 0.6.7 速览（Windows 可用版）
 
+> **预发中**：先以 `0.6.7-beta.x` 发布在 npm `beta` 通道（`latest` 仍是 0.6.6），
+> 待 Windows 真机验证通过后转正式版。安装预发版：
+> `npx @mrrisega/dsh-remote@0.6.7-beta.3`；若 dsh web 已起不来，用
+> `npx @mrrisega/dsh-remote@0.6.7-beta.3 repair`（只修 profile，不联网）。
+
+
 0.6.6 及更早的插件半整套「服务状态 / 启停 / 重启」是按 macOS/Linux 写死的
 （launchctl / systemd / pgrep / ps / /bin/sh），**在 Windows 上安装一切正常、运行期必死**：
 面板红字「读取状态失败: process.getuid is not a function」、状态永远停在「查询中…」、
@@ -154,8 +160,16 @@ npx @mrrisega/dsh-remote setup --server wss://<你的域名>:端口 --key <访
   校验值用于登录，与加密密钥域分离（详见 [docs/e2ee-protocol.md](docs/e2ee-protocol.md)）。
 - 请**牢记账号密码**：修改/重置密码会使全部旧设备会话失效，且服务端不保存你的内容、
   无法代为解密旧会话；改密后需在电脑端面板重新登录并重启 bridge，手机端重新解锁。
-- 电脑端本机配置（`.dsh-config.json`，0600）会保存账号密码用于自动登录，等于该账号
+- 电脑端本机配置（`.dsh-config.json`）会保存账号密码用于自动登录，等于该账号
   内容的“解密权”，请妥善保护电脑；电脑被他人使用期间请退出登录。
+  - macOS / Linux：文件权限 **0600**（仅本人可读写）。
+  - Windows：**`0600` 在 Windows 上无效**（Windows 用 ACL，不是 POSIX 权限位）——
+    早期版本只写了 `mode: 0o600`，实测该文件拿到的仍是用户目录的**默认继承 ACL**，
+    等于没有这层保护。0.6.7-beta.3 起安装器/插件/bridge 都会显式收紧：`icacls` 断开继承、
+    只授予当前用户。若收紧失败（无 icacls / 权限异常），安装日志会明确告警，不会假装成功。
+  - 无论哪个平台：**不要把 `.dsh-remote` 目录交给备份/同步盘/他人排查**——
+    里面的 `.dsh-config.json`（明文账号密码）与 `.harness-cookie.json`（dsh web 会话 Cookie，
+    等于该会话的完整访问权）被复制走就等于把钥匙一起给了对方。发支持包前请先删除这两项。
 
 **边界与建议（如实告知）**
 

package/clients/dsh-remote/dsh-bridge.mjs

@@ -65,7 +65,7 @@ import WebSocket from "ws";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import { randomBytes, generateKeyPairSync, createHash } from "node:crypto";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { promisify } from "node:util";
@@ -200,10 +200,40 @@ function loadLocalConfig() {
   try { return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")); } catch { return {}; }
 }
 
+/**
+ * 把文件权限收紧到「只有本人可读写」。
+ *
+ * ⚠️ Windows 上 `{ mode: 0o600 }` 是**空操作**（Windows 用 ACL，不是 POSIX mode 位）：
+ * 实测 .dsh-config.json 拿到的是用户目录的默认**继承 ACL**（AreAccessRulesProtected=False），
+ * 也就是说代码里那句 0600 对 Windows 用户完全没效果 —— 而文件里是**明文账号密码**。
+ * 风险不在"同机他人可读"（默认 ACL 下其实读不到），而在**任何按文件复制的场景**
+ * （备份/同步盘/杀软上报/崩溃转储/用户发给作者的支持包）都会连钥匙一起被带走，
+ * 而文档里的"0600 请妥善保护"会让用户误以为 Windows 上已有这层保护。
+ * 这里显式断开继承、只授予当前用户；失败只警告一次，绝不影响主流程。
+ */
+let hardenWarned = false;
+function hardenFile(file) {
+  try { fs.chmodSync(file, 0o600); } catch { /* POSIX 上失败不致命 */ }
+  if (process.platform !== "win32") return;
+  const who = [process.env.USERDOMAIN, process.env.USERNAME].filter(Boolean).join("\\");
+  if (!who) return;
+  let r;
+  try {
+    r = spawnSync("icacls", [file, "/inheritance:r", "/grant:r", `${who}:F`],
+      { windowsHide: true, encoding: "utf8", timeout: 8000 });
+  } catch (e) { r = { status: -1, stderr: e.message }; }
+  if (r.status !== 0 && !hardenWarned) {
+    hardenWarned = true;
+    console.warn(`⚠️ 收紧文件权限失败（${who}）：${String(r.stderr || "").trim() || `icacls 退出码 ${r.status}`}`);
+    console.warn("   配置文件可能仍可被其它账户/备份工具读取，请自行确认其存放位置。");
+  }
+}
+
 function saveLocalConfig(cfg) {
   try {
     fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+    hardenFile(CONFIG_PATH); // Windows 上 mode 是空操作 → 显式收紧 ACL（内含明文账号密码）
   } catch (e) {
     console.warn(`[bridge] 无法写配置 ${CONFIG_PATH}: ${e.message}`);
   }

package/dsh-setup.mjs

@@ -257,6 +257,35 @@ const SERVICE_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/
 const INSTALL_SOURCE = String(process.env.DSH_BRIDGE_INSTALL_SOURCE || "").trim() || "npx";
 const INSTALL_VERSION = String(process.env.DSH_BRIDGE_INSTALL_VERSION || "").trim() || pkgVersion();
 
+/**
+ * 把文件权限收紧到「只有本人可读写」。
+ *
+ * ⚠️ Windows 上 `{ mode: 0o600 }` 是**空操作**（Windows 用 ACL，不是 POSIX mode 位）：
+ * 实测 .dsh-config.json 拿到的是用户目录的默认**继承 ACL**（AreAccessRulesProtected=False），
+ * 也就是说代码里那句 0600 对 Windows 用户完全没效果 —— 而文件里是**明文账号密码**。
+ * 风险不在"同机他人可读"（默认 ACL 下其实读不到），而在**任何按文件复制的场景**
+ * （备份/同步盘/杀软上报/崩溃转储/用户发给作者的支持包）都会连钥匙一起被带走，
+ * 而文档里的"0600 请妥善保护"会让用户误以为 Windows 上已有这层保护。
+ * 这里显式断开继承、只授予当前用户；失败只警告一次，绝不影响主流程。
+ */
+let hardenWarned = false;
+function hardenFile(file) {
+  try { fs.chmodSync(file, 0o600); } catch { /* POSIX 上失败不致命 */ }
+  if (process.platform !== "win32") return;
+  const who = [process.env.USERDOMAIN, process.env.USERNAME].filter(Boolean).join("\\");
+  if (!who) return;
+  let r;
+  try {
+    r = spawnSync("icacls", [file, "/inheritance:r", "/grant:r", `${who}:F`],
+      { windowsHide: true, encoding: "utf8", timeout: 8000 });
+  } catch (e) { r = { status: -1, stderr: e.message }; }
+  if (r.status !== 0 && !hardenWarned) {
+    hardenWarned = true;
+    console.warn(`⚠️ 收紧文件权限失败（${who}）：${String(r.stderr || "").trim() || `icacls 退出码 ${r.status}`}`);
+    console.warn("   配置文件可能仍可被其它账户/备份工具读取，请自行确认其存放位置。");
+  }
+}
+
 // ---------- 配置读写 ----------
 function loadConfig() {
   try { return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")); }
@@ -265,6 +294,7 @@ function loadConfig() {
 function saveConfig(cfg) {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  hardenFile(CONFIG_PATH); // Windows 上 mode 是空操作 → 必须显式收紧 ACL（内含明文账号密码）
 }
 
 // ---------- 公共配置（从服务端取域名，服务商可随时更换） ----------
@@ -754,7 +784,7 @@ await delay(1000);
 try { process.kill(PLAN.pid); } catch (e) {}
 const deadline = Date.now() + 30000;
 while (Date.now() < deadline && alive(PLAN.pid)) await delay(200);
-if (alive(PLAN.pid)) spawnSync("taskkill", ["/PID", String(PLAN.pid), "/T", "/F"], { windowsHide: true });
+if (alive(PLAN.pid)) spawnSync("taskkill", ["/PID", String(PLAN.pid), "/T", "/F"], { windowsHide: true, timeout: 8000 });
 let out = "ignore";
 try { out = openSync(PLAN.log, "a"); } catch (e) {}
 const child = spawn(PLAN.argv[0], PLAN.argv.slice(1), { detached: true, stdio: ["ignore", out, out], windowsHide: true });
@@ -1328,6 +1358,48 @@ function validatePatchBase(text) {
   return { ok: true, cleaned, insertedIds: ids };
 }
 
+/**
+ * patch 文本是否是「合法的顶层 YAML 数组文档」。
+ *
+ * 为什么必须判：dsh 侧解析 cordis.patch.yml 时**要求顶层是数组**，而
+ * **纯注释文档的 YAML 解析结果是 `null`（不是空数组）**，于是 dsh 直接启动失败：
+ *   `Error: dsh: overlay …/cordis.patch.yml must be a top-level YAML array of loader patch entries`
+ * 官方空 profile 模板（dsh-app-boot）正是「注释 + `[]`」——`[]` 这个占位符不能省。
+ * 现场（2026-09-18 Windows 用户实测）：卸载把插件条目摘掉后只剩顶部注释，dsh web 再也起不来。
+ */
+/** 顶层（无缩进）非注释行 = YAML 的结构行；缩进行属于上一条目。 */
+function patchStructuralLines(text) {
+  return String(text ?? "")
+    .split(/\r?\n/)
+    .map((l) => l.replace(/\s+$/, ""))
+    .filter((l) => l.trim() !== "" && !/^\s*#/.test(l) && !/^[ \t]/.test(l));
+}
+
+/** 是否是合法的顶层数组文档（`[]` 占位，或若干 `-` 开头的顶层条目）。 */
+function isPatchArrayDocument(text) {
+  const roots = patchStructuralLines(text);
+  return roots.length > 0 && roots.every((l) => l === "[]" || l.startsWith("-"));
+}
+
+/** 只有注释/空行 → YAML 解析成 null（不是空数组），必须补 `[]` 占位，否则 dsh 起不来。 */
+function needsArrayPlaceholder(text) {
+  return patchStructuralLines(text).length === 0;
+}
+
+/**
+ * 写回 patch 文档，并**保证结果仍是合法顶层数组**：条目被删光时补回 `[]` 占位。
+ * 卸载、摘 include、回滚都必须走这里 —— 任何一条写路径漏了这步，用户就会拿到
+ * 一个「dsh web 起不来且面板也进不去」的 profile（只能靠 CLI 自救）。
+ */
+function writePatchDocument(patchFile, text) {
+  const body = String(text ?? "").replace(/\s+$/, "") + "\n";
+  // ⚠️ 只在「一个结构行都不剩」时补 —— 不能因为"看起来不像数组"就乱补，
+  //    那会把本来好的文件写坏（把 `[]` 追加到已有 insert 块后面 → YAML 直接报错）。
+  const fixed = needsArrayPlaceholder(body) ? `${body}[]\n` : body;
+  writePatchAtomic(patchFile, fixed);
+  return fixed;
+}
+
 /** 安全写回 patch（原子：先写同目录临时文件再 rename，避免中途被打断留下半截文件）。 */
 function writePatchAtomic(patchFile, text) {
   const tmp = `${patchFile}.dsh-remote.tmp`;
@@ -1384,7 +1456,7 @@ function ensurePatchActivation(patchFile, pluginLocalDir, pkgFile, opts = {}) {
         const merged2 = `${base2.cleaned ? base2.cleaned + "\n" : ""}\n${want}\n`;
         const chk = parsePatchInsertIds(merged2);
         if (!chk.badLines.length && chk.ids.filter((id) => id === PLUGIN_ID).length === 1) {
-          writePatchAtomic(patchFile, merged2);
+          writePatchDocument(patchFile, merged2);
           console.log(`✅ 已同步激活行的 relayDir → ${wantDir}`);
           return { ok: true, changed: true, basePatch: original };
         }
@@ -1407,18 +1479,18 @@ function ensurePatchActivation(patchFile, pluginLocalDir, pkgFile, opts = {}) {
   if (check.badLines.length || check.ids.filter((id) => id === PLUGIN_ID).length !== 1) {
     return { ok: false, reason: "合并后的 patch 校验未通过（未做改动）", changed: false, basePatch: original };
   }
-  writePatchAtomic(patchFile, merged);
+  writePatchDocument(patchFile, merged);
   const after = fs.readFileSync(patchFile, "utf8");
   const verify = parsePatchInsertIds(after);
   if (verify.badLines.length || verify.ids.filter((id) => id === PLUGIN_ID).length !== 1) {
-    writePatchAtomic(patchFile, original); // 回滚
+    writePatchDocument(patchFile, original); // 回滚
     return { ok: false, reason: "写入后校验失败，已回滚", changed: false, basePatch: original };
   }
   removeBundleEntry(pkgFile); // 单一激活点：bundles 里不能再有本插件
   // 双保险：上面那次移除若没生效（并发写 package.json / 解析失败），**回滚本次 patch 行**，
   // 宁可退回 bundles 形态（需重启）也绝不留"两处激活"→ dsh web 启动会 duplicate id 崩掉。
   if (pkgBundles().length) {
-    writePatchAtomic(patchFile, original);
+    writePatchDocument(patchFile, original);
     return { ok: false, reason: "bundles 条目未能移除，已回滚 patch 行以免重复激活", changed: false, bundleOnly: true, basePatch: original };
   }
   return { ok: true, changed: true, basePatch: original };
@@ -1428,7 +1500,7 @@ function ensurePatchActivation(patchFile, pluginLocalDir, pkgFile, opts = {}) {
 function stripIncludeEntries(patchFile, patch, reason) {
   const next = stripPluginEntries(patch);
   if (next === patch) return false;
-  writePatchAtomic(patchFile, next);
+  writePatchDocument(patchFile, next);
   console.log(`✅ 已移除 ${patchFile} 中的冗余 include（${reason}；激活点必须唯一，避免重复 ID 崩溃）`);
   return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.7-beta.2",
+  "version": "0.6.7-beta.3",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",

package/packages/dsh-remote-web/lib/client.js

@@ -340,8 +340,35 @@ window.__ModuleLoader__.load({
     }
 
     // ── 宿主 API ────────────────────────────────────────────────────────────
-    function api(path, options) {
-      return fetch(path, options).then(function (res) {
+    /**
+     * 默认请求超时（0.6.7-beta.3 新增）。
+     * 背景（用户实测）：node 半一旦被同步子进程调用钉死（卸载时 spawnSync 卡在 schtasks 上），
+     * 请求**永远不会返回**，面板就对着一个永不结束的 spinner —— 用户只能猜。
+     * 现在超时后给出明确报错（并提示"这一步可能已经在后台完成了"），而不是无限转圈。
+     * 30s 足够覆盖最慢的正常路径（relay 6s + Windows 进程扫描 8s）。
+     */
+    var API_TIMEOUT_MS = 30000;
+    function api(path, options, timeoutMs) {
+      var opts = options || {};
+      var timer = null;
+      try {
+        if (typeof AbortController === "function") {
+          var ctrl = new AbortController();
+          var ms = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : API_TIMEOUT_MS;
+          timer = setTimeout(function () { try { ctrl.abort(); } catch (e) { /* 忽略 */ } }, ms);
+          opts = Object.assign({}, opts, { signal: ctrl.signal });
+        }
+      } catch (e) { /* 无 AbortController 的旧环境：退化为无超时（不阻断使用） */ }
+      var done = function () { if (timer) { clearTimeout(timer); timer = null; } };
+      return fetch(path, opts).catch(function (e) {
+        // AbortError → 换成用户能看懂的话（并说明服务端可能已经做完了）
+        if (e && (e.name === "AbortError" || /abort/i.test(String(e.message || "")))) {
+          var te = new Error("请求超时（面板等不到本机响应）。这一步可能已经在后台完成了 —— 请刷新页面查看；若 dsh web 无响应，重启一次 dsh web 即可。");
+          te.timeout = true;
+          throw te;
+        }
+        throw e;
+      }).finally(done).then(function (res) {
         return res.text().then(function (text) {
           var body = null;
           try { body = JSON.parse(text); } catch (e) { body = null; }
@@ -358,6 +385,10 @@ window.__ModuleLoader__.load({
     var post = function (path, data) {
       return api(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(data || {}) });
     };
+    /** 带自定义超时的 POST（用于卸载这类"可能拖住"的操作）。 */
+    var postWithTimeout = function (path, data, timeoutMs) {
+      return api(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(data || {}) }, timeoutMs);
+    };
 
     // ── 交流群（二维码由图层面板上传统一配置,node 半经公开配置下发） ─────────
     // 设置面板「加入交流群」按钮与用户反馈页都展示同一张码;未配置(qrcode 为空)→ 不展示任何入口。
@@ -1066,7 +1097,9 @@ window.__ModuleLoader__.load({
         if (!armed) { setArmed(true); return; }
         setUnBusy(true);
         setSelfMsg(null);
-        post("/dsh-remote/self/uninstall", {}).then(function (b) {
+        // 卸载：服务端现在"先卸插件、先回响应、慢活交子进程"，正常应在 1 秒内返回；
+        // 给 20s 上界，超时也要给用户一句能照做的话（而不是永久转圈）。
+        postWithTimeout("/dsh-remote/self/uninstall", {}, 20000).then(function (b) {
           if (b && b.ok) {
             setArmed(false);
             // 优先展示服务端 detail（含 bridge 自启动/配置目录的逐项清理结果与重启提示）；
@@ -1079,7 +1112,7 @@ window.__ModuleLoader__.load({
           }
         }).catch(function (e) {
           setArmed(false);
-          setSelfMsg({ kind: "err", text: "卸载失败：" + e.message });
+          setSelfMsg({ kind: e && e.timeout ? "warn" : "err", text: (e && e.timeout ? "" : "卸载失败：") + e.message });
         }).finally(function () { setUnBusy(false); });
       };
 

package/packages/dsh-remote-web/lib/index.js

@@ -20,11 +20,11 @@
 //   - 0.1.2+ ?token 浏览器鉴权会话代持（0.4.1 起）
 //
 // 不依赖任何第三方包：只使用 node 内置模块与 cordis 注入的 webServer 服务。
-import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync, accessSync, chmodSync, openSync, closeSync, readSync, fstatSync, rmSync, statSync, constants as fsConstants } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync, accessSync, chmodSync, openSync, closeSync, readSync, fstatSync, rmSync, renameSync, statSync, constants as fsConstants } from "node:fs";
 import { join, dirname, sep, delimiter } from "node:path";
 import { execSync, spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 /** 本插件在 host 侧的服务依赖。 */
@@ -86,6 +86,35 @@ const DEFAULT_RELAY_DIR = process.env.DSH_RELAY_DIR || join(homedir(), ".dsh-rem
 const DEFAULT_API = "https://n.risegao.cn:13443/relay-api";
 const DEFAULT_APP_URL = "https://n.risegao.cn:13443/app/";
 
+/**
+ * 把文件权限收紧到「只有本人可读写」。
+ *
+ * ⚠️ Windows 上 `{ mode: 0o600 }` 是**空操作**（Windows 用 ACL，不是 POSIX mode 位）：
+ * 实测 .dsh-config.json 拿到的是用户目录的默认**继承 ACL**（AreAccessRulesProtected=False），
+ * 也就是说代码里那句 0600 对 Windows 用户完全没效果 —— 而文件里是**明文账号密码**。
+ * 风险不在"同机他人可读"（默认 ACL 下其实读不到），而在**任何按文件复制的场景**
+ * （备份/同步盘/杀软上报/崩溃转储/用户发给作者的支持包）都会连钥匙一起被带走，
+ * 而文档里的"0600 请妥善保护"会让用户误以为 Windows 上已有这层保护。
+ * 这里显式断开继承、只授予当前用户；失败只警告一次，绝不影响主流程。
+ */
+let hardenWarned = false;
+function hardenFile(file) {
+  try { fs.chmodSync(file, 0o600); } catch { /* POSIX 上失败不致命 */ }
+  if (process.platform !== "win32") return;
+  const who = [process.env.USERDOMAIN, process.env.USERNAME].filter(Boolean).join("\\");
+  if (!who) return;
+  let r;
+  try {
+    r = spawnSync("icacls", [file, "/inheritance:r", "/grant:r", `${who}:F`],
+      { windowsHide: true, encoding: "utf8", timeout: 8000 });
+  } catch (e) { r = { status: -1, stderr: e.message }; }
+  if (r.status !== 0 && !hardenWarned) {
+    hardenWarned = true;
+    console.warn(`⚠️ 收紧文件权限失败（${who}）：${String(r.stderr || "").trim() || `icacls 退出码 ${r.status}`}`);
+    console.warn("   配置文件可能仍可被其它账户/备份工具读取，请自行确认其存放位置。");
+  }
+}
+
 // ---------- 小工具 ----------
 
 /** 执行 shell 命令，不抛异常，返回 { ok, stdout, stderr, code }。 */
@@ -334,6 +363,7 @@ function saveConfig(relayDir, cfg) {
   mkdirSync(dirname(configPathOf(relayDir)), { recursive: true });
   // mode 0o600：与 dsh-setup.mjs 一致（文件已存在时 writeFileSync 不改权限，显式 chmod 兜底）
   writeFileSync(configPathOf(relayDir), JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  hardenFile(configPathOf(relayDir)); // Windows 上 mode 是空操作 → 显式收紧 ACL（内含明文账号密码）
   try {
     chmodSync(configPathOf(relayDir), 0o600);
   } catch {
@@ -412,6 +442,7 @@ async function mintHarnessCookie(ctx, relayDir) {
     const out = { authority: `127.0.0.1:${port}`, cookie, mintedAt: Date.now() };
     mkdirSync(dirname(configPathOf(relayDir)), { recursive: true });
     writeFileSync(join(relayDir, HARNESS_COOKIE_FILE), JSON.stringify(out, null, 2), { mode: 0o600 });
+    hardenFile(join(relayDir, HARNESS_COOKIE_FILE)); // 会话 Cookie ≈ dsh web 的完整访问权，同样要收紧
     return true;
   } catch {
     return false;
@@ -1459,7 +1490,7 @@ const deadline = Date.now() + 30000;
 while (Date.now() < deadline && alive(PLAN.pid)) await delay(200);
 if (alive(PLAN.pid)) {
   logLine("旧进程 30s 未退出，改用 taskkill /T /F");
-  spawnSync("taskkill", ["/PID", String(PLAN.pid), "/T", "/F"], { windowsHide: true });
+  spawnSync("taskkill", ["/PID", String(PLAN.pid), "/T", "/F"], { windowsHide: true, timeout: 8000 });
   await delay(500);
 }
 
@@ -2302,7 +2333,7 @@ const PLUGIN_ID = "dsh-remote-web";
 const PLUGIN_LEGACY_IDS = ["dsh-remote-ui"];
 const PLUGIN_ALL_IDS = [PLUGIN_ID, ...PLUGIN_LEGACY_IDS];
 /** 插件自身发布版本（与 dsh-remote 根包同步递增）。 */
-const PLUGIN_VERSION = "0.6.7-beta.2";
+const PLUGIN_VERSION = "0.6.7-beta.3";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -2507,17 +2538,204 @@ function tailOf(filePath, lines = 24) {
   } catch { return ""; }
 }
 
+/**
+ * 判断 patch 文本是否是「合法的顶层 YAML 数组文档」。
+ *
+ * 为什么必须判（2026-09-18 Windows 用户实测的致命事故）：dsh 解析 cordis.patch.yml 时
+ * **要求顶层是数组**，而**纯注释文档的 YAML 解析结果是 `null` 而不是空数组**，于是 dsh 直接：
+ *   `Error: dsh: overlay …/cordis.patch.yml must be a top-level YAML array of loader patch entries`
+ * 官方空 profile 模板是「注释 + `[]`」——`[]` 这个占位符不能省。
+ * 卸载把插件条目摘掉后若只剩注释，用户就再也起不来 dsh web（面板也进不去，只能靠 CLI 自救）。
+ */
+/** 顶层（无缩进）非注释行 = YAML 的结构行；缩进行属于上一条目。 */
+function patchStructuralLines(text) {
+  return String(text ?? "")
+    .split(/\r?\n/)
+    .map((l) => l.replace(/\s+$/, ""))
+    .filter((l) => l.trim() !== "" && !/^\s*#/.test(l) && !/^[ \t]/.test(l));
+}
+
+/** 是否是合法的顶层数组文档（`[]` 占位，或若干 `-` 开头的顶层条目）。 */
+function isPatchArrayDocument(text) {
+  const roots = patchStructuralLines(text);
+  return roots.length > 0 && roots.every((l) => l === "[]" || l.startsWith("-"));
+}
+
+/** 只有注释/空行 → YAML 解析成 null（不是空数组），必须补 `[]` 占位，否则 dsh 起不来。 */
+function needsArrayPlaceholder(text) {
+  return patchStructuralLines(text).length === 0;
+}
+
+/** 摘掉本插件的 patch 条目：管理标记块 + 无标记的 `- insert:` 块（当前名与历史名都清）。 */
+function stripOwnEntriesFromPatch(patch) {
+  // ① 管理标记块（dsh-setup 写入的形式）
+  // 结尾标记后面可能还有残留文字（历史变体），用 [^\n]* 吃掉整行，避免留下半截内容
+  const out = String(patch ?? "").replace(/\n?# >>> dsh-remote-(?:web|ui)[^\n]*\n[\s\S]*?# <<< dsh-remote-(?:web|ui)[^\n]*\n?/g, "\n");
+  // ② 无标记的 insert 块（旧版 / 其它工具写入的形式，历史事故里出现过）。
+  //    只摘标记块是不够的：目录已删而 patch 仍引用 → dsh 插件树加载失败 → 整个 dsh web 起不来。
+  const lines = out.split("\n");
+  const kept = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (/^- insert:\s*$/.test(lines[i])) {
+      const block = [lines[i]];
+      let j = i + 1;
+      while (j < lines.length && (lines[j].startsWith(" ") || lines[j].startsWith("\t"))) { block.push(lines[j]); j += 1; }
+      if (PLUGIN_ALL_IDS.some((id) => new RegExp(`\\b${id}\\b`).test(block.join("\n")))) {
+        while (kept.length && /^\s*#/.test(kept[kept.length - 1])) kept.pop(); // 连带条目上方的说明注释
+        i = j;
+        continue;
+      }
+      kept.push(...block);
+      i = j;
+      continue;
+    }
+    kept.push(lines[i]);
+    i += 1;
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+/**
+ * 原子写回 patch，并保证结果仍是合法顶层数组：条目被删光时补回 `[]` 占位。
+ * ⚠️ 只在「一个结构行都不剩」时补 —— 不能因为"看起来不像数组"就乱补，
+ *    那会把本来好的文件写坏（例如把 `[]` 追加到已有 insert 块后面 → YAML 直接报错）。
+ */
+function writePatchDocument(patchFile, text) {
+  const body = String(text ?? "").replace(/\s+$/, "") + "\n";
+  const fixed = needsArrayPlaceholder(body) ? `${body}[]\n` : body;
+  const tmp = `${patchFile}.dsh-remote.tmp`;
+  writeFileSync(tmp, fixed);
+  renameSync(tmp, patchFile);
+  return fixed;
+}
+
+/**
+ * 「运行时清理助手」源码（卸载用；由插件生成、detached 执行）。
+ *
+ * 为什么必须是独立进程（2026-09-18 用户实测的僵死事故）：
+ *   uninstallRuntime() 里有 spawnSync("schtasks"/"powershell"/"taskkill")，同步子进程调用会把
+ *   **dsh web 的事件循环整个钉死** —— 不只是这一个请求不返回，手机端隧道、其它页面、所有 API
+ *   一起停摆，表现为「端口在听、连接建立、但永不响应」。而 spawnSync 的 timeout 在 Windows 上
+ *   **并不可靠**（实测被策略拦截的进程 18s+ 仍未返回），所以不能把 timeout 当设计依据：
+ *   真正的解法是不要把同步子进程调用留在宿主进程里。
+ *
+ * 助手做的是「宁可少做也不卡住」的有界清理：杀残留进程 → 删自启动 → 清配置目录，每步独立 try/catch。
+ */
+function buildRuntimeCleanupHelper(relayDir, protectedPath) {
+  const plan = JSON.stringify({
+    relayDir,
+    protectedPath: protectedPath || "",
+    platform: osPlatform(),
+    taskName: WIN_TASK_NAME,
+    pidFiles: [WATCHER_PID_FILE, BRIDGE_PID_FILE],
+    plistPath: join(homedir(), "Library", "LaunchAgents", "com.dshremote.bridge.plist"),
+    unitPath: join(homedir(), ".config", "systemd", "user", "dsh-bridge.service"),
+    log: join(tmpdir(), "dsh-remote-uninstall.log"),
+  });
+  return `// dsh-remote 自动生成：彻底卸载的「运行时清理」部分（独立进程执行，避免阻塞 dsh web）
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, sep } from "node:path";
+
+const PLAN = ${plan};
+// 与主进程一致的测试隔离开关：置位时**绝不做任何真实系统操作**（不碰 launchctl/systemctl/schtasks/taskkill），
+// 但仍清空配置目录 —— 否则用例会去动开发者本机真实的自启动服务（历史事故，见 setup-output 用例的护栏）。
+const SKIP_SYSTEM_OPS = process.env.DSH_RELAY_SKIP_SERVICE === "1";
+function log(m) { try { appendFileSync(PLAN.log, "\\n[" + new Date().toISOString() + "] " + m + "\\n"); } catch (e) { /* 日志失败不阻断清理 */ } }
+function run(cmd, args, timeout) {
+  try { const r = spawnSync(cmd, args, { windowsHide: true, encoding: "utf8", timeout }); return r.status === 0; }
+  catch (e) { log("命令失败 " + cmd + ": " + e.message); return false; }
+}
+function alive(pid) { try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; } }
+function readPid(name) {
+  try { const n = Number(String(readFileSync(join(PLAN.relayDir, name), "utf8")).trim()); return Number.isInteger(n) && n > 0 ? n : null; }
+  catch (e) { return null; }
+}
+log("运行时清理开始（platform=" + PLAN.platform + "，relayDir=" + PLAN.relayDir + "）");
+if (SKIP_SYSTEM_OPS) log("测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过一切真实系统操作");
+
+// ① 结束 watcher / bridge 残留进程
+for (const name of (SKIP_SYSTEM_OPS ? [] : PLAN.pidFiles)) {
+  const pid = readPid(name);
+  if (!pid || pid === process.pid) continue;
+  if (!alive(pid)) { log(name + " 里的 pid " + pid + " 已不在"); continue; }
+  if (PLAN.platform === "win32") run("taskkill", ["/PID", String(pid), "/T", "/F"], 8000);
+  else { try { process.kill(pid, "SIGTERM"); } catch (e) { /* 已退出 */ } }
+  log("已结束 " + name + " 的进程 pid=" + pid);
+}
+
+// ② 移除自启动（按平台）
+if (SKIP_SYSTEM_OPS) {
+  log("跳过自启动清理（测试隔离）");
+} else if (PLAN.platform === "win32") {
+  run("schtasks", ["/Delete", "/TN", PLAN.taskName, "/F"], 15000);
+  log("已请求删除登录任务 " + PLAN.taskName);
+} else if (PLAN.platform === "darwin") {
+  if (existsSync(PLAN.plistPath)) {
+    run("launchctl", ["bootout", "gui/" + (typeof process.getuid === "function" ? process.getuid() : 0) + "/com.dshremote.bridge"], 8000);
+    try { rmSync(PLAN.plistPath, { force: true }); } catch (e) { /* 非关键 */ }
+    log("已移除自启动 plist");
+  }
+} else if (PLAN.platform === "linux") {
+  run("systemctl", ["--user", "stop", "dsh-bridge"], 8000);
+  run("systemctl", ["--user", "disable", "dsh-bridge"], 8000);
+  try { if (existsSync(PLAN.unitPath)) rmSync(PLAN.unitPath, { force: true }); } catch (e) { /* 非关键 */ }
+  log("已移除 systemd 用户服务");
+}
+
+// ③ 清空配置目录（账号/密钥/会话 cookie/固化运行时）——安全护栏与主进程一致
+try {
+  const isRoot = dirname(PLAN.relayDir) === PLAN.relayDir;
+  const isHome = PLAN.relayDir === homedir();
+  const hitsProfile = Boolean(PLAN.protectedPath) && (
+    PLAN.relayDir === PLAN.protectedPath
+    || PLAN.relayDir.startsWith(PLAN.protectedPath + sep)
+    || PLAN.protectedPath.startsWith(PLAN.relayDir + sep));
+  if (PLAN.relayDir && !isRoot && !isHome && !hitsProfile && existsSync(PLAN.relayDir)) {
+    rmSync(PLAN.relayDir, { recursive: true, force: true });
+    log("已清空配置目录");
+  } else {
+    log("跳过配置目录清理（护栏命中或目录不存在）");
+  }
+} catch (e) { log("配置目录清理失败: " + e.message); }
+log("运行时清理结束");
+`;
+}
+
+/**
+ * 把「运行时清理」交给一个 detached 子进程（不阻塞宿主事件循环）。
+ * @returns {{ok:boolean, pid:number|null, log:string, detail:string}}
+ */
+function spawnRuntimeCleanupDetached(relayDir, protectedPath) {
+  const logPath = join(tmpdir(), "dsh-remote-uninstall.log");
+  try {
+    // 助手放**系统临时目录**而不是 relayDir：它自己就要删 relayDir，
+    // 把正在运行的脚本放在待删目录里既别扭又可能在 Windows 上因文件占用而失败。
+    const helperPath = join(tmpdir(), `dsh-remote-uninstall-${process.pid}-${Date.now()}.mjs`);
+    writeFileSync(helperPath, buildRuntimeCleanupHelper(relayDir, protectedPath));
+    const { child, error } = safeSpawn(process.execPath, [helperPath], {
+      detached: true, cwd: homedir(), stdio: "ignore", windowsHide: true,
+      onError: (e) => console.warn(`[dsh-remote-web] 运行时清理子进程启动失败: ${e.message}`),
+    });
+    if (error || !child) {
+      return { ok: false, pid: null, log: logPath, detail: (error || new Error("spawn 未返回子进程")).message };
+    }
+    child.unref();
+    return { ok: true, pid: child.pid, log: logPath, detail: "已在后台清理" };
+  } catch (e) {
+    return { ok: false, pid: null, log: logPath, detail: e.message };
+  }
+}
+
 /** 彻底卸载第 2 步 —— profile 插件清理（兼容市场“拒绝改写用户补丁”）：移除 include、依赖、bundle、本地目录与链接。 */
 function uninstallSelf(relayDir, profileDir, patchFile, pkgFile) {
   const out = { removedPatch: false, removedDep: false, removedDir: false, removedBundle: false };
   try {
     const patch = readFileSync(patchFile, "utf8");
-    // 兼容当前与历史（dsh-remote-ui）两种管理标记
-    const cleaned = patch
-      .replace(/\n?# >>> dsh-remote-(?:web|ui) .*?# <<< dsh-remote-(?:web|ui)\s*/s, "\n")
-      .replace(/\n{3,}/g, "\n\n")
-      .trimEnd() + "\n";
-    if (cleaned !== patch) { writeFileSync(patchFile, cleaned); out.removedPatch = true; }
+    const cleaned = stripOwnEntriesFromPatch(patch); // 兼容当前与历史（dsh-remote-ui）两种名
+    if (cleaned !== patch) { writePatchDocument(patchFile, cleaned); out.removedPatch = true; }
   } catch { /* 无 patch 忽略 */ }
   try {
     const pkg = JSON.parse(readFileSync(pkgFile, "utf8"));
@@ -3571,30 +3789,47 @@ function registerRoutes(ctx, relayDir) {
       method: "POST",
       path: "/dsh-remote/self/uninstall",
       handler: async (_req, res) => {
-        // 彻底卸载 = ① 运行时/bridge 清理（停自启动 → 杀残留 → 清空配置目录，顺序防 KeepAlive 复活）
-        //           + ② 插件 profile 清理（include 块/依赖/bundle/本地目录与链接，解锁市场卸载）
-        const rt = uninstallRuntime(relayDir, profileDir);
-        const prof = uninstallSelf(relayDir, profileDir, join(profileDir, "cordis.patch.yml"), join(profileDir, "package.json"));
-        // 卸载后本进程内（直到重启）自愈/代持调度一律停摆，不再重建配置目录或拉起 bridge
+        // 彻底卸载 = ① 插件 profile 清理（快、纯 fs、可预期）② 运行时/bridge 清理（慢、要调外部命令）
+        //
+        // ⚠️ 顺序是刻意的，别改回去（2026-09-18 用户实测的僵死事故）：
+        //   旧实现把**慢的** uninstallRuntime 排在最前、uninstallSelf 排在其后，于是
+        //   uninstallRuntime 里任何一次 spawnSync 卡住（Windows 沙箱拦 schtasks，而 spawnSync 的
+        //   timeout 在 Windows 上并不可靠，实测 18s+ 未返回），uninstallSelf 就**永远不执行**
+        //   → 用户看到「点了卸载、插件纹丝不动」，而且整个 dsh web 僵死（端口在听、无响应）。
+        //   现在：先做真正"卸载掉插件"的部分 → 立刻关掉自愈 → 立刻回响应 → 慢步骤交独立子进程。
+        let prof = { removedPatch: false, removedDep: false, removedBundle: false, removedDir: false };
+        try {
+          prof = uninstallSelf(relayDir, profileDir, join(profileDir, "cordis.patch.yml"), join(profileDir, "package.json"));
+        } catch (e) {
+          console.warn(`[dsh-remote-web] 卸载插件引用失败: ${e.message}`);
+        }
+        // 必须在慢步骤之前置位：否则慢步骤期间自愈有机会把 bridge / 配置目录再拉回来
         markUninstalled(relayDir);
+        // 运行时清理交给独立进程：宿主事件循环绝不做同步子进程调用
+        const cleanup = spawnRuntimeCleanupDetached(relayDir, profileDir);
+        const cleanupMode = cleanup.ok ? "deferred" : "in-process";
         const bits = [];
         if (prof.removedPatch || prof.removedDep || prof.removedBundle || prof.removedDir) bits.push("插件引用与本地文件已移除");
-        if (rt.stoppedService) bits.push("bridge 自启动服务已停止");
-        if (rt.removedPlist) bits.push("自启动项已删除");
-        if (rt.killedPids.length) bits.push(`已结束 ${rt.killedPids.length} 个残留进程`);
-        if (rt.removedDir) bits.push("配置目录已清空（账号/密钥/固化运行时等）");
+        bits.push(cleanup.ok
+          ? "bridge 自启动项与本地配置目录（账号/密钥/固化运行时等）正在后台清理"
+          : `bridge 自启动项与配置目录的后台清理未能启动（${cleanup.detail}），已改在本进程内清理`);
         bits.push("请重启 dsh web 后完全卸载生效（本插件与「远程访问」面板将消失）；如需再次使用，在插件市场重新安装即可。");
         sendJson(res, 200, {
           ok: true,
           ...prof, // removedPatch / removedDep / removedBundle / removedDir(profile 插件目录)
-          servicePlatform: rt.servicePlatform,
-          stoppedService: rt.stoppedService,
-          removedPlist: rt.removedPlist,
-          killedPids: rt.killedPids,
-          relayDirRemoved: rt.removedDir, // 配置目录 relayDir 已整目录清空
+          runtimeCleanup: cleanupMode,
+          cleanupLog: cleanup.log,
           relayDir,
           detail: bits.join("；"),
         });
+        // 兜底：助手起不来（relayDir 不可写 / node 起不来）时才在进程内清理。
+        // **必须放在响应之后**：这条路径会阻塞事件循环，绝不能让用户先等它。
+        if (!cleanup.ok) {
+          setTimeout(() => {
+            try { uninstallRuntime(relayDir, profileDir); }
+            catch { /* 非致命：残留可由用户手动清理 */ }
+          }, 50).unref?.();
+        }
       },
     },
     {

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.7-beta.2",
+  "version": "0.6.7-beta.3",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/packages/dsh-remote-web/test/self-manage.test.mjs

@@ -155,6 +155,16 @@ test("残留 marker 自愈：记录进程已死的 marker 在插件启动时立
   }
 });
 
+/** 等待条件成立：运行时清理现在是独立子进程，物理结果要等它跑完。 */
+async function waitFor(fn, { timeout = 10000, step = 50 } = {}) {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    if (await fn()) return true;
+    if (Date.now() > deadline) return false;
+    await new Promise((r) => setTimeout(r, step));
+  }
+}
+
 test("uninstall 路由：移除 include 块 + package.json 依赖/bundle + 本地目录（解锁市场卸载）", async () => {
   const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-home-"));
   const relayDir = path.join(tempHome, "relay");
@@ -189,13 +199,12 @@ test("uninstall 路由：移除 include 块 + package.json 依赖/bundle + 本
       assert.equal(r.removedBundle, true, "应移除 dsh.profile.bundles 条目");
       assert.equal(r.removedDir, true, "应删除本地插件目录与 node_modules 链接");
 
-      // 运行时/bridge 清理（隔离模式下只清空配置目录，绝不触碰真实 launchd 服务）
-      assert.equal(r.relayDirRemoved, true, "配置目录 relayDir 应被整目录清空");
-      assert.equal(r.stoppedService, false, "DSH_RELAY_SKIP_SERVICE=1 → 不做真实服务操作");
-      assert.equal(r.removedPlist, false, "DSH_RELAY_SKIP_SERVICE=1 → 不删自启动 plist");
-      assert.deepEqual(r.killedPids, [], "DSH_RELAY_SKIP_SERVICE=1 → 不杀进程");
-      assert.equal(existsSync(relayDir), false, "relayDir 物理上应已不存在");
-      assert.match(String(r.detail), /配置目录已清空/, "detail 应说明配置目录已清空");
+      // 运行时/bridge 清理：0.6.7-beta.3 起交给**独立子进程**（先回响应，慢活不阻塞事件循环），
+      // 所以这里断言响应契约 + 轮询等它的物理结果（隔离模式下只清空配置目录，绝不触碰真实 launchd 服务）
+      assert.equal(r.runtimeCleanup, "deferred", "运行时清理应由子进程接管");
+      const gone = await waitFor(() => !existsSync(relayDir));
+      assert.equal(gone, true, "relayDir 物理上应已不存在（子进程执行）");
+      assert.match(String(r.detail), /正在后台清理/, "detail 应说明后台清理");
       assert.match(String(r.detail), /请重启 dsh web/, "detail 应提示重启生效");
 
       const patch = await readFile(patchFile, "utf8");

package/packages/dsh-remote-web/test/uninstall-runtime.test.mjs

@@ -2,8 +2,12 @@
 // 背景：用户反馈卸载不干净——bridge 自启动服务（launchd com.dshremote.bridge / Linux dsh-bridge）
 //       仍在运行、自启动 plist/unit 仍在、配置目录 ~/.dsh-remote（账号/设备密钥/.dsh-config.json/
 //       .harness-cookie.json/固化运行时 dsh-setup.mjs + clients 等）也还在。
-// 卸载路由现在依次执行：profile 插件清理（uninstallSelf，原逻辑）+ 运行时清理（uninstallRuntime：
-// 停自启动服务 → 删自启动文件 → 杀残留进程 → rm -rf 配置目录），全部幂等、单项失败不致命。
+// 0.6.7-beta.3 起卸载**分两段**（顺序是刻意的，见 uninstall 路由注释）：
+//   ① 同步段：uninstallSelf（纯 fs、快）→ markUninstalled → 立刻回响应；
+//   ② 异步段：运行时清理（停自启动/杀残留/清配置目录）交给**独立子进程**执行。
+// 为什么必须这样：同步段里任何一次 spawnSync 卡住（Windows 沙箱拦 schtasks，而 spawnSync 的
+// timeout 在 Windows 上并不可靠），旧实现会让 uninstallSelf 永远不执行、整个 dsh web 僵死
+// （端口在听、无响应）。因此这些用例改为：断言响应契约（runtimeCleanup）+ 轮询等待子进程的物理结果。
 // 测试隔离（绝不触碰本机真实 launchd/systemd/进程）：
 //   - 大多数用例设 DSH_RELAY_SKIP_SERVICE=1 → 跳过一切系统级操作，只验证配置目录清理与 profile 清理；
 //   - 「自然跳过」用例把 PATH 指向假 launchctl/pgrep/ps，完全接管系统命令后走无开关路径。
@@ -23,6 +27,18 @@ const PLUGIN_BLOCK = `# >>> dsh-remote-ui (managed by dsh-remote plugin; do not
 # <<< dsh-remote-ui
 `;
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** 等待条件成立：运行时清理现在是独立子进程，物理结果要等它跑完（而不是同步返回）。 */
+async function waitFor(fn, { timeout = 10000, step = 50 } = {}) {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    if (await fn()) return true;
+    if (Date.now() > deadline) return false;
+    await sleep(step);
+  }
+}
+
 /** 加载插件（要求调用方已把 process.env.HOME 指向 tempHome；profile 推导才落在 temp 而非真实 ~/.dsh）。 */
 function boot(relayDir) {
   const routes = new Map();
@@ -96,14 +112,11 @@ test("彻底卸载：配置目录整目录清空（含账号/密钥/固化运行
       assert.equal(r.removedDep, true);
       assert.equal(r.removedBundle, true);
       assert.equal(r.removedDir, true, "profile 插件目录与 node_modules 链接应删除");
-      // 运行时清理标志位
-      assert.equal(r.relayDirRemoved, true, "relayDir 应被整目录清空");
-      assert.equal(r.servicePlatform, "launchd", "macOS 下 servicePlatform=launchd");
-      assert.equal(r.stoppedService, false, "DSH_RELAY_SKIP_SERVICE=1 → 不触碰真实 launchd 服务");
-      assert.equal(r.removedPlist, false);
-      assert.deepEqual(r.killedPids, []);
-      // 物理断言：relayDir 与其中全部残留都消失
-      assert.equal(existsSync(relayDir), false, "relayDir 目录应整体不存在");
+      // 运行时清理交给独立子进程（响应先回，慢活不再钉住事件循环）
+      assert.equal(r.runtimeCleanup, "deferred", "运行时清理必须由子进程接管（不得同步阻塞）");
+      assert.ok(r.cleanupLog, "应给出清理日志路径");
+      // 物理断言：等子进程跑完，relayDir 与其中全部残留都应消失
+      assert.ok(await waitFor(() => !existsSync(relayDir)), "relayDir 应被整目录清空（子进程执行）");
       assert.equal(existsSync(path.join(relayDir, ".dsh-config.json")), false);
       assert.equal(existsSync(path.join(relayDir, "dsh-setup.mjs")), false);
       assert.equal(existsSync(path.join(relayDir, "clients")), false);
@@ -117,7 +130,7 @@ test("彻底卸载：配置目录整目录清空（含账号/密钥/固化运行
       assert.equal(existsSync(profile), true, "dsh web profile 目录整体不得被删");
       // 人类可读 detail
       assert.match(String(r.detail), /插件引用与本地文件已移除/);
-      assert.match(String(r.detail), /配置目录已清空/);
+      assert.match(String(r.detail), /正在后台清理/);
       assert.match(String(r.detail), /请重启 dsh web/);
     } finally {
       host.close();
@@ -145,13 +158,12 @@ test("彻底卸载边界：只装了插件、从未跑过 bridge → relayDir
       const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
       assert.equal(r.ok, true);
       assert.equal(r.removedPatch, true, "profile 里的插件引用应照常清理");
-      assert.equal(r.relayDirRemoved, false, "目录本就不存在 → 不声称已清空");
-      assert.equal(r.stoppedService, false);
-      assert.equal(r.removedPlist, false);
-      assert.deepEqual(r.killedPids, []);
+      assert.equal(r.runtimeCleanup, "deferred");
       const detail = String(r.detail);
       assert.ok(!detail.includes("配置目录已清空"), "目录不存在时不应谎报已清空，实际: " + detail);
       assert.match(detail, /请重启 dsh web/);
+      await sleep(800); // 等清理子进程跑完
+      assert.equal(existsSync(relayDir), false, "relayDir 本来就不存在 → 不得被凭空创建");
     } finally {
       host.close();
     }
@@ -174,12 +186,13 @@ test("彻底卸载边界：什么都没有安装 → 全链路幂等返回 ok，
     try {
       const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
       assert.equal(r.ok, true);
-      assert.equal(r.relayDirRemoved, false);
+      assert.equal(r.runtimeCleanup, "deferred");
       assert.equal(r.removedPatch, false);
       assert.equal(r.removedDep, false);
       assert.equal(r.removedBundle, false);
-      assert.deepEqual(r.killedPids, []);
       assert.match(String(r.detail), /请重启 dsh web/);
+      await sleep(800);
+      assert.equal(existsSync(relayDir), false, "什么都没有也不该凭空创建目录");
     } finally {
       host.close();
     }
@@ -206,10 +219,9 @@ test("DSH_RELAY_SKIP_SERVICE 开关：置位时即便存在自启动 plist 也
     try {
       const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
       assert.equal(r.ok, true);
-      assert.equal(r.removedPlist, false, "开关置位 → plist 不得被删");
-      assert.equal(existsSync(fakePlist), true, "plist 应原样保留（开关只放行配置目录清理）");
-      assert.equal(r.relayDirRemoved, true, "配置目录清理不受开关影响");
-      assert.equal(existsSync(relayDir), false);
+      assert.equal(r.runtimeCleanup, "deferred");
+      assert.ok(await waitFor(() => !existsSync(relayDir)), "配置目录清理不受开关影响");
+      assert.equal(existsSync(fakePlist), true, "开关置位 → plist 不得被删（子进程同样受开关约束）");
     } finally {
       host.close();
     }
@@ -220,7 +232,7 @@ test("DSH_RELAY_SKIP_SERVICE 开关：置位时即便存在自启动 plist 也
   }
 });
 
-test("自然跳过（无开关）：HOME 有 plist 但服务未运行 → 删除 plist 但不发 launchctl bootout（PATH 假命令接管）", { skip: process.platform !== "darwin" }, async () => {
+test("无开关（真实分支）：自启动清理由独立子进程执行，且走 PATH 上的假 launchctl（不碰真实服务）", { skip: process.platform !== "darwin" }, async () => {
   const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-natural-"));
   const prevHome = process.env.HOME;
   const prevPath = process.env.PATH;
@@ -254,15 +266,13 @@ exit 0
     try {
       const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
       assert.equal(r.ok, true);
-      assert.equal(r.removedPlist, true, "plist 存在于当前 HOME → 应被删除");
-      assert.equal(existsSync(plist), false);
-      assert.equal(r.stoppedService, false, "服务未运行 → 无需 bootout，不虚报已停止");
-      assert.deepEqual(r.killedPids, [], "无残留进程可杀");
-      assert.equal(r.relayDirRemoved, true);
-      assert.equal(existsSync(relayDir), false);
-      // 关键：全程不得发出 bootout（避免任何真实/假服务被停）
-      const log = readFileSync(launchLog, "utf8");
-      assert.ok(!log.includes("bootout"), "未运行的服务不应触发 bootout，实际调用: " + log);
+      assert.equal(r.runtimeCleanup, "deferred", "无开关时同样走子进程");
+      // 等清理子进程跑完（它继承 HOME/PATH → plist 路径与 launchctl 都落在测试环境里）
+      assert.ok(await waitFor(() => !existsSync(plist)), "plist 应被清理子进程删除");
+      assert.ok(await waitFor(() => !existsSync(relayDir)), "配置目录应被清空");
+      // 关键安全性质：清理用的是 PATH 上的**假** launchctl —— 证明没有触碰任何真实服务
+      const log = existsSync(launchLog) ? readFileSync(launchLog, "utf8") : "";
+      assert.ok(log.includes("com.dshremote.bridge"), "应通过（假）launchctl 清理自启动，实际: " + log);
     } finally {
       host.close();
     }
@@ -289,8 +299,9 @@ test("保护参数：relayDir 误配置成 dsh web profile 目录 → 绝不整
     try {
       const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
       assert.equal(r.ok, true);
-      assert.equal(r.relayDirRemoved, false, "profile 目录受保护 → 不得整目录删除");
-      assert.equal(existsSync(profile), true, "dsh web profile 必须存活");
+      assert.equal(r.runtimeCleanup, "deferred");
+      await sleep(1000); // 等清理子进程跑完：它必须自己判断出"这是 profile，不许删"
+      assert.equal(existsSync(profile), true, "dsh web profile 必须存活（子进程也受同一条护栏约束）");
       assert.equal(existsSync(path.join(profile, "package.json")), true);
       assert.equal(existsSync(path.join(profile, "dsh-remote-ui-plugin")), false, "插件子目录应被 uninstallSelf 单独移除");
       assert.equal(existsSync(path.join(profile, "node_modules", "dsh-remote-ui")), false);

package/packages/dsh-remote-web/test/uninstall-safety.test.mjs

@@ -0,0 +1,379 @@
+/**
+ * 卸载安全回归（0.6.7-beta.3 新增）—— 两个"卸载把 dsh web 弄坏"的致命缺陷。
+ *
+ * 缺陷一：卸载后 cordis.patch.yml 只剩注释。
+ *   dsh 要求该文件顶层是**数组**，而纯注释文档的 YAML 解析结果是 `null`（不是空数组），
+ *   于是 dsh 直接启动失败：
+ *     `Error: dsh: overlay …/cordis.patch.yml must be a top-level YAML array of loader patch entries`
+ *   官方空 profile 模板是「注释 + `[]`」，这个占位符不能省。用户卸载后 dsh web 起不来，
+ *   而面板也在那个进程里 → 只能靠 CLI 自救。
+ *
+ * 缺陷二：卸载全链路同步执行在 dsh web 的事件循环里，且把易卡的运行时清理排在前面。
+ *   一次 spawnSync 卡住（Windows 沙箱拦 schtasks；spawnSync 的 timeout 在 Windows 上不可靠，
+ *   实测 18s+ 未返回）→ 真正"卸载插件"的那步永远不执行，且**整个 dsh web 僵死**
+ *   （端口在听、连接建立、永不响应）。
+ *
+ * ⚠️ 本文件的断言对象刻意落在**可用性**上（文件还能不能被解析成数组、进程结果、响应契约），
+ *    而不是"函数返回了什么"——上一轮正是因为只断言后者才漏掉了挂载缺陷。
+ */
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { apply } from "../lib/index.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const INDEX_SRC = fs.readFileSync(path.join(HERE, "..", "lib", "index.js"), "utf8");
+const CLIENT_SRC = fs.readFileSync(path.join(HERE, "..", "lib", "client.js"), "utf8");
+const SETUP = path.join(HERE, "..", "..", "..", "dsh-setup.mjs");
+const SETUP_SRC = fs.readFileSync(SETUP, "utf8");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const PLUGIN_ID = "dsh-remote-web";
+const LEGACY_ID = "dsh-remote-ui";
+
+/**
+ * 独立复刻 dsh 的判定：顶层必须是 YAML 数组。
+ * 只认**顶层（无缩进）非注释行** —— 缩进行属于上一条目；纯注释 → 结构行数为 0 → 判定不合法
+ * （这正是缺陷一的形态）。刻意不引用被测实现里的同名函数，避免自证。
+ */
+function isTopLevelArrayDoc(text) {
+  const structural = String(text).split(/\r?\n/)
+    .filter((l) => l.trim() !== "" && !/^\s*#/.test(l) && !/^[ \t]/.test(l)) // 只保留顶层非注释行
+    .map((l) => l.trim());
+  if (structural.length === 0) return false;
+  return structural.every((l) => l === "[]" || l.startsWith("-"));
+}
+
+function boot(relayDir) {
+  const routes = new Map();
+  apply({
+    webServer: { register(route) { routes.set(route.path, route.handler); return () => {}; } },
+    effect(register) { return register(); },
+    logger: { info() {}, warn() {} },
+  }, { relayDir });
+  return routes;
+}
+
+async function serve(routes) {
+  const host = http.createServer((req, res) => {
+    const handler = routes.get(new URL(req.url, "http://x").pathname);
+    (handler || ((_r, rs) => { rs.writeHead(404); rs.end(); }))(req, res);
+  });
+  await new Promise((resolve) => host.listen(0, "127.0.0.1", resolve));
+  return { host, base: `http://127.0.0.1:${host.address().port}` };
+}
+
+/** 造一个装了插件的 profile：patch（标记块形式）+ 依赖 + 本地拷贝 + node_modules 链接。 */
+async function plantProfile(home, { extraPatch = "", unmarked = false } = {}) {
+  const profile = path.join(home, ".dsh", "profiles", "web");
+  fs.mkdirSync(path.join(profile, "node_modules"), { recursive: true });
+  const block = unmarked
+    ? `- insert:\n    - id: ${PLUGIN_ID}\n      name: '${PLUGIN_ID}'\n`
+    : `# >>> ${PLUGIN_ID} (managed by dsh-remote plugin; do not edit)\n- insert:\n    - id: ${PLUGIN_ID}\n      name: '${PLUGIN_ID}'\n      config:\n        relayDir: '${path.join(home, "relay")}'\n# <<< ${PLUGIN_ID}\n`;
+  fs.writeFileSync(path.join(profile, "cordis.patch.yml"), `# 空 profile 的 patch 层\n${extraPatch}${block}`);
+  fs.writeFileSync(path.join(profile, "package.json"), JSON.stringify({
+    name: "dsh-profile-web",
+    dependencies: { [PLUGIN_ID]: "file:./dsh-remote-web-plugin", other: "^1.0.0" },
+    dsh: { profile: { bundles: [] } },
+  }, null, 2));
+  const local = path.join(profile, "dsh-remote-web-plugin");
+  fs.mkdirSync(path.join(local, "lib"), { recursive: true });
+  fs.writeFileSync(path.join(local, "package.json"), JSON.stringify({ name: PLUGIN_ID, version: "0.0.0" }));
+  fs.writeFileSync(path.join(local, "lib", "index.js"), "export const x = 1;\n");
+  fs.symlinkSync(local, path.join(profile, "node_modules", PLUGIN_ID), "dir");
+  fs.mkdirSync(path.join(home, "relay"), { recursive: true });
+  fs.writeFileSync(path.join(home, "relay", ".dsh-config.json"), JSON.stringify({ phone: "13800000000", password: "pw" }));
+  return { profile, patchFile: path.join(profile, "cordis.patch.yml") };
+}
+
+// ─────────────────────── ① patch 占位符（缺陷一） ───────────────────────
+
+test("对照：纯注释文档必须判为「不是顶层数组」（这正是 dsh 起不来的形态）", () => {
+  assert.equal(isTopLevelArrayDoc("# 只有注释\n# 再来一行\n"), false);
+  assert.equal(isTopLevelArrayDoc(""), false);
+  assert.equal(isTopLevelArrayDoc("[]\n"), true);
+  assert.equal(isTopLevelArrayDoc("# c\n[]\n"), true);
+  assert.equal(isTopLevelArrayDoc("- insert:\n    - id: x\n      name: 'x'\n"), true, "缩进行属于条目，不能判成非法");
+});
+
+test("卸载：patch 条目被摘光后必须补回 `[]` 占位（否则 dsh web 起不来）", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-safety-"));
+  const prevHome = process.env.HOME;
+  const prevSkip = process.env.DSH_RELAY_SKIP_SERVICE;
+  process.env.HOME = home;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1"; // 隔离：绝不碰真实系统服务
+  try {
+    const { profile, patchFile } = await plantProfile(home);
+    const routes = boot(path.join(home, "relay"));
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.removedPatch, true, "插件引用应被摘除");
+
+      const after = fs.readFileSync(patchFile, "utf8");
+      assert.ok(!after.includes(PLUGIN_ID), "patch 里不该再有本插件：" + JSON.stringify(after));
+      assert.ok(isTopLevelArrayDoc(after), "★卸载后 patch 必须仍是合法顶层数组（含 [] 占位）：" + JSON.stringify(after));
+      assert.match(after, /\[\]/, "被摘空时必须补回 `[]` 占位");
+
+      // 依赖 / 本地拷贝 / 链接也被移除（市场卸载才能接手）
+      const pkg = JSON.parse(fs.readFileSync(path.join(profile, "package.json"), "utf8"));
+      assert.equal(pkg.dependencies[PLUGIN_ID], undefined);
+      assert.equal(pkg.dependencies.other, "^1.0.0", "别人的依赖不得被误删");
+      assert.equal(fs.existsSync(path.join(profile, "dsh-remote-web-plugin")), false);
+      assert.equal(fs.existsSync(path.join(profile, "node_modules", PLUGIN_ID)), false);
+    } finally {
+      host.close();
+    }
+  } finally {
+    if (prevSkip === undefined) delete process.env.DSH_RELAY_SKIP_SERVICE; else process.env.DSH_RELAY_SKIP_SERVICE = prevSkip;
+    process.env.HOME = prevHome;
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("卸载：无标记的 `- insert:` 块（旧版/其它工具写入的形式）也要被摘掉", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-safety-unmarked-"));
+  const prevHome = process.env.HOME;
+  const prevSkip = process.env.DSH_RELAY_SKIP_SERVICE;
+  process.env.HOME = home;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    const { patchFile } = await plantProfile(home, { unmarked: true });
+    const routes = boot(path.join(home, "relay"));
+    const { host, base } = await serve(routes);
+    try {
+      await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      const after = fs.readFileSync(patchFile, "utf8");
+      // 只摘标记块是不够的：目录已删而 patch 仍引用 → dsh 插件树加载失败 → 整个 dsh web 起不来
+      assert.ok(!after.includes(PLUGIN_ID), "无标记的 insert 块也必须摘掉：" + JSON.stringify(after));
+      assert.ok(isTopLevelArrayDoc(after), "摘空后仍须是合法数组：" + JSON.stringify(after));
+    } finally {
+      host.close();
+    }
+  } finally {
+    if (prevSkip === undefined) delete process.env.DSH_RELAY_SKIP_SERVICE; else process.env.DSH_RELAY_SKIP_SERVICE = prevSkip;
+    process.env.HOME = prevHome;
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("卸载：别人的 patch 条目必须原样保留（不许顺手清空整份文件）", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-safety-other-"));
+  const prevHome = process.env.HOME;
+  const prevSkip = process.env.DSH_RELAY_SKIP_SERVICE;
+  process.env.HOME = home;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    const other = "- insert:\n    - id: some-other-plugin\n      name: 'other'\n";
+    const { patchFile } = await plantProfile(home, { extraPatch: other });
+    const routes = boot(path.join(home, "relay"));
+    const { host, base } = await serve(routes);
+    try {
+      await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      const after = fs.readFileSync(patchFile, "utf8");
+      assert.ok(after.includes("some-other-plugin"), "别人的条目必须保留：" + JSON.stringify(after));
+      assert.ok(!after.includes(PLUGIN_ID), "我们的条目必须摘掉");
+      assert.ok(isTopLevelArrayDoc(after));
+      assert.ok(!/\[\]/.test(after), "还有条目时不该多写 `[]`（会变成 YAML 语法错误）");
+    } finally {
+      host.close();
+    }
+  } finally {
+    if (prevSkip === undefined) delete process.env.DSH_RELAY_SKIP_SERVICE; else process.env.DSH_RELAY_SKIP_SERVICE = prevSkip;
+    process.env.HOME = prevHome;
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("CLI 卸载（dsh-remote plugin --uninstall）：同样必须留下合法数组", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-safety-cli-"));
+  try {
+    const { patchFile } = await plantProfile(home);
+    // 用真实安装器跑一遍 CLI 卸载（隔离 HOME + 隔离开关）
+    const r = spawnSync(process.execPath, [SETUP, "plugin", "--uninstall"], {
+      encoding: "utf8", timeout: 60000,
+      env: { ...process.env, HOME: home, DSH_RELAY_SKIP_SERVICE: "1", DSH_RELAY_DIR: path.join(home, "relay"), DSH_PROFILE_DIR: path.dirname(patchFile) },
+    });
+    assert.equal(r.status, 0, `CLI 卸载应成功：${r.stdout}\n${r.stderr}`);
+    const after = fs.readFileSync(patchFile, "utf8");
+    assert.ok(!after.includes(PLUGIN_ID), "CLI 卸载也应摘掉条目：" + JSON.stringify(after));
+    assert.ok(isTopLevelArrayDoc(after), "★CLI 卸载后同样必须是合法数组：" + JSON.stringify(after));
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+// ─────────────────────── ② 卸载顺序与阻塞（缺陷二） ───────────────────────
+
+test("源码契约：卸载必须先卸插件、再关自愈、最后才把慢活交子进程", () => {
+  const route = INDEX_SRC.slice(INDEX_SRC.indexOf('path: "/dsh-remote/self/uninstall"'), INDEX_SRC.indexOf("// ---------- 路由", INDEX_SRC.indexOf('path: "/dsh-remote/self/uninstall"')));
+  const iSelf = route.indexOf("uninstallSelf(relayDir, profileDir");
+  const iMark = route.indexOf("markUninstalled(relayDir)");
+  const iSpawn = route.indexOf("spawnRuntimeCleanupDetached(relayDir, profileDir)");
+  const iSend = route.indexOf("sendJson(res, 200");
+  assert.ok(iSelf > -1 && iMark > -1 && iSpawn > -1 && iSend > -1, "应能定位四个关键步骤");
+  assert.ok(iSelf < iSpawn, "★先卸插件（快、纯 fs），再交子进程做慢活 —— 旧实现顺序相反，卡住就「什么都没卸载」");
+  assert.ok(iMark < iSpawn, "自愈标记必须在慢步骤之前置位，否则慢步骤期间可能被复活");
+  // 兜底路径（进程内同步清理）必须在响应之后：它会阻塞事件循环，用户不能先等它
+  const iFallback = route.indexOf("uninstallRuntime(relayDir, profileDir)");
+  assert.ok(iFallback === -1 || iSend < iFallback, "兜底的进程内清理必须排在响应之后");
+  assert.ok(!/const rt = uninstallRuntime\(relayDir, profileDir\);/.test(route), "不得再同步执行 uninstallRuntime");
+  // 事件循环禁令：请求路径上不许出现同步子进程调用
+  assert.ok(!/spawnSync\(/.test(route), "卸载请求路径不得出现 spawnSync（会把事件循环钉死）");
+});
+
+test("行为：响应里插件引用已经卸掉（不依赖慢步骤先跑完）", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-order-"));
+  const prevHome = process.env.HOME;
+  const prevSkip = process.env.DSH_RELAY_SKIP_SERVICE;
+  process.env.HOME = home;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    const { patchFile } = await plantProfile(home);
+    const routes = boot(path.join(home, "relay"));
+    const { host, base } = await serve(routes);
+    try {
+      const t0 = Date.now();
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      const ms = Date.now() - t0;
+      assert.equal(r.removedPatch, true, "响应必须已包含「插件引用已移除」");
+      assert.ok(isTopLevelArrayDoc(fs.readFileSync(patchFile, "utf8")), "响应返回时 patch 必须已写好");
+      assert.equal(r.runtimeCleanup, "deferred", "运行时清理应交给子进程");
+      assert.ok(ms < 5000, `响应不该等运行时清理（实测 ${ms}ms）`);
+    } finally {
+      host.close();
+    }
+  } finally {
+    if (prevSkip === undefined) delete process.env.DSH_RELAY_SKIP_SERVICE; else process.env.DSH_RELAY_SKIP_SERVICE = prevSkip;
+    process.env.HOME = prevHome;
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+// ─────────────────────── ③ 运行时清理助手 ───────────────────────
+
+/** 从插件源码里取出助手生成函数（安装器/插件都是 CLI+ESM，import 会执行 main）。 */
+function loadCleanupHelperBuilder() {
+  const src = INDEX_SRC.slice(
+    INDEX_SRC.indexOf("function buildRuntimeCleanupHelper("),
+    INDEX_SRC.indexOf("/**\n * 把「运行时清理」交给一个 detached 子进程"));
+  return new Function("osPlatform", "WIN_TASK_NAME", "WATCHER_PID_FILE", "BRIDGE_PID_FILE", "join", "homedir", "tmpdir",
+    `${src}; return buildRuntimeCleanupHelper;`)(
+    () => process.platform, "dsh-remote-bridge", ".dsh-watcher.pid", ".dsh-bridge.pid", path.join, os.homedir, os.tmpdir);
+}
+
+test("清理助手：生成的脚本语法合法，且每个外部命令都有 timeout（超时不能当唯一防线，但要有）", () => {
+  const src = loadCleanupHelperBuilder()(path.join(os.tmpdir(), "relay-x"), path.join(os.tmpdir(), "prof-x"));
+  const file = path.join(os.tmpdir(), `dsh-helper-check-${process.pid}.mjs`);
+  fs.writeFileSync(file, src);
+  try {
+    const chk = spawnSync(process.execPath, ["--check", file], { encoding: "utf8" });
+    assert.equal(chk.status, 0, `生成的清理助手语法必须合法：${chk.stderr}`);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+  // 外部命令一律经 run(cmd, args, timeout)
+  const calls = src.match(/run\("[a-z]+", \[[^\]]*\], (\d+)\)/g) || [];
+  assert.ok(calls.length >= 2, `应通过 run(...) 调外部命令（实际 ${calls.length} 处）`);
+  assert.ok(!/spawnSync\("[a-z]+", \[[^\]]*\](?!, \{)/.test(src), "不得有裸 spawnSync（缺 timeout）");
+  assert.ok(/DSH_RELAY_SKIP_SERVICE === "1"/.test(src), "助手必须遵守测试隔离开关（否则用例会动到真实服务）");
+});
+
+test("清理助手：真跑一遍 → 结束 pid 文件里的进程并清空配置目录", async () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-helper-"));
+  const relayDir = path.join(home, "relay");
+  fs.mkdirSync(relayDir, { recursive: true });
+  fs.writeFileSync(path.join(relayDir, ".dsh-config.json"), JSON.stringify({ phone: "x", password: "y" }));
+  // 用一个真实存活的长命进程当"残留 bridge"
+  const sleeper = spawn(process.execPath, ["-e", "setTimeout(() => {}, 60000)"], { stdio: "ignore" });
+  fs.writeFileSync(path.join(relayDir, ".dsh-bridge.pid"), String(sleeper.pid));
+  const src = loadCleanupHelperBuilder()(relayDir, path.join(home, "prof"));
+  const helper = path.join(home, "helper.mjs");
+  fs.writeFileSync(helper, src);
+  try {
+    // 注意：这里**不**设隔离开关，用来验证真实的 kill 路径；
+    // 但 HOME 已指向临时目录 → 自启动 plist 路径落在临时目录、不存在 → 不会碰真实 launchd。
+    // 显式去掉隔离开关：本用例要验证**真实**的 kill 路径；HOME 指向临时目录保证不碰真实服务
+    const env = { ...process.env, HOME: home };
+    delete env.DSH_RELAY_SKIP_SERVICE;
+    const r = spawnSync(process.execPath, [helper], { encoding: "utf8", timeout: 30000, env });
+    assert.equal(r.status, 0, `助手应正常退出：${r.stderr}`);
+    assert.equal(fs.existsSync(relayDir), false, "★配置目录必须被清空");
+    assert.equal(fs.existsSync(path.join(relayDir, ".dsh-config.json")), false);
+    // pid 文件里的进程应被结束
+    let alive = true;
+    for (let i = 0; i < 40; i += 1) {
+      try { process.kill(sleeper.pid, 0); } catch { alive = false; break; }
+      await sleep(50);
+    }
+    assert.equal(alive, false, "★pid 文件里记录的残留进程必须被结束");
+  } finally {
+    try { sleeper.kill("SIGKILL"); } catch { /* 已退出 */ }
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("清理助手：护栏命中时绝不删 profile（relayDir 误配成 profile 的兜底）", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-un-helper-guard-"));
+  const profile = path.join(home, "prof");
+  fs.mkdirSync(profile, { recursive: true });
+  fs.writeFileSync(path.join(profile, "package.json"), "{}");
+  const src = loadCleanupHelperBuilder()(profile, profile); // relayDir === protectedPath
+  const helper = path.join(home, "helper.mjs");
+  fs.writeFileSync(helper, src);
+  try {
+    spawnSync(process.execPath, [helper], { encoding: "utf8", timeout: 30000, env: { ...process.env, HOME: home, DSH_RELAY_SKIP_SERVICE: "1" } });
+    assert.equal(fs.existsSync(path.join(profile, "package.json")), true, "★护栏命中：profile 必须完好");
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+// ─────────────────────── ④ Windows ACL 收紧（mode 0600 是空操作） ───────────────────────
+
+test("安全：三处机密写入都要显式收紧 ACL（Windows 上 mode 0o600 无效）", () => {
+  for (const [label, src, callSites] of [
+    ["安装器", SETUP_SRC, [/hardenFile\(CONFIG_PATH\)/]],
+    ["插件半", INDEX_SRC, [/hardenFile\(configPathOf\(relayDir\)\)/, /hardenFile\(join\(relayDir, HARNESS_COOKIE_FILE\)\)/]],
+    ["bridge", fs.readFileSync(path.join(HERE, "..", "..", "..", "clients", "dsh-remote", "dsh-bridge.mjs"), "utf8"), [/hardenFile\(CONFIG_PATH\)/]],
+  ]) {
+    assert.ok(/function hardenFile\(file\)/.test(src), `${label} 应有 hardenFile`);
+    assert.ok(/icacls/.test(src) && /inheritance:r/.test(src), `${label} 必须在 Windows 上断开继承并只授权当前用户`);
+    assert.ok(/process\.platform !== "win32"/.test(src), `${label} 非 Windows 走 chmod 即可`);
+    for (const re of callSites) assert.ok(re.test(src), `${label} 的机密写入点必须调用 hardenFile：${re}`);
+  }
+});
+
+test("安全：hardenFile 在非 Windows 上只 chmod（不引入任何子进程，零副作用）", () => {
+  const src = SETUP_SRC.slice(SETUP_SRC.indexOf("function hardenFile(file)"), SETUP_SRC.indexOf("// ---------- 配置读写 ----------"));
+  const calls = [];
+  const fakeSpawn = () => { calls.push("spawn"); return { status: 0 }; };
+  const fakeFs = { ...fs, chmodSync: (f, m) => { calls.push(`chmod:${m.toString(8)}`); } };
+  const harden = new Function("fs", "spawnSync", "process", "hardenWarned", `${src}; return hardenFile;`)(fakeFs, fakeSpawn, process, false);
+  const file = path.join(os.tmpdir(), `dsh-harden-${process.pid}.tmp`);
+  fs.writeFileSync(file, "x");
+  try {
+    harden(file);
+    if (process.platform !== "win32") {
+      assert.deepEqual(calls, ["chmod:600"], `非 Windows 只应 chmod 600，实际 ${JSON.stringify(calls)}`);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+// ─────────────────────── ⑤ 前端：请求超时 ───────────────────────
+
+test("前端：任何请求都有超时上界（node 半僵死时不再永久转圈）", () => {
+  assert.ok(/var API_TIMEOUT_MS = \d+/.test(CLIENT_SRC), "应有默认请求超时");
+  assert.ok(/AbortController/.test(CLIENT_SRC), "应通过 AbortController 实现超时");
+  assert.ok(/postWithTimeout\("\/dsh-remote\/self\/uninstall"/.test(CLIENT_SRC), "卸载这类可能拖住的操作应使用更短超时");
+  assert.ok(/请求超时/.test(CLIENT_SRC), "超时后必须给用户一句能照做的话");
+  assert.ok(/clearTimeout\(timer\)/.test(CLIENT_SRC), "请求结束必须清掉定时器（否则泄漏）");
+});