rnxsim 0.1.408 → 0.1.409

package/cli/commands/assert.ts

@@ -15,6 +15,7 @@
 
 import { spawn } from 'child_process'
 import { rnxExit } from '../run-rnx'
+import { rnxSelfInvocation } from '../self-invocation'
 
 // READ_VERBS lists every command whose stdout we know is valid JSON under
 // --json. keeping this explicit means `rnx assert tap 100 200` fails
@@ -161,14 +162,13 @@ interface VerbResult {
 }
 
 async function runVerbOnce(verbArgs: string[]): Promise<VerbResult> {
-  // re-invoke self using whichever entrypoint is actually running (bin.ts
-  // in dev, dist-cli/bin.js when installed). running the real bin keeps us
-  // honest — every code path the user's verb would take, assert takes too.
-  const binPath = process.argv[1]
-  const args = [binPath, ...verbArgs, '--json']
+  // re-invoke self through the real CLI entry, so every code path the user's
+  // verb would take, assert takes too.
+  const { executable, prefixArgs } = rnxSelfInvocation()
+  const args = [...prefixArgs, ...verbArgs, '--json']
 
   return new Promise<VerbResult>((resolve) => {
-    const proc = spawn(process.execPath, args, {
+    const proc = spawn(executable, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: process.env,
     })

package/cli/commands/box/rnx-command.ts

@@ -11,17 +11,9 @@ import path from 'node:path'
 import { defineCommand, type CustomCommand } from '@rnx/box/shell'
 import { PROJECT_MOUNT } from '@rnx/box/shell'
 import { rnxPublicBrand } from '../../../src/public-brand'
+import { rnxSelfInvocation } from '../../self-invocation'
 import { RNX_PLACEMENT_ENV } from '../../ws-bridge'
 
-// the standalone binary is its own entry; the npm package runs through node
-// with the CLI as argv[1]. this is the same shape bin.ts uses to respawn
-// itself for automatic cleanup.
-function selfInvocation(): { command: string; prefix: string[] } {
-  const entry = process.argv[1]
-  if (!entry) return { command: process.execPath, prefix: [] }
-  return { command: process.execPath, prefix: [entry] }
-}
-
 // map a shell path under /project back onto the real checkout, so a child
 // process started from `cd src && rnx describe` sees the directory the user
 // is actually standing in.
@@ -36,8 +28,8 @@ export function createRnxCommand(options: {
   shellCwd: () => string
 }): CustomCommand {
   return defineCommand(rnxPublicBrand.commandName, async (args) => {
-    const { command, prefix } = selfInvocation()
-    const child = spawn(command, [...prefix, ...args], {
+    const { executable, prefixArgs } = rnxSelfInvocation()
+    const child = spawn(executable, [...prefixArgs, ...args], {
       cwd: hostCwd(options.root, options.shellCwd()),
       // mark the child as running inside a local box. this is the only thing
       // that sets a placement — nothing infers one from cwd — and it is what

package/cli/commands/control.ts

@@ -57,6 +57,7 @@ import {
 import { getDriver } from '../drivers/registry'
 import { openUrl as openUrlInBrowser } from '../open-url'
 import { rethrowIfExit, rnxExit } from '../run-rnx'
+import { rnxSelfInvocation } from '../self-invocation'
 import {
   BridgeSimLockedError,
   bridgePortForShellBaseUrl,
@@ -250,15 +251,8 @@ async function ensureRuntimeForOpen() {
 }
 
 function spawnSootsim(args: string[]) {
-  const entry = process.argv[1]
-  if (entry && fs.existsSync(entry)) {
-    return spawn(process.execPath, [entry, ...args], {
-      detached: true,
-      stdio: 'ignore',
-      env: process.env,
-    })
-  }
-  return spawn(rnxPublicBrand.commandName, args, {
+  const { executable, prefixArgs } = rnxSelfInvocation()
+  return spawn(executable, [...prefixArgs, ...args], {
     detached: true,
     stdio: 'ignore',
     env: process.env,

package/cli/commands/daemon-mac-app.ts

@@ -11,8 +11,8 @@
 //
 // the bundle is regenerated every time `daemonInstall` runs — it's tiny
 // (a plist + a shell launcher) and the launcher embeds a snapshot of the
-// invocation, so an `npm update -g sootsim` followed by `rnx daemon
-// install --force` is the documented upgrade path. there's no notarization
+// invocation, so `rnx upgrade` followed by `rnx daemon install --force` is
+// the documented upgrade path. there's no notarization
 // or Developer ID signing here yet; ad-hoc + hardened runtime is enough to
 // fix the attribution, and a real signed bundle (shipped via the runtime
 // CDN) is a follow-up.
@@ -25,6 +25,7 @@ import {
   daemonAppDir,
   daemonAppLauncherPath,
 } from '../../src/home-paths'
+import type { RnxSelfInvocation } from '../self-invocation'
 
 const BUNDLE_IDENTIFIER = 'dev.sootsim.daemon'
 const BUNDLE_DISPLAY_NAME = 'RNX Daemon'
@@ -35,13 +36,6 @@ const BUNDLE_DISPLAY_NAME = 'RNX Daemon'
 // checkouts.
 const BUNDLE_VERSION = '0.1.36'
 
-export interface DaemonInvocation {
-  /** absolute path to the executable launchd should spawn. */
-  executable: string
-  /** arguments passed to the executable (before server/--port flags). */
-  prefixArgs: string[]
-}
-
 export interface DaemonAppPaths {
   /** the rebuilt .app bundle. */
   bundlePath: string
@@ -53,7 +47,7 @@ export interface DaemonAppPaths {
  *  and re-sign it ad-hoc. safe to call repeatedly; the directory is wiped
  *  before write so stale state from earlier installs can't leak through. */
 export function ensureDaemonApp(
-  invocation: DaemonInvocation,
+  invocation: RnxSelfInvocation,
   port: number,
   logDir: { stdout: string; stderr: string },
 ): DaemonAppPaths {
@@ -121,7 +115,7 @@ function renderInfoPlist(): string {
 }
 
 function renderLauncherScript(
-  invocation: DaemonInvocation,
+  invocation: RnxSelfInvocation,
   port: number,
   logDir: { stdout: string; stderr: string },
 ): string {

package/cli/commands/daemon.ts

@@ -1,9 +1,9 @@
 // rnx daemon — manage the persistent rnx bridge daemon
 //
 // wraps `rnx serve` so it starts automatically on login and restarts if
-// it crashes. the agent is tied to whichever `rnxsim` binary resolves at
-// registration time, so `npm update -g rnxsim` + `rnx daemon restart`
-// picks up the upgrade without touching the plist/unit file.
+// it crashes. the agent points at the executable that ran `daemon install`,
+// so `rnx upgrade` (which replaces that file in place) is picked up by
+// `rnx daemon restart` without touching the plist/unit file.
 //
 // `daemonInstall` is shared by `rnx setup` and the explicit
 // `rnx daemon install` machine-bootstrap path.
@@ -15,7 +15,7 @@
 // the macOS launchd Label is `dev.sootsim.daemon` (matching the .app
 // CFBundleIdentifier).
 
-import { execFileSync, spawnSync } from 'child_process'
+import { spawnSync } from 'child_process'
 import {
   existsSync,
   mkdirSync,
@@ -25,11 +25,10 @@ import {
   writeFileSync,
 } from 'fs'
 import { homedir } from 'os'
-import { basename, dirname, resolve, sep } from 'path'
+import { dirname, resolve } from 'path'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
-import { getCliVersion } from '../../src/cli-version'
 import {
-  daemonAppBundlePath,
+  daemonAppDir,
   isDaemonLockfileFresh,
   readDaemonLockfile,
   shouldSkipPersistentDaemon,
@@ -38,6 +37,7 @@ import {
 import { rnxPublicBrand } from '../../src/public-brand'
 import { printCommandHelp } from '../help'
 import { rnxExit } from '../run-rnx'
+import { rnxSelfInvocation, type RnxSelfInvocation } from '../self-invocation'
 import { ensureDaemonApp } from './daemon-mac-app'
 
 // minimum seconds between launchd / systemd respawns. without this, a daemon
@@ -69,7 +69,7 @@ export async function runDaemon(args: string[], opts: DaemonOptions = {}) {
     case 'install':
       return daemonInstall({ port, force: rest.includes('--force') })
     case 'uninstall':
-      return daemonUninstall()
+      return daemonUninstall(rest)
     case 'status':
       return daemonStatus()
     case 'restart':
@@ -93,94 +93,17 @@ function printHelp() {
 
 // --- resolve sootsim binary ----------------------------------------------
 
-interface SootsimInvocation {
-  /** absolute path to the executable launchd / systemd should spawn directly. */
-  executable: string
-  /** args to pass before `serve --quiet --port <port>`. */
-  prefixArgs: string[]
-}
-
-function resolveSootsimInvocation(): SootsimInvocation {
-  // launchd / systemd run agents with a stripped PATH (basically just
-  // /usr/bin:/bin:/usr/sbin:/sbin), so a `#!/usr/bin/env node` shebang
-  // resolves nothing and the daemon never starts. spawn the absolute node
-  // binary directly with the rnx entry script as an argument.
-  //
-  // process.execPath is whichever node ran the install command, which is
-  // also the node the user expects rnx to run on.
-  const npxInvocation = resolveNpxDaemonInvocation()
-  if (npxInvocation) return npxInvocation
-  const entry = resolveSootsimEntryScript()
-  return { executable: process.execPath, prefixArgs: [entry] }
-}
-
-function resolveNpxDaemonInvocation(): SootsimInvocation | null {
-  if (!isNpxSootsimInvocation()) return null
-
-  const npmCli = resolveNpmCliPath()
-  if (!npmCli) return null
-
-  const version = getCliVersion()
-  const packageSpec =
-    version === '0.0.0'
-      ? rnxPublicBrand.packageName
-      : `${rnxPublicBrand.packageName}@${version}`
+// launchd and systemd run agents with a stripped PATH (basically just
+// /usr/bin:/bin:/usr/sbin:/sbin), so anything that depends on PATH resolution
+// never starts. rnxSelfInvocation() answers with absolute paths for both CLI
+// shapes; resolve symlinks on the entry script so the service spawns the real
+// file rather than a bin shim that would itself need PATH.
+function resolveDaemonInvocation(): RnxSelfInvocation {
+  const invocation = rnxSelfInvocation()
   return {
-    executable: process.execPath,
-    prefixArgs: [
-      npmCli,
-      'exec',
-      '--yes',
-      '--package',
-      packageSpec,
-      '--',
-      rnxPublicBrand.commandName,
-    ],
-  }
-}
-
-function isNpxSootsimInvocation(): boolean {
-  const argv1 = process.argv[1]
-  if (process.env.npm_command === 'exec') return true
-  if (!argv1) return false
-  const real = realPathOrSelf(argv1)
-  return real.includes(`${sep}_npx${sep}`)
-}
-
-function resolveNpmCliPath(): string | null {
-  try {
-    const out = execFileSync('which', ['npm'], { encoding: 'utf8' }).trim()
-    if (out && existsSync(out)) return realNpmCliPath(out)
-  } catch {}
-
-  const envPath = process.env.npm_execpath
-  if (envPath && existsSync(envPath)) return realNpmCliPath(envPath)
-  return null
-}
-
-function realNpmCliPath(path: string): string {
-  const real = realPathOrSelf(path)
-  if (basename(real) === 'npx-cli.js') {
-    const npmCli = resolve(dirname(real), 'npm-cli.js')
-    if (existsSync(npmCli)) return npmCli
+    executable: invocation.executable,
+    prefixArgs: invocation.prefixArgs.map(realPathOrSelf),
   }
-  return real
-}
-
-function resolveSootsimEntryScript(): string {
-  // prefer which(1) → handles the user's $PATH (npm/bun/pnpm global bin dirs).
-  // fall back to process.argv[1] for dev checkouts. resolve any symlink so
-  // launchd / systemd spawn the real script, not a /node_modules/.bin shim
-  // that may itself depend on PATH.
-  try {
-    const out = execFileSync('which', [rnxPublicBrand.commandName], {
-      encoding: 'utf8',
-    }).trim()
-    if (out && existsSync(out)) return realPathOrSelf(out)
-  } catch {}
-  const argv1 = process.argv[1]
-  if (argv1 && existsSync(argv1)) return realPathOrSelf(argv1)
-  throw new Error(`could not locate the ${rnxPublicBrand.commandName} binary`)
 }
 
 function realPathOrSelf(p: string): string {
@@ -193,7 +116,7 @@ function realPathOrSelf(p: string): string {
 
 // --- plist / unit generation ---------------------------------------------
 
-function renderPlist(invocation: SootsimInvocation, port: number): string {
+function renderPlist(invocation: RnxSelfInvocation, port: number): string {
   mkdirSync(LOG_DIR, { recursive: true })
   const stdout = resolve(LOG_DIR, 'bridge.out.log')
   const stderr = resolve(LOG_DIR, 'bridge.err.log')
@@ -222,7 +145,7 @@ ${programArgs}
 `
 }
 
-function renderSystemdUnit(invocation: SootsimInvocation, port: number): string {
+function renderSystemdUnit(invocation: RnxSelfInvocation, port: number): string {
   mkdirSync(LOG_DIR_LINUX, { recursive: true })
   const exec = [invocation.executable, ...invocation.prefixArgs].map(shellQuote).join(' ')
   return `[Unit]
@@ -293,7 +216,7 @@ export async function daemonInstall({ port, force }: { port: number; force: bool
     throw new Error('background daemon setup is unavailable in this environment')
   }
 
-  const invocation = resolveSootsimInvocation()
+  const invocation = resolveDaemonInvocation()
   console.log(`  binary: ${[invocation.executable, ...invocation.prefixArgs].join(' ')}`)
   console.log(`  port:   ${port}`)
 
@@ -511,10 +434,7 @@ export function teardownLegacyMacDaemonArtifacts(
 
 /** stop + disable + remove the persistent launchd / systemd registration
  *  and its support files (mac .app bundle, log dir). does NOT touch user
- *  data under ~/.rnx. idempotent: each entry is checked before remove.
- *  exported for reuse by the npm preuninstall hook (scripts/preuninstall.cjs)
- *  via the bundled CLI so a `npm rm -g rnxsim` tears down the daemon before
- *  the bin disappears. */
+ *  data under ~/.rnx. idempotent: each entry is checked before remove. */
 export function teardownDaemonService(): TeardownReport {
   const removed: string[] = []
   if (process.platform === 'darwin') {
@@ -530,10 +450,12 @@ export function teardownDaemonService(): TeardownReport {
       rmSync(plist, { force: true })
       removed.push(plist)
     }
-    const bundle = daemonAppBundlePath()
-    if (existsSync(bundle)) {
-      rmSync(bundle, { recursive: true, force: true })
-      removed.push(bundle)
+    // daemon-app holds only the generated .app launcher, so the whole
+    // directory goes with the service.
+    const appDir = daemonAppDir()
+    if (existsSync(appDir)) {
+      rmSync(appDir, { recursive: true, force: true })
+      removed.push(appDir)
     }
     if (existsSync(LOG_DIR)) {
       rmSync(LOG_DIR, { recursive: true, force: true })
@@ -545,8 +467,8 @@ export function teardownDaemonService(): TeardownReport {
     const unit = linuxUnitPath()
     if (existsSync(unit)) {
       // `disable --now` stops + disables in one call. ignore exit status: a
-      // unit pointing at a now-stale ExecStart (the npm preuninstall path)
-      // can return non-zero while still successfully disabling the unit.
+      // unit whose ExecStart no longer exists can return non-zero while
+      // still successfully disabling the unit.
       spawnSync('systemctl', ['--user', 'disable', '--now', SERVICE_NAME_LINUX], {
         stdio: 'ignore',
       })
@@ -571,10 +493,12 @@ export function teardownDaemonService(): TeardownReport {
   return { removed, missing: true }
 }
 
-/** remove the user-data cache under ~/.rnx (runtimes, electron support,
- *  profiles, lockfile, config). idempotent. honors $RNX_HOME. exported
- *  for reuse by the npm preuninstall hook. */
-export function teardownSootsimHome(): TeardownReport {
+/** remove EVERYTHING under ~/.rnx: installed runtimes, electron support,
+ *  device profiles and their app storage, live dev-bridge state, lockfile,
+ *  and config. only `rnx daemon uninstall --purge` calls this, because a
+ *  user who asked to remove a background service did not ask to lose the
+ *  simulators they have been working in. idempotent. honors $RNX_HOME. */
+export function teardownRnxHome(): TeardownReport {
   const removed: string[] = []
   const home = rnxHomeDir()
   if (existsSync(home)) {
@@ -584,10 +508,36 @@ export function teardownSootsimHome(): TeardownReport {
   return { removed, missing: removed.length === 0 }
 }
 
-async function daemonUninstall() {
+// `uninstall` removes the background service and nothing else. device
+// profiles, their app storage, and live dev-bridge state belong to simulators
+// the user may still be working in, so deleting them is something you ask for
+// by name with `--purge`.
+async function daemonUninstall(rest: string[]) {
+  const unknown = rest.filter((arg) => arg !== '--purge')
+  if (unknown.length > 0) {
+    console.error(`  unknown daemon uninstall option: ${unknown[0]}`)
+    printHelp()
+    rnxExit(1)
+    return
+  }
+  const purge = rest.includes('--purge')
+
   const service = teardownDaemonService()
   for (const path of service.removed) console.log(`  removed ${path}`)
-  const home = teardownSootsimHome()
+
+  if (!purge) {
+    if (service.missing) console.log('  not installed')
+    const home = rnxHomeDir()
+    if (existsSync(home)) {
+      console.log(`  kept ${home} (runtimes, device profiles, open simulators)`)
+      console.log(
+        `  remove that too with \`${rnxPublicBrand.commandName} daemon uninstall --purge\``,
+      )
+    }
+    return
+  }
+
+  const home = teardownRnxHome()
   for (const path of home.removed) console.log(`  removed ${path}`)
   if (service.missing && home.missing) console.log('  not installed')
 }

package/cli/drivers/playwright-provisioning.ts

@@ -2,6 +2,9 @@ import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join } from 'node:path'
+import { RNX_INTERNAL_CHILDREN, RNX_INTERNAL_COMMAND } from '../internal-child'
+import { rnxSelfInvocation } from '../self-invocation'
+
 export interface ResolvedPlaywright {
   // package name that resolved (for human-facing messaging)
   spec: string
@@ -24,23 +27,6 @@ export type PlaywrightBrowserProvisioningResult =
       message: string
     }
 
-const PLAYWRIGHT_BROWSER_PROBE = `
-const { existsSync } = require('node:fs');
-const modulePath = process.env.SOOTSIM_PW_MODULE;
-try {
-  const playwright = require(modulePath);
-  const browser = playwright && playwright.chromium;
-  if (!browser || typeof browser.executablePath !== 'function') {
-    throw new Error('resolved package does not expose browser "chromium"');
-  }
-  const executablePath = browser.executablePath();
-  process.stdout.write(JSON.stringify({ executablePath, exists: existsSync(executablePath) }));
-} catch (error) {
-  process.stderr.write(String((error && error.stack) || error));
-  process.exit(1);
-}
-`
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
@@ -93,14 +79,19 @@ function probeBrowser(
   resolved: ResolvedPlaywright,
   env: NodeJS.ProcessEnv,
 ): BrowserProbeResult {
-  const probe = spawnSync(process.execPath, ['-e', PLAYWRIGHT_BROWSER_PROBE], {
-    env: {
-      ...env,
-      SOOTSIM_PW_MODULE: resolved.modulePath,
+  const self = rnxSelfInvocation()
+  const probe = spawnSync(
+    self.executable,
+    [...self.prefixArgs, RNX_INTERNAL_COMMAND, RNX_INTERNAL_CHILDREN.playwrightProbe],
+    {
+      env: {
+        ...env,
+        SOOTSIM_PW_MODULE: resolved.modulePath,
+      },
+      encoding: 'utf8',
+      timeout: 30_000,
     },
-    encoding: 'utf8',
-    timeout: 30_000,
-  })
+  )
   if (probe.status !== 0) {
     const detail = (probe.stderr || probe.error?.message || 'browser probe failed').trim()
     return {
@@ -145,11 +136,24 @@ export function ensurePlaywrightBrowser(
   // the resolved package is the authority for both the required executable
   // path and the installer. never scan a shared cache or select a neighboring
   // revision: Playwright's own CLI installs the exact revision its API named.
-  const install = spawnSync(process.execPath, [resolved.cliPath, 'install', 'chromium'], {
-    env,
-    encoding: 'utf8',
-    timeout: 10 * 60_000,
-  })
+  // that CLI is a javascript file, so this CLI runs it as itself.
+  const installer = rnxSelfInvocation()
+  const install = spawnSync(
+    installer.executable,
+    [
+      ...installer.prefixArgs,
+      RNX_INTERNAL_COMMAND,
+      RNX_INTERNAL_CHILDREN.playwrightInstall,
+      resolved.cliPath,
+      'install',
+      'chromium',
+    ],
+    {
+      env,
+      encoding: 'utf8',
+      timeout: 10 * 60_000,
+    },
+  )
   if (install.status !== 0) {
     const rawDetail = (
       install.stderr ||