peachsim 0.1.527

package/src/codex-client.ts

@@ -0,0 +1,234 @@
+// 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
+
+  // the one channel child output reaches a caller on. carries the
+  // app-server's own stderr and any pipe failure against it.
+  function reportChildText(text: string): void {
+    const set = handlers.get('__stderr__')
+    if (!set) return
+    for (const h of set) {
+      try {
+        h({ text })
+      } catch {}
+    }
+  }
+
+  // an 'error' event with no listener is an uncaught exception, so a child
+  // that fails to spawn or a write against a dead app-server would take the
+  // hosting process down with exit 1 instead of letting it shut down. a
+  // failed spawn is a closed client: requests reject with the real reason
+  // rather than hanging until their timeout.
+  child.on('error', (err) => {
+    closed = true
+    reportChildText(`[codex-spawn] ${err.message}\n`)
+  })
+  child.stdin.on('error', (err) => {
+    reportChildText(`[codex-stdin] ${err.message}\n`)
+  })
+
+  const exited = new Promise<{
+    code: number | null
+    signal: NodeJS.Signals | null
+  }>((resolve) => {
+    child.on('close', (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) => {
+    reportChildText(chunk)
+  })
+
+  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,132 @@
+// rnx.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 RNXConfig<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 RNX_CONFIG_QUERY_PARAM = 'rnxConfig'
+
+export function defineConfig<Settings extends Record<string, any> = Record<string, any>>(
+  config: RNXConfig<Settings>,
+): RNXConfig<Settings> {
+  return config
+}
+
+function hasOwnKeys(value: Record<string, unknown> | undefined): boolean {
+  return !!value && Object.keys(value).length > 0
+}
+
+export function hasRNXConfig<Settings extends Record<string, any> = Record<string, any>>(
+  config?: RNXConfig<Settings> | null,
+): config is RNXConfig<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 mergeRNXConfig<
+  Settings extends Record<string, any> = Record<string, any>,
+>(
+  base?: RNXConfig<Settings> | null,
+  override?: RNXConfig<Settings> | null,
+): RNXConfig<Settings> | undefined {
+  if (!hasRNXConfig(base) && !hasRNXConfig(override)) return undefined
+  if (!hasRNXConfig(base)) return override ? { ...override } : undefined
+  if (!hasRNXConfig(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 readRNXConfigFromSearchParams<
+  Settings extends Record<string, any> = Record<string, any>,
+>(searchParams: URLSearchParams): RNXConfig<Settings> | undefined {
+  const raw = searchParams.get(RNX_CONFIG_QUERY_PARAM)
+  if (!raw) return undefined
+  try {
+    const parsed = JSON.parse(raw) as RNXConfig<Settings>
+    return hasRNXConfig(parsed) ? parsed : undefined
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(`[rnx] invalid ${RNX_CONFIG_QUERY_PARAM}: ${message}`)
+    return undefined
+  }
+}
+
+export function applyRNXConfigToUrl<
+  Settings extends Record<string, any> = Record<string, any>,
+>(url: string, config?: RNXConfig<Settings> | null): string {
+  const parsed = new URL(url)
+  if (hasRNXConfig(config)) {
+    parsed.searchParams.set(RNX_CONFIG_QUERY_PARAM, JSON.stringify(config))
+  } else {
+    parsed.searchParams.delete(RNX_CONFIG_QUERY_PARAM)
+  }
+  return parsed.toString()
+}

package/src/connect.ts

@@ -0,0 +1,101 @@
+// `connect()` — the node entrypoint of the rnxsim SDK. resolves the running
+// bridge world the same way the CLI does (development bridge registry, then
+// daemon, then default port), picks a sim, and returns a connected SimClient
+// over the shared ws transport. node-only by design: sim-client.ts stays
+// browser-safe.
+
+import {
+  createCloudBridgeForParsed,
+  resolveCloudSessionForParsed,
+} from '../cli/cloud-client'
+import { readCurrentSimId } from '../cli/current-sim'
+import { createBridge, resolveBridgeWorld, type BridgeSimInfo } from '../cli/ws-bridge'
+import { SimClient, SimConnectError } from './sim-client'
+
+export interface ConnectOptions {
+  /** ws bridge port. default: the resolved bridge world (lockfiles). */
+  port?: number
+  /** sim id to attach to (as shown by `rnx list`). default: the primary sim. */
+  sim?: string
+  /** per-command bridge timeout in ms. default 15000. */
+  timeoutMs?: number
+}
+
+function pickSim(
+  sims: BridgeSimInfo[],
+  wanted: string | undefined,
+  port: number,
+): BridgeSimInfo {
+  const open = sims.filter((sim) => sim.readyState === 'open')
+  if (wanted) {
+    const match = open.find((sim) => sim.id === wanted)
+    if (!match) {
+      throw new SimConnectError(
+        `no sim connected with id ${wanted} on bridge :${port}` +
+          (open.length
+            ? ` — connected: ${open.map((sim) => sim.id).join(', ')}`
+            : ' — no sims connected; open one with `rnx open <port>`'),
+      )
+    }
+    return match
+  }
+  // same session affinity as the CLI: a sim pinned by `rnx open` /
+  // `rnx use` in this terminal wins over the primary election, so a script
+  // run next to CLI commands drives the sim the terminal is working with. a
+  // stale pin (sim gone) falls through to the primary.
+  const pinned = readCurrentSimId()
+  if (pinned) {
+    const match = open.find((sim) => sim.id === pinned)
+    if (match) return match
+  }
+  const primary = open.find((sim) => sim.isPrimary) ?? open[0]
+  if (!primary) {
+    throw new SimConnectError(
+      `no sims connected on bridge :${port} — open one with \`rnx open <port>\``,
+    )
+  }
+  return primary
+}
+
+export async function connect(options: ConnectOptions = {}): Promise<SimClient> {
+  const target = {
+    simId: options.sim,
+    simIdSource: options.sim ? 'flag' : 'none',
+  } satisfies Parameters<typeof resolveCloudSessionForParsed>[0]
+  const cloud = resolveCloudSessionForParsed(target)
+  if (cloud) {
+    const bridge = createCloudBridgeForParsed(target)
+    if (!bridge)
+      throw new SimConnectError('remote simulator session disappeared while connecting')
+    return new SimClient(bridge, cloud.simId, {
+      commandTimeoutMs: options.timeoutMs ?? 15_000,
+    })
+  }
+
+  const port = options.port ?? resolveBridgeWorld().bridgePort
+  const commandTimeoutMs = options.timeoutMs ?? 15_000
+
+  // discovery socket: list sims and pick the target. closed before the pinned
+  // client socket is opened so a failed connect never leaks a connection.
+  const discovery = createBridge(port, { commandTimeoutMs, cliLabel: 'sdk' })
+  let picked: BridgeSimInfo
+  try {
+    picked = pickSim(await discovery.listSims(), options.sim, port)
+  } catch (error) {
+    discovery.close()
+    if (error instanceof SimConnectError) throw error
+    const message = error instanceof Error ? error.message : String(error)
+    throw new SimConnectError(`${message} — is the rnx daemon or dev shell running?`)
+  }
+  discovery.close()
+
+  // pinned socket: every command targets exactly the picked sim, immune to the
+  // CLI's saved-pin re-resolution.
+  const bridge = createBridge(port, {
+    commandTimeoutMs,
+    cliLabel: 'sdk',
+    simId: picked.id,
+    simIdSource: 'flag',
+  })
+  return new SimClient(bridge, picked.id, { commandTimeoutMs })
+}