@threadbase-sh/streamer 1.36.2 → 1.36.3

package/dist/index.cjs

@@ -6899,6 +6899,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.
@@ -7916,9 +7920,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 +7950,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 +7979,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 +8227,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 +8238,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;