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

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;
@@ -515,11 +546,28 @@ function launchAgentPath() {
  * `process.getuid()`，在 Windows 上直接 TypeError（这正是面板两个读状态接口 500 的根因）。
  * 现在：非 macOS 或取不到 uid 一律返回 null，调用方必须先判空。
  */
-function launchTarget() {
-  if (!isDarwin()) return null;
+/**
+ * launchd 域名阶梯（**必须与 dsh-setup.mjs 一致**）。
+ *
+ * 事故（2026-09-19 实测）：安装器按 macOS 26 的修复把作业装在 **`user/<uid>`** 域
+ * （gui 域会被系统置为 on-demand-only，RunAtLoad/KeepAlive 失效），
+ * 但插件这边只认 `gui/<uid>` → 切换账号时那次"重启 bridge"实际执行的是
+ *   launchctl bootout gui/501/com.dshremote.bridge   → 找不到
+ *   launchctl bootstrap gui/501 <plist>              → 失败
+ * 结果：旧 bridge 继续用**旧账号**跑，新账号的设备列表里永远看不到这台机器。
+ * 现在两边用同一条阶梯：user/<uid> 优先，gui/<uid> 兜底。
+ */
+function launchDomains() {
+  if (!isDarwin()) return [];
   const uid = currentUid();
-  if (uid === null) return null;
-  return `gui/${uid}/com.dshremote.bridge`;
+  return uid === null ? [] : [`user/${uid}`, `gui/${uid}`];
+}
+/** 所有可能承载本服务的 launchd target（按优先级）。 */
+function launchTargets() {
+  return launchDomains().map((d) => `${d}/com.dshremote.bridge`);
+}
+function launchTarget() {
+  return launchTargets()[0] || null; // 首选域（user/<uid>）
 }
 
 /**
@@ -536,12 +584,21 @@ function launchTarget() {
  * 现在：print 的 state 为准 + 附带 runs/lastExitCode/crashing 供面板与自愈解释原因；
  * 仅在 print 本身不可用时才回退 list，且回退路径要求 pid 真实存活。
  */
+const NO_LAUNCHD = { running: false, pid: null, state: "", runs: null, lastExitCode: null, crashing: false };
+
 function launchdStatus() {
   // 非 macOS 没有 launchctl（Windows 上连 process.getuid 都没有）：直接返回「无此服务」，
   // 不再去 shell 里调一个不存在的命令——这既避免 500，也避免每次轮询白起一个 cmd.exe。
-  if (!isDarwin()) return { running: false, pid: null, state: "", runs: null, lastExitCode: null, crashing: false };
-  const target = launchTarget();
-  if (!target) return { running: false, pid: null, state: "", runs: null, lastExitCode: null, crashing: false };
+  if (!isDarwin()) return { ...NO_LAUNCHD };
+  // 逐域查询：安装器可能把作业装在 user/<uid>，插件以前只看 gui/<uid> → 会把"正在运行"看成"未运行"。
+  for (const target of launchTargets()) {
+    const st = launchdStatusIn(target);
+    if (st.running || st.crashing || st.state) return st;
+  }
+  return { ...NO_LAUNCHD };
+}
+
+function launchdStatusIn(target) {
   const pr = sh(`launchctl print ${target}`);
   if (pr.ok) {
     const stateMatch = pr.stdout.match(/state\s*=\s*([^\n]+)/);
@@ -930,7 +987,7 @@ function reapBrokenAutostart(relayDir) {
   if (!plistEntryMissing()) return false;
   const st = launchdStatus();
   if (!st.running && !st.crashing && !st.state) return false; // 作业未被 launchd 加载、无可摘的东西
-  sh(`launchctl bootout ${launchTarget()}`);
+  for (const target of launchTargets()) sh(`launchctl bootout ${target}`);
   try { rmSync(launchAgentPath(), { force: true }); } catch { /* 非关键 */ }
   appendLogLine(relayDir, AUTO_INSTALL_LOG,
     `[dsh-remote-web] 已摘除失效自启动：plist 入口 ${join(relayDir, "dsh-setup.mjs")} 不存在`
@@ -966,16 +1023,15 @@ function killPid(pid, signal = "SIGTERM") {
 }
 
 /**
- * Windows：启动 bridge（0.6.7 新增）。
+ * 「脱离进程」方式启动 bridge（Windows 必用；macOS/Linux 在 launchd/systemd 托管不了时兜底）。
  *
- * Windows 上没有 launchd/systemd，dsh-setup.mjs 也不为 win32 生成自启动
- * （它明写「平台 win32 不支持自启动」）。但 bridge 本身在 Windows 上能跑——
- * 所以插件直接把 watcher（`node <relayDir>/dsh-setup.mjs run`）作为脱离进程拉起：
+ * Windows 上没有服务管理器自启动；macOS 上 launchd 被系统置为 on-demand-only（gui 域）时也托管不住。
+ * 此时插件直接把 watcher（`node <relayDir>/dsh-setup.mjs run`）作为脱离进程拉起：
  * 这与用户手动跑 `dsh-remote run` 是**同一条代码路径**，watcher 自己盯着 127.0.0.1:3080，
  * dsh web 活着就拉起 dsh-bridge.mjs、dsh web 退出就把 bridge 停掉。
  * 代价（如实告知用户）：不随开机自启；但 dsh web 每次启动后插件都会在自愈轮次里重新拉起它。
  */
-function startBridgeWindows(relayDir) {
+function startBridgeDetached(relayDir, fallbackReason = "") {
   if (skipsSystemOps()) return { ok: false, status: "skipped", detail: "测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过真实服务操作" };
   if (!runtimeReady(relayDir)) {
     ensureRuntime(relayDir);
@@ -1015,16 +1071,18 @@ function startBridgeWindows(relayDir) {
     ok: true,
     status: "running",
     pid: child.pid,
-    // 如实区分两条路径：装过（或更新过）就有登录任务；没有的话只有"重开 dsh web 自动拉起"这一层保障
-    detail: windowsTaskRegistered()
+    // 如实区分两条路径：装过（且平台支持）就有自启动；否则只有"重开 dsh web 自动拉起"这一层保障
+    detail: isWindows() && windowsTaskRegistered()
       ? "已在后台启动 bridge 守护（已注册登录任务，下次登录会自动运行）"
-      : "已在后台启动 bridge 守护（未注册登录任务：不随开机自启，重开 dsh web 时插件会自动拉起）",
+      : `已在后台启动 bridge 守护${fallbackReason ? `（${fallbackReason}；不随开机自启，重开 dsh web 时插件会自动拉起）` : "（不随开机自启，重开 dsh web 时插件会自动拉起）"}`,
   };
 }
 
-/** Windows：停止 bridge（结束 watcher 与其 bridge 子进程，并清掉 pid 文件）。 */
-function stopBridgeWindows(relayDir) {
-  if (skipsSystemOps()) return { ok: false, status: "skipped", detail: "测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过真实服务操作" };
+/** 停止「脱离进程」方式运行的 bridge（结束 watcher 与其 bridge 子进程，并清掉 pid 文件）。 */
+function stopBridgeDetached(relayDir, opts = {}) {
+  // 账号切换时用 force：即使处于测试隔离模式也要把进程停掉（否则"换个账号"在测试里走不通），
+  // 但隔离模式下仍只用信号结束**本插件记录的** pid，不碰任何系统服务。
+  if (skipsSystemOps() && !opts.force) return { ok: false, status: "skipped", detail: "测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过真实服务操作" };
   const targets = [];
   for (const name of [WATCHER_PID_FILE, BRIDGE_PID_FILE]) {
     const pid = readPidFile(relayDir, name);
@@ -1051,7 +1109,7 @@ function startBridge(relayDir) {
     // 已彻底卸载：面板/自愈在重启前可能仍在内存中，禁止再把自启动与 plist 拉回来
     return { ok: false, status: "uninstalled", detail: "插件已彻底卸载，重启 dsh web 后生效" };
   }
-  if (isWindows()) return startBridgeWindows(relayDir);
+  if (isWindows()) return startBridgeDetached(relayDir);
   const plistPath = launchAgentPath();
   if (!plistPath) {
     return {
@@ -1079,21 +1137,32 @@ function startBridge(relayDir) {
   }
   if (!existsSync(plistPath)) writeAutostartFile(relayDir);
   if (!existsSync(plistPath)) return { ok: false, status: "not-installed", detail: "plist 生成失败" };
-  const target = launchTarget();
-  const boot = (() => {
+  // 与 dsh-setup.mjs 同一条域阶梯：user/<uid> 优先（macOS 26 上唯一支持 RunAtLoad/KeepAlive 的域），
+  // gui/<uid> 兜底（只能靠 kickstart 拉这一次，不保证崩溃自愈）。
+  let lastDetail = "";
+  for (const domain of launchDomains()) {
+    const target = `${domain}/com.dshremote.bridge`;
+    // 清掉**另一个**域的历史注册，避免两处并存导致重复实例（与安装器同构）
+    for (const other of launchDomains()) {
+      if (other !== domain) sh(`launchctl bootout ${other}/com.dshremote.bridge`);
+    }
     sh(`launchctl bootout ${target}`);
-    // domain 一律由 launchTarget 推导（不再直接 process.getuid()：Windows 上没有该 API）
-    const domain = `gui/${currentUid()}`;
-    let r = sh(`launchctl bootstrap ${domain} ${shQuote(plistPath)}`);
-    if (!r.ok) {
+    let boot = sh(`launchctl bootstrap ${domain} ${shQuote(plistPath)}`);
+    if (!boot.ok) {
       sh(`launchctl unload ${shQuote(plistPath)}`);
-      r = sh(`launchctl load -w ${shQuote(plistPath)}`);
+      boot = sh(`launchctl load -w ${shQuote(plistPath)}`);
     }
-    return r;
-  })();
-  if (!boot.ok) return { ok: false, status: "failed", detail: (boot.stderr || boot.stdout).trim() || "launchctl 启动失败" };
-  const st = launchdStatus();
-  return { ok: st.running, status: st.running ? "running" : "failed", pid: st.pid, detail: st.running ? void 0 : "服务未进入运行态" };
+    if (!boot.ok) { lastDetail = (boot.stderr || boot.stdout).trim() || `launchctl bootstrap ${domain} 失败`; continue; }
+    // bootstrap 只是登记：立刻 kickstart 一次，确保"这一次"一定起来
+    sh(`launchctl kickstart -k ${target}`);
+    const st = launchdStatusIn(target);
+    if (st.running) return { ok: true, status: "running", pid: st.pid, domain };
+    lastDetail = st.state ? `已登记但未运行（state=${st.state}, runs=${st.runs ?? "?"}）` : "已登记但查不到状态";
+  }
+  // launchd 都托管不了（macOS 26 的 on-demand-only / 权限异常等）→ 退化为脱离进程，
+  // 与 Windows 走同一条路径：绝不出现"重启失败但用户无感、旧账号继续跑"这种静默失败。
+  const d = startBridgeDetached(relayDir, `launchd 无法托管（${lastDetail || "未知原因"}）`);
+  return d.ok ? d : { ok: false, status: "failed", detail: `${lastDetail}；脱离进程兜底也失败：${d.detail}` };
 }
 
 /**
@@ -1146,12 +1215,20 @@ function scheduleRuntime(relayDir) {
 
 /** 停止 bridge：macOS/Linux 走 launchctl bootout；Windows 结束 watcher/bridge 进程。 */
 function stopBridge(relayDir) {
-  if (isWindows()) return stopBridgeWindows(relayDir);
-  const target = launchTarget();
-  if (!target) return { ok: false, status: "unsupported", detail: `当前平台（${osPlatform()}）没有 launchd 服务可停，请手动结束 \`dsh-remote run\` 进程` };
-  const r = sh(`launchctl bootout ${target}`);
+  if (isWindows()) return stopBridgeDetached(relayDir);
+  // 测试隔离：置位时绝不对真实 launchd/systemd 下手（切换账号也会走到这里，
+  // 少了这一条，用例就会去 bootout 开发者本机上真实运行的 bridge —— 实测过的污染风险）。
+  if (skipsSystemOps()) return { ok: false, status: "skipped", detail: "测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过真实服务操作" };
+  const targets = launchTargets();
+  if (!targets.length) return { ok: false, status: "unsupported", detail: `当前平台（${osPlatform()}）没有 launchd 服务可停，请手动结束 \`dsh-remote run\` 进程` };
+  // 两个域都要停：作业可能由安装器装在 user/<uid>，而旧版插件只会去 gui/<uid> 找不到（实测事故）
+  let lastErr = "";
+  for (const target of targets) {
+    const r = sh(`launchctl bootout ${target}`);
+    if (!r.ok) lastErr = (r.stderr || r.stdout).trim();
+  }
   const st = launchdStatus();
-  return { ok: !st.running, status: st.running ? "failed" : "stopped", pid: null, detail: st.running ? (r.stderr || "停止失败").trim() : void 0 };
+  return { ok: !st.running, status: st.running ? "failed" : "stopped", pid: null, detail: st.running ? (lastErr || "停止失败").trim() : void 0 };
 }
 
 // ---------- 彻底卸载：bridge 自启动 / 残留进程 / 配置目录 ----------
@@ -1459,7 +1536,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 +2379,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.4";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -2507,17 +2584,249 @@ 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 };
+  }
+}
+
+/** 账号指纹：账号 / 模式 / 设备身份任一变化都意味着"必须用新凭据重新登记"。 */
+function accountFingerprintOf(cfg) {
+  const c = cfg || {};
+  return [c.local_key ? "local" : "saas", c.phone || c.email || "", String(c.device_id || "")].join("|");
+}
+
+/**
+ * 账号（或模式/设备身份）变化后，**必须让 bridge 用新凭据重新登记**。
+ *
+ * 事故（2026-09-19 实测）：从 A 账号切到 B 账号后，配置已经改了、device_id 也清了，
+ * 但**正在运行的 bridge 是启动时把账号/密码固化在环境变量里的**，它不会自己换账号；
+ * 而那次"重启 bridge"又因 launchd 域名不一致（插件只认 gui/<uid>，安装器装在 user/<uid>）静默失败
+ * → 设备继续留在 A 账号，B 账号的设备列表里永远看不到这台机器。
+ *
+ * 这里做三件事：① 停掉旧 bridge（含两个 launchd 域与脱离进程两种形态）；
+ * ② 删掉旧账号留下的状态文件（否则面板据 phase=online + 旧 device_id 谎报"已连接"，
+ * 自愈也就永远不会去纠正）；③ 交给调用方随后重新启动。
+ */
+function resetBridgeForAccountChange(relayDir, why) {
+  const stopped = stopBridge(relayDir);
+  // 脱离进程形态（launchd 托管不住时的兜底）也要收干净，否则它会用旧凭据继续跑
+  try { stopBridgeDetached(relayDir, { force: true }); } catch { /* 非关键 */ }
+  try {
+    if (bridgeStateFile(relayDir)) {
+      rmSync(join(relayDir, BRIDGE_STATE_FILE), { force: true });
+      appendLogLine(relayDir, AUTO_INSTALL_LOG, `[dsh-remote-web] ${why}：已清除过期的 bridge 状态记录（旧账号的注册证据作废）`);
+    }
+  } catch { /* 非关键 */ }
+  return stopped;
+}
+
+/**
+ * 运行中的 bridge 是否属于「当前账号」。
+ * 判据：bridge 状态文件记录的 device_id 必须与配置里的一致；配置里没有 device_id
+ * （= 刚切过账号、旧身份已作废）而状态里还有 → 说明跑的是**上一个账号**的 bridge。
+ * @returns {boolean} true=属于当前账号；false=过期（必须重启）；未记录 device_id 时按旧行为返回 true
+ */
+function bridgeMatchesCurrentAccount(relayDir, cfg) {
+  const state = bridgeStateFile(relayDir);
+  if (!state || !state.device_id) return true;          // 无记录可判：不改变既有行为
+  const want = String((cfg || loadConfig(relayDir)).device_id || "");
+  if (!want) return false;                              // 配置里身份已清空 = 旧 bridge 的注册已作废
+  return want === String(state.device_id);
+}
+
 /** 彻底卸载第 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"));
@@ -2745,9 +3054,13 @@ async function composeConnect(relayDir, opts = {}) {
   const deviceId = String(cfg.device_id || "");
 
   // ── 中继注册证据（只有 bridge 进程在跑时才算「现在能用」） ──
+  // ⚠️ 先判「这个 bridge 是不是当前账号的」：账号切换后进程不会自己换凭据，
+  // 旧账号留下的状态文件（phase=online + 旧 device_id）会让面板谎报「已连接」，
+  // 自愈也就永远不会去重启它（2026-09-19 实测事故）。
+  const accountCurrent = bridgeMatchesCurrentAccount(relayDir, cfg);
   let registered = false;
   let registerSource = "";
-  if (runtime && bridgeRunning) {
+  if (runtime && bridgeRunning && accountCurrent) {
     if (state && state.phase === "online" && Number(state.tunnel_registered_at) > 0) {
       registered = true; registerSource = "state";
     } else if (log.tunnelRegistered) {
@@ -2816,6 +3129,10 @@ async function composeConnect(relayDir, opts = {}) {
     detail = bindError.code === "device_limit_exceeded"
       ? "已达本套餐设备数上限：同机重装会自动顶替旧设备；仍失败请到手机端「设备管理」解绑旧设备后点「重试」。"
       : "请确认网络与账号状态后点「重试」；仍不成功可点「复制诊断信息」发给客服。";
+  } else if (!accountCurrent) {
+    // 进程在跑，但它是**上一个账号**的 bridge：必须重启才能用新账号登记
+    phase = "starting";
+    detail = "检测到后台 bridge 仍是上一个账号的身份（账号切换后需要重启它才能用新账号重新登记），正在自动重启…";
   } else {
     phase = "connecting";
     detail = "bridge 进程已在运行，正在等待设备注册到中继…通常几秒内完成。";
@@ -2836,6 +3153,7 @@ async function composeConnect(relayDir, opts = {}) {
     installing: inst.installing,
     installStale: inst.stale,
     bridgeRunning,
+    accountCurrent, // 运行中的 bridge 是否属于当前账号（false = 上一个账号的进程还在跑）
     bridgePids,
     launchdState: launchd.state || "",
     launchdCrashLoop: Boolean(launchd.crashing),
@@ -2863,6 +3181,7 @@ function buildConnectDiagnostics(relayDir, conn, log) {
     `运行环境: ${conn.runtimeReady ? "已就绪" : "缺失"}${conn.installing ? "（后台安装中）" : ""}${conn.installStale ? "（安装标记已超时）" : ""}`,
     `bridge 进程: ${conn.bridgeRunning ? "在运行" : "未运行"}（pid=${conn.bridgePids && conn.bridgePids.length ? conn.bridgePids.join(",") : "-"}，launchd state=${conn.launchdState || "-"}，崩溃循环=${conn.launchdCrashLoop ? "是" : "否"}）`,
     `中继注册: ${conn.registered ? "已注册（" + conn.registerSource + "）" : "未注册"}`,
+    `bridge 账号: ${conn.accountCurrent === false ? "⚠️ 仍是上一个账号的身份（需重启 bridge 重新登记）" : "当前账号"}`,
     `最近错误: ${conn.error ? conn.error.code + ": " + conn.error.message : (log && log.lastError ? log.lastError : "无")}`,
     `自动重试: 已尝试 ${conn.attempts} 次${conn.nextRetryInMs ? `，约 ${Math.ceil(conn.nextRetryInMs / 1000)} 秒后重试` : ""}`,
     `bridge 日志: ${conn.logPath}`,
@@ -2897,6 +3216,17 @@ function ensureConnection(relayDir, opts = {}) {
   const launchd = launchdStatus();
   const manual = manualStatus(relayDir);
   if (launchd.running || (manual.allBridge || []).length || (manual.bridge || []).length) {
+    // 进程在跑 ≠ 跑对了账号：切换账号后旧 bridge 会一直用旧凭据，
+    // 只看"有没有进程"会让自愈永久停摆（实测事故）。这里多判一次账号归属。
+    if (!bridgeMatchesCurrentAccount(relayDir, cfg)) {
+      book.lastAttemptAt = now;
+      book.attempts += 1;
+      resetBridgeForAccountChange(relayDir, "bridge 身份与当前账号不符");
+      const r = startBridge(relayDir);
+      appendLogLine(relayDir, AUTO_INSTALL_LOG,
+        `[dsh-remote-web] 检测到旧账号的 bridge 仍在运行，已重启以用当前账号重新登记（${r.status || "?"}）`);
+      return { action: "restart", result: r };
+    }
     book.attempts = 0; // 进程已在跑：退避计数归零，后续只等注册
     book.lastAttemptAt = now;
     return { action: "none" };
@@ -3571,30 +3901,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?.();
+        }
       },
     },
     {
@@ -3768,8 +4115,11 @@ function registerRoutes(ctx, relayDir) {
             if (secret) cfg.bridge_secret = secret;
           }
         }
+        // 账号/模式变化 → 先停掉旧 bridge 并作废它的注册证据，否则新账号永远等不到这台设备
+        const accountFpBefore = accountFingerprintOf(loadConfig(relayDir));
         saveConfig(relayDir, cfg);
         invalidateRelayToken(relayDir); // 账号可能变了：丢弃旧 token 缓存，立即用新账号认证
+        if (accountFingerprintOf(cfg) !== accountFpBefore) resetBridgeForAccountChange(relayDir, "账号/模式已变更");
         const bridgeRestart = startBridge(relayDir);
         // 登录成功即上报本机安装信息（企业端用于「升级插件后刷新版本号」口径）；失败静默。
         maybeReportInstall(relayDir, { force: true });
@@ -3780,11 +4130,17 @@ function registerRoutes(ctx, relayDir) {
       method: "POST",
       path: "/dsh-remote/logout",
       handler: async (_req, res) => {
-        // 退出登录:清除本机保存的账号(邮箱/密码),bridge 下次重启将不再自动登录
+        // 退出登录：清除本机保存的账号(邮箱/密码)，并**立刻停掉 bridge**。
+        // 为什么必须停：bridge 的凭据是启动时固化的，不停就会继续用旧账号的隧道对外服务 ——
+        // 用户以为"已退出登录"，实际上手机端仍能访问这台电脑（安全语义不成立）。
         const cfg = loadConfig(relayDir);
         delete cfg.phone;
         delete cfg.password;
+        delete cfg.device_id;          // 设备身份一并作废：下次登录会生成新身份并重新登记
+        delete cfg.device_private_key;
+        delete cfg.device_public_key;
         saveConfig(relayDir, cfg);
+        resetBridgeForAccountChange(relayDir, "退出登录");
         invalidateRelayToken(relayDir); // 退出登录：token 缓存立即失效
         sendJson(res, 200, { ok: true, ...(await composeStatus(relayDir)) });
       },