@threadbase-sh/streamer 1.34.0 → 1.35.0

package/dist/cli.cjs

@@ -142454,12 +142454,13 @@ function fingerprintOf(ids) {
   return `sha256:${(0, import_crypto10.createHash)("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
-  constructor(cache, wsHub, log8, cacheDir, rescan) {
+  constructor(cache, wsHub, log8, cacheDir, rescan, runDuringReset) {
     this.cache = cache;
     this.wsHub = wsHub;
     this.log = log8;
     this.cacheDir = cacheDir;
     this.rescan = rescan;
+    this.runDuringReset = runDuringReset;
     const state = loadAlertState();
     this._pending = state.pending ?? null;
     this.ignoredIds = new Set(state.ignoredIds ?? []);
@@ -142469,6 +142470,7 @@ var CacheIntegrityMonitor = class {
   log;
   cacheDir;
   rescan;
+  runDuringReset;
   _pending;
   ignoredIds;
   deferredUnlinks = [];
@@ -142672,18 +142674,20 @@ var CacheIntegrityMonitor = class {
       }
       case "reset_rescan": {
         const backupPath = await this.ensureBackup(pending);
-        this.cache.clearAll();
-        if (this.rescan) {
-          try {
+        const reset = async () => {
+          this.cache.clearAll();
+          if (this.rescan) {
             const metas = await this.rescan();
             this.cache.upsertFromScannerMeta(metas);
-          } catch (err) {
-            this.log.error("cache-integrity reset rescan failed", {
-              event: "cache_integrity.reset_rescan_failed",
-              error: err instanceof Error ? err.message : String(err)
-            });
           }
-        }
+        };
+        const resetPromise = this.runDuringReset ? this.runDuringReset(reset) : reset();
+        void resetPromise.catch((err) => {
+          this.log.error("cache-integrity reset rescan failed", {
+            event: "cache_integrity.reset_rescan_failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
         this.clearPending();
         this.broadcastResolved(fingerprint2, action);
         return { ok: true, action, backupPath };
@@ -143911,7 +143915,8 @@ var StreamerServer = class {
   // listener-level 'error' handler demotes EADDRINUSE to debug during this
   // window so the self-healing kickstart-relaunch race doesn't spam warn.
   binding = false;
-  cacheReady = false;
+  activeWarmups = /* @__PURE__ */ new Map([[0, "startup"]]);
+  nextWarmupId = 1;
   // Every fire-and-forget task that runs a scan and then writes to this.cache
   // in an async continuation (startup warm-up, background count refresh, …).
   // close() awaits all of them before closing this.cache, so a scan's post-scan
@@ -144261,7 +144266,7 @@ var StreamerServer = class {
         this.wsHub.addClient(ws2);
         const sessions = this.sessionStore.list(this.ptyAttachedIds());
         ws2.send(JSON.stringify({ type: "session_list", sessions }));
-        if (this.cacheReady) {
+        if (!this.currentWarmupState()) {
           ws2.send(JSON.stringify({ type: "cache_ready" }));
         }
         const alertMsg = this.cacheMonitor?.wsMessage();
@@ -144470,6 +144475,39 @@ var StreamerServer = class {
     const addr = this.httpServer.address();
     return typeof addr === "object" && addr ? addr.port : 0;
   }
+  currentWarmupState() {
+    let current = null;
+    for (const state of this.activeWarmups.values()) current = state;
+    return current;
+  }
+  beginWarmup(state) {
+    const id = this.nextWarmupId++;
+    this.activeWarmups.set(id, state);
+    return id;
+  }
+  finishWarmup(id) {
+    if (!this.activeWarmups.delete(id) || this.activeWarmups.size > 0) return;
+    this.wsHub.broadcast({ type: "cache_ready" });
+  }
+  async withWarmup(state, operation) {
+    const id = this.beginWarmup(state);
+    try {
+      return await operation();
+    } finally {
+      this.finishWarmup(id);
+    }
+  }
+  rejectIfWarmingUp(res) {
+    const warmupState = this.currentWarmupState();
+    if (!warmupState) return false;
+    const body = {
+      error: "Server is warming up",
+      code: "SERVER_WARMING_UP",
+      warmupState
+    };
+    json2(res, 503, body);
+    return true;
+  }
   async listen(port, opts) {
     const dbConfig = this.disableDb ? null : getDbConfig();
     if (dbConfig) {
@@ -144527,6 +144565,11 @@ var StreamerServer = class {
             async () => {
               const scanner = await this.rescanForRefresh();
               return [...scanner.getMetadataCache().values()];
+            },
+            (operation) => {
+              const reset = this.withWarmup("cache_reset", operation);
+              this.trackCacheWrite(reset);
+              return reset;
             }
           );
           for (const dir of this.projectsDirs()) {
@@ -144622,8 +144665,7 @@ var StreamerServer = class {
             event: "cache.warmup_failed"
           });
         }).finally(() => {
-          this.cacheReady = true;
-          this.wsHub.broadcast({ type: "cache_ready" });
+          this.finishWarmup(0);
           resolveWarm();
         });
       }
@@ -144855,6 +144897,7 @@ var StreamerServer = class {
     return this.checkRateLimit(this.sessionInputAttempts, sessionId, 500, 6e4);
   }
   async handleListConversations(url2, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const limit = intParam(url2, "limit", 50);
     const offset = intParam(url2, "offset", 0);
     const sort = url2.searchParams.get("sort") ?? "recent";
@@ -144862,7 +144905,7 @@ var StreamerServer = class {
     const providerFilter = url2.searchParams.get("provider") ?? void 0;
     const bustCache = url2.searchParams.get("refresh") === "1";
     if (bustCache && this.cache) {
-      const scanner2 = await this.rescanForRefresh();
+      const scanner2 = await this.withWarmup("conversation_refresh", () => this.rescanForRefresh());
       const metas2 = [...scanner2.getMetadataCache().values()];
       try {
         this.cache.upsertFromScannerMeta(metas2);
@@ -144943,6 +144986,7 @@ var StreamerServer = class {
     json2(res, 200, { conversations: adapted, hasMore: offset + limit < total, offset, total });
   }
   async handleConversationsCount(url2, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const project = url2.searchParams.get("project") ?? void 0;
     const providerFilter = url2.searchParams.get("provider") ?? void 0;
     const bustCache = url2.searchParams.get("refresh") === "1";
@@ -144970,7 +145014,7 @@ var StreamerServer = class {
   // path — refresh=1 returns the cached total synchronously and this catches up.
   refreshCountInBackground() {
     this.trackCacheWrite(
-      (async () => {
+      this.withWarmup("conversation_refresh", async () => {
         try {
           const scanner = await this.getFreshScanner();
           if (this.cache) {
@@ -144982,13 +145026,15 @@ var StreamerServer = class {
             { event: "count.refresh_failed" }
           );
         }
-      })()
+      })
     );
   }
   handleSessionsCount(res) {
+    if (this.rejectIfWarmingUp(res)) return;
     json2(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
   }
   handleGetRecentSessions(url2, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const limit = intParam(url2, "limit", 20);
     if (!this.cache) {
       json2(res, 200, { sessions: [], total: 0 });
@@ -145436,6 +145482,7 @@ var StreamerServer = class {
     return isScannedSnapshotStale(conv.timestamp, mtimeMs);
   }
   async handleGetConversation(id, url2, res, ifNoneMatch) {
+    if (this.rejectIfWarmingUp(res)) return;
     const conversation = await this.findConversationByUuid(id);
     if (!conversation && this.cache) {
       const isFirstLoad = !url2.searchParams.has("before_index");
@@ -145763,6 +145810,7 @@ var StreamerServer = class {
     });
   }
   async handleListSessions(url2, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const now = Date.now();
     if (!this.discoveryCache || now - this.discoveryCache.fetchedAt >= DISCOVERY_TTL_MS) {
       try {
@@ -145795,6 +145843,7 @@ var StreamerServer = class {
     }
   }
   handleGetSession(sessionId, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
       if (!(0, import_fs28.existsSync)(session.projectPath)) {
@@ -146246,12 +146295,21 @@ var StreamerServer = class {
       json2(res, 404, { error: "Discovered session not found" });
       return;
     }
-    const { projectPath, projectName, branch } = discSession;
+    const { branch } = discSession;
+    let { projectPath, projectName } = discSession;
     const convId = discSession.id;
     if (discSession.pid == null) {
       json2(res, 400, { error: "Session has no known PID" });
       return;
     }
+    if (!projectPath) {
+      const jsonlPath = this.findJsonlPath(convId);
+      const jsonlCwd = jsonlPath ? await this.readCwdFromJsonl(jsonlPath) : null;
+      if (jsonlCwd) {
+        projectPath = jsonlCwd;
+        projectName = projectName || (0, import_path28.basename)(jsonlCwd);
+      }
+    }
     if (!projectPath) {
       this.log.warn("adopt: refusing, working directory unknown", {
         event: "adopt.no_project_path",
@@ -146264,6 +146322,22 @@ var StreamerServer = class {
       });
       return;
     }
+    const availability = classifyResumability(projectPath);
+    if (!availability.resumable) {
+      this.log.warn("adopt: refusing, project directory no longer exists", {
+        event: "adopt.project_path_missing",
+        sessionId,
+        pid: discSession.pid,
+        projectPath,
+        reason: availability.unavailable_reason
+      });
+      json2(res, 400, {
+        error: "Cannot take over this session: its project directory no longer exists",
+        code: "ADOPT_PROJECT_PATH_MISSING",
+        reason: availability.unavailable_reason
+      });
+      return;
+    }
     this.ptyManager.killPid(discSession.pid);
     const exited = await waitForProcessExit(discSession.pid, ADOPT_KILL_TIMEOUT_MS);
     if (!exited) {