@threadbase-sh/streamer 1.41.0 → 1.41.1

package/dist/cli.cjs

@@ -141533,7 +141533,8 @@ var ManagedSessionsRepository = class {
              completed_at = @completed_at,
              last_activity_at = @last_activity_at,
              prompt_count = @prompt_count,
-             failure_reason = COALESCE(@failure_reason, failure_reason)
+             failure_reason = COALESCE(@failure_reason, failure_reason),
+             session_name = COALESCE(@session_name, session_name)
        WHERE session_id = @session_id
     `);
     this.getStmt = db.prepare("SELECT * FROM managed_sessions WHERE session_id = ?");
@@ -141590,7 +141591,8 @@ var ManagedSessionsRepository = class {
       completed_at: fields.completedAt?.getTime() ?? null,
       last_activity_at: fields.lastActivityAt?.getTime() ?? null,
       prompt_count: fields.promptCount ?? 0,
-      failure_reason: fields.failureReason ?? null
+      failure_reason: fields.failureReason ?? null,
+      session_name: fields.sessionName ?? null
     });
   }
   get(sessionId) {
@@ -142825,8 +142827,8 @@ var PTY_COLS2 = 120;
 var PTY_ROWS2 = 40;
 var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
-var PROMPT_MARKER_FALLBACK_MS = 1e4;
 var QUIET_DETECT_MS2 = 500;
+var CLAUDE_READY_FALLBACK_MS = 8e3;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
@@ -142902,8 +142904,8 @@ var PTYManager = class {
   // silently lost — the "dot bug".
   queuedInputs = /* @__PURE__ */ new Map();
   log;
-  // Timestamp of first PTY chunk per session; drives the prompt-marker fallback
-  // when neither ╭ nor ❯ shows up within PROMPT_MARKER_FALLBACK_MS.
+  // Timestamp of first PTY chunk per session; used for the [pty.ready] elapsed
+  // measurement so a slow boot is visible in the logs.
   firstChunkAt = /* @__PURE__ */ new Map();
   // Per-session chunk counter and last-chunk timestamp. Diagnostic-only,
   // feeds the [pty.chunk] log lines so we can trace whether Claude responded
@@ -142914,6 +142916,8 @@ var PTYManager = class {
   // QUIET_DETECT_MS after the last chunk so ready/prompt detection doesn't
   // wait for another chunk that may never arrive (Claude blocked on input).
   quietCheckers = /* @__PURE__ */ new Map();
+  // Per-session flat backstop from the first chunk (CLAUDE_READY_FALLBACK_MS).
+  readyFallbackTimers = /* @__PURE__ */ new Map();
   // In-flight start()/startFresh() calls keyed by sessionId. A second
   // concurrent resume for the same session (double-tap, client retry) awaits
   // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
@@ -142999,6 +143003,7 @@ var PTYManager = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -143059,6 +143064,7 @@ var PTYManager = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -143233,6 +143239,7 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
     this.quietCheckers.get(sessionId)?.cancel();
     this.quietCheckers.delete(sessionId);
+    this.clearReadyFallback(sessionId);
     try {
       session.process.kill("SIGINT");
     } catch {
@@ -143321,6 +143328,8 @@ var PTYManager = class {
     this.lastChunkAt.clear();
     for (const quiet of this.quietCheckers.values()) quiet.cancel();
     this.quietCheckers.clear();
+    for (const timer of this.readyFallbackTimers.values()) clearTimeout(timer);
+    this.readyFallbackTimers.clear();
     this.permissionOpen.clear();
     this.lastScreenQuestionKey.clear();
     this.shellPromptOpen.clear();
@@ -143363,8 +143372,6 @@ var PTYManager = class {
     const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m2) => stripped.includes(m2));
     if (session.status === "running" && matchedMarker) {
       this.markReady(sessionId, session, "prompt-marker", `marker:${matchedMarker}`);
-    } else if (session.status === "running" && this.pendingReady.has(sessionId) && now - (this.firstChunkAt.get(sessionId) ?? now) >= PROMPT_MARKER_FALLBACK_MS) {
-      this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
     }
     this.onOutput?.(sessionId, data);
     this.detectLivePrompts(sessionId, data, stripped).catch((err) => {
@@ -143464,7 +143471,13 @@ var PTYManager = class {
     const session = this.sessions.get(sessionId);
     if (session?.status !== "running") return;
     if (this.pendingReady.has(sessionId)) {
-      this.markReady(sessionId, session, "quiet-fallback", "quiet:timeout");
+      this.recheckReadyFromScreen(sessionId).catch((err) => {
+        this.log.warn("[pty.ready] boot screen recheck failed", {
+          event: "pty.ready_recheck_failed",
+          sessionId,
+          err
+        });
+      });
     } else {
       this.recheckReadyFromScreen(sessionId).catch((err) => {
         this.log.warn("[pty.ready] screen recheck failed", {
@@ -143496,9 +143509,32 @@ var PTYManager = class {
       this.markReady(sessionId, session, "screen-marker", `quiet:screen-marker:${matchedMarker}`);
     }
   }
+  // Flat backstop from the first chunk: if neither a prompt marker nor the
+  // screen recheck settles the session within CLAUDE_READY_FALLBACK_MS, mark it
+  // ready anyway so start requests resolve and queued input is not held
+  // forever. This is what makes the quiet-checker safe to be strict — a boot
+  // variant whose marker we cannot see still recovers, just 8s later instead of
+  // 500ms sooner and wrong. unref() so it never holds the process open.
+  armReadyFallback(sessionId) {
+    const timer = setTimeout(() => {
+      this.readyFallbackTimers.delete(sessionId);
+      const session = this.sessions.get(sessionId);
+      if (session?.status === "running" && this.pendingReady.has(sessionId)) {
+        this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
+      }
+    }, CLAUDE_READY_FALLBACK_MS);
+    timer.unref?.();
+    this.readyFallbackTimers.set(sessionId, timer);
+  }
+  clearReadyFallback(sessionId) {
+    const timer = this.readyFallbackTimers.get(sessionId);
+    if (timer) clearTimeout(timer);
+    this.readyFallbackTimers.delete(sessionId);
+  }
   // Transition a session from "running" to "waiting_input", clear pendingReady,
   // and flush any queued input. Idempotent: callers can invoke at any chunk.
   markReady(sessionId, session, source, reason) {
+    this.clearReadyFallback(sessionId);
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "waiting_input";
     session.statusSource = source;
@@ -143542,6 +143578,7 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
     this.quietCheckers.get(sessionId)?.cancel();
     this.quietCheckers.delete(sessionId);
+    this.clearReadyFallback(sessionId);
   }
 };
 function toPublicSession2(s3) {
@@ -146999,7 +147036,11 @@ var StreamerServer = class {
             completedAt: session.completedAt,
             lastActivityAt: session.lastActivityAt ?? null,
             promptCount: session.promptCount,
-            failureReason: session.failureReason ?? null
+            failureReason: session.failureReason ?? null,
+            // Derived from the first user message, so it does not exist yet at
+            // recordSpawn. The input that produces it also flips
+            // waiting_input→running, which lands here.
+            sessionName: session.sessionName ?? null
           }
         );
         if (session.status === "waiting_input" || session.status === "idle") {