peachsim 0.1.527

package/src/dev-bundle-resolution.ts

@@ -0,0 +1,346 @@
+import {
+  buildLoopbackProbeBaseUrl,
+  isLoopbackHost,
+  LOOPBACK_PROBE_HOSTNAMES,
+} from './backend-origin'
+import {
+  alignLoopbackBundleUrlWithProbe,
+  METRO_BUNDLE_PATH,
+  normalizeNativeDevBundleUrl,
+} from './native-dev-bundle-url'
+
+export const DEFAULT_TEST_DRIVE_PORT = 8081
+
+export interface ResolvedDevBundle {
+  bundleUrl: string
+  port: number
+  framework: string
+  projectName?: string
+}
+
+function buildUnresolvedTargetError(targetLabel: string): Error {
+  return new Error(
+    `could not resolve a native bundle for ${targetLabel}. pass an explicit bundle URL or open Connect and choose the app there.`,
+  )
+}
+
+export function inferManifestFramework(
+  launchUrl: string | undefined,
+  sdkVersion: unknown,
+): string {
+  if (launchUrl?.includes('/one/metro-entry.bundle')) return 'one'
+  if (typeof sdkVersion === 'string' && sdkVersion) return 'expo'
+  return 'unknown'
+}
+
+function buildBaseUrl(protocol: string, host: string, port: number) {
+  return `${protocol}//${host}:${port}`
+}
+
+function shouldProxyLoopbackProbe(targetUrl: string) {
+  if (typeof window === 'undefined') return false
+  try {
+    const parsed = new URL(targetUrl)
+    return (
+      isLoopbackHost(parsed.hostname) &&
+      isLoopbackHost(window.location.hostname) &&
+      parsed.origin !== window.location.origin
+    )
+  } catch {
+    return false
+  }
+}
+
+async function fetchDevProbe(targetUrl: string, init?: RequestInit): Promise<Response> {
+  const requestInit: RequestInit = {
+    ...init,
+    cache: init?.cache ?? 'no-store',
+  }
+  if (!shouldProxyLoopbackProbe(targetUrl)) {
+    return fetch(targetUrl, requestInit)
+  }
+  return fetch(`/__fetch-proxy?url=${encodeURIComponent(targetUrl)}`, requestInit)
+}
+
+function getDefaultPortForProtocol(protocol: string) {
+  return protocol === 'https:' ? 443 : 80
+}
+
+function isBaseServerUrl(url: URL) {
+  const path = url.pathname || '/'
+  return (path === '/' || path === '') && !url.search && !url.hash
+}
+
+// resolve a loopback dev-server port through the SAME server-side scanner the
+// dev-server list uses (`/__server-scan`), so an explicit port (`/rn/<port>`, a
+// typed port) gets the same manifest path and query the list resolves. loopback
+// hosts stay aligned to the address that answered discovery.
+//
+// why this exists: in a browser/worker the direct manifest probe below is
+// cross-origin (shell on :5173, dev server on :<port>), and a dev server
+// answers a cross-origin `GET /` with its SSR HTML, not the expo manifest. so
+// the manifest branch silently fails (`.json()` throws on HTML) and the probe
+// falls back to a generic `/index.bundle` — a DIFFERENT metro entry point than
+// the manifest's `metro-entry.bundle`, which makes metro build the same app
+// twice. the scanner runs server-side (same-origin node fetch, sends the
+// expo-platform header) and reads `launchAsset.url` correctly.
+//
+// env-agnostic by design: it just attempts `/__server-scan` and lets the result
+// decide. in the tenant worker (which has no `location`) the patched fetch
+// resolves the relative path to the shell origin and returns the scan json. in a
+// node/bun CLI a relative-URL fetch with no base throws → null → the direct probe
+// runs (correct there, since node can read the cross-origin manifest). in prod
+// the path SPA-falls-back to HTML → the json content-type guard returns null →
+// direct probe. so there is exactly one resolver per environment, no env sniff.
+async function resolvePortViaServerScan(port: number): Promise<ResolvedDevBundle | null> {
+  try {
+    const res = await fetch('/__server-scan', { cache: 'no-store' })
+    if (!res.ok) return null
+    if (!(res.headers.get('content-type') || '').toLowerCase().includes('json'))
+      return null
+    const servers: unknown = await res.json()
+    if (!Array.isArray(servers)) return null
+    const match = servers.find(
+      (
+        s,
+      ): s is {
+        port: number
+        bundleUrl: string
+        framework?: string
+        projectName?: string
+        bundleUrlProvisional?: boolean
+      } =>
+        !!s &&
+        typeof s === 'object' &&
+        (s as { port?: unknown }).port === port &&
+        typeof (s as { bundleUrl?: unknown }).bundleUrl === 'string',
+    )
+    if (!match) return null
+    // the scanner marks a bundle URL provisional when its own fast manifest
+    // probe got no answer and it fell back to the generic `/index.bundle`. that
+    // is enough to LIST the server and not enough to open it, so fall through
+    // to the direct probe below, which asks the manifest again with a budget
+    // that fits a real dev server. same rule the CLI applies in
+    // `resolveConnectionInputForCli`; a provisional URL must never reach a sim.
+    if (match.bundleUrlProvisional) return null
+    return {
+      // normalize exactly like the manifest-probe branch below — the scan
+      // returns metro's manifest launchAsset url (lazy=true for code-split
+      // one/vxrn apps), but sootsim loads ONE self-contained bundle into the tenant
+      // worker, so a deferred React.lazy chunk throws "Requiring unknown module
+      // <id>". normalizeNativeDevBundleUrl forces lazy=false + strips bytecode.
+      bundleUrl: normalizeNativeDevBundleUrl(match.bundleUrl),
+      port,
+      framework: typeof match.framework === 'string' ? match.framework : 'unknown',
+      projectName: typeof match.projectName === 'string' ? match.projectName : undefined,
+    }
+  } catch {
+    return null
+  }
+}
+
+// how a dev server answered `GET /`, which is the one request that tells the
+// two kinds of dev server apart. an Expo or One server answers with its
+// manifest. a vanilla Metro server answers with Metro's own HTML landing page
+// and has no manifest to serve. NO answer is neither: a One server that is
+// still starting leaves `/` hanging until its manifest middleware is up, while
+// `/status` already reports packager-status:running. reading that silence as
+// "this server has no manifest" opens the app on `<base>/index.bundle` — a
+// second entry point, with its own module graph, that the app's manifest never
+// named — so Metro builds the whole app twice and the connection is labelled
+// `metro` instead of its real framework.
+type ManifestProbe =
+  | { state: 'resolved'; bundle: ResolvedDevBundle }
+  | { state: 'no-manifest' }
+  | { state: 'no-answer' }
+
+// a `/` that has not answered in this long is a server still coming up, not a
+// server telling us what it is. without it an unresponsive dev server hangs
+// the caller for as long as it feels like.
+const MANIFEST_PROBE_TIMEOUT_MS = 5_000
+// how long to keep asking a confirmed-running packager for its manifest.
+const MANIFEST_BOOT_BUDGET_MS = 30_000
+const MANIFEST_BOOT_RETRY_MS = 1_000
+
+async function probeExpoManifest(
+  normalizedBaseUrl: string,
+  port: number,
+): Promise<ManifestProbe> {
+  let body: string
+  // the deadline means STOP WAITING, not KILL THE REQUEST. `AbortSignal.timeout`
+  // does the second: it tears down a dev server that is still assembling its
+  // manifest, which fires "Cannot pipe to a closed or destroyed stream" into
+  // One's manifest middleware and can exit the user's dev server. so nothing
+  // here aborts. we race the probe against the budget, answer `no-answer` on
+  // time, and let the request run itself out in the background, discarded.
+  const pending = fetchDevProbe(`${normalizedBaseUrl}/`, {
+    headers: { 'expo-platform': 'ios' },
+  }).then(
+    async (res) => (res.ok ? { ok: true as const, body: await res.text() } : null),
+    () => undefined,
+  )
+  let probeDeadline: ReturnType<typeof setTimeout> | undefined
+  const answered = await Promise.race([
+    pending,
+    new Promise<'timeout'>((resolve) => {
+      probeDeadline = setTimeout(() => resolve('timeout'), MANIFEST_PROBE_TIMEOUT_MS)
+    }),
+  ])
+  // the race is settled, so drop the deadline rather than leaving it pending.
+  clearTimeout(probeDeadline)
+  if (answered === 'timeout' || answered === undefined) return { state: 'no-answer' }
+  if (answered === null) return { state: 'no-manifest' }
+  body = answered.body
+  if (!body.trim()) return { state: 'no-answer' }
+
+  let manifest: any
+  try {
+    manifest = JSON.parse(body)
+  } catch {
+    // a page rather than a manifest — Metro's landing page, or an app's own
+    // SSR html. that is a real answer: this server serves no manifest.
+    return { state: 'no-manifest' }
+  }
+
+  const client = manifest?.extra?.expoClient || manifest?.extra || {}
+  const rawLaunchUrl =
+    typeof manifest?.launchAsset?.url === 'string' ? manifest.launchAsset.url : undefined
+  const launchUrl = rawLaunchUrl
+    ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, normalizedBaseUrl)
+    : undefined
+  if (!launchUrl && !client.name) return { state: 'no-manifest' }
+
+  return {
+    state: 'resolved',
+    bundle: {
+      bundleUrl: normalizeNativeDevBundleUrl(
+        launchUrl || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+      ),
+      port,
+      framework: inferManifestFramework(launchUrl, client.sdkVersion),
+      projectName: client.name,
+    },
+  }
+}
+
+async function isPackagerRunning(normalizedBaseUrl: string): Promise<boolean> {
+  try {
+    const res = await fetchDevProbe(`${normalizedBaseUrl}/status`)
+    if (!res.ok) return false
+    return (await res.text()).includes('packager-status:running')
+  } catch {
+    return false
+  }
+}
+
+async function probeBaseUrlBundleDirect(
+  baseUrl: string,
+  port: number,
+): Promise<ResolvedDevBundle | null> {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, '')
+
+  let manifest = await probeExpoManifest(normalizedBaseUrl, port)
+  let packagerConfirmed = false
+
+  // nothing answered `/`. that is either a closed address — the other loopback
+  // family, a dead port — or a packager whose manifest middleware has not come
+  // up yet. `/status` separates them, and only the second is worth waiting on.
+  if (manifest.state === 'no-answer') {
+    packagerConfirmed = await isPackagerRunning(normalizedBaseUrl)
+    if (!packagerConfirmed) return null
+    const deadline = Date.now() + MANIFEST_BOOT_BUDGET_MS
+    while (manifest.state === 'no-answer' && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, MANIFEST_BOOT_RETRY_MS))
+      manifest = await probeExpoManifest(normalizedBaseUrl, port)
+    }
+  }
+
+  if (manifest.state === 'resolved') return manifest.bundle
+  // a server that never says what it is gets no guessed entry point.
+  if (manifest.state === 'no-answer') return null
+
+  // vanilla Metro (or any non-Expo dev server) — packager-status:running on
+  // /status is the canonical signature. we previously also did `HEAD
+  // /node_modules/one/metro-entry.bundle` as a framework discriminator, but
+  // Metro lazy-resolves modules at request time, so HEAD on *any* `.bundle`
+  // path can return 200 even when the underlying file doesn't exist. that
+  // caused false-positive One framework detection on non-One apps that had
+  // `node_modules/one` anywhere on disk (or that returned 200 HEAD + 404
+  // GET for missing bundles), surfacing as
+  //   "failed to fetch bundle (404|502): .../node_modules/one/metro-entry.bundle…"
+  // the Expo manifest probe above already returns the correct launchAsset.url
+  // for One apps (which serve the Expo manifest format via vxrn), so we
+  // drop the bespoke One probe entirely.
+  if (!packagerConfirmed && !(await isPackagerRunning(normalizedBaseUrl))) return null
+  return {
+    bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+    port,
+    framework: 'metro',
+  }
+}
+
+async function probeBaseUrlBundle(
+  baseUrl: string,
+  port: number,
+): Promise<ResolvedDevBundle | null> {
+  // browser/worker loopback targets resolve through the server-side scanner so
+  // they match the dev-server list exactly — see resolvePortViaServerScan.
+  try {
+    if (isLoopbackHost(new URL(baseUrl).hostname)) {
+      const viaScan = await resolvePortViaServerScan(port)
+      if (viaScan) return viaScan
+    }
+  } catch {}
+  return probeBaseUrlBundleDirect(baseUrl, port)
+}
+
+export async function probePortBundle(port: number): Promise<ResolvedDevBundle | null> {
+  const viaScan = await resolvePortViaServerScan(port)
+  if (viaScan) return viaScan
+  const candidates = await Promise.all(
+    LOOPBACK_PROBE_HOSTNAMES.map((hostname) =>
+      probeBaseUrlBundleDirect(buildLoopbackProbeBaseUrl('http:', hostname, port), port),
+    ),
+  )
+  return candidates.find((candidate) => candidate !== null) ?? null
+}
+
+export async function resolveConnectionInput(input: string): Promise<ResolvedDevBundle> {
+  const trimmed = input.trim()
+
+  if (/^\d+$/.test(trimmed)) {
+    const port = parseInt(trimmed, 10)
+    const resolved = await probePortBundle(port)
+    if (resolved) return resolved
+    throw buildUnresolvedTargetError(`localhost:${port}`)
+  }
+
+  const bundleUrl = trimmed.startsWith('http') ? trimmed : `http://${trimmed}`
+  let parsed: URL
+
+  try {
+    parsed = new URL(bundleUrl)
+  } catch {
+    throw new Error(
+      `could not parse "${input}". pass a dev-server port, a dev-server base URL, or a full bundle URL.`,
+    )
+  }
+
+  const protocol = parsed.protocol || 'http:'
+  const port = parsed.port
+    ? parseInt(parsed.port, 10)
+    : getDefaultPortForProtocol(protocol)
+  const baseUrl = buildBaseUrl(protocol, parsed.hostname, port)
+
+  // a bare base URL (just an origin, no path) is unambiguously a dev server
+  // to probe — regardless of host. probe its live manifest rather than
+  // guessing that the origin itself is the bundle URL. loopback vs. remote
+  // only affects how the probe fetch is routed (see shouldProxyLoopbackProbe).
+  if (isBaseServerUrl(parsed)) {
+    const resolved = await probeBaseUrlBundle(baseUrl, port)
+    if (resolved) return resolved
+    throw buildUnresolvedTargetError(baseUrl)
+  }
+
+  return { bundleUrl: parsed.toString(), port, framework: 'unknown' }
+}

package/src/dev-server-open.ts

@@ -0,0 +1,198 @@
+import { spawn, type ChildProcess } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export type RnxDesktopOpenOption = boolean | { appName: string }
+
+const scheduledMetroOpens = new Set<string>()
+
+export function resolveRnxDesktopAppName(
+  open: RnxDesktopOpenOption | undefined,
+  projectRoot: string,
+): string | null {
+  if (!open) return null
+  if (typeof open === 'object') {
+    const appName = open.appName.trim()
+    if (!appName) throw new Error('rnx: open.appName must not be empty')
+    return appName
+  }
+
+  const packageJsonPath = path.join(projectRoot, 'package.json')
+  const packageJson: unknown = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+  const packageName =
+    packageJson && typeof packageJson === 'object'
+      ? Reflect.get(packageJson, 'name')
+      : undefined
+  if (typeof packageName !== 'string' || !packageName.trim()) {
+    throw new Error(`rnx: ${packageJsonPath} must declare a package name`)
+  }
+  return packageName.trim()
+}
+
+export function tagRnxBundleForPlugin(
+  bundleUrl: string,
+  replacementOrigin: string,
+  replacementToken: string,
+  projectRoot: string,
+  appName?: string | null,
+): string {
+  const absolute = /^[a-z][a-z\d+.-]*:\/\//i.test(bundleUrl)
+  const url = new URL(bundleUrl, absolute ? undefined : 'http://rnx.local')
+  if (appName) {
+    url.searchParams.set('rnxAppName', appName)
+    url.searchParams.set(
+      'rnxProjectId',
+      createHash('sha256')
+        .update(fs.realpathSync(projectRoot))
+        .digest('hex')
+        .slice(0, 32),
+    )
+  }
+  url.searchParams.set('rnxReplacementOrigin', replacementOrigin)
+  url.searchParams.set('rnxReplacementToken', replacementToken)
+  return absolute ? url.toString() : `${url.pathname}${url.search}${url.hash}`
+}
+
+export function resolveRnxDesktopLaunchTarget(port: number, bundleUrl: string): string {
+  return new URL(bundleUrl, `http://localhost:${port}`).toString()
+}
+
+export function buildRnxDesktopOpenArgs(bundleUrl: string): string[] {
+  return ['open', bundleUrl, '--new', '--driver', 'electron', '--no-describe']
+}
+
+export function observeRnxDesktopLaunch(child: ChildProcess, appName: string): void {
+  let stderr = ''
+  let spawnFailed = false
+  child.stderr?.setEncoding('utf8')
+  child.stderr?.on('data', (chunk: string) => {
+    stderr = `${stderr}${chunk}`.slice(-16_384)
+  })
+  child.once('error', (error) => {
+    spawnFailed = true
+    console.error(`[rnx] could not open ${appName}: ${error.message}`)
+  })
+  child.once('close', (code, signal) => {
+    if (spawnFailed) return
+    if (code === 0) {
+      console.log(`[rnx] opened ${appName} in the desktop simulator`)
+      return
+    }
+    const detail = stderr.trim() || (signal ? `signal ${signal}` : `exit ${code}`)
+    console.error(`[rnx] could not open ${appName}: ${detail}`)
+  })
+}
+
+export function launchRnxDesktop(bundleUrl: string, appName: string): void {
+  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+  const binPath = path.join(packageRoot, 'dist-cli', 'bin.js')
+  console.log(`[rnx] opening ${appName} in the desktop simulator`)
+  const child = spawn(
+    process.execPath,
+    [binPath, ...buildRnxDesktopOpenArgs(bundleUrl)],
+    {
+      stdio: ['ignore', 'ignore', 'pipe'],
+      windowsHide: true,
+    },
+  )
+  observeRnxDesktopLaunch(child, appName)
+}
+
+interface MetroDesktopOpenOptions {
+  port: number
+  bundleUrl: string
+  appName: string
+  projectRoot: string
+  serverId: string
+  intervalMs?: number
+  timeoutMs?: number
+  launch?: (bundleUrl: string, appName: string) => void
+}
+
+export function openRnxDesktopWhenMetroIsReady({
+  port,
+  bundleUrl,
+  appName,
+  projectRoot,
+  serverId,
+  intervalMs = 100,
+  timeoutMs = 30_000,
+  launch = launchRnxDesktop,
+}: MetroDesktopOpenOptions): Promise<boolean> {
+  const key = `${projectRoot}\0${port}`
+  if (scheduledMetroOpens.has(key)) return Promise.resolve(false)
+  scheduledMetroOpens.add(key)
+  const deadline = Date.now() + timeoutMs
+
+  return new Promise((resolve) => {
+    let finished = false
+    let retryTimer: ReturnType<typeof setTimeout> | undefined
+    const finish = (opened: boolean) => {
+      if (finished) return
+      finished = true
+      clearTimeout(retryTimer)
+      scheduledMetroOpens.delete(key)
+      resolve(opened)
+    }
+    const retry = () => {
+      if (finished) return
+      if (Date.now() >= deadline) {
+        console.error(
+          `[rnx] could not open ${appName}: Metro did not become ready on port ${port}`,
+        )
+        finish(false)
+        return
+      }
+      retryTimer = setTimeout(check, intervalMs)
+    }
+    const check = () => {
+      const request = http.get(
+        `http://127.0.0.1:${port}/__server-scan`,
+        { headers: { Accept: 'application/json' } },
+        (response) => {
+          let body = ''
+          response.setEncoding('utf8')
+          response.on('data', (chunk: string) => {
+            body = `${body}${chunk}`.slice(0, 65_536)
+          })
+          response.once('end', () => {
+            try {
+              const scan: unknown = JSON.parse(body)
+              const matches =
+                response.statusCode === 200 &&
+                Array.isArray(scan) &&
+                scan.some((entry: unknown) => {
+                  if (!entry || typeof entry !== 'object') return false
+                  const scannedPort = Reflect.get(entry, 'port')
+                  const projectName = Reflect.get(entry, 'projectName')
+                  const scannedServerId = Reflect.get(entry, 'rnxServerId')
+                  const scannedBundle = Reflect.get(entry, 'bundleUrl')
+                  if (
+                    scannedPort !== port ||
+                    projectName !== appName ||
+                    scannedServerId !== serverId ||
+                    typeof scannedBundle !== 'string'
+                  ) {
+                    return false
+                  }
+                  return new URL(scannedBundle).searchParams.get('rnxAppName') === appName
+                })
+              if (matches) {
+                launch(bundleUrl, appName)
+                finish(true)
+                return
+              }
+            } catch {}
+            retry()
+          })
+        },
+      )
+      request.setTimeout(Math.min(1_000, timeoutMs), () => request.destroy())
+      request.once('error', retry)
+    }
+    check()
+  })
+}