rnxsim 0.1.351 → 0.1.353

package/cli/commands/setup.ts

@@ -1,36 +1,44 @@
-// sootsim setup — the single guided machine and repository onboarding flow.
+// rnx setup owns the optional machine and repository choices. rnx itself
+// works without project setup; bare first-run onboarding launches ConnectRN
+// during this flow and leaves the repository choice until the end.
 
-import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import {
-  COMPAT_RESULT_CAVEAT,
-  formatDetailedScanLines,
-  formatScanCounts,
-  scanDeps,
-  type ScanResult,
-} from '@sootsim/compat/web'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
 import { getCliVersion } from '../../src/cli-version'
 import {
   readActiveRuntime,
   readPrivacyPreferences,
+  readSimulatorDriverPreference,
   runtimeDir,
+  type SimulatorDriverPreference,
+  writeOnboardingPreferences,
   writePrivacyPreferences,
 } from '../../src/home-paths'
 import { sootsimRuntime } from '../../src/runtime-delivery'
-import { confirm } from '../prompt'
+import { findDesktopCompanion } from '../desktop-companion'
+import { confirm, select } from '../prompt'
 import {
   applyRepositorySetup,
-  detectPreferredPackageManager,
-  findPackageRoot,
+  findRepositoryPackageRoot,
   formatRepositoryOperations,
   planRepositorySetup,
   type RepositorySetupPlan,
 } from '../setup-repository'
 import { trackCliError } from '../telemetry'
+import {
+  accent,
+  bold,
+  muted,
+  printBrand,
+  printPromptBlock,
+  success,
+  withSpinner,
+} from '../ui'
+import { runOpenCommand } from './control'
 import { daemonInstall, getDaemonServiceStatus } from './daemon'
 import { isAgentEnv } from './inspect/env'
+import { runInstallDesktop } from './install-desktop'
 
 interface SetupOptions {
   appDir: string
@@ -41,107 +49,155 @@ interface SetupOptions {
   service: boolean | undefined
   repository: boolean | undefined
   productAnalytics: boolean | undefined
+  simulatorDriver: SimulatorDriverPreference | undefined
+}
+
+interface SetupRunOptions {
+  launchConnectRN?: boolean
 }
 
 export interface SetupResult {
   runtimeVersion: string
   serviceInstalled: boolean
   repositoryPrepared: boolean
+  simulatorDriver: SimulatorDriverPreference
 }
 
-export async function runSetup(args: string[]): Promise<SetupResult | undefined> {
+export async function runSetup(
+  args: string[],
+  runOptions: SetupRunOptions = {},
+): Promise<SetupResult | undefined> {
   if (args.includes('--help') || args.includes('-h')) {
     printHelp()
     return
   }
 
   const options = parseSetupOptions(args)
+  const launchConnectRN =
+    runOptions.launchConnectRN ??
+    (!options.ci &&
+      !options.yes &&
+      !options.json &&
+      !options.dryRun &&
+      process.stdin.isTTY)
   try {
-    const packageRoot = findPackageRoot(options.appDir)
+    printIntro(options)
+
+    const packageRoot = findRepositoryPackageRoot(options.appDir)
     const serviceStatus = getDaemonServiceStatus()
     const privacy = readPrivacyPreferences()
     const service = await decideService(options, serviceStatus)
-    const repository = await decideRepository(options, packageRoot)
-    const productAnalytics = await decidePrivacy(options, privacy)
-    const crashReports = false
-
-    const manifest = await sootsimRuntime.fetchManifest()
-    const resolvedRuntime = sootsimRuntime.resolveVersion(manifest, { channel: 'stable' })
-    const runtimeVersion = resolvedRuntime.version
+    if (!service && !serviceStatus.installed && !options.json) {
+      console.log(`  ${muted('Enable it later with')} ${accent('rnx daemon install')}`)
+    }
+    const simulatorDriver = await decideSimulatorDriver(options)
+
+    const manifest = options.json
+      ? await sootsimRuntime.fetchManifest()
+      : await withSpinner('Checking the rnx runtime', () =>
+          sootsimRuntime.fetchManifest(),
+        )
+    const runtimeVersion = sootsimRuntime.resolveVersion(manifest, {
+      channel: 'stable',
+    }).version
     const cliVersion = getCliVersion()
     if (cliVersion === '0.0.0') {
       throw new Error('could not resolve the installed rnx CLI version')
     }
 
-    let repositoryPlan: RepositorySetupPlan | null = null
-    if (repository && packageRoot) {
-      repositoryPlan = planRepositorySetup({
-        appDir: packageRoot,
-        cliVersion,
-      })
+    let runtimeInstalled = false
+    if (!options.dryRun) {
+      const activeRuntime = readActiveRuntime()
+      const install = () =>
+        sootsimRuntime.install({
+          version: runtimeVersion,
+          channel: 'stable',
+          setActive: true,
+          protectVersions: activeRuntime ? [activeRuntime] : [],
+        })
+      const result = options.json
+        ? await install()
+        : await withSpinner(`Preparing runtime ${runtimeVersion}`, install)
+      runtimeInstalled = result.installed
     }
 
-    printIntro(options)
-    printMachineSection(options, serviceStatus, service, runtimeVersion)
-    printRepositorySection(options, packageRoot, repositoryPlan)
-    printPrivacySection(options, productAnalytics)
+    let serviceInstalled = serviceStatus.installed
+    if (service && !serviceStatus.installed && !options.dryRun) {
+      if (options.json) {
+        await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
+      } else {
+        console.log(`\n  ${accent('◆')} ${bold('Enabling the background service')}`)
+        await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
+      }
+      serviceInstalled = true
+    }
 
-    let installed = false
-    if (!options.dryRun) {
-      const activeRuntime = readActiveRuntime()
-      const result = await sootsimRuntime.install({
-        version: runtimeVersion,
-        channel: 'stable',
-        setActive: true,
-        protectVersions: activeRuntime ? [activeRuntime] : [],
-      })
-      installed = result.installed
+    if (simulatorDriver === 'electron' && !options.dryRun && !findDesktopCompanion()) {
+      await runInstallDesktop(['--yes'])
+    }
+
+    if (launchConnectRN) {
+      console.log(`\n  ${accent('◆')} Opening ConnectRN`)
+      await runOpenCommand([
+        'ConnectRN',
+        '--driver',
+        simulatorDriver,
+        '--no-describe',
+        '--quiet',
+      ])
     }
 
-    if (repositoryPlan) {
+    const productAnalytics = await decidePrivacy(options, privacy)
+    const crashReports = false
+
+    const repositoryPlan = packageRoot
+      ? planRepositorySetup({ appDir: packageRoot, cliVersion })
+      : null
+    const repository = await decideRepository(options, repositoryPlan)
+    if (repository && repositoryPlan) {
+      if (!options.json) {
+        for (const operation of formatRepositoryOperations(repositoryPlan)) {
+          console.log(`  ${muted(options.dryRun ? 'Would run' : 'Running')} ${operation}`)
+        }
+      }
       await applyRepositorySetup(repositoryPlan, {
         dryRun: options.dryRun,
         json: options.json,
       })
     }
 
-    let serviceInstalled = serviceStatus.installed
-    if (service && !serviceStatus.installed && !options.dryRun) {
-      await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
-      serviceInstalled = true
-    }
-
     if (!options.dryRun) {
       writePrivacyPreferences({ productAnalytics, crashReports })
+      writeOnboardingPreferences(simulatorDriver)
     }
 
-    const scan = packageRoot ? scanPackage(packageRoot) : null
-    printCompatibilitySection(options, scan)
-
     const result: SetupResult = {
       runtimeVersion,
       serviceInstalled,
-      repositoryPrepared: repositoryPlan !== null,
+      repositoryPrepared: repository,
+      simulatorDriver,
     }
-    const cache = runtimeCacheMetadata(runtimeVersion)
     if (options.json) {
       console.log(
         JSON.stringify(
           {
             ...result,
-            runtimeInstalled: options.dryRun ? false : installed,
+            runtimeInstalled,
             dryRun: options.dryRun,
-            cache,
-            repositoryOperations: repositoryPlan
-              ? formatRepositoryOperations(repositoryPlan)
-              : [],
+            cache: runtimeCacheMetadata(runtimeVersion),
+            repositoryOperations:
+              repository && repositoryPlan
+                ? formatRepositoryOperations(repositoryPlan)
+                : [],
           },
           null,
           2,
         ),
       )
     } else {
-      printReadySection(repositoryPlan)
+      console.log(
+        `\n  ${success('✓')} ${launchConnectRN ? 'ConnectRN is open. ' : ''}rnx is ready.`,
+      )
     }
 
     return result
@@ -157,20 +213,30 @@ function parseSetupOptions(args: string[]): SetupOptions {
   if (appIndex >= 0 && (!appArg || appArg.startsWith('-'))) {
     throw new Error('--app requires a directory')
   }
-  const service = readBooleanFlag(args, '--service', '--no-service')
-  const repository = readBooleanFlag(args, '--repo', '--no-repo')
   return {
     appDir: path.resolve(appArg ?? process.cwd()),
     ci: args.includes('--ci') || isAgentEnv(),
     dryRun: args.includes('--dry-run'),
     json: args.includes('--json'),
     yes: args.includes('--yes') || args.includes('-y'),
-    service,
-    repository,
+    service: readBooleanFlag(args, '--service', '--no-service'),
+    repository: readBooleanFlag(args, '--repo', '--no-repo'),
     productAnalytics: readOnOffFlag(args, '--analytics'),
+    simulatorDriver: readSimulatorDriverFlag(args),
   }
 }
 
+function readSimulatorDriverFlag(args: string[]): SimulatorDriverPreference | undefined {
+  const desktop = args.includes('--desktop')
+  const browser = args.includes('--browser')
+  if (desktop && browser) {
+    throw new Error('--desktop and --browser cannot be used together')
+  }
+  if (desktop) return 'electron'
+  if (browser) return 'playwright'
+  return undefined
+}
+
 function readBooleanFlag(
   args: string[],
   positive: string,
@@ -202,26 +268,59 @@ async function decideService(
     if (options.service === true) throw new Error('--ci cannot install a machine service')
     return false
   }
-  if (!status.supported) return false
-  if (status.installed && options.service === undefined) return true
+  if (!status.supported) {
+    if (!options.json) {
+      printPromptBlock('Background service', [
+        'The persistent service is currently available on macOS and Linux.',
+        'rnx will start the bridge when needed on this platform.',
+      ])
+    }
+    return false
+  }
+  if (status.installed && options.service === undefined) {
+    if (!options.json) console.log(`  ${success('✓')} Background service is ready`)
+    return true
+  }
   if (options.service !== undefined) return options.service
   if (options.yes) return true
   requireInteractive(options, '--service or --no-service')
-  return confirm('Install the background service and shared managed runtime?', true)
+  printPromptBlock('Background service', [
+    'Keeps the local bridge and runtime ready between commands.',
+    'Agent inspection, interaction, and test commands start much faster.',
+  ])
+  return confirm('Enable the background service?', true)
 }
 
-async function decideRepository(
+async function decideSimulatorDriver(
   options: SetupOptions,
-  packageRoot: string | null,
-): Promise<boolean> {
-  if (!packageRoot) {
-    if (options.repository === true) throw new Error('--repo requires a package.json')
-    return false
-  }
-  if (options.repository !== undefined) return options.repository
-  if (options.yes) return true
-  requireInteractive(options, '--repo or --no-repo')
-  return confirm(`Prepare ${packageRoot} for reproducible rnx runs?`, true)
+): Promise<SimulatorDriverPreference> {
+  if (options.simulatorDriver) return options.simulatorDriver
+  const current = readSimulatorDriverPreference()
+  if (current) return current
+  if (options.ci || options.yes) return 'playwright'
+  requireInteractive(options, '--desktop or --browser')
+  const desktopDescription =
+    process.platform === 'darwin'
+      ? 'Desktop downloads a DMG and installs rnx.app.'
+      : process.platform === 'win32'
+        ? 'Desktop downloads and runs the rnx installer.'
+        : 'Desktop downloads the matching rnx AppImage.'
+  const desktopChoice =
+    process.platform === 'darwin'
+      ? 'Desktop app            Installs rnx.app from a DMG'
+      : process.platform === 'win32'
+        ? 'Desktop app            Runs the rnx installer'
+        : 'Desktop app            Installs the matching AppImage'
+  printPromptBlock('Simulator window', [
+    'Browser opens immediately in an isolated Chrome window.',
+    desktopDescription,
+    'The Desktop app opens in a dedicated native window.',
+  ])
+  const choice = await select('Where should rnx open?', [
+    'Browser (recommended)  No additional download',
+    desktopChoice,
+  ])
+  return choice === 0 ? 'playwright' : 'electron'
 }
 
 async function decidePrivacy(
@@ -231,10 +330,32 @@ async function decidePrivacy(
   if (options.productAnalytics !== undefined) return options.productAnalytics
   if (current.configured) return current.productAnalytics
   if (options.yes || options.ci || !process.stdin.isTTY) return false
-  return confirm(
-    'Share anonymous package incompatibilities and error classes to improve rnx?',
-    false,
-  )
+  printPromptBlock('Private by default', [
+    'Diagnostics stay off unless you opt in.',
+    'Reports can contain package compatibility or an error class.',
+    'They never contain your code or app data.',
+  ])
+  return confirm('Share bounded diagnostics to improve rnx?', false)
+}
+
+async function decideRepository(
+  options: SetupOptions,
+  plan: RepositorySetupPlan | null,
+): Promise<boolean> {
+  if (!plan) {
+    if (options.repository === true) {
+      throw new Error('--repo requires a package.json inside a Git repository')
+    }
+    return false
+  }
+  if (plan.operations.length === 0) return true
+  if (options.repository !== undefined) return options.repository
+  if (options.yes || options.ci || !process.stdin.isTTY) return false
+  printPromptBlock('Share rnx with your team', [
+    'rnx already works here with no project setup.',
+    'This only adds an exact rnxsim dev dependency and an rnx script for teammates.',
+  ])
+  return confirm(`Add rnx to ${path.basename(plan.appDir)}?`, false)
 }
 
 function requireInteractive(options: SetupOptions, flags: string): void {
@@ -242,16 +363,6 @@ function requireInteractive(options: SetupOptions, flags: string): void {
   throw new Error(`non-interactive setup requires ${flags}, or --yes to accept defaults`)
 }
 
-function scanPackage(packageRoot: string): ScanResult {
-  const parsed: unknown = JSON.parse(
-    fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
-  )
-  if (!parsed || typeof parsed !== 'object') {
-    throw new Error('package.json must contain an object')
-  }
-  return scanDeps(parsed)
-}
-
 function runtimeCacheMetadata(runtimeVersion: string) {
   const platform = os.platform()
   const arch = os.arch()
@@ -264,89 +375,16 @@ function runtimeCacheMetadata(runtimeVersion: string) {
 
 function printIntro(options: SetupOptions): void {
   if (options.json) return
-  console.log(`\n  rnx setup`)
-}
-
-function printMachineSection(
-  options: SetupOptions,
-  status: ReturnType<typeof getDaemonServiceStatus>,
-  service: boolean,
-  runtimeVersion: string,
-): void {
-  if (options.json) return
-  console.log(`\n  1. machine`)
-  console.log(`     stable runtime: ${runtimeVersion}`)
-  console.log(
-    `     background service: ${status.supported ? (service ? 'install' : 'skip') : 'unsupported on this platform'}`,
-  )
-}
-
-function printRepositorySection(
-  options: SetupOptions,
-  packageRoot: string | null,
-  plan: RepositorySetupPlan | null,
-): void {
-  if (options.json) return
-  console.log(`\n  2. repository`)
-  if (!packageRoot) {
-    console.log(`     no package.json found; repository preparation skipped`)
-    return
-  }
-  if (!plan) {
-    console.log(`     skipped for ${packageRoot}`)
-    return
-  }
-  console.log(`     package manager: ${detectPreferredPackageManager(packageRoot)}`)
-  for (const operation of formatRepositoryOperations(plan)) {
-    console.log(`     ${options.dryRun ? 'would run' : 'run'}: ${operation}`)
-  }
-}
-
-function printPrivacySection(options: SetupOptions, productAnalytics: boolean): void {
-  if (options.json) return
-  console.log(`\n  3. privacy`)
-  console.log(`     bounded diagnostics: ${productAnalytics ? 'on' : 'off'}`)
-  console.log(`       package name/version/unsupported API or error class only`)
-  console.log(
-    `     source, paths, project names, app content, identity, and command usage are never included`,
-  )
-}
-
-function printCompatibilitySection(options: SetupOptions, scan: ScanResult | null): void {
-  if (options.json) return
-  console.log(`\n  4. compatibility`)
-  if (!scan) {
-    console.log(`     no package.json found; run \`rnx compat\` inside an app later`)
-    return
-  }
-  console.log(`     ${formatScanCounts(scan)}`)
-  for (const line of formatDetailedScanLines(scan)) console.log(`     ${line}`)
-  console.log(`     ${COMPAT_RESULT_CAVEAT}`)
-}
-
-function printReadySection(repository: RepositorySetupPlan | null): void {
-  console.log(`\n  5. ready`)
-  if (repository) {
-    const command =
-      repository.packageManager === 'bun'
-        ? 'bun run sootsim'
-        : `${repository.packageManager} run rnx`
-    console.log(`     start your app normally, then ${command} -- <port>`)
-  } else {
-    console.log(`     start your app normally, then rnx open <port>`)
-  }
-  console.log(`     useful next commands: rnx describe; rnx get errors; rnx compat`)
-  console.log(
-    `     install agent skills with \`rnx skill install\`, then start a new session`,
-  )
-  console.log(
-    `     if a concrete rnx seam is missing or broken, preview \`rnx report-issue\` and confirm separately`,
-  )
+  printBrand('Run any React Native app in a local simulator. No project setup required.')
 }
 
 function printHelp(): void {
   console.log(`
-rnx setup — configure a machine and optionally prepare the current repository
+rnx setup - configure optional local conveniences
+
+rnx works without project setup. This command can enable the faster background
+service, choose Browser or Desktop, configure private diagnostics, and optionally
+add an exact rnxsim dependency plus an rnx script for teammates.
 
 usage:
   rnx setup
@@ -354,16 +392,17 @@ usage:
   rnx setup --ci --yes --json
   rnx setup --dry-run --yes
 
-decisions:
+choices:
   --service | --no-service
-  --repo | --no-repo
+  --desktop | --browser
   --analytics on|off
+  --repo | --no-repo
 
 automation:
-  --yes       accept setup defaults; diagnostics remain off unless explicitly enabled
+  --yes       accept recommended machine defaults; diagnostics and repo changes stay off
   --ci        never prompt or install a background service
-  --json      emit runtime/cache metadata as JSON
-  --dry-run   print exact repository operations without changing the machine
-  --app DIR   use DIR as the repository search start
+  --json      emit runtime and cache metadata as JSON
+  --dry-run   show choices and repository operations without changing anything
+  --app DIR   inspect DIR for an optional repository installation
 `)
 }

package/cli/commands/welcome.ts

@@ -1,66 +1,17 @@
-import { scanDevServers, type DiscoveredServer } from '../../scripts/dev-server-scanner'
-import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
-import { readPrivacyPreferences } from '../../src/home-paths'
+import { isOnboardingComplete } from '../../src/home-paths'
 import { canPromptForPrivacyChoice } from '../privacy'
-import { select } from '../prompt'
-import { createBridge } from '../ws-bridge'
+import { printBrand } from '../ui'
 import { runOpenCommand } from './control'
-
-function serverLabel(server: DiscoveredServer): string {
-  return `${server.projectName?.trim() || server.framework} on :${server.port}`
-}
+import { runSetup } from './setup'
 
 export async function runWelcome(): Promise<number> {
-  const privacy = readPrivacyPreferences()
-  console.log('\n  welcome to rnx')
-  console.log(
-    `  diagnostics: ${privacy.configured && privacy.productAnalytics ? 'bounded opt-in on' : 'off until you opt in'}`,
-  )
-  console.log('  looking for a running React Native app…')
-
-  const discovered = await scanDevServers({
-    excludePorts: [DEFAULT_SOOTSIM_BRIDGE_PORT],
-  })
-  const ordered = [...discovered].sort((a, b) => a.port - b.port)
-  if (ordered.length === 0) {
-    console.error('  no running React Native development server found.')
-    console.error('  start your app normally, then run `npx rnxsim` again.')
-    return 1
+  if (!isOnboardingComplete() && canPromptForPrivacyChoice()) {
+    await runSetup([], { launchConnectRN: true })
+    return 0
   }
-  if (ordered.length > 1 && !canPromptForPrivacyChoice()) {
-    console.error('  multiple React Native development servers found.')
-    for (const server of ordered) {
-      console.error(`  ${serverLabel(server)}: rnx open ${server.port}`)
-    }
-    console.error('  choose one explicitly; automated runs do not guess.')
-    return 1
-  }
-  const selectedIndex =
-    ordered.length === 1
-      ? 0
-      : await select('which running app should rnx open?', ordered.map(serverLabel))
-  const selected = ordered[selectedIndex]
-  if (!selected) throw new Error('rnx app selection returned an invalid choice')
 
-  console.log(`  found ${serverLabel(selected)} · opening simulator…`)
-  const bridgePort = await runOpenCommand([selected.bundleUrl])
-  if (bridgePort !== undefined) {
-    const { runInspect } = await import('./inspect')
-    await runInspect(['wait', 'ready', '--max-ms', '120000'], { port: bridgePort })
-    const bridge = createBridge(bridgePort, { commandTimeoutMs: 45_000 })
-    try {
-      const frame: unknown = await bridge.send({ type: 'screenshot' })
-      const pngPrefix = 'data:image/png;base64,'
-      if (
-        typeof frame !== 'string' ||
-        !frame.startsWith(pngPrefix) ||
-        frame.length <= pngPrefix.length
-      ) {
-        throw new Error('the simulator connected but did not produce a visible app frame')
-      }
-    } finally {
-      bridge.close()
-    }
-  }
+  printBrand('Run any React Native app in a local simulator.')
+  console.log(`\n  Opening ConnectRN`)
+  await runOpenCommand(['ConnectRN', '--no-describe', '--quiet'])
   return 0
 }