peachsim 0.1.1620 → 0.1.1625

package/cli/cloud-client.ts

@@ -46,8 +46,8 @@ import {
   RNX_METRO_MODULE_IDENTITY_VERSION,
   type RNXMetroModuleIdentityMetadata,
 } from '../src/metro-production-bundle.ts'
+import { readPackageVersionsFooter } from '../src/packageVersionsContract'
 import { rnxPublicBrand } from '../src/public-brand.ts'
-import { PEACH_SIMULATOR_PATH } from '../src/simulator-route'
 import { CHOOSE_ACCOUNT_HINT, resolveCliAuth } from './auth.ts'
 import {
   createCloudSession,
@@ -274,6 +274,26 @@ async function loadBundleSource(bundleInput: string, command: string): Promise<s
   return source
 }
 
+// a metro bundle carries react native's Platform module for exactly the
+// platform it was built for, and that module's OS constant survives
+// minification. a bundle naming only the other platform would boot against
+// native modules it was never built for, so it refuses before a host exists.
+export function assertBundleBuiltFor(
+  bytes: Buffer,
+  platform: RemotePlatform,
+  command: string,
+): void {
+  const source = bytes.toString('latin1')
+  const ios = /\bOS:\s*["']ios["']/.test(source)
+  const android = /\bOS:\s*["']android["']/.test(source)
+  if (ios === android) return
+  const built = ios ? 'ios' : 'android'
+  if (built === platform) return
+  throw new Error(
+    `${command} needs a bundle built for ${platform}; this one was built for ${built}. Rebuild with \`react-native bundle --platform ${platform}\` or run \`peach ${built} --remote\`.`,
+  )
+}
+
 // `react-native bundle --assets-dest` dest paths are not always the JS
 // descriptor's httpServerLocation with `../` replaced by `_`. Metro 0.83 does
 // that (`__node_modules`); Metro 0.84 often dests `node_modules` and keeps the
@@ -746,6 +766,11 @@ export async function produceCloudBoxArtifact(
     assetsDirectory ? 'require-assets' : 'allow-placeholders',
     assetsDirectory,
   )
+  if (!readPackageVersionsFooter(prepared.source)?.['react-native']) {
+    throw new Error(
+      'remote simulator bundle is missing __peachPackageVersions with the installed react-native version. Wrap your project Metro config with withPeach from peachsim/metro, then rebuild the bundle before running peach ios --remote or peach android --remote.',
+    )
+  }
   const warnings: string[] = []
   if (prepared.search.unconfirmed && prepared.dest) {
     warnings.push(
@@ -1662,39 +1687,54 @@ export class BoxBootFailedError extends Error {
   }
 }
 
-export interface BoxDisplayGrant {
-  url: string
-  authToken: string
-  expectedPeer: unknown
-}
-
 // how long `peach remote` waits for a fresh box's page to attach its simulator
 // before giving up on the watch url. the page boots the bundle after the
 // browser is up, and a large bundle takes a while to parse.
 const BOX_DISPLAY_GRANT_WAIT_MS = 180_000
 const BOX_DISPLAY_GRANT_RETRY_MS = 2_000
 
-function readBoxDisplayGrant(value: unknown): BoxDisplayGrant {
-  if (!isRecord(value) || !isRecord(value.grant)) {
-    throw new Error('box display-grant returned an invalid grant')
-  }
-  const grant = value.grant
-  if (
-    typeof grant.url !== 'string' ||
-    !grant.url ||
-    typeof grant.authToken !== 'string' ||
-    !grant.authToken ||
-    !isRecord(grant.expectedPeer)
-  ) {
-    throw new Error('box display-grant returned an invalid grant')
+// waits for a fresh box's page to load its app or report that the app threw
+// while booting, reading the same runtime receipts the page records. a boot
+// error throws; a slow boot that reports neither within the wait is not an
+// error, so the caller still gets its watch url.
+export async function awaitBoxBoot(options: {
+  apiOrigin: string
+  boxId: string
+  boxToken: string
+}): Promise<void> {
+  const started = Date.now()
+  while (Date.now() - started < BOX_DISPLAY_GRANT_WAIT_MS) {
+    const response = await fetch(
+      `${options.apiOrigin}/v1/boxes/${encodeURIComponent(options.boxId)}/lifecycle`,
+      { headers: { authorization: `Bearer ${options.boxToken}` } },
+    )
+    const text = await response.text()
+    if (!response.ok) throw responseError(response.status, text)
+    const status: unknown = JSON.parse(text)
+    const generation =
+      isRecord(status) && isRecord(status.browser)
+        ? status.browser.browserGeneration
+        : null
+    const receipts =
+      isRecord(status) && Array.isArray(status.runtimeReceipts)
+        ? status.runtimeReceipts
+        : []
+    for (const receipt of receipts.toReversed()) {
+      if (!isRecord(receipt) || receipt.browserGeneration !== generation) continue
+      if (receipt.kind === 'boot-failed' && typeof receipt.error === 'string') {
+        throw new BoxBootFailedError(options.boxId, receipt.error)
+      }
+      if (receipt.kind === 'loaded' || receipt.kind === 'painted') return
+    }
+    await new Promise((resolve) => setTimeout(resolve, BOX_DISPLAY_GRANT_RETRY_MS))
   }
-  return { url: grant.url, authToken: grant.authToken, expectedPeer: grant.expectedPeer }
 }
 
-// mints a watch-only display grant from the box and builds the bare shell
-// watch url for it: the same /simulator#remoteEngine fragment the nano service
-// mints, pointed at the box's display socket instead. the box token stays in
-// this process; only the grant travels in the fragment.
+// mints a watch-only display grant from the box and returns the watch url the
+// box service built for it. the service puts it on the deploy that serves the
+// box page, so the viewer runs the same engine build, and display wire, as the
+// page hosting the simulator. the box token stays in this process; only the
+// grant travels, in the url's fragment.
 export async function requestBoxWatchUrl(options: {
   apiOrigin: string
   boxId: string
@@ -1722,17 +1762,6 @@ export async function requestBoxWatchUrl(options: {
         }`,
       )
     }
-    if (response.status === 422) {
-      const text = await response.text()
-      let failure: unknown = null
-      try {
-        failure = JSON.parse(text)
-      } catch {}
-      if (isRecord(failure) && failure.code === 'boot-failed') {
-        throw new BoxBootFailedError(options.boxId, String(failure.error))
-      }
-      throw responseError(response.status, text)
-    }
     if (response.status === 409) {
       // the page has not attached its simulator yet. this is the normal state
       // right after a create, so wait rather than refusing.
@@ -1752,27 +1781,9 @@ export async function requestBoxWatchUrl(options: {
     } catch {
       throw new Error('box display-grant returned unreadable JSON')
     }
-    const grant = readBoxDisplayGrant(parsed)
-    const watch = new URL(PEACH_SIMULATOR_PATH, rnxPublicBrand.origin)
-    // the shell boots its stage at its own default device, while the box page
-    // hosts its simulator at the grant's device profile. without ?device= the
-    // tenant refuses the host hello on dimensions and paints nothing — the
-    // same param SimPage and BoxHostPage already set on their stage urls.
-    if (
-      isRecord(grant.expectedPeer) &&
-      typeof grant.expectedPeer.deviceProfile === 'string' &&
-      grant.expectedPeer.deviceProfile
-    ) {
-      watch.searchParams.set('device', grant.expectedPeer.deviceProfile)
-    }
-    watch.hash = `remoteEngine=${encodeURIComponent(
-      JSON.stringify({
-        url: grant.url,
-        authToken: grant.authToken,
-        expectedPeer: grant.expectedPeer,
-      }),
-    )}`
-    return watch.toString()
+    if (!isRecord(parsed) || typeof parsed.watchUrl !== 'string' || !parsed.watchUrl)
+      throw new Error('box display-grant returned no watch url')
+    return parsed.watchUrl
   }
 }
 

package/cli/commands/box/search-command.ts

@@ -34,6 +34,7 @@
 import { spawn } from 'node:child_process'
 import { defineCommand, type CustomCommand } from '@peach/box/shell'
 import { PROJECT_MOUNT } from '@peach/box/shell'
+import { terminateProcessGroup } from '../../../src/process-group'
 
 // generous next to a 414ms p95: this bounds a wedged child, it does not cut off
 // a large search.
@@ -63,9 +64,9 @@ function runGitGrep(args: string[], cwd: string) {
       clearTimeout(timer)
       resolve({ stdout, stderr, exitCode })
     }
-    const timer = setTimeout(() => {
+    const timer = setTimeout(async () => {
       try {
-        child.kill('SIGKILL')
+        await terminateProcessGroup(child, 'SIGKILL')
       } catch {}
       stderr += `rg: search timed out after ${SEARCH_DEADLINE_MS}ms\n`
       finish(2)

package/cli/commands/box.ts

@@ -52,9 +52,6 @@ interface BoxCommandOptions {
   verbose?: boolean
 }
 
-// no default. a cloud box service has to be deployed before one can exist, and
-// defaulting to an origin that answers nothing would advertise a capability
-// that always fails.
 const ENDPOINT_ENV = 'PEACH_BOX_ENDPOINT'
 const API_ORIGIN_ENV = 'PEACH_API_ORIGIN'
 const BOX_TEMPLATES = new BoxTemplateRegistry([
@@ -212,23 +209,16 @@ async function runCloudBoxUse(args: string[]): Promise<number> {
   }
 }
 
-function requireEndpoint(args: string[], label: string): string | null {
-  return cloudBoxEndpoint(args, `box ${label}`)
-}
-
 /**
- * the cloud box service this command talks to, or null with the reason
- * printed. exported because `peach box send` creates a box too, and a second
- * spelling of where boxes live is a second place to configure.
+ * the cloud box service for every CLI command that selects a service. existing
+ * box references carry their own endpoint from the account service.
  */
-export function cloudBoxEndpoint(args: string[], command: string): string | null {
-  const endpoint = flag(args, 'endpoint') ?? process.env[ENDPOINT_ENV]?.trim()
-  if (endpoint) return endpoint
-  console.error(
-    `  ${rnxPublicBrand.commandName} ${command}: no cloud box service to talk to.\n` +
-      `  set ${ENDPOINT_ENV} or pass --endpoint=<url>.`,
+export function cloudBoxEndpoint(args: string[]): string {
+  return (
+    flag(args, 'endpoint')?.trim() ||
+    process.env[ENDPOINT_ENV]?.trim() ||
+    rnxPublicBrand.boxOrigin
   )
-  return null
 }
 
 /** the api origin a cloud box bills against. */
@@ -278,8 +268,7 @@ async function runBoxSend(args: string[], opts: BoxCommandOptions): Promise<numb
 async function runCloudBoxStop(args: string[], purge: boolean): Promise<number> {
   const peach = rnxPublicBrand.commandName
   const label = purge ? 'delete' : 'stop'
-  const endpoint = requireEndpoint(args, label)
-  if (!endpoint) return 1
+  const endpoint = cloudBoxEndpoint(args)
   const name = boxTarget(args, label)
   if (!name) return 1
   const { auth, header } = authHeaderOrExit(`box ${label}`)
@@ -321,7 +310,7 @@ async function runCloudBoxList(args: string[]): Promise<number> {
   const accountId = cloudAccountIdOrExit(auth)
   const client = createBoxClient(
     createCloudBoxProvider({
-      endpoint: flag(args, 'endpoint') ?? process.env[ENDPOINT_ENV]?.trim() ?? '',
+      endpoint: cloudBoxEndpoint(args),
       authority: { kind: 'account', apiOrigin: apiOrigin(args, auth), apiKey, accountId },
     }),
   )
@@ -589,15 +578,7 @@ async function runCloudBoxCreate(
 ): Promise<number> {
   const peach = rnxPublicBrand.commandName
   const json = args.includes('--json')
-  const endpoint = flag(args, 'endpoint') ?? process.env[ENDPOINT_ENV]?.trim()
-  if (!endpoint) {
-    console.error(
-      `  ${peach} box create: no cloud box service to create a box in.\n` +
-        `  set ${ENDPOINT_ENV} or pass --endpoint=<url>. \`${peach} box\` runs the\n` +
-        `  same shell locally over this checkout.`,
-    )
-    return 1
-  }
+  const endpoint = cloudBoxEndpoint(args)
 
   // --bundle IS the template choice: the box runs an app that is already
   // built, so naming a second template would ask for two different boxes.

package/cli/commands/control.ts

@@ -45,8 +45,14 @@ import {
   runtimesDir,
 } from '../../src/home-paths'
 import { projectLoopbackUrl } from '../../src/host/loopback-ports'
-import { stageHostFile } from '../../src/host/staged-host-files'
+import {
+  isStagedHostFileRequest,
+  stageHostBytes,
+  stageHostFile,
+  stageHostLaunchMetadata,
+} from '../../src/host/staged-host-files'
 import { readInstalledNativePackageVersions } from '../../src/installed-package-versions'
+import { LAUNCH_METADATA_QUERY_PARAM } from '../../src/launchMetadataContract'
 import { detectBundleModeFromText } from '../../src/metro-production-bundle'
 import {
   canExtractNativeAppIdentity,
@@ -275,12 +281,15 @@ async function connectBridgeForOpen(
   const lock = readDaemonLockfile()
   assertExplicitBridgeLock(preferredPort, explicitPort, lock)
   const preferredWorld = worldForBridgePort(preferredPort)
-  const handshake = await bridgeHandshake(preferredPort, LIVE_BRIDGE_HANDSHAKE_TIMEOUT_MS)
+  const handshakeTimeoutMs = LIVE_BRIDGE_HANDSHAKE_TIMEOUT_MS * flowTimeoutScale()
+  const handshake = await bridgeHandshake(preferredPort, handshakeTimeoutMs)
   if ((explicitPort || preferredWorld !== null) && handshake === 'open') {
     return preferredPort
   }
   if (explicitPort && preferredWorld !== null) {
-    throw new Error(unreachableBridgeMessage(preferredPort, handshake))
+    throw new Error(
+      unreachableBridgeMessage(preferredPort, handshake, handshakeTimeoutMs),
+    )
   }
   if (
     !explicitPort &&
@@ -288,7 +297,7 @@ async function connectBridgeForOpen(
     isDaemonLockfileFresh(lock) &&
     (lock.bridgePort === preferredPort
       ? handshake === 'open'
-      : await canConnectToBridge(lock.bridgePort, LIVE_BRIDGE_HANDSHAKE_TIMEOUT_MS))
+      : await canConnectToBridge(lock.bridgePort, handshakeTimeoutMs))
   ) {
     return lock.bridgePort
   }
@@ -452,12 +461,16 @@ function bridgeHandshake(port: number, timeoutMs: number): Promise<BridgeHandsha
   })
 }
 
-function unreachableBridgeMessage(port: number, handshake: BridgeHandshake): string {
+function unreachableBridgeMessage(
+  port: number,
+  handshake: BridgeHandshake,
+  timeoutMs: number,
+): string {
   if (handshake === 'timeout') {
     const cores = Math.max(1, os.cpus().length)
     const load = os.loadavg()[0]
     if (load >= cores) {
-      return `peach open: requested bridge port ${port} did not finish its handshake within 2s while load average was ${load.toFixed(1)} on ${cores} cores.`
+      return `peach open: requested bridge port ${port} did not finish its handshake within ${timeoutMs / 1000}s while load average was ${load.toFixed(1)} on ${cores} cores.`
     }
   }
   return `peach open: requested bridge port ${port} is not reachable.`
@@ -585,11 +598,12 @@ async function resolveConnectionInputForCli(target: string): Promise<ResolvedDev
   const releaseListenerScan = pinSharedListenerScan()
   try {
     for (let attempt = 0; attempt < DEV_BUNDLE_RESOLVE_ATTEMPTS; attempt++) {
+      let resolutionTarget = normalized
       if (registeredPort && registeredPort > 0) {
         const discovered = await probePort(registeredPort)
         // a provisional bundle URL is enough to LIST the server but not to open
-        // it; fall through to resolveConnectionInput, which asks the manifest
-        // again with a budget that fits a real dev server.
+        // it; resolveConnectionInput joins the scanner's pending manifest with
+        // the full startup budget instead of starting the same work again.
         if (discovered && !discovered.bundleUrlProvisional) {
           return {
             bundleUrl: projectLoopbackUrl(discovered.bundleUrl),
@@ -598,10 +612,15 @@ async function resolveConnectionInputForCli(target: string): Promise<ResolvedDev
             projectName: discovered.projectName,
           }
         }
+        // keep the scanner's answering address and join its manifest request.
+        // probing both loopback families again duplicates cold config work.
+        if (discovered?.bundleUrlProvisional && /^\d+$/.test(normalized)) {
+          resolutionTarget = new URL(discovered.bundleUrl).origin
+        }
       }
 
       try {
-        const resolved = await resolveConnectionInput(normalized)
+        const resolved = await resolveConnectionInput(resolutionTarget)
         return { ...resolved, bundleUrl: projectLoopbackUrl(resolved.bundleUrl) }
       } catch (error) {
         if (
@@ -850,7 +869,7 @@ export function resolveShellBaseUrlForBridgePort(bridgePort: number): string {
   )
 }
 
-// stamp the engine page url with `?appFonts=<url[::family]>,...` so the
+// stamp a bounded catalog reference on the engine page url so the
 // engine's app-font-loader registers native config-only fonts at boot. fonts
 // loaded by JS already flow through normal runtime fetch capture; this covers
 // UIAppFonts-style assets that Metro can serve but the guest bundle never
@@ -874,7 +893,11 @@ function stampAppFonts(
       nativeAssetOrigin,
     })
     if (specs.length === 0) return urlStr
-    url.searchParams.set('appFonts', encodeAppFontsWire(specs))
+    const catalogUrl = stageHostBytes(
+      new TextEncoder().encode(encodeAppFontsWire(specs)),
+      nativeAssetOrigin,
+    )
+    url.searchParams.set('appFonts', `@${catalogUrl}`)
     return url.toString()
   } catch {
     return urlStr
@@ -1059,45 +1082,74 @@ export interface BuildShellUrlOptions {
   bridgePort?: number
 }
 
-function readProjectNativeFirebaseConfig(
+type ProjectExpoConfigRead = { config: Record<string, unknown> } | { error: string }
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function readProjectExpoConfig(
   project: ResolvedAppProject,
-): Promise<Record<string, unknown> | null> {
+): Promise<ProjectExpoConfigRead | null> {
   const require = createRequire(path.join(project.appDir, 'package.json'))
   try {
     require.resolve('@expo/config')
   } catch {
     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),
-    }))
+  return readExpoConfigAsync(project.appDir).then(
+    (config) => ({ config }),
+    (error: unknown) => ({ error: errorMessage(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),
-    )
+const startedExpoConfigReads = new Map<string, Promise<ProjectExpoConfigRead | null>>()
+
+function startExpoConfigRead(project: ResolvedAppProject | null) {
+  if (project) startedExpoConfigReads.set(project.appDir, readProjectExpoConfig(project))
 }
 
-function takeNativeFirebaseConfig(project: ResolvedAppProject | null | undefined) {
+function takeExpoConfigRead(project: ResolvedAppProject | null | undefined) {
   if (!project) return Promise.resolve(null)
-  const started = startedNativeFirebaseConfigs.get(project.appDir)
-  startedNativeFirebaseConfigs.delete(project.appDir)
-  return started ?? readProjectNativeFirebaseConfig(project)
+  const started = startedExpoConfigReads.get(project.appDir)
+  startedExpoConfigReads.delete(project.appDir)
+  return started ?? readProjectExpoConfig(project)
+}
+
+function nativeFirebaseFromExpoConfig(
+  project: ResolvedAppProject,
+  read: ProjectExpoConfigRead,
+): Record<string, unknown> {
+  if ('error' in read) return read
+  try {
+    return readNativeFirebaseConfig(project.appDir, undefined, undefined, read.config)
+  } catch (error) {
+    return { error: errorMessage(error) }
+  }
+}
+
+// a built bundle staged on the bridge has no packager to serve its manifest.
+// the built binary embeds its evaluated app config (expo's `app.config`
+// resource, and the Info.plist prebuild writes from it), so the bundle's
+// manifest is that config, staged beside it
+function stageBuiltBundleManifest(
+  bundleUrl: string,
+  config: Record<string, unknown>,
+): string | null {
+  const bundle = new URL(bundleUrl)
+  if (!isStagedHostFileRequest(bundle.pathname) || Object.keys(config).length === 0)
+    return null
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'peach-app-manifest-'))
+  try {
+    const file = path.join(directory, 'manifest.json')
+    fs.writeFileSync(file, JSON.stringify({ extra: { expoClient: config } }))
+    return stageHostFile(file, bundle.origin)
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true })
+  }
 }
 
 // a plain Metro carries no identity footer or header, so the page carries the
@@ -1200,6 +1252,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')
+  expoStamped.searchParams.delete('appManifest')
   expoStamped.searchParams.delete('packageVersions')
   if (project && expoStamped.searchParams.get('bundle')) {
     expoStamped.searchParams.set(
@@ -1207,9 +1260,19 @@ export async function buildShellUrl(
       JSON.stringify(readInstalledNativePackageVersions(project.appDir)),
     )
   }
-  const nativeFirebase = await takeNativeFirebaseConfig(project)
-  if (nativeFirebase && expoStamped.searchParams.get('bundle'))
-    expoStamped.searchParams.set('nativeFirebase', JSON.stringify(nativeFirebase))
+  const expoConfigRead = await takeExpoConfigRead(project)
+  const stampedBundle = expoStamped.searchParams.get('bundle')
+  if (project && expoConfigRead && stampedBundle) {
+    expoStamped.searchParams.set(
+      'nativeFirebase',
+      JSON.stringify(nativeFirebaseFromExpoConfig(project, expoConfigRead)),
+    )
+    const manifest =
+      'config' in expoConfigRead
+        ? stageBuiltBundleManifest(stampedBundle, expoConfigRead.config)
+        : null
+    if (manifest) expoStamped.searchParams.set('appManifest', manifest)
+  }
   if (opts.bundleOriginOverride)
     expoStamped.searchParams.set('bundleOriginOverride', opts.bundleOriginOverride)
   if (opts.hostDriver) expoStamped.searchParams.set('peachHostDriver', opts.hostDriver)
@@ -1235,7 +1298,7 @@ export async function buildShellUrl(
     !opts.env?.length &&
     !opts.dotEnv
   )
-    return expoStamped.toString()
+    return stageHostLaunchMetadata(expoStamped, `http://localhost:${port.port}`)
   const url = expoStamped
   if (opts.dotEnv) url.searchParams.set('dotEnv', JSON.stringify(opts.dotEnv))
   if (opts.device) url.searchParams.set('device', opts.device)
@@ -1246,7 +1309,7 @@ export async function buildShellUrl(
   if (opts.proof) url.searchParams.set('proof', '1')
   if (opts.ephemeral) url.searchParams.set('ephemeral', '1')
   for (const entry of opts.env ?? []) url.searchParams.append('env', entry)
-  return url.toString()
+  return stageHostLaunchMetadata(url, `http://localhost:${port.port}`)
 }
 
 function deriveCurrentSimBaseUrl(
@@ -1278,6 +1341,7 @@ function deriveCurrentSimBaseUrl(
     url.searchParams.delete('nativeFirebase')
     url.searchParams.delete('packageVersions')
     url.searchParams.delete('nativeAppIdentity')
+    url.searchParams.delete(LAUNCH_METADATA_QUERY_PARAM)
     url.searchParams.delete('expoSwift')
     url.searchParams.delete('expoKotlin')
     return url.toString()
@@ -1836,7 +1900,9 @@ export async function runOpenCommand(
     peachExit(1)
   }
 
-  if (isAppDeepLinkTarget(target)) {
+  // an absolute path to a built bundle is a file, not an app path
+  const prebuiltBundle = prebuiltBundleFile(target)
+  if (!prebuiltBundle && isAppDeepLinkTarget(target)) {
     if (openInNewSim) {
       console.error(
         '  peach open: deep links target the current app; remove --new, --profile, or --ephemeral',
@@ -1879,7 +1945,6 @@ export async function runOpenCommand(
     return
   }
 
-  const prebuiltBundle = prebuiltBundleFile(target)
   // a bundle file gets its url once the bridge that serves it is settled
   let resolvedBundle =
     !prebuiltBundle && shouldResolveBundleTargetInCli(target)
@@ -1895,7 +1960,7 @@ export async function runOpenCommand(
     resolvedBundle?.bundleUrl,
     projectRoot ?? (prebuiltBundle ? appDirAbove(prebuiltBundle) : undefined),
   )
-  startNativeFirebaseConfigRead(project)
+  startExpoConfigRead(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.