@threadbase-sh/streamer 1.36.2 → 1.36.4

package/dist/index.cjs

@@ -1449,6 +1449,9 @@ var import_fs6 = require("fs");
 var import_path6 = require("path");
 
 // src/services/questions/detectPermissionGate.ts
+function permissionContentKey(gate) {
+  return `${gate.prompt ?? ""}::${gate.detail ?? ""}::${gate.options.map((o) => `${o.index}.${o.label}`).join(",")}::${gate.cursor ?? ""}`;
+}
 var OSC_777_PERMISSION_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*needs your permission/;
 var OSC_777_WAITING_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*waiting for your input/;
 function hasPermissionOsc(rawData) {
@@ -6884,6 +6887,11 @@ var StreamerServer = class {
   // to pendingQuestions; mobile answers it by sending the option index via
   // /input { keys }. Cleared when the gate closes.
   pendingPermission = /* @__PURE__ */ new Map();
+  // Content key (prompt + detail + options + cursor) of the permission gate
+  // currently broadcast for a session — mirrors pendingQuestionKey so a PTY
+  // repaint of the same gate doesn't re-broadcast on every tick. Cleared
+  // alongside pendingPermission.
+  pendingPermissionKey = /* @__PURE__ */ new Map();
   scanner = null;
   // Set when better-sqlite3 is unusable (e.g. node ABI mismatch made
   // ConversationCache.open throw), or when config.scannerPersistent is false
@@ -6899,6 +6907,10 @@ 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 guard for the background disk reconcile: a burst of list
+  // polls during active session writes shares one rescan instead of queueing
+  // a full rescan per request.
+  conversationReconcileInFlight = null;
   // 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.
@@ -7177,6 +7189,7 @@ var StreamerServer = class {
             this.cancelPendingQuestion(session.id);
           }
           this.pendingPermission.delete(session.id);
+          this.pendingPermissionKey.delete(session.id);
           this.contendedSessions.delete(session.id);
           this.rememberSelfPtyEnded(session.id);
         }
@@ -7916,9 +7929,9 @@ var StreamerServer = class {
    * the automatic freshness path when the directory watcher marked the scanner
    * stale or shouldRefreshProjectsFromHdd detected disk drift.
    */
-  async reconcileConversationsCacheFromDisk() {
+  async reconcileConversationsCacheFromDisk(onProgress) {
     if (!this.cache) return;
-    const scanner = await this.rescanForRefresh();
+    const scanner = await this.rescanForRefresh(onProgress);
     const metas = [...scanner.getMetadataCache().values()];
     try {
       this.cache.upsertFromScannerMeta(metas);
@@ -7946,6 +7959,18 @@ var StreamerServer = class {
       );
     }
   }
+  // Reconcile the cache from disk without blocking the caller. Single-flighted
+  // so a burst of list polls during active session writes shares one rescan
+  // rather than queueing a full rescan each; tracked so close() awaits the
+  // in-flight cache write before shutting the DB.
+  startBackgroundConversationReconcile() {
+    if (this.conversationReconcileInFlight) return;
+    const task = this.reconcileConversationsCacheFromDisk().finally(() => {
+      this.conversationReconcileInFlight = null;
+    });
+    this.conversationReconcileInFlight = task;
+    this.trackCacheWrite(task);
+  }
   shouldAutoReconcileConversationList() {
     if (!this.cache) return false;
     if (this.scannerStale) return true;
@@ -7963,13 +7988,19 @@ var StreamerServer = class {
     const providerFilter = url.searchParams.get("provider") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
     if (this.cache && (bustCache || this.shouldAutoReconcileConversationList())) {
-      if (bustCache) {
+      const canServeStale = !bustCache && this.cache.listConversations({ limit: 0, offset: 0 }).total > 0;
+      if (canServeStale) {
+        this.startBackgroundConversationReconcile();
+      } else {
+        const shouldEmitProgress = createScanProgressThrottle();
         await this.withWarmup(
           "conversation_refresh",
-          () => this.reconcileConversationsCacheFromDisk()
+          () => this.reconcileConversationsCacheFromDisk((scanned, total2) => {
+            if (shouldEmitProgress(scanned, total2)) {
+              this.wsHub.broadcast({ type: "scan_progress", scanned, total: total2 });
+            }
+          })
         );
-      } else {
-        await this.reconcileConversationsCacheFromDisk();
       }
     }
     if (this.cache) {
@@ -8205,7 +8236,7 @@ var StreamerServer = class {
   // getFreshScanner() this does NOT discard the warm scanner. scannerReady is
   // only ever reassigned to a live scan promise (never nulled mid-scan), so the
   // getScanner() anti-infinite-loop guard is preserved.
-  async rescanForRefresh() {
+  async rescanForRefresh(onProgress) {
     if (this.scannerReady) await this.scannerReady;
     this.scannerStale = false;
     if (!this.scanner) {
@@ -8216,7 +8247,8 @@ var StreamerServer = class {
     this.scannerReady = scanner.scan({
       ...this.scanProfiles ? { profiles: this.scanProfiles } : {},
       ...this.codexScanOpts(),
-      fullRescan: true
+      fullRescan: true,
+      ...onProgress ? { onProgress } : {}
     });
     await this.scannerReady;
     return scanner;
@@ -9194,10 +9226,14 @@ var StreamerServer = class {
     if (gate === null) {
       if (!this.pendingPermission.has(sessionId)) return;
       this.pendingPermission.delete(sessionId);
+      this.pendingPermissionKey.delete(sessionId);
       this.wsHub.broadcast({ type: "permission_cancelled", sessionId });
       return;
     }
+    const key = permissionContentKey(gate);
+    if (this.pendingPermissionKey.get(sessionId) === key) return;
     this.pendingPermission.set(sessionId, gate);
+    this.pendingPermissionKey.set(sessionId, key);
     const subscriberCount = this.sessionSubscribers.get(sessionId)?.size ?? 0;
     this.log.info(
       `[ws.broadcast_permission] ${sessionId.slice(0, 8)} subscribers=${subscriberCount}`,