@mrrisega/dsh-remote 0.6.10 → 0.6.11

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

@@ -591,7 +591,17 @@ class EventSubscriber extends EventEmitter {
     if (ws !== null) {
       try {
         ws.removeAllListeners();
-        ws.close(1000, "subscriber closed");
+        // ⚠️ 先挂一个吞掉的 error 监听：**握手中的**连接被 close() 时，ws 会**异步** emit
+        //    'error'（"WebSocket was closed before the connection was established"）。
+        //    上面刚 removeAllListeners()，于是它成了**未捕获错误** —— 真机表现是「解绑」
+        //    这一步偶发把流程打挂（测试里是一条 e2e 偶发红，2026-09-23 定位）。
+        ws.on("error", () => { /* 关闭途中的错误不该冒泡到业务 */ });
+        if (ws.readyState === this.#WebSocketImpl.CONNECTING) {
+          // 还没握手完 → terminate()：立刻中止，且不产生上面那个错误
+          ws.terminate();
+        } else {
+          ws.close(1000, "subscriber closed");
+        }
       } catch {
         /* 关不掉就等 GC */
       }

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

@@ -1666,3 +1666,82 @@ test("★ /help 必须逐行分隔:付费档也不许退化成一坨(无换行/
     await ilink.close();
   }
 });
+
+// ---------------------------------------------------------------------------
+// 日报**重复推送**的根治（2026-09-23 业主实测「每日简报推送了两次」）
+//
+// 根因：`#maybeDigest` 是「读 state → 等网络发送 → 写 state」的**跨 await 读-改-写**。
+// 发送要等网络，这段窗口里第二个执行者会读到"今天还没发" → 两条都发出去。
+// 真实撞车场景有两个：① 更新期间新旧 bridge 短暂共存；② 一次发送超过 60s，下一次 tick 叠上来。
+// 修法：`openSync(..., "wx")`（不存在才创建，内核保证原子）占位 —— 只有一个执行者拿得到。
+// ---------------------------------------------------------------------------
+
+/** 两个 runtime **共用同一个 relayDir**（模拟更新期间新旧 bridge 短暂共存）。 */
+async function twoRuntimesSameDir(ilink) {
+  const relayDir = tmp();
+  saveAccount(relayDir, { token: "tok-abc", accountId: "bot-1", baseUrl: ilink.baseUrl, userId: "user-1", boundAt: 1 });
+  const mk = () => {
+    const rt = createWeChatRuntime({
+      relayDir,
+      upstream: "http://127.0.0.1:1",
+      secret: SECRET,
+      tier: "pro",
+      logger: quietLogger()
+    });
+    rt.subscriber = makeFakeSubscriber();
+    rt.digestHour = new Date().getHours(); // 让真实路径通过时刻闸门
+    return rt;
+  };
+  return { rtA: mk(), rtB: mk(), relayDir };
+}
+
+test("★★ 两个实例共存时日报只能发一条(原子占位 —— 真机曾发两条)", async () => {
+  const ilink = await fakeIlink();
+  try {
+    const { rtA, rtB } = await twoRuntimesSameDir(ilink);
+    const before = ilink.state.sends.length;
+    // 并发触发：模拟两个实例在同一分钟内各自 tick（旧实现会两条都发）
+    await Promise.all([rtA.runMaybeDigestNow(), rtB.runMaybeDigestNow()]);
+    const sent = ilink.state.sends.length - before;
+    assert.equal(sent, 1, `★同一天只能有一条简报，实际发出 ${sent} 条（旧实现：两个执行者都读到"今天还没发"）`);
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 日报占位是陈旧的(>10 分钟)时必须接管,不能把那天彻底吞掉", async () => {
+  const ilink = await fakeIlink();
+  try {
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "pro" });
+    rt.digestHour = new Date().getHours();
+    const day = `${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, "0")}-${String(new Date().getDate()).padStart(2, "0")}`;
+    const lock = path.join(relayDir, `.digest-${day}.sent`);
+    // 造一个 20 分钟前的占位(模拟"上个实例占位后、发送途中被杀")
+    fs.writeFileSync(lock, "");
+    const old = new Date(Date.now() - 20 * 60_000);
+    fs.utimesSync(lock, old, old);
+
+    const before = ilink.state.sends.length;
+    await rt.runMaybeDigestNow();
+    assert.equal(ilink.state.sends.length - before, 1,
+      "★陈旧占位必须被接管并补发 —— 否则进程一被杀,那天就再也不会发简报");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 日报占位一天一个,换天时会清掉旧占位(不攒文件)", async () => {
+  const ilink = await fakeIlink();
+  try {
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "pro" });
+    rt.digestHour = new Date().getHours();
+    // 放两个"昨天/前天"的占位
+    fs.writeFileSync(path.join(relayDir, ".digest-2020-01-01.sent"), "");
+    fs.writeFileSync(path.join(relayDir, ".digest-2020-01-02.sent"), "");
+    await rt.runMaybeDigestNow();
+    const left = fs.readdirSync(relayDir).filter((n) => n.startsWith(".digest-") && n.endsWith(".sent"));
+    assert.equal(left.length, 1, `旧占位必须被清掉,只剩今天的,实际:${left.join(", ")}`);
+  } finally {
+    await ilink.close();
+  }
+});

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

@@ -1679,25 +1679,93 @@ export class WeChatRuntime {
   /**
    * 每日简报(兼作 24h 推送窗口的心跳)。
    *
-   * ⚠️ 旧实现有两个问题,一起修了:
+   * ⚠️ 旧实现有三个问题,一起修了:
    *   ① 只把 `{notified, answered}` 交给下游,**没有 lines** → 用户每天收到的是兜底句
    *      「今天暂时没有要做的事。」—— 那不是"今天干了啥",等于白发(业主:"日报发的内容有点问题")。
    *   ② 先把 `last_digest_day` 落盘**再**发送 → 一旦这次没发出去(网络抖动/节点被权限关掉),
    *      当天的简报就被**烧掉**、当天再也不会补发。
+   *   ③ 「读 state → 发送 → 写 state」是一段**跨 await 的读-改-写**:发送要等网络,
+   *      这段窗口里第二个执行者会读到"今天还没发"→ **两条都发出去**
+   *      (2026-09-23 真机:业主收到两条简报)。现在用**原子占位**把"今天这条归我发"锁死。
    */
   async #maybeDigest() {
     if (this.stopping || !this.channel.account || !this.subscriber) return;
     const now = this.clock();
     const hour = new Date(now).getHours();
     if (hour !== this.digestHour) return;
+    const day = this.#today(now);
     const state = loadState(this.relayDir);
-    if (state.last_digest_day === this.#today(now)) return; // 今天已发
+    if (state.last_digest_day === day) return; // 今天已发
+    // ★ 先原子占位再发送:两个实例/两次 tick 并存时,只有一个能拿到(见 #claimDigest)
+    const claim = this.#claimDigest(day);
+    if (!claim.ok) return;
     const s = this.todayStats;
     const lines = this.#digestLines();
     const node = this.subscriber.digestDue({ lines, notified: s.notified, answered: s.answered });
-    const r = await this.notify(node);
+    let r = null;
+    try {
+      r = await this.notify(node);
+    } finally {
+      // 没真发出去 → 释放占位,留给下一 tick 补发(见上面 ②:不能把当天烧掉)
+      if (!(r && r.ok)) this.#releaseDigest(claim);
+    }
     // ★ 只有**真的发出去了**才记"今天已发"(见上面 ②)
-    if (r && r.ok) this.channel.writeState({ last_digest_day: this.#today(now) });
+    if (r && r.ok) this.channel.writeState({ last_digest_day: day });
+  }
+
+  /**
+   * 原子占位「今天这条简报由我来发」。
+   *
+   * 🔴 为什么光看 state 里的 `last_digest_day` 不够:那是**读-改-写**,中间隔着一次网络发送。
+   *    典型撞车场景有两个,都真实发生过:
+   *      · 更新期间新旧 bridge **短暂共存**(旧的还没退、新的已起);
+   *      · 一次发送耗时超过 60s,下一次定时器 tick **叠**上来。
+   *    两者都会让第二个执行者在写盘之前读到"今天还没发" → 用户收到两条。
+   *    `openSync(..., "wx")`(不存在才创建)由内核保证原子,只有一个执行者能拿到 ✅
+   *
+   * 生命期:发成功 → 占位**留着**(它比 state 更强,重启/换实例也不会丢);
+   *        发失败 → 立刻由 `#releaseDigest` 释放,让下一 tick 补发;
+   *        占位超过 10 分钟 = **陈旧**(进程在发送途中被杀)→ 接管它。
+   *        宁可极小概率重发一次,也不要出现"那天彻底不发了"。
+   */
+  #claimDigest(day) {
+    const file = path.join(this.relayDir, `.digest-${day}.sent`);
+    const STALE_MS = 10 * 60_000;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        fs.closeSync(fs.openSync(file, "wx"));
+        this.#pruneDigestClaims(day);
+        return { ok: true, file };
+      } catch (e) {
+        if (!e || e.code !== "EEXIST") {
+          // 目录不可写等:退回"这次不发",绝不因此把 bridge 打挂(简报是锦上添花)
+          return { ok: false, file };
+        }
+        let age = 0;
+        try { age = Date.now() - fs.statSync(file).mtimeMs; } catch { age = 0; }
+        if (age < STALE_MS) return { ok: false, file }; // 别人正在发 / 今天已经发过
+        try { fs.rmSync(file, { force: true }); } catch { return { ok: false, file }; }
+        // 删掉陈旧占位后重抢一次
+      }
+    }
+    return { ok: false, file };
+  }
+
+  /** 发送失败时释放占位(交给下一 tick 补发)。 */
+  #releaseDigest(claim) {
+    if (!claim || !claim.file) return;
+    try { fs.rmSync(claim.file, { force: true }); } catch { /* ignore */ }
+  }
+
+  /** 清掉别的日期留下的占位文件(一天一个,不清理会一年攒 365 个)。 */
+  #pruneDigestClaims(today) {
+    try {
+      for (const name of fs.readdirSync(this.relayDir)) {
+        if (!name.startsWith(".digest-") || !name.endsWith(".sent")) continue;
+        if (name === `.digest-${today}.sent`) continue;
+        try { fs.rmSync(path.join(this.relayDir, name), { force: true }); } catch { /* ignore */ }
+      }
+    } catch { /* 目录读不了就算了:占位本身仍生效 */ }
   }
 
   /** 简报正文:回答"**今天**干了啥"(业主口径:日报是回顾,不是待办清单)。 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "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",