rnxsim 0.1.499 → 0.1.501

package/cli/commands/detox.ts

@@ -1,14 +1,7 @@
 // rnx detox — run existing detox suites against rnx
 //
-// the command is a thin orchestration layer over `npx jest`:
-//  1. resolves a test dir (cwd e2e|test/e2e|detox, or the flag)
-//  2. makes sure an rnx shell is reachable (auto-launches one if not)
-//  3. spawns jest with our preset baked in so `import ... from 'detox'`
-//     resolves to the rnx driver
-//
-// it deliberately shells out to the user's own jest so their jest version,
-// transforms, and setupFiles keep working. the only thing we force is the
-// moduleNameMapper for `^detox$`.
+// use the customer's jest config unchanged. the rnx preset maps the detox
+// driver and owns browser cleanup; jest owns setup, selection and deadlines.
 
 import { spawn } from 'child_process'
 import {
@@ -20,27 +13,17 @@ import {
   unlinkSync,
 } from 'fs'
 import { createRequire } from 'module'
+import { fileURLToPath } from 'node:url'
 import { tmpdir } from 'os'
 import { dirname, resolve, join, relative } from 'path'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { resolveCliAuth } from '../auth'
 import { registerRun, shouldRegisterRun } from '../run-registry'
 import { rnxExit } from '../run-rnx'
+import { buildShellUrl } from './control'
 import { discoverSootsimUrl } from './flow'
 import { resolveDefaultUploadOrigin } from './upload'
 
-// resolve the detox preset directory via the package's own subpath export.
-function resolveDetoxDir(): string {
-  try {
-    const entry = import.meta.resolve(`${rnxPublicBrand.packageName}/detox`)
-    // import.meta.resolve returns a file:// URL — convert to a path
-    return dirname(entry.startsWith('file://') ? entry.slice(7) : entry)
-  } catch {
-    // fallback for source-layout dev (no compiled package.json exports)
-    return resolve(import.meta.dirname!, '..', '..', 'detox')
-  }
-}
-
 interface RunDetoxOpts {
   port?: number
   verbose?: boolean
@@ -73,62 +56,73 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
   }
 
   const getFlag = (name: string) => {
+    const inline = args.find((arg) => arg.startsWith(`${name}=`))
+    if (inline) return inline.slice(name.length + 1)
     const i = args.indexOf(name)
     return i >= 0 ? args[i + 1] : undefined
   }
   const hasFlag = (name: string) => args.includes(name)
 
-  const watch = hasFlag('--watch')
+  const watch = hasFlag('--watch') || hasFlag('--watchAll')
   const headed = hasFlag('--headed')
   const noLaunch = hasFlag('--no-launch')
   const configFlag = getFlag('--config')
-  const port = opts.port || Number(process.env.SOOTSIM_PORT) || 5173
-
-  // positional args: test file paths passed directly to jest
-  const positional = args.filter((a, i) => {
-    if (a.startsWith('--') || a === '-t' || a === '-h') return false
-    const prev = args[i - 1]
-    if (
-      prev === '--config' ||
-      prev === '-t' ||
-      prev === '--testNamePattern' ||
-      prev === '--grep' ||
-      prev === '--outputFile' ||
-      prev === '--maxWorkers' ||
-      prev === '--shard'
+  const port =
+    Number(getFlag('--port')) || opts.port || Number(process.env.SOOTSIM_PORT) || 5173
+  if (getFlag('--sim')) {
+    throw new Error(
+      'Detox owns its browser context; pin its shell with RNX_URL and --device instead of --sim',
     )
-      return false
-    return true
-  })
-  const passthroughJestFlags = args.flatMap((arg, index) => {
-    if (
-      arg === '--runInBand' ||
-      arg.startsWith('--maxWorkers=') ||
-      arg.startsWith('--shard=')
-    ) {
-      return [arg]
-    }
-    if ((arg === '--maxWorkers' || arg === '--shard') && args[index + 1]) {
-      return [arg, args[index + 1]]
+  }
+
+  // consume only rnx options. jest must receive its complete argv, including
+  // selection, timeouts, reporters, coverage, and options added by future jest versions.
+  const jestArgs: string[] = ['jest']
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]
+    if (arg === '--headed' || arg === '--no-launch') continue
+    const name = arg.split('=', 1)[0]
+    if (['--config', '--app', '--device', '--port'].includes(name)) {
+      if (!arg.includes('=')) {
+        if (!args[index + 1] || args[index + 1].startsWith('-')) {
+          throw new Error(`${name} requires a value`)
+        }
+        index++
+      }
+      continue
     }
-    return []
-  })
+    jestArgs.push(arg === '--grep' ? '--testNamePattern' : arg)
+  }
+
+  let localConfig =
+    configFlag ||
+    firstExisting([
+      'rnx-detox.config.cjs',
+      'jest.config.ts',
+      'jest.config.mts',
+      'jest.config.mjs',
+      'jest.config.cjs',
+      'jest.config.js',
+      'jest.config.cts',
+      'jest.config.json',
+    ])
+  if (!localConfig && existsSync('package.json')) {
+    const pkg = JSON.parse(readFileSync('package.json', 'utf8'))
+    if (pkg.jest) localConfig = 'package.json'
+  }
 
-  // test dir discovery. an explicit suite owns its root; otherwise external
-  // suites set RNX_TEST_DIR and conventional locations remain the fallback.
+  // test dir discovery. external test suites set RNX_TEST_DIR; otherwise
+  // we auto-detect the conventional locations.
   const detoxDirs = ['e2e', 'test/e2e', 'detox']
-  const explicitTarget =
-    positional[0] && existsSync(resolve(process.cwd(), positional[0]))
-      ? resolve(process.cwd(), positional[0])
-      : null
-  let testDir: string | null = explicitTarget
-    ? statSync(explicitTarget).isDirectory()
-      ? explicitTarget
-      : dirname(explicitTarget)
-    : process.env.RNX_TEST_DIR
-      ? resolve(process.cwd(), process.env.RNX_TEST_DIR)
-      : null
-  if (!testDir) {
+  let testDir: string | null = process.env.RNX_TEST_DIR
+    ? resolve(process.cwd(), process.env.RNX_TEST_DIR)
+    : null
+  if (!testDir && !localConfig && args[0] && !args[0].startsWith('-')) {
+    const target = resolve(args[0])
+    if (existsSync(target))
+      testDir = statSync(target).isDirectory() ? target : dirname(target)
+  }
+  if (!testDir && !localConfig) {
     for (const dir of detoxDirs) {
       const full = resolve(process.cwd(), dir)
       if (existsSync(full)) {
@@ -137,13 +131,14 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
       }
     }
   }
-  if (!testDir) {
+  if (!testDir && !localConfig) {
     console.error(
       `  error: no detox tests found. expected one of: ${detoxDirs.join(', ')}\n` +
         `  run 'rnx detox init' to scaffold a starter suite.`,
     )
     rnxExit(1)
   }
+  testDir ??= process.cwd()
 
   // auto-launch: make sure an rnx shell is reachable before running jest.
   // Reuse the Maestro discovery path: scan local dev servers.
@@ -152,52 +147,40 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
     await ensureShellRunning(port)
   }
 
-  // build the jest command. customer config remains authoritative for setup,
-  // transforms, roots, and timeouts; the generated wrapper adds only RNX's
-  // Detox module mapping and cleanup hook.
-  const jestArgs: string[] = ['jest']
-  const localConfig =
-    configFlag ||
-    firstExisting(['rnx-detox.config.cjs', 'jest.config.cjs', 'jest.config.js'])
-
+  // build the jest command. prefer the user's config if they passed --config
+  // or if a rnx-detox.config.cjs exists in cwd. otherwise write a temporary
+  // config that loads our preset.
   let tempConfig: string | null = null
-  const presetPath = resolve(resolveDetoxDir(), 'jest-preset.cjs')
   if (localConfig) {
-    const localConfigPath = resolve(process.cwd(), localConfig)
-    // Keep the wrapper beside the customer config so a relative rootDir keeps
-    // resolving from the same directory Jest would have used directly.
-    tempConfig = join(dirname(localConfigPath), `rnx-detox-${process.pid}.config.cjs`)
-    writeFileSync(
-      tempConfig,
-      `const rnx = require(${JSON.stringify(presetPath)})\n` +
-        `const customer = require(${JSON.stringify(localConfigPath)})\n` +
-        `module.exports = {\n` +
-        `  ...rnx,\n` +
-        `  ...customer,\n` +
-        `  moduleNameMapper: { ...rnx.moduleNameMapper, ...customer.moduleNameMapper, '^detox$': rnx.moduleNameMapper['^detox$'] },\n` +
-        `  setupFilesAfterEnv: [...new Set([...(customer.setupFilesAfterEnv || []), ...(rnx.setupFilesAfterEnv || [])])],\n` +
-        `}\n`,
+    jestArgs.push(
+      '--config',
+      localConfig.startsWith('{') ? localConfig : resolve(process.cwd(), localConfig),
     )
-    jestArgs.push('--config', tempConfig)
   } else {
     // no local config — write a temp config that pulls in our preset.
     // jest's --preset flag has quirky module resolution that breaks with
     // subpath exports, so we generate a real config file instead.
     // scope roots + testMatch to the discovered test dir so jest doesn't
     // scan the entire repo (which causes haste collisions in monorepos).
+    const presetPath = fileURLToPath(
+      import.meta.resolve(`${rnxPublicBrand.packageName}/detox/jest-preset`),
+    )
     // an external suite may optionally declare its own ignore patterns via e2e/jest-ignore.cjs
     const suiteIgnoreFile = testDir ? join(testDir, 'e2e', 'jest-ignore.cjs') : null
     let suiteIgnorePatterns: string[] = []
     if (suiteIgnoreFile && existsSync(suiteIgnoreFile)) {
-      try {
-        const req = createRequire(import.meta.url)
-        const exported = req(suiteIgnoreFile)
-        suiteIgnorePatterns = Array.isArray(exported)
-          ? exported
-          : Array.isArray(exported.testPathIgnorePatterns)
-            ? exported.testPathIgnorePatterns
-            : []
-      } catch {}
+      const req = createRequire(import.meta.url)
+      const exported = req(suiteIgnoreFile)
+      const patterns = Array.isArray(exported)
+        ? exported
+        : exported.testPathIgnorePatterns
+      if (
+        !Array.isArray(patterns) ||
+        !patterns.every((pattern) => typeof pattern === 'string')
+      ) {
+        throw new Error(`${suiteIgnoreFile} must export string ignore patterns`)
+      }
+      suiteIgnorePatterns = patterns
     }
     tempConfig = join(tmpdir(), `rnx-detox-${process.pid}.config.cjs`)
     const cfg = {
@@ -215,36 +198,33 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
     jestArgs.push('--config', tempConfig)
   }
 
-  if (watch) jestArgs.push('--watch')
-
-  const testNamePattern =
-    getFlag('-t') || getFlag('--testNamePattern') || getFlag('--grep')
-  if (testNamePattern) jestArgs.push('-t', testNamePattern)
-
   // hosted run registration (org dashboard pass/fail row). when it applies,
   // capture jest's structured results via --json --outputFile so the row can
   // carry test counts + the first failure; console output stays untouched.
   const auth = resolveCliAuth()
   const wantsRegistration = !watch && shouldRegisterRun({ uploadedShare: false, auth })
-  let resultsFile: string | null = process.env.SOOTSIM_JEST_OUTPUT_FILE || null
-  if (process.env.SOOTSIM_JEST_JSON === '1') jestArgs.push('--json')
-  if (process.env.SOOTSIM_JEST_OUTPUT_FILE) {
+  let resultsFile: string | null =
+    getFlag('--outputFile') || process.env.SOOTSIM_JEST_OUTPUT_FILE || null
+  if ((process.env.SOOTSIM_JEST_JSON === '1' || wantsRegistration) && !hasFlag('--json'))
+    jestArgs.push('--json')
+  if (!getFlag('--outputFile') && process.env.SOOTSIM_JEST_OUTPUT_FILE) {
     jestArgs.push('--outputFile', process.env.SOOTSIM_JEST_OUTPUT_FILE)
-  } else if (wantsRegistration) {
+  } else if (!resultsFile && wantsRegistration) {
     resultsFile = join(tmpdir(), `rnx-detox-results-${process.pid}.json`)
-    jestArgs.push('--json', '--outputFile', resultsFile)
+    jestArgs.push('--outputFile', resultsFile)
   }
 
-  jestArgs.push(...passthroughJestFlags)
-
-  // any positional test files get passed straight through
-  jestArgs.push(...positional)
-
   console.log(`  rnx detox`)
   console.log(`    test dir: ${testDir}`)
   console.log(`    port:     ${port}${headed ? ' (headed)' : ''}`)
   if (localConfig) console.log(`    config:   ${localConfig}`)
 
+  const shellBaseUrl = process.env.RNX_URL || `http://localhost:${port}`
+  const app = getFlag('--app')
+  const shellUrl = new URL(app ? await buildShellUrl(app, shellBaseUrl) : shellBaseUrl)
+  const device = getFlag('--device')
+  if (device) shellUrl.searchParams.set('device', device)
+
   // proof capture runs under the repo's pinned node runtime. its v8 collector
   // crashes in ClearStaleLeftTrimmedPointerVisitor when Sparkplug baseline
   // compilation (Builtins_BaselineOutOfLinePrologue) pushes untagged register
@@ -273,7 +253,7 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
       RNX_TEST_DIR: testDir,
       SOOTSIM_PORT: String(port),
       SOOTSIM_HEADED: headed ? '1' : '',
-      RNX_URL: process.env.RNX_URL || `http://localhost:${port}`,
+      RNX_URL: shellUrl.toString(),
     },
   })
 
@@ -292,26 +272,30 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
   process.on('SIGINT', onInt)
 
   const startedAt = Date.now()
-  const code = await new Promise<number>((resolveCode, reject) => {
-    child.once('error', reject)
-    child.once('exit', (exitCode, signal) => {
-      if (signal) {
-        console.error(`  error: jest terminated by ${signal}`)
-        resolveCode(1)
-        return
-      }
-      resolveCode(exitCode ?? 1)
+  let code: number
+  try {
+    code = await new Promise<number>((resolveCode, reject) => {
+      child.once('error', reject)
+      child.once('exit', (exitCode, signal) => {
+        if (signal) {
+          console.error(`  error: jest terminated by ${signal}`)
+          resolveCode(1)
+          return
+        }
+        resolveCode(exitCode ?? 1)
+      })
     })
-  })
-  process.off('SIGTERM', onTerm)
-  process.off('SIGINT', onInt)
-  if (tempConfig)
-    try {
-      unlinkSync(tempConfig)
-    } catch {}
+  } finally {
+    process.off('SIGTERM', onTerm)
+    process.off('SIGINT', onInt)
+    if (tempConfig) unlinkSync(tempConfig)
+  }
 
   if (wantsRegistration) {
-    const results = resultsFile ? readJestResults(resultsFile) : null
+    const results =
+      resultsFile && existsSync(resultsFile) && statSync(resultsFile).mtimeMs >= startedAt
+        ? readJestResults(resultsFile)
+        : null
     const origin = await resolveDefaultUploadOrigin()
     const run = await registerRun({
       origin,
@@ -330,11 +314,20 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
       auth,
     })
     if (run) console.log(`  run: ${run.id}`)
+    else rnxExit(code || 1)
+  }
+  if (
+    resultsFile &&
+    existsSync(resultsFile) &&
+    !getFlag('--outputFile') &&
+    !process.env.SOOTSIM_JEST_OUTPUT_FILE
+  ) {
+    unlinkSync(resultsFile)
   }
   rnxExit(code)
 }
 
-type JestRunSummary = {
+export type JestRunSummary = {
   numTotalTests: number
   numPassedTests: number
   firstFailure: string | null
@@ -344,47 +337,52 @@ type JestRunSummary = {
 // parse jest's --json output file down to the counts + first failure the
 // hosted run row carries. tolerant: any parse problem returns null and the
 // run registers with exit-code status only.
-function readJestResults(file: string): JestRunSummary | null {
+export function readJestResults(file: string): JestRunSummary | null {
   try {
-    const parsed = JSON.parse(readFileSync(file, 'utf8')) as {
-      numTotalTests?: number
-      numPassedTests?: number
-      testResults?: Array<{
-        testResults?: Array<{
-          status?: string
-          fullName?: string
-          failureMessages?: string[]
-        }>
-      }>
-    }
+    const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'))
+    if (
+      !parsed ||
+      typeof parsed !== 'object' ||
+      !('numTotalTests' in parsed) ||
+      typeof parsed.numTotalTests !== 'number' ||
+      !('numPassedTests' in parsed) ||
+      typeof parsed.numPassedTests !== 'number' ||
+      !('testResults' in parsed) ||
+      !Array.isArray(parsed.testResults)
+    )
+      return null
     let firstFailure: string | null = null
     let firstFailedIndex: number | null = null
     let index = 0
-    for (const suite of parsed.testResults ?? []) {
-      for (const test of suite.testResults ?? []) {
+    for (const suite of parsed.testResults) {
+      if (!suite || typeof suite !== 'object' || !Array.isArray(suite.assertionResults))
+        return null
+      for (const test of suite.assertionResults) {
+        if (!test || typeof test !== 'object') return null
         if (firstFailedIndex == null && test.status === 'failed') {
           firstFailedIndex = index
-          const message = test.failureMessages?.[0]?.split('\n')[0]
-          firstFailure = [test.fullName, message].filter(Boolean).join(': ') || null
+          const messages: unknown[] = Array.isArray(test.failureMessages)
+            ? test.failureMessages
+            : []
+          const message = messages
+            .filter((value): value is string => typeof value === 'string')
+            .join('\n')
+          firstFailure =
+            [typeof test.fullName === 'string' ? test.fullName : '', message]
+              .filter(Boolean)
+              .join(': ') || null
         }
         index += 1
       }
     }
-    if (typeof parsed.numTotalTests !== 'number') return null
     return {
       numTotalTests: parsed.numTotalTests,
-      numPassedTests: parsed.numPassedTests ?? 0,
+      numPassedTests: parsed.numPassedTests,
       firstFailure,
       firstFailedIndex,
     }
   } catch {
     return null
-  } finally {
-    if (!process.env.SOOTSIM_JEST_OUTPUT_FILE) {
-      try {
-        unlinkSync(file)
-      } catch {}
-    }
   }
 }
 
@@ -419,7 +417,7 @@ function initDetoxProject(): void {
 
 /** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
-  preset: 'rnxsim/detox/jest-preset',
+  preset: 'rnxsim/detox',
   rootDir: __dirname,
   testMatch: ['<rootDir>/e2e/**/*.test.ts', '<rootDir>/e2e/**/*.test.js'],
 }

package/cli/commands/inspect/core.ts

@@ -1025,6 +1025,7 @@ export interface WaitReadyStatus {
 export interface WaitReadyOptions {
   progressIntervalMs?: number
   onProgress?: (status: WaitReadyStatus) => void
+  simId?: string
 }
 
 export function waitReadyReason(
@@ -1091,6 +1092,7 @@ export async function inspectWaitReady(
     result = await bridge.send(
       {
         type: 'waitFor',
+        ...(options.simId ? { simId: options.simId } : {}),
         waitForOptions: { condition: { type: 'ready' }, timeoutMs },
       },
       { timeoutMs: timeoutMs + 1_000 },