rnxsim 0.1.313 → 0.1.314

package/cli/commands/desktop.ts

@@ -0,0 +1,39 @@
+import { runElectron } from './electron'
+import { runInstallDesktop } from './install-desktop'
+
+interface DesktopOptions {
+  port?: number
+  device?: string
+}
+
+function printHelp(): void {
+  console.log(`
+rnxsim desktop — launch or install the desktop companion
+
+usage:
+  rnxsim desktop [options]
+  rnxsim desktop install [options]
+
+options:
+  --port <number>     connect to a running dev server on this port
+  --profile <id>      launch with an isolated persistent storage profile
+  --ephemeral         launch with a temporary isolated storage profile
+  -y, --yes           install without prompting
+`)
+}
+
+export async function runDesktop(args: string[], opts: DesktopOptions): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const sub = args.find((arg) => !arg.startsWith('-'))
+  if (sub === 'install') {
+    const index = args.indexOf(sub)
+    await runInstallDesktop([...args.slice(0, index), ...args.slice(index + 1)])
+    return
+  }
+
+  await runElectron(args, opts)
+}

package/cli/commands/detect.ts

@@ -0,0 +1,197 @@
+// project detection — finds project root, detects framework, scans monorepo workspaces
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
+import { basename, dirname, join } from 'path'
+
+export type Framework = 'one' | 'expo' | 'bare' | 'unknown'
+export type PackageManager = 'bun' | 'pnpm' | 'npm' | 'yarn'
+export type MonorepoType = 'turbo' | 'pnpm' | 'nx' | 'npm-workspaces' | 'single'
+
+export interface DetectedProject {
+  dir: string
+  name: string
+  framework: Framework
+  hasViteConfig: boolean
+  hasMetroConfig: boolean
+  hasSootsimDependency: boolean
+  devCommand: string | null
+}
+
+export interface DetectedWorkspace {
+  root: string
+  type: MonorepoType
+  packageManager: PackageManager
+  apps: DetectedProject[]
+}
+
+export function findProjectRoot(cwd: string): string {
+  let dir = cwd
+  while (true) {
+    if (
+      existsSync(join(dir, 'turbo.json')) ||
+      existsSync(join(dir, 'nx.json')) ||
+      existsSync(join(dir, 'lerna.json')) ||
+      existsSync(join(dir, 'pnpm-workspace.yaml'))
+    ) {
+      return dir
+    }
+
+    const pkgPath = join(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+        if (pkg.workspaces) return dir
+      } catch {}
+    }
+
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return cwd
+}
+
+export function detectPackageManager(root: string): PackageManager {
+  if (existsSync(join(root, 'bun.lock')) || existsSync(join(root, 'bun.lockb'))) {
+    return 'bun'
+  }
+  if (existsSync(join(root, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(root, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+export function detectMonorepoType(root: string): MonorepoType {
+  if (existsSync(join(root, 'turbo.json'))) return 'turbo'
+  if (existsSync(join(root, 'nx.json'))) return 'nx'
+  if (existsSync(join(root, 'pnpm-workspace.yaml'))) return 'pnpm'
+
+  const pkgPath = join(root, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      if (pkg.workspaces) return 'npm-workspaces'
+    } catch {}
+  }
+  return 'single'
+}
+
+export function detectFramework(deps: Record<string, string>): Framework {
+  if (deps.one) return 'one'
+  if (deps.expo) return 'expo'
+  if (deps['react-native']) return 'bare'
+  return 'unknown'
+}
+
+export function detectProject(dir: string): DetectedProject | null {
+  const pkgPath = join(dir, 'package.json')
+  if (!existsSync(pkgPath)) return null
+
+  let pkg: any
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return null
+  }
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const framework = detectFramework(deps)
+
+  if (framework === 'unknown') return null
+
+  return {
+    dir,
+    name: pkg.name || basename(dir),
+    framework,
+    hasViteConfig:
+      existsSync(join(dir, 'vite.config.ts')) || existsSync(join(dir, 'vite.config.js')),
+    hasMetroConfig:
+      existsSync(join(dir, 'metro.config.js')) ||
+      existsSync(join(dir, 'metro.config.ts')),
+    hasSootsimDependency: Boolean(deps.sootsim),
+    devCommand: pkg.scripts?.dev || null,
+  }
+}
+
+function getWorkspaceDirs(root: string): string[] {
+  const dirs: string[] = []
+
+  const pnpmWs = join(root, 'pnpm-workspace.yaml')
+  if (existsSync(pnpmWs)) {
+    const content = readFileSync(pnpmWs, 'utf8')
+    const match = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/)
+    if (match) {
+      const lines = match[1].split('\n').filter(Boolean)
+      for (const line of lines) {
+        const glob = line.replace(/^\s*-\s*['"]?/, '').replace(/['"]?\s*$/, '')
+        if (glob) dirs.push(...expandGlob(root, glob))
+      }
+    }
+    return dirs
+  }
+
+  const pkgPath = join(root, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      const workspaces = Array.isArray(pkg.workspaces)
+        ? pkg.workspaces
+        : pkg.workspaces?.packages || []
+      for (const glob of workspaces) {
+        dirs.push(...expandGlob(root, glob))
+      }
+    } catch {}
+  }
+
+  return dirs
+}
+
+function expandGlob(root: string, pattern: string): string[] {
+  const clean = pattern.replace(/\/\*\*?$/, '').replace(/\*$/, '')
+  const baseDir = join(root, clean)
+
+  if (!existsSync(baseDir)) return []
+
+  try {
+    const entries = readdirSync(baseDir)
+    return entries
+      .map((entry) => join(baseDir, entry))
+      .filter((path) => {
+        try {
+          return statSync(path).isDirectory() && existsSync(join(path, 'package.json'))
+        } catch {
+          return false
+        }
+      })
+  } catch {
+    return []
+  }
+}
+
+export function scanWorkspace(root: string): DetectedWorkspace {
+  const type = detectMonorepoType(root)
+  const packageManager = detectPackageManager(root)
+
+  if (type === 'single') {
+    const project = detectProject(root)
+    return {
+      root,
+      type,
+      packageManager,
+      apps: project ? [project] : [],
+    }
+  }
+
+  const workspaceDirs = getWorkspaceDirs(root)
+  const apps: DetectedProject[] = []
+
+  const rootProject = detectProject(root)
+  if (rootProject) apps.push(rootProject)
+
+  for (const dir of workspaceDirs) {
+    if (dir === root) continue
+    const project = detectProject(dir)
+    if (project) apps.push(project)
+  }
+
+  return { root, type, packageManager, apps }
+}

package/cli/commands/detox.ts

@@ -0,0 +1,385 @@
+// sootsim detox — run existing detox suites against sootsim
+//
+// 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 a sootsim shell is reachable (auto-launches one if not)
+//  3. spawns jest with our preset baked in so `import ... from 'detox'`
+//     resolves to the sootsim 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$`.
+
+import { spawn } from 'child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
+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 { 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
+}
+
+const HELP = `
+rnxsim detox — run detox-style tests against an rnx shell
+
+usage:
+  rnxsim detox [testFiles...]        run all tests under e2e/, test/e2e/, or detox/
+  rnxsim detox --config <path>       use a specific jest config
+  rnxsim detox init                  scaffold sootsim-detox.config.cjs + sample test
+  rnxsim detox --watch               jest watch mode
+  rnxsim detox --headed              keep the rnx shell window visible
+  rnxsim detox -t <pattern>          pass a jest --testNamePattern
+  rnxsim detox --no-launch           skip auto-launching an rnx shell
+
+rnxsim detox auto-launches an rnx shell if none is running on the
+expected port. disable with --no-launch if you're managing the shell yourself.
+`
+
+export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP)
+    process.exit(0)
+  }
+
+  if (args[0] === 'init') {
+    return initDetoxProject()
+  }
+
+  const getFlag = (name: string) => {
+    const i = args.indexOf(name)
+    return i >= 0 ? args[i + 1] : undefined
+  }
+  const hasFlag = (name: string) => args.includes(name)
+
+  const watch = hasFlag('--watch')
+  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'
+    )
+      return false
+    return true
+  })
+  const passthroughJestFlags = args.filter(
+    (a) => a === '--runInBand' || a.startsWith('--maxWorkers='),
+  )
+
+  // test dir discovery. external test suites set SOOTSIM_TEST_DIR; otherwise
+  // we auto-detect the conventional locations.
+  const detoxDirs = ['e2e', 'test/e2e', 'detox']
+  let testDir: string | null = process.env.SOOTSIM_TEST_DIR
+    ? resolve(process.cwd(), process.env.SOOTSIM_TEST_DIR)
+    : null
+  if (!testDir) {
+    for (const dir of detoxDirs) {
+      const full = resolve(process.cwd(), dir)
+      if (existsSync(full)) {
+        testDir = full
+        break
+      }
+    }
+  }
+  if (!testDir) {
+    console.error(
+      `  error: no detox tests found. expected one of: ${detoxDirs.join(', ')}\n` +
+        `  run 'rnxsim detox init' to scaffold a starter suite.`,
+    )
+    process.exit(1)
+  }
+
+  // auto-launch: make sure a sootsim shell is reachable before running jest.
+  // Reuse the Maestro discovery path: scan local dev servers.
+  // and `sootsim open` the first match.
+  if (!noLaunch) {
+    await ensureShellRunning(port)
+  }
+
+  // build the jest command. prefer the user's config if they passed --config
+  // or if a sootsim-detox.config.cjs exists in cwd. otherwise point at our
+  // preset directly via --preset-free inline config.
+  const jestArgs: string[] = ['jest']
+  const localConfig =
+    configFlag ||
+    firstExisting(['sootsim-detox.config.cjs', 'jest.config.cjs', 'jest.config.js'])
+
+  let tempConfig: string | null = null
+  if (localConfig) {
+    jestArgs.push('--config', resolve(process.cwd(), localConfig))
+  } 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 = resolve(resolveDetoxDir(), 'jest-preset.cjs')
+    tempConfig = join(tmpdir(), `sootsim-detox-${process.pid}.config.cjs`)
+    const cfg = {
+      rootDir: testDir,
+      roots: ['<rootDir>'],
+      testMatch: ['<rootDir>/**/*.test.ts', '<rootDir>/**/*.test.js'],
+    }
+    writeFileSync(
+      tempConfig,
+      `module.exports = { ...require(${JSON.stringify(presetPath)}), ...${JSON.stringify(cfg)} }\n`,
+    )
+    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) {
+    jestArgs.push('--outputFile', process.env.SOOTSIM_JEST_OUTPUT_FILE)
+  } else if (wantsRegistration) {
+    resultsFile = join(tmpdir(), `sootsim-detox-results-${process.pid}.json`)
+    jestArgs.push('--json', '--outputFile', resultsFile)
+  }
+
+  jestArgs.push(...passthroughJestFlags)
+
+  // any positional test files get passed straight through
+  jestArgs.push(...positional)
+
+  console.log(`  rnxsim detox`)
+  console.log(`    test dir: ${testDir}`)
+  console.log(`    port:     ${port}${headed ? ' (headed)' : ''}`)
+  if (localConfig) console.log(`    config:   ${localConfig}`)
+
+  const child = spawn('npx', jestArgs, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      SOOTSIM_TEST_DIR: testDir,
+      SOOTSIM_PORT: String(port),
+      SOOTSIM_HEADED: headed ? '1' : '',
+      SOOTSIM_URL: process.env.SOOTSIM_URL || `http://localhost:${port}`,
+    },
+  })
+
+  // jest owns the browsers, and it only reaps them from its own signal and exit
+  // handlers. this process is the one a caller has a pid for, so a SIGTERM aimed
+  // at `sootsim detox` lands here and jest never hears about it: it is a
+  // grandchild (this -> npx -> jest), so it keeps running with no parent and
+  // every chrome it launched is orphaned for good. forward the signal instead of
+  // exiting out from under it, and let its exit code end this process.
+  const forward = (signal: NodeJS.Signals) => () => {
+    child.kill(signal)
+  }
+  const onTerm = forward('SIGTERM')
+  const onInt = forward('SIGINT')
+  process.on('SIGTERM', onTerm)
+  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)
+    })
+  })
+  process.off('SIGTERM', onTerm)
+  process.off('SIGINT', onInt)
+  if (tempConfig)
+    try {
+      unlinkSync(tempConfig)
+    } catch {}
+
+  if (wantsRegistration) {
+    const results = resultsFile ? readJestResults(resultsFile) : null
+    const origin = await resolveDefaultUploadOrigin()
+    const run = await registerRun({
+      origin,
+      kind: 'detox',
+      name: relative(process.cwd(), testDir) || 'e2e',
+      status: code === 0 ? 'passed' : 'failed',
+      summary: results
+        ? `${results.numPassedTests}/${results.numTotalTests} tests passed`
+        : null,
+      failureMessage: code === 0 ? null : (results?.firstFailure ?? null),
+      // tests map onto the row's step summary: total count + first failing
+      // index, same shape flow lanes fill from their step trace.
+      stepCount: results?.numTotalTests ?? null,
+      failedStepIndex: results?.firstFailedIndex ?? null,
+      durationMs: Date.now() - startedAt,
+      auth,
+    })
+    if (run) console.log(`  run: ${run.id}`)
+  }
+  process.exit(code)
+}
+
+type JestRunSummary = {
+  numTotalTests: number
+  numPassedTests: number
+  firstFailure: string | null
+  firstFailedIndex: number | null
+}
+
+// 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 {
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8')) as {
+      numTotalTests?: number
+      numPassedTests?: number
+      testResults?: Array<{
+        testResults?: Array<{
+          status?: string
+          fullName?: string
+          failureMessages?: string[]
+        }>
+      }>
+    }
+    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 ?? []) {
+        if (firstFailedIndex == null && test.status === 'failed') {
+          firstFailedIndex = index
+          const message = test.failureMessages?.[0]?.split('\n')[0]
+          firstFailure = [test.fullName, message].filter(Boolean).join(': ') || null
+        }
+        index += 1
+      }
+    }
+    if (typeof parsed.numTotalTests !== 'number') return null
+    return {
+      numTotalTests: parsed.numTotalTests,
+      numPassedTests: parsed.numPassedTests ?? 0,
+      firstFailure,
+      firstFailedIndex,
+    }
+  } catch {
+    return null
+  } finally {
+    if (!process.env.SOOTSIM_JEST_OUTPUT_FILE) {
+      try {
+        unlinkSync(file)
+      } catch {}
+    }
+  }
+}
+
+function firstExisting(names: string[]): string | null {
+  for (const n of names) {
+    if (existsSync(resolve(process.cwd(), n))) return n
+  }
+  return null
+}
+
+async function ensureShellRunning(port: number): Promise<void> {
+  const shellUrl = await discoverSootsimUrl()
+  if (shellUrl) return
+
+  console.warn(
+    `  warn: no rnx shell reachable on :${port}. start your app, then run \`rnxsim open <app-port>\`\n` +
+      `  or pass --no-launch if you're managing the shell yourself.`,
+  )
+}
+
+function initDetoxProject(): void {
+  const cwd = process.cwd()
+  const configPath = resolve(cwd, 'sootsim-detox.config.cjs')
+  if (existsSync(configPath)) {
+    console.log(`  skip: ${configPath} already exists`)
+  } else {
+    writeFileSync(
+      configPath,
+      `// rnxsim detox jest config.
+// extends the sootsim preset, which rewrites \`import ... from 'detox'\`
+// to the sootsim driver and keeps your jest transforms intact.
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  preset: 'rnxsim/detox/jest-preset',
+  rootDir: __dirname,
+  testMatch: ['<rootDir>/e2e/**/*.test.ts', '<rootDir>/e2e/**/*.test.js'],
+}
+`,
+    )
+    console.log(`  created ${configPath}`)
+  }
+
+  const e2eDir = resolve(cwd, 'e2e')
+  const samplePath = resolve(e2eDir, 'example.test.ts')
+  if (existsSync(samplePath)) {
+    console.log(`  skip: ${samplePath} already exists`)
+  } else {
+    mkdirSync(e2eDir, { recursive: true })
+    writeFileSync(
+      samplePath,
+      `// sample rnxsim detox test. resolve \`detox\` via the jest preset in
+// sootsim-detox.config.cjs — no extra imports required.
+
+import { by, device, element, expect, waitFor } from 'detox'
+
+describe('example', () => {
+  beforeAll(async () => {
+    await device.launchApp()
+  })
+
+  it('shows the welcome text', async () => {
+    await waitFor(element(by.text('Welcome'))).toBeVisible().withTimeout(5000)
+  })
+
+  it('taps a button by id', async () => {
+    await element(by.id('start-button')).tap()
+    await expect(element(by.id('home-screen'))).toBeVisible()
+  })
+})
+`,
+    )
+    console.log(`  created ${samplePath}`)
+  }
+
+  console.log(`\n  next:`)
+  console.log(`    rnxsim detox        # run the sample`)
+  console.log(`    rnxsim detox --watch`)
+  process.exit(0)
+}