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

package/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/clients/dsh-remote/wechat-runtime.mjs

@@ -199,10 +199,22 @@ const SPECIAL_EVENT_KINDS = Object.freeze([
 const NOTICE_FORMATTER_KINDS = Object.freeze(["quota", "membership"]);
 
 /**
- * 主动推送失败后的**待补发队列**上限（见 `#pushProactive`）。
- * 为什么是 20：够放下"一轮里所有该告诉用户的事"；再多下去，补发就变成刷屏了。
+ * 主动推送失败后的**待补发队列**上限（见 `#pushProactive`）：只留**最近几条**。
+ *
+ * 2026-10-09 业主口径：「积压超过一定时限后就丢弃掉最早的数据，只保留最近几条」。
+ * 从 20 收到 5 的理由：一轮里真正还值得看的就最近那么两三条；攒到 20 条的结果是
+ * 平台一恢复就**一次连打十几条** —— 实测正是这种突发批量触发 `ret=-2 prepare failed`
+ * 被限流，于是补发又失败、队列再涨，越积越多永远还不上（现场观察到的就是这个循环）。
+ */
+const MAX_OUTBOX = 5;
+/**
+ * 待补发条目的**保质期**：超过这个时长还没送达就丢弃（先丢最旧的）。
+ *
+ * 为什么必须有（同一条业主口径）：一条"任务跑完了"的通知迟到几小时就**毫无价值** ——
+ * 补发出去只会让用户以为刚刚才发生；而队列的价值在于"网络抖动期间的短暂失败"，
+ * 那是分钟级的。2 小时足够覆盖抖动与短时离线，又不会把半天前的旧事翻出来刷屏。
  */
-const MAX_OUTBOX = 20;
+const OUTBOX_TTL_MS = 2 * 60 * 60 * 1000;
 /** 补发时的正文前缀（迟到必须如实说，不能让用户以为刚刚才发生）。 */
 const OUTBOX_MARK = "（补发）";
 
@@ -337,10 +349,16 @@ function sendJson(res, status, body) {
 }
 
 export class WeChatRuntime {
+  /**
+   * 「预期内的订阅拒绝」已报过的 (code|sessionId) 集合 —— 见 fault 处理器。
+   * 只是防刷屏：每生成一个**子代理**会话都会被订阅层拒一次，不记集合就是每个子代理刷一行 warn。
+   */
+  #expectedFaultSeen = new Set();
+
   /**
    * @param {{
    *   relayDir: string,
-   *   upstream?: string,              // dsh web 地址,默认 http://127.0.0.1:3080
+   *   upstream?: string|(() => string), // dsh web 地址,默认 http://127.0.0.1:3080;函数=每次重连重新求值
    *   cookieOf?: () => string,        // 读 .harness-cookie.json 的回调(bridge 已有该逻辑)
    *   secret?: string,                // 控制面密钥(bridge_secret);空则控制面拒绝所有请求
    *   logger?: any,
@@ -356,6 +374,16 @@ export class WeChatRuntime {
     if (!opts.relayDir) throw new Error("WeChatRuntime: 缺少 relayDir");
     this.relayDir = opts.relayDir;
     this.upstream = String(opts.upstream || "http://127.0.0.1:3080").replace(/\/+$/, "");
+    /**
+     * 上游地址的**取值器**：恰好是字符串时是常量函数。
+     *
+     * 为什么不让它是个固化字符串：宿主端口会变（`dsh web --port 0`、DSH Desktop 每次启动随机端口），
+     * 而事件订阅器是**长连接** —— 固化字符串的后果是端口一变就永久重连到旧端口。
+     * 【2026-10-09 真机实证】bridge 启动时宿主还是 3080，随后换成 19387；隧道转发侧
+     * （每次都读最新 UPSTREAM）一切正常，唯独微信事件通道死循环刷
+     * `connect ECONNREFUSED 127.0.0.1:3080` —— 手机能开页面，但**任务完成没有任何推送**。
+     */
+    this.upstreamOf = typeof opts.upstream === "function" ? opts.upstream : () => this.upstream;
     this.cookieOf = typeof opts.cookieOf === "function" ? opts.cookieOf : () => "";
     this.secret = String(opts.secret || "");
     this.clock = opts.clock || Date.now;
@@ -498,7 +526,9 @@ export class WeChatRuntime {
       followed_sessions: this.subscriber && typeof this.subscriber.sessions === "function"
         ? this.subscriber.sessions()
         : [],
-      pending_outbox: Array.isArray(state.pending_outbox) ? state.pending_outbox.length : 0,
+      // 报**有效**条数（按保质期过滤后）：否则进程重启后，面板会一直显示那几条早已过期、
+      // 永远不会被补发的条目，看起来像"队列卡住了"。真正的清理由 #trimOutbox 落盘。
+      pending_outbox: this.#pruneOutbox(state.pending_outbox).kept.length,
       last_fault: state.last_fault || null,
       last_completed_session_id: state.last_completed_session_id || "",
       last_completed_at: Number(state.last_completed_at || 0),
@@ -1537,14 +1567,44 @@ export class WeChatRuntime {
     return list;
   }
 
+  /**
+   * 丢掉**过期**条目（返回保留的与丢掉的数量）。
+   * `at` 缺失/非法 = 更早的落盘格式（那时还没有 at 字段）→ 一律视为过期：
+   * 留着只会把"最近几条"挤掉，而它们必然比 TTL 更老。
+   */
+  #pruneOutbox(list) {
+    const now = this.clock();
+    const kept = [];
+    let dropped = 0;
+    for (const item of Array.isArray(list) ? list : []) {
+      const at = Number(item && item.at);
+      if (!Number.isFinite(at) || at <= 0 || now - at > OUTBOX_TTL_MS) { dropped += 1; continue; }
+      kept.push(item);
+    }
+    return { kept, dropped };
+  }
+
+  /** 丢弃过期的、并按上限只留最近几条；丢了就**如实记一行日志**（绝不静默丢）。 */
+  #trimOutbox(list) {
+    const { kept, dropped } = this.#pruneOutbox(list);
+    let overflow = 0;
+    while (kept.length > MAX_OUTBOX) { kept.shift(); overflow += 1; }
+    const lost = dropped + overflow;
+    if (lost > 0) {
+      const mins = Math.round(OUTBOX_TTL_MS / 60000);
+      const why = [dropped ? `${dropped} 条超 ${mins} 分钟未送达` : "", overflow ? `${overflow} 条超出最近 ${MAX_OUTBOX} 条上限` : ""]
+        .filter(Boolean).join("、");
+      this.logger.warn(`[wechat] 待补发队列丢弃 ${lost} 条（${why}），保留最近 ${kept.length} 条`);
+    }
+    return kept;
+  }
+
   #enqueueOutbox(text, kind = "") {
     const body = String(text || "");
     if (!body) return 0;
     const list = this.#outbox();
     list.push({ text: body, kind: String(kind || ""), at: this.clock() });
-    // 上限：丢最旧的（用户最需要的是"最近发生了什么"，而无限攒下去只会让补发像刷屏）
-    while (list.length > MAX_OUTBOX) list.shift();
-    return this.#writeOutbox(list).length;
+    return this.#writeOutbox(this.#trimOutbox(list)).length;
   }
 
   /**
@@ -1552,7 +1612,11 @@ export class WeChatRuntime {
    * @returns {Promise<number>} 这次补发成功的条数
    */
   async #flushOutbox(to) {
-    const list = this.#outbox();
+    // 补发前先按保质期清一遍：**过期的不发**（迟到几小时的"任务跑完了"只会误导用户），
+    // 也避免一次性连打十几条把平台打限流（那正是队列越积越多的成因）。
+    const raw = this.#outbox();
+    const list = this.#trimOutbox(raw);              // 只在真丢了东西时才落盘（避免每轮都写状态文件）
+    if (list.length !== raw.length) this.#writeOutbox(list);
     if (!list.length || !to) return 0;
     let sent = 0;
     const rest = [...list];
@@ -1597,7 +1661,8 @@ export class WeChatRuntime {
     // 而且完全静默。现在无论订阅器是新建还是注入,都保证挂上处理器(WeakSet 去重,可重复调用)。
     if (!this.subscriber) {
       this.subscriber = createEventSubscriber({
-        upstream: this.upstream,
+        // 传**取值器**而不是当次的值：见构造函数里 upstreamOf 的说明（端口变了要能跟上）。
+        upstream: () => this.upstreamOf(),
         cookie: () => this.cookieOf(),
         follow: true,
         log: (level, message, meta) => {
@@ -1634,10 +1699,20 @@ export class WeChatRuntime {
       const code = String((info && info.code) || "unknown");
       const message = String((info && info.message) || "").slice(0, 160);
       const sessionId = String((info && info.sessionId) || "");
-      this.logger.warn(`[wechat/events] 订阅异常 ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
-      if (!(info && info.expected === true)) {
-        this.channel.writeState({ last_fault: { code, message, session_id: sessionId, at: this.clock() } });
+      // 预期内的拒绝（子代理会话必然被拒 `session/agent-busy` / 会话刚被删 `session/not-found`）
+      // **不是故障**：每生成一个子代理就会来一条，写成 warn 会把真正的故障淹掉
+      // （2026-10-09 现场：日志里成片 `订阅异常 session/agent-busy … require their durable parent address`）。
+      // 但也不能完全静默（2026-09-25 的教训：fault 以前没人接，全丢）→ 降为 info，且同一对只报一次。
+      if (info && info.expected === true) {
+        const key = `${code}|${sessionId}`;
+        if (this.#expectedFaultSeen.size < 200 && !this.#expectedFaultSeen.has(key)) {
+          this.#expectedFaultSeen.add(key);
+          this.logger.info(`[wechat/events] 订阅跳过(预期，不重试) ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
+        }
+        return;
       }
+      this.logger.warn(`[wechat/events] 订阅异常 ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
+      this.channel.writeState({ last_fault: { code, message, session_id: sessionId, at: this.clock() } });
     });
   }
 

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

@@ -362,9 +362,13 @@ const SERVICE_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/
  * 插件市场那条路径由插件半自愈补装：插件 spawn 本安装器时显式传入
  * DSH_BRIDGE_INSTALL_SOURCE=plugin_market，这里原样透传（外部注入 > 硬编码默认）。
  * install_version：优先取外部注入（插件/在线更新器），否则取本包 package.json 版本。
+ * harness_version：**只能由外部注入** —— 宿主（DeepSeek Harness）版本要从宿主进程的 argv /
+ *   安装目录推出来，而安装器是独立进程，推不出来。插件会在宿主进程内问出来再传进来；
+ *   用户直接跑 `npx @mrrisega/dsh-remote` 时没有这个值 → 留空（= 未上报，绝不猜一个错的）。
  */
 const INSTALL_SOURCE = String(process.env.DSH_BRIDGE_INSTALL_SOURCE || "").trim() || "npx";
 const INSTALL_VERSION = String(process.env.DSH_BRIDGE_INSTALL_VERSION || "").trim() || pkgVersion();
+const HARNESS_VERSION = String(process.env.DSH_BRIDGE_HARNESS_VERSION || "").trim();
 
 /**
  * 把文件权限收紧到「只有本人可读写」。
@@ -708,7 +712,7 @@ function writeAutostartFile() {
   <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${path.join(CONFIG_DIR, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${path.join(CONFIG_DIR, ".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>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_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>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_VERSION}</string><key>DSH_BRIDGE_HARNESS_VERSION</key><string>${HARNESS_VERSION}</string></dict>
 </dict></plist>`;
     // ~/Library/LaunchAgents 在全新账户/精简系统上可能不存在,必须先建目录,
     // 否则 writeFileSync 抛 ENOENT 直接把安装流程打断(用户反馈里也踩过类似的路径问题)。
@@ -724,7 +728,7 @@ function writeAutostartFile() {
   if (process.platform === "linux") {
     const dir = path.join(os.homedir(), ".config/systemd/user");
     fs.mkdirSync(dir, { recursive: true });
-    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\n${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
+    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\n${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\nEnvironment=DSH_BRIDGE_HARNESS_VERSION=${HARNESS_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
     const unitPath = autostartFilePath();
     fs.writeFileSync(unitPath, unit);
     return unitPath; // 路径在最终汇总里统一展示
@@ -1505,6 +1509,8 @@ async function runBridge() {
         // 安装口径透传给 bridge（bridge 把它随设备登记请求一起上报给账号 API）
         DSH_BRIDGE_INSTALL_SOURCE: INSTALL_SOURCE,
         DSH_BRIDGE_INSTALL_VERSION: INSTALL_VERSION,
+        // 宿主版本：外部注入（插件在宿主进程内问出来的），安装器只是搬运工；没有就是空串
+        DSH_BRIDGE_HARNESS_VERSION: HARNESS_VERSION,
         ...(saas ? { DSH_BRIDGE_PHONE: (cfg.phone || cfg.email || ""), DSH_BRIDGE_PASSWORD: cfg.password, DSH_BRIDGE_API: apiUrl, DSH_BRIDGE_SECRET: cfg.bridge_secret || "" } : {}),
         ...(local ? { DSH_BRIDGE_LOCAL_KEY: cfg.local_key } : {})
       };

package/packages/dsh-remote-web/test/desktop-compat.test.mjs

@@ -35,17 +35,27 @@ const SETUP_SRC = readFileSync(path.join(HERE, "..", "..", "..", "dsh-setup.mjs"
 /**
  * 以给定的宿主形态构造一个真实的 spawnEnv 并调用它。
  * 切片只含 spawnEnv 函数体，故它引用的模块级常量/工具必须显式注入。
+ *
+ * ⚠️ 必须注入 **process 桩**（2026-10-09）：`spawnEnv` 的第一件事是 `...process.env`，
+ *   而这个套件**是在 DSH 宿主里跑的** —— 从桌面端应用内跑 `npm run test:plugin` 时，
+ *   环境里天然带着 `ELECTRON_RUN_AS_NODE=1`（那正是"宿主是 Electron"的标志）。
+ *   于是"Web 版绝不得注入这个变量"那条断言会读到**宿主自己的**变量而必红 ——
+ *   可被测代码其实一个字节都没往 env 里加。注入干净环境后，这条用例检验的才是插件的行为
+ *   （而不是"运行测试的这台机器是不是桌面端"）。
+ *
  * @param {object} selfNodeEnv 该宿主形态下 SELF_NODE_ENV 的值
  * @param {object} [extra] 调用方业务变量
+ * @param {object} [sourceEnv] 宿主进程环境（默认干净：只含 PATH）
  */
-function makeSpawnEnv(selfNodeEnv, extra) {
+function makeSpawnEnv(selfNodeEnv, extra, sourceEnv) {
   const start = INDEX_SRC.indexOf("function spawnEnv(extra)");
   const end = INDEX_SRC.indexOf("function safeSpawn(");
   assert.ok(start > 0 && end > start, "切片锚点失效：spawnEnv / safeSpawn 结构变了");
   const src = INDEX_SRC.slice(start, end);
-  const make = new Function("SELF_NODE_ENV", "isWindows", "delimiter", "dirname",
+  const make = new Function("SELF_NODE_ENV", "isWindows", "delimiter", "dirname", "process", "path",
     `${src}\nreturn spawnEnv;`);
-  return make(selfNodeEnv, () => false, path.delimiter, path.dirname)(extra);
+  const processStub = { env: sourceEnv ?? { PATH: "/usr/bin:/bin" }, execPath: "/usr/bin/node" };
+  return make(selfNodeEnv, () => false, path.posix.delimiter, path.posix.dirname, processStub, path.posix)(extra);
 }
 
 test("桌面端：Electron 宿主下 spawnEnv 必须注入 ELECTRON_RUN_AS_NODE=1", () => {
@@ -60,6 +70,19 @@ test("Web 版（真实 node）：绝不得注入 ELECTRON_RUN_AS_NODE（不能
     "非 Electron 宿主下注入该变量会污染子进程环境、并让 node 版本探测类工具困惑");
 });
 
+test("Web 版：宿主环境**已经带着** ELECTRON_RUN_AS_NODE 时，最终 env 与宿主逐键一致（插件没加料）", () => {
+  // 这条是上面那条的补充（2026-10-09）：上面那条断言"结果里没有这个键"，在 Electron 宿主里
+  // 跑测试时**天然不成立**（键来自宿主 process.env）。真正的判据是"插件有没有往 env 里加料"，
+  // 故这里显式把宿主环境造成带这个变量，验证：最终 env **逐键等于宿主环境 + PATH 调整**，
+  // 一个多余的键都没有（`{}` 展开是恒等）。这样这条用例在任何宿主里都恒真且有意义。
+  const hostEnv = { PATH: "/usr/bin:/bin", ELECTRON_RUN_AS_NODE: "1", HOME: "/Users/tester" };
+  const env = makeSpawnEnv({}, undefined, hostEnv);
+  const expectedPath = ["/usr/bin", "/usr/bin:/bin", "/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(":");
+  assert.deepEqual(env, { ...hostEnv, PATH: expectedPath },
+    "除 PATH 外不得新增/删除/改动任何键（否则就是插件在污染子进程环境）");
+  assert.equal(env.ELECTRON_RUN_AS_NODE, "1", "宿主自己的值原样透传，不算插件注入");
+});
+
 test("spawnEnv：NODE_INTERPRETER 变量不得挤掉调用方的业务变量，PATH 仍按平台分隔符拼接", () => {
   const env = makeSpawnEnv({ ELECTRON_RUN_AS_NODE: "1" }, { DSH_BRIDGE_INSTALL_SOURCE: "npx" });
   assert.equal(env.DSH_BRIDGE_INSTALL_SOURCE, "npx", "业务变量必须仍能覆盖");
@@ -153,15 +176,25 @@ test("桌面端：面板文案改为引导'退出并重开应用'，且不影响
 
 // ─────────────── ④ 安装：--profile desktop 必须真的生效 ───────────────
 
-/** 用安装器切片构造真实的 resolveProfileDir（注入 os / path，伪造 HOME）。 */
+/**
+ * 用安装器切片构造真实的 resolveProfileDir（注入 os / path / process，伪造 HOME 与空环境）。
+ *
+ * ⚠️ 必须注入 **process 桩**（2026-10-09）：`resolveProfileDir` 的第二来源是
+ *   `process.env.DSH_PROFILE_DIR`，而这个测试套件**是在 DSH 宿主里跑的** ——
+ *   从桌面端应用内跑 `npm run test:plugin` 时，环境里天然带着
+ *   `DSH_PROFILE_DIR=/Users/<me>/.dsh/profiles/desktop`，于是"缺省仍是 Web 版"那条断言
+ *   会读到真实 HOME 下的 desktop，**在任何装了桌面端的机器上必红**（假红，且指向错误结论）。
+ *   注空环境 = 这条用例从此只验证被测逻辑，不受宿主环境影响。
+ */
 function makeResolveProfileDir(home) {
   const start = SETUP_SRC.indexOf("const KNOWN_PROFILE_NAMES");
   const end = SETUP_SRC.indexOf("function warnIfDesktopProfile");
   assert.ok(start > 0 && end > start, "切片锚点失效：profile 解析函数结构变了");
   const src = SETUP_SRC.slice(start, end);
   const osStub = { homedir: () => home };
-  const make = new Function("os", "path", `${src}\nreturn { resolveProfileDir, profileArgvOf, isDesktopProfileDir, profileDirOfName };`);
-  return make(osStub, path);
+  const processStub = { env: {} };
+  const make = new Function("os", "path", "process", `${src}\nreturn { resolveProfileDir, profileArgvOf, isDesktopProfileDir, profileDirOfName };`);
+  return make(osStub, path, processStub);
 }
 
 test("安装器：--profile desktop 解析到桌面端 profile 目录，不再是相对路径/被忽略", () => {