rnxsim 0.1.369 → 0.1.370

package/cli/auth.ts

@@ -9,6 +9,7 @@
 // callers wanting an auth header: `authHeaderOrExit('upload')`.
 
 import { readSharedDesktopAuthSession } from '../src/auth/shared-session'
+import { rnxExit } from './run-rnx'
 
 export type CliApiKeyEnvName = 'RNX_API_KEY' | 'SOOTSIM_API_KEY'
 
@@ -151,5 +152,5 @@ export function authHeaderOrExit(commandLabel: string): {
       `    • run \`rnx login\` to sign in with your GH account\n` +
       `    • set RNX_API_KEY=sk_rnx_... (recommended for CI)\n\n`,
   )
-  process.exit(1)
+  rnxExit(1)
 }

package/cli/bin.ts

@@ -8,6 +8,7 @@
 
 import { rnxPublicBrand } from '../src/public-brand'
 import { parseArgs, TOP_LEVEL_RUNTIME_COMMANDS } from './parse-args'
+import { RnxExit } from './run-rnx'
 
 // `./help` is loaded lazily (only on help paths) — it statically pulls the full
 // CLI registry renderers and engine settings, which would otherwise add ~400ms
@@ -317,281 +318,290 @@ if (
 // is much harder to act on than this targeted message.
 exitIfStandaloneBlocked(command)
 
-if (TOP_LEVEL_RUNTIME_COMMANDS.has(command)) {
-  if (command === 'do') {
-    const { hasDoChain, runDoChain } = await import('./commands/do-chain')
-    if (hasDoChain(commandArgsWithSim)) {
-      await exitWithFlush(await runDoChain(commandArgsWithSim, { port }))
-    }
-  }
-  const { runInspect } = await import('./commands/inspect')
-  await runInspect([command, ...commandArgsWithSim], { port, verbose })
-} else {
-  switch (command) {
-    case 'assert': {
-      // stays outside the usual dispatcher — it spawns self to get the
-      // inner verb's --json payload, so it never needs the shared bridge
-      // machinery that lives inside runInspect.
-      const { runAssert } = await import('./commands/assert')
-      await runAssert(parsed.commandArgs)
-      break
-    }
-
-    case 'detox': {
-      const { runDetox } = await import('./commands/detox')
-      await runDetox(parsed.commandArgs, { port, verbose })
-      break
-    }
-
-    case 'maestro': {
-      const { runMaestro } = await import('./commands/maestro')
-      // Maestro forwards playback argv to the shared runner, so it must
-      // receive the global `--sim`. passing the bare
-      // parsed.commandArgs dropped an explicit `sootsim --sim <id> maestro
-      // …`, silently falling back to the current/saved sim (QA F21-4).
-      const code = await runMaestro(commandArgsWithSim, { port, verbose })
-      // bridge + dynamic imports leave handles open that keep node alive.
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'record': {
-      const { runRecord } = await import('./commands/record')
-      await runRecord(commandArgsWithSim, { port, verbose })
-      break
-    }
-
-    case 'film': {
-      const { runFilm } = await import('./commands/film')
-      // film chains the flow runner, which opens ws bridges + dynamic
-      // imports that keep node alive — exit explicitly like `flow` does.
-      const code = await runFilm(commandArgsWithSim, { port, verbose })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'storage': {
-      const { runStorage } = await import('./commands/storage')
-      const code = await runStorage(commandArgsWithSim, { port, verbose })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'state': {
-      const { runState } = await import('./commands/state')
-      const code = await runState(commandArgsWithSim, { port })
-      await exitWithFlush(code)
-    }
-
-    case 'reset': {
-      const { runReset } = await import('./commands/reset')
-      const code = await runReset(commandArgsWithSim, { port })
-      await exitWithFlush(code)
-    }
-
-    case 'perf': {
-      const { runPerf } = await import('./commands/perf')
-      const code = await runPerf(commandArgsWithSim, { port, verbose })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'screenshot': {
-      const { runScreenshotCommand } = await import('./commands/screenshot-command')
-      const code = await runScreenshotCommand(commandArgsWithSim, { port, verbose })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'camera': {
-      const { runCamera } = await import('./commands/camera')
-      const code = await runCamera(commandArgsWithSim, { port })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'mode': {
-      const { runMode } = await import('./commands/mode')
-      await runMode(commandArgsWithSim, { port, verbose })
-      break
-    }
-
-    case 'permissions': {
-      const { runPermissions } = await import('./commands/permissions')
-      const code = await runPermissions(commandArgsWithSim, { port, verbose })
-      await exitWithFlush(code)
-    }
-
-    case 'debug': {
-      const { runDebug } = await import('./commands/debug')
-      await runDebug(commandArgsWithSim, { port, verbose })
-      break
-    }
-
-    case 'timeline': {
-      const { runTimeline } = await import('./commands/timeline')
-      await runTimeline(commandArgsWithSim, { port, verbose })
-      break
-    }
-
-    case 'what-happened': {
-      const { runWhatHappened } = await import('./commands/what-happened')
-      await runWhatHappened(commandArgsWithSim, { port, verbose })
-      break
-    }
-
-    case 'open': {
-      const { runOpenCommand } = await import('./commands/control')
-      await runOpenCommand(commandArgsWithSim, { port })
-      break
-    }
-
-    case 'ios':
-    case 'android': {
-      const { runPlatformCommand } = await import('./commands/platform')
-      const code = await runPlatformCommand(command, commandArgsWithSim, { port })
-      await exitWithFlush(typeof code === 'number' ? code : 0)
-    }
-
-    case 'box': {
-      const { runBox } = await import('./commands/box')
-      await exitWithFlush(await runBox(commandArgsWithSim, { port, verbose }))
-    }
-
-    case 'use': {
-      const { runUseCommand } = await import('./commands/control')
-      await runUseCommand(commandArgsWithSim, { port })
-      break
-    }
-
-    case 'claim': {
-      const { runClaimCommand } = await import('./commands/control')
-      await runClaimCommand(commandArgsWithSim, { port })
-      break
-    }
-
-    case 'close': {
-      const { runCloseCommand } = await import('./commands/control')
-      await runCloseCommand(commandArgsWithSim, { port })
-      break
-    }
-
-    case 'device': {
-      const { runDeviceCommand } = await import('./commands/device')
-      await runDeviceCommand(commandArgsWithSim, { port })
-      break
-    }
-
-    case 'compat': {
-      const { runCompat } = await import('./commands/compat')
-      await runCompat(parsed.commandArgs)
-      break
-    }
-
-    case 'report-issue': {
-      const { runReportIssue } = await import('./commands/report-issue')
-      const code = await runReportIssue(parsed.commandArgs)
-      await exitWithFlush(code)
-    }
-
-    case 'desktop': {
-      const { runDesktop } = await import('./commands/desktop')
-      await runDesktop(parsed.commandArgs, { port, device })
-      break
-    }
-
-    case 'login': {
-      const { runLogin } = await import('./commands/login')
-      await runLogin(parsed.commandArgs)
-      break
-    }
-
-    case 'logout': {
-      const { runLogout } = await import('./commands/logout')
-      await runLogout()
-      break
-    }
-
-    case 'auth': {
-      const { runAuth } = await import('./commands/auth')
-      await runAuth(parsed.commandArgs)
-      break
-    }
-
-    case 'setup': {
-      const { runSetup } = await import('./commands/setup')
-      await runSetup(parsed.commandArgs)
-      break
-    }
-
-    case 'serve': {
-      const { runServe } = await import('./commands/serve')
-      await runServe(parsed.commandArgs, { port })
-      break
-    }
-
-    case 'daemon': {
-      const { runDaemon } = await import('./commands/daemon')
-      await runDaemon(parsed.commandArgs, { port })
-      break
-    }
-
-    case 'runtime': {
-      const { runRuntime } = await import('./commands/runtime')
-      await runRuntime(parsed.commandArgs)
-      break
-    }
-
-    case 'upgrade': {
-      const { runUpgrade } = await import('./commands/upgrade')
-      await runUpgrade(parsed.commandArgs)
-      break
-    }
-
-    case 'version': {
-      const { runVersion } = await import('./commands/version')
-      await runVersion(parsed.commandArgs)
-      break
-    }
-
-    case 'agent': {
-      const { runAgentCommand } = await import('./commands/agent')
-      const code = await runAgentCommand(parsed.commandArgs)
-      await exitWithFlush(code)
-    }
-
-    case 'agent-wrapper': {
-      const { runAgentWrapper } = await import('./commands/agent-wrapper')
-      const code = await runAgentWrapper(parsed.commandArgs)
-      await exitWithFlush(code)
-    }
-
-    case 'skill': {
-      const { runSkill } = await import('./commands/skills')
-      await runSkill(parsed.commandArgs)
-      break
-    }
-
-    case 'app-fonts': {
-      const { runAppFonts } = await import('./commands/app-fonts')
-      await runAppFonts(parsed.commandArgs)
-      break
-    }
-
-    case 'config': {
-      const { runConfig } = await import('./commands/config')
-      await runConfig(parsed.commandArgs)
-      break
-    }
-
-    case 'cleanup': {
-      const { runCleanup } = await import('./commands/cleanup')
-      const code = await runCleanup(parsed.commandArgs)
-      await exitWithFlush(code)
-    }
-
-    default: {
-      console.error(`  unknown command: ${command}`)
-      console.error(
-        `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
-      )
-      await exitWithFlush(1)
+// the command modules stop by throwing RnxExit rather than ending the
+// process, because the same command has to run in a box shell and in
+// workerd, where process.exit() cancels the whole request. this is the
+// host boundary that turns it back into a real exit code.
+try {
+  if (TOP_LEVEL_RUNTIME_COMMANDS.has(command)) {
+    if (command === 'do') {
+      const { hasDoChain, runDoChain } = await import('./commands/do-chain')
+      if (hasDoChain(commandArgsWithSim)) {
+        await exitWithFlush(await runDoChain(commandArgsWithSim, { port }))
+      }
+    }
+    const { runInspect } = await import('./commands/inspect')
+    await runInspect([command, ...commandArgsWithSim], { port, verbose })
+  } else {
+    switch (command) {
+      case 'assert': {
+        // stays outside the usual dispatcher — it spawns self to get the
+        // inner verb's --json payload, so it never needs the shared bridge
+        // machinery that lives inside runInspect.
+        const { runAssert } = await import('./commands/assert')
+        await runAssert(parsed.commandArgs)
+        break
+      }
+
+      case 'detox': {
+        const { runDetox } = await import('./commands/detox')
+        await runDetox(parsed.commandArgs, { port, verbose })
+        break
+      }
+
+      case 'maestro': {
+        const { runMaestro } = await import('./commands/maestro')
+        // Maestro forwards playback argv to the shared runner, so it must
+        // receive the global `--sim`. passing the bare
+        // parsed.commandArgs dropped an explicit `sootsim --sim <id> maestro
+        // …`, silently falling back to the current/saved sim (QA F21-4).
+        const code = await runMaestro(commandArgsWithSim, { port, verbose })
+        // bridge + dynamic imports leave handles open that keep node alive.
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'record': {
+        const { runRecord } = await import('./commands/record')
+        await runRecord(commandArgsWithSim, { port, verbose })
+        break
+      }
+
+      case 'film': {
+        const { runFilm } = await import('./commands/film')
+        // film chains the flow runner, which opens ws bridges + dynamic
+        // imports that keep node alive — exit explicitly like `flow` does.
+        const code = await runFilm(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'storage': {
+        const { runStorage } = await import('./commands/storage')
+        const code = await runStorage(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'state': {
+        const { runState } = await import('./commands/state')
+        const code = await runState(commandArgsWithSim, { port })
+        await exitWithFlush(code)
+      }
+
+      case 'reset': {
+        const { runReset } = await import('./commands/reset')
+        const code = await runReset(commandArgsWithSim, { port })
+        await exitWithFlush(code)
+      }
+
+      case 'perf': {
+        const { runPerf } = await import('./commands/perf')
+        const code = await runPerf(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'screenshot': {
+        const { runScreenshotCommand } = await import('./commands/screenshot-command')
+        const code = await runScreenshotCommand(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'camera': {
+        const { runCamera } = await import('./commands/camera')
+        const code = await runCamera(commandArgsWithSim, { port })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'mode': {
+        const { runMode } = await import('./commands/mode')
+        await runMode(commandArgsWithSim, { port, verbose })
+        break
+      }
+
+      case 'permissions': {
+        const { runPermissions } = await import('./commands/permissions')
+        const code = await runPermissions(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(code)
+      }
+
+      case 'debug': {
+        const { runDebug } = await import('./commands/debug')
+        await runDebug(commandArgsWithSim, { port, verbose })
+        break
+      }
+
+      case 'timeline': {
+        const { runTimeline } = await import('./commands/timeline')
+        await runTimeline(commandArgsWithSim, { port, verbose })
+        break
+      }
+
+      case 'what-happened': {
+        const { runWhatHappened } = await import('./commands/what-happened')
+        await runWhatHappened(commandArgsWithSim, { port, verbose })
+        break
+      }
+
+      case 'open': {
+        const { runOpenCommand } = await import('./commands/control')
+        await runOpenCommand(commandArgsWithSim, { port })
+        break
+      }
+
+      case 'ios':
+      case 'android': {
+        const { runPlatformCommand } = await import('./commands/platform')
+        const code = await runPlatformCommand(command, commandArgsWithSim, { port })
+        await exitWithFlush(typeof code === 'number' ? code : 0)
+      }
+
+      case 'box': {
+        const { runBox } = await import('./commands/box')
+        await exitWithFlush(await runBox(commandArgsWithSim, { port, verbose }))
+      }
+
+      case 'use': {
+        const { runUseCommand } = await import('./commands/control')
+        await runUseCommand(commandArgsWithSim, { port })
+        break
+      }
+
+      case 'claim': {
+        const { runClaimCommand } = await import('./commands/control')
+        await runClaimCommand(commandArgsWithSim, { port })
+        break
+      }
+
+      case 'close': {
+        const { runCloseCommand } = await import('./commands/control')
+        await runCloseCommand(commandArgsWithSim, { port })
+        break
+      }
+
+      case 'device': {
+        const { runDeviceCommand } = await import('./commands/device')
+        await runDeviceCommand(commandArgsWithSim, { port })
+        break
+      }
+
+      case 'compat': {
+        const { runCompat } = await import('./commands/compat')
+        await runCompat(parsed.commandArgs)
+        break
+      }
+
+      case 'report-issue': {
+        const { runReportIssue } = await import('./commands/report-issue')
+        const code = await runReportIssue(parsed.commandArgs)
+        await exitWithFlush(code)
+      }
+
+      case 'desktop': {
+        const { runDesktop } = await import('./commands/desktop')
+        await runDesktop(parsed.commandArgs, { port, device })
+        break
+      }
+
+      case 'login': {
+        const { runLogin } = await import('./commands/login')
+        await runLogin(parsed.commandArgs)
+        break
+      }
+
+      case 'logout': {
+        const { runLogout } = await import('./commands/logout')
+        await runLogout()
+        break
+      }
+
+      case 'auth': {
+        const { runAuth } = await import('./commands/auth')
+        await runAuth(parsed.commandArgs)
+        break
+      }
+
+      case 'setup': {
+        const { runSetup } = await import('./commands/setup')
+        await runSetup(parsed.commandArgs)
+        break
+      }
+
+      case 'serve': {
+        const { runServe } = await import('./commands/serve')
+        await runServe(parsed.commandArgs, { port })
+        break
+      }
+
+      case 'daemon': {
+        const { runDaemon } = await import('./commands/daemon')
+        await runDaemon(parsed.commandArgs, { port })
+        break
+      }
+
+      case 'runtime': {
+        const { runRuntime } = await import('./commands/runtime')
+        await runRuntime(parsed.commandArgs)
+        break
+      }
+
+      case 'upgrade': {
+        const { runUpgrade } = await import('./commands/upgrade')
+        await runUpgrade(parsed.commandArgs)
+        break
+      }
+
+      case 'version': {
+        const { runVersion } = await import('./commands/version')
+        await runVersion(parsed.commandArgs)
+        break
+      }
+
+      case 'agent': {
+        const { runAgentCommand } = await import('./commands/agent')
+        const code = await runAgentCommand(parsed.commandArgs)
+        await exitWithFlush(code)
+      }
+
+      case 'agent-wrapper': {
+        const { runAgentWrapper } = await import('./commands/agent-wrapper')
+        const code = await runAgentWrapper(parsed.commandArgs)
+        await exitWithFlush(code)
+      }
+
+      case 'skill': {
+        const { runSkill } = await import('./commands/skills')
+        await runSkill(parsed.commandArgs)
+        break
+      }
+
+      case 'app-fonts': {
+        const { runAppFonts } = await import('./commands/app-fonts')
+        await runAppFonts(parsed.commandArgs)
+        break
+      }
+
+      case 'config': {
+        const { runConfig } = await import('./commands/config')
+        await runConfig(parsed.commandArgs)
+        break
+      }
+
+      case 'cleanup': {
+        const { runCleanup } = await import('./commands/cleanup')
+        const code = await runCleanup(parsed.commandArgs)
+        await exitWithFlush(code)
+      }
+
+      default: {
+        console.error(`  unknown command: ${command}`)
+        console.error(
+          `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
+        )
+        await exitWithFlush(1)
+      }
     }
   }
+} catch (error) {
+  if (error instanceof RnxExit) await exitWithFlush(error.code)
+  throw error
 }
 
 await scheduleAutomaticCleanup()

package/cli/commands/app-fonts.ts

@@ -15,6 +15,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { gzipSync } from 'node:zlib'
 import { fetchAppFontFiles } from '../app-fonts'
+import { rnxExit } from '../run-rnx'
 
 type ManifestEntry = {
   url: string
@@ -40,7 +41,7 @@ async function stage(args: string[]): Promise<void> {
     console.error(
       '  usage: rnx app-fonts stage --wire <wire> --out-dir <dir> --manifest <path>',
     )
-    process.exit(1)
+    rnxExit(1)
   }
   if (!wire.trim()) {
     console.log('no app fonts declared — nothing to stage')
@@ -94,5 +95,5 @@ export async function runAppFonts(args: string[]): Promise<void> {
   }
   console.error(`  unknown app-fonts subcommand: ${sub ?? '(none)'}`)
   console.error('  available: stage')
-  process.exit(1)
+  rnxExit(1)
 }