rnxsim 0.0.0 → 0.1.313

package/src/codex-client.ts

@@ -0,0 +1,215 @@
+// minimal client for `codex app-server` — a long-lived child process that
+// speaks line-delimited JSON-RPC 2.0 over stdio.
+//
+// scope: just the subset sootsim needs for the attached-projects agent
+// wrapper. each connection owns exactly one spawned app-server child; caller
+// is responsible for lifecycle. bidirectional: client can issue requests +
+// receive server-initiated notifications. we treat every method we don't
+// recognize as an observable event that we pass straight to the handler map.
+
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import readline from 'node:readline'
+
+export interface CodexClientOptions {
+  /** resolved path to the codex binary (via `which codex` or user override). */
+  bin: string
+  /** working directory for the spawned process. defaults to process.cwd(). */
+  cwd?: string
+  /** extra environment overrides forwarded to the child. */
+  env?: Record<string, string | undefined>
+}
+
+export type CodexNotificationHandler = (params: unknown) => void
+
+export interface CodexClient {
+  /** promise that resolves when the child exits. use to await shutdown. */
+  readonly exited: Promise<{ code: number | null; signal: NodeJS.Signals | null }>
+  /** register a handler for a server-sent notification method. returns
+   *  a dispose fn. multiple handlers per method are allowed. */
+  on(method: string, handler: CodexNotificationHandler): () => void
+  /** send a JSON-RPC request and await its response. rejects on error
+   *  response or child death. */
+  request<TResult = unknown>(method: string, params?: unknown): Promise<TResult>
+  /** send a JSON-RPC notification (no id, no response). */
+  notify(method: string, params?: unknown): void
+  /** close stdin (graceful shutdown), then SIGTERM after timeout. */
+  shutdown(timeoutMs?: number): Promise<void>
+  /** force-kill immediately. */
+  kill(signal?: NodeJS.Signals): void
+}
+
+interface JsonRpcResponse {
+  jsonrpc?: '2.0'
+  id?: number | string | null
+  result?: unknown
+  error?: { code: number; message: string; data?: unknown }
+  method?: string
+  params?: unknown
+}
+
+export class CodexRpcError extends Error {
+  code: number
+  data: unknown
+  constructor(message: string, code: number, data?: unknown) {
+    super(message)
+    this.name = 'CodexRpcError'
+    this.code = code
+    this.data = data
+  }
+}
+
+export function spawnCodexClient(options: CodexClientOptions): CodexClient {
+  const child: ChildProcessWithoutNullStreams = spawn(options.bin, ['app-server'], {
+    cwd: options.cwd,
+    env: { ...process.env, ...options.env },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+
+  const pending = new Map<
+    number,
+    {
+      resolve: (value: unknown) => void
+      reject: (err: unknown) => void
+      method: string
+    }
+  >()
+  const handlers = new Map<string, Set<CodexNotificationHandler>>()
+  let nextId = 1
+  let closed = false
+
+  const exited = new Promise<{
+    code: number | null
+    signal: NodeJS.Signals | null
+  }>((resolve) => {
+    child.on('exit', (code, signal) => {
+      closed = true
+      const err = new Error(
+        `codex app-server exited (code=${code}, signal=${signal ?? ''})`,
+      )
+      for (const { reject } of pending.values()) reject(err)
+      pending.clear()
+      resolve({ code, signal })
+    })
+  })
+
+  // stdout carries JSON-RPC messages, one per line.
+  const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity })
+  rl.on('line', (line) => {
+    const trimmed = line.trim()
+    if (!trimmed) return
+    let msg: JsonRpcResponse
+    try {
+      msg = JSON.parse(trimmed) as JsonRpcResponse
+    } catch {
+      // app-server occasionally emits non-JSON warnings; ignore.
+      return
+    }
+    if (msg.id != null && (msg.result !== undefined || msg.error !== undefined)) {
+      const idNum = typeof msg.id === 'string' ? Number(msg.id) : msg.id
+      const entry = idNum != null ? pending.get(idNum) : undefined
+      if (!entry) return
+      pending.delete(idNum!)
+      if (msg.error) {
+        entry.reject(new CodexRpcError(msg.error.message, msg.error.code, msg.error.data))
+      } else {
+        entry.resolve(msg.result)
+      }
+      return
+    }
+    if (msg.method) {
+      const set = handlers.get(msg.method)
+      if (!set) return
+      for (const h of set) {
+        try {
+          h(msg.params)
+        } catch (err) {
+          // a buggy handler must not kill the bridge, but it MUST be visible —
+          // silent swallowing turned a notification-handler typo into a
+          // "nothing happens" bug once already.
+          console.error(
+            `[codex-client] handler for "${msg.method}" threw:`,
+            err instanceof Error ? (err.stack ?? err.message) : err,
+          )
+        }
+      }
+    }
+  })
+
+  // stderr is diagnostic only; surfaced via the "stderr" notification channel
+  // so callers can forward it into transcripts if they want.
+  child.stderr.setEncoding('utf8')
+  child.stderr.on('data', (chunk: string) => {
+    const set = handlers.get('__stderr__')
+    if (!set) return
+    for (const h of set) {
+      try {
+        h({ text: chunk })
+      } catch {}
+    }
+  })
+
+  function write(msg: unknown): void {
+    if (closed) return
+    try {
+      child.stdin.write(JSON.stringify(msg) + '\n')
+    } catch {
+      // if stdin has been closed, subsequent writes will throw; ignore.
+    }
+  }
+
+  return {
+    exited,
+    on(method, handler) {
+      let set = handlers.get(method)
+      if (!set) {
+        set = new Set()
+        handlers.set(method, set)
+      }
+      set.add(handler)
+      return () => {
+        set?.delete(handler)
+      }
+    },
+    request<TResult>(method: string, params?: unknown): Promise<TResult> {
+      if (closed) {
+        return Promise.reject(new Error(`codex app-server closed; cannot call ${method}`))
+      }
+      const id = nextId++
+      return new Promise<TResult>((resolve, reject) => {
+        pending.set(id, {
+          resolve: (v) => resolve(v as TResult),
+          reject,
+          method,
+        })
+        write({ jsonrpc: '2.0', id, method, params })
+      })
+    },
+    notify(method, params) {
+      write({ jsonrpc: '2.0', method, params })
+    },
+    async shutdown(timeoutMs = 1500) {
+      if (closed) return
+      try {
+        child.stdin.end()
+      } catch {}
+      const t = setTimeout(() => {
+        if (!closed) {
+          try {
+            child.kill('SIGTERM')
+          } catch {}
+        }
+      }, timeoutMs)
+      try {
+        await exited
+      } finally {
+        clearTimeout(t)
+      }
+    },
+    kill(signal = 'SIGTERM') {
+      if (closed) return
+      try {
+        child.kill(signal)
+      } catch {}
+    },
+  }
+}

package/src/config.ts

@@ -0,0 +1,134 @@
+// sootsim.config.ts — per-app module resolution, turbo modules, env, state, and settings.
+//
+// usage:
+//   import { defineConfig } from 'rnxsim/config'
+//   export default defineConfig({ modules: { ... }, env: { ... } })
+
+import type { RevenueCatTestStoreConfig } from '@sootsim/compat/revenuecat-test-store'
+
+export type ModuleResolution =
+  // an empty module under `modules`; under `nativeModules` / `turboModules` a
+  // present-but-inert native module whose every method call is a no-op.
+  | 'noop'
+  | false // disable builtin stub, use original
+  | { use: string } // redirect to existing compat stub
+  | { file: string } // resolve to a file relative to the config
+  | { inline: Record<string, any> } // inline stub object
+
+export type NativeModuleResolution = ModuleResolution | Record<string, any> // direct native module object for non-url configs
+
+export interface SootSimConfig<
+  Settings extends Record<string, any> = Record<string, any>,
+> {
+  // host-only engine selection. omitted means the current stable runtime.
+  runtimeVersion?: string
+  modules?: Record<string, ModuleResolution>
+  turboModules?: Record<string, NativeModuleResolution>
+  nativeModules?: Record<string, NativeModuleResolution>
+  env?: Record<string, string>
+  // generic per-sim network rewrites for the guest app's runtime fetches.
+  // `remap` keys/values are `host:port` (or bare `host`) — a tenant fetch whose
+  // url matches a key has its host:port swapped for the value before the
+  // request is issued. exists for third-party e2e suites that hardcode a port
+  // (e.g. bluesky's flows type `http://localhost:3000`) which collides with a
+  // host service; map it to the real bound port without editing the app.
+  network?: {
+    remap?: Record<string, string>
+  }
+  settings?: Partial<Settings>
+  initialState?: {
+    authenticated?: boolean
+    locale?: string
+    colorScheme?: 'light' | 'dark' | 'auto'
+    featureFlags?: Record<string, boolean | string | number>
+    // opt-in RevenueCat Test Store catalog consumed by the RNPurchases seam.
+    // omitting it preserves the empty-project result with purchases unavailable.
+    revenueCat?: RevenueCatTestStoreConfig
+    [key: string]: any
+  }
+}
+
+export const SOOTSIM_CONFIG_QUERY_PARAM = 'sootsimConfig'
+
+export function defineConfig<Settings extends Record<string, any> = Record<string, any>>(
+  config: SootSimConfig<Settings>,
+): SootSimConfig<Settings> {
+  return config
+}
+
+function hasOwnKeys(value: Record<string, unknown> | undefined): boolean {
+  return !!value && Object.keys(value).length > 0
+}
+
+export function hasSootSimConfig<
+  Settings extends Record<string, any> = Record<string, any>,
+>(config?: SootSimConfig<Settings> | null): config is SootSimConfig<Settings> {
+  if (!config) return false
+  return (
+    (typeof config.runtimeVersion === 'string' && config.runtimeVersion.length > 0) ||
+    hasOwnKeys(config.modules as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.turboModules as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.nativeModules as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.env as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.network?.remap as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.settings as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.initialState as Record<string, unknown> | undefined)
+  )
+}
+
+export function mergeSootSimConfig<
+  Settings extends Record<string, any> = Record<string, any>,
+>(
+  base?: SootSimConfig<Settings> | null,
+  override?: SootSimConfig<Settings> | null,
+): SootSimConfig<Settings> | undefined {
+  if (!hasSootSimConfig(base) && !hasSootSimConfig(override)) return undefined
+  if (!hasSootSimConfig(base)) return override ? { ...override } : undefined
+  if (!hasSootSimConfig(override)) return base ? { ...base } : undefined
+
+  return {
+    runtimeVersion: override.runtimeVersion ?? base.runtimeVersion,
+    modules: { ...(base.modules || {}), ...(override.modules || {}) },
+    turboModules: { ...(base.turboModules || {}), ...(override.turboModules || {}) },
+    nativeModules: {
+      ...(base.nativeModules || {}),
+      ...(override.nativeModules || {}),
+    },
+    env: { ...(base.env || {}), ...(override.env || {}) },
+    network: {
+      remap: { ...(base.network?.remap || {}), ...(override.network?.remap || {}) },
+    },
+    settings: {
+      ...(base.settings || {}),
+      ...(override.settings || {}),
+    } as Partial<Settings>,
+    initialState: { ...(base.initialState || {}), ...(override.initialState || {}) },
+  }
+}
+
+export function readSootSimConfigFromSearchParams<
+  Settings extends Record<string, any> = Record<string, any>,
+>(searchParams: URLSearchParams): SootSimConfig<Settings> | undefined {
+  const raw = searchParams.get(SOOTSIM_CONFIG_QUERY_PARAM)
+  if (!raw) return undefined
+  try {
+    const parsed = JSON.parse(raw) as SootSimConfig<Settings>
+    return hasSootSimConfig(parsed) ? parsed : undefined
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(`[rnx] invalid ${SOOTSIM_CONFIG_QUERY_PARAM}: ${message}`)
+    return undefined
+  }
+}
+
+export function applySootSimConfigToUrl<
+  Settings extends Record<string, any> = Record<string, any>,
+>(url: string, config?: SootSimConfig<Settings> | null): string {
+  const parsed = new URL(url)
+  if (hasSootSimConfig(config)) {
+    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config))
+  } else {
+    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM)
+  }
+  return parsed.toString()
+}

package/src/dev-bundle-resolution.ts

@@ -0,0 +1,236 @@
+import { isLoopbackHost } from './backend-origin'
+import { 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 EXACT manifest `launchAsset.url` the list resolves —
+// byte-identical, one resolver.
+//
+// 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
+      } =>
+        !!s &&
+        typeof s === 'object' &&
+        (s as { port?: unknown }).port === port &&
+        typeof (s as { bundleUrl?: unknown }).bundleUrl === 'string',
+    )
+    if (!match) return null
+    return {
+      // normalize exactly like the manifest-probe branch below — the scan
+      // returns metro's raw 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
+  }
+}
+
+async function probeBaseUrlBundle(
+  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' },
+    })
+    if (manifestRes.ok) {
+      const manifest = await manifestRes.json()
+      const client = manifest?.extra?.expoClient || manifest?.extra || {}
+      const launchUrl =
+        typeof manifest?.launchAsset?.url === 'string'
+          ? manifest.launchAsset.url
+          : undefined
+      if (launchUrl || client.name) {
+        return {
+          bundleUrl: normalizeNativeDevBundleUrl(
+            launchUrl || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+          ),
+          port,
+          framework: inferManifestFramework(launchUrl, client.sdkVersion),
+          projectName: client.name,
+        }
+      }
+    }
+  } catch {}
+
+  // 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.
+  try {
+    const statusRes = await fetchDevProbe(`${normalizedBaseUrl}/status`)
+    if (statusRes.ok) {
+      const text = await statusRes.text()
+      if (text.includes('packager-status:running')) {
+        return {
+          bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+          port,
+          framework: 'metro',
+        }
+      }
+    }
+  } catch {}
+
+  return null
+}
+
+export async function probePortBundle(port: number): Promise<ResolvedDevBundle | null> {
+  return probeBaseUrlBundle(buildBaseUrl('http:', 'localhost', port), port)
+}
+
+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' }
+}