rnxsim 0.1.369 → 0.1.371

package/cli/commands/box.ts

@@ -8,19 +8,41 @@
 
 import path from 'node:path'
 import { createInterface } from 'node:readline'
-import { createHarnessShell, HarnessProjectFs, PROJECT_MOUNT } from '@contrast/harness'
+import {
+  createHarnessShell,
+  HarnessProjectFs,
+  PROJECT_MOUNT,
+} from '@contrast/harness/shell'
 import { rnxPublicBrand } from '../../src/public-brand'
+import { authHeaderOrExit } from '../auth'
 import { findRepositoryPackageRoot } from '../setup-repository'
 import { resolvePlacement } from '../ws-bridge'
 import { CheckoutFilePlane, CheckoutRequiresGitError } from './box/checkout-plane'
+import {
+  CloudBoxError,
+  connectCloudBox,
+  createCloudBox,
+  heartbeatSession,
+  listCloudBoxes,
+  stopCloudBox,
+} from './box/cloud-box'
+import { sharePlane } from './box/plane-share'
 import { createRnxCommand } from './box/rnx-command'
+import { createSearchCommand } from './box/search-command'
+import type { HarnessShellResult } from '@contrast/harness/shell'
 
 interface BoxCommandOptions {
   port?: number
   verbose?: boolean
 }
 
-const CLOUD_SUBCOMMANDS = new Set(['create', 'ls', 'connect', 'stop', 'delete'])
+const CLOUD_SUBCOMMANDS = new Set(['connect'])
+
+// no default. a cloud box service has to be deployed before one can exist, and
+// defaulting to an origin that answers nothing would advertise a capability
+// that always fails.
+const ENDPOINT_ENV = 'RNX_BOX_ENDPOINT'
+const API_ORIGIN_ENV = 'RNX_API_ORIGIN'
 
 function usage(): void {
   const rnx = rnxPublicBrand.commandName
@@ -31,6 +53,12 @@ function usage(): void {
     ${rnx} box                     start a local box over the current checkout
     ${rnx} box create              create a cloud box and enter its shell
     ${rnx} box create --name=<n>   create a named cloud box
+    ${rnx} box create --endpoint=<url>
+                                   the box service to create it in, or set
+                                   ${ENDPOINT_ENV}
+    ${rnx} box ls                  cloud boxes running on this account
+    ${rnx} box stop --name=<n>     stop a cloud box and its billing
+    ${rnx} box delete --name=<n>   stop it and wipe its files
 
   a local box mounts this checkout at ${PROJECT_MOUNT}, gives you a shell with
   ls, cat, find, rg, sed, pipes and redirects, and registers ${rnx} itself as a
@@ -60,6 +88,11 @@ export async function runBox(
   }
 
   const subcommand = args.find((arg) => !arg.startsWith('-'))
+  if (subcommand === 'create') return runCloudBoxCreate(args, opts)
+  if (subcommand === 'stop' || subcommand === 'delete') {
+    return runCloudBoxStop(args, subcommand === 'delete')
+  }
+  if (subcommand === 'ls') return runCloudBoxList(args)
   if (subcommand !== undefined) {
     if (CLOUD_SUBCOMMANDS.has(subcommand)) {
       console.error(
@@ -78,6 +111,177 @@ export async function runBox(
   return runLocalBox(opts)
 }
 
+function flag(args: string[], name: string): string | undefined {
+  const inline = args.find((arg) => arg.startsWith(`--${name}=`))
+  if (inline) return inline.slice(name.length + 3)
+  const index = args.indexOf(`--${name}`)
+  if (index >= 0 && args[index + 1] && !args[index + 1].startsWith('-')) {
+    return args[index + 1]
+  }
+  return undefined
+}
+
+function apiOrigin(args: string[]): string {
+  return (
+    flag(args, 'api-origin') ??
+    process.env[API_ORIGIN_ENV]?.trim() ??
+    rnxPublicBrand.origin
+  )
+}
+
+function requireEndpoint(args: string[], label: string): string | null {
+  const endpoint = flag(args, 'endpoint') ?? process.env[ENDPOINT_ENV]?.trim()
+  if (endpoint) return endpoint
+  const rnx = rnxPublicBrand.commandName
+  console.error(
+    `  ${rnx} box ${label}: no cloud box service to talk to.\n` +
+      `  set ${ENDPOINT_ENV} or pass --endpoint=<url>.`,
+  )
+  return null
+}
+
+async function runCloudBoxStop(args: string[], purge: boolean): Promise<number> {
+  const rnx = rnxPublicBrand.commandName
+  const label = purge ? 'delete' : 'stop'
+  const endpoint = requireEndpoint(args, label)
+  if (!endpoint) return 1
+  const name =
+    flag(args, 'name') ?? path.basename(findRepositoryPackageRoot(process.cwd()) ?? '')
+  if (!name) {
+    console.error(`  ${rnx} box ${label}: which box? pass --name=<n>.`)
+    return 1
+  }
+  const { header } = authHeaderOrExit(`box ${label}`)
+  try {
+    const result = await stopCloudBox({
+      endpoint,
+      name,
+      apiKey: header.replace(/^Bearer /, ''),
+      purge,
+    })
+    console.log(
+      purge
+        ? `  deleted ${name}, freeing ${Number(result.freedBytes ?? 0)} bytes`
+        : `  stopped ${name}`,
+    )
+    return 0
+  } catch (error) {
+    if (error instanceof CloudBoxError) {
+      console.error(`  ${rnx} box ${label}: ${error.message}`)
+      return 1
+    }
+    throw error
+  }
+}
+
+async function runCloudBoxList(args: string[]): Promise<number> {
+  const rnx = rnxPublicBrand.commandName
+  const { header } = authHeaderOrExit('box ls')
+  try {
+    const boxes = await listCloudBoxes({
+      apiOrigin: apiOrigin(args),
+      apiKey: header.replace(/^Bearer /, ''),
+    })
+    if (boxes.length === 0) {
+      console.log(`  no cloud boxes running on this account`)
+      return 0
+    }
+    for (const box of boxes) {
+      const minutes = Math.round(box.meteredMs / 60_000)
+      console.log(`  ${box.name ?? box.id}  running ${minutes}m  since ${box.startedAt}`)
+    }
+    return 0
+  } catch (error) {
+    if (error instanceof CloudBoxError) {
+      console.error(`  ${rnx} box ls: ${error.message}`)
+      return 1
+    }
+    throw error
+  }
+}
+
+async function runCloudBoxCreate(
+  args: string[],
+  opts: BoxCommandOptions,
+): Promise<number> {
+  const rnx = rnxPublicBrand.commandName
+  const endpoint = flag(args, 'endpoint') ?? process.env[ENDPOINT_ENV]?.trim()
+  if (!endpoint) {
+    console.error(
+      `  ${rnx} box create: no cloud box service to create a box in.\n` +
+        `  set ${ENDPOINT_ENV} or pass --endpoint=<url>. \`${rnx} box\` runs the\n` +
+        `  same shell locally over this checkout.`,
+    )
+    return 1
+  }
+
+  const root = findRepositoryPackageRoot(process.cwd())
+  if (!root) {
+    console.error(
+      `  ${rnx} box create: no project here. a box is created from a checkout,\n` +
+        `  so run this inside a git repository that has a package.json.`,
+    )
+    return 1
+  }
+
+  const plane = new CheckoutFilePlane(root)
+  try {
+    await plane.refresh()
+  } catch (error) {
+    if (error instanceof CheckoutRequiresGitError) {
+      console.error(`  ${rnx} box create: ${error.message}`)
+      return 1
+    }
+    throw error
+  }
+
+  const name = flag(args, 'name') ?? path.basename(root)
+  // the ACCOUNT's key. the box service forwards it to /v1/rnx/sessions, which
+  // is what authenticates this caller, names the account, and starts the
+  // session the box is billed against.
+  const { header } = authHeaderOrExit('box create')
+  const apiKey = header.replace(/^Bearer /, '')
+
+  console.log(`  ...creating cloud box ${name}`)
+  let session: Awaited<ReturnType<typeof connectCloudBox>> | null = null
+  let heartbeat: { stop: () => void } | null = null
+  try {
+    const created = await createCloudBox({
+      endpoint,
+      name,
+      apiKey,
+      plane,
+      onProgress: opts.verbose
+        ? (seeded, total) => console.log(`  ...seeded ${seeded}/${total} files`)
+        : undefined,
+    })
+    console.log(`  ...seeded ${created.files} project files`)
+    // shown once and never stored: this process does not own a credential
+    // store, and inventing one here would be a second place secrets live.
+    console.log(`  ...box token (shown once): ${created.token}`)
+    console.log(`  ...accessing shell\n`)
+    session = await connectCloudBox({ endpoint, name, token: created.token })
+    // bank the wall clock while the shell is open. the box holds no account
+    // credential, so the client that is using it is what keeps the session
+    // alive; when this process dies the sweep closes it at the last heartbeat.
+    heartbeat = heartbeatSession({
+      apiOrigin: apiOrigin(args),
+      apiKey,
+      sessionId: created.sessionId,
+    })
+    return await repl(session, '')
+  } catch (error) {
+    if (error instanceof CloudBoxError) {
+      console.error(`  ${rnx} box create: ${error.message}`)
+      return 1
+    }
+    throw error
+  } finally {
+    heartbeat?.stop()
+    session?.close()
+  }
+}
+
 async function runLocalBox(opts: BoxCommandOptions): Promise<number> {
   // findRepositoryPackageRoot answers both halves of what a box needs: the
   // nearest package.json, and only when it sits inside a git repository. git
@@ -109,35 +313,90 @@ async function runLocalBox(opts: BoxCommandOptions): Promise<number> {
 
   const shell = createHarnessShell({
     projectFs: new HarnessProjectFs(plane),
-    commands: [createRnxCommand({ root, shellCwd: () => shell.cwd })],
+    commands: [
+      createRnxCommand({ root, shellCwd: () => shell.cwd }),
+      // overrides just-bash's JavaScript rg, which reads every file body
+      // through the plane. see search-command.ts for the numbers.
+      createSearchCommand({ root }),
+    ],
   })
 
   const relative = path.relative(root, process.cwd())
   console.log(`  ...starting local box`)
   console.log(`  ...mounting ${root} at ${PROJECT_MOUNT}`)
+
+  // authorize this checkout for the bridge daemon so a browser tab can reach
+  // this box's plane. deliberately NOT awaited: a box must not pay for a
+  // bridge that may not be there, and an older daemon never answers at all.
+  const shared = sharePlane(root, { port: opts.port })
+  // two boxes over one checkout is worth SAYING, not refusing. a person with
+  // two terminals in one project is doing something reasonable, and the plane
+  // re-reads the file list before every command, so neither box works from a
+  // stale one. what it does break is an agent mid-run, whose file set changes
+  // underneath it because something else is writing the tree. that is the wave
+  // case, and the wave's own isolation check is where a refusal belongs; this
+  // reports the fact so that check has something to refuse on.
+  void shared.settled.then((outcome) => {
+    if ('declined' in outcome) {
+      if (opts.verbose) console.log(`  ...plane not shared: ${outcome.declined}`)
+      return
+    }
+    if (outcome.holders > 1) {
+      console.error(
+        `\n  ${rnxPublicBrand.commandName} box: ${outcome.holders - 1} other box${
+          outcome.holders > 2 ? 'es are' : ' is'
+        } already open on this checkout.\n` +
+          `  writes from either land on the same files. that is fine for a person\n` +
+          `  with two terminals, and not fine for an agent, whose file set will\n` +
+          `  change underneath it mid-run.\n`,
+      )
+      return
+    }
+    if (opts.verbose) {
+      console.log(`  ...plane shared on the bridge (port ${outcome.port})`)
+    }
+  })
+
   console.log(`  ...accessing shell\n`)
   if (opts.verbose) {
     console.log(`  ${plane.index().size} project files indexed\n`)
   }
 
-  return repl(shell, plane, relative)
+  try {
+    // the checkout is shared with editors, agents, and the user's own terminal,
+    // so re-read the file set before every command rather than trusting a
+    // snapshot taken when the box started. a cloud box has no equivalent: its
+    // store is the box, and the box refreshes on its own side.
+    return await repl(shell, relative, () => plane.refresh())
+  } finally {
+    shared?.close()
+  }
+}
+
+// the REPL drives whatever holds the shell. locally that is an in-process
+// HarnessShell over this checkout; for a cloud box it is a socket to the box,
+// which holds both the files and the shell. same loop, because the only
+// difference is where exec runs.
+interface BoxSession {
+  readonly cwd: string
+  exec(command: string): Promise<HarnessShellResult>
 }
 
 async function repl(
-  shell: ReturnType<typeof createHarnessShell>,
-  plane: CheckoutFilePlane,
+  session: BoxSession,
   startRelative: string,
+  beforeCommand?: () => Promise<void>,
 ): Promise<number> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
 
   // enter where the user was standing, so `rnx box` from a subdirectory does
   // not silently teleport them to the project root.
   if (startRelative && !startRelative.startsWith('..')) {
-    await shell.exec(`cd ${JSON.stringify(startRelative)}`)
+    await session.exec(`cd ${JSON.stringify(startRelative)}`)
   }
 
   const prompt = () => {
-    rl.setPrompt(`${shell.cwd} > `)
+    rl.setPrompt(`${session.cwd} > `)
     rl.prompt()
   }
 
@@ -155,11 +414,8 @@ async function repl(
   const run = async (command: string) => {
     if (stopped) return
     try {
-      // the checkout is shared with editors, agents, and the user's own
-      // terminal, so re-read the file set before every command rather than
-      // trusting a snapshot taken when the box started.
-      await plane.refresh()
-      const result = await shell.exec(command)
+      await beforeCommand?.()
+      const result = await session.exec(command)
       if (result.text && result.text !== '(no output)') console.log(result.text)
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error))

package/cli/commands/config.ts

@@ -1,3 +1,4 @@
+import { rnxExit } from '../run-rnx'
 import { runTelemetry } from './telemetry'
 
 function printHelp(): void {
@@ -28,5 +29,5 @@ export async function runConfig(args: string[]): Promise<void> {
 
   console.error(`  unknown config command: ${sub ?? '(missing)'}`)
   printHelp()
-  process.exit(1)
+  rnxExit(1)
 }

package/cli/commands/control.ts

@@ -55,6 +55,7 @@ import {
 } from '../current-sim'
 import { getDriver } from '../drivers/registry'
 import { openUrl as openUrlInBrowser } from '../open-url'
+import { rethrowIfExit, rnxExit } from '../run-rnx'
 import {
   BridgeSimLockedError,
   bridgePortForShellBaseUrl,
@@ -387,7 +388,12 @@ async function resolveConnectionInputForCli(target: string): Promise<ResolvedDev
 
   if (registeredPort && registeredPort > 0) {
     const discovered = await probePort(registeredPort)
-    if (discovered) {
+    // a provisional bundle URL means the scanner's fast manifest probe got no
+    // answer and fell back to the generic `/index.bundle`. that is enough to
+    // LIST the server and not enough to open it, so hand the question to
+    // `resolveConnectionInput`, which asks the manifest again with a budget
+    // that fits a real dev server and returns the entry point the app names.
+    if (discovered && !discovered.bundleUrlProvisional) {
       return {
         bundleUrl: discovered.bundleUrl,
         port: discovered.port,
@@ -477,18 +483,18 @@ function parseOpenRuntimeConfig(args: string[]): SootSimConfig | undefined {
       const raw = args[i + 1]
       if (!raw) {
         console.error('  rnx open: --replace expects <module>=<file>')
-        process.exit(1)
+        rnxExit(1)
       }
       const eqIndex = raw.indexOf('=')
       if (eqIndex <= 0 || eqIndex === raw.length - 1) {
         console.error('  rnx open: --replace expects <module>=<file>')
-        process.exit(1)
+        rnxExit(1)
       }
       const moduleName = raw.slice(0, eqIndex).trim()
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim())
       if (!fs.existsSync(filePath)) {
         console.error(`  rnx open: replacement file not found: ${filePath}`)
-        process.exit(1)
+        rnxExit(1)
       }
       modules[moduleName] = { file: filePath }
       i++
@@ -502,7 +508,7 @@ function parseOpenRuntimeConfig(args: string[]): SootSimConfig | undefined {
       const eqIndex = raw ? raw.indexOf('=') : -1
       if (!raw || eqIndex <= 0 || eqIndex === raw.length - 1) {
         console.error('  rnx open: --remap expects <host:port>=<host:port>')
-        process.exit(1)
+        rnxExit(1)
       }
       remap[raw.slice(0, eqIndex).trim()] = raw.slice(eqIndex + 1).trim()
       i++
@@ -1338,7 +1344,7 @@ export async function runLinkCommand(args: string[], opts: ControlCommandOptions
   if (parsed.positional.length !== 1) {
     console.error('  rnx open: expected exactly one <url-or-route>')
     console.error('  examples: rnx open /settings  |  rnx open myapp://settings')
-    process.exit(1)
+    rnxExit(1)
   }
 
   const bridge = createBridgeFromParsed(parsed)
@@ -1353,7 +1359,7 @@ export async function runLinkCommand(args: string[], opts: ControlCommandOptions
       warningsCommand: `rnx get warnings 5${simHint}`,
       requestsCommand: `rnx get requests 5${simHint}`,
     })
-    process.exit(1)
+    rnxExit(1)
   } finally {
     bridge.close()
   }
@@ -1397,11 +1403,11 @@ export async function runOpenCommand(
     console.error(
       `  rnx open: --cdp-port must be a positive port number, got "${cdpPortArg}"`,
     )
-    process.exit(1)
+    rnxExit(1)
   }
   if (requestedProfileId && ephemeralProfile) {
     console.error('  rnx open: --profile cannot be combined with --ephemeral')
-    process.exit(1)
+    rnxExit(1)
   }
   const profileId = requestedProfileId ? ensureProfile(requestedProfileId).id : undefined
   const openInNewSim = args.includes('--new') || !!profileId || ephemeralProfile
@@ -1410,7 +1416,7 @@ export async function runOpenCommand(
     console.error(
       '  rnx open: --new, --profile, and --ephemeral cannot be combined with --sim',
     )
-    process.exit(1)
+    rnxExit(1)
   }
   const target = parsed.positional[0] || ''
 
@@ -1419,7 +1425,7 @@ export async function runOpenCommand(
       console.error(
         '  rnx open: deep links target the current app; remove --new, --profile, or --ephemeral',
       )
-      process.exit(1)
+      rnxExit(1)
     }
     await runLinkCommand(args, opts)
     return
@@ -1447,7 +1453,7 @@ export async function runOpenCommand(
         `  could not launch a browser: ${err instanceof Error ? err.message : String(err)}`,
       )
       console.error(`  open it yourself: ${target}`)
-      process.exit(1)
+      rnxExit(1)
     }
     console.log(
       isLocal
@@ -1492,7 +1498,7 @@ export async function runOpenCommand(
   const requestedDriverId = args.find((_, i) => args[i - 1] === '--driver') || ''
   if (requestedDriverId && !isDriverId(requestedDriverId)) {
     console.error(`  unknown driver "${requestedDriverId}" — run \`rnx list --drivers\``)
-    process.exit(1)
+    rnxExit(1)
   }
   const driverId: DriverId = isDriverId(requestedDriverId)
     ? requestedDriverId
@@ -1506,7 +1512,7 @@ export async function runOpenCommand(
   const driverHeadless = resolveDriverHeadless(args, driverId)
   if (cdpPort && driverId !== 'playwright') {
     console.error('  rnx open: --cdp-port is only honored by the playwright driver')
-    process.exit(1)
+    rnxExit(1)
   }
 
   // metro HMR mode. interactive opens default to hot=true so edits hot-apply
@@ -1520,7 +1526,7 @@ export async function runOpenCommand(
   const noHmrFlag = args.includes('--no-hmr')
   if (hotFlag && noHmrFlag) {
     console.error('  rnx open: --hot and --no-hmr cannot be combined')
-    process.exit(1)
+    rnxExit(1)
   }
   const hotMode = hotFlag ? true : noHmrFlag ? false : driverId !== 'playwright'
 
@@ -1532,7 +1538,7 @@ export async function runOpenCommand(
   if (deviceArg && !(deviceArg in devices)) {
     console.error(`  rnx open: unknown device "${deviceArg}"`)
     console.error(`  known devices: ${listSelectableDeviceModels().join(', ')}`)
-    process.exit(1)
+    rnxExit(1)
   }
   const deviceSpec = deviceArg ? devices[deviceArg as DeviceModel] : undefined
 
@@ -1544,7 +1550,7 @@ export async function runOpenCommand(
   const viewportMatch = viewportArg ? /^(\d+)x(\d+)$/.exec(viewportArg) : null
   if (viewportArg && !viewportMatch) {
     console.error(`  rnx open: --viewport must be <width>x<height>, got "${viewportArg}"`)
-    process.exit(1)
+    rnxExit(1)
   }
   const explicitViewport = viewportMatch
     ? { width: Number(viewportMatch[1]), height: Number(viewportMatch[2]) }
@@ -1662,7 +1668,7 @@ export async function runOpenCommand(
           warningsCommand: `rnx get warnings 5${simHint}`,
           requestsCommand: `rnx get requests 5${simHint}`,
         })
-        process.exit(1)
+        rnxExit(1)
       }
 
       if (!fallBackToNewSim && targetSim) {
@@ -1674,7 +1680,7 @@ export async function runOpenCommand(
         )
         if (!ready) {
           console.error('  timed out waiting for current sim to load target')
-          process.exit(1)
+          rnxExit(1)
         }
         ready.bridge.close()
         saveCurrentSimId(targetSim.id)
@@ -1706,7 +1712,7 @@ export async function runOpenCommand(
     console.error(
       '  could not resolve a stable owning process; refusing unsupervised sim host',
     )
-    process.exit(1)
+    rnxExit(1)
   }
   const simMatchesToken = (sim: BridgeSimInfo) =>
     sim.url?.includes(`inspectOpen=${token}`) ?? false
@@ -1714,7 +1720,7 @@ export async function runOpenCommand(
   const driver = getDriver(driverId)
   if (!driver) {
     console.error(`  unknown driver "${driverId}" — run \`rnx list --drivers\``)
-    process.exit(1)
+    rnxExit(1)
   }
   const connectWait = resolveDriverConnectWaitOptions()
   const result = await driver.launch({
@@ -1738,7 +1744,7 @@ export async function runOpenCommand(
   })
   if (!result.launched) {
     console.error(`  ${driver.name} driver: ${result.message}`)
-    process.exit(1)
+    rnxExit(1)
   }
   const outcome = await waitForSimMatchOrHostExit(
     parsed.wsPort,
@@ -1750,7 +1756,7 @@ export async function runOpenCommand(
   if (outcome.kind === 'host-exit') {
     printDriverDiagnosticLogTail(result)
     console.error(`  ${driver.name} host crashed — sim is no longer attached`)
-    process.exit(1)
+    rnxExit(1)
   }
   if (outcome.kind === 'timeout') {
     if (result.pid) {
@@ -1763,7 +1769,7 @@ export async function runOpenCommand(
     console.error(
       `  timed out after ${connectWait.timeoutMs}ms waiting for opened sim to connect`,
     )
-    process.exit(1)
+    rnxExit(1)
   }
   const match = outcome.sim
   saveCurrentSimId(match.id)
@@ -1801,7 +1807,7 @@ async function runUseLikeCommand(args: string[], opts: ControlCommandOptions = {
             `  refused: ${target.id} is locked by the active user (${secs}s) — that's a live human tab`,
           )
           console.error(`  run \`rnx open --new\` for a fresh investigation sim`)
-          process.exit(1)
+          rnxExit(1)
         }
         if (!force) {
           // another CLI agent leases it. don't hijack its target silently;
@@ -1813,20 +1819,21 @@ async function runUseLikeCommand(args: string[], opts: ControlCommandOptions = {
           console.error(
             `  \`sootsim use ${target.id} --force\` to take it, or \`rnx open --new\` for a fresh sim`,
           )
-          process.exit(1)
+          rnxExit(1)
         }
       }
       await bridge.focusSim(target.id)
       saveCurrentSimId(target.id)
       console.log(`  using: ${target.id}`)
     } catch (err) {
+      rethrowIfExit(err)
       console.error(`  use failed: ${err instanceof Error ? err.message : String(err)}`)
       await printBridgeFailureDiagnostics(bridge, {
         errorsCommand: `rnx get errors 5${simHint}`,
         warningsCommand: `rnx get warnings 5${simHint}`,
         requestsCommand: `rnx get requests 5${simHint}`,
       })
-      process.exit(1)
+      rnxExit(1)
     }
   } finally {
     bridge.close()
@@ -1871,10 +1878,10 @@ export async function runClaimCommand(args: string[], opts: ControlCommandOption
         const secs = Math.max(0, Math.round(err.lock.expiresInMs / 1000))
         console.error(`  claim failed: locked by ${err.lock.by} for ${secs}s more`)
         console.error(`  use --force to take it, or \`rnx open --new\` for a fresh sim`)
-        process.exit(1)
+        rnxExit(1)
       }
       console.error(`  claim failed: ${err instanceof Error ? err.message : String(err)}`)
-      process.exit(1)
+      rnxExit(1)
     }
   } finally {
     bridge.close()
@@ -2016,7 +2023,7 @@ export async function runCloseCommand(args: string[], opts: ControlCommandOption
         console.error(
           `  close failed: keep sim ${plan.missingExplicitKeepId} is not connected; not closing other sims`,
         )
-        process.exit(1)
+        rnxExit(1)
       }
       if (plan.targets.length === 0) {
         console.log(
@@ -2047,11 +2054,12 @@ export async function runCloseCommand(args: string[], opts: ControlCommandOption
       console.log(summary)
       if (result.remaining.length > 0) {
         console.error(`  close failed: still connected: ${result.remaining.join(', ')}`)
-        process.exit(1)
+        rnxExit(1)
       }
     } catch (err) {
+      rethrowIfExit(err)
       console.error(`  close failed: ${err instanceof Error ? err.message : String(err)}`)
-      process.exit(1)
+      rnxExit(1)
     } finally {
       bridge.close()
     }
@@ -2074,7 +2082,7 @@ export async function runCloseCommand(args: string[], opts: ControlCommandOption
       if (!closed) {
         await terminatePlaywrightHostsForSims(sims, [target.id])
         console.error(`  close failed: ${target.id} is still connected`)
-        process.exit(1)
+        rnxExit(1)
       }
       await terminatePlaywrightHostsForSims(sims, [target.id])
       if (readCurrentSimId() === target.id) {
@@ -2083,13 +2091,14 @@ export async function runCloseCommand(args: string[], opts: ControlCommandOption
       }
       console.log(`  closed: ${target.id}`)
     } catch (err) {
+      rethrowIfExit(err)
       console.error(`  close failed: ${err instanceof Error ? err.message : String(err)}`)
       await printBridgeFailureDiagnostics(bridge, {
         errorsCommand: `rnx get errors 5${simHint}`,
         warningsCommand: `rnx get warnings 5${simHint}`,
         requestsCommand: `rnx get requests 5${simHint}`,
       })
-      process.exit(1)
+      rnxExit(1)
     }
   } finally {
     bridge.close()