@mrrisega/dsh-remote 0.7.0-beta.1 → 0.7.0-beta.3

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

@@ -254,8 +254,25 @@ function resolveInstallVersion() {
     return JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8")).version || "";
   } catch { return ""; }
 }
+/**
+ * 宿主（DeepSeek Harness）版本：**由插件注入**，bridge 自己算不出来。
+ *
+ * 为什么必须是注入：宿主版本要从"宿主进程的 argv / 安装目录"推出来，而 bridge 是插件
+ * **另外拉起的独立进程**（脱离宿主，见 dsh-setup.mjs 的守护），它的 argv 与宿主毫无关系。
+ * 插件跑在宿主进程内，能拿到真实版本（见 packages/dsh-remote-web/lib/index.js 的
+ * harnessVersion()），所以由它经 DSH_BRIDGE_HARNESS_VERSION 传下来。
+ *
+ * 与 INSTALL_VERSION 的区别（曾经把这两个数混为一谈，导致版本问题答不出来）：
+ *   install_version = **本插件**的版本（用户装的 dsh-remote-web 是哪个版本）
+ *   harness_version = **宿主**的版本（用户跑的 DeepSeek Harness 是哪个版本）
+ * 只知其一都定位不了"是不是宿主升级导致的兼容性故障"。
+ */
+function resolveHarnessVersion() {
+  return String(process.env.DSH_BRIDGE_HARNESS_VERSION || "").trim();
+}
 const INSTALL_SOURCE = resolveInstallSource();
 const INSTALL_VERSION = resolveInstallVersion();
+const HARNESS_VERSION = resolveHarnessVersion();
 
 // ---------- 稳定设备身份(.dsh-config.json) ----------
 
@@ -320,21 +337,100 @@ const HARNESS_COOKIE_FILE = ".harness-cookie.json";
 const HARNESS_UNAUTHORIZED_TEXT = "dsh web authentication required";
 /** 撞到 401 时写的「作废」标记:插件在面板轮询时看到它就会立刻重换 Cookie(见 node 半 ensureHarnessCookie)。 */
 const HARNESS_COOKIE_REVOKED_FILE = ".harness-cookie-revoked";
-function markHarnessCookieRevoked() {
+
+/**
+ * Cookie 按 **authority 分文件**(0.7.0-beta.2 起,2026-10-09 事故根治)。
+ *
+ * 【事故】`~/.dsh-remote/` 只有一份 `.harness-cookie.json`,而 Web 端(3080)与桌面端(每次启动
+ *   随机端口)是**两个宿主、两个进程**,各自的插件都会往里写"自己 authority 的 Cookie" →
+ *   互相覆盖。桥撞 401 后重读磁盘,拿到的是**另一个宿主刚写的** Cookie(与失败的不是同一个)
+ *   → 重试 → 还是 401 → 再读 → 又被覆盖回去……**乒乓,永不自愈**。手机端持续白页。
+ * 【根治】每个宿主只写自己 authority 的文件:`.harness-cookie.<authority>.json`
+ *   (`:` 换成 `_`,如 `.harness-cookie.127.0.0.1_19387.json`),互不覆盖;桥只认
+ *   **当前上游 authority** 的那一份。旧版共享文件继续兼容读取,但**foreign authority 一律不用**
+ *   —— 那正是乒乓的来源。命名规则与插件半 `packages/dsh-remote-web/lib/index.js` 同名,
+ *   漂移由 `test/harness-cookie-authority.test.mjs` 的跨文件不变量锁住。
+ */
+function authoritySlug(authority) {
+  return String(authority).replace(/[^A-Za-z0-9._-]/g, "_");
+}
+/** 本宿主专属 Cookie 文件名(与插件半同规则)。 */
+function harnessCookieFileFor(authority) {
+  return `${HARNESS_COOKIE_FILE.slice(0, -".json".length)}.${authoritySlug(authority)}.json`;
+}
+/** 本宿主专属「作废」标记名(与插件半同规则)。 */
+function harnessCookieRevokedFileFor(authority) {
+  return `${HARNESS_COOKIE_REVOKED_FILE}.${authoritySlug(authority)}`;
+}
+/** 当前上游的 authority(`127.0.0.1:<port>`);取不到返回空串。 */
+function upstreamAuthorityOf(upstream) {
   try {
-    const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_REVOKED_FILE);
-    fs.writeFileSync(p, String(Date.now()), { mode: 0o600 });
-  } catch { /* 忽略:标记只为加速自愈 */ }
+    return new URL(String(upstream || UPSTREAM)).host || "";
+  } catch {
+    return "";
+  }
+}
+/** 已就"哪个 foreign authority 在抢"告警过的集合(每对只吵一次,不刷屏)。 */
+const foreignCookieWarned = new Set();
+function warnForeignCookieOnce(claimed, authority) {
+  const key = `${claimed}->${authority}`;
+  if (foreignCookieWarned.has(key)) return;
+  foreignCookieWarned.add(key);
+  console.warn(
+    `[bridge] 检测到另一宿主的会话 Cookie(${claimed}),而当前上游是 ${authority} —— ` +
+    `一台机器只能服务一个宿主,已跳过该 Cookie(不再乒乓重试)。` +
+    `若手机端仍 401,请确认 .dsh-upstream 指向正在运行的那个宿主,并让该宿主的插件重发 Cookie。`
+  );
 }
+function readCookieDoc(dir, file) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
+    return j && typeof j.cookie === "string" && j.cookie ? j : null;
+  } catch {
+    return null;
+  }
+}
+/**
+ * 当前上游该用的浏览器会话 Cookie(空串 = 没有可用的)。
+ *
+ * 取值顺序(2026-10-09 起):
+ *   ① 本宿主专属文件 `.harness-cookie.<authority>.json` —— 新插件写的,权威;
+ *   ② 旧版共享 `.harness-cookie.json` —— 仅当它声明的 `authority` 与当前上游一致,
+ *      或旧插件根本没写 authority 字段(向后兼容)时才用;
+ *   ③ 声明了**别的** authority → 明确不用,并告警一次(这就是乒乓的源头)。
+ */
 function harnessCookieOf() {
+  const dir = path.dirname(CONFIG_PATH);
+  const authority = upstreamAuthorityOf();
+  if (authority) {
+    const own = readCookieDoc(dir, harnessCookieFileFor(authority));
+    if (own) return own.cookie;
+  }
+  const legacy = readCookieDoc(dir, HARNESS_COOKIE_FILE);
+  if (!legacy) return "";
+  const claimed = typeof legacy.authority === "string" ? legacy.authority : "";
+  if (claimed === "" || authority === "" || claimed === authority) return legacy.cookie;
+  warnForeignCookieOnce(claimed, authority);
+  return "";
+}
+/** 本宿主 Cookie 是否处于「已作废、等插件重换」状态(诊断用,不参与取值)。 */
+function harnessCookieRevokedFor(authority) {
   try {
-    const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_FILE);
-    const j = JSON.parse(fs.readFileSync(p, "utf8"));
-    return j && typeof j.cookie === "string" && j.cookie ? j.cookie : "";
+    return fs.existsSync(path.join(path.dirname(CONFIG_PATH), harnessCookieRevokedFileFor(authority)));
   } catch {
-    return "";
+    return false;
   }
 }
+function markHarnessCookieRevoked() {
+  const dir = path.dirname(CONFIG_PATH);
+  const authority = upstreamAuthorityOf();
+  // 只写**本宿主**的标记:两个宿主各写各的,插件侧才不会被人家的 401 反复催着重换。
+  // (旧版共享标记 `.harness-cookie-revoked` 不再写:它是"两个写者抢一份文件"的同款隐患。)
+  if (!authority) return;
+  try {
+    fs.writeFileSync(path.join(dir, harnessCookieRevokedFileFor(authority)), String(Date.now()), { mode: 0o600 });
+  } catch { /* 忽略:标记只为加速自愈 */ }
+}
 
 /**
  * 解析稳定 deviceId:优先级 env DSH_BRIDGE_DEVICE_ID > argv[2] > 配置 device_id > 生成。
@@ -1320,6 +1416,9 @@ async function registerDeviceInAccount(token) {
         //   install_source: npx(安装器注入) | plugin_market(插件拉起/自愈,默认) | unknown(白名单外)
         install_source: INSTALL_SOURCE,
         install_version: INSTALL_VERSION,
+        // v15 宿主版本(由插件注入;老插件不注入 → 空串 = 未上报)。服务端 devices.harness_version。
+        // 与 install_version 是两个不同的数:前者是"插件版本",这个是"DeepSeek Harness 版本"。
+        harness_version: HARNESS_VERSION,
         host_os: process.platform,
         host_arch: process.arch
       })
@@ -1568,6 +1667,18 @@ function wechatAppUrl() {
 }
 
 let wechatRuntime = null;
+
+/**
+ * 微信事件通道要连的上游（**每次重连都会调一次**）。
+ *
+ * 行为：先顺手触发一次上游重发现（内部有 15s 冷却 + 单飞，反复调用不会打爆 lsof/探测），
+ * 再返回**当下**的 UPSTREAM。这样宿主换端口时通道能自己跟上，而不必重启 bridge。
+ */
+function currentUpstreamForChannel() {
+  void refreshUpstream("微信事件通道重连");
+  return UPSTREAM;
+}
+
 function startWeChat() {
   if (WECHAT_DISABLED) {
     console.log("[bridge] 微信通道已禁用(DSH_WECHAT=0)");
@@ -1578,10 +1689,15 @@ function startWeChat() {
     const cfg = loadLocalConfig();
     wechatRuntime = createWeChatRuntime({
       relayDir,
-      // 上游地址在 runTunnel() 开头已完成动态发现（见 refreshUpstream），所以这里拿到的是真实端口。
-      // ⚠️ 这是**取值**而非引用：运行中若上游端口又变了（自愈重发现），微信通道要等 bridge 重启才跟上；
-      //    隧道转发那一侧不受影响（它每次都读最新的 UPSTREAM）。
-      upstream: UPSTREAM,
+      // 传**取值器**而不是当次的值（0.7.0-beta.2 修复）。
+      //
+      // 【2026-10-09 真机事故】这里以前传的是 `UPSTREAM` 这个**当次快照**：bridge 起来时宿主还在
+      //   3080，随后宿主换了端口（Desktop 每次启动随机），隧道转发侧因为每次读最新 UPSTREAM 而
+      //   一切正常，**唯独微信事件通道抱着 3080 死循环重连** —— 现象极具迷惑性：手机能开页面、
+      //   bridge-status 显示 online，但任务跑完**一条推送都没有**，日志里只有刷屏的
+      //   `connect ECONNREFUSED 127.0.0.1:3080`。
+      // 现在取值器每次重连都会重新求值，并在打到死端口时主动触发一次上游重发现。
+      upstream: () => currentUpstreamForChannel(),
       cookieOf: harnessCookieOf,
       secret: process.env.DSH_BRIDGE_SECRET || (typeof cfg.bridge_secret === "string" ? cfg.bridge_secret : ""),
       // 免费/付费分层:档位来自账号的生效套餐,App 链接是免费用户越界时的转化入口。

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

@@ -457,6 +457,17 @@ class EventSubscriber extends EventEmitter {
    */
   #cursors = new Map();
 
+  /**
+   * 上一次**连接尝试**用的上游 URL（不是"成功"的那一次）。
+   *
+   * 为什么记"尝试"而不是"成功"：上游端口从 A 换到 B 时，第一轮打 B 必然是失败的
+   * （B 还没起来），若只在成功后才更新，就会每轮都判成"目标变了"而重置退避 ——
+   * 退避彻底失效、变成猛敲 B。记"上次尝试过的目标"才能做到**同一个目标只重置一次**。
+   */
+  #lastConnectUrl = null;
+  /** 上一次成功求值到的上游（getter 抛错/返回空时的回退，保证不会去打空地址）。 */
+  #lastGoodUpstream = null;
+
   #seq = 0;
   #lastFrameAt = 0;
   #authStatus = null;
@@ -465,11 +476,19 @@ class EventSubscriber extends EventEmitter {
 
   constructor(options = {}) {
     super();
-    if (typeof options.upstream !== "string" || options.upstream.trim() === "") {
+    const upstreamGiven = typeof options.upstream === "function"
+      ? true
+      : typeof options.upstream === "string" && options.upstream.trim() !== "";
+    if (!upstreamGiven) {
       throw new TypeError("dsh-events: options.upstream is required (e.g. http://127.0.0.1:3080)");
     }
+    // upstream 允许是**函数**（每次连接时求值）：宿主端口会变（`dsh web --port 0`、
+    // DSH Desktop 每次启动随机端口），写死字符串的话端口一变，本订阅器就会永久打旧端口。
+    const upstreamGetter = typeof options.upstream === "function"
+      ? options.upstream
+      : () => options.upstream;
     this.#opts = {
-      upstream: options.upstream.replace(/\/+$/, ""),
+      upstreamGetter,
       cookie: options.cookie ?? "",
       muxPath: options.muxPath ?? MUX_PATH,
       /** HTTP 路由（默认 `/api/$events/result`）。 */
@@ -631,8 +650,27 @@ class EventSubscriber extends EventEmitter {
     }
   }
 
-  #muxUrl() {
-    const url = new URL(this.#opts.upstream);
+  /**
+   * 当前上游地址（**每次调用都重新求值**，见构造函数里 upstream 可为函数的说明）。
+   *
+   * 求值失败（函数抛错 / 返回空 / 不是合法 URL）时回退到上一次成功用过的地址，
+   * 保证"取不到新地址"永远不会变成"打一个空 URL"。真的没得回退时返回空串，
+   * 由 `#connect()` 如实报错，而不是静默重连到垃圾地址。
+   */
+  #upstream() {
+    let raw;
+    try {
+      raw = this.#opts.upstreamGetter();
+    } catch (error) {
+      this.#log("warn", "upstream getter threw", { error: String(error) });
+      return this.#lastGoodUpstream ?? "";
+    }
+    const value = typeof raw === "string" ? raw.replace(/\/+$/, "") : "";
+    return value || this.#lastGoodUpstream || "";
+  }
+
+  #muxUrl(upstream) {
+    const url = new URL(upstream);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     url.pathname = this.#opts.muxPath;
     url.search = "";
@@ -643,16 +681,35 @@ class EventSubscriber extends EventEmitter {
   #connect() {
     if (this.#closed) return;
     this.#state = "connecting";
+    const upstream = this.#upstream();
+    if (upstream === "") {
+      this.#state = "auth-failed";
+      this.#emitAuthError(0, "upstream 不可用（取不到宿主地址）", "ws");
+      return;
+    }
+    // 目标变了 = 宿主换了端口（Desktop 每次启动随机 / `dsh web` 重启到新端口）。
+    // 把退避重置，否则旧目标上累积的长退避会让"换了端口反而更慢连上"（最长要等满 maxMs）。
+    if (upstream !== this.#lastConnectUrl) {
+      if (this.#lastConnectUrl !== null) {
+        this.#log("info", `上游切换 ${this.#lastConnectUrl} → ${upstream}，重连退避已重置`, {
+          from: this.#lastConnectUrl,
+          to: upstream,
+        });
+      }
+      this.#lastConnectUrl = upstream;
+      this.#attempt = 0;
+    }
+    this.#lastGoodUpstream = upstream;
     let url;
     try {
-      url = this.#muxUrl();
+      url = this.#muxUrl(upstream);
     } catch (error) {
       this.#state = "auth-failed";
       this.#emitAuthError(0, `upstream 不是合法 URL: ${String(error)}`, "ws");
       return;
     }
     // Host 显式写成上游 authority（loopback 围栏），Cookie 复用 bridge 已持有的浏览器会话。
-    const headers = { Host: new URL(this.#opts.upstream).host };
+    const headers = { Host: new URL(upstream).host };
     const cookie = this.#cookieValue();
     if (cookie !== "") headers.Cookie = cookie;
 
@@ -1411,7 +1468,8 @@ class EventSubscriber extends EventEmitter {
   async #rpc(method, args, eventId) {
     const rpcId = randomUUID();
     const envelope = { type: "client-request", rpcId, method, payload: { args } };
-    const url = `${this.#opts.upstream}${API_CHANNEL}/${method}`;
+    // 回执/RPC 也走**当前**上游（端口变了就跟着走），不是一个启动时固化的字符串。
+    const url = `${this.#upstream()}${API_CHANNEL}/${method}`;
 
     const timeoutMs = Number(this.#opts.rpcTimeoutMs);
     const budgeted = Number.isFinite(timeoutMs) && timeoutMs > 0;
@@ -1984,7 +2042,7 @@ export function classifyTurnEnd(sessionId, event, at) {
 /**
  * 创建一个订阅器。
  * @param {{
- *   upstream: string,
+ *   upstream: string|(() => string),  // 函数 = 每次连接/每次 RPC 重新求值（宿主端口会变）
  *   cookie?: string|(() => string),
  *   muxPath?: string,
  *   resultPath?: string,

package/clients/dsh-remote/mobile-adapter.mjs

@@ -1244,7 +1244,12 @@ const SCRIPT = `(() => {
          旧的 120/300 分档是照"网页首屏"的体感定的，会把大量正常可用的移动网络误报成"较慢"，
          反而让用户以为哪里坏了。 */
       const RTT_KEEP = 8, RTT_MAX_MS = 20000;
-      const rttSamples = [];
+      /* 🔴 样本数组挂在 window 上，**不在 buildRemoteMenu 的闭包里**（2026-10-09 加固）。
+         为什么：fetch 包装只装一次（window.__dshMaSessionWatch 一次性闸门），而菜单/悬浮按钮
+         在官方 SPA 重渲染时可能被**重建**。若样本数组长在 buildRemoteMenu 里，包装就会一直喂给
+         "上一代"渲染器（那个节点已经不在文档里），新界面读自己的空数组 → **永远停在「测速中…」**。
+         挂在 window 上则任何一代渲染器都读同一份样本。 */
+      const rttSamples = (window.__dshMaRttSamples || (window.__dshMaRttSamples = []));
       const rttEl = fab.querySelector('[data-role="rtt"]');
       const netEl = menu.querySelector('[data-role="net"]');
       const rttValue = () => {
@@ -1262,11 +1267,13 @@ const SCRIPT = `(() => {
         try {
           const ms = rttValue();
           const g = ms === null ? "" : rttGrade(ms);
+          // 0ms 是句谎话（不足 1ms 的真实往返会被四舍五入成 0）→ 展示层夹到 ≥1ms。
+          const shown = ms === null ? null : Math.max(1, Math.round(ms));
           if (rttEl) {
-            if (ms === null) { rttEl.hidden = true; rttEl.textContent = ""; rttEl.removeAttribute("data-rtt"); }
+            if (shown === null) { rttEl.hidden = true; rttEl.textContent = ""; rttEl.removeAttribute("data-rtt"); }
             else {
               rttEl.hidden = false;
-              rttEl.textContent = ms + "ms";
+              rttEl.textContent = shown + "ms";
               rttEl.setAttribute("data-rtt", g);
             }
           }
@@ -1274,17 +1281,22 @@ const SCRIPT = `(() => {
             netEl.setAttribute("data-rtt", g || "");
             const ico = netEl.querySelector(".ico");
             const txt = netEl.querySelector(".txt");
-            if (ico) ico.textContent = ms === null ? "📶" : (g === "bad" ? "📵" : "📶");
-            if (txt) txt.textContent = ms === null ? "测速中…（等一次网络请求后显示）" : (ms + " ms · " + rttLabel(g));
+            if (ico) ico.textContent = shown === null ? "📶" : (g === "bad" ? "📵" : "📶");
+            if (txt) txt.textContent = shown === null ? "测速中…（等一次网络请求后显示）" : (shown + " ms · " + rttLabel(g));
           }
-          try { fab.title = ms === null ? FAB_TITLE_BASE : ("远程控制：网络延迟 " + ms + "ms（" + rttLabel(g) + "） / 字号 / 加密状态 / 返回设备列表（可拖动）"); } catch (e) { /* 忽略 */ }
+          try { fab.title = shown === null ? FAB_TITLE_BASE : ("远程控制：网络延迟 " + shown + "ms（" + rttLabel(g) + "） / 字号 / 加密状态 / 返回设备列表（可拖动）"); } catch (e) { /* 忽略 */ }
         } catch (e) { /* 延迟显示失败绝不影响主功能 */ }
       };
       /** 记一个成功样本（由 fetch 包装在**响应到达**时调用；失败/超时不调用）。 */
       const noteRtt = (ms) => {
         if (typeof ms !== "number" || !isFinite(ms)) return;
         const r = Math.round(ms);
-        if (r < 1 || r > RTT_MAX_MS) return;      // 亚毫秒=同帧缓存命中；>20s=卡住/超时 → 都不是"网络延迟"
+        /* 🔴 旧写法是 if (r < 1 || ...) return; ，注释说"亚毫秒=同帧缓存命中"。这个假设是**错的**：
+           本机/回环访问（桌面端自测、在同一台机器上打开镜像页）一次真实往返往往就是 < 1ms，
+           于是**每一个**样本都被丢掉，界面永远停在「测速中…（等一次网络请求后显示）」——
+           业主 2026-10-09 实测反馈的正是这个现象。只拒绝负数与超时；0 → 展示层夹到 1ms。
+           （面板侧 chip 从一开始就是 v <= 0 + Math.max(1, round)，两边口径由此对齐。） */
+        if (r < 0 || r > RTT_MAX_MS) return;
         rttSamples.push(r);
         while (rttSamples.length > RTT_KEEP) rttSamples.shift();
         renderRtt();

package/clients/dsh-remote/test/device-registration-report.test.mjs

@@ -0,0 +1,133 @@
+// 设备登记上报口径回归（2026-10 版本分析需求）。
+//
+// 【为什么必须有】生产反馈只能看到「插件版本」（install_version），从来拿不到
+//   「宿主 DeepSeek Harness 版本」—— 于是「是不是 DSH 升级导致的兼容性故障」这个问题
+//   在后台**答不出来**（数据不能回填，只能从新版开始积累）。
+//   宿主版本由插件在**宿主进程里**问出来（harnessVersion()），经 DSH_BRIDGE_HARNESS_VERSION
+//   传给 bridge；bridge 自己（独立进程）推不出来。本用例走真实 bridge 进程 + 假账号 API，
+//   逐字断言**桥到底往 /api/devices 发了什么**。
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import http from "node:http";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const BRIDGE = path.join(HERE, "..", "dsh-bridge.mjs");
+
+test("设备登记：harness_version（宿主版本）与 install_version（插件版本）必须分别如实上报", async () => {
+  let seen = null;
+  const api = http.createServer((req, res) => {
+    if (req.url === "/api/device-login") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ token: "token-1" }));
+      return;
+    }
+    if (req.url === "/api/devices") {
+      let raw = "";
+      req.on("data", (c) => { raw += c; });
+      req.on("end", () => {
+        try { seen = JSON.parse(raw); } catch { seen = { parseError: raw }; }
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ device: { id: "dev-000000000002" } }));
+      });
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
+  });
+  await new Promise((resolve) => api.listen(0, "127.0.0.1", resolve));
+
+  const wss = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+  await new Promise((resolve) => wss.once("listening", resolve));
+
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dsh-device-report-"));
+  const child = spawn(process.execPath, [BRIDGE], {
+    env: {
+      ...process.env,
+      DSH_BRIDGE_API: `http://127.0.0.1:${api.address().port}`,
+      DSH_BRIDGE_TUNNEL_URL: `ws://127.0.0.1:${wss.address().port}`,
+      DSH_BRIDGE_PHONE: "test-account",
+      DSH_BRIDGE_PASSWORD: "test-password",
+      DSH_BRIDGE_DEVICE_ID: "dev-000000000002",
+      DSH_BRIDGE_CONFIG: path.join(tempDir, "config.json"),
+      // 插件在宿主进程里探测到的宿主版本 → 经环境变量注入 bridge
+      DSH_BRIDGE_HARNESS_VERSION: "0.2.0-rc.2",
+      DSH_BRIDGE_INSTALL_VERSION: "0.7.0-beta.2",
+      DSH_BRIDGE_INSTALL_SOURCE: "plugin_market",
+    },
+    stdio: "ignore",
+  });
+
+  try {
+    for (let i = 0; i < 60 && !seen; i += 1) await delay(100, null, { ref: false });
+    assert.ok(seen, "bridge 应在 6 秒内完成设备登记（POST /api/devices）");
+    assert.equal(seen.harness_version, "0.2.0-rc.2", "★宿主版本必须进登记请求（这是本次需求的核心）");
+    assert.equal(seen.install_version, "0.7.0-beta.2", "插件版本照旧上报，两个数都要有");
+    assert.equal(seen.install_source, "plugin_market");
+    assert.equal(seen.device_id, "dev-000000000002");
+    assert.ok(seen.host_os && seen.host_arch, "平台/架构照旧");
+  } finally {
+    try { child.kill("SIGKILL"); } catch { /* 已退出 */ }
+    await new Promise((r) => wss.close(r));
+    await new Promise((r) => api.close(r));
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("设备登记：老插件不注入 DSH_BRIDGE_HARNESS_VERSION 时，字段必须是空串（不是缺字段、更不是猜）", async () => {
+  let seen = null;
+  const api = http.createServer((req, res) => {
+    if (req.url === "/api/device-login") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ token: "token-1" }));
+      return;
+    }
+    if (req.url === "/api/devices") {
+      let raw = "";
+      req.on("data", (c) => { raw += c; });
+      req.on("end", () => {
+        try { seen = JSON.parse(raw); } catch { seen = null; }
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ device: { id: "dev-000000000003" } }));
+      });
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
+  });
+  await new Promise((resolve) => api.listen(0, "127.0.0.1", resolve));
+  const wss = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+  await new Promise((resolve) => wss.once("listening", resolve));
+
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dsh-device-report-"));
+  const env = { ...process.env };
+  delete env.DSH_BRIDGE_HARNESS_VERSION;   // 模拟老插件
+  const child = spawn(process.execPath, [BRIDGE], {
+    env: {
+      ...env,
+      DSH_BRIDGE_API: `http://127.0.0.1:${api.address().port}`,
+      DSH_BRIDGE_TUNNEL_URL: `ws://127.0.0.1:${wss.address().port}`,
+      DSH_BRIDGE_PHONE: "test-account",
+      DSH_BRIDGE_PASSWORD: "test-password",
+      DSH_BRIDGE_DEVICE_ID: "dev-000000000003",
+      DSH_BRIDGE_CONFIG: path.join(tempDir, "config.json"),
+    },
+    stdio: "ignore",
+  });
+  try {
+    for (let i = 0; i < 60 && !seen; i += 1) await delay(100, null, { ref: false });
+    assert.ok(seen, "bridge 仍应完成设备登记");
+    assert.equal(seen.harness_version, "", "取不到就上报空串（= 未上报），绝不猜一个错的版本");
+  } finally {
+    try { child.kill("SIGKILL"); } catch { /* 已退出 */ }
+    await new Promise((r) => wss.close(r));
+    await new Promise((r) => api.close(r));
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/clients/dsh-remote/test/dsh-events.test.mjs

@@ -2085,3 +2085,91 @@ test("★ 一次 follow 失败不该把这条会话**永久**钉死：下一轮
     await api.close();
   }
 });
+
+// ============================================================
+// 上游是**函数**：宿主换端口要能自己跟上（2026-10-09 真机事故回归）
+// ============================================================
+
+/**
+ * 【事故原貌】bridge 起来时宿主在 3080，随后宿主换端口（DSH Desktop 每次启动都是随机端口）。
+ * 隧道转发侧每次都读最新 UPSTREAM，所以一切正常；**唯独事件订阅器抱着启动那一刻的字符串**，
+ * 于是永久 `connect ECONNREFUSED 127.0.0.1:3080` —— 手机能开页面、面板显示 online，
+ * 但任务跑完**一条微信推送都没有**。迷惑性极强，最后靠 bridge 日志里刷屏的那一行才定位。
+ *
+ * 修法：`upstream` 允许传函数，每次连接/RPC 重新求值。这条用例就是那件事的锁。
+ */
+test("★ 事故锁：upstream 传函数时，宿主换端口后订阅器必须自己跟过去（不得永久打旧端口）", async () => {
+  const a = await startFakeDsh();
+  const b = await startFakeDsh();
+  let current = a.base;
+  const logs = [];
+  const sub = createEventSubscriber({
+    upstream: () => current,
+    cookie: () => a.cookie,
+    followSettleMs: 20,
+    reconnect: { minMs: 15, maxMs: 40, factor: 1, jitter: 0 },
+    log: (level, message) => logs.push(`${level}:${message}`),
+  });
+  try {
+    const first = await start(sub);
+    assert.ok(first.clientId, "先连上 A（模拟宿主最初的端口）");
+
+    // 宿主换端口：A 下线、B 上线，取值器开始返回 B。
+    await a.close();
+    current = b.base;
+
+    const second = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("换端口后没能自行连上 B（会永久打旧端口）")), 3_000);
+      timer.unref?.();
+      sub.on("ready", (info) => {
+        clearTimeout(timer);
+        resolve(info);
+      });
+    });
+    assert.ok(second.clientId, "必须自己连上 B 并拿到新的 clientId");
+    // clientId 是**每个服务端各自从 client-1 开始编号**的，不能拿它证明"换了连接"；
+    // 真正的证据是：B（新端口）确实收到了这条 mux 连接。
+    assert.equal(b.state.connections.length, 1, "新上游 B 必须真的收到了连接");
+    assert.ok(
+      logs.some((l) => l.includes("上游切换") && l.includes(b.base)),
+      `切换上游时必须留下可排查的日志（实际：${JSON.stringify(logs)}）`,
+    );
+  } finally {
+    sub.close();
+    await a.close().catch(() => {});
+    await b.close();
+  }
+});
+
+test("upstream 传函数但取值器抛错/返回空：绝不退化成打空地址（回退上一次可用地址）", async () => {
+  const a = await startFakeDsh();
+  let mode = "ok";
+  const logs = [];
+  const sub = createEventSubscriber({
+    upstream: () => {
+      if (mode === "throw") throw new Error("取值器炸了");
+      if (mode === "empty") return "";
+      return a.base;
+    },
+    cookie: () => a.cookie,
+    followSettleMs: 20,
+    reconnect: { minMs: 15, maxMs: 40, factor: 1, jitter: 0 },
+    log: (level, message) => logs.push(`${level}:${message}`),
+  });
+  try {
+    await start(sub);
+    mode = "empty";
+    // 断掉当前连接以触发一次退避重连：必须仍然打到 A（回退上次可用地址），而不是某个空 URL。
+    const before = a.state.connections.length;
+    a.currentConn().ws.terminate();
+    await waitFor(() => a.state.connections.length > before, { label: "退避重连（回退上次可用地址）" });
+    mode = "throw";
+    const before2 = a.state.connections.length;
+    a.currentConn().ws.terminate();
+    await waitFor(() => a.state.connections.length > before2, { label: "取值器抛错后仍能重连" });
+    assert.ok(!logs.some((l) => l.includes("upstream 不可用")), "有可回退的地址时不该报『upstream 不可用』");
+  } finally {
+    sub.close();
+    await a.close();
+  }
+});