@threadbase-sh/streamer 1.64.0 → 1.66.0

package/dist/index.cjs

@@ -4136,7 +4136,7 @@ var import_events = require("events");
 var import_fs28 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_http = require("http");
-var import_os14 = require("os");
+var import_os15 = require("os");
 var import_path24 = require("path");
 
 // src/api/app.ts
@@ -4979,7 +4979,7 @@ function redactPath(path) {
 function worstStatus(checks) {
   const rank = { ok: 0, unknown: 1, degraded: 2, failed: 3 };
   return checks.reduce(
-    (worst, c) => rank[c.status] > rank[worst] ? c.status : worst,
+    (worst2, c) => rank[c.status] > rank[worst2] ? c.status : worst2,
     "ok"
   );
 }
@@ -5994,7 +5994,12 @@ var createMiscRoutes = (deps) => {
       // Whether to encrypt to this server. Additive, same contract as `push`:
       // absent means an older server, which a client must read as "unknown" and
       // resolve as today's plaintext path — never as a reason to fail.
-      e2ee: describeE2eeCapability(deps.featureFlagsConfig().values.e2ee)
+      e2ee: describeE2eeCapability(deps.featureFlagsConfig().values.e2ee),
+      // This build samples cheap host signals and pushes `host_pressure` when
+      // the box is starved. Additive capability flag only — live readings stay
+      // off this polled endpoint. Absent means an older server that never
+      // samples. Informational: pressure never holds, kills, or refuses sessions.
+      hostPressure: true
     });
   });
   app.get("/api/profiles", (c) => c.json([]));
@@ -10660,6 +10665,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);
@@ -12843,6 +12861,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);
     }
   };
 }
@@ -12866,6 +12885,7 @@ function createApiDeps(deps) {
     wsHub: deps.wsHub,
     cache: () => deps.cache(),
     cacheMonitor: () => deps.cacheMonitor(),
+    hostPressureMonitor: () => deps.hostPressureMonitor(),
     pushRepo: () => deps.pushRepo(),
     liveActivityPushEnabled: () => deps.liveActivityPushEnabled(),
     devicesRepo: () => deps.devicesRepo(),
@@ -12916,6 +12936,8 @@ function createApiDeps(deps) {
       }
       const alertMsg = deps.cacheMonitor()?.wsMessage();
       if (alertMsg) deps.wsHub.unicast(ws, alertMsg);
+      const pressureMsg = deps.hostPressureMonitor()?.wsMessage();
+      if (pressureMsg) deps.wsHub.unicast(ws, pressureMsg);
     },
     handleWsMessage: async (ws, raw, principal) => {
       const deny = (type, required) => {
@@ -12991,7 +13013,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 {
       }
@@ -13528,6 +13563,221 @@ function pruneAgentConversations(cache) {
   return { scanned: rows.length, pruned, missing };
 }
 
+// src/services/host-pressure/hostPressure.ts
+var import_os13 = require("os");
+var import_perf_hooks = require("perf_hooks");
+var HOST_PRESSURE_SAMPLE_MS = 5e3;
+var HOST_PRESSURE_BARS = {
+  memFreeRatio: {
+    enterElevated: 0.15,
+    leaveElevated: 0.17,
+    enterCritical: 0.08,
+    leaveCritical: 0.15
+  },
+  eventLoopP99Ms: {
+    enterElevated: 100,
+    leaveElevated: 80,
+    enterCritical: 250,
+    leaveCritical: 100
+  },
+  loadPerCpu: {
+    enterElevated: 1.25,
+    leaveElevated: 1.05,
+    enterCritical: 2,
+    leaveCritical: 1.25
+  },
+  // win32 has no loadavg. Busy ratio from os.cpus()[].times deltas is 0–1, so
+  // it cannot reuse loadPerCpu's 2.0 critical bar. Reason on the wire stays `load`.
+  cpuBusy: {
+    enterElevated: 0.85,
+    leaveElevated: 0.7,
+    enterCritical: 0.97,
+    leaveCritical: 0.85
+  },
+  liveAgentsPair: 4
+};
+var REASON_ORDER = ["memory", "event_loop", "load", "agents"];
+var RANK = { ok: 0, elevated: 1, critical: 2 };
+function worst(levels) {
+  return levels.reduce(
+    (acc, level) => RANK[level] > RANK[acc] ? level : acc,
+    "ok"
+  );
+}
+function schmittLowIsWorse(value, previous, enterElevated, leaveElevated, enterCritical, leaveCritical) {
+  if (previous === "critical") {
+    if (value < leaveCritical) return "critical";
+    if (value < leaveElevated) return "elevated";
+    return "ok";
+  }
+  if (previous === "elevated") {
+    if (value < enterCritical) return "critical";
+    if (value < leaveElevated) return "elevated";
+    return "ok";
+  }
+  if (value < enterCritical) return "critical";
+  if (value < enterElevated) return "elevated";
+  return "ok";
+}
+function schmittHighIsWorse(value, previous, enterElevated, leaveElevated, enterCritical, leaveCritical) {
+  if (previous === "critical") {
+    if (value > leaveCritical) return "critical";
+    if (value > leaveElevated) return "elevated";
+    return "ok";
+  }
+  if (previous === "elevated") {
+    if (value > enterCritical) return "critical";
+    if (value > leaveElevated) return "elevated";
+    return "ok";
+  }
+  if (value > enterCritical) return "critical";
+  if (value > enterElevated) return "elevated";
+  return "ok";
+}
+function timesTotal(times) {
+  return times.user + times.nice + times.sys + times.idle + times.irq;
+}
+function hostPressureOs(platform3) {
+  if (platform3 === "darwin" || platform3 === "linux" || platform3 === "win32") return platform3;
+  return void 0;
+}
+function cpuBusyRatio(previous, next) {
+  if (!previous || previous.length === 0 || next.length === 0 || previous.length !== next.length) {
+    return 0;
+  }
+  let idle = 0;
+  let total = 0;
+  for (let i = 0; i < next.length; i++) {
+    const dt = timesTotal(next[i]) - timesTotal(previous[i]);
+    if (dt <= 0) continue;
+    total += dt;
+    idle += Math.max(0, next[i].idle - previous[i].idle);
+  }
+  if (total <= 0) return 0;
+  return 1 - idle / total;
+}
+function classifyHostPressure(sample, previous, platform3) {
+  const memRaw = schmittLowIsWorse(
+    sample.memFreeRatio,
+    previous,
+    HOST_PRESSURE_BARS.memFreeRatio.enterElevated,
+    HOST_PRESSURE_BARS.memFreeRatio.leaveElevated,
+    HOST_PRESSURE_BARS.memFreeRatio.enterCritical,
+    HOST_PRESSURE_BARS.memFreeRatio.leaveCritical
+  );
+  const mem = platform3 === "darwin" && memRaw === "critical" ? "elevated" : memRaw;
+  const eventLoop = schmittHighIsWorse(
+    sample.eventLoopP99Ms,
+    previous,
+    HOST_PRESSURE_BARS.eventLoopP99Ms.enterElevated,
+    HOST_PRESSURE_BARS.eventLoopP99Ms.leaveElevated,
+    HOST_PRESSURE_BARS.eventLoopP99Ms.enterCritical,
+    HOST_PRESSURE_BARS.eventLoopP99Ms.leaveCritical
+  );
+  const ncpu = sample.ncpu > 0 ? sample.ncpu : 1;
+  const windows = platform3 === "win32";
+  const loadValue = windows ? sample.cpuBusyRatio ?? 0 : sample.load1 / ncpu;
+  const loadBars = windows ? HOST_PRESSURE_BARS.cpuBusy : HOST_PRESSURE_BARS.loadPerCpu;
+  const load = schmittHighIsWorse(
+    loadValue,
+    previous,
+    loadBars.enterElevated,
+    loadBars.leaveElevated,
+    loadBars.enterCritical,
+    loadBars.leaveCritical
+  );
+  const resourceLevel = worst([mem, eventLoop, load]);
+  const agentsPair = sample.liveAgents >= HOST_PRESSURE_BARS.liveAgentsPair && resourceLevel !== "ok";
+  const level = resourceLevel;
+  const firing = [];
+  if (mem !== "ok") firing.push("memory");
+  if (eventLoop !== "ok") firing.push("event_loop");
+  if (load !== "ok") firing.push("load");
+  if (agentsPair) firing.push("agents");
+  const reasons = REASON_ORDER.filter((reason) => firing.includes(reason));
+  return { level, reasons };
+}
+var HostPressureMonitor = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  timer = null;
+  level = "ok";
+  lastWarning = null;
+  start() {
+    this.opts.histogram?.enable();
+    if (this.timer) return;
+    const intervalMs = this.opts.intervalMs ?? HOST_PRESSURE_SAMPLE_MS;
+    this.timer = setInterval(() => this.tick(), intervalMs);
+    this.timer.unref?.();
+  }
+  tick() {
+    const sample = this.opts.readSample();
+    const platform3 = this.opts.platform ?? process.platform;
+    const classified = classifyHostPressure(sample, this.level, platform3);
+    if (classified.level === this.level) return;
+    this.level = classified.level;
+    const updatedAt = (this.opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+    if (classified.level === "ok") {
+      this.lastWarning = null;
+      this.opts.wsHub.broadcast({ type: "host_pressure_cleared", updatedAt });
+      return;
+    }
+    const os2 = hostPressureOs(platform3);
+    const message = {
+      type: "host_pressure",
+      level: classified.level,
+      reasons: classified.reasons,
+      liveAgents: sample.liveAgents,
+      updatedAt,
+      ...os2 ? { os: os2 } : {}
+    };
+    this.lastWarning = message;
+    this.opts.wsHub.broadcast(message);
+  }
+  wsMessage() {
+    return this.lastWarning;
+  }
+  dispose() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.opts.histogram?.disable();
+  }
+};
+function createHostPressureMonitor(wsHub, liveAgents) {
+  const histogram = (0, import_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
+  const windows = process.platform === "win32";
+  let prevCpuTimes = null;
+  const monitor = new HostPressureMonitor({
+    wsHub,
+    histogram,
+    readSample: () => {
+      const eventLoopP99Ms = histogram.percentile(99) / 1e6;
+      histogram.reset();
+      const total = (0, import_os13.totalmem)();
+      const cpuList = (0, import_os13.cpus)();
+      const sample = {
+        liveAgents: liveAgents(),
+        memFreeRatio: total > 0 ? (0, import_os13.freemem)() / total : 1,
+        eventLoopP99Ms,
+        load1: (0, import_os13.loadavg)()[0],
+        ncpu: cpuList.length
+      };
+      if (windows) {
+        const cpuTimes = cpuList.map((cpu) => cpu.times);
+        sample.cpuBusyRatio = cpuBusyRatio(prevCpuTimes, cpuTimes);
+        prevCpuTimes = cpuTimes;
+      }
+      return sample;
+    }
+  });
+  monitor.start();
+  return monitor;
+}
+
 // src/services/push/expoPushSender.ts
 var log5 = getLogger("expo-push");
 var EXPO_PUSH_ENDPOINT = "https://exp.host/--/api/v2/push/send";
@@ -15027,7 +15277,7 @@ function discoveredToResponse(d, conversationId) {
 
 // src/session-watchers.ts
 var import_fs27 = require("fs");
-var import_os13 = require("os");
+var import_os14 = require("os");
 var import_path23 = require("path");
 var SessionWatchers = class {
   constructor(deps) {
@@ -15109,7 +15359,7 @@ var SessionWatchers = class {
   // was passed to Claude via --session-id so the filename matches from the start.
   watchForJsonl(sessionId, projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
-    const projectsDir = (0, import_path23.join)((0, import_os13.homedir)(), ".claude", "projects", encoded);
+    const projectsDir = (0, import_path23.join)((0, import_os14.homedir)(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
     const filePath = (0, import_path23.join)(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
@@ -15547,6 +15797,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
@@ -15572,6 +15826,7 @@ var StreamerServer = class {
   wsToClientId = /* @__PURE__ */ new Map();
   cache = null;
   cacheMonitor = null;
+  hostPressureMonitor = null;
   projectsRepo = null;
   conversationsRepo = null;
   sessionsRepo = null;
@@ -15636,7 +15891,7 @@ var StreamerServer = class {
     this.skipStartupWarmup = config.skipStartupWarmup ?? false;
     this.autoResumeOnBoot = config.autoResumeOnBoot ?? false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [(0, import_path24.join)((0, import_os14.homedir)(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [(0, import_path24.join)((0, import_os15.homedir)(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const flagResolution = resolveFeatureFlags({
@@ -15653,7 +15908,7 @@ var StreamerServer = class {
     this.claudeFlagsPersistable = config.claudeFlags === void 0;
     this.claudeFlags = config.claudeFlags ?? loadClaudeFlags();
     this.claudeExtraArgs = config.claudeExtraArgs ?? loadClaudeExtraArgs();
-    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path24.join)((0, import_os14.homedir)(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path24.join)((0, import_os15.homedir)(), ".threadbase", "cache");
     this.runtimeDbPath = resolveRuntimeDbPath(config.runtimeDbPath);
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
@@ -15774,7 +16029,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({
@@ -15921,6 +16177,7 @@ var StreamerServer = class {
       // reset-and-rescan, and tests swap methods on the server instance.
       cache: () => this.cache,
       cacheMonitor: () => this.cacheMonitor,
+      hostPressureMonitor: () => this.hostPressureMonitor,
       pushRepo: () => this.pushRepo,
       liveActivityPushEnabled: () => this.liveActivityNotifier !== null,
       devicesRepo: () => this.devicesRepo,
@@ -15937,6 +16194,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),
@@ -16056,6 +16314,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).
@@ -16083,14 +16348,14 @@ var StreamerServer = class {
     }
     this.apnsClient = new ApnsClient(creds);
     const sender = new LiveActivitySender(this.apnsClient, pushRepo);
-    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os14.hostname)();
-    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, (0, import_os14.hostname)());
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os15.hostname)();
+    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, (0, import_os15.hostname)());
     this.liveActivityRenewal = new LiveActivityRenewalScheduler({
       repo: pushRepo,
       sender,
       sessionStore: this.sessionStore,
       serverId,
-      serverLabel: (0, import_os14.hostname)()
+      serverLabel: (0, import_os15.hostname)()
     });
     this.liveActivityRenewal.start();
     this.log.info("Live Activity push enabled", {
@@ -16110,7 +16375,7 @@ var StreamerServer = class {
    */
   initWaitingInputPush(pushRepo) {
     const sender = new ExpoPushSender(pushRepo, process.env.THREADBASE_EXPO_ACCESS_TOKEN);
-    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os14.hostname)();
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os15.hostname)();
     this.waitingInputNotifier = new WaitingInputNotifier(
       sender,
       serverId,
@@ -16163,6 +16428,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(() => {
@@ -16204,6 +16470,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;
@@ -16282,7 +16605,7 @@ var StreamerServer = class {
         let sessions = null;
         for (let attempt = 0; attempt < 2; attempt += 1) {
           const transport = await connectOrSpawnHost({
-            instanceId: process.env.THREADBASE_INSTANCE_ID ?? (0, import_os14.hostname)()
+            instanceId: process.env.THREADBASE_INSTANCE_ID ?? (0, import_os15.hostname)()
           });
           try {
             sessions = await this.ptyManager.useRemoteRunner(transport);
@@ -16329,6 +16652,10 @@ var StreamerServer = class {
       this.idleReaperTimer = setInterval(() => this.reapIdleSessions(), IDLE_REAP_SWEEP_MS);
       this.idleReaperTimer.unref?.();
     }
+    this.hostPressureMonitor = createHostPressureMonitor(
+      this.wsHub,
+      () => this.ptyAttachedIds().size
+    );
     const warmUp = new Promise((resolveWarm) => {
       {
         this.log.info(`Streamer server listening on port ${port}`, {
@@ -16636,10 +16963,13 @@ 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;
     }
+    this.hostPressureMonitor?.dispose();
+    this.hostPressureMonitor = null;
     this.lastAgentChunkAt.clear();
     this.terminalSeq.clear();
     if (this.ptyManager.isRemote()) this.ptyManager.dispose();
@@ -16833,7 +17163,7 @@ var StreamerServer = class {
             deviceToken: device.deviceToken,
             capabilities: device.capabilities,
             publicUrl: this.publicUrl,
-            machineName: (0, import_os14.hostname)(),
+            machineName: (0, import_os15.hostname)(),
             serverVersion: getVersion()
           })
         );
@@ -16867,7 +17197,7 @@ var StreamerServer = class {
       // Released builds that predate that fix DO still adopt it, so changing
       // this value moves where old devices talk. It is not a free field.
       publicUrl: this.publicUrl,
-      machineName: (0, import_os14.hostname)(),
+      machineName: (0, import_os15.hostname)(),
       ...device && {
         deviceId: device.deviceId,
         deviceToken: device.deviceToken,