@threadbase-sh/streamer 1.27.1 → 1.27.3

package/dist/index.d.cts

@@ -882,6 +882,7 @@ declare class StreamerServer {
     private allScanners;
     private scannerReady;
     private scannerStale;
+    private refreshInFlight;
     private binding;
     private cacheReady;
     private inFlightCacheWrites;
@@ -945,6 +946,7 @@ declare class StreamerServer {
     private bindWithRetry;
     private bindWithRetryLoop;
     private trackCacheWrite;
+    private refreshFileGuarded;
     close(): Promise<void>;
     private handleRequest;
     private handlePairStart;

package/dist/index.d.ts

@@ -882,6 +882,7 @@ declare class StreamerServer {
     private allScanners;
     private scannerReady;
     private scannerStale;
+    private refreshInFlight;
     private binding;
     private cacheReady;
     private inFlightCacheWrites;
@@ -945,6 +946,7 @@ declare class StreamerServer {
     private bindWithRetry;
     private bindWithRetryLoop;
     private trackCacheWrite;
+    private refreshFileGuarded;
     close(): Promise<void>;
     private handleRequest;
     private handlePairStart;

package/dist/index.js

@@ -5095,6 +5095,7 @@ var WSHub = class {
 var BROWSE_SYSTEM_PROMPT = (browseRoot) => `You are working within the project boundary: ${browseRoot}. Do not read, write, or execute commands that access files or directories outside this boundary.`;
 var DEFAULT_SYSTEM_PROMPT = "When presenting options or choices to the user, limit the options to at most 3.";
 var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
+var REFRESH_TTL_MS = 2e3;
 var START_READY_TIMEOUT_MS = 15e3;
 function parseIncludeAgentsEnv(raw) {
   if (raw === void 0) return false;
@@ -5134,6 +5135,12 @@ var StreamerServer = class {
   // Set by onConversationChanged while a scan is in-flight; getScanner() does
   // a single rescan after the current one completes instead of restarting it.
   scannerStale = false;
+  // Single-flight + TTL guard around scanner.refreshFile (see refreshFileGuarded).
+  // A live file's mtime is always newer than the snapshot, so an unguarded
+  // refresh fires on every request and re-parses the whole file from byte 0.
+  // Keyed by filePath; entries drop on settle + TTL expiry, so the map stays
+  // bounded by the active-file set.
+  refreshInFlight = /* @__PURE__ */ new Map();
   // True only while bindWithRetry is actively retrying. The persistent
   // listener-level 'error' handler demotes EADDRINUSE to debug during this
   // window so the self-healing kickstart-relaunch race doesn't spam warn.
@@ -5332,7 +5339,7 @@ var StreamerServer = class {
         if (session.status === "waiting_input" || session.status === "idle") {
           const filePath = this.sessionFileMap.get(session.id);
           if (filePath) {
-            this.getScanner().then((scanner) => scanner.refreshFile(filePath)).then((meta) => {
+            this.getScanner().then((scanner) => this.refreshFileGuarded(scanner, filePath)).then((meta) => {
               this.log.info("scanner.refreshFile: ok", {
                 event: "scanner.refresh",
                 sessionId: session.id,
@@ -5781,6 +5788,34 @@ var StreamerServer = class {
       this.inFlightCacheWrites.delete(guarded);
     });
   }
+  // Single-flight + TTL wrapper for scanner.refreshFile. Both call sites (the
+  // detail-stale branch and the per-turn refresh) route through here so that
+  // N stacked retries on a live, actively-appended file cost one parse, not N:
+  //  - a refresh already in flight for the path → await the same promise;
+  //  - a refresh that settled within REFRESH_TTL_MS → skip, return null (the
+  //    caller keeps serving the current snapshot);
+  //  - otherwise start one, cache the promise, and stamp completedAt on settle.
+  // The map is bounded by the active-file set (entries only live while a
+  // refresh is in flight or within its TTL and are overwritten on the next
+  // refresh of the same path).
+  refreshFileGuarded(scanner, filePath) {
+    const existing = this.refreshInFlight.get(filePath);
+    if (existing) {
+      const settled = existing.completedAt > 0;
+      if (!settled) {
+        return existing.promise;
+      }
+      if (Date.now() - existing.completedAt < REFRESH_TTL_MS) {
+        return Promise.resolve(null);
+      }
+    }
+    const entry = { promise: Promise.resolve(null), completedAt: 0 };
+    entry.promise = scanner.refreshFile(filePath).finally(() => {
+      entry.completedAt = Date.now();
+    });
+    this.refreshInFlight.set(filePath, entry);
+    return entry.promise;
+  }
   async close() {
     for (const timer of this.ptyGraceTimers.values()) clearTimeout(timer);
     this.ptyGraceTimers.clear();
@@ -6245,10 +6280,22 @@ var StreamerServer = class {
     const scanner = await this.getScanner(true);
     const fromIndex = await scanner.getConversation(uuid);
     if (fromIndex) {
+      if (this.ptyManager.hasSession(uuid)) {
+        return fromIndex;
+      }
       if (fromIndex.filePath && this.isConversationSnapshotStale(fromIndex)) {
-        const refreshedMeta = await scanner.refreshFile(fromIndex.filePath);
-        if (!refreshedMeta) return null;
-        return await scanner.getConversation(uuid) ?? fromIndex;
+        const filePath2 = fromIndex.filePath;
+        this.trackCacheWrite(
+          this.refreshFileGuarded(scanner, filePath2).catch((err) => {
+            this.log.warn("scanner.refreshFile: failed", {
+              event: "scanner.refresh_failed",
+              conversationId: uuid,
+              filePath: filePath2,
+              trigger: "detail-swr",
+              err
+            });
+          })
+        );
       }
       return fromIndex;
     }