peachsim 0.1.625 → 0.1.627

package/src/host/bridge-host.ts

@@ -9,6 +9,7 @@ import {
 } from '../../scripts/dev-server-scanner.ts'
 import { buildBrowserAssetProxyUrl } from '../backend-origin.ts'
 import {
+  AUTOMATION_SIM_IDLE_REAP_TTL_MS,
   DEFAULT_SOOTSIM_BRIDGE_PORT,
   SOOTSIM_BRIDGE_SIM_CLOSE_CODE,
   SOOTSIM_BRIDGE_SIM_CLOSE_REASON,
@@ -260,23 +261,6 @@ export interface BridgeHostOptions {
    *  `peach serve` command resolves this with the same probe the
    *  upload itself uses (`resolveDefaultUploadOrigin`). */
   contrastOrigin?: string
-  /** override the abandoned-sim GC TTL (ms). defaults to
-   *  SIM_IDLE_REAP_TTL_MS (30 min). exists so the reaper integration test
-   *  can drive the real timer path deterministically instead of mocking
-   *  time. production callers should never set this. */
-  simIdleReapTtlMs?: number
-  /** override the idle GC TTL (ms) for automation sims (playwright-driver,
-   *  capture/factory). defaults to AUTOMATION_SIM_IDLE_REAP_TTL_MS (10 min).
-   *  test-only, like simIdleReapTtlMs. */
-  automationSimIdleReapTtlMs?: number
-  /** cap on concurrent non-primary automation sims before the reaper drops
-   *  the most-idle overflow. defaults to MAX_CONCURRENT_AUTOMATION_SIMS (6).
-   *  test-only. */
-  maxConcurrentAutomationSims?: number
-  /** grace (ms) below which an automation sim is never reaped by the cap,
-   *  even when over it. defaults to AUTOMATION_SIM_ACTIVE_GRACE_MS (60 s).
-   *  test-only. */
-  automationSimActiveGraceMs?: number
 }
 
 const DAEMON_HEARTBEAT_INTERVAL_MS = 5_000
@@ -417,25 +401,9 @@ export class SootSimBridgeHost {
   // terminal 4001 code, so the client closes the abandoned window instead
   // of reconnecting the zombie straight back in.
   private static SIM_IDLE_REAP_TTL_MS = 30 * 60_000
-  // automation sims (spawned by the playwright driver: `peach open --driver
-  // playwright`, the factory/screenshot capture path — `meta.sootsimHostDriver
-  // === 'playwright'`) are unattended one-shot browsers, never a human's tab. a
-  // capture run opens one per slide/app/retry and the 30-min human/dev TTL lets
-  // hundreds pile up inside the window — orphaned ms-playwright chromiums that
-  // drove the box to swap-thrash (load hit 157 in one incident). give them a far
-  // shorter idle TTL, and cap how many can sit concurrently: reap the most-idle
-  // overflow, but never a sim active within ACTIVE_GRACE (an agent composing
-  // between captures), nor primary / cli-attached / leased sims.
-  private static AUTOMATION_SIM_IDLE_REAP_TTL_MS = 10 * 60_000
-  private static MAX_CONCURRENT_AUTOMATION_SIMS = 6
-  private static AUTOMATION_SIM_ACTIVE_GRACE_MS = 60_000
 
   private preferredPort: number
   private portFallbackCount: number
-  private simIdleReapTtlMs: number
-  private automationSimIdleReapTtlMs: number
-  private maxConcurrentAutomationSims: number
-  private automationSimActiveGraceMs: number
   private shouldWriteLockfile: boolean
   private shouldWriteDevLockfile: boolean
   private getShellPort: (() => number | null) | null
@@ -486,14 +454,6 @@ export class SootSimBridgeHost {
       getExcludePorts: opts.agentScanExcludes,
     })
     this.contrastOrigin = opts.contrastOrigin?.replace(/\/$/, '') || null
-    this.simIdleReapTtlMs =
-      opts.simIdleReapTtlMs ?? SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS
-    this.automationSimIdleReapTtlMs =
-      opts.automationSimIdleReapTtlMs ?? SootSimBridgeHost.AUTOMATION_SIM_IDLE_REAP_TTL_MS
-    this.maxConcurrentAutomationSims =
-      opts.maxConcurrentAutomationSims ?? SootSimBridgeHost.MAX_CONCURRENT_AUTOMATION_SIMS
-    this.automationSimActiveGraceMs =
-      opts.automationSimActiveGraceMs ?? SootSimBridgeHost.AUTOMATION_SIM_ACTIVE_GRACE_MS
   }
 
   /** expose the agent host so tests and embedders can inspect state or
@@ -502,14 +462,6 @@ export class SootSimBridgeHost {
     return this.agentHost
   }
 
-  /** run the abandoned-sim GC pass on demand. the reaper normally fires off
-   *  the 30s idle-sweep timer; this lets the F21-3 integration test drive
-   *  the real path without waiting for the timer. not part of the public
-   *  WS protocol. */
-  reapIdleSimsForTest(now = Date.now()): void {
-    this.reapIdleSims(now)
-  }
-
   /** synchronous wrapper around startAsync for callers that don't care
    *  about port fallback outcomes. returns immediately; actual binding
    *  happens on the event loop. callers that need to know the bound port
@@ -816,6 +768,13 @@ export class SootSimBridgeHost {
             return
           }
 
+          // a capture the page is still running after its cli exited (`peach
+          // record start`) is use the idle reaper cannot see in cli traffic.
+          if (msg.type === 'bridge:capture-active' && sim) {
+            sim.lastActiveAt = Date.now()
+            return
+          }
+
           // write a partial patch into ~/.peach/config.json. fired by the
           // engine's settingsStore when a persisted key flips in a browser
           // tab (which has no fs access of its own). after the merge, we
@@ -2025,71 +1984,33 @@ export class SootSimBridgeHost {
   // automation sims are spawned by the playwright driver (`peach open
   // --driver playwright`, the factory/screenshot capture path), which tags them
   // with `meta.sootsimHostDriver === 'playwright'` via the host's addInitScript.
-  // they are unattended one-shot browsers, never a human's tab, so they get a
-  // shorter idle TTL and a concurrent cap.
   private isAutomationSim(sim: BridgeSimConnection): boolean {
     return sim.meta?.sootsimHostDriver === 'playwright'
   }
 
-  // an automation sim whose spawning playwright host process is still alive is
-  // an ACTIVE run, not an abandoned tab. mirrors the cli's playwrightHostPidForSim
-  // (control.ts): extract the host pid from meta, then check liveness so the
-  // host-side idle GC never kills a live capture/factory sim mid-run.
-  private automationSimOwnerAlive(sim: BridgeSimConnection): boolean {
-    const pid = Number(sim.meta?.sootsimHostPid)
-    if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) return false
-    try {
-      process.kill(pid, 0) // ESRCH → dead; EPERM → alive but unsignalable
-      return true
-    } catch (err) {
-      return (err as NodeJS.ErrnoException).code === 'EPERM'
-    }
-  }
-
   private reapIdleSims(now = Date.now()) {
     const attachedSimIds = new Set(this.cliSimBySocket.values())
-    // automation sims that pass every "someone cares" gate but are still under
-    // their TTL — candidates for the concurrent-cap pass below.
-    const automationLive: { sim: BridgeSimConnection; idleMs: number }[] = []
     for (const sim of this.sims.values()) {
-      if (sim.id === this.primarySimId) continue
       if (attachedSimIds.has(sim.id)) continue
-      if (this.getActiveLease(sim)) continue
-      // never-CLI-driven sims have lastActiveAt 0 — fall back to connectedAt
-      // so a freshly opened, not-yet-primary tab isn't reaped on the spot.
-      const lastTouched = Math.max(sim.lastActiveAt, sim.connectedAt)
-      const idleMs = now - lastTouched
       const automation = this.isAutomationSim(sim)
-      // a live-owner automation sim is an ACTIVE run (its spawning playwright host
-      // process is still alive) — never reap it. the host keeps Chrome alive
-      // intentionally and tears it down itself when ITS owner driver dies; only
-      // orphaned/host-dead autos are the leak this reaper targets. (2026-06: the
-      // 10-min automation TTL was reaping live capture + factory sims mid-run —
-      // too aggressive.) continue skips both the TTL reap and the cap pass below.
-      if (automation && this.automationSimOwnerAlive(sim)) continue
-      const ttl = automation ? this.automationSimIdleReapTtlMs : this.simIdleReapTtlMs
-      if (idleMs >= ttl) {
-        // terminal close → client closes the window, does not reconnect; the
-        // 'close' handler runs rememberDisconnectedSim → this.sims.delete.
-        this.closeSimSocketFromHost(sim.ws)
+      const lease = this.getActiveLease(sim)
+      // an automation sim is nobody's tab, so being primary or holding a cli
+      // lease (10 min from its last grant) says nothing about use: only a human
+      // interacting with a headed window keeps one past its idle window.
+      if (
+        automation ? lease?.kind === 'user-active' : sim.id === this.primarySimId || lease
+      ) {
         continue
       }
-      if (automation) automationLive.push({ sim, idleMs })
-    }
-    // concurrent cap: a burst of capture opens can pile up hundreds inside the
-    // TTL window. keep at most maxConcurrentAutomationSims of the freshest;
-    // reap the most-idle overflow, but never one active within the grace (an
-    // agent mid-capture between screenshots).
-    const cap = this.maxConcurrentAutomationSims
-    if (automationLive.length > cap) {
-      automationLive.sort((a, b) => b.idleMs - a.idleMs) // most-idle first
-      for (const { sim, idleMs } of automationLive.slice(
-        0,
-        automationLive.length - cap,
-      )) {
-        if (idleMs < this.automationSimActiveGraceMs) continue
-        this.closeSimSocketFromHost(sim.ws)
-      }
+      // never-CLI-driven sims have lastActiveAt 0 — fall back to connectedAt
+      // so a freshly opened, not-yet-primary tab isn't reaped on the spot.
+      const idleMs = now - Math.max(sim.lastActiveAt, sim.connectedAt)
+      const ttl = automation
+        ? AUTOMATION_SIM_IDLE_REAP_TTL_MS
+        : SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS
+      // terminal close → client closes the window, does not reconnect; the
+      // 'close' handler runs rememberDisconnectedSim → this.sims.delete.
+      if (idleMs >= ttl) this.closeSimSocketFromHost(sim.ws)
     }
   }