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

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/test/mobile-adapter-runtime.test.mjs

@@ -535,6 +535,47 @@ test("网络延迟分档：500ms 以内=顺畅、1000ms 以内=正常（远程
   }
 });
 
+test("★ 亚毫秒样本（本机/回环自测）也必须出数 —— 不得永远停在「测速中…」", async () => {
+  // 业主 2026-10-09 实测反馈：「小悬浮窗一直提示『测速中，等待下一次网络请求后开始测速』」。
+  // 根因：旧实现是 `if (r < 1) return;`（注释写"亚毫秒=同帧缓存命中"），但**本机/回环**访问
+  //   （桌面端自测、在同一台机器上打开镜像页）一次真实往返往往就是 < 1ms —— 于是**每一个**样本
+  //   都被丢掉，界面永远停在空态。面板侧 chip 从来没这个毛病（`v <= 0` + `Math.max(1, …)`），
+  //   这条用例把两侧口径钉在一起。
+  const env = harness({ width: 390, fetchImpl: async () => ({ status: 200, ok: true }) }); // 零延迟 = 亚毫秒
+  runAdapter(env);
+  const rtt = findFab(env).querySelector('[data-role="rtt"]');
+  assert.equal(rtt.hidden, true, "前提：还没有样本");
+  await env.win.fetch("/api/session/list");
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(rtt.hidden, false, "★亚毫秒的真实往返必须记成样本（否则本机自测永远是「测速中…」）");
+  assert.equal(String(rtt.textContent), "1ms", "展示层夹到 1ms —— 0ms 是谎话");
+  const net = findMenu(env).querySelector(".dsh-ma-menu-net");
+  assert.ok(!/测速中/.test(String(net.textContent)),
+    `菜单行不得再显示空态，实际：${net.textContent}`);
+});
+
+test("★ 悬浮窗被官方 SPA 重渲染重建后，已积累的样本仍要显示（样本不跟着某一代闭包走）", async () => {
+  // fetch 包装只装一次（window.__dshMaSessionWatch 一次性闸门），而悬浮窗可能被重建。
+  // 若样本数组长在 buildRemoteMenu 的闭包里，包装会一直喂"上一代"（节点已不在文档里），
+  // 新界面读自己那份空数组 → 又是永远「测速中…」。样本挂在 window 上才不会这样。
+  const env = harness({
+    width: 390,
+    fetchImpl: async () => { await new Promise((r) => setTimeout(r, 5)); return { status: 200, ok: true }; },
+  });
+  runAdapter(env);
+  await env.win.fetch("/api/session/list");
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(findFab(env).querySelector('[data-role="rtt"]').hidden, false, "前提：第一代已有样本");
+
+  // 模拟 SPA 重渲染：官方把 body 子树整片换掉（我们的悬浮窗跟着消失），适配层再建一代。
+  env.body.children = [];
+  runAdapter(env);
+  const fab2 = findFab(env);
+  assert.ok(fab2, "重建后应有新的悬浮按钮");
+  assert.equal(fab2.querySelector('[data-role="rtt"]').hidden, false,
+    "★重建后的悬浮窗必须立刻显示已积累的样本（旧实现读自己那份空数组 → 永远「测速中…」）");
+});
+
 test("网络延迟：无样本 / 失败请求绝不显示 0ms（显示「测速中…」是唯一正确的空态）", async () => {
   const env = harness({
     width: 390,

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

@@ -1983,6 +1983,77 @@ test("★ 事故锁：用户主动 /use 切走的会话不能被「最近完成
   }
 });
 
+test("★ 待补发队列：过期的**不发**（丢弃最早的），且只保留最近几条", async () => {
+  // 业主 2026-10-09 口径：「积压超过一定时限后就丢弃掉最早的数据，只保留最近几条」。
+  // 两条理由：① 迟到几小时的"任务跑完了"只会误导用户；② 攒到十几条会在平台恢复时一次连打，
+  // 实测正是这种突发批量触发 `ret=-2 prepare failed` 被限流 → 补发又失败 → 队列再涨（死循环）。
+  const ilink = await fakeIlink();
+  try {
+    const sub = makeFakeSubscriber();
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
+    const statePath = path.join(relayDir, ".wechat-state.json");
+    const stateOf = () => JSON.parse(fs.readFileSync(statePath, "utf8"));
+    const now = Date.now();
+    const H = 60 * 60 * 1000;
+
+    // 手工造一段积压：2 条很旧（>2h）+ 1 条刚失败（刚刚）
+    rt.channel.writeState({
+      pending_outbox: [
+        { text: "很久以前的完成通知A", kind: "stopped", at: now - 5 * H },
+        { text: "很久以前的完成通知B", kind: "stopped", at: now - 3 * H },
+        { text: "刚刚的完成通知C", kind: "stopped", at: now - 1000 },
+      ],
+    });
+    // ① 面板看到的是**有效**条数（过期的不该再显示成"待补发"）
+    assert.equal(rt.status().pending_outbox, 1, "status 必须按保质期报有效条数（否则重启后面板显示永远发不出去的旧条目）");
+
+    // ② 用户随便发一条 → 触发补发：只发那条没过期的
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/status" } }] });
+    await waitFor(() => (stateOf().pending_outbox || []).length === 0);
+    const resent = allTexts(ilink.state).filter((t) => t.startsWith("（补发）"));
+    assert.equal(resent.length, 1, `★ 只应补发未过期的那一条，实际补发 ${resent.length} 条`);
+    assert.match(resent[0], /刚刚的完成通知C/, "补发的必须是没过期的那条");
+    assert.ok(!resent.some((t) => /很久以前的完成通知/.test(t)), "★ 过期条目绝不能发出去");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 待补发队列：超过上限只留最近几条（丢最早，且如实记日志）", async () => {
+  const ilink = await fakeIlink({ onSendMessage: (_s, reply) => reply({ ret: -2, errmsg: "prepare failed" }) });
+  try {
+    const infos = [];
+    const warns = [];
+    const sub = makeFakeSubscriber();
+    sub.sessionsFixture = [{ sessionId: "session-done", title: "跑完的活", running: false, cwd: "/p" }];
+    sub.summaryFixture = "做完了。";
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
+    rt.logger = { info: (m) => infos.push(String(m)), warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
+    const statePath = path.join(relayDir, ".wechat-state.json");
+    const stateOf = () => JSON.parse(fs.readFileSync(statePath, "utf8"));
+
+    // 连推 9 条（每一条都发不出去 → 全部入队）。每条正文不同，才能断言"留下的是最近的"。
+    for (let i = 1; i <= 9; i += 1) {
+      sub.summaryFixture = `这是第${i}条结论。`;
+      await rt.notify({ kind: NODE_KINDS.TURN_END, sessionId: "session-done", reason: "completed", at: i });
+    }
+    const queued = stateOf().pending_outbox || [];
+    assert.equal(queued.length, 5, `★ 队列上限 = 最近 5 条，实际 ${queued.length}`);
+    const kept = queued.map((q) => String(q.text)).join("\n");
+    for (const i of [5, 6, 7, 8, 9]) {
+      assert.match(kept, new RegExp(`这是第${i}条结论`), `最近的第 ${i} 条必须保留`);
+    }
+    for (const i of [1, 2, 3, 4]) {
+      assert.ok(!kept.includes(`这是第${i}条结论`), `★ 最早的第 ${i} 条必须被丢弃（只留最近几条）`);
+    }
+    assert.ok(warns.some((m) => /待补发队列丢弃 \d+ 条/.test(m)),
+      `丢数据必须如实记日志（不得静默），实际:${JSON.stringify(warns)}`);
+  } finally {
+    await ilink.close();
+  }
+});
+
+
 test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 emit、没人接 → 全静默）", async () => {
   // 那次「一条推送都没有、日志里也没有任何报错」的根因就在这类静默里：
   // `#emitFault` 只 emit('fault')，而运行时没接这个事件 —— follow 失败/发现失败/流上限
@@ -1990,9 +2061,10 @@ test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 em
   const ilink = await fakeIlink();
   try {
     const warns = [];
+    const infos = [];
     const sub = makeFakeSubscriber();
     const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
-    rt.logger = { info() {}, warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
+    rt.logger = { info: (m) => infos.push(String(m)), warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
     await rt.startChannel(); // 真实接线：#startSubscriber() → 给注入的订阅器挂 handler
     try {
       sub.emit("fault", { code: "follow-limit", message: "follow 流已达上限 8", sessionId: "session-x", expected: false });
@@ -2002,9 +2074,23 @@ test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 em
       assert.equal(st.last_fault && st.last_fault.code, "follow-limit", "非预期的订阅异常要记进状态供面板显示");
 
       // 预期内的（子代理会话必然被拒 / 会话刚被删）只记日志，不该污染故障状态
+      const warnCountBefore = warns.length;
       sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
       const st2 = JSON.parse(fs.readFileSync(path.join(relayDir, ".wechat-state.json"), "utf8"));
       assert.equal(st2.last_fault.code, "follow-limit", "expected 的异常不该覆盖真正的故障");
+      // ★2026-10-09：预期内的拒绝**不能写成 warn** —— 每生成一个子代理就会来一条，
+      // 成片的 `订阅异常 session/agent-busy …` 会把真正的故障淹掉（业主现场看到的就是这个）。
+      assert.equal(warns.length, warnCountBefore, `expected 的拒绝不得写 warn，实际:${JSON.stringify(warns)}`);
+      assert.ok(infos.some((m) => m.includes("订阅跳过(预期") && m.includes("session=sub-1")),
+        `expected 的拒绝要有一条 info 留痕（绝不静默），实际:${JSON.stringify(infos)}`);
+      // 同一对 (code, session) 反复来也只报一次：否则子代理一多照样刷屏
+      const infoCountBefore = infos.length;
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
+      assert.equal(infos.length, infoCountBefore, "同一 (code, session) 的预期拒绝只报一次（防刷屏）");
+      // 但**不同**会话仍各自留痕一次（可诊断，不被去重抹掉）
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-2", expected: true });
+      assert.equal(infos.length, infoCountBefore + 1, "不同子代理会话各留一条");
     } finally {
       await rt.stopChannel();
     }

package/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.3",
   "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",