dsh-client-auto-continue 0.7.3 → 0.7.5

package/README.md

@@ -64,9 +64,9 @@ It watches the live event streams and reacts to:
 
 The plugin opens two extra SSE streams in the browser — `events.mux` (session events) and `events.host` (host events). The host supports multiple consumers, so this never interferes with the built-in runtime. On an interruption it waits a **grace period** (default 3 s) — if the host starts a new turn by itself (`turn/start`), the auto-continue is cancelled — then calls `sessions.prompt` in `queue` mode with the configured text.
 
-On page load / reconnect it also scans the most recently updated sessions: a session whose last turn ended with a non-human reason **within the scan window** (default 15 minutes), with no later `turn/start` or user message, gets resumed automatically too (e.g. the host crashed while the browser was closed).
+On page load / reconnect it also scans the most recently updated sessions: a session whose last turn ended with a non-human reason **within the scan window** (default 15 minutes), with no later `turn/start` or user message, gets resumed automatically too (e.g. the host crashed while the browser was closed). Before every send the plugin also asks the host one authoritative question — is the latest session event already this exact message? If the same text is still queued (the last event is that `user/message`), it skips; once the message has been processed (the last event is a turn end or anything else), a fresh send is allowed, so legitimate consecutive resumes are never blocked.
 
-With the page open in several tabs, a localStorage mutex plus a shared per-session cooldown stamp guarantee exactly one tab sends — no duplicated 「继续」.
+With the page open in several tabs, a cross-tab atomic send lock (Web Locks API with a mutex-stamp fallback), a shared per-session cooldown stamp, and a shared send counter that hard-caps consecutive sends at `maxConsecutive` guarantee exactly one tab sends — no duplicated 「继续」, even when several tabs watch the same session.
 
 All knobs live in the plugin's settings card — see [Configuration](#configuration).
 
@@ -232,7 +232,7 @@ The plugin is browser-only and touches **no files, credentials, or network beyon
 
 - It opens the same two read-only event streams the web UI already uses (no extra server, no third-party endpoints)
 - The engine's **only automatic write** is `sessions.prompt` — the same call the Send button makes — with the text you configured (saving the settings card writes the `auto-continue` section of `~/.dsh/settings.yaml` through the normal settings API, exactly like any other setting)
-- Browser storage is limited to small `localStorage` keys: cross-tab coordination stamps, per-session pauses, and the daily stats counters
+- Browser storage is limited to small `localStorage` keys: cross-tab send locks and counts (a hard cap that stops duplicate sends even with several tabs open), per-session pauses, and the daily stats counters
 - Browser notifications are opt-in (`notify` setting) and permission is requested on first use only
 
 ---
@@ -243,7 +243,7 @@ The plugin is browser-only and touches **no files, credentials, or network beyon
 npm run typecheck   # tsc --noEmit
 npm run build       # lib/client.js + lib/index.js + lib/types
 npm run watch       # rebuild on change; host HMR hot-reloads without a page refresh
-npm run test        # node tests/simulate.mjs — 38 behavioral scenarios
+npm run test        # node tests/simulate.mjs — 43 behavioral scenarios
 ```
 
 While `npm run watch` runs, the profile's client-hmr row polls `lib/client.js` every 500 ms and hot-reloads the plugin in the browser — no server restart needed for code changes.

package/README.zh.md

@@ -64,9 +64,9 @@
 
 插件在浏览器里额外打开两条 SSE 流——`events.mux`(会话事件)与 `events.host`(宿主事件)。宿主支持多消费者, 与内置运行时互不干扰。检测到中断后先等待一个**宽限期**(默认 3 秒)——若宿主自行开启了新回合(`turn/start`), 自动继续即取消——然后以 `queue` 模式调用 `sessions.prompt` 发送配置的文本。
 
-页面启动 / 重连时, 插件还会扫描最近更新的会话: 若某个会话的最后一个回合在**扫描时间窗**(默认 15 分钟)内以非人为原因结束, 且之后没有新的 `turn/start` 或用户消息, 也会被自动续跑(例如浏览器关闭期间宿主崩溃的情况)。
+页面启动 / 重连时, 插件还会扫描最近更新的会话: 若某个会话的最后一个回合在**扫描时间窗**(默认 15 分钟)内以非人为原因结束, 且之后没有新的 `turn/start` 或用户消息, 也会被自动续跑(例如浏览器关闭期间宿主崩溃的情况)。每次发送前插件还会问宿主一个权威问题——会话的**最后一条事件**是否正是这条消息: 若相同文本还在排队(最后一条就是那条 `user/message`)则跳过; 一旦该消息已被处理(最后一条是回合结束或其他事件)就允许再发, 因此合法的连续续跑不会被误挡。
 
-多个标签页同时打开时, 通过 localStorage 互斥锁 + 共享的每会话冷却记录保证**只有一个标签页发送**——不会重复出现两条「继续」。
+多个标签页同时打开时, 通过跨标签页原子发送锁(Web Locks API, 旧环境回退互斥戳)+ 共享的每会话冷却记录 + 以 `maxConsecutive` 为硬上限的共享发送计数, 保证**只有一个标签页发送**——即使多个标签页盯着同一会话, 也不会重复出现两条「继续」。
 
 所有参数都在插件的设置卡片中调整——见 [配置](#配置)。
 
@@ -232,7 +232,7 @@ auto-continue:
 
 - 只复用 webui 本身就在用的两条只读事件流(无额外服务、无第三方端点)
 - 引擎**唯一会自动执行的写入**是 `sessions.prompt`——与点「发送」按钮完全相同的调用, 内容为你配置的文本(设置卡片里保存配置会通过常规设置 API 写入 `~/.dsh/settings.yaml` 的 `auto-continue` 段落, 与任何其他设置一样)
-- 浏览器存储仅限于少量 `localStorage` 键: 跨标签页协调时间戳、会话级暂停、每日统计计数
+- 浏览器存储仅限于少量 `localStorage` 键: 跨标签页发送锁与发送计数(多标签页同时打开时也绝不重复刷屏的硬上限)、会话级暂停、每日统计计数
 - 浏览器通知是可选开启的(`notify` 设置), 仅在首次使用时请求一次权限
 
 ---
@@ -243,7 +243,7 @@ auto-continue:
 npm run typecheck   # tsc --noEmit
 npm run build       # lib/client.js + lib/index.js + lib/types
 npm run watch       # 监听变更自动重建; 宿主 HMR 免刷新热重载
-npm run test        # node tests/simulate.mjs — 38 个行为场景
+npm run test        # node tests/simulate.mjs — 43 个行为场景
 ```
 
 `npm run watch` 运行时, profile 的 client-hmr 行每 500ms 轮询 `lib/client.js` 并在浏览器中热重载插件——改代码无需重启服务。

package/lib/client.js

@@ -204,31 +204,85 @@ function clientTimeZone() {
 var lockPrefix = "dsh-auto-continue:";
 var lockKey = (sessionId) => `${lockPrefix}lock:${sessionId}`;
 var stampKey = (sessionId) => `${lockPrefix}last:${sessionId}`;
-function claimSend(sessionId) {
+var countKey = (sessionId) => `${lockPrefix}count:${sessionId}`;
+function readLastSent(sessionId) {
   try {
-    const token = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    localStorage.setItem(lockKey(sessionId), token);
-    return localStorage.getItem(lockKey(sessionId)) === token;
+    const raw = localStorage.getItem(stampKey(sessionId));
+    if (raw === null) return { at: 0, text: "" };
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.text === "string") {
+      return { at: Number(parsed.at) || 0, text: parsed.text };
+    }
+    return { at: Number(raw) || 0, text: "" };
   } catch {
-    return true;
+    return { at: 0, text: "" };
   }
 }
-function releaseSend(sessionId) {
+function readLastSend(sessionId) {
+  return readLastSent(sessionId).at;
+}
+function writeLastSend(sessionId, at, text) {
   try {
-    localStorage.removeItem(lockKey(sessionId));
+    localStorage.setItem(stampKey(sessionId), JSON.stringify({ at, text }));
   } catch {
   }
 }
-function readLastSend(sessionId) {
+var SEND_COUNT_WINDOW_MS = 10 * 60 * 1e3;
+function readSendCount(sessionId) {
   try {
-    return Number(localStorage.getItem(stampKey(sessionId)) ?? 0) || 0;
+    const raw = localStorage.getItem(countKey(sessionId));
+    if (raw === null) return { at: 0, count: 0 };
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.count === "number") {
+      const at = Number(parsed.at) || 0;
+      if (Date.now() - at > SEND_COUNT_WINDOW_MS) return { at: 0, count: 0 };
+      return { at, count: parsed.count };
+    }
+  } catch {
+  }
+  return { at: 0, count: 0 };
+}
+function bumpSendCount(sessionId) {
+  try {
+    const current2 = readSendCount(sessionId);
+    localStorage.setItem(
+      countKey(sessionId),
+      JSON.stringify({ at: Date.now(), count: current2.count + 1 })
+    );
   } catch {
-    return 0;
   }
 }
-function writeLastSend(sessionId, at) {
+function clearSendCount(sessionId) {
   try {
-    localStorage.setItem(stampKey(sessionId), String(at));
+    localStorage.removeItem(countKey(sessionId));
+  } catch {
+  }
+}
+async function withSendLock(sessionId, body) {
+  const nav = globalThis.navigator;
+  if (nav?.locks !== void 0) {
+    await nav.locks.request(`dsh-auto-continue:send:${sessionId}`, body);
+    return;
+  }
+  if (!claimSend(sessionId)) return;
+  try {
+    await body();
+  } finally {
+    releaseSend(sessionId);
+  }
+}
+function claimSend(sessionId) {
+  try {
+    const token = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    localStorage.setItem(lockKey(sessionId), token);
+    return localStorage.getItem(lockKey(sessionId)) === token;
+  } catch {
+    return true;
+  }
+}
+function releaseSend(sessionId) {
+  try {
+    localStorage.removeItem(lockKey(sessionId));
   } catch {
   }
 }
@@ -340,17 +394,20 @@ var freshState = () => ({
   sameTextRun: 0,
   toolRun: void 0,
   loopFired: false,
-  loopCancelled: false
+  loopCancelled: false,
+  loopRetryTimer: void 0
 });
 var RECOVERY_WINDOW_MS = 10 * 60 * 1e3;
-function isOurEcho(state, event) {
+var ECHO_WINDOW_MS = 10 * 60 * 1e3;
+function isOurEcho(state, sessionId, event) {
   if (event.type !== "user/message") return false;
   const message = event.data;
   if (message.source.kind !== "user") return false;
-  if (state.lastSentText === "") return false;
-  if (Date.now() - state.lastAutoAt > 3e4) return false;
+  const last = readLastSent(sessionId);
+  if (last.at === 0 || last.text === "") return false;
+  if (Date.now() - last.at > ECHO_WINDOW_MS) return false;
   const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-  return text === state.lastSentText;
+  return text === last.text;
 }
 async function pumpStream(open, onFrame, onReconnect, getBackoff, log, signal) {
   let backoff = getBackoff();
@@ -410,6 +467,7 @@ var AutoContinueRunner = class {
     this.hostAbort.abort();
     for (const state of this.states.values()) {
       if (state.pendingTimer !== void 0) clearTimeout(state.pendingTimer);
+      if (state.loopRetryTimer !== void 0) clearTimeout(state.loopRetryTimer);
     }
     this.states.clear();
   }
@@ -587,6 +645,10 @@ ${frame.event.data.arguments}`;
         state.toolRun = void 0;
         state.loopFired = false;
         state.loopCancelled = false;
+        if (state.loopRetryTimer !== void 0) {
+          clearTimeout(state.loopRetryTimer);
+          state.loopRetryTimer = void 0;
+        }
         this.cancelPending(sessionId, "宿主自行开启新回合");
         break;
       case "turn/end": {
@@ -596,23 +658,34 @@ ${frame.event.data.arguments}`;
         if (reason.kind === "completed") {
           state.consecutive = 0;
           state.lastFailure = void 0;
+          clearSendCount(sessionId);
           this.noteRecovery(sessionId, "completed");
         } else if (reason.kind === "aborted") {
           if (state.loopCancelled) {
             state.loopCancelled = false;
             state.loopFired = false;
-            state.consecutive = 0;
             state.pendingRecoveryAt = 0;
             state.shortRun = 0;
             state.lastShortAt = 0;
             state.lastAssistantText = "";
             state.sameTextRun = 0;
             state.toolRun = void 0;
-            state.lastAttemptAt = 0;
-            this.schedule(sessionId, "loop:aborted");
+            const cooldown = this.cooldownFor(state);
+            const remaining = cooldown - (Date.now() - state.lastAttemptAt);
+            if (remaining > 0) {
+              if (state.loopRetryTimer !== void 0) clearTimeout(state.loopRetryTimer);
+              state.loopRetryTimer = setTimeout(() => {
+                state.loopRetryTimer = void 0;
+                this.schedule(sessionId, "loop:aborted");
+              }, remaining);
+              this.log(`loop 重启延迟 ${remaining}ms(冷却期) ${sessionId}`);
+            } else {
+              this.schedule(sessionId, "loop:aborted");
+            }
           } else {
             state.consecutive = 0;
             state.pendingRecoveryAt = 0;
+            clearSendCount(sessionId);
           }
         } else if (reason.kind === "blocked") {
         } else if (reason.kind === "interrupted") {
@@ -637,9 +710,10 @@ ${frame.event.data.arguments}`;
         break;
       }
       case "user/message":
-        if (isOurEcho(state, event)) break;
+        if (isOurEcho(state, sessionId, event)) break;
         if (event.data.source.kind === "user") {
           state.consecutive = 0;
+          clearSendCount(sessionId);
           this.cancelPending(sessionId, "用户手动发送消息");
         }
         break;
@@ -811,12 +885,8 @@ ${frame.event.data.arguments}`;
       this.log(`跳过 ${sessionId}: 已有排队消息`);
       return;
     }
-    if (!force && Date.now() - readLastSend(sessionId) < this.cooldownFor(state)) {
-      this.log(`跳过 ${sessionId}: 其他标签页刚发送过`);
-      return;
-    }
-    if (!claimSend(sessionId)) {
-      this.log(`跳过 ${sessionId}: 其他标签页正在发送`);
+    if (!force && readSendCount(sessionId).count >= config.maxConsecutive) {
+      this.log(`跳过 ${sessionId}: 发送计数已达上限 ${config.maxConsecutive}, 等待用户介入或成功回合`);
       return;
     }
     const template = reason.startsWith("loop:") ? config.loopText : reason.includes("max-tokens") ? config.continueTextMaxTokens : config.continueText;
@@ -830,51 +900,69 @@ ${frame.event.data.arguments}`;
     }
     const text = this.buildContinueText(config, state, template, sessionTitle);
     const zone = clientTimeZone();
-    state.lastAttemptAt = Date.now();
-    try {
-      const response = await this.api.sessions.prompt({
-        sessionId,
-        mode: "queue",
-        content: [{ type: "text", text }],
-        ...zone === void 0 ? {} : { clientTimeZone: zone }
-      });
-      if (response.result.ok) {
-        const now = Date.now();
-        state.consecutive += 1;
-        state.lastAutoAt = now;
-        state.lastSentText = text;
-        state.pendingRecoveryAt = now;
-        writeLastSend(sessionId, now);
-        bumpStat({ sent: 1, ...state.lastFailure !== void 0 ? { code: state.lastFailure.code } : {} });
-        this.log(`已自动发送「${text}」到 ${sessionId}(${reason}), 第 ${state.consecutive} 次连续`);
-        if (config.notify) {
-          notify(
-            "dsh-auto-continue: 已自动继续",
-            `${sessionId}: 已发送「${text}」(第 ${state.consecutive} 次连续)`,
-            this.notifyOptions(sessionId)
-          );
-        }
-        if (state.consecutive >= config.maxConsecutive) {
-          bumpStat({ gaveUp: 1 });
-          this.log(`达到连续上限 ${config.maxConsecutive} 次, 停止自动继续 ${sessionId}`);
+    await withSendLock(sessionId, async () => {
+      if (this.disposed) return;
+      if (state.queued > 0) {
+        this.log(`跳过 ${sessionId}: 已有排队消息`);
+        return;
+      }
+      if (!force && Date.now() - readLastSend(sessionId) < this.cooldownFor(state)) {
+        this.log(`跳过 ${sessionId}: 其他标签页刚发送过`);
+        return;
+      }
+      if (!force && readSendCount(sessionId).count >= config.maxConsecutive) {
+        this.log(`跳过 ${sessionId}: 发送计数已达上限 ${config.maxConsecutive}, 等待用户介入或成功回合`);
+        return;
+      }
+      if (!force && await this.hostHasPendingSameText(sessionId, text)) {
+        this.log(`跳过 ${sessionId}: 宿主队列里已有相同文本消息在排队`);
+        return;
+      }
+      state.lastAttemptAt = Date.now();
+      try {
+        const response = await this.api.sessions.prompt({
+          sessionId,
+          mode: "queue",
+          content: [{ type: "text", text }],
+          ...zone === void 0 ? {} : { clientTimeZone: zone }
+        });
+        if (response.result.ok) {
+          const now = Date.now();
+          state.consecutive += 1;
+          state.lastAutoAt = now;
+          state.lastSentText = text;
+          state.pendingRecoveryAt = now;
+          writeLastSend(sessionId, now, text);
+          bumpSendCount(sessionId);
+          bumpStat({ sent: 1, ...state.lastFailure !== void 0 ? { code: state.lastFailure.code } : {} });
+          this.log(`已自动发送「${text}」到 ${sessionId}(${reason}), 第 ${state.consecutive} 次连续`);
           if (config.notify) {
             notify(
-              "dsh-auto-continue: 已停止自动继续",
-              `${sessionId}: 连续失败 ${state.consecutive} 次, 需要人工介入`,
+              "dsh-auto-continue: 已自动继续",
+              `${sessionId}: 已发送「${text}」(第 ${state.consecutive} 次连续)`,
               this.notifyOptions(sessionId)
             );
           }
+          if (state.consecutive >= config.maxConsecutive) {
+            bumpStat({ gaveUp: 1 });
+            this.log(`达到连续上限 ${config.maxConsecutive} 次, 停止自动继续 ${sessionId}`);
+            if (config.notify) {
+              notify(
+                "dsh-auto-continue: 已停止自动继续",
+                `${sessionId}: 连续失败 ${state.consecutive} 次, 需要人工介入`,
+                this.notifyOptions(sessionId)
+              );
+            }
+          }
+        } else {
+          this.log(
+            `发送失败 ${sessionId}: ${response.result.error.code} ${response.result.error.message}`
+          );
         }
-      } else {
-        this.log(
-          `发送失败 ${sessionId}: ${response.result.error.code} ${response.result.error.message}`
-        );
+      } catch (error) {
+        this.log(`发送异常 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
       }
-    } catch (error) {
-      this.log(`发送异常 ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
-    } finally {
-      releaseSend(sessionId);
-    }
+    });
   }
   /**
    * 组装本次续跑消息: 模板填充 + 幂等护栏。
@@ -910,6 +998,25 @@ ${frame.event.data.arguments}`;
     }
     return { kind: "failed", tool: state.lastTool };
   }
+  /**
+   * 宿主权威兜底: 历史里最后一条事件是否就是同一文本的 user 消息。
+   * 是 = 它还在排队未被处理, 不应再叠加发送; 否(回合结束等其他事件)= 放行。
+   * 查询失败时返回 false(放行, 本地防线仍在)。
+   */
+  async hostHasPendingSameText(sessionId, text) {
+    try {
+      const response = await this.api.sessions.history({ sessionId, maxMessages: 10 });
+      if (!response.result.ok) return false;
+      const events = response.result.value.events;
+      const last = events[events.length - 1]?.event;
+      if (last === void 0 || last.type !== "user/message") return false;
+      if (last.data.source?.kind !== "user") return false;
+      const lastText = (last.data.content ?? []).filter((part) => part.type === "text").map((part) => part.text).join("");
+      return lastText === text;
+    } catch {
+      return false;
+    }
+  }
   /** 查一次 session.list, 顺带缓存该会话的标题。 */
   async fetchSessionInfo(sessionId) {
     try {