rnxsim 0.1.345 → 0.1.347

package/scripts/dev-server-scanner.ts

@@ -22,6 +22,11 @@ import { promisify } from 'util'
 import type { AppSettingsSpecifier } from '@sootsim/globals'
 
 const execP = promisify(exec)
+import {
+  buildLoopbackProbeBaseUrl,
+  LOOPBACK_PROBE_HOSTNAMES,
+  normalizeHostname,
+} from '../src/backend-origin.ts'
 import { applySootSimConfigToUrl } from '../src/config.ts'
 import {
   alignLoopbackBundleUrlWithProbe,
@@ -74,30 +79,42 @@ interface HttpResult {
   statusCode: number
   body: string
   contentType?: string
+  hostname: string
 }
 
 // cheap TCP-connect gate. lsof already says the socket is LISTEN, but the
 // process can be closing, the fd can be a different protocol, or a zombie
 // can linger — none of those cases are worth firing 5 HTTP probes at.
-function tcpPing(port: number, timeout = TCP_GATE_MS): Promise<boolean> {
-  return new Promise((resolve) => {
-    const sock = new net.Socket()
-    let settled = false
-    const done = (ok: boolean) => {
-      if (settled) return
-      settled = true
-      sock.destroy()
-      resolve(ok)
-    }
-    sock.setTimeout(timeout)
-    sock.once('connect', () => done(true))
-    sock.once('timeout', () => done(false))
-    sock.once('error', () => done(false))
-    sock.connect(port, 'localhost')
-  })
+async function tcpPing(port: number, timeout = TCP_GATE_MS): Promise<string | null> {
+  try {
+    return await Promise.any(
+      LOOPBACK_PROBE_HOSTNAMES.map(
+        (hostname) =>
+          new Promise<string>((resolve, reject) => {
+            const sock = new net.Socket()
+            let settled = false
+            const done = (reachable: boolean) => {
+              if (settled) return
+              settled = true
+              sock.destroy()
+              if (reachable) resolve(hostname)
+              else reject(new Error(`unreachable loopback host ${hostname}`))
+            }
+            sock.setTimeout(timeout)
+            sock.once('connect', () => done(true))
+            sock.once('timeout', () => done(false))
+            sock.once('error', () => done(false))
+            sock.connect(port, hostname)
+          }),
+      ),
+    )
+  } catch {
+    return null
+  }
 }
 
 function httpGet(
+  hostname: string,
   port: number,
   path: string,
   method: 'GET' | 'HEAD' = 'GET',
@@ -106,7 +123,7 @@ function httpGet(
 ): Promise<HttpResult | null> {
   return new Promise((resolve) => {
     const req = http.request(
-      { hostname: 'localhost', port, path, method, timeout, headers },
+      { hostname, port, path, method, timeout, headers },
       (res) => {
         let body = ''
         res.on('data', (c: Buffer) => (body += c.toString()))
@@ -117,7 +134,12 @@ function httpGet(
           return undefined
         })()
         res.on('end', () =>
-          resolve({ statusCode: res.statusCode || 0, body, contentType }),
+          resolve({
+            statusCode: res.statusCode || 0,
+            body,
+            contentType,
+            hostname,
+          }),
         )
       },
     )
@@ -342,6 +364,7 @@ export async function resolveProcessCwd(pid: number): Promise<string | null> {
 // ── per-port probe orchestration ────────────────────────────────────────────
 
 function makeResult(
+  hostname: string,
   port: number,
   framework: DiscoveredServer['framework'],
   owner: Pick<DiscoveredServer, 'cwd' | 'pid'>,
@@ -351,10 +374,10 @@ function makeResult(
     framework,
     bundleUrl: withRuntimeConfig(
       port,
-      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
+      `${buildLoopbackProbeBaseUrl('http:', hostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
       owner.cwd,
     ),
-    hmrUrl: `ws://localhost:${port}/hot`,
+    hmrUrl: `${buildLoopbackProbeBaseUrl('ws:', hostname, port)}/hot`,
     lastSeen: Date.now(),
     ...owner,
   }
@@ -408,7 +431,10 @@ function applyManifest(
     const rawLaunchUrl = manifest?.launchAsset?.url
     const launchUrl =
       typeof rawLaunchUrl === 'string'
-        ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, `http://localhost:${result.port}`)
+        ? alignLoopbackBundleUrlWithProbe(
+            rawLaunchUrl,
+            buildLoopbackProbeBaseUrl('http:', manifestRes.hostname, result.port),
+          )
         : rawLaunchUrl
     if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
       result.bundleUrl = withRuntimeConfig(result.port, launchUrl, result.cwd)
@@ -423,14 +449,14 @@ function applyManifest(
         } else {
           const cleanPath = rawIconUrl.replace(/^\.\//, '')
           result.iconUrl = buildIconProxyUrl(
-            `http://localhost:${result.port}/assets/${cleanPath}`,
+            `${buildLoopbackProbeBaseUrl('http:', manifestRes.hostname, result.port)}/assets/${cleanPath}`,
           )
         }
       } else {
         // no proxy requested — use the raw URL
         result.iconUrl = rawIconUrl.startsWith('http')
           ? rawIconUrl
-          : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, '')}`
+          : `${buildLoopbackProbeBaseUrl('http:', manifestRes.hostname, result.port)}/assets/${rawIconUrl.replace(/^\.\//, '')}`
       }
     }
   } catch {}
@@ -441,7 +467,11 @@ export function __applyManifestForTests(
   result: DiscoveredServer,
   manifestBody: string,
 ): DiscoveredServer {
-  return applyManifest(result, { statusCode: 200, body: manifestBody })
+  return applyManifest(result, {
+    statusCode: 200,
+    body: manifestBody,
+    hostname: new URL(result.bundleUrl).hostname,
+  })
 }
 
 // ── name/icon enrichment ────────────────────────────────────────────────────
@@ -490,30 +520,42 @@ function enrichWithManifest(
 
   if (!enrichmentInFlight.has(result.port)) {
     enrichmentInFlight.add(result.port)
-    const port = result.port
-    void fetchManifestEnrichment(port, buildIconProxyUrl).finally(() =>
-      enrichmentInFlight.delete(port),
+    void fetchManifestEnrichment(result, buildIconProxyUrl).finally(() =>
+      enrichmentInFlight.delete(result.port),
     )
   }
   return result
 }
 
 async function fetchManifestEnrichment(
-  port: number,
+  result: DiscoveredServer,
   buildIconProxyUrl?: (externalUrl: string) => string,
 ): Promise<void> {
-  const manifestRes = await httpGet(port, '/', 'GET', ENRICH_TIMEOUT_MS, {
-    'expo-platform': 'ios',
-  })
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname)
+  const manifestRes = await httpGet(
+    hostname,
+    result.port,
+    '/',
+    'GET',
+    ENRICH_TIMEOUT_MS,
+    {
+      'expo-platform': 'ios',
+    },
+  )
   if (!manifestRes || manifestRes.statusCode !== 200) return
   // reuse applyManifest's exact field extraction against a throwaway result.
   const parsed = applyManifest(
-    { port, framework: 'one', bundleUrl: '', lastSeen: 0 },
+    {
+      port: result.port,
+      framework: 'one',
+      bundleUrl: `${buildLoopbackProbeBaseUrl('http:', hostname, result.port)}/index.bundle`,
+      lastSeen: 0,
+    },
     manifestRes,
     buildIconProxyUrl,
   )
   if (!parsed.projectName && !parsed.iconUrl) return
-  enrichmentCache.set(port, {
+  enrichmentCache.set(result.port, {
     projectName: parsed.projectName,
     iconUrl: parsed.iconUrl,
     iconPath: parsed.iconPath,
@@ -521,7 +563,7 @@ async function fetchManifestEnrichment(
   })
   // the nameless result cached as a strong entry and won't re-probe on its own;
   // drop it so the next scan re-runs probePort and publishes the enriched name.
-  portCache.delete(port)
+  portCache.delete(result.port)
 }
 
 // ports confirmed to be running a non-sootsim dev server — safe to skip the
@@ -569,7 +611,8 @@ export async function probePort(
   // too, or a cold CLI process can build the known app's bundle url before its
   // runtime config is available.
   await loadOptionalDemoApps()
-  if (!(await tcpPing(port))) return null
+  const probeHostname = await tcpPing(port)
+  if (!probeHostname) return null
 
   const suppliedPid = listeningProcess?.pid
   const ownerPid =
@@ -584,12 +627,18 @@ export async function probePort(
 
   // wave 1 — safe parallel probes. none of these mutate metro state.
   const [sootsimRes, statusRes, manifestRes, expoRes] = await Promise.all([
-    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, '/__soot/'),
-    httpGet(port, '/status'),
+    knownNonPatched.has(port)
+      ? Promise.resolve(null)
+      : httpGet(probeHostname, port, '/__soot/'),
+    httpGet(probeHostname, port, '/status'),
     knownOne.has(port)
       ? Promise.resolve(null)
-      : httpGet(port, '/', 'GET', MANIFEST_TIMEOUT_MS, { 'expo-platform': 'ios' }),
-    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, '/_expo/status'),
+      : httpGet(probeHostname, port, '/', 'GET', MANIFEST_TIMEOUT_MS, {
+          'expo-platform': 'ios',
+        }),
+    knownNonExpo.has(port)
+      ? Promise.resolve(null)
+      : httpGet(probeHostname, port, '/_expo/status'),
   ])
 
   // remember negative /_expo/status responses so we don't keep probing this
@@ -627,7 +676,7 @@ export async function probePort(
     knownNonPatched.add(port)
     const launchUrl =
       manifestLaunchUrl ||
-      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
+      `${buildLoopbackProbeBaseUrl('http:', probeHostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
     // call the framework "one" only when launchAsset clearly points at
     // a One metro entry; otherwise treat it as plain expo so downstream
     // bundle handling uses the right path semantics.
@@ -641,7 +690,7 @@ export async function probePort(
         port,
         framework,
         bundleUrl: withRuntimeConfig(port, launchUrl, owner.cwd),
-        hmrUrl: `ws://localhost:${port}/hot`,
+        hmrUrl: `${buildLoopbackProbeBaseUrl('ws:', probeHostname, port)}/hot`,
         lastSeen: Date.now(),
         ...owner,
       },
@@ -661,7 +710,12 @@ export async function probePort(
     knownNonPatched.add(port)
     return enrichWithManifest(
       applyManifest(
-        makeResult(port, expoRes && expoRes.statusCode === 200 ? 'expo' : 'metro', owner),
+        makeResult(
+          probeHostname,
+          port,
+          expoRes && expoRes.statusCode === 200 ? 'expo' : 'metro',
+          owner,
+        ),
         manifestRes,
         buildIconProxyUrl,
       ),
@@ -684,10 +738,10 @@ export async function probePort(
           framework: 'one',
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}/__soot/bundle.js`,
+            `${buildLoopbackProbeBaseUrl('http:', probeHostname, port)}/__soot/bundle.js`,
             owner.cwd,
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl('ws:', probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           patched: true,
           ...owner,
@@ -726,7 +780,7 @@ export async function probePort(
     return null
   }
 
-  const oneRes = await httpGet(port, onePath, 'HEAD')
+  const oneRes = await httpGet(probeHostname, port, onePath, 'HEAD')
   if (
     oneRes &&
     oneRes.statusCode > 0 &&
@@ -742,10 +796,10 @@ export async function probePort(
           framework: 'one',
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}${onePath}&minify=false`,
+            `${buildLoopbackProbeBaseUrl('http:', probeHostname, port)}${onePath}&minify=false`,
             owner.cwd,
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl('ws:', probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           ...owner,
         },

package/src/backend-origin.ts

@@ -1,9 +1,23 @@
 const DEFAULT_CONTRAST_BACKEND_ORIGIN = 'https://contrast.dev'
 
-function normalizeHostname(hostname: string): string {
+export const LOOPBACK_PROBE_HOSTNAMES = ['::1', '127.0.0.1'] as const
+
+export function normalizeHostname(hostname: string): string {
   return hostname.replace(/^\[|\]$/g, '').toLowerCase()
 }
 
+export function buildLoopbackProbeBaseUrl(
+  protocol: 'http:' | 'ws:',
+  hostname: string,
+  port: number,
+): string {
+  const normalizedHostname = normalizeHostname(hostname)
+  const urlHost = normalizedHostname.includes(':')
+    ? `[${normalizedHostname}]`
+    : normalizedHostname
+  return `${protocol}//${urlHost}:${port}`
+}
+
 export function isLoopbackHost(hostname: string): boolean {
   const normalized = normalizeHostname(hostname)
   return (

package/src/dev-bundle-resolution.ts

@@ -1,4 +1,8 @@
-import { isLoopbackHost } from './backend-origin'
+import {
+  buildLoopbackProbeBaseUrl,
+  isLoopbackHost,
+  LOOPBACK_PROBE_HOSTNAMES,
+} from './backend-origin'
 import {
   alignLoopbackBundleUrlWithProbe,
   METRO_BUNDLE_PATH,
@@ -127,21 +131,12 @@ async function resolvePortViaServerScan(port: number): Promise<ResolvedDevBundle
   }
 }
 
-async function probeBaseUrlBundle(
+async function probeBaseUrlBundleDirect(
   baseUrl: string,
   port: number,
 ): Promise<ResolvedDevBundle | null> {
   const normalizedBaseUrl = baseUrl.replace(/\/+$/, '')
 
-  // 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(normalizedBaseUrl).hostname)) {
-      const viaScan = await resolvePortViaServerScan(port)
-      if (viaScan) return viaScan
-    }
-  } catch {}
-
   try {
     const manifestRes = await fetchDevProbe(`${normalizedBaseUrl}/`, {
       headers: { 'expo-platform': 'ios' },
@@ -198,8 +193,30 @@ async function probeBaseUrlBundle(
   return null
 }
 
+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> {
-  return probeBaseUrlBundle(buildBaseUrl('http:', 'localhost', port), port)
+  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> {