@threadbase-sh/streamer 1.64.0 → 1.65.0

package/dist/index.js

@@ -10620,6 +10620,19 @@ var SessionHandlers = class {
       sessions: this.sessionStore.list(this.deps.ptyAttachedIds())
     });
   }
+  /**
+   * Same empty-unused check stop uses (promptCount === 0 and no cache row,
+   * including boundConversationId / resumedFromConversationId). Safe after
+   * putOnHold: the runner may already have dropped the live session.
+   */
+  forgetIfEmptyUnused(sessionId) {
+    const live = this.ptyManager.getSession(sessionId);
+    const stored = this.sessionStore.getManaged(sessionId);
+    const session = live ?? stored;
+    if (!session) return;
+    if (!this.shouldForgetEmptySession(session)) return;
+    this.forgetEmptyStoppedSession(sessionId);
+  }
   async handleAdopt(sessionId, res) {
     const discovered = await discoverClaudeProcesses();
     this.sessionStore.setDiscovered(discovered);
@@ -12814,6 +12827,7 @@ function createLiveSessionOptions(deps) {
       void deps.liveActivityNotifier()?.onStatusChange(session, previousStatus);
       void deps.waitingInputNotifier()?.onStatusChange(session, previousStatus);
       deps.sessionStatusBus.emit(`status:${session.id}`, session.status, session);
+      deps.maybeFireHoldWhenIdle?.(session);
     }
   };
 }
@@ -12962,7 +12976,20 @@ function createApiDeps(deps) {
             deny(msg.type, "session:control");
             return;
           }
-          deps.startGraceTimer(msg.sessionId, deps.ptyGracePeriodMs);
+          const when = msg.when;
+          if (when === void 0 || when === "grace") {
+            deps.startGraceTimer(msg.sessionId, deps.ptyGracePeriodMs);
+            return;
+          }
+          if (when === "waiting_input") {
+            deps.armHoldWhenIdle(msg.sessionId);
+            return;
+          }
+          deps.log().warn(`[pty.hold_when_unknown] hold_session when=${String(when)}`, {
+            event: "pty.hold_when_unknown",
+            sessionId: msg.sessionId,
+            when
+          });
         }
       } catch {
       }
@@ -15518,6 +15545,10 @@ var StreamerServer = class {
   // Consecutive grace-timer defers for a still-`running` session (see
   // GRACE_MAX_DEFERS). Reset when a subscriber reconnects or the PTY settles.
   ptyGraceDeferCounts = /* @__PURE__ */ new Map();
+  // Session ids that should be putOnHold at the next waiting_input/idle.
+  // Same lifetime as ptyGraceTimers: in-memory, dropped on close/restart.
+  // Last writer wins against the grace timer — never both armed.
+  holdWhenIdle = /* @__PURE__ */ new Set();
   // Map of sessionId → set of subscribed WS clients
   sessionSubscribers = /* @__PURE__ */ new Map();
   // sessionId → wall-clock ms of the last PTY chunk. Written from onOutput for
@@ -15745,7 +15776,8 @@ var StreamerServer = class {
         waitingInputNotifier: () => this.waitingInputNotifier,
         ptyAttachedIds: () => this.ptyAttachedIds(),
         cancelPendingQuestion: (sessionId) => this.cancelPendingQuestion(sessionId),
-        rememberSelfPtyEnded: (conversationId) => this.rememberSelfPtyEnded(conversationId)
+        rememberSelfPtyEnded: (conversationId) => this.rememberSelfPtyEnded(conversationId),
+        maybeFireHoldWhenIdle: (session) => this.maybeFireHoldWhenIdle(session)
       })
     );
     this.sessionWatchers = new SessionWatchers({
@@ -15908,6 +15940,7 @@ var StreamerServer = class {
       currentWarmupState: () => this.currentWarmupState(),
       addSessionSubscriber: (sessionId, ws) => this.addSessionSubscriber(sessionId, ws),
       startGraceTimer: (sessionId, delayMs) => this.startGraceTimer(sessionId, delayMs),
+      armHoldWhenIdle: (sessionId) => this.armHoldWhenIdle(sessionId),
       handleSessionsCount: (res) => this.handleSessionsCount(res),
       applyLiveSessionSetting: (id, req, res, setting) => this.applyLiveSessionSetting(id, req, res, setting),
       handlePairStart: (res) => this.handlePairStart(res),
@@ -16027,6 +16060,13 @@ var StreamerServer = class {
       this.ptyGraceTimers.delete(sessionId);
     }
     this.ptyGraceDeferCounts.delete(sessionId);
+    if (this.holdWhenIdle.delete(sessionId)) {
+      this.log.info(
+        `[hold-when-idle] cancelled ${sessionId} (subscribe)`,
+        { sessionId, event: "pty.hold_when_idle_cancel", reason: "subscribe" },
+        "pino"
+      );
+    }
   }
   /**
    * Bring up Live Activity push, if credentials are present (Feature 12).
@@ -16134,6 +16174,7 @@ var StreamerServer = class {
     return reaped;
   }
   startGraceTimer(sessionId, delayMs) {
+    this.holdWhenIdle.delete(sessionId);
     const existing = this.ptyGraceTimers.get(sessionId);
     if (existing) clearTimeout(existing);
     const timer = setTimeout(() => {
@@ -16175,6 +16216,63 @@ var StreamerServer = class {
     }, delayMs);
     this.ptyGraceTimers.set(sessionId, timer);
   }
+  clearGrace(sessionId) {
+    const existing = this.ptyGraceTimers.get(sessionId);
+    if (existing) {
+      clearTimeout(existing);
+      this.ptyGraceTimers.delete(sessionId);
+    }
+    this.ptyGraceDeferCounts.delete(sessionId);
+  }
+  /**
+   * Arm the in-app "Kill on idle" latch: hold now if already settled, otherwise
+   * on the next running → waiting_input (or idle). No grace delay, no defer cap.
+   * A subscribed leaving socket must not block an immediate hold.
+   */
+  armHoldWhenIdle(sessionId) {
+    if (!this.ptyManager.hasSession(sessionId)) return;
+    this.clearGrace(sessionId);
+    const status = this.ptyManager.getSession(sessionId)?.status ?? this.sessionStore.getManaged(sessionId)?.status;
+    if (status === "waiting_input" || status === "idle") {
+      this.holdWhenIdle.delete(sessionId);
+      this.ptyManager.putOnHold(sessionId);
+      this.forgetIfEmptyUnused(sessionId);
+      return;
+    }
+    this.holdWhenIdle.add(sessionId);
+    this.log.info(
+      `[hold-when-idle] armed ${sessionId}`,
+      { sessionId, event: "pty.hold_when_idle_armed" },
+      "pino"
+    );
+  }
+  /**
+   * Fire the Kill-on-idle latch from the shared onStatusChange funnel.
+   * Delete first so the ensuing idle transition cannot re-enter.
+   */
+  maybeFireHoldWhenIdle(session) {
+    if (session.status !== "waiting_input" && session.status !== "idle") return;
+    if (!this.holdWhenIdle.has(session.id)) return;
+    this.holdWhenIdle.delete(session.id);
+    if (this.hasSessionSubscriber(session.id)) {
+      this.log.info(
+        `[hold-when-idle] cancelled ${session.id} (subscriber)`,
+        { sessionId: session.id, event: "pty.hold_when_idle_cancel", reason: "subscriber" },
+        "pino"
+      );
+      return;
+    }
+    this.log.info(
+      `[hold-when-idle] holding ${session.id}`,
+      { sessionId: session.id, event: "pty.hold_when_idle_fire" },
+      "pino"
+    );
+    this.ptyManager.putOnHold(session.id);
+    this.forgetIfEmptyUnused(session.id);
+  }
+  forgetIfEmptyUnused(sessionId) {
+    this.sessionHandlers.forgetIfEmptyUnused(sessionId);
+  }
   get port() {
     const addr = this.httpServer.address();
     return typeof addr === "object" && addr ? addr.port : 0;
@@ -16607,6 +16705,7 @@ var StreamerServer = class {
   async close() {
     for (const timer of this.ptyGraceTimers.values()) clearTimeout(timer);
     this.ptyGraceTimers.clear();
+    this.holdWhenIdle.clear();
     if (this.idleReaperTimer) {
       clearInterval(this.idleReaperTimer);
       this.idleReaperTimer = null;