peachsim 0.1.1406 → 0.1.1465

package/cli/commands/control.ts

@@ -1,8 +1,11 @@
 import { spawn, spawnSync } from 'node:child_process'
 import fs from 'node:fs'
+import http from 'node:http'
+import https from 'node:https'
 import { createRequire } from 'node:module'
 import os from 'node:os'
 import path from 'node:path'
+import { bundleUrlForPlatform } from 'peach-engine/bundle-platform-url'
 import { encodeAppCatalogWire } from 'peach-engine/engine/app-catalog-wire'
 import {
   devices,
@@ -41,7 +44,10 @@ import {
   runtimeDir,
 } from '../../src/home-paths'
 import { applyHotMode } from '../../src/native-dev-bundle-url'
-import { readNativeFirebaseConfig } from '../../src/native-firebase-config'
+import {
+  readExpoConfigAsync,
+  readNativeFirebaseConfig,
+} from '../../src/native-firebase-config'
 import { ensureProfile } from '../../src/profiles'
 import { rnxPublicBrand } from '../../src/public-brand'
 import {
@@ -57,7 +63,6 @@ import { sleep } from '../../src/sleep'
 import { discoverAppCatalog } from '../app-catalog'
 import { loadRNXAppConfig } from '../app-config'
 import {
-  type DiscoveredAppFontSpec,
   discoverNativeLinkedAppFonts,
   encodeAppFontsWire,
   resolveMetroProjectRoot,
@@ -68,6 +73,7 @@ import {
   type ResolvedAppProject,
 } from '../app-project'
 import {
+  type DiscoveredAppSplashSpec,
   discoverConfigPluginAppSplash,
   discoverOneNativeAppSplash,
   encodeAppSplashWire,
@@ -560,6 +566,22 @@ async function resolveConnectionInputForCli(target: string): Promise<ResolvedDev
   )
 }
 
+// a dev server builds an app's graph on the first request for its bundle and
+// finishes the build after that request goes away. `peach open` asks as soon as
+// the bundle is resolved, so the build overlaps bridge, host and runtime boot;
+// the engine's own request for the same url then joins it, so the cli drops its
+// copy unread. nothing the open stamps asks the dev server, so a busy build
+// cannot change the page. the socket is unreferenced: a pending build never
+// holds the command open.
+function startDevServerBuild(bundleUrl: string): void {
+  const request = (bundleUrl.startsWith('https:') ? https : http).get(
+    bundleUrl,
+    (response) => response.resume(),
+  )
+  request.on('socket', (socket) => socket.unref())
+  request.on('error', () => {})
+}
+
 function getShellRoutePrefix(pathname: string): string {
   const normalized = pathname.replace(/\/+$/, '') || '/'
   if (normalized === '/__peachsim' || normalized.startsWith('/__peachsim/')) {
@@ -743,18 +765,9 @@ export function resolveShellBaseUrlForBridgePort(bridgePort: number): string {
 // loaded by JS already flow through normal runtime fetch capture; this covers
 // UIAppFonts-style assets that Metro can serve but the guest bundle never
 // fetches itself. auto-discovery only — scans the repo for expo-font config
-// plugin declarations, no user-facing flag.
-//
-// each discovered font is HEAD-checked against the metro host before we
-// include it on the URL. fonts whose metro asset URL 404s (typo in the
-// expo-font plugin config, missing file, or a wrong app.config picked up
-// by the scan) are dropped silently so the engine never tries to fetch a
-// known-bad URL at boot — that would just log a registration failure and
-// confuse anyone reading the page console.
-async function stampAppFonts(
-  urlStr: string,
-  project?: ResolvedAppProject | null,
-): Promise<string> {
+// plugin declarations, no user-facing flag. discovery keeps only font files
+// that exist on disk, so the stamp never waits on the dev server.
+function stampAppFonts(urlStr: string, project?: ResolvedAppProject | null): string {
   try {
     const url = new URL(urlStr)
     const bundleUrl = url.searchParams.get('bundle') || ''
@@ -764,48 +777,13 @@ async function stampAppFonts(
       projectDir: project.appDir,
     })
     if (specs.length === 0) return urlStr
-    const reachable = await filterReachableAppFonts(specs)
-    if (reachable.length === 0) return urlStr
-    url.searchParams.set('appFonts', encodeAppFontsWire(reachable))
+    url.searchParams.set('appFonts', encodeAppFontsWire(specs))
     return url.toString()
   } catch {
     return urlStr
   }
 }
 
-// HEAD-check each font URL with a short timeout. metro returns 200 (or
-// sometimes a redirect) for assets it can resolve and 500 with an ENOENT
-// trace for paths it cannot. anything not in the 2xx-3xx range gets dropped.
-async function filterReachableAppFonts(
-  specs: DiscoveredAppFontSpec[],
-): Promise<DiscoveredAppFontSpec[]> {
-  const results = await Promise.all(
-    specs.map(async (spec): Promise<DiscoveredAppFontSpec | null> => {
-      const controller = new AbortController()
-      const timer = setTimeout(() => controller.abort(), 1500)
-      try {
-        const res = await fetch(spec.url, {
-          method: 'HEAD',
-          signal: controller.signal,
-        })
-        if (res.status >= 200 && res.status < 400) return spec
-        return null
-      } catch {
-        return null
-      } finally {
-        clearTimeout(timer)
-      }
-    }),
-  )
-  // a font offered from more than one candidate metro root keeps the first
-  // url metro served.
-  const reachable = new Map<string, DiscoveredAppFontSpec>()
-  for (const spec of results) {
-    if (spec !== null && !reachable.has(spec.family)) reachable.set(spec.family, spec)
-  }
-  return [...reachable.values()]
-}
-
 async function resolveShellUrl(
   target: string,
   baseUrl: string,
@@ -856,6 +834,7 @@ async function resolveShellUrl(
 async function stampAppSplash(
   urlStr: string,
   project?: ResolvedAppProject | null,
+  oneAppSplash?: Promise<DiscoveredAppSplashSpec | null>,
 ): Promise<string> {
   try {
     const url = new URL(urlStr)
@@ -866,11 +845,11 @@ async function stampAppSplash(
           bundleUrl,
           projectDir: project.appDir,
         })
-      : await discoverOneNativeAppSplash(bundleUrl)
+      : await (oneAppSplash ?? discoverOneNativeAppSplash(bundleUrl))
     if (!spec) return urlStr
     // native splash assets are required for the first frame.
     for (const imageUrl of splashImageUrls(spec)) {
-      if (!(await splashImageReachable(imageUrl))) return urlStr
+      if (!splashImageOnDisk(imageUrl, project.appDir)) return urlStr
     }
     url.searchParams.set('appSplash', encodeAppSplashWire(spec))
     return url.toString()
@@ -897,16 +876,18 @@ function stampAppCatalog(urlStr: string, project?: ResolvedAppProject | null): s
   }
 }
 
-async function splashImageReachable(imageUrl: string): Promise<boolean> {
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), 1500)
+// a splash spec names `<origin>/assets/<project-relative-path>`, the file the
+// dev server serves from its project root, so the file is checked on disk and
+// the stamp never waits on a dev server busy building.
+function splashImageOnDisk(imageUrl: string, appDir: string): boolean {
+  const { pathname } = new URL(imageUrl)
+  if (!pathname.startsWith('/assets/')) return false
   try {
-    const res = await fetch(imageUrl, { method: 'HEAD', signal: controller.signal })
-    return res.status >= 200 && res.status < 400
+    return fs
+      .statSync(path.join(appDir, decodeURIComponent(pathname.slice('/assets/'.length))))
+      .isFile()
   } catch {
     return false
-  } finally {
-    clearTimeout(timer)
   }
 }
 
@@ -947,6 +928,10 @@ export interface BuildShellUrlOptions {
   theme?: string
   resolvedBundle?: ResolvedDevBundle
   project?: ResolvedAppProject | null
+  // a One app's splash, read from its dev server's manifest. `peach open`
+  // starts the read beside its early bundle request so the answer overlaps
+  // bridge and host setup instead of preceding the launch.
+  oneAppSplash?: Promise<DiscoveredAppSplashSpec | null>
   // deterministic-capture mode, stamped onto the engine URL as ?proof=1. the
   // shell worker, compositor worker and tenant worker each read it off the
   // host page URL at boot (syncProofModeFromInitUrl) and pin everything that
@@ -975,20 +960,44 @@ export interface BuildShellUrlOptions {
 }
 
 function readProjectNativeFirebaseConfig(
-  project: ResolvedAppProject | null | undefined,
-): Record<string, unknown> | null {
-  if (!project) return null
+  project: ResolvedAppProject,
+): Promise<Record<string, unknown> | null> {
   const require = createRequire(path.join(project.appDir, 'package.json'))
   try {
     require.resolve('@expo/config')
   } catch {
-    return null
-  }
-  try {
-    return readNativeFirebaseConfig(project.appDir)
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : String(error) }
+    return Promise.resolve(null)
   }
+  return readExpoConfigAsync(project.appDir)
+    .then((config) =>
+      readNativeFirebaseConfig(project.appDir, undefined, undefined, config),
+    )
+    .catch((error: unknown) => ({
+      error: error instanceof Error ? error.message : String(error),
+    }))
+}
+
+// evaluating the Expo config spawns node, so `peach open` starts the read as
+// soon as the project resolves and the shell url it builds takes that read. a
+// later build reads the config again.
+const startedNativeFirebaseConfigs = new Map<
+  string,
+  Promise<Record<string, unknown> | null>
+>()
+
+function startNativeFirebaseConfigRead(project: ResolvedAppProject | null) {
+  if (project)
+    startedNativeFirebaseConfigs.set(
+      project.appDir,
+      readProjectNativeFirebaseConfig(project),
+    )
+}
+
+function takeNativeFirebaseConfig(project: ResolvedAppProject | null | undefined) {
+  if (!project) return Promise.resolve(null)
+  const started = startedNativeFirebaseConfigs.get(project.appDir)
+  startedNativeFirebaseConfigs.delete(project.appDir)
+  return started ?? readProjectNativeFirebaseConfig(project)
 }
 
 function bundleUrlOf(urlStr: string): string | undefined {
@@ -1014,7 +1023,7 @@ export async function buildShellUrl(
     opts.project ?? (await resolveAppProjectForBundleUrl(bundleUrlOf(resolved)))
   const expoRoot = project?.appDir ?? null
   const stamped = stampAppCatalog(
-    await stampAppSplash(await stampAppFonts(resolved, project), project),
+    await stampAppSplash(stampAppFonts(resolved, project), project, opts.oneAppSplash),
     project,
   )
   const expoStamped = new URL(stamped)
@@ -1046,7 +1055,7 @@ export async function buildShellUrl(
   // own `@expo/config` (a dependency-free recorder) leaves it to the Peach
   // Metro plugin's endpoint.
   expoStamped.searchParams.delete('nativeFirebase')
-  const nativeFirebase = readProjectNativeFirebaseConfig(project)
+  const nativeFirebase = await takeNativeFirebaseConfig(project)
   if (nativeFirebase && expoStamped.searchParams.get('bundle'))
     expoStamped.searchParams.set('nativeFirebase', JSON.stringify(nativeFirebase))
   if (opts.bundleOriginOverride)
@@ -1129,13 +1138,8 @@ function deriveCurrentSimBaseUrl(
   }
 }
 
-export async function buildOpenUrl(
-  target: string,
-  baseUrl: string,
-  openToken: string,
-  opts: BuildShellUrlOptions = {},
-): Promise<string> {
-  const url = new URL(await buildShellUrl(target, baseUrl, opts))
+function withOpenToken(shellUrl: string, openToken: string): string {
+  const url = new URL(shellUrl)
   url.searchParams.set('inspectOpen', openToken)
   return url.toString()
 }
@@ -1788,50 +1792,7 @@ export async function runOpenCommand(
     resolvedBundle?.bundleUrl,
     projectRoot,
   )
-  const appConfig = await loadRNXAppConfig(project)
-  const configuredRuntimeVersion = appConfig?.runtimeVersion
-  const runtimeConfig = mergePeachConfig(
-    mergePeachConfig(
-      appConfig ? { ...appConfig, runtimeVersion: undefined } : undefined,
-      opts.runtimeConfig,
-    ),
-    commandConfig,
-  )
-  if (configuredRuntimeVersion) {
-    await ensureConfiguredRuntime(configuredRuntimeVersion)
-  }
-
-  // keep the bridge port and the shell base URL in one world: --base-url
-  // retargets polling at THAT world's bridge (otherwise open builds the page
-  // against one runtime while polling the other bridge for registration and
-  // times out after ~125s), and a pin nothing serves is refused rather than
-  // falling back to the discovered default, which used to send
-  // ensureBridgeForOpen below off to start a second shell.
-  const explicitBaseUrl = args.find((_, i) => args[i - 1] === '--base-url')
-  if (explicitBaseUrl) {
-    const pinned = resolveBridgePortForPin({
-      baseUrl: explicitBaseUrl,
-      wsPort: parsed.wsPort,
-      explicitPort: parsed.explicitPort,
-    })
-    if (pinned.error !== undefined) {
-      console.error(`  error: ${pinned.error}`)
-      peachExit(1)
-    } else {
-      parsed.wsPort = pinned.port
-    }
-  }
-
-  opts.signal?.throwIfAborted()
-  parsed.wsPort = await ensureBridgeForOpen(
-    parsed.wsPort,
-    parsed.explicitPort,
-    opts.resources,
-    explicitBaseUrl && !configuredRuntimeVersion ? 'external' : 'bridge',
-  )
-  if (opts.resources) opts.resources.port = parsed.wsPort
-  opts.signal?.throwIfAborted()
-
+  startNativeFirebaseConfigRead(project)
   // playwright is the browser-sim launcher. it owns an isolated profile and
   // can reap exactly its own browser tree. desktop opens the native host and
   // electron the Electron companion. none opens the user's browser profile.
@@ -1892,6 +1853,65 @@ export async function runOpenCommand(
     peachExit(1)
   }
 
+  // asked before the bundle so the dev server answers it ahead of the build
+  const oneAppSplash =
+    resolvedBundle && project && !findExpoAppConfig(project.appDir)
+      ? discoverOneNativeAppSplash(resolvedBundle.bundleUrl)
+      : undefined
+  if (resolvedBundle) {
+    // the engine fetches this url for its device's platform
+    const bundleUrl = applyHotMode(resolvedBundle.bundleUrl, hotMode)
+    startDevServerBuild(
+      deviceArg && isDeviceModel(deviceArg)
+        ? bundleUrlForPlatform(bundleUrl, getRuntimePlatform(deviceArg), () => bundleUrl)
+        : bundleUrl,
+    )
+  }
+
+  const appConfig = await loadRNXAppConfig(project)
+  const configuredRuntimeVersion = appConfig?.runtimeVersion
+  const runtimeConfig = mergePeachConfig(
+    mergePeachConfig(
+      appConfig ? { ...appConfig, runtimeVersion: undefined } : undefined,
+      opts.runtimeConfig,
+    ),
+    commandConfig,
+  )
+  if (configuredRuntimeVersion) {
+    await ensureConfiguredRuntime(configuredRuntimeVersion)
+  }
+
+  // keep the bridge port and the shell base URL in one world: --base-url
+  // retargets polling at THAT world's bridge (otherwise open builds the page
+  // against one runtime while polling the other bridge for registration and
+  // times out after ~125s), and a pin nothing serves is refused rather than
+  // falling back to the discovered default, which used to send
+  // ensureBridgeForOpen below off to start a second shell.
+  const explicitBaseUrl = args.find((_, i) => args[i - 1] === '--base-url')
+  if (explicitBaseUrl) {
+    const pinned = resolveBridgePortForPin({
+      baseUrl: explicitBaseUrl,
+      wsPort: parsed.wsPort,
+      explicitPort: parsed.explicitPort,
+    })
+    if (pinned.error !== undefined) {
+      console.error(`  error: ${pinned.error}`)
+      peachExit(1)
+    } else {
+      parsed.wsPort = pinned.port
+    }
+  }
+
+  opts.signal?.throwIfAborted()
+  parsed.wsPort = await ensureBridgeForOpen(
+    parsed.wsPort,
+    parsed.explicitPort,
+    opts.resources,
+    explicitBaseUrl && !configuredRuntimeVersion ? 'external' : 'bridge',
+  )
+  if (opts.resources) opts.resources.port = parsed.wsPort
+  opts.signal?.throwIfAborted()
+
   // --posture <open|closed> seeds the fold posture for the opened sim,
   // stamped on the engine URL next to ?device= so it round-trips instead of
   // being swallowed into the bundle param. only foldable devices (iphone-duo)
@@ -2002,6 +2022,7 @@ export async function runOpenCommand(
     theme: themeArg,
     resolvedBundle,
     project,
+    oneAppSplash,
     proof: args.includes('--proof'),
     ephemeral: ephemeralProfile,
     env: envArgs.length ? envArgs : undefined,
@@ -2029,6 +2050,9 @@ export async function runOpenCommand(
   const simMatchesToken = (sim: BridgeSimInfo) =>
     sim.url?.includes(`inspectOpen=${token}`) ?? false
 
+  // the reuse check builds the page url a new sim loads; building it once
+  // keeps the project's native config read, a node spawn, to one per open
+  let newSimShellUrl: string | null = null
   if (shouldReuseCurrentSim) {
     const bridge = createBridgeFromParsed(parsed)
     const simHint = parsed.simId ? ` --sim ${parsed.simId}` : ''
@@ -2060,7 +2084,7 @@ export async function runOpenCommand(
           }
         }
         if (!targetSim && parsed.simIdSource !== 'flag') {
-          targetShellUrl = await buildShellUrl(
+          targetShellUrl = newSimShellUrl = await buildShellUrl(
             target,
             applyPeachConfigToUrl(baseUrl, runtimeConfig),
             buildShellUrlOpts,
@@ -2105,6 +2129,11 @@ export async function runOpenCommand(
               buildShellUrlOpts,
             ))
           const navigationUrl = new URL(navigatedShellUrl)
+          const currentEphemeral = new URL(
+            deriveCurrentSimBaseUrl(targetSim, baseUrl),
+          ).searchParams.get('ephemeral')
+          if (currentEphemeral) navigationUrl.searchParams.set('ephemeral', currentEphemeral)
+          navigatedShellUrl = navigationUrl.toString()
           navigationUrl.searchParams.set('inspectOpen', token)
           bridge
             .send({
@@ -2184,7 +2213,10 @@ export async function runOpenCommand(
   }
 
   const configuredBaseUrl = applyPeachConfigToUrl(baseUrl, runtimeConfig)
-  const openUrl = await buildOpenUrl(target, configuredBaseUrl, token, buildShellUrlOpts)
+  const openUrl = withOpenToken(
+    newSimShellUrl ?? (await buildShellUrl(target, configuredBaseUrl, buildShellUrlOpts)),
+    token,
+  )
   const ownerPid = opts.ownerPid ?? getStableOwnerPid()
   if (!ownerPid) {
     console.error(

package/cli/commands/daemon-mac-app.ts

@@ -10,9 +10,9 @@
 // bundle Info.plist instead, so the entry reads "Peach Daemon".
 //
 // the bundle is regenerated every time `daemonInstall` runs — it's tiny
-// (a plist + a shell launcher) and the launcher embeds a snapshot of the
-// invocation, so `peach upgrade` followed by `peach daemon install --force` is
-// the documented upgrade path. there's no notarization
+// (a plist + a shell launcher) and the launcher execs the executable path
+// that installed it, which `peach upgrade` replaces in place before restarting
+// the daemon, so an upgrade needs no reinstall. there's no notarization
 // or Developer ID signing here yet; ad-hoc + hardened runtime is enough to
 // fix the attribution, and a real signed bundle (shipped via the runtime
 // CDN) is a follow-up.

package/cli/commands/daemon.ts

@@ -2,8 +2,8 @@
 //
 // wraps `peach serve` so it starts automatically on login and restarts if
 // it crashes. the agent points at the executable that ran `daemon install`,
-// so `peach upgrade` (which replaces that file in place) is picked up by
-// `peach daemon restart` without touching the plist/unit file.
+// and `peach upgrade` replaces that file in place and then restarts a running
+// daemon itself, so the plist/unit file never needs rewriting.
 //
 // `daemonInstall` is shared by `peach setup` and the explicit
 // `peach daemon install` machine-bootstrap path.

package/cli/commands/do-chain.ts

@@ -1,4 +1,5 @@
 import { BridgeInputError } from '../../src/bridge-contract-input'
+import { IdleObservationError } from './inspect/settling'
 import type { PerformResult } from '../../src/bridge-contract'
 import type { SimPerformStep } from '../../src/sim-client'
 
@@ -342,7 +343,7 @@ export async function runDoChain(
   let sim: Awaited<ReturnType<typeof connect>> | null = null
   try {
     sim = await connect({
-      port: parsed.wsPort,
+      port: parsed.explicitPort ? parsed.wsPort : undefined,
       sim: parsed.simIdSource === 'flag' ? parsed.simId : undefined,
       timeoutMs: parsed.commandTimeoutMs,
     })
@@ -436,7 +437,13 @@ export async function runDoChain(
             `  ⚠ auto-wait timed out after ${settled.elapsed ?? budgetMs}ms (${settled.blockedBy}). next command may see mid-animation state. use \`peach do settle\` for a longer wait.\n`,
           )
         }
-      } catch {}
+      } catch (error) {
+        if (error instanceof IdleObservationError) {
+          process.stderr.write(
+            `  ⚠ ${error.message}. next command may see mid-animation state. use \`peach do settle\` to retry.\n`,
+          )
+        }
+      }
     }
 
     if (wantsJson) {

package/cli/commands/electron.ts

@@ -90,7 +90,10 @@ examples:
   if (!install) {
     printMissingCompanionHint(native)
     const canPrompt =
-      process.stdin.isTTY && process.env.CI !== '1' && process.env.PEACH_NO_PROMPT !== '1'
+      process.platform !== 'darwin' &&
+      process.stdin.isTTY &&
+      process.env.CI !== '1' &&
+      process.env.PEACH_NO_PROMPT !== '1'
     if (canPrompt && (await confirm('run peach desktop install now?', true))) {
       console.log()
       const { runInstallDesktop } = await import('./install-desktop')

package/cli/commands/inspect/core.ts

@@ -2236,7 +2236,7 @@ export function formatTimelinePayload(
     case 'notification':
       return `${d.title ?? ''}${d.body ? ` — ${d.body}` : ''}`
     case 'fetch':
-      return `${d.method ?? 'GET'} ${d.url ?? ''}${d.status ? ` -> ${d.status}` : ''}`
+      return `${d.method ?? 'GET'} ${d.url ?? ''}${d.status ? ` -> ${d.status}` : ''}${d.error ? ` -> ${d.error}` : ''}`
     case 'console':
     case 'console-log':
       return `${d.level ?? 'log'}: ${(d.message ?? '').toString().slice(0, 120)}`

package/cli/commands/inspect/settle.ts

@@ -1,4 +1,5 @@
-import { waitForSootsimIdle } from './settling'
+import { rnxExit } from '../../run-rnx'
+import { IdleObservationError, waitForSootsimIdle } from './settling'
 import type { WsBridge } from '../../ws-bridge'
 
 // default: worker stillness plus mounted-root membership; budgets of a
@@ -24,11 +25,22 @@ export async function runSettleSubcommand(opts: {
     return
   }
   const strict = args.includes('--strict')
-  const { elapsed, settled } = await waitForSootsimIdle({ bridge, maxMs, strict })
-
-  if (settled) {
-    console.log(`  settled in ${elapsed}ms`)
-  } else {
-    console.log(`  timed out after ${elapsed}ms (may still be animating)`)
+  try {
+    const { elapsed, settled, blockedBy } = await waitForSootsimIdle({
+      bridge,
+      maxMs,
+      strict,
+    })
+    if (settled) {
+      console.log(`  settled in ${elapsed}ms`)
+    } else {
+      console.log(`  timed out after ${elapsed}ms (${blockedBy})`)
+    }
+  } catch (error) {
+    if (error instanceof IdleObservationError) {
+      console.error(`  ⚠ ${error.message}`)
+      rnxExit(1)
+    }
+    throw error
   }
 }