Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

apps/desktop/electron/pool-eviction.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for electron/pool-eviction.ts — LRU cap accounting for the desktop
+ * backend pool. The cap exists to bound SPAWNED local backends (real child
+ * processes); process-less descriptor entries (remote/cloud registry sources,
+ * per-profile remote overrides) must not count against it, or a roster
+ * refresh across N registered remote connections evicts a real local backend
+ * that was merely idle past the keepalive window.
+ */
+
+import assert from 'node:assert/strict'
+
+import { test } from 'vitest'
+
+import { selectPoolEvictions } from './pool-eviction'
+
+const NOW = 1_000_000
+// Mirrors main.ts POOL_KEEPALIVE_FRESH_MS (4 minutes — see #95189).
+const FRESH_MS = 4 * 60_000
+
+/** A spawned local backend entry (has a child process). */
+const spawned = (idleMs: number) => ({ process: { pid: 123 }, lastActiveAt: NOW - idleMs })
+
+/** A process-less remote/cloud descriptor entry. */
+const descriptor = (idleMs: number) => ({ process: null, lastActiveAt: NOW - idleMs })
+
+test('process-less descriptors do not count toward the cap', () => {
+  // 1 real spawned backend idle beyond the keepalive window + 3 remote
+  // descriptors: total size (4) exceeds keep (2), but only ONE entry holds a
+  // process, so nothing may be evicted. This is the roster-refresh regression:
+  // the old size-based accounting evicted the real local backend here.
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['default', spawned(120_000)],
+    ['conn:homelab::default', descriptor(0)],
+    ['conn:office::default', descriptor(0)],
+    ['conn:cloud-a::default', descriptor(0)]
+  ]
+
+  assert.deepEqual(selectPoolEvictions(entries, 2, NOW, FRESH_MS), [])
+})
+
+test('spawned backends over the cap are still LRU-evicted', () => {
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['a', spawned(500_000)],
+    ['b', spawned(300_000)],
+    ['c', spawned(100_000)],
+    // Descriptors interleaved: must neither inflate the count nor be evicted.
+    ['conn:x::a', descriptor(999_000)]
+  ]
+
+  // keep=2 → one spawned backend over; evict the least-recently-used ('a').
+  assert.deepEqual(selectPoolEvictions(entries, 2, NOW, FRESH_MS), ['a'])
+})
+
+test('fresh spawned backends are spared even over the cap', () => {
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['a', spawned(1_000)],
+    ['b', spawned(2_000)],
+    ['c', spawned(3_000)]
+  ]
+
+  // All within the keepalive window → the pool may exceed the soft cap.
+  assert.deepEqual(selectPoolEvictions(entries, 1, NOW, FRESH_MS), [])
+})
+
+test('evicts only enough stale spawned backends to reach the cap', () => {
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['a', spawned(500_000)],
+    ['b', spawned(400_000)],
+    ['c', spawned(300_000)],
+    ['d', spawned(1_000)]
+  ]
+
+  // 4 spawned, keep 2 → remove 2, oldest first.
+  assert.deepEqual(selectPoolEvictions(entries, 2, NOW, FRESH_MS), ['a', 'b'])
+})
+
+test('descriptor-only pools never evict', () => {
+  const entries: [string, ReturnType<typeof descriptor>][] = [
+    ['conn:a::p', descriptor(999_000)],
+    ['conn:b::p', descriptor(999_000)],
+    ['conn:c::p', descriptor(999_000)],
+    ['conn:d::p', descriptor(999_000)]
+  ]
+
+  assert.deepEqual(selectPoolEvictions(entries, 2, NOW, FRESH_MS), [])
+})
+
+// ── #95189 — Keepalive-fresh window must tolerate transient missed pings ──
+// Symptom: gateway restarts every ~2 minutes on WSL2. Root cause: the renderer
+// pings every 60s; the LRU cap declared a backend "stale" if `lastActiveAt`
+// was > 90s ago — only 1.5× the ping interval. WSL2 IPC roundtrips (renderer
+// → 9p → Electron main → ipcMain.handle) commonly stall several seconds; one
+// delayed or missed ping pushed a live backend past the threshold and the
+// cap-driven eviction killed the active profile's backend mid-session,
+// forcing a restart loop that re-minted runtime ids and re-allocated pooled
+// gateway secondaries ~700×/day (#95189, related #87906/#84716/#88054).
+//
+// These tests pin the new tolerance: the keepalive-fresh window is wide
+// enough to absorb ≥1 missed ping (and the IPC stall headroom around it)
+// without evicting an active backend. Truly stale backends (multiple lapses,
+// minutes idle) are still evicted as before.
+
+test('#95189: one missed keepalive ping must NOT make the most-recently-touched backend evictable', () => {
+  // Renderer's keepalive cadence is 60s. With the old freshMs=90s window,
+  // a backend last touched 95s ago — i.e. exactly ONE missed/delayed ping —
+  // was eligible for LRU eviction even though it had been actively
+  // touched the moment before and would be touched again imminently.
+  //
+  // Build a pool where the only entry over the cap is the active one (95s
+  // idle). With the old 90s window, it was evicted; with the widened window
+  // the cap must instead be honored by leaving the pool over-cap for one
+  // extra cycle — killing an active backend is far worse than briefly
+  // exceeding the soft cap.
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['active', spawned(95_000)], // 1 missed ping on a 60s cadence
+    ['fresher', spawned(2_000)] // touched recently — must NOT be evicted
+  ]
+
+  // keep=1 → pool over cap by one. Active backend must be spared; the cap
+  // may be exceeded rather than kill a live backend (the long-standing
+  // "spare fresh backends" rule from #94381 / earlier pool-eviction tests).
+  assert.deepEqual(selectPoolEvictions(entries, 1, NOW, FRESH_MS), [])
+})
+
+test('#95189: two missed keepalive pings (2-min IPC stall) must NOT evict an active backend', () => {
+  // The reported symptom: gateways exited ~80–90s after start with a clean
+  // disconnect (no stderr), recurring every ~2 min. Reproduce the boundary:
+  // 125s of silence = just over two missed pings at 60s. A backend in this
+  // state is still actively serving — the renderer is mid-reconnect, not
+  // gone — so eviction here was the trigger for the restart loop.
+  //
+  // The other entries are all FRESH (well within the keepalive window), so
+  // no eviction is correct even before any cap considerations.
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['active', spawned(125_000)],
+    ['fresher', spawned(2_000)],
+    ['fresher-2', spawned(5_000)]
+  ]
+
+  assert.deepEqual(selectPoolEvictions(entries, 1, NOW, FRESH_MS), [])
+})
+
+test('#95189: a backend genuinely idle for minutes IS evicted (#95189 long-window scenario)', () => {
+  // Sanity: the widening does NOT make the pool unbounded. 10 minutes of
+  // silence (the documented POOL_IDLE_MS) is still fair game.
+  const entries: [string, ReturnType<typeof spawned>][] = [
+    ['idle', spawned(10 * 60_000)],
+    ['fresh', spawned(5_000)]
+  ]
+
+  // keep=1, idle is over the cap AND past the fresh window → evicted.
+  assert.deepEqual(selectPoolEvictions(entries, 1, NOW, FRESH_MS), ['idle'])
+})