@threadbase-sh/streamer 1.42.0 → 1.43.0

package/dist/cli.cjs

@@ -146439,6 +146439,34 @@ function paginate(results, offset, limit) {
   };
 }
 
+// src/services/sessions/autoResumeOnBoot.ts
+var AUTO_RESUME_WINDOW_MS = 15 * 60 * 1e3;
+var AUTO_RESUME_MAX = 5;
+var AUTO_RESUME_CONCURRENCY = 2;
+var AUTO_RESUME_STAGGER_MS = 500;
+function autoResumeSkipReason(row, opts) {
+  if (row.status_source !== "shutdown") return "not_shutdown";
+  if (row.status !== "running" && row.status !== "waiting_input") return "not_interrupted";
+  if (opts.now - row.status_updated_at > AUTO_RESUME_WINDOW_MS) return "too_old";
+  if (!opts.projectExists(row.project_path)) return "project_missing";
+  if (resumeIdForRow(row) == null) return "resume_identity_missing";
+  return null;
+}
+function planAutoResume(rows, opts) {
+  const eligible = [];
+  const skipped = [];
+  for (const row of rows) {
+    const reason = autoResumeSkipReason(row, opts);
+    if (reason) skipped.push({ row, reason });
+    else eligible.push(row);
+  }
+  return {
+    attempts: eligible.slice(0, AUTO_RESUME_MAX),
+    skipped,
+    overflow: eligible.slice(AUTO_RESUME_MAX)
+  };
+}
+
 // src/services/sessions/conversationBusy.ts
 var import_fs29 = require("fs");
 var RESUME_BUSY_WINDOW_MS = 12e4;
@@ -147312,6 +147340,7 @@ var StreamerServer = class {
   disableDb = false;
   // Skip the startup warm-up scan (test hook; see ServerConfig.skipStartupWarmup).
   skipStartupWarmup;
+  autoResumeOnBoot;
   browseRoot = null;
   publicUrl = null;
   browserCors;
@@ -147428,6 +147457,7 @@ var StreamerServer = class {
     this.verbose = config2.verbose ?? false;
     this.disableDb = config2.disableDb ?? false;
     this.skipStartupWarmup = config2.skipStartupWarmup ?? false;
+    this.autoResumeOnBoot = config2.autoResumeOnBoot ?? false;
     this.scannerPersistenceDisabled = config2.scannerPersistent === false;
     this.scanProfiles = config2.scanProfiles;
     this.codexRoots = config2.codexRoots ?? [(0, import_path29.join)((0, import_os13.homedir)(), ".codex", "sessions")];
@@ -147908,16 +147938,19 @@ var StreamerServer = class {
   broadcastOrUnicastSessionList(req) {
     const clientId = req.headers["x-client-id"];
     const ws2 = typeof clientId === "string" ? this.clientIdToWs.get(clientId) : void 0;
-    const payload = {
-      type: "session_list",
-      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
-    };
+    const payload = this.sessionListPayload();
     if (ws2) {
       this.wsHub.unicast(ws2, payload);
     } else {
       this.wsHub.broadcast(payload);
     }
   }
+  sessionListPayload() {
+    return {
+      type: "session_list",
+      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
+    };
+  }
   /**
    * Overlay boot-reconciliation verdicts onto session responses.
    *
@@ -148091,7 +148124,7 @@ var StreamerServer = class {
    * by id rather than duplicating it.
    */
   rehydratePreviousSessions(verdicts) {
-    if (!this.featureFlags.sessionRehydration || !this.managedSessionsRepo) return;
+    if (!this.managedSessionsRepo) return [];
     try {
       const now = Date.now();
       const rows = this.managedSessionsRepo.listRecoverable({
@@ -148100,7 +148133,7 @@ var StreamerServer = class {
       });
       const truncated = rows.length > REHYDRATE_MAX;
       const candidates = truncated ? rows.slice(0, REHYDRATE_MAX) : rows;
-      if (candidates.length === 0) return;
+      if (!this.featureFlags.sessionRehydration || candidates.length === 0) return candidates;
       const verdictById = new Map(verdicts.map((v2) => [v2.sessionId, v2]));
       let rehydrated = 0;
       const skippedBy = {};
@@ -148135,12 +148168,107 @@ var StreamerServer = class {
         skippedBy,
         truncated
       });
+      return candidates;
     } catch (err) {
       this.log.warn("[rehydrate] failed to rehydrate previous sessions", {
         event: "sessions.rehydrate_failed",
         err
       });
+      return [];
+    }
+  }
+  /** Resume only the recent sessions the user explicitly allowed us to start at boot. */
+  async autoResumePreviousSessions(rows) {
+    if (!this.autoResumeOnBoot) return;
+    const plan = planAutoResume(rows, { now: Date.now(), projectExists: import_fs30.existsSync });
+    const skippedBy = {};
+    for (const { row, reason } of plan.skipped) {
+      skippedBy[reason] = (skippedBy[reason] ?? 0) + 1;
+      this.log.debug(`[auto-resume] skipped ${row.session_id}: ${reason}`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason
+      });
     }
+    if (plan.skipped.length > 0) {
+      this.log.info(
+        `[auto-resume] left ${plan.skipped.length} ineligible session(s) for manual resume`,
+        {
+          event: "sessions.auto_resume_skipped",
+          skipped: plan.skipped.length,
+          skippedBy
+        }
+      );
+    }
+    for (const row of plan.overflow) {
+      this.log.info(`[auto-resume] left ${row.session_id} for manual resume: ceiling reached`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason: "ceiling_reached"
+      });
+    }
+    let resumed = 0;
+    let failed = 0;
+    const inFlight = /* @__PURE__ */ new Set();
+    let started = 0;
+    const resume = async (row) => {
+      try {
+        const outcome = await this.resumeSession({
+          sessionId: row.session_id,
+          projectName: row.project_name,
+          branch: row.branch
+        });
+        if (!outcome.ok) {
+          failed++;
+          this.log.info(`[auto-resume] skipped ${row.session_id}: ${outcome.reason}`, {
+            event: "sessions.auto_resume_skipped",
+            sessionId: row.session_id,
+            reason: outcome.reason,
+            ...outcome.reason === "conversation_busy" && {
+              detectedBy: outcome.detectedBy,
+              lastActivityMs: outcome.lastActivityMs,
+              likelyOwner: outcome.likelyOwner
+            }
+          });
+          return;
+        }
+        resumed++;
+        this.log.info(`[auto-resume] resumed ${row.session_id}`, {
+          event: "sessions.auto_resume_succeeded",
+          sessionId: row.session_id,
+          alreadyRunning: outcome.alreadyRunning
+        });
+      } catch (err) {
+        failed++;
+        this.log.warn(`[auto-resume] failed to resume ${row.session_id}`, {
+          event: "sessions.auto_resume_failed",
+          sessionId: row.session_id,
+          err
+        });
+      }
+    };
+    for (const row of plan.attempts) {
+      while (inFlight.size >= AUTO_RESUME_CONCURRENCY) {
+        await Promise.race(inFlight);
+      }
+      if (started > 0) {
+        await new Promise((resolve4) => setTimeout(resolve4, AUTO_RESUME_STAGGER_MS));
+      }
+      const task = resume(row);
+      inFlight.add(task);
+      void task.then(() => inFlight.delete(task));
+      started++;
+    }
+    await Promise.all(inFlight);
+    if (resumed > 0) this.wsHub.broadcast(this.sessionListPayload());
+    this.log.info(`[auto-resume] completed boot recovery: ${resumed} resumed`, {
+      event: "sessions.auto_resume_completed",
+      attempted: plan.attempts.length,
+      resumed,
+      failed,
+      ineligible: plan.skipped.length,
+      overflow: plan.overflow.length
+    });
   }
   /**
    * Pick a token guaranteed to appear in the spawned process's argv, for the
@@ -148462,8 +148590,9 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
-        void this.reconcilePreviousSessions().then((v2) => {
-          this.rehydratePreviousSessions(v2);
+        void this.reconcilePreviousSessions().then(async (v2) => {
+          const recoverableRows = this.rehydratePreviousSessions(v2);
+          await this.autoResumePreviousSessions(recoverableRows);
           this.pruneTerminalSessions();
         });
         if (this.skipStartupWarmup) {