rnxsim 0.1.344 → 0.1.345

package/cli/commands/control.ts

@@ -188,10 +188,15 @@ export async function ensureBridgeForOpen(
   preferredPort: number,
   explicitPort = false,
 ): Promise<number> {
-  if (await canConnectToBridge(preferredPort, 250)) return preferredPort
-
   const lock = readDaemonLockfile()
   assertExplicitBridgeLock(preferredPort, explicitPort, lock)
+  const preferredWorld = worldForBridgePort(preferredPort)
+  if (
+    (explicitPort || preferredWorld !== null) &&
+    (await canConnectToBridge(preferredPort, 250))
+  ) {
+    return preferredPort
+  }
   if (
     lock &&
     isDaemonLockfileFresh(lock) &&
@@ -227,12 +232,6 @@ export async function ensureBridgeForOpen(
       )
       return nextLock.bridgePort
     }
-    if (await canConnectToBridge(preferredPort, 250)) {
-      console.error(
-        `  started local bridge on port ${preferredPort}; run \`sootsim setup\` to install the background daemon`,
-      )
-      return preferredPort
-    }
     if (childExit) {
       throw new Error(`rnx bridge exited before becoming ready (exit ${childExit})`)
     }
@@ -542,13 +541,9 @@ function parseOpenRuntimeConfig(args: string[]): SootSimConfig | undefined {
 async function resolveOpenAppProject(
   resolvedBundle?: ResolvedDevBundle,
 ): Promise<ResolvedAppProject | null> {
-  if (resolvedBundle) {
-    const advertisedRoot = await resolveMetroProjectRoot(resolvedBundle.bundleUrl)
-    if (advertisedRoot) {
-      return resolveAppProject(advertisedRoot, { trustStart: true })
-    }
-  }
-  return resolveAppProject(process.env.CONTRAST_REPO_DIR || process.cwd())
+  if (!resolvedBundle) return null
+  const advertisedRoot = await resolveMetroProjectRoot(resolvedBundle.bundleUrl)
+  return advertisedRoot ? resolveAppProject(advertisedRoot) : null
 }
 
 async function ensureConfiguredRuntime(version: string): Promise<void> {
@@ -616,16 +611,10 @@ async function stampAppFonts(
   try {
     const url = new URL(urlStr)
     const bundleUrl = url.searchParams.get('bundle') || ''
-    if (!bundleUrl) return urlStr
-    // the dev server's project root identifies the exact app in a monorepo.
-    // CONTRAST_REPO_DIR is only the fallback for servers that do not advertise
-    // their root.
-    const repoDir =
-      project?.appDir ?? (await resolveMetroProjectRoot(bundleUrl)) ?? undefined
+    if (!bundleUrl || !project) return urlStr
     const specs = discoverNativeLinkedAppFonts({
       bundleUrl,
-      repoDir,
-      exactProjectDir: !!project || !!repoDir,
+      projectDir: project.appDir,
     })
     if (specs.length === 0) return urlStr
     const reachable = await filterReachableAppFonts(specs)
@@ -716,13 +705,10 @@ async function stampAppSplash(
   try {
     const url = new URL(urlStr)
     const bundleUrl = url.searchParams.get('bundle') || ''
-    if (!bundleUrl) return urlStr
-    const repoDir =
-      project?.appDir ?? (await resolveMetroProjectRoot(bundleUrl)) ?? undefined
+    if (!bundleUrl || !project) return urlStr
     const spec = discoverConfigPluginAppSplash({
       bundleUrl,
-      repoDir,
-      exactProjectDir: !!project || !!repoDir,
+      projectDir: project.appDir,
     })
     if (!spec) return urlStr
     // HEAD-check the image before stamping so a typo'd/missing splash path never
@@ -1427,7 +1413,10 @@ export async function runLinkCommand(args: string[], opts: ControlCommandOptions
   }
 }
 
-export async function runOpenCommand(args: string[], opts: ControlCommandOptions = {}) {
+export async function runOpenCommand(
+  args: string[],
+  opts: ControlCommandOptions = {},
+): Promise<number | undefined> {
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
     commandTimeoutMs: opts.timeoutMs,
@@ -1748,7 +1737,7 @@ export async function runOpenCommand(args: string[], opts: ControlCommandOptions
           ))
         printOpenedSim(shellUrl, { ...targetSim, url: shellUrl }, 'current sim')
         await maybeDescribeAfterOpen(parsed.wsPort, targetSim.id, args)
-        return
+        return parsed.wsPort
       }
     } finally {
       bridge.close()
@@ -1827,6 +1816,7 @@ export async function runOpenCommand(args: string[], opts: ControlCommandOptions
   signalDriverLaunchConnected(result)
   printOpenedSim(openUrl, match, `${driver.name} driver`)
   await maybeDescribeAfterOpen(parsed.wsPort, match.id, args)
+  return parsed.wsPort
 }
 
 async function runUseLikeCommand(args: string[], opts: ControlCommandOptions = {}) {

package/cli/commands/daemon.ts

@@ -37,7 +37,6 @@ import {
 } from '../../src/home-paths'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { printCommandHelp } from '../help'
-import { flushCliTelemetry, trackCliEvent } from '../telemetry'
 import { ensureDaemonApp } from './daemon-mac-app'
 
 // minimum seconds between launchd / systemd respawns. without this, a daemon
@@ -65,49 +64,25 @@ export async function runDaemon(args: string[], opts: DaemonOptions = {}) {
     return
   }
 
-  // emit a single observable event per subcommand. validate against the
-  // known set so an unknown / malformed `sub` (e.g. accidental path or
-  // shell-expanded garbage) doesn't pollute the posthog event taxonomy.
-  // tagged with subsource so daemon traffic is filterable from regular
-  // cli traffic.
-  const KNOWN_SUBCOMMANDS = new Set([
-    'install',
-    'uninstall',
-    'restart',
-    'start',
-    'stop',
-    'logs',
-  ])
-  if (KNOWN_SUBCOMMANDS.has(sub)) {
-    trackCliEvent({
-      event: `daemon_${sub}`,
-      properties: { platform: process.platform, subsource: 'daemon' },
-    })
-  }
-
-  try {
-    switch (sub) {
-      case 'install':
-        return await daemonInstall({ port, force: rest.includes('--force') })
-      case 'uninstall':
-        return await daemonUninstall()
-      case 'status':
-        return await daemonStatus()
-      case 'restart':
-        return await daemonRestart()
-      case 'start':
-        return await daemonStart()
-      case 'stop':
-        return await daemonStop()
-      case 'logs':
-        return await daemonLogs(rest)
-      default:
-        console.error(`  unknown daemon subcommand: ${sub}`)
-        printHelp()
-        process.exit(1)
-    }
-  } finally {
-    await flushCliTelemetry()
+  switch (sub) {
+    case 'install':
+      return daemonInstall({ port, force: rest.includes('--force') })
+    case 'uninstall':
+      return daemonUninstall()
+    case 'status':
+      return daemonStatus()
+    case 'restart':
+      return daemonRestart()
+    case 'start':
+      return daemonStart()
+    case 'stop':
+      return daemonStop()
+    case 'logs':
+      return daemonLogs(rest)
+    default:
+      console.error(`  unknown daemon subcommand: ${sub}`)
+      printHelp()
+      process.exit(1)
   }
 }
 

package/cli/commands/flow.ts

@@ -23,7 +23,6 @@ import {
   keepFlowCandidate,
   startFlowSession,
 } from '../flow-session'
-import { flushCliTelemetry, trackCliEvent } from '../telemetry'
 import { createBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
 import {
   buildShellUrl,
@@ -334,26 +333,6 @@ flow extension:
   ${steps.length} steps | ${mode}${appLabel}${record ? ' | recording' : ''}${profile ? ' | profiling' : ''}${slow ? ` | ${slow}ms delay` : ''}
 `)
 
-  // only meter flows that will result in a cloud preview upload. plain
-  // flow playback + local recording stay completely unmetered per the
-  // free/pro/enterprise beta plan (local usage is free). server emits
-  // the authoritative preview_upload events when the chained upload
-  // actually lands.
-  if (preview) {
-    trackCliEvent({
-      event: 'preview_flow_started',
-      properties: {
-        flowName: path.basename(flowPath),
-        stepCount: steps.length,
-        mode,
-        electron: wantElectron,
-        record,
-        profile,
-        previewOrigin,
-      },
-    })
-  }
-
   let openTarget = url || targetApp || ''
   const effectiveOpenInNewSim =
     openInNewSim || (wantElectron && parsedBridgeArgs.simIdSource !== 'flag')
@@ -392,7 +371,6 @@ flow extension:
     const discovered = await discoverSootsimUrl()
     if (!discovered) {
       console.error('  error: no current sim and no sootsim target found')
-      await flushCliTelemetry()
       process.exit(1)
     }
     openTarget = discovered
@@ -832,11 +810,6 @@ flow extension:
     saveCurrentSimId(driver.simId)
   }
 
-  // flush before returning to caller — caller typically calls
-  // process.exit(returnedCode), and node's `exit` hook can't await, so
-  // without this the flow telemetry (and any chained upload's events)
-  // get silently dropped.
-  await flushCliTelemetry()
   return exitCode
 }
 

package/cli/commands/install-desktop.ts

@@ -146,10 +146,10 @@ async function installMacDmg(dmgPath: string): Promise<string> {
     throw new Error(`could not determine dmg mount point (output: ${mountOutput.stdout})`)
   }
 
-  const appSource = join(mountPoint, 'sootsim.app')
+  const appSource = join(mountPoint, 'rnx.app')
   if (!existsSync(appSource)) {
     spawnSync('hdiutil', ['detach', '-force', mountPoint])
-    throw new Error(`sootsim.app not found inside ${mountPoint}`)
+    throw new Error(`rnx.app not found inside ${mountPoint}`)
   }
 
   // prefer /Applications if writable, otherwise ~/Applications (same paths
@@ -319,24 +319,10 @@ examples:
   console.log()
   console.log(`  installing...`)
 
-  const { trackCliEvent, flushCliTelemetry } = await import('../telemetry')
-
   try {
     const installedAt = await target.install(downloadPath)
-    trackCliEvent({
-      event: 'cli_install_desktop_succeeded',
-      properties: { platform: target.platform, size_bytes: size },
-    })
     console.log(`  installed: ${installedAt}`)
   } catch (err) {
-    trackCliEvent({
-      event: 'cli_install_desktop_failed',
-      properties: {
-        platform: target.platform,
-        error: err instanceof Error ? err.message : String(err),
-      },
-    })
-    await flushCliTelemetry()
     console.error(`  install failed: ${err instanceof Error ? err.message : String(err)}`)
     console.error(`  keeping download at ${downloadPath} for manual install.`)
     process.exit(1)

package/cli/commands/login.ts

@@ -8,22 +8,15 @@ import {
 import { rnxPublicBrand } from '../../src/public-brand'
 
 const REMOTE_DEFAULT_ORIGIN = process.env.SOOTSIM_AUTH_ORIGIN || 'https://contrast.dev'
-const LOCAL_DEFAULT_ORIGIN = 'https://contrast.localhost:3000'
 
 type LoginResult =
   | { ok: true; token: string; userId?: string; email?: string }
   | { ok: false; error: string }
 
-async function resolveDefaultAuthOrigin(explicitOrigin?: string) {
+function resolveDefaultAuthOrigin(explicitOrigin?: string) {
   if (explicitOrigin) return explicitOrigin
   if (process.env.SOOTSIM_AUTH_ORIGIN) return process.env.SOOTSIM_AUTH_ORIGIN
   if (process.env.SOOTSIM_UPLOAD_ORIGIN) return process.env.SOOTSIM_UPLOAD_ORIGIN
-
-  try {
-    const res = await fetch(`${LOCAL_DEFAULT_ORIGIN}/api/auth/me`)
-    if (res.ok) return LOCAL_DEFAULT_ORIGIN
-  } catch {}
-
   return REMOTE_DEFAULT_ORIGIN
 }
 
@@ -35,9 +28,7 @@ usage:
   rnx login [--origin <url>]
 
 options:
-  --origin <url>     auth host (default: auto)
-                     prefers ${LOCAL_DEFAULT_ORIGIN} when available, otherwise
-                     falls back to ${REMOTE_DEFAULT_ORIGIN}
+  --origin <url>     auth host (default: ${REMOTE_DEFAULT_ORIGIN})
                      override with SOOTSIM_AUTH_ORIGIN env var
   -h, --help
 `)
@@ -154,9 +145,7 @@ export async function runLogin(args: string[]) {
   }
 
   const mutableArgs = [...args]
-  const origin = await resolveDefaultAuthOrigin(
-    extractStringFlag(mutableArgs, '--origin'),
-  )
+  const origin = resolveDefaultAuthOrigin(extractStringFlag(mutableArgs, '--origin'))
 
   // in dev (localhost), skip the browser and sign in as the shared dev
   // user via POST /api/dev-login. the no-device contract is local-only, so this
@@ -177,13 +166,6 @@ export async function runLogin(args: string[]) {
         devResult.email ||
         refreshed?.user?.id ||
         devResult.userId
-      const { trackCliEvent, flushCliTelemetry } = await import('../telemetry')
-      trackCliEvent({
-        event: 'cli_login_succeeded',
-        identity: { userId: devResult.userId ?? refreshed?.user?.id ?? null },
-        properties: { origin, mode: 'dev' },
-      })
-      await flushCliTelemetry()
       console.log(`  signed in${label ? ` as ${label}` : ''} (dev)`)
       return
     }
@@ -192,15 +174,6 @@ export async function runLogin(args: string[]) {
 
   const state = randomBytes(16).toString('hex')
 
-  // flush a start event BEFORE the browser wait: queued telemetry only drains
-  // on process exit, so a login that hangs (or gets ctrl+c'd) would otherwise
-  // leave zero trace. first-time-user hangs were invisible in posthog.
-  {
-    const { trackCliEvent, flushCliTelemetry } = await import('../telemetry')
-    trackCliEvent({ event: 'cli_login_started', properties: { origin } })
-    await flushCliTelemetry()
-  }
-
   // the browser round-trip needs human action (github's authorize screen on
   // first sign-in), so the wait is generous, but it must not be infinite: a
   // closed tab, denied consent, or blocked popup used to hang the CLI forever.
@@ -295,12 +268,6 @@ export async function runLogin(args: string[]) {
   })
 
   if (!result.ok) {
-    const { trackCliEvent, flushCliTelemetry } = await import('../telemetry')
-    trackCliEvent({
-      event: 'cli_login_failed',
-      properties: { origin, error: result.error },
-    })
-    await flushCliTelemetry()
     console.error(`  login failed: ${result.error}`)
     process.exit(1)
   }
@@ -320,12 +287,5 @@ export async function runLogin(args: string[]) {
   const refreshed = await refreshSharedDesktopAuthSession(origin)
   const label =
     refreshed?.user?.email || result.email || refreshed?.user?.id || result.userId
-  const { trackCliEvent, flushCliTelemetry } = await import('../telemetry')
-  trackCliEvent({
-    event: 'cli_login_succeeded',
-    identity: { userId: result.userId ?? refreshed?.user?.id ?? null },
-    properties: { origin },
-  })
-  await flushCliTelemetry()
   console.log(`  signed in${label ? ` as ${label}` : ''}`)
 }

package/cli/commands/logout.ts

@@ -2,7 +2,6 @@ import {
   clearSharedDesktopAuthSession,
   readSharedDesktopAuthSession,
 } from '../../src/auth/shared-session'
-import { flushCliTelemetry, trackCliEvent } from '../telemetry'
 
 export async function runLogout() {
   const current = readSharedDesktopAuthSession()
@@ -21,11 +20,5 @@ export async function runLogout() {
   }
 
   clearSharedDesktopAuthSession()
-  trackCliEvent({
-    event: 'cli_logout',
-    identity: { userId: current.user?.id ?? null },
-    properties: { origin: current.origin },
-  })
-  await flushCliTelemetry()
   console.log('  signed out')
 }

package/cli/commands/serve.ts

@@ -15,21 +15,8 @@ import {
   readDaemonLockfile,
 } from '../../src/home-paths'
 import { SootSimBridgeHost } from '../../src/host/bridge-host'
-import { flushCliTelemetry, trackCliEvent } from '../telemetry'
 import { resolveDefaultUploadOrigin } from './upload'
 
-// launchd sets `XPC_SERVICE_NAME` to the agent label and systemd sets
-// `INVOCATION_ID` for unit-managed processes. either tells us this bridge
-// boot is the daemon firing rather than a user running `sootsim serve`
-// in a terminal — useful for filtering daemon traffic in posthog.
-//
-function runningUnderDaemon(): boolean {
-  const xpc = process.env.XPC_SERVICE_NAME || ''
-  if (xpc.includes('dev.sootsim.daemon')) return true
-  if (process.env.INVOCATION_ID) return true
-  return false
-}
-
 interface ServeOptions {
   port?: number
 }
@@ -81,9 +68,8 @@ examples:
   }
 
   ensureSootsimHome()
-  // resolve the contrast origin the same way uploads do (probe a local
-  // :3000 stack, else prod) so served runtimes talk auth/billing/preview
-  // to the same origin the CLI's own entitlement + upload paths use.
+  // use the explicit upload/auth origin when configured, otherwise production.
+  // never probe a local Contrast stack during bridge startup.
   const contrastOrigin = await resolveDefaultUploadOrigin()
   const host = new SootSimBridgeHost({
     port,
@@ -115,22 +101,6 @@ examples:
     for (const id of currentIds) lastSimIds.add(id)
   }, 500)
 
-  // single boot heartbeat so we know the bridge is alive on this machine.
-  // not periodic — frequency would pollute posthog volumes for no signal.
-  // explicitly flush: this process pins the event loop with a never-
-  // resolving promise (line 155), so beforeExit will not fire and the
-  // event would otherwise sit in the queue until SIGTERM dropped it.
-  trackCliEvent({
-    event: 'daemon_heartbeat',
-    properties: {
-      bridge_port: boundPort,
-      under_daemon: runningUnderDaemon(),
-      platform: process.platform,
-      subsource: 'daemon',
-    },
-  })
-  void flushCliTelemetry()
-
   log(`rnx bridge listening on ws://localhost:${boundPort} (runtime http on same port)`)
   if (boundPort !== port) {
     log(`  (preferred port ${port} was taken — fell back to ${boundPort})`)