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

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

@@ -9,6 +9,10 @@
 //       ① 官方「设置」→「远程访问」栏目（settings.section，位于「Agent 预设」下方，官方扩展点）；
 //       ② 左侧官方「设置」按钮旁注入独立「📱 远程访问」快捷按钮（id=dru-nav-remote，非 clone，
 //          插在其前方、同布局不覆盖官方按钮；点击直达该栏目，首次带引导红点）
+//          ⚠️ 只认**语义锚点**（`button[aria-haspopup="dialog"]`，且必须在设置弹层之外）：
+//             0.2 桌面端的设置面板本身就是 role="dialog" 的弹层，它的栏目也叫「通用设置」，
+//             旧代码用「文本包含『设置』」去找锚点 → 按钮被塞进设置面板栏目列表最上面（业主反馈的
+//             「植入错了地方」）。现在找不到锚点就**不注入**，绝不将就一个错误的落点。
 //   - 栏目内联渲染配置面板（浅色高对比 UI，遵循主流登录体验）
 //     · 登录态：已登录显示账号 + 退出登录；未登录显示 登录/注册 tabs
 //     · 🔒 修改密码（账号卡）：已登录账号经 图形验证码+短信验证码 重置（/dsh-remote/password/reset 代理）；
@@ -792,35 +796,87 @@ window.__ModuleLoader__.load({
         return !!el.closest('[role="navigation"], nav, [class*="sidebar" i], [class*="sidenav" i], [class*="appnav" i], [class*="navRail" i]');
       } catch (e) { return false; }
     }
-    function pickNavByToken(token) {
+    /**
+     * 是否位于「设置」弹层内部。
+     *
+     * 🔴 这一条是 2026-10-09 桌面端事故的根治点。官方设置面板本身就是一个
+     * `role="dialog" aria-modal="true"` 的弹层（0.2 实测，见 ui-settings-general 的 SettingsRoot），
+     * 它的左侧栏目同样长得像「导航」（`nav` + `navCell`），于是会被 navCellLike 命中。
+     * 旧代码用「文本包含『设置』」去找侧栏那颗齿轮按钮 —— 而弹层里的第一项叫
+     * **「通用设置」**，`indexOf("设置") !== -1` 直接命中，注入按钮就被塞进了
+     * 设置面板的栏目列表最上面（用户反馈的「植入错了地方」）。
+     */
+    function navInDialog(el) {
+      try { return !!el.closest('[role="dialog"], [aria-modal="true"]'); } catch (e) { return false; }
+    }
+    /**
+     * 官方「设置」触发器（侧栏那颗齿轮按钮）—— **只认语义锚点**。
+     *
+     * 两个版本（Web 0.1.x / 桌面端 0.2）的触发器都是同一个形状（各自实测源码一致）：
+     *   `<button aria-label="设置" aria-haspopup="dialog" aria-expanded=…>`，外层 `…triggerRow`。
+     * `aria-haspopup="dialog"` 是**语言无关**的语义标记，比匹配文案稳（换语言/换文案都不失效）。
+     * 找不到就**不注入** —— 宁可不显示快捷入口，也绝不把按钮塞到别人家的面板里。
+     */
+    function pickSettingsTrigger() {
+      try {
+        var cands = document.querySelectorAll('button[aria-haspopup="dialog"], [aria-haspopup="dialog"]');
+        for (var i = 0; i < cands.length; i++) {
+          var el = cands[i];
+          if (!el || el.id === NAV_ENTRY_ID) continue;   // 排除注入按钮自身
+          if (navInDialog(el)) continue;                 // 弹层里的（含面板内的关闭/栏目）一律不要
+          if (!navCellLike(el)) continue;
+          if (NAV_BAD_RE.test(String(el.className || ""))) continue;
+          return el;
+        }
+      } catch (e) { /* 忽略 */ }
+      // 兜底：严格等值匹配（**不做子串匹配**，否则又会命中「通用设置」）；且必须在弹层外
+      return pickNavByToken("设置", { exactOnly: true, insideDialog: false });
+    }
+    /**
+     * 按文案/aria-label 找导航项。
+     * @param {string} token 目标文案（如「远程访问」「设置」）
+     * @param {{exactOnly?:boolean, insideDialog?:boolean}} [opts]
+     *   exactOnly=true 只接受完全相等；insideDialog 限定是否必须在设置弹层内。
+     *   无论哪种模式：**精确相等优先于子串**（老代码只要子串命中就返回，误伤面很大）。
+     */
+    function pickNavByToken(token, opts) {
+      var exactOnly = !!(opts && opts.exactOnly);
+      var insideDialog = opts ? opts.insideDialog : undefined;
       try {
         var els = document.querySelectorAll("button, [role='tab'], [role='menuitem'], [role='button'], a, [aria-label]");
+        var loose = null;
         for (var i = 0; i < els.length; i++) {
           var el = els[i];
           if (!el || el.id === NAV_ENTRY_ID) continue; // 排除注入按钮自身(防递归)
           if (!navCellLike(el)) continue;
           if (NAV_BAD_RE.test(String(el.className || ""))) continue;
+          var inDlg = navInDialog(el);
+          if (insideDialog === true && !inDlg) continue;
+          if (insideDialog === false && inDlg) continue;
           var t = navCleanText(el);
-          if (t && !/\r|\n/.test(t) && t.length <= NAV_TEXT_MAX &&
-              (t === token || t.indexOf(token) === 0 || t.indexOf(token) !== -1)) return el;
           var at = navAttrOf(el);
-          if (at && (at === token || at.indexOf(token) === 0)) return el;
+          var textOK = !!(t && !/\r|\n/.test(t) && t.length <= NAV_TEXT_MAX);
+          if ((textOK && t === token) || (at && at === token)) return el;              // 精确命中：立即返回
+          if (!loose && ((textOK && t.indexOf(token) !== -1) || (at && at.indexOf(token) === 0))) loose = el;
         }
+        return exactOnly ? null : loose;
       } catch (e) { /* 忽略 */ }
       return null;
     }
     /** 打开「远程访问」设置栏目：栏目已渲染直接点；否则先点官方「设置」再 ≤3s 轮询补点。 */
     function openRemoteSettings() {
       try {
-        var cell = pickNavByToken("远程访问");
+        // 栏目项在设置弹层内 → 这里**允许**弹层内匹配（insideDialog: true）；
+        // 精确相等优先，避免命中「通用设置」这类含「设置」的邻居。
+        var cell = pickNavByToken("远程访问", { insideDialog: true });
         if (cell) { cell.click(); return; }
-        var st = pickNavByToken("设置");
+        var st = pickSettingsTrigger();   // 侧栏那颗齿轮（语义锚点，绝不落进弹层）
         if (!st) return;
         st.click();
         var tries = 0;
         var iv = setInterval(function () {
           tries++;
-          var c2 = pickNavByToken("远程访问");
+          var c2 = pickNavByToken("远程访问", { insideDialog: true });
           if (c2) { clearInterval(iv); c2.click(); }
           else if (tries >= NAV_POLL_MAX) clearInterval(iv);
         }, 150);
@@ -830,6 +886,9 @@ window.__ModuleLoader__.load({
     function mountNavEntry(host) {
       try {
         if (document.getElementById(NAV_ENTRY_ID)) return;
+        // 最后一道防线：无论调用方怎么找的，**绝不**把入口塞进设置弹层内部
+        // （2026-10-09 桌面端事故：按钮出现在设置面板栏目列表最上面）。
+        if (navInDialog(host)) return;
         var wrap = host && host.parentNode;
         if (!wrap || !wrap.insertBefore || !wrap.contains) return;
         var btn = document.createElement("button");
@@ -871,7 +930,7 @@ window.__ModuleLoader__.load({
       var iv = setInterval(function () {
         try {
           if (document.getElementById(NAV_ENTRY_ID)) return; // 已注入
-          var host = pickNavByToken("设置");
+          var host = pickSettingsTrigger();   // 只认 aria-haspopup="dialog" 的官方「设置」触发器
           if (host) mountNavEntry(host);
         } catch (e) { /* 忽略 */ }
       }, 2000);

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

@@ -21,7 +21,7 @@
 //
 // 不依赖任何第三方包：只使用 node 内置模块与 cordis 注入的 webServer 服务。
 import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync, accessSync, chmodSync, openSync, closeSync, readSync, fstatSync, rmSync, renameSync, statSync, copyFileSync, cpSync, constants as fsConstants } from "node:fs";
-import { join, dirname, sep, delimiter } from "node:path";
+import { join, dirname, sep, delimiter, isAbsolute } from "node:path";
 import { execSync, spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
@@ -740,6 +740,34 @@ function applySaaSMode(cfg) {
  * 老版本(无该鉴权)下 connection 服务没有 authenticatedUrl → 静默跳过,行为不变。
  */
 const HARNESS_COOKIE_FILE = ".harness-cookie.json";
+/**
+ * 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 一律跳过。
+ *   命名规则与桥半 `clients/dsh-remote/dsh-bridge.mjs` 同名,漂移由
+ *   `clients/dsh-remote/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)}`;
+}
+/** 由本进程 webServer 端口推出 authority(与 bridge 的 Host 口径一致)。 */
+function harnessAuthorityOfPort(port) {
+  return port ? `127.0.0.1:${port}` : "";
+}
 /**
  * 手机端 401「dsh web authentication required; reopen the URL printed by dsh web」的根因就在这里：
  * 该 Cookie 由本插件在进程内经 ?token= 换取后交给 bridge 代持，**dsh web 每次重启都会换签名密钥**，
@@ -786,22 +814,47 @@ async function mintHarnessCookie(ctx, relayDir) {
     if (UNINSTALLED_DIRS.has(relayDir)) return false;
     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 的完整访问权，同样要收紧
+    // ① 本宿主专属文件(权威,两个宿主互不覆盖 —— 事故根治点)
+    const ownPath = join(relayDir, harnessCookieFileFor(out.authority));
+    writeFileSync(ownPath, JSON.stringify(out, null, 2), { mode: 0o600 });
+    hardenFile(ownPath); // 会话 Cookie ≈ dsh web 的完整访问权，同样要收紧
+    // ② 旧版共享文件镜像:只为还跑着旧桥(<0.7.0-beta.2)的机器保留 —— 新桥优先读 ①,
+    //    且对 authority 不符的镜像**直接跳过**,所以这里写镜像不会再引发乒乓。
+    const legacyPath = join(relayDir, HARNESS_COOKIE_FILE);
+    writeFileSync(legacyPath, JSON.stringify(out, null, 2), { mode: 0o600 });
+    hardenFile(legacyPath);
     return true;
   } catch {
     return false;
   }
 }
 
-/** 读取当前 Cookie 文件状态:{cookie, authority, mintedAt} 或 null。 */
-function readHarnessCookie(relayDir) {
-  try {
-    const j = JSON.parse(readFileSync(join(relayDir, HARNESS_COOKIE_FILE), "utf8"));
-    return j && typeof j.cookie === "string" && j.cookie ? j : null;
-  } catch {
-    return null;
+/**
+ * 读取当前 authority 可用的 Cookie 文件状态:{cookie, authority, mintedAt} 或 null。
+ *   ① 本宿主专属文件优先;
+ *   ② 旧版共享文件仅在 authority 对得上、或旧插件没写 authority 字段(兼容)时采用;
+ *   ③ 声明了别的 authority → 明确不用(那属于另一个宿主,用了必然 401)。
+ * @param {string} relayDir 配置目录
+ * @param {string} [authority] 本进程 authority(`127.0.0.1:<port>`);缺省只做兼容读取
+ */
+function readHarnessCookie(relayDir, authority) {
+  const read = (file) => {
+    try {
+      const j = JSON.parse(readFileSync(join(relayDir, file), "utf8"));
+      return j && typeof j.cookie === "string" && j.cookie ? j : null;
+    } catch {
+      return null;
+    }
+  };
+  if (authority) {
+    const own = read(harnessCookieFileFor(authority));
+    if (own) return own;
   }
+  const legacy = read(HARNESS_COOKIE_FILE);
+  if (!legacy) return null;
+  const claimed = typeof legacy.authority === "string" ? legacy.authority : "";
+  if (claimed === "" || !authority || claimed === authority) return legacy;
+  return null; // foreign authority:另一个宿主的 Cookie,本宿主用不了
 }
 
 let harnessMintInflight = false;
@@ -819,9 +872,22 @@ let harnessMintLastAt = 0;
  */
 async function ensureHarnessCookie(ctx, relayDir, opts) {
   const force = !!(opts && opts.force);
-  const revoked = existsSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE));
+  const authority = harnessAuthorityOfPort(ctx.webServer?.port);
+  const ownRevokedPath = authority ? join(relayDir, harnessCookieRevokedFileFor(authority)) : "";
+  const legacyRevokedPath = join(relayDir, HARNESS_COOKIE_REVOKED_FILE);
+  const cur = readHarnessCookie(relayDir, authority);
+  // 作废标记两个来源:
+  //   ① 本宿主专属标记(新桥 0.7.0-beta.2+ 写)—— 精确,不会被人家的 401 催着重换;
+  //   ② 旧版共享标记(旧桥写)—— 仅当它**晚于**我们手上这份 Cookie 时才认:说明是它被拒了。
+  //      否则(比如另一个宿主刚被拒、标记比我们的 Cookie 还旧)不理会,避免两个宿主互相催。
+  let revoked = ownRevokedPath !== "" && existsSync(ownRevokedPath);
+  if (!revoked && existsSync(legacyRevokedPath)) {
+    try {
+      const revokedAt = Number(readFileSync(legacyRevokedPath, "utf8").trim()) || 0;
+      revoked = !cur || revokedAt > Number(cur.mintedAt || 0);
+    } catch { /* 标记读不到就当没有 */ }
+  }
   if (!force && !revoked) {
-    const cur = readHarnessCookie(relayDir);
     if (cur && Date.now() - Number(cur.mintedAt || 0) < HARNESS_COOKIE_STALE_MS) return true;
   }
   if (harnessMintInflight) return false;              // 去重:同一时刻只换一次
@@ -831,7 +897,11 @@ async function ensureHarnessCookie(ctx, relayDir, opts) {
   try {
     const ok = await mintHarnessCookie(ctx, relayDir);
     if (ok || revoked) {
-      try { rmSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE), { force: true }); } catch { /* ignore */ }
+      // 清标记:① 本宿主专属标记(精确);② 旧版共享标记(旧桥写的,清了不影响新桥)。
+      // 代价:多宿主机器上可能清掉"另一个宿主"的旧标记 —— 那只让对方的**快速**自愈退化成
+      // 30 分钟周期刷新,不会造成错误状态,故不做更细的归属判定(复杂度不值)。
+      if (ownRevokedPath) { try { rmSync(ownRevokedPath, { force: true }); } catch { /* ignore */ } }
+      try { rmSync(legacyRevokedPath, { force: true }); } catch { /* ignore */ }
     }
     if (!ok && revoked) console.warn("[dsh-remote-web] 浏览器会话 Cookie 已被 dsh web 作废,重取失败,下次查状态再试");
     return ok;
@@ -1005,6 +1075,7 @@ Environment=PATH=${SERVICE_PATH}
 ${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_UPSTREAM=${upstreamUrl()}
 Environment=DSH_BRIDGE_INSTALL_SOURCE=${installSourceOf(relayDir)}
 Environment=DSH_BRIDGE_INSTALL_VERSION=${PLUGIN_VERSION}
+Environment=DSH_BRIDGE_HARNESS_VERSION=${harnessVersion()}
 
 [Install]
 WantedBy=default.target
@@ -1487,7 +1558,8 @@ function ensureRuntime(relayDir) {
       windowsHide: true,
       // DSH_BRIDGE_INSTALL_SOURCE：本机运行环境是插件自愈补的 → 安装器原样透传到 plist/bridge env，
       // 于是设备行上的 install_source 如实记成 plugin_market（而不是安装器默认的 npx）。
-      env: spawnEnv({ npm_config_registry: "https://registry.npmjs.org", DSH_BRIDGE_INSTALL_SOURCE: "plugin_market" }),
+      // DSH_BRIDGE_HARNESS_VERSION 同理：安装器会把它写进 plist；不给的话，桥重启后就丢了宿主版本。
+      env: spawnEnv({ npm_config_registry: "https://registry.npmjs.org", DSH_BRIDGE_INSTALL_SOURCE: "plugin_market", DSH_BRIDGE_HARNESS_VERSION: harnessVersion() }),
       stdio: ["ignore", openSync(log, "a"), openSync(log, "a")],
       onError: (e) => failSpawn(e, npx.kind),
     });
@@ -1583,7 +1655,7 @@ function writeAutostartFile(relayDir) {
   <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string><key>DSH_BRIDGE_HARNESS_VERSION</key><string>${harnessVersion()}</string></dict>
 </dict></plist>`;
   mkdirSync(dirname(plistPath), { recursive: true });
   writeFileSync(plistPath, plist, { mode: 0o644 });
@@ -1693,6 +1765,8 @@ function startBridgeDetached(relayDir, fallbackReason = "") {
     env: spawnEnv({
       DSH_BRIDGE_INSTALL_SOURCE: installSourceOf(relayDir),
       DSH_BRIDGE_INSTALL_VERSION: PLUGIN_VERSION,
+      // 宿主版本：bridge 自己推不出来（它是另一个进程），只能由插件在宿主进程内问出来再注入。
+      DSH_BRIDGE_HARNESS_VERSION: harnessVersion(),
       // 上游端口**必须**透传：watcher 用它判断「dsh web 在线吗」，bridge 用它做转发目标。
       // 不传的话两边都回落到写死的 3080 —— dsh web 不在默认端口时 bridge 永远不启动（0.6.12 修）。
       DSH_BRIDGE_UPSTREAM: upstreamUrl(),
@@ -3042,6 +3116,12 @@ async function proxyFeedback(relayDir, req, res, pathname) {
   const headers = {
     "x-dsh-device": cfg.device_id || "",
     "x-dsh-client": `dsh-remote-web/${PLUGIN_VERSION}`,
+    // 真实 UA 必须**转发**：以前不转发，上游 fetch 就用 undici 默认 UA（`node`），
+    // 后台「机型」列对每条真实反馈都显示同一个没用值（生产实测 fb_* 全是 user_agent=node），
+    // 于是「Windows 还是 Linux 出的问题」只能靠翻安装日志考古。同时补一个结构化平台字段
+    // （x-dsh-platform），比让后台解析 UA 可靠得多。
+    "user-agent": String(req.headers["user-agent"] || `dsh-remote-web/${PLUGIN_VERSION}`),
+    "x-dsh-platform": process.platform,
   };
   if (cfg.phone) headers["x-dsh-phone"] = String(cfg.phone);
   const auth = req.headers.authorization;
@@ -3457,7 +3537,14 @@ function spawnUpdater(relayDir, extraEnv, onError, spec = UPDATE_SPEC) {
     windowsHide: true, // Windows：不弹控制台窗口（POSIX 上该选项被忽略）
     // PATH 补 node 目录：App 最小 PATH 下也能跑 npx；同时保持本机既有的安装来源口径
     // （在线更新会重跑安装器并重写 plist，若不带来源就会把 plugin_market 误记成 npx）。
-    env: spawnEnv({ DSH_BRIDGE_INSTALL_SOURCE: installSourceOf(relayDir), ...(extraEnv || {}) }),
+    env: spawnEnv({
+      DSH_BRIDGE_INSTALL_SOURCE: installSourceOf(relayDir),
+      // 安装器会把这些环境变量原样写进 plist/systemd 单元，所以宿主版本也要一起给它 ——
+      // 否则安装器重启桥之后，新写的自启动项里就没有 harness 版本了。
+      DSH_BRIDGE_INSTALL_VERSION: PLUGIN_VERSION,
+      DSH_BRIDGE_HARNESS_VERSION: harnessVersion(),
+      ...(extraEnv || {}),
+    }),
     stdio: ["ignore", openSync(log, "a"), openSync(log, "a")],
     onError,
   });
@@ -3537,6 +3624,7 @@ async function runOnlineUpdate(relayDir) {
         env: spawnEnv({
           DSH_BRIDGE_INSTALL_SOURCE: installSourceOf(relayDir),
           DSH_BRIDGE_INSTALL_VERSION: PLUGIN_VERSION,
+          DSH_BRIDGE_HARNESS_VERSION: harnessVersion(),
           npm_config_registry: "https://registry.npmjs.org",
         }),
         stdio: ["ignore", out, out],
@@ -4543,6 +4631,8 @@ function buildConnectDiagnostics(relayDir, conn, log) {
   const rows = [
     "dsh-remote 连接诊断",
     `插件版本: ${PLUGIN_VERSION}`,
+    // 宿主版本：生产反馈里最缺的就是这个数 —— 只报插件版本时，「是不是 DSH 升级导致的兼容故障」答不出来
+    `宿主版本: ${harnessVersion() || "未知"}`,
     `配置目录: ${relayDir}`,
     `连接阶段: ${conn.phase}（${conn.text}）`,
     `设备 ID: ${conn.deviceId || "（未生成）"}`,
@@ -4608,7 +4698,7 @@ async function buildDiagReport(relayDir, opts = {}) {
   const conn = await composeConnect(relayDir, { manual });
   const cfg = loadConfig(relayDir);
   const head = redactForDiagnostics([
-    `【插件】v${PLUGIN_VERSION}　运行时 ${runtimeVersionOf(relayDir) || "未知"}　${osPlatform()}/${process.arch}　node ${String(process.versions.node).split(".")[0]}`,
+    `【插件】v${PLUGIN_VERSION}　运行时 ${runtimeVersionOf(relayDir) || "未知"}　宿主 ${harnessVersion() || "未知"}　${osPlatform()}/${process.arch}　node ${String(process.versions.node).split(".")[0]}`,
     `【阶段】${conn.phase}（${conn.text}）`,
     `【设备】ID=${conn.deviceId || "（未生成）"}　运行环境=${conn.runtimeReady ? "就绪" : `缺失${conn.runtimeMissing && conn.runtimeMissing.length ? `（缺 ${conn.runtimeMissing.slice(0, 3).join("、")}）` : ""}`}`,
     `【bridge】${conn.bridgeRunning ? `在运行 pid=${conn.bridgePids.join(",")}` : "未运行"}　守护=${conn.watcherRunning ? `在运行 pid=${conn.watcherPids.join(",")}${conn.watcherAgeMs ? `（${Math.round(conn.watcherAgeMs / 1000)}s）` : ""}` : "未运行"}${conn.watcherWedged ? " ⚠️活着但拉不起 bridge" : ""}${conn.watcherRestarts ? ` 已自动重启 ${conn.watcherRestarts} 次` : ""}`,
@@ -4644,6 +4734,10 @@ async function submitFeedback(relayDir, payload) {
     "content-type": "application/json",
     "x-dsh-device": cfg.device_id || "",
     "x-dsh-client": `dsh-remote-web/${PLUGIN_VERSION}`,
+    // 与 proxyFeedback 同一口径：结构化平台字段 + 真实 UA（此处没有浏览器请求可转发，
+    // 就如实写本机平台，绝不冒充浏览器 UA）。
+    "user-agent": `dsh-remote-web/${PLUGIN_VERSION} (${process.platform}; ${process.arch})`,
+    "x-dsh-platform": process.platform,
   };
   if (cfg.phone) headers["x-dsh-phone"] = String(cfg.phone);
   const t = await feedbackAuthToken(relayDir).catch(() => "");
@@ -5110,9 +5204,51 @@ function harnessVersionFromEntry(entry) {
   }
 }
 
+/**
+ * 由**宿主根目录**解析版本：`<root>/node_modules/@deepseek-ai/dsh/package.json`。
+ *
+ * 【为什么还要这一条（2026-10-09 真机）】桌面端（DeepSeek Harness 0.2，Electron）的宿主进程 argv 是：
+ *   [0] …/MacOS/DeepSeek Harness
+ *   [1] --expose-internals                                  ← **是开关，不是路径**
+ *   [2] …/app.asar/dsh/node_modules/@deepseek-ai/dsh-desktop-host/lib/index.js
+ *   [3] …/app.asar/dsh                                      ← **宿主根目录**
+ * 于是「取 argv[1] 的上一级 package.json」在桌面端**必然拿不到**（argv[1] 是 `--expose-internals`），
+ * 这就是桌面用户全部上报 harness 版本为空的原因。好在 argv[3] 就是宿主根，其
+ * `node_modules/@deepseek-ai/dsh/package.json` 正是宿主版本（实测 0.2.0-rc.2）。
+ * 桌面端是 Electron，`readFileSync` 能透明读 asar 内的路径，所以这条在真实宿主里可读。
+ */
+function harnessVersionFromRoot(root) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(String(root), "node_modules", HARNESS_PACKAGE_NAME, "package.json"), "utf8"));
+    if (!manifest || manifest.name !== HARNESS_PACKAGE_NAME) return "";
+    return telemetryToken(manifest.version);
+  } catch {
+    return "";   // 不是宿主根 / 读不到 → 交给下一条候选，绝不抛
+  }
+}
+
+/**
+ * 从整条 argv 里找出宿主版本（**顺序试探，先命中先返回**）。三条来源都不联网、不起子进程：
+ *   ① 目录形态：某参数本身就是宿主根（桌面端 argv[3]）；
+ *   ② 文件形态：某参数是 DSH 主模块（Web 版 argv[1]），取它上一级的 package.json；
+ * 开关（`-` 开头）与非绝对路径一律跳过 —— 绝不把 `--expose-internals` 当路径去 realpath。
+ */
+function harnessVersionFromArgv(argv) {
+  const list = Array.isArray(argv) ? argv : [];
+  for (const raw of list) {
+    const p = String(raw ?? "");
+    if (p === "" || p.startsWith("-") || !isAbsolute(p)) continue;
+    const viaRoot = harnessVersionFromRoot(p);
+    if (viaRoot) return viaRoot;
+    const viaEntry = harnessVersionFromEntry(p);
+    if (viaEntry) return viaEntry;
+  }
+  return "";
+}
+
 /** 本进程运行所在的宿主版本（未知 = ""）。每次调用现读：事件量很小，且绝不该缓存出过期结论。 */
 function harnessVersion() {
-  return harnessVersionFromEntry(process.argv[1]);
+  return harnessVersionFromArgv(process.argv);
 }
 
 /**
@@ -5486,6 +5622,8 @@ export const __telemetryInternals = {
   // 必须能被用例逐条锁住（含未知/非法值的降级行为）。
   harnessVersion: () => harnessVersion(),
   harnessVersionFromEntry: (entry) => harnessVersionFromEntry(entry),
+  harnessVersionFromRoot: (root) => harnessVersionFromRoot(root),
+  harnessVersionFromArgv: (argv) => harnessVersionFromArgv(argv),
   harnessToken: (v) => telemetryToken(v),
   updateTag: UPDATE_TAG,
   eventNames: [...TELEMETRY_EVENT_NAMES],
@@ -5512,7 +5650,7 @@ export const __telemetryInternals = {
  * 安装信息上报（插件侧通道）：登录后把本机安装信息发给企业端，供「已登录用户升级插件后刷新版本号」
  * 之类的口径统计。无账号凭据不上报；失败静默（绝不阻塞面板、不弹错误）。
  * 契约：POST <api_url>/api/install-report，头 `authorization: Bearer <device-login JWT>`，
- * body { device_id?, install_source, install_version, host_os, host_arch }，成功 200 {ok:true}；
+ * body { device_id?, install_source, install_version, harness_version, host_os, host_arch }，成功 200 {ok:true}；
  * 404/400 一律忽略（老服务端没有该接口时不能报错）。
  */
 const INSTALL_REPORT_FILE = ".dsh-install-report.json";
@@ -5547,6 +5685,9 @@ async function reportInstallOnce(relayDir, cfgOverride, opts = {}) {
     ...(cfg.device_id ? { device_id: String(cfg.device_id) } : {}),
     install_source: source,
     install_version: version,
+    // 宿主（DeepSeek Harness）版本：与 install_version（插件版本）是两个数，
+    // 只报插件版本时「是不是 DSH 升级导致的故障」答不出来（2026-10 生产反馈的普遍缺口）。
+    harness_version: harnessVersion(),
     host_os: process.platform,
     host_arch: process.arch,
   };

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

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-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/runtime/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 链接是免费用户越界时的转化入口。