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

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

@@ -320,21 +320,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 > 生成。
@@ -1568,6 +1647,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 +1669,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/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();
+  }
+});

package/clients/dsh-remote/test/harness-cookie-authority.test.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * Cookie **按 authority 隔离**回归（2026-10-09 事故根治）。
+ *
+ * 【事故原貌】`~/.dsh-remote/` 只有一份 `.harness-cookie.json`，而 Web 端(3080)与桌面端
+ *   (每次启动随机端口)是**两个宿主进程**，各自的插件都往里写自己 authority 的 Cookie →
+ *   互相覆盖。桥撞 401 后重读磁盘拿到的是**另一个宿主刚写的** Cookie（与失败的不是同一个）
+ *   → 重试 → 还是 401 → 再读 → 又被覆盖回去……**乒乓，永不自愈**，手机端持续白页。
+ *   现场极具迷惑性：`bridge-status` 显示 online、页面能开，只有日志里 401 刷屏。
+ *
+ * 【修法】每个宿主只写自己 authority 的文件 `.harness-cookie.<authority>.json`；桥只认
+ *   **当前上游 authority** 的那一份，旧版共享文件仅在 authority 对得上（或旧插件根本没写
+ *   authority）时才用，**声明了别的 authority 一律不用** —— 那一份必然 401，用它就是乒乓。
+ *
+ * 本用例走真实 `handleHttpFrame` → `doHttp` 全链路：假上游把"收到的 Cookie"回显出来，
+ * 因此可以逐字断言桥**到底发了什么**（而不是只断言状态码）。
+ */
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import test, { after } from "node:test";
+
+const tmpDir = mkdtempSync(path.join(os.tmpdir(), "dsh-cookie-authority-"));
+const LEGACY = path.join(tmpDir, ".harness-cookie.json");
+
+/** 与两份源码同名的规则（漂移由下面的"源码约束"用例兜住）。 */
+const slug = (authority) => String(authority).replace(/[^A-Za-z0-9._-]/g, "_");
+const cookieFileFor = (authority) => path.join(tmpDir, `.harness-cookie.${slug(authority)}.json`);
+
+let upstreamAuthority = "";
+function writeDoc(file, doc) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(doc), { mode: 0o600 });
+}
+function clearCookies() {
+  for (const f of [LEGACY, cookieFileFor(upstreamAuthority)]) rmSync(f, { force: true });
+}
+
+/** 假 dsh web：把收到的 Cookie 原样回显（200），便于断言"桥发了哪一份"。 */
+const upstream = http.createServer((req, res) => {
+  res.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+  res.end(req.headers.cookie || "");
+});
+
+process.env.DSH_BRIDGE_DEVICE_ID = "dev-cookieauth1";
+process.env.DSH_BRIDGE_CONFIG = path.join(tmpDir, "config.json");
+
+const { handleHttpFrame } = await new Promise((resolve, reject) => {
+  upstream.listen(0, "127.0.0.1", () => {
+    upstreamAuthority = `127.0.0.1:${upstream.address().port}`;
+    process.env.DSH_BRIDGE_UPSTREAM = `http://${upstreamAuthority}`;
+    import("../dsh-bridge.mjs").then(resolve, reject);
+  });
+});
+
+async function ask(pathname = "/echo") {
+  let reply;
+  await handleHttpFrame((obj) => { reply = obj; return true; }, { type: "http", id: `req-${Math.random()}`, method: "GET", path: pathname, headers: {} });
+  return { status: reply.status, cookie: Buffer.from(reply.body || "", "base64").toString("utf8") };
+}
+
+test("本宿主专属文件优先：`.harness-cookie.<authority>.json` 收到的就是它", async () => {
+  clearCookies();
+  writeDoc(cookieFileFor(upstreamAuthority), { authority: upstreamAuthority, cookie: "dsh-auth-OWN", mintedAt: Date.now() });
+  const r = await ask();
+  assert.equal(r.status, 200);
+  assert.equal(r.cookie, "dsh-auth-OWN");
+});
+
+test("★ 事故锁：旧版共享文件里是**另一个宿主**的 Cookie → 一个字节都不许发出去", async () => {
+  clearCookies();
+  // 这正是事故现场：共享文件被另一宿主(3080)覆盖过
+  writeDoc(LEGACY, { authority: "127.0.0.1:3080", cookie: "dsh-auth-FOREIGN", mintedAt: Date.now() });
+  const r = await ask();
+  assert.equal(r.status, 200);
+  assert.equal(r.cookie, "", "foreign authority 的 Cookie 必须被跳过（发出去必然 401 → 乒乓）");
+});
+
+test("旧版共享文件 authority 对得上 → 继续用（向后兼容）", async () => {
+  clearCookies();
+  writeDoc(LEGACY, { authority: upstreamAuthority, cookie: "dsh-auth-LEGACY-OK", mintedAt: Date.now() });
+  const r = await ask();
+  assert.equal(r.cookie, "dsh-auth-LEGACY-OK");
+});
+
+test("旧插件没写 authority 字段 → 按兼容采用（不能因为缺字段就 401 白页）", async () => {
+  clearCookies();
+  writeDoc(LEGACY, { cookie: "dsh-auth-NO-AUTHORITY", mintedAt: Date.now() });
+  const r = await ask();
+  assert.equal(r.cookie, "dsh-auth-NO-AUTHORITY");
+});
+
+test("两份都在且互相矛盾 → 用本宿主那份（专属文件优先级高于共享镜像）", async () => {
+  clearCookies();
+  writeDoc(LEGACY, { authority: "127.0.0.1:3080", cookie: "dsh-auth-FOREIGN", mintedAt: Date.now() });
+  writeDoc(cookieFileFor(upstreamAuthority), { authority: upstreamAuthority, cookie: "dsh-auth-OWN", mintedAt: Date.now() });
+  const r = await ask();
+  assert.equal(r.cookie, "dsh-auth-OWN");
+});
+
+test("源码约束（跨文件漂移锁）：命名规则与文件名模板两份必须逐字一致", () => {
+  const bridge = readFileSync(new URL("../dsh-bridge.mjs", import.meta.url), "utf8");
+  const plugin = readFileSync(new URL("../../../packages/dsh-remote-web/lib/index.js", import.meta.url), "utf8");
+  const rule = 'return String(authority).replace(/[^A-Za-z0-9._-]/g, "_");';
+  const nameTpl = '`${HARNESS_COOKIE_FILE.slice(0, -".json".length)}.${authoritySlug(authority)}.json`';
+  const revokedTpl = "`${HARNESS_COOKIE_REVOKED_FILE}.${authoritySlug(authority)}`";
+  for (const [label, src] of [["桥半", bridge], ["插件半", plugin]]) {
+    assert.ok(src.includes(rule), `${label} 缺少 authoritySlug 规则（两份必须一致，否则各写各的文件名）`);
+    assert.ok(src.includes(nameTpl), `${label} 缺少专属文件名模板`);
+    assert.ok(src.includes(revokedTpl), `${label} 缺少专属作废标记名模板`);
+  }
+  assert.ok(bridge.includes("claimed === authority"), "桥半必须显式判 foreign authority（乒乓的根源）");
+  assert.ok(plugin.includes("claimed === authority"), "插件半必须在读的时候判 foreign authority");
+});
+
+after(() => {
+  try { upstream.close(); } catch { /* ignore */ }
+  try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});

package/clients/dsh-remote/test/harness-cookie-selfheal.test.mjs

@@ -19,10 +19,17 @@ import test, { after } from "node:test";
 const UNAUTH = "dsh web authentication required; reopen the URL printed by dsh web.\n";
 const tmpDir = mkdtempSync(path.join(os.tmpdir(), "dsh-harness-cookie-"));
 const cookieFile = path.join(tmpDir, ".harness-cookie.json");
-const revokedFile = path.join(tmpDir, ".harness-cookie-revoked");
+/** 作废标记自 0.7.0-beta.2 起**按 authority 分文件**（见 harness-cookie-authority.test.mjs）。 */
+const slug = (authority) => String(authority).replace(/[^A-Za-z0-9._-]/g, "_");
+const revokedFileFor = (authority) => path.join(tmpDir, `.harness-cookie-revoked.${slug(authority)}`);
+/** 本用例的假上游 authority（listen 后才知道端口；Cookie 必须按它命名才不会被判 foreign）。 */
+let upstreamAuthority = "127.0.0.1:3080";
+const revokedFile = () => revokedFileFor(upstreamAuthority);
 
 function writeCookie(value) {
-  writeFileSync(cookieFile, JSON.stringify({ authority: "127.0.0.1:3080", cookie: value, mintedAt: Date.now() }), { mode: 0o600 });
+  // 写**旧版共享文件**：新桥仍兼容读取（authority 对得上时），这条用例验的是 401 自愈链路，
+  // 与"专属/共享"无关；专属文件的优先级由 harness-cookie-authority.test.mjs 覆盖。
+  writeFileSync(cookieFile, JSON.stringify({ authority: upstreamAuthority, cookie: value, mintedAt: Date.now() }), { mode: 0o600 });
 }
 
 // 假 dsh web:只认 cookie=dsh-auth-NEW;第一次请求 401(并模拟插件此刻换好新 Cookie)
@@ -50,7 +57,8 @@ process.env.DSH_BRIDGE_CONFIG = path.join(tmpDir, "config.json");
 
 const { handleHttpFrame } = await new Promise((resolve, reject) => {
   upstream.listen(0, "127.0.0.1", () => {
-    process.env.DSH_BRIDGE_UPSTREAM = `http://127.0.0.1:${upstream.address().port}`;
+    upstreamAuthority = `127.0.0.1:${upstream.address().port}`;
+    process.env.DSH_BRIDGE_UPSTREAM = `http://${upstreamAuthority}`;
     import("../dsh-bridge.mjs").then(resolve, reject);
   });
 });
@@ -69,12 +77,12 @@ async function request(frame) {
 
 test("旧 Cookie 被 dsh web 拒(401)→ 用新 Cookie 自动重试一次:手机端拿到 200,用户零操作", async () => {
   writeCookie("dsh-auth-OLD");
-  rmSync(revokedFile, { force: true });
+  rmSync(revokedFile(), { force: true });
   const reply = await request({ id: "heal-1", method: "GET", path: "/needs-auth", headers: {} });
   assert.equal(reply.status, 200, "自愈后应返回 200(而不是把 401 透传给手机)");
   assert.equal(Buffer.from(reply.body, "base64").toString("utf8"), "ok");
   assert.equal(firstCallSeen, 1, "上游只被 401 了一次(第二次带新 Cookie 成功)");
-  assert.ok(existsSync(revokedFile), "应写下 .harness-cookie-revoked 标记,让插件在面板轮询时重换");
+  assert.ok(existsSync(revokedFile()), "应写下 .harness-cookie-revoked 标记,让插件在面板轮询时重换");
 });
 
 test("Cookie 未变(插件还没换好)→ 保留 401 但已打标记,等待插件重换", async () => {
@@ -87,14 +95,14 @@ test("Cookie 未变(插件还没换好)→ 保留 401 但已打标记,等待插
   const prev = process.env.DSH_BRIDGE_UPSTREAM;
   // 另起一个 bridge 实例指向这个永远 401 的上游(模块已加载,上游常量不可变 → 用新进程不便;
   // 这里直接验证标记语义:标记存在时 401 应原样透传,且标记仍在)
-  rmSync(revokedFile, { force: true });
+  rmSync(revokedFile(), { force: true });
   writeCookie("dsh-auth-STILL-OLD");
   try {
     const reply = await request({ id: "heal-2", method: "GET", path: "/needs-auth", headers: {} });
     // 上一个用例的假上游此刻会返回 200(因为它已经在第一次调用时把 Cookie 改成了 NEW),
     // 所以这里只断言"标记机制"本身:去掉标记后仍能再次自愈
     assert.ok(reply.status === 200 || reply.status === 401);
-    assert.ok(existsSync(revokedFile) || reply.status === 200, "自愈后应留下标记或已成功");
+    assert.ok(existsSync(revokedFile()) || reply.status === 200, "自愈后应留下标记或已成功");
   } finally {
     process.env.DSH_BRIDGE_UPSTREAM = prev;
     await new Promise((r) => srv2.close(r));

package/clients/dsh-remote/wechat-runtime.mjs

@@ -340,7 +340,7 @@ export class WeChatRuntime {
   /**
    * @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 +356,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;
@@ -1597,7 +1607,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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.2",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",

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

@@ -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;

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.2",
   "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

@@ -320,21 +320,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 > 生成。
@@ -1568,6 +1647,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 +1669,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/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/wechat-runtime.mjs

@@ -340,7 +340,7 @@ export class WeChatRuntime {
   /**
    * @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 +356,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;
@@ -1597,7 +1607,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) => {

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 目录，不再是相对路径/被忽略", () => {

package/packages/dsh-remote-web/test/uninstall-safety.test.mjs

@@ -407,7 +407,7 @@ test("清理助手：护栏命中时绝不删 profile（relayDir 误配成 profi
 test("安全：三处机密写入都要显式收紧 ACL（Windows 上 mode 0o600 无效）", () => {
   for (const [label, src, callSites] of [
     ["安装器", SETUP_SRC, [/hardenFile\(CONFIG_PATH\)/]],
-    ["插件半", INDEX_SRC, [/hardenFile\(configPathOf\(relayDir\)\)/, /hardenFile\(join\(relayDir, HARNESS_COOKIE_FILE\)\)/]],
+    ["插件半", INDEX_SRC, [/hardenFile\(configPathOf\(relayDir\)\)/]],
     ["bridge", fs.readFileSync(path.join(HERE, "..", "..", "..", "clients", "dsh-remote", "dsh-bridge.mjs"), "utf8"), [/hardenFile\(CONFIG_PATH\)/]],
   ]) {
     assert.ok(/function hardenFile\(file\)/.test(src), `${label} 应有 hardenFile`);
@@ -417,6 +417,18 @@ test("安全：三处机密写入都要显式收紧 ACL（Windows 上 mode 0o600
   }
 });
 
+test("安全：Cookie 的每个写入点都必须紧跟着 hardenFile（按 authority 分文件后不得漏收）", () => {
+  // 0.7.0-beta.2 把 Cookie 从「一份共享文件」改成「本宿主专属 + 旧版镜像」两份（见 P0-2 事故根治）。
+  // 写点从 1 个变 2 个 —— 逐个按变量名断言，漏收的那一份在 Windows 上就是 ACL 敞开状态。
+  const mint = INDEX_SRC.slice(INDEX_SRC.indexOf("async function mintHarnessCookie"), INDEX_SRC.indexOf("function readHarnessCookie"));
+  assert.ok(mint.length > 0, "应能定位到 mintHarnessCookie（找不到说明函数被改名，请同步本用例）");
+  const written = [...mint.matchAll(/writeFileSync\((\w+),/g)].map((m) => m[1]);
+  assert.ok(written.length >= 2, `mintHarnessCookie 应写两份 Cookie（本宿主专属 + 旧版镜像），实际 ${written.length}`);
+  for (const v of written) {
+    assert.ok(new RegExp(`hardenFile\\(${v}\\)`).test(mint), `Cookie 写入点 ${v} 之后必须调用 hardenFile 收紧 ACL`);
+  }
+});
+
 test("安全：hardenFile 在非 Windows 上只 chmod（不引入任何子进程，零副作用）", () => {
   const src = SETUP_SRC.slice(SETUP_SRC.indexOf("function hardenFile(file)"), SETUP_SRC.indexOf("// ---------- 配置读写 ----------"));
   const calls = [];