peachsim 0.1.659 → 0.1.661

package/README.md

@@ -244,21 +244,16 @@ software renderer without the desktop browser's printing and service discovery
 libraries (`libcups2`, `libavahi-client3`). Headed launches and every launch on
 a Mac use full Chromium. When the needed browser is not installed, the CLI runs
 the resolved Playwright core's absolute installer entry for just that browser.
-On Linux the CLI checks the browser's shared libraries before launching and,
-when any are missing, exits naming them and the exact `apt-get install` line.
-The headless shell needs these Debian 12 packages (Ubuntu 24.04 and Debian 13
-add a `t64` suffix to `libglib2.0-0`, `libatk1.0-0`, `libatk-bridge2.0-0`,
-`libatspi2.0-0` and `libasound2`):
-
-```sh
-apt-get install --no-install-recommends libglib2.0-0 libnspr4 libnss3 \
-  libatk1.0-0 libatk-bridge2.0-0 libatspi2.0-0 libdbus-1-3 libx11-6 libxcb1 \
-  libxcomposite1 libxdamage1 libxext6 libxfixes3 libxrandr2 libgbm1 libexpat1 \
-  libxkbcommon0 libudev1 libasound2
-```
-
-Headed launches on Linux use full Chromium, which also needs `libcups2`,
-`libcairo2` and `libpango-1.0-0`. Later opens reuse that sim and
+On Linux the CLI checks the browser's shared libraries before launching. When
+the system lacks any, it downloads peach's own bundle of them once (Ubuntu 20.04
+builds, so they load on glibc 2.31 and newer; about 15 MB) into
+`$PEACH_HOME/linux-libs/` and launches the browser with that bundle on its
+library path, so no host needs `apt-get` or root. The bundle is pinned in
+`cli/drivers/linux-browser-libs.lock.json`; `bun scripts/linux-browser-libs.ts
+resolve` re-pins it, and the CLI release publishes any bundle the bucket lacks.
+
+Headed launches on Linux use full Chromium, whose extra libraries the bundle
+also carries. Later opens reuse that sim and
 reload it at the requested target. Use `peach do reload` when the target has not
 changed.
 Reserve `--new` for a genuinely concurrent sim; repeated new browser trees

package/cli/cli-update.ts

@@ -195,29 +195,61 @@ export function takeCliUpdateNotification(
   return update
 }
 
-export async function fetchCliReleaseFile(
-  url: string,
-  timeoutMs: number,
-): Promise<Buffer> {
-  let response: Response
+// `stallMs` bounds silence, not the whole transfer: the executable is tens of
+// megabytes, and on a slow link it keeps arriving well past any fixed total.
+// only a server that does not answer, or a stream that stops, is a failure.
+export async function fetchCliReleaseFile(url: string, stallMs: number): Promise<Buffer> {
+  const controller = new AbortController()
+  let timer = setTimeout(() => controller.abort(), stallMs)
+  const seconds = Math.round(stallMs / 1000)
   try {
-    response = await fetch(url, {
-      headers: { accept: 'application/octet-stream' },
-      signal: AbortSignal.timeout(timeoutMs),
-    })
-  } catch (error) {
-    throw new Error(
-      `could not reach the peach update service: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    )
-  }
-  if (!response.ok) {
-    throw new Error(
-      `peach update download failed: ${response.status} ${response.statusText}`,
-    )
+    let response: Response
+    try {
+      response = await fetch(url, {
+        headers: { accept: 'application/octet-stream' },
+        signal: controller.signal,
+      })
+    } catch (error) {
+      throw new Error(
+        controller.signal.aborted
+          ? `the peach update service did not answer ${url} within ${seconds}s`
+          : `could not reach the peach update service at ${url}: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+      )
+    }
+    // the answer arrived; the body gets its own full window.
+    clearTimeout(timer)
+    timer = setTimeout(() => controller.abort(), stallMs)
+    if (!response.ok) {
+      throw new Error(
+        `peach update download failed: ${response.status} ${response.statusText} (${url})`,
+      )
+    }
+    if (!response.body) throw new Error(`peach update service sent no body for ${url}`)
+    const reader = response.body.getReader()
+    const chunks: Uint8Array[] = []
+    try {
+      for (;;) {
+        const { done, value } = await reader.read()
+        if (done) break
+        chunks.push(value)
+        clearTimeout(timer)
+        timer = setTimeout(() => controller.abort(), stallMs)
+      }
+    } catch (error) {
+      throw new Error(
+        controller.signal.aborted
+          ? `peach update download of ${url} stalled for ${seconds}s`
+          : `peach update download of ${url} failed: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+      )
+    }
+    return Buffer.concat(chunks)
+  } finally {
+    clearTimeout(timer)
   }
-  return Buffer.from(await response.arrayBuffer())
 }
 
 export async function refreshCliUpdateCache(

package/cli/commands/compat.ts

@@ -277,9 +277,13 @@ async function scanLocalNative(
     }
   }
   // a local expo module declares its name in its native definition, Name("X"),
-  // whether or not the app's javascript spells it out.
+  // whether or not the app's javascript spells it out. swift first, so a
+  // module the report marks Swift points at its swift definition.
   for (const [, files] of nativeFilesByModule) {
-    for (const file of files) {
+    const swiftFirst = [...files].sort(
+      (a, b) => Number(b.endsWith('.swift')) - Number(a.endsWith('.swift')),
+    )
+    for (const file of swiftFirst) {
       const text = readSmallFile(file)
       if (!text) continue
       for (const match of text.matchAll(/\bName\(\s*"(\w+)"\s*\)/g)) {

package/cli/commands/control.ts

@@ -2069,7 +2069,13 @@ async function runUseLikeCommand(args: string[], opts: ControlCommandOptions = {
       // human is actively driving is the same footgun `claim` guards against,
       // so honor the lock here too (this command historically did not, which
       // let `peach use <id>` steal the user's live tab).
-      if (target.lockedBy && target.lockExpiresAt && target.lockExpiresAt > Date.now()) {
+      // a lease this CLI identity holds is its own target already.
+      if (
+        target.lockedBy &&
+        !target.lockedByMe &&
+        target.lockExpiresAt &&
+        target.lockExpiresAt > Date.now()
+      ) {
         const secs = Math.max(0, Math.round((target.lockExpiresAt - Date.now()) / 1000))
         if (target.lockedByKind === 'user-active') {
           // the active human is interacting with this tab. never steal it,
@@ -2086,7 +2092,7 @@ async function runUseLikeCommand(args: string[], opts: ControlCommandOptions = {
           // a cli lease is short (60s, refreshes per command) so this is
           // usually a real conflict, not a stale lock.
           console.error(
-            `  refused: ${target.id} is leased by ${target.lockedBy} (${secs}s)`,
+            `  refused: ${target.id} is leased by ${formatLockOwner(target.lockedBy)} (${secs}s)`,
           )
           console.error(
             `  \`peach use ${target.id} --force\` to take it, or \`peach open --new\` for a fresh sim`,
@@ -2130,7 +2136,10 @@ export async function runClaimCommand(args: string[], opts: ControlCommandOption
       const sims = await bridge.listSims()
       const target = resolveTargetSim(sims, parsed.positional[0] || parsed.simId)
       const priorHolder =
-        force && target.lockedBy && target.lockedByKind !== 'user-active'
+        force &&
+        target.lockedBy &&
+        !target.lockedByMe &&
+        target.lockedByKind !== 'user-active'
           ? target.lockedBy
           : null
       const result = await bridge.claim(target.id, { force })

package/cli/commands/inspect.ts

@@ -274,6 +274,13 @@ function formatNetworkStatus(e: NetworkEntryPayload): string {
   return String(e.status)
 }
 
+// how long a reload waits for the guest to boot, emit ready and settle. one
+// budget for an in-place app reload and a full page reload alike: a real app
+// that signs in and fetches over the network remounts past 10 s on a large
+// screen, while a full engine boot runs 5-8 s unloaded and well past 10 s on
+// a busy box.
+const RELOAD_READY_TIMEOUT_MS = 30000
+
 function describeReloadReadyBlocker(result: ReloadReadyResult): string {
   if (result.externalError) return `guest app errored: ${result.externalError}`
   if (result.loadingText) return `still showing "${result.loadingText}"`
@@ -3499,10 +3506,9 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           rnxExit(1)
         }
         // reload waits for the guest app's `sootsim:externalAppReady` signal
-        // (not just a live ws connection), with a 10s budget. fatal bundle
-        // failures surface as console errors that pile up fast — bail early
-        // in that case instead of waiting the full budget.
-        const READY_TIMEOUT_MS = 10000
+        // (not just a live ws connection) within RELOAD_READY_TIMEOUT_MS. fatal
+        // bundle failures surface as console errors that pile up fast — bail
+        // early in that case instead of waiting the full budget.
         let issuedReload = false
         let inPlaceReload = false
         try {
@@ -3560,30 +3566,27 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         let readyResult: ReloadReadyResult | null = null
         if (inPlaceReload) {
           readyResult = await pollForReloadReady(bridge, {
-            timeoutMs: READY_TIMEOUT_MS,
+            timeoutMs: RELOAD_READY_TIMEOUT_MS,
           })
         } else {
           // full page reload — wait for a fresh bridge before polling for ready.
           // engine-drift escalation made page reloads the COMMON case during
-          // engine iteration, and a full engine boot runs 5-8s unloaded and
-          // well past 10s on a busy box — a 10s reconnect budget here reads
-          // as "bridge-reconnect fails" exactly when someone is rebuilding.
-          const PAGE_RELOAD_TIMEOUT_MS = 30000
+          // engine iteration.
           if (issuedReload) await sleep(300)
           const reconnected = await waitForBridgeConnected(
             wsPort,
             commandTimeoutMs,
             simId,
-            { timeoutMs: PAGE_RELOAD_TIMEOUT_MS, simIdSource },
+            { timeoutMs: RELOAD_READY_TIMEOUT_MS, simIdSource },
           )
           if (reconnected) {
             finalBridge = reconnected
             readyResult = await pollForReloadReady(reconnected, {
-              timeoutMs: PAGE_RELOAD_TIMEOUT_MS,
+              timeoutMs: RELOAD_READY_TIMEOUT_MS,
             })
           } else {
             console.log(
-              `  ⚠ reload: bridge never reconnected within ${PAGE_RELOAD_TIMEOUT_MS}ms`,
+              `  ⚠ reload: bridge never reconnected within ${RELOAD_READY_TIMEOUT_MS}ms`,
             )
             finalBridge = null
           }
@@ -3643,7 +3646,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
       }
 
       case 'storage-clear': {
-        const READY_TIMEOUT_MS = 10000
         await clearConsole(bridge)
         const cleared = await bridge.send({
           type: 'evaluate',
@@ -3665,7 +3667,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         }
 
         const readyResult = await pollForReloadReady(bridge, {
-          timeoutMs: READY_TIMEOUT_MS,
+          timeoutMs: RELOAD_READY_TIMEOUT_MS,
         })
 
         if (wantsJson(effectiveArgs)) {

package/cli/commands/upgrade.ts

@@ -120,7 +120,7 @@ export async function upgradeCli(options: UpgradeOptions = {}): Promise<void> {
 
   console.log(`  v${current} → v${latest}`)
   console.log(`  downloading ${artifact}...`)
-  const executable = await fetchCliReleaseFile(artifactUrl, 120_000)
+  const executable = await fetchCliReleaseFile(artifactUrl, 30_000)
   const actualSha = createHash('sha256').update(executable).digest('hex')
   if (actualSha !== expectedSha) {
     throw new Error(
@@ -129,7 +129,9 @@ export async function upgradeCli(options: UpgradeOptions = {}): Promise<void> {
   }
 
   const executablePath = path.resolve(options.cliExecutablePath ?? process.execPath)
-  const tempDir = fs.mkdtempSync(path.join(path.dirname(executablePath), '.peach-update-'))
+  const tempDir = fs.mkdtempSync(
+    path.join(path.dirname(executablePath), '.peach-update-'),
+  )
   const candidatePath = path.join(tempDir, path.basename(executablePath))
   try {
     fs.writeFileSync(candidatePath, executable, { mode: 0o755 })

package/cli/current-sim.ts

@@ -21,6 +21,10 @@ const IDENTITY_ENV_VARS = [
   'PEACH_CLI_IDENTITY', // explicit override — fastest path, skips all pid lookups
   'CLAUDE_CODE_SESSION_ID', // claude code, if ever set
   'CODEX_THREAD_ID', // codex / openai agent thread, stable across tool invocations
+  // a Team Machine session, per agent run. its other runners set no session
+  // variable of their own, and the terminal variables below are inherited from
+  // whatever shell started the daemon, so every such agent would share one key.
+  'TM_SESSION',
   'TERM_SESSION_ID', // macOS Terminal.app + iTerm2
   'ITERM_SESSION_ID', // iTerm2 (older variant)
   'TMUX_PANE', // tmux — stable per pane