@mrrisega/dsh-remote 0.7.3-beta.1 → 0.7.3-beta.2

package/packages/dsh-remote-web/runtime/clients/dsh-remote/upstream-discovery.mjs

@@ -103,7 +103,12 @@ export function resolveUpstreamHint({ relayDir = "", env = process.env } = {}) {
 
 function tryExec(cmd, args, timeoutMs = 4000) {
   try {
-    return String(execFileSync(cmd, args, { encoding: "utf8", timeout: timeoutMs, stdio: ["ignore", "pipe", "ignore"] }) || "");
+    // windowsHide（C1）：这里会跑 netstat/lsof/ps 这类**控制台程序**。watcher/bridge 常以
+    // 无控制台方式启动（launchd / 任务计划 wscript / 插件的 detached spawn），此时 Windows 会
+    // 为子进程新分配一个可见控制台窗口 → 用户看到"一闪而过"的黑窗（诊断报告 04 §3.2 第二条）。
+    // 上游探测在上游请求失败/ws-open 失败时每 15s 冷却反复触发（见 refreshUpstream），所以闪窗成串。
+    // POSIX 上该选项被忽略。
+    return String(execFileSync(cmd, args, { encoding: "utf8", timeout: timeoutMs, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }) || "");
   } catch {
     return "";
   }

package/packages/dsh-remote-web/runtime/dsh-setup.mjs

@@ -63,6 +63,17 @@ const WIN_TASK_NAME = "dsh-remote-bridge";
  */
 const WATCHER_PID_FILE = ".dsh-watcher.pid";
 const BRIDGE_PID_FILE = ".dsh-bridge.pid";
+/**
+ * C2 互踢根治：bridge 判定"本机已有同 deviceId 的另一个 bridge"时的退出码（必须与
+ * dsh-bridge.mjs 里的 DUPLICATE_INSTANCE_EXIT_CODE 一致），以及 watcher 收到它之后的暂停时长。
+ *
+ * 为什么 watcher 要暂停而不是照常 10s 重拉：互踢的本质是"两个实例抢同一个 deviceId"，
+ * 重拉的唯一效果是**把对方也顶掉**（对方同样重连），形成 2~3.5s 周期的乒乓（生产日志实测
+ * dev-a50dced9cc19 327 次/10min）。本机已有实例在跑时，让位才是对的；5 分钟后若对方已经
+ * 退出（用户重装/升级收尾），本守护自然恢复。
+ */
+const DUPLICATE_INSTANCE_EXIT_CODE = 4;
+const DUPLICATE_BRIDGE_BACKOFF_MS = 5 * 60 * 1000;
 
 // ---------- 运行时自物化（npm/npx 安装 → 固化到配置目录，脱离 npx 缓存） ----------
 // npx 每次安装的缓存目录（~/.npm/_npx/<hash>）不固定：缓存一旦清理，指向它的自启动服务
@@ -232,7 +243,8 @@ function runtimeSetupPath() {
 
 function sh(cmd, timeoutMs = 15000, cwd = undefined) {
   try {
-    const stdout = execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs, ...(cwd ? { cwd } : {}) });
+    // windowsHide：POSIX 上被忽略；Windows 上避免 execSync 经 cmd.exe 执行控制台程序时闪窗/弹窗。
+    const stdout = execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs, windowsHide: true, ...(cwd ? { cwd } : {}) });
     return { ok: true, stdout: String(stdout ?? ""), stderr: "", code: 0 };
   } catch (e) {
     return { ok: false, stdout: String(e.stdout ?? ""), stderr: String(e.stderr ?? ""), code: e.status ?? -1 };
@@ -411,13 +423,50 @@ function hardenFile(file) {
 }
 
 // ---------- 配置读写 ----------
+/** 配置读失败只报一次（每 10s 一轮的 ensureBridge 会把同一行刷成噪音）。 */
+let configReadWarned = false;
 function loadConfig() {
-  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")); }
-  catch { return {}; }
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch (e) {
+    // ⚠️ 静默返回 {} 是历史行为（首次安装时文件确实不存在）。但**读失败不能与"没登录"混淆**：
+    // 配置文件存在却读不出来（杀软占用 / OneDrive 同步中 / EPERM / 半写）时，指纹会瞬间变成
+    // `saas|||`，旧逻辑据此按"账号变了"停掉 bridge → 下一轮再拉起 → 反复重启（诊断报告 04 §4.3）。
+    // 这里只补"可观测"（写一次原因），重启抑制由 accountFingerprint 的连续确认负责。
+    if (e && e.code !== "ENOENT" && !configReadWarned) {
+      configReadWarned = true;
+      console.warn(`⚠️ 读取配置失败（${e.code || e.message}）：${CONFIG_PATH} —— 本轮按空配置处理，但不据此重启 bridge。`);
+    }
+    return {};
+  }
 }
+/**
+ * 保存配置。
+ *
+ * 【C8 原子写】旧实现是"先截断再写"（writeFileSync 直接覆盖）：saas 模式**每 10 秒**重写一次，
+ * 而插件半（设置页/切账号/备份）也在写同一个文件 —— Windows 上被杀软扫描/OneDrive 同步放大成
+ * "读到半截 JSON" → loadConfig 静默 {} → 指纹抖动 → bridge 反复重启。
+ *
+ * 现在写成 `<config>.<pid>.tmp` 再 rename 覆盖（rename 在同一目录内是原子的）：
+ * 读的一方要么看到旧内容、要么看到新内容，永远读不到半截。
+ * 失败安全：Windows 上目标文件被杀软/备份工具持有句柄时 rename 可能 EBUSY/EPERM ——
+ * 先短暂重试，仍失败就退回直接写（宁可丢原子性，也绝不写不进去把配置搞丢）。
+ */
 function saveConfig(cfg) {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  const body = JSON.stringify(cfg, null, 2);
+  const tmp = `${CONFIG_PATH}.${process.pid}.tmp`;
+  let renamed = false;
+  try {
+    fs.writeFileSync(tmp, body, { mode: 0o600 });
+    for (let i = 0; i < 3 && !renamed; i += 1) {
+      try { fs.renameSync(tmp, CONFIG_PATH); renamed = true; }
+      catch (e) { if (i === 2) throw e; sleepSync(30); }
+    }
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* 临时文件删不掉不致命 */ }
+    fs.writeFileSync(CONFIG_PATH, body, { mode: 0o600 }); // 兜底：绝不让保存失败
+  }
   hardenFile(CONFIG_PATH); // Windows 上 mode 是空操作 → 必须显式收紧 ACL（内含明文账号密码）
 }
 
@@ -584,6 +633,83 @@ function pidAlive(pid) {
   try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; }
 }
 
+/* ── C2：孤儿 bridge 清扫（命令行校验，绝不误杀）─────────────────────────────────
+ *
+ * 为什么 pid 文件回收（上面的 shouldReapLeftoverBridge）还不够：pid 文件只覆盖"上一任 watcher
+ * 写过的那个 pid"。真实场景里还有两类抓不到的孤儿（诊断报告 04 §4.4）：
+ *   ① watcher 被 TerminateProcess / 关闭控制台收掉时，bridge 子进程被 reparent 成孤儿继续持有隧道；
+ *   ② 0.7.2 的升级覆盖写运行时**不停旧进程**，旧 bridge 继续用旧脚本跑。
+ * 两种孤儿都与新 bridge 同 deviceId → 中继 close(4000) 互踢（生产上 3 台 Win 设备长期乒乓，全 0.7.2）。
+ *
+ * 安全边界（误杀无关进程是不可接受的）：
+ *   · 只认**命令行同时包含** `dsh-bridge.mjs` 与**本运行时** `clients/dsh-remote` 路径的进程
+ *     （与 looksLikeBridge 同一套纪律；还额外要求是本 THIS_DIR 的运行时，避免碰到另一个配置目录/用户）；
+ *   · 取不到命令行（ps/PowerShell 不可用）→ 一个都不杀。失败方向必须是"漏杀"而不是"误杀"。
+ */
+function isThisRuntimeBridgeCmd(cmd) {
+  const c = String(cmd || "");
+  if (!/dsh-bridge\.mjs/.test(c)) return false;
+  const needle = path.join(THIS_DIR, "clients", "dsh-remote");
+  // 命令行里的分隔符可能与本机 path.sep 不同（Windows 上两者都可能出现）→ 归一化后比较
+  const norm = (v) => v.replace(/[\\/]+/g, "/").toLowerCase();
+  return norm(c).includes(norm(needle));
+}
+
+/** 列出本机属于**本运行时**的 bridge 进程 pid（命令行校验；取不到命令行 → 空数组）。 */
+function listRuntimeBridgePids() {
+  const pids = [];
+  if (IS_WIN) {
+    // 一次性 PowerShell CIM 枚举（逐个 windowsProcessCommandLine 会起 N 个进程，太贵）
+    const script = [
+      "try { $p = Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" }",
+      "catch { $p = Get-WmiObject Win32_Process -Filter \"Name='node.exe'\" }",
+      "$p | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress",
+    ].join("; ");
+    const encoded = Buffer.from(script, "utf16le").toString("base64");
+    try {
+      const r = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded],
+        { encoding: "utf8", timeout: 8000, windowsHide: true, maxBuffer: 8 * 1024 * 1024 });
+      const raw = String(r.stdout || "").trim();
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        for (const p of Array.isArray(parsed) ? parsed : [parsed]) {
+          const pid = Number(p && p.ProcessId);
+          if (Number.isInteger(pid) && pid > 0 && isThisRuntimeBridgeCmd(p.CommandLine)) pids.push(pid);
+        }
+      }
+    } catch { /* 无 PowerShell / 解析失败 → 不杀任何进程 */ }
+    return pids;
+  }
+  const r = sh("pgrep -fl 'dsh-bridge\\.mjs'");
+  if (!r.ok) return pids;
+  for (const line of String(r.stdout || "").split("\n")) {
+    const m = /^(\d+)\s+(.+)$/.exec(line.trim());
+    if (!m) continue;
+    if (isThisRuntimeBridgeCmd(m[2])) pids.push(Number(m[1]));
+  }
+  return pids;
+}
+
+/**
+ * 清扫孤儿 bridge（接管/退出时调用）。返回被结束的 pid 列表。
+ * @param {{ fast?: boolean }} opts fast=true 时不等待（退出钩子里只剩 3s 预算）
+ */
+function sweepStrayBridges({ fast = false } = {}) {
+  const strays = listRuntimeBridgePids().filter((pid) => pid !== process.pid);
+  const killed = [];
+  for (const pid of strays) {
+    try { process.kill(pid, "SIGTERM"); killed.push(pid); } catch { /* 已退出 */ }
+  }
+  if (!fast) {
+    for (const pid of strays) {
+      const dl = Date.now() + 3000;
+      while (Date.now() < dl && pidAlive(pid)) sleepSync(100);
+      if (pidAlive(pid)) { try { process.kill(pid, "SIGKILL"); } catch { /* 已退出 */ } }
+    }
+  }
+  return killed;
+}
+
 /**
  * 注册 Windows 登录任务（幂等：先删再建）。
  * /DELAY 0000:15：登录后等 15 秒再起，避免与桌面环境抢启动时机
@@ -1435,6 +1561,32 @@ function accountFingerprint(cfg) {
   return [c.local_key ? "local" : "saas", c.phone || c.email || "", String(c.device_id || ""), String(c.local_key || "")].join("|");
 }
 
+/* ── 账号指纹"变化确认"（C8）────────────────────────────────────────────────────
+ *
+ * 🔴 为什么不能"指纹一变就重启 bridge"（诊断报告 04 §4.3）：
+ *   `loadConfig()` 读失败会静默返回 `{}`，此时指纹 = `saas|||`，与真实值不等 ——
+ *   旧逻辑据此按"账号变了"停 bridge，下一轮再拉起，于是每 10~20s 重启一次；
+ *   Windows 上被杀软扫描/OneDrive 同步/文件占用放大的"读抖动"就是这样变成重启循环的。
+ *
+ * 修法：指纹变化必须**连续 2 轮**（ensureBridge 每 10s 一轮）看到同一个新值，
+ * 或该新值已持续 ≥5s，才认为"真的变了"。单轮的 `{}` 抖动会被下一轮复位清掉。
+ * 抽成纯函数是因为这条判断的代价很实在（每误判一次就断一次隧道），必须能被直接测。
+ */
+const FINGERPRINT_CONFIRM_ROUNDS = 2;
+const FINGERPRINT_CONFIRM_MS = 5000;
+
+/** 记一次"疑似新指纹"：同一个 fp 连击计数，换值则重新从 1 开始。 */
+function noteFingerprintCandidate(prev, fp, now = Date.now()) {
+  if (!prev || prev.value !== fp) return { value: fp, rounds: 1, since: now };
+  return { value: fp, rounds: prev.rounds + 1, since: prev.since };
+}
+
+/** 这个"疑似变化"是否已经确认（连续 2 轮，或持续 ≥5s）。 */
+function fingerprintChangeConfirmed(cand, now = Date.now()) {
+  if (!cand || !cand.value) return false;
+  return cand.rounds >= FINGERPRINT_CONFIRM_ROUNDS || now - cand.since >= FINGERPRINT_CONFIRM_MS;
+}
+
 /**
  * 服务端登录限流的"最早可重试时刻"（bridge 在收到 429 时落盘）。
  * 为什么需要：限流窗口是 15 分钟，而 watcher 每 10 秒就会重新拉起 bridge ——
@@ -1590,11 +1742,30 @@ async function runBridge() {
         removePidFile(BRIDGE_PID_FILE);
       }
     }
+    // ── C2：清扫「pid 文件之外的孤儿 bridge」（命令行校验，绝不误杀）──────────────
+    //
+    // pid 文件只能覆盖"上一任 watcher 写过的那个 pid"。真实世界里还有两类抓不到的孤儿：
+    //   ① watcher 被 TerminateProcess / 关闭控制台收掉 → bridge 被 reparent 成孤儿继续持有隧道；
+    //   ② 0.7.2 升级覆盖运行时**不停旧进程** → 旧 bridge 继续用旧脚本跑。
+    // 它们与新 bridge 共用同一 deviceId → 中继 close(4000) 互踢（生产 3 台 Win 设备长期乒乓，全 0.7.2）。
+    // 走到这里说明**本机此刻只有本守护**（去重已通过），所以任何"本运行时的 bridge"都是上一代的遗留。
+    {
+      const strays = sweepStrayBridges();
+      if (strays.length) {
+        console.log(`[dsh-remote] 已清扫 ${strays.length} 个孤儿 bridge 进程（pid ${strays.join(", ")}）——避免与新实例互踢。`);
+      }
+    }
   }
   let cfg = loadConfig();
   let warnedNoLogin = false;
   /** 当前 bridge 子进程使用的账号指纹（账号/模式/设备身份任一变化 → 重启子进程）。 */
   let bridgeAccountFp = "";
+  /** C8：疑似变化但还没确认的新指纹（连续 2 轮/≥5s 才确认，防 loadConfig 静默 {} 抖动）。 */
+  let pendingFp = null;
+  /** C2：bridge 判为「本机已有另一个实例」后的暂停拉起截止时刻。 */
+  let duplicateBridgeBackoffUntil = 0;
+  /** 暂停提示只打一次，避免每 10s 刷屏。 */
+  let warnedDuplicateBridge = false;
   /** 限流提示只打一次，避免刷屏。 */
   let warnedRateLimit = false;
 
@@ -1642,11 +1813,25 @@ async function runBridge() {
     //（2026-09-19 实测故障）。
     const fp = accountFingerprint(cfg);
     if (!childStopped(bridgeProc) && bridgeAccountFp && bridgeAccountFp !== fp) {
+      // C8：**连续确认**才重启（理由见 noteFingerprintCandidate 上方的长注释）。
+      // 单独一次读到 `{}`（文件被占用/半写/杀软扫描）不构成"账号变了"，下一轮自然复位。
+      pendingFp = noteFingerprintCandidate(pendingFp, fp);
+      if (!fingerprintChangeConfirmed(pendingFp)) {
+        if (pendingFp.rounds === 1) {
+          // 不打印指纹内容：它含手机号/设备 id（日志会被用户复制到群里）
+          console.log("[dsh-remote] 账号配置疑似变化，先观察一轮再决定是否重启 bridge（防配置读抖动）。");
+        }
+        return;
+      }
+      pendingFp = null;
       console.log("[dsh-remote] 账号配置已变化 → 重启 bridge 让新账号生效...");
       await stopChildGracefully(bridgeProc); // 先请它优雅退出，跑完微信通道下线通知
       bridgeAccountFp = "";
+      duplicateBridgeBackoffUntil = 0; // 用户明确换了账号：清掉"让位"暂停，立即用新凭据拉起
       return; // 下一轮（10s 内）用新配置重新拉起
     }
+    // 指纹又回到一致（或本来就没变）→ 之前的"疑似变化"作废，绝不让它跨轮累积。
+    pendingFp = null;
 
     // 服务端登录限流窗口内不反复拉起 bridge（凭据没错，改了也没用）
     const rlUntil = loginRateLimitUntil();
@@ -1659,6 +1844,18 @@ async function runBridge() {
     }
     warnedRateLimit = false;
 
+    // C2：bridge 连续 2 次收到 code=4000 已判定"本机还有另一个同 deviceId 的实例"并退出（code=4）。
+    // 那段时间内本守护**不再拉起**：拉起只会把对方顶掉，继续乒乓互踢。
+    if (Date.now() < duplicateBridgeBackoffUntil) {
+      if (!warnedDuplicateBridge) {
+        warnedDuplicateBridge = true;
+        console.log(`[dsh-remote] 本机已有另一个同 deviceId 的 bridge（互踢保护）→ 本守护暂停拉起约 ${Math.ceil((duplicateBridgeBackoffUntil - Date.now()) / 60000)} 分钟。`);
+        console.log("   若这是升级/重装留下的旧实例，可执行 `dsh-remote doctor` 或重启一次 dsh web 让它退出。");
+      }
+      return;
+    }
+    warnedDuplicateBridge = false;
+
     const alive = await checkUpstream();
     if (alive && childStopped(bridgeProc)) {
       starting = true;
@@ -1685,9 +1882,28 @@ async function runBridge() {
       // 只有它能让我们在停 bridge 之前请它跑完退出钩子（notifystop）—— 见 stopChildGracefully。
       bridgeProc = spawn(NODE_BIN,
         [path.join(THIS_DIR, "clients/dsh-remote/dsh-bridge.mjs")],
-        { env: nodeEnv(childEnv), stdio: ["inherit", "inherit", "inherit", "ipc"] });
-      bridgeProc.on("exit", () => {
+        {
+          env: nodeEnv(childEnv),
+          stdio: ["inherit", "inherit", "inherit", "ipc"],
+          // 🔴 C1 黑窗根治（2026-10-20 诊断 W1，生产截图 04）：这里**必须**带 windowsHide。
+          // 原理同 spawnDetachedBridge 的注释：watcher 自己常以"无控制台"方式被拉起
+          //（launchd / 任务计划里的 wscript / 插件的 detached spawn）。无控制台的父进程
+          // spawn 一个控制台程序（node.exe）却不给 CREATE_NO_WINDOW 时，Windows 会**为子进程
+          // 新分配一个可见控制台窗口**；而 bridge 的 stdout/stderr 又被 watcher 指向日志文件，
+          // 于是用户看到的就是一个**空白黑窗**。bridge 崩溃 → watcher 每 10s 重拉 → 每 10s 弹一个。
+          // POSIX 上该选项被忽略。
+          windowsHide: true
+        });
+      bridgeProc.on("exit", (code) => {
         removePidFile(BRIDGE_PID_FILE);
+        // C2 互踢根治的 watcher 半边：bridge 连续 2 次收到 code=4000（= 本机已有同 deviceId 的
+        // 另一个 bridge 把本连接顶掉）后会以"重复实例"退出码优雅退出（见 dsh-bridge.mjs）。
+        // 这种退出**绝不能**照常 10s 重拉：本机已经有另一个实例在跑，重拉只会继续乒乓互踢。
+        if (code === DUPLICATE_INSTANCE_EXIT_CODE) {
+          duplicateBridgeBackoffUntil = Date.now() + DUPLICATE_BRIDGE_BACKOFF_MS;
+          console.log(`[dsh-remote] bridge 检测到同 deviceId 的另一个实例并退出（code=${code}）——本守护暂停 ${Math.round(DUPLICATE_BRIDGE_BACKOFF_MS / 60000)} 分钟后再试，避免两个实例反复互踢。`);
+          return;
+        }
         console.log("[dsh-remote] bridge 退出，等待重启...");
       });
       // Windows：落 pid 文件，供插件半发现进程（Windows 没有 pgrep/ps）。
@@ -1728,6 +1944,9 @@ async function runBridge() {
             if (bridgeProc && bridgeProc.exitCode === null) {
               try { bridgeProc.kill("SIGKILL"); } catch { /* 已退出 */ }
             }
+            // C2：退出时顺手清掉本运行时的全部 bridge 残留（fast：不等待）。
+            // 否则 Windows 上 watcher 被收掉后 bridge 可能成孤儿、继续与新实例互踢。
+            try { sweepStrayBridges({ fast: true }); } catch { /* 清扫失败不影响退出 */ }
             process.exit(0);
           }, 3000);
         });

package/packages/dsh-remote-web/test/bridge-hardening.test.mjs

@@ -0,0 +1,299 @@
+/**
+ * C2 / C8 回归：客户端升级与守护层的「不折腾用户的那些约束」。
+ *
+ * 背景（2026-10-20 用户群故障诊断，报告 00 §6.2 / 04 §四·§五）：
+ *   · C8-a **配置抖动**：loadConfig() 任何读失败都静默返回 {} → 账号指纹瞬间变化 →
+ *     旧逻辑据此"账号变了，重启 bridge" → 下一轮再拉起。Windows 上被杀软/OneDrive
+ *     放大的读抖动就这样变成每 10~20s 一次的重启循环（§4.3）。修法：指纹变化必须
+ *     连续 2 轮（或持续 ≥5s）确认；saveConfig 改原子写（tmp + rename），让读方永远读不到半截。
+ *   · C8-b **升级杀旧进程**：安装器覆盖写 clients/ 与 node_modules/ws 时，旧 watcher/bridge
+ *     正在跑那份文件 → Windows 杀软持有句柄 → 半装（`Cannot find package 'ws'`）+ 孤儿互踢。
+ *     修法：覆盖前按"本 relayDir 的命令行"停旧进程，装完按 pid 点名清残留；失败则恢复。
+ *   · C2 **孤儿 bridge 清扫**：pid 文件之外的 bridge（watcher 被 TerminateProcess 收掉、
+ *     升级后旧进程未退）由 watcher 按命令行清扫，绝不误杀无关进程。
+ *
+ * 这些分支里的"安全边界"（误杀/误停/误重启）代价都很高，所以纯函数 + 注入替身逐条上锁。
+ */
+import assert from "node:assert/strict";
+import http from "node:http";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+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 ROOT = path.join(HERE, "..", "..", "..");
+const INDEX_SRC = readFileSync(path.join(HERE, "..", "lib", "index.js"), "utf8").replace(/\r\n/g, "\n");
+const SETUP_SRC = readFileSync(path.join(ROOT, "dsh-setup.mjs"), "utf8").replace(/\r\n/g, "\n");
+const BRIDGE_SRC = readFileSync(path.join(ROOT, "clients", "dsh-remote", "dsh-bridge.mjs"), "utf8").replace(/\r\n/g, "\n");
+
+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);
+  }
+}
+
+/** 提取 `function name(...) { ... }` 的完整源码（按花括号配对，忽略字符串里的括号风险极小）。 */
+function extractFunction(src, name) {
+  const start = src.indexOf(`function ${name}(`);
+  assert.ok(start >= 0, `源码里找不到 function ${name}`);
+  const open = src.indexOf("{", start);
+  let depth = 0;
+  for (let i = open; i < src.length; i += 1) {
+    if (src[i] === "{") depth += 1;
+    else if (src[i] === "}") { depth -= 1; if (depth === 0) return src.slice(start, i + 1); }
+  }
+  throw new Error(`function ${name} 花括号不配对`);
+}
+
+// ─────────────────────── ① C8：指纹确认（读抖动不得触发重启）───────────────────────
+
+/** 从 dsh-setup.mjs 里取出"指纹变化确认"那段（两个常量 + 两个纯函数），单独求值。 */
+function loadFingerprintConfirmers() {
+  const start = SETUP_SRC.indexOf("const FINGERPRINT_CONFIRM_ROUNDS");
+  const end = SETUP_SRC.indexOf("const LOGIN_RATELIMIT_FILE");
+  assert.ok(start > 0 && end > start, "应在 dsh-setup.mjs 里找到指纹确认实现");
+  return new Function(
+    `${SETUP_SRC.slice(start, end)}\nreturn { FINGERPRINT_CONFIRM_ROUNDS, FINGERPRINT_CONFIRM_MS, noteFingerprintCandidate, fingerprintChangeConfirmed };`
+  )();
+}
+
+test("C8 指纹抖动被抑制：单轮读到 {} / 半截配置不得触发「账号变了→重启 bridge」", () => {
+  const { FINGERPRINT_CONFIRM_ROUNDS, FINGERPRINT_CONFIRM_MS, noteFingerprintCandidate, fingerprintChangeConfirmed } = loadFingerprintConfirmers();
+  assert.ok(FINGERPRINT_CONFIRM_ROUNDS >= 2, "确认轮数至少 2");
+  assert.ok(FINGERPRINT_CONFIRM_MS >= 5000, "确认时长至少 5s（等待跨轮）");
+
+  // 模拟 ensureBridge 每 10s 一轮：真实指纹 A，某轮 loadConfig() 读失败 → {} → 指纹成 "saas|||"
+  const A = "saas|13800000000|dev-1234|";
+  const EMPTY = "saas|||";
+  const t0 = 1_000_000;
+  let pending = null;
+  let restarts = 0;
+  const rounds = [A, EMPTY, A, EMPTY, A, EMPTY, A];
+  let maxRounds = 0;
+  rounds.forEach((fp, i) => {
+    const now = t0 + i * 10_000;
+    if (fp === A) { pending = null; return; } // 指纹回到一致 → 疑似变化作废
+    pending = noteFingerprintCandidate(pending, fp, now);
+    maxRounds = Math.max(maxRounds, pending.rounds);
+    if (fingerprintChangeConfirmed(pending, now)) restarts += 1;
+  });
+  assert.equal(restarts, 0, "★抖动（A/{} 交替）必须一次都不重启：旧实现每轮都会重启");
+  assert.equal(maxRounds, 1, "待确认状态不得跨轮累积（相邻两轮看到的必须是同一个新值才算数）");
+  assert.equal(pending, null, "指纹回到一致后，待确认状态必须清空");
+});
+
+test("C8 真·切号仍要生效：连续 2 轮看到新指纹（或持续 ≥5s）就重启", () => {
+  const { noteFingerprintCandidate, fingerprintChangeConfirmed } = loadFingerprintConfirmers();
+  const A = "saas|13800000000|dev-1234|";
+  const B = "saas|13900000000|dev-1234|";
+  const t0 = 2_000_000;
+  let pending = noteFingerprintCandidate(null, B, t0);
+  assert.equal(fingerprintChangeConfirmed(pending, t0), false, "第一轮只是「疑似」，不能立刻重启");
+  // 第二轮（ensureBridge 下一轮，10s 后）看到同一个新指纹 → 确认
+  pending = noteFingerprintCandidate(pending, B, t0 + 10_000);
+  assert.equal(fingerprintChangeConfirmed(pending, t0 + 10_000), true, "连续 2 轮 → 确认真切号");
+
+  // 只看到一次、但已经过去 ≥5s（例如被限流/上游离线跳过若干轮）→ 也确认
+  const single = noteFingerprintCandidate(null, B, t0);
+  assert.equal(fingerprintChangeConfirmed(single, t0 + 4_999), false);
+  assert.equal(fingerprintChangeConfirmed(single, t0 + 5_000), true);
+
+  // 换了另一个新值就把连击清零（B/C 交替不是"连续同一个"）
+  const flip = noteFingerprintCandidate(noteFingerprintCandidate(null, B, t0), "saas|13700000000|dev-1234|", t0 + 100);
+  assert.equal(flip.rounds, 1);
+  assert.equal(fingerprintChangeConfirmed(flip, t0 + 100), false);
+
+  // 集成形态：ensureBridge 里必须真的用这套判定，而不是"指纹一变就重启"
+  const ensure = SETUP_SRC.slice(SETUP_SRC.indexOf("const ensureBridge = async () => {"), SETUP_SRC.indexOf("// watcher 自身的 pid 也要落盘"));
+  assert.ok(/pendingFp = noteFingerprintCandidate\(pendingFp, fp\)/.test(ensure), "ensureBridge 必须走连续确认");
+  assert.ok(/if \(!fingerprintChangeConfirmed\(pendingFp\)\)/.test(ensure), "未确认时必须直接 return（不重启）");
+  assert.ok(/pendingFp = null;/.test(ensure), "指纹复位/确认后要清空待确认状态");
+  assert.ok(/bridgeAccountFp !== fp/.test(ensure), "仍然只在「读到的指纹与当前子进程不同」时才考虑重启");
+});
+
+// ─────────────────────── ② C8：配置原子写 ───────────────────────
+
+test("C8 配置原子写：写临时文件 + rename（读方永远读不到半截 JSON）；rename 失败才退回直写", () => {
+  const fnSrc = extractFunction(SETUP_SRC, "saveConfig");
+  const calls = [];
+  const make = (fsFake) => new Function("fs", "CONFIG_PATH", "CONFIG_DIR", "sleepSync", "hardenFile", "process",
+    `${fnSrc}\nreturn saveConfig;`)(fsFake, "/tmp/relay/.dsh-config.json", "/tmp/relay", () => {}, (p) => calls.push(["harden", p]), { pid: 4242 });
+
+  // ① 正常路径：先写 <config>.<pid>.tmp，再 rename 覆盖；**绝不**直接写目标文件
+  const fsOk = {
+    mkdirSync: () => calls.push(["mkdir"]),
+    writeFileSync: (p, body) => calls.push(["write", p, body]),
+    renameSync: (from, to) => calls.push(["rename", from, to]),
+    rmSync: (p) => calls.push(["rm", p]),
+  };
+  make(fsOk)({ phone: "13800000000" });
+  const write = calls.find((c) => c[0] === "write");
+  const rename = calls.find((c) => c[0] === "rename");
+  assert.ok(write, "必须写临时文件");
+  assert.equal(write[1], "/tmp/relay/.dsh-config.json.4242.tmp", "临时文件应带 pid（并发写互不覆盖）");
+  assert.ok(rename, "必须 rename 到目标路径（原子替换）");
+  assert.equal(rename[1], write[1], "rename 的源就是刚写的临时文件");
+  assert.equal(rename[2], "/tmp/relay/.dsh-config.json");
+  assert.ok(!calls.some((c) => c[0] === "write" && c[1] === "/tmp/relay/.dsh-config.json"),
+    "★不得直接覆盖目标文件（旧实现先截断再写 = 读方可能读到半截）");
+  assert.ok(calls.some((c) => c[0] === "harden"), "写完仍要收紧文件权限（内含明文账号密码）");
+
+  // ② rename 一直失败（Windows 被杀软/备份工具持有句柄）→ 重试后兜底直写，绝不丢配置
+  calls.length = 0;
+  const fsBusy = {
+    mkdirSync: () => {},
+    writeFileSync: (p, body) => calls.push(["write", p, body]),
+    renameSync: () => { const e = new Error("EBUSY"); e.code = "EBUSY"; throw e; },
+    rmSync: (p) => calls.push(["rm", p]),
+  };
+  make(fsBusy)({ phone: "13800000000" });
+  assert.ok(calls.some((c) => c[0] === "write" && c[1] === "/tmp/relay/.dsh-config.json"),
+    "rename 不可用时必须兜底直写（宁可丢原子性，也不能保存失败把配置丢了）");
+});
+
+// ─────────────────────── ③ C8：升级前停旧进程 / 装完清残留 ───────────────────────
+
+test("C8 更新流：覆盖运行时**之前**停旧 bridge；成功清残留、失败恢复（顺序与落点）", () => {
+  const body = INDEX_SRC.slice(INDEX_SRC.indexOf("async function runOnlineUpdate(relayDir) {"), INDEX_SRC.indexOf("function tailOf("));
+  assert.ok(/stopInfo = stopBridgeForRuntimeReplace\(relayDir\)/.test(body), "更新开始要停本 relayDir 的旧 watcher/bridge");
+  const stopAt = body.indexOf("stopInfo = stopBridgeForRuntimeReplace(relayDir)");
+  const runAt = body.indexOf("const child = run();");
+  assert.ok(stopAt > 0 && runAt > 0 && stopAt < runAt, "★必须先停旧进程，再启动 npx 安装（否则覆盖写运行中的文件）");
+  assert.ok(/sweepIfSucceeded\(\);/.test(body), "成功路径要清残留");
+  assert.ok(/restoreIfStopped\(\);/.test(body), "失败/取消路径要把 bridge 拉回来（别让用户莫名失去远程访问）");
+  // 失败分支的覆盖：三跳（官方源/默认源/离线）任一失败都要恢复
+  const restoreCount = (body.match(/restoreIfStopped\(\);/g) || []).length;
+  assert.ok(restoreCount >= 4, `失败/取消/异常各分支都要恢复（实际 ${restoreCount} 处）`);
+  // 恢复只在本轮真停过进程时才执行（测试/无进程环境下不得乱拉）
+  assert.ok(/if \(!stopInfo\.pids\.length\) return;/.test(body), "没停过进程就不要恢复（避免测试里碰真实服务）");
+});
+
+test("C8 清残留只按命令行点名：死 pid/无关进程/更新前不存在的新实例一律不动", () => {
+  const fnSrc = extractFunction(INDEX_SRC, "sweepBridgeAfterRuntimeReplace");
+  const make = () => new Function("skipsSystemOps", "pidAlive", "pidRunsFrom", "killPid",
+    `${fnSrc}\nreturn sweepBridgeAfterRuntimeReplace;`)(
+    () => false,
+    (pid) => pid !== 999,                       // 999 = 已死
+    (pid, relayDir) => {                        // 只有 11/12 的命令行属于本 relayDir（12 其实已被回收给无关进程）
+      if (pid === 12) return false;
+      return pid === 11 || pid === 10;
+    },
+    (pid, sig) => { killed.push([pid, sig]); return true; }
+  );
+  const killed = [];
+  const sweep = make();
+  const out = sweep("/tmp/relay", [10, 11, 12, 999]);
+  assert.deepEqual(out, [10, 11], "只结束「还活着且命令行仍指向本 relayDir」的那批 pid");
+  assert.deepEqual(killed.map((k) => k[0]).sort((a, b) => a - b), [10, 11]);
+  // 不传 pid 列表 = 什么都不做（成功但没停过旧进程时绝不清扫，避免误杀安装器刚拉起的新实例）
+  assert.deepEqual(sweep("/tmp/relay", []), []);
+});
+
+test("C8 停旧进程前必须做命令行校验：看不清就不动（误杀无关进程不可接受）", () => {
+  const fnSrc = extractFunction(INDEX_SRC, "pidRunsFrom");
+  const make = (cmd) => new Function("commandLineOfPid", `${fnSrc}\nreturn pidRunsFrom;`)(() => cmd);
+  assert.equal(make("")(123, "/home/u/.dsh-remote"), false, "取不到命令行 → 不动");
+  assert.equal(make("node /home/u/.dsh-remote/clients/dsh-remote/dsh-bridge.mjs")(123, "/home/u/.dsh-remote"), true);
+  assert.equal(make("node /opt/other/.dsh-remote/clients/dsh-remote/dsh-bridge.mjs")(123, "/home/u/.dsh-remote"), false,
+    "别的目录的 bridge 不得被停");
+  assert.equal(make("node C:\\Users\\u\\.dsh-remote\\clients\\dsh-remote\\dsh-bridge.mjs")(123, "C:\\Users\\u\\.dsh-remote"), true,
+    "Windows 反斜杠路径也要能匹配");
+});
+
+// ─────────────────────── ④ C2：watcher 侧孤儿 bridge 清扫 ───────────────────────
+
+test("C2 watcher 孤儿清扫：按「本运行时命令行」双重校验，且退出码 4 时暂停拉起", () => {
+  // 清扫函数必须同时校验脚本名与**本运行时**路径（别的配置目录/用户的 bridge 不碰）
+  const isCmd = extractFunction(SETUP_SRC, "isThisRuntimeBridgeCmd");
+  const make = (thisDir) => new Function("path", "THIS_DIR", `${isCmd}\nreturn isThisRuntimeBridgeCmd;`)(path, thisDir);
+  const check = make("/home/u/.dsh-remote");
+  assert.equal(check(`node /home/u/.dsh-remote/clients/dsh-remote/dsh-bridge.mjs --x`), true);
+  assert.equal(check(`node /opt/other/.dsh-remote/clients/dsh-remote/dsh-bridge.mjs`), false, "别的配置目录的 bridge 绝不能被扫到");
+  assert.equal(check(`node /home/u/.dsh-remote/clients/dsh-remote/wechat-channel.mjs`), false, "不是 bridge 脚本");
+
+  // 接管/退出时都要清扫孤儿（否则孤儿与新实例同 deviceId 互踢）
+  const run = SETUP_SRC.slice(SETUP_SRC.indexOf("async function runBridge() {"), SETUP_SRC.indexOf("// ---------- setup：一键安装"));
+  assert.ok(/const strays = sweepStrayBridges\(\);/.test(run), "watcher 启动/接管时要清扫 pid 文件之外的孤儿 bridge");
+  assert.ok(/sweepStrayBridges\(\{ fast: true \}\)/.test(run), "watcher 退出时也要顺手清扫（fast）");
+  // bridge 侧"重复实例"退出码必须与 watcher 侧一致（否则 watcher 不会暂停、继续 10s 重拉互踢）
+  assert.match(BRIDGE_SRC, /export const DUPLICATE_INSTANCE_EXIT_CODE = 4;/);
+  assert.match(SETUP_SRC, /const DUPLICATE_INSTANCE_EXIT_CODE = 4;/);
+  assert.ok(/code === DUPLICATE_INSTANCE_EXIT_CODE/.test(SETUP_SRC), "watcher 要识别这个退出码");
+  assert.ok(/duplicateBridgeBackoffUntil = Date\.now\(\) \+ DUPLICATE_BRIDGE_BACKOFF_MS/.test(SETUP_SRC),
+    "识别后必须暂停拉起（否则 10s 后又去顶撞对方）");
+});
+
+// ─────────────────────── ⑤ 端到端：一键更新真的会停掉本 relayDir 的旧 bridge ───────────────────────
+
+/** 假 npx：写一行进度（避免被"无输出看门狗"判卡住）后成功退出。 */
+const FAKE_NPX = `#!/bin/sh
+echo "[fake-npx] progress"
+sleep 0.3
+exit 0
+`;
+
+test("C8 端到端：一键更新覆盖运行时前，先结束本 relayDir 的旧 bridge（命令行校验通过才杀）", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "dsh-update-stop-"));
+  const fakeBin = path.join(root, "bin");
+  const relayDir = path.join(root, "relay");
+  const home = path.join(root, "home");
+  await mkdir(fakeBin, { recursive: true });
+  await mkdir(relayDir, { recursive: true });
+  await mkdir(home, { recursive: true });
+  await writeFile(path.join(fakeBin, "npx"), FAKE_NPX);
+  await chmod(path.join(fakeBin, "npx"), 0o755);
+  // 假"旧 bridge"：真进程 + 真命令行（路径在本 relayDir 下），才能过 collectRuntimePids/pidRunsFrom
+  const stub = path.join(relayDir, "clients", "dsh-remote", "dsh-bridge.mjs");
+  await mkdir(path.dirname(stub), { recursive: true });
+  await writeFile(stub, "setTimeout(() => {}, 600000);\n");
+  const oldBridge = spawn(process.execPath, [stub], { stdio: "ignore" });
+  await writeFile(path.join(relayDir, ".dsh-bridge.pid"), String(oldBridge.pid));
+
+  const saved = {};
+  for (const k of ["HOME", "DSH_SETUP_NPX_DIR", "DSH_RELAY_SKIP_SERVICE", "DSH_UPDATE_IDLE_MS", "DSH_INSTALL_IDLE_MS",
+    "DSH_STALL_POLL_MS", "DSH_REMOTE_TELEMETRY", "DSH_RELAY_SELFHEAL_MS"]) saved[k] = process.env[k];
+  process.env.HOME = home;
+  process.env.DSH_SETUP_NPX_DIR = fakeBin;
+  process.env.DSH_REMOTE_TELEMETRY = "0";
+  process.env.DSH_RELAY_SELFHEAL_MS = "600000"; // 别让自愈在我们观察期间另外拉起东西
+  delete process.env.DSH_RELAY_SKIP_SERVICE;    // 要真的走"停旧进程"分支
+
+  const routes = new Map();
+  apply({
+    webServer: { register(route) { routes.set(route.path, route.handler); return () => {}; } },
+    effect(register) { return register(); },
+    logger: { info() {}, warn() {} },
+  }, { relayDir });
+  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));
+  const base = `http://127.0.0.1:${host.address().port}`;
+  try {
+    const started = await (await fetch(base + "/dsh-remote/self/update", { method: "POST" })).json();
+    assert.equal(started.ok, true, `更新应能启动：${JSON.stringify(started)}`);
+    const logPath = path.join(relayDir, ".dsh-update.log");
+    const stopped = await waitFor(() => {
+      try { process.kill(oldBridge.pid, 0); return false; } catch { return true; }
+    }, { timeout: 8000 });
+    assert.equal(stopped, true, "★覆盖运行时的旧 bridge 必须被结束（否则半装 + 新老互踢）");
+    const log = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
+    assert.match(log, /覆盖运行时前已停旧 bridge\/watcher（pid /, `更新日志要写明停了哪些进程，实际：\n${log.slice(-600)}`);
+  } finally {
+    try { oldBridge.kill("SIGKILL"); } catch { /* 已退出 */ }
+    await new Promise((resolve) => host.close(resolve));
+    for (const [k, v] of Object.entries(saved)) { if (v === undefined) delete process.env[k]; else process.env[k] = v; }
+    await rm(root, { recursive: true, force: true });
+  }
+});