peachsim 0.1.527

package/cli/secure-file.ts

@@ -0,0 +1,31 @@
+import { randomUUID } from 'node:crypto'
+import {
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname } from 'node:path'
+
+export function writeSecureJsonAtomic(filepath: string, value: unknown): void {
+  mkdirSync(dirname(filepath), { recursive: true })
+  const temporary = `${filepath}.tmp-${process.pid}-${randomUUID()}`
+  let descriptor: number | null = null
+  try {
+    descriptor = openSync(temporary, 'wx', 0o600)
+    fchmodSync(descriptor, 0o600)
+    writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}\n`)
+    fsyncSync(descriptor)
+    closeSync(descriptor)
+    descriptor = null
+    renameSync(temporary, filepath)
+  } catch (error) {
+    if (descriptor !== null) closeSync(descriptor)
+    rmSync(temporary, { force: true })
+    throw error
+  }
+}

package/cli/self-invocation.ts

@@ -0,0 +1,58 @@
+// how this CLI re-invokes itself as a child process.
+//
+// two shapes exist and only the build decides which one is running:
+//
+//   standalone   the bun-compiled executable IS the entry point. it takes the
+//                CLI argv directly and there is no script to hand it.
+//   entry script every other shape (dev checkout, the repository dist-cli
+//                bundle) runs through the javascript runtime executing now,
+//                with the script as its first argument.
+//
+// a presence check cannot tell them apart. inside the compiled binary
+// `process.argv[1]` is a path in bun's virtual filesystem (`/$bunfs/root/...`)
+// that passes `existsSync` in-process, so every site that probed argv[1]
+// re-invoked itself as `rnx <bunfs path> <command>` and the child died on
+// `unknown command`. the build-time constant is the only honest signal.
+
+import { existsSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { rnxPublicBrand } from '../src/public-brand.ts'
+import { IS_STANDALONE } from './standalone.ts'
+
+export interface RnxSelfInvocation {
+  /** absolute path to spawn. */
+  executable: string
+  /** arguments that precede the CLI's own argv. */
+  prefixArgs: string[]
+}
+
+function sourceEntryPath(): string | null {
+  try {
+    const candidate = join(dirname(fileURLToPath(import.meta.url)), 'bin.ts')
+    return existsSync(candidate) ? candidate : null
+  } catch {
+    return null
+  }
+}
+
+function isCliEntry(path: string): boolean {
+  const name = basename(path)
+  return name === 'bin.ts' || name === 'bin.js'
+}
+
+export function rnxSelfInvocation(): RnxSelfInvocation {
+  if (IS_STANDALONE) return { executable: process.execPath, prefixArgs: [] }
+  const entry = process.argv[1]
+  if (entry && isCliEntry(entry)) {
+    return { executable: process.execPath, prefixArgs: [entry] }
+  }
+  const sourceEntry = sourceEntryPath()
+  if (sourceEntry) {
+    return { executable: process.execPath, prefixArgs: [sourceEntry] }
+  }
+  if (!entry) {
+    throw new Error(`could not locate the ${rnxPublicBrand.commandName} entry script`)
+  }
+  return { executable: process.execPath, prefixArgs: [entry] }
+}

package/cli/send-to-box.ts

@@ -0,0 +1,109 @@
+// "send to box": the running local app becomes a nano cloud simulator.
+//
+// one function serves both callers. the rail button in the shell reaches it
+// through the local daemon's `/__send-to-box` route, and `rnx box send` calls
+// it directly; both hand it a way to run a bridge command against the sim that
+// is running the app, and both get the same simulator id and URL back.
+
+import { isStorageSnapshot } from '../../sootsim-engine/src/preview/storage-snapshot-contract.ts'
+import {
+  DEFAULT_DEVICE_BY_PLATFORM,
+  getRuntimePlatform,
+  listDeviceModels,
+} from '../../sootsim-engine/src/settings/devices.ts'
+import { toRNXProductionBundleUrl } from '../src/metro-production-bundle.ts'
+import { createCloudBox } from './cloud-client.ts'
+import type { StorageSnapshot } from '../../sootsim-engine/src/preview/storage-snapshot-contract.ts'
+import type { DeviceModel } from '../../sootsim-engine/src/settings/devices.ts'
+import type { BridgeCommandType } from '../src/bridge-contract.ts'
+
+export interface SendToBoxOptions {
+  /** runs one bridge command against the sim running the app. */
+  send: (command: { type: BridgeCommandType; [key: string]: unknown }) => Promise<unknown>
+  authorization: string
+  /** the account the box bills. an api key names its own, so it sends none. */
+  accountId: string | null
+  /** the cloud device model. defaults to the device the sim is running on. */
+  device?: DeviceModel
+  /**
+   * carry the signed-in session into the box. on by default in the shell: the
+   * box is the sender's own, and an app that boots signed out is not the app
+   * they were looking at.
+   */
+  carryAuth: boolean
+  boxName?: string | null
+  apiOrigin?: string
+  simId?: string
+}
+
+export interface SendToBoxResult {
+  boxId: string
+  simId: string
+  url: string
+  carriedAuth: boolean
+  warnings: string[]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+// the box opens on the device the sender was looking at. a remote simulator is
+// iOS only, so an Android sim sends to the default iPhone rather than refusing.
+function cloudDevice(capturedModel: unknown): DeviceModel {
+  const captured = listDeviceModels().find((model) => model === capturedModel)
+  return captured && getRuntimePlatform(captured) === 'ios'
+    ? captured
+    : DEFAULT_DEVICE_BY_PLATFORM.ios
+}
+
+export async function sendToBox(options: SendToBoxOptions): Promise<SendToBoxResult> {
+  const captured: unknown = await options.send({
+    type: 'evaluate',
+    simId: options.simId,
+    code: '(typeof window.__sootsimCaptureBundle === "function") ? window.__sootsimCaptureBundle() : null',
+  })
+  const bundleUrl = isRecord(captured) ? captured.bundleUrl : null
+  if (!isRecord(captured) || typeof bundleUrl !== 'string' || !bundleUrl) {
+    throw new Error(
+      'send to box needs a simulator running an app: this one has no bundle loaded',
+    )
+  }
+  // the snapshot is taken before the production bundle is fetched, so the box
+  // gets the state the app was in when the button was pressed rather than the
+  // state it drifted to while Metro rebuilt.
+  const dumped: unknown = await options.send({
+    type: 'storageSnapshot',
+    simId: options.simId,
+    storageSnapshotOptions: { includeCredentials: options.carryAuth },
+  })
+  if (!isStorageSnapshot(dumped)) {
+    throw new Error('the simulator returned a storage snapshot this build cannot read')
+  }
+  const storage: StorageSnapshot = dumped
+  const created = await createCloudBox({
+    bundlePath: toRNXProductionBundleUrl(bundleUrl),
+    device:
+      options.device ??
+      cloudDevice(isRecord(captured.deviceSpec) ? captured.deviceSpec.model : null),
+    authorization: options.authorization,
+    accountId: options.accountId,
+    apiOrigin: options.apiOrigin,
+    boxName: options.boxName ?? null,
+    storage,
+  })
+  const simId = created.receipt.simulator.simId
+  const url = `${created.session.apiOrigin.replace(/\/$/, '')}/sim/${simId}`
+  // the local terminal is where an agent driving this checkout reads results,
+  // so the id and the URL land there whichever caller asked for the send.
+  console.log(`  box simulator: ${simId}`)
+  console.log(`  ${url}`)
+  for (const warning of created.warnings) console.warn(`  warning: ${warning}`)
+  return {
+    boxId: created.receipt.boxId,
+    simId,
+    url,
+    carriedAuth: options.carryAuth,
+    warnings: created.warnings,
+  }
+}

package/cli/setup-repository.ts

@@ -0,0 +1,191 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { rnxPublicBrand } from '../src/public-brand'
+
+export type SetupPackageManager = 'bun' | 'pnpm' | 'npm'
+
+export interface RepositoryOperation {
+  command: string
+  args: string[]
+  description: string
+}
+
+export interface RepositorySetupPlan {
+  appDir: string
+  packageManager: SetupPackageManager
+  operations: RepositoryOperation[]
+}
+
+interface PackageManifest {
+  scripts?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+export function findRepositoryPackageRoot(startDir: string): string | null {
+  let current = path.resolve(startDir)
+  let packageRoot: string | null = null
+  while (true) {
+    if (!packageRoot && fs.existsSync(path.join(current, 'package.json'))) {
+      packageRoot = current
+    }
+    if (fs.existsSync(path.join(current, '.git'))) return packageRoot
+    const parent = path.dirname(current)
+    if (parent === current) return null
+    current = parent
+  }
+}
+
+export function detectPreferredPackageManager(startDir: string): SetupPackageManager {
+  let current = path.resolve(startDir)
+  while (true) {
+    if (fs.existsSync(path.join(current, 'bun.lock'))) return 'bun'
+    if (fs.existsSync(path.join(current, 'bun.lockb'))) return 'bun'
+    if (fs.existsSync(path.join(current, 'pnpm-lock.yaml'))) return 'pnpm'
+    if (fs.existsSync(path.join(current, 'package-lock.json'))) return 'npm'
+    const parent = path.dirname(current)
+    if (parent === current) return 'npm'
+    current = parent
+  }
+}
+
+export function planRepositorySetup(input: {
+  appDir: string
+  cliVersion: string
+}): RepositorySetupPlan {
+  const appDir = path.resolve(input.appDir)
+  const manifest = readManifest(path.join(appDir, 'package.json'))
+  const expectedScript = `${rnxPublicBrand.commandName} open`
+  const existingScript = manifest.scripts?.[rnxPublicBrand.commandName]
+  if (existingScript && existingScript !== expectedScript) {
+    throw new Error(
+      `package.json already defines scripts.${rnxPublicBrand.commandName} as ${JSON.stringify(existingScript)}; resolve that conflict before setup`,
+    )
+  }
+
+  const packageManager = detectPreferredPackageManager(appDir)
+  const operations: RepositoryOperation[] = []
+  if (manifest.devDependencies?.[rnxPublicBrand.packageName] !== input.cliVersion) {
+    operations.push(addDependencyOperation(packageManager, input.cliVersion))
+  }
+  if (existingScript !== expectedScript) {
+    operations.push(scriptOperation(packageManager))
+  }
+  return {
+    appDir,
+    packageManager,
+    operations,
+  }
+}
+
+export async function applyRepositorySetup(
+  plan: RepositorySetupPlan,
+  options: { dryRun: boolean; json: boolean },
+): Promise<void> {
+  for (const operation of plan.operations) {
+    if (options.dryRun) continue
+    await runOperation(operation, plan.appDir, options.json)
+  }
+}
+
+export function formatRepositoryOperations(plan: RepositorySetupPlan): string[] {
+  return plan.operations.map(
+    (operation) => `${operation.command} ${operation.args.map(quoteArg).join(' ')}`,
+  )
+}
+
+function readManifest(packagePath: string): PackageManifest {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(fs.readFileSync(packagePath, 'utf8'))
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`could not read ${packagePath}: ${message}`)
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`${packagePath} must contain a JSON object`)
+  }
+  const scripts = readStringRecord(Reflect.get(parsed, 'scripts'))
+  const devDependencies = readStringRecord(Reflect.get(parsed, 'devDependencies'))
+  return {
+    ...(scripts ? { scripts } : {}),
+    ...(devDependencies ? { devDependencies } : {}),
+  }
+}
+
+function readStringRecord(value: unknown): Record<string, string> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const entries = Object.entries(value).filter(
+    (entry): entry is [string, string] => typeof entry[1] === 'string',
+  )
+  return Object.fromEntries(entries)
+}
+
+function addDependencyOperation(
+  packageManager: SetupPackageManager,
+  version: string,
+): RepositoryOperation {
+  const spec = `${rnxPublicBrand.packageName}@${version}`
+  switch (packageManager) {
+    case 'bun':
+      return {
+        command: 'bun',
+        args: ['add', '--dev', '--exact', spec],
+        description: `install ${spec} as an exact dev dependency`,
+      }
+    case 'pnpm':
+      return {
+        command: 'pnpm',
+        args: ['add', '--save-dev', '--save-exact', spec],
+        description: `install ${spec} as an exact dev dependency`,
+      }
+    case 'npm':
+      return {
+        command: 'npm',
+        args: ['install', '--save-dev', '--save-exact', spec],
+        description: `install ${spec} as an exact dev dependency`,
+      }
+  }
+}
+
+function quoteArg(value: string): string {
+  return /^[a-zA-Z0-9_./@=-]+$/.test(value) ? value : JSON.stringify(value)
+}
+
+function runOperation(
+  operation: RepositoryOperation,
+  cwd: string,
+  json: boolean,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(operation.command, operation.args, {
+      cwd,
+      stdio: json ? ['ignore', 2, 'inherit'] : 'inherit',
+    })
+    child.once('error', reject)
+    child.once('exit', (code) => {
+      if (code === 0) resolve()
+      else reject(new Error(`${operation.command} exited with code ${code ?? 'unknown'}`))
+    })
+  })
+}
+
+function scriptOperation(packageManager: SetupPackageManager): RepositoryOperation {
+  return {
+    command: packageManager,
+    args:
+      packageManager === 'bun'
+        ? [
+            'pm',
+            'pkg',
+            'set',
+            `scripts.${rnxPublicBrand.commandName}=${rnxPublicBrand.commandName} open`,
+          ]
+        : [
+            'pkg',
+            'set',
+            `scripts.${rnxPublicBrand.commandName}=${rnxPublicBrand.commandName} open`,
+          ],
+    description: `add the \`${rnxPublicBrand.commandName}\` package script`,
+  }
+}

package/cli/shell-init.ts

@@ -0,0 +1,98 @@
+import {
+  RNX_CLOUD_SESSION_ENV,
+  RNX_SHELL_UPDATE_SET_PREFIX,
+  RNX_SHELL_UPDATE_UNSET,
+} from './cloud-session'
+
+export function renderRnxShellInit(shell: string): string {
+  if (shell !== 'bash' && shell !== 'zsh') {
+    throw new Error('RNX shell integration supports bash and zsh')
+  }
+  return `rnx() {
+  local -a _rnx_shell_args
+  local _rnx_shell_command _rnx_shell_create _rnx_shell_update
+  local _rnx_shell_session _rnx_shell_status _rnx_shell_traced
+  _rnx_shell_args=("$@")
+  _rnx_shell_command=''
+  _rnx_shell_create=0
+  while [ "$#" -gt 0 ]; do
+    case "$1" in
+      -h|--help|-V|--version|-v|--verbose|--headless) shift ;;
+      -p|--port|-d|--device|-t|--theme|--driver|--sim|--session|--tab)
+        if [ "$#" -ge 2 ]; then shift 2; else shift; fi
+        ;;
+      --) break ;;
+      -*) shift ;;
+      *) _rnx_shell_command="$1"; shift; break ;;
+    esac
+  done
+  case "$_rnx_shell_command" in
+    claim|close) ;;
+    ios)
+      for _rnx_shell_session in "$@"; do
+        if [ "$_rnx_shell_session" = '--remote' ]; then
+          _rnx_shell_create=1
+          break
+        fi
+      done
+      if [ "$_rnx_shell_create" -ne 1 ]; then
+        command rnx "\${_rnx_shell_args[@]}"
+        return $?
+      fi
+      ;;
+    *)
+      command rnx "\${_rnx_shell_args[@]}"
+      return $?
+      ;;
+  esac
+
+  if { [ -n "\${BASH_VERSION:-}" ] && [ "\${BASH_SUBSHELL:-0}" -ne 0 ]; } ||
+     { [ -n "\${ZSH_VERSION:-}" ] && [ "\${ZSH_SUBSHELL:-0}" -ne 0 ]; }; then
+    printf '%s\\n' 'rnx remote simulator lifecycle commands must run directly in the current shell, not in a pipeline or command substitution' >&2
+    return 1
+  fi
+  if ( : >&9 ) 2>/dev/null; then
+    printf '%s\\n' 'rnx remote simulator shell integration requires file descriptor 9 to be unused' >&2
+    return 1
+  fi
+  if ! ( export ${RNX_CLOUD_SESSION_ENV}=__rnx_shell_probe && unset ${RNX_CLOUD_SESSION_ENV} ) 2>/dev/null; then
+    printf '%s\\n' 'rnx remote simulator shell integration cannot update RNX_CLOUD_SESSION in this shell' >&2
+    return 1
+  fi
+
+  case "$-" in
+    *x*) _rnx_shell_traced=1; set +x ;;
+    *) _rnx_shell_traced=0 ;;
+  esac
+  exec 9>&1
+  _rnx_shell_update="$(RNX_SHELL_UPDATE_FD=3 command rnx "\${_rnx_shell_args[@]}" 3>&1 1>&9)"
+  _rnx_shell_status=$?
+  exec 9>&-
+
+  if [ "$_rnx_shell_status" -eq 0 ]; then
+    case "$_rnx_shell_update" in
+      ${RNX_SHELL_UPDATE_SET_PREFIX}*)
+        _rnx_shell_session="\${_rnx_shell_update#${RNX_SHELL_UPDATE_SET_PREFIX}}"
+        case "$_rnx_shell_session" in
+          ''|*$'\\n'*) _rnx_shell_status=1 ;;
+          *) export ${RNX_CLOUD_SESSION_ENV}="$_rnx_shell_session" || _rnx_shell_status=$? ;;
+        esac
+        ;;
+      ${RNX_SHELL_UPDATE_UNSET})
+        unset ${RNX_CLOUD_SESSION_ENV} || _rnx_shell_status=$?
+        ;;
+      *) _rnx_shell_status=1 ;;
+    esac
+    if [ "$_rnx_shell_status" -ne 0 ]; then
+      printf '%s\\n' 'rnx refused an invalid shell session update' >&2
+    elif [ "$_rnx_shell_create" -eq 1 ]; then
+      command rnx __cloud-confirm
+      _rnx_shell_status=$?
+    fi
+  fi
+
+  if [ "$_rnx_shell_traced" -eq 1 ]; then set -x; fi
+  return "$_rnx_shell_status"
+}
+`
+}

package/cli/standalone.ts

@@ -0,0 +1,4 @@
+declare const __SOOTSIM_STANDALONE__: boolean
+
+export const IS_STANDALONE =
+  typeof __SOOTSIM_STANDALONE__ !== 'undefined' && __SOOTSIM_STANDALONE__

package/cli/telemetry.ts

@@ -0,0 +1,84 @@
+import { diagnosticsAllowedForCurrentProcess } from './privacy'
+
+type PackageIncompatibility = {
+  kind: 'package_incompatibility'
+  packageName: string
+  packageVersion: string
+  unsupportedApi?: string
+}
+
+type ErrorShape = {
+  kind: 'error_shape'
+  errorClass: string
+}
+
+export type CliDiagnostic = PackageIncompatibility | ErrorShape
+
+type Config = { apiKey: string; host: string }
+
+function loadConfig(): Config | null {
+  if (!diagnosticsAllowedForCurrentProcess()) return null
+  const apiKey =
+    process.env.CONTRAST_POSTHOG_API_KEY || process.env.VITE_POSTHOG_API_KEY || ''
+  if (!apiKey) return null
+  const host =
+    process.env.CONTRAST_POSTHOG_HOST ||
+    process.env.VITE_POSTHOG_HOST ||
+    'https://us.i.posthog.com'
+  return { apiKey, host: host.replace(/\/+$/, '') }
+}
+
+function bounded(value: string, max: number): string {
+  return value.trim().slice(0, max)
+}
+
+export function buildCliDiagnosticEvent(diagnostic: CliDiagnostic) {
+  const properties =
+    diagnostic.kind === 'package_incompatibility'
+      ? {
+          package_name: bounded(diagnostic.packageName, 160),
+          package_version: bounded(diagnostic.packageVersion, 80),
+          ...(diagnostic.unsupportedApi
+            ? { unsupported_api: bounded(diagnostic.unsupportedApi, 160) }
+            : {}),
+        }
+      : { error_class: bounded(diagnostic.errorClass, 160) }
+
+  return {
+    event: diagnostic.kind,
+    distinct_id: 'rnx-cli-diagnostic',
+    properties,
+  }
+}
+
+const queue: CliDiagnostic[] = []
+
+export function trackCliDiagnostic(diagnostic: CliDiagnostic): void {
+  if (!diagnosticsAllowedForCurrentProcess()) return
+  queue.push(diagnostic)
+}
+
+export function trackCliError(error: unknown): void {
+  const errorClass = error instanceof Error ? error.constructor.name : typeof error
+  trackCliDiagnostic({ kind: 'error_shape', errorClass })
+}
+
+export async function flushCliTelemetry(): Promise<void> {
+  if (queue.length === 0) return
+  const config = loadConfig()
+  if (!config) {
+    queue.length = 0
+    return
+  }
+  const batch = queue.splice(0, queue.length).map(buildCliDiagnosticEvent)
+  try {
+    await fetch(`${config.host}/batch/`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ api_key: config.apiKey, batch }),
+      signal: AbortSignal.timeout(2_000),
+    })
+  } catch {
+    // diagnostics never change a command's result.
+  }
+}

package/cli/ui.ts

@@ -0,0 +1,68 @@
+const RESET = '\x1b[0m'
+const BOLD = '\x1b[1m'
+const DIM = '\x1b[2m'
+const BRAND_BLUE = '\x1b[38;2;42;95;255m'
+const GREEN = '\x1b[38;5;84m'
+const RED = '\x1b[38;5;203m'
+
+function paint(code: string, value: string): string {
+  if (!process.stdout.isTTY || process.env.NO_COLOR !== undefined) return value
+  return `${code}${value}${RESET}`
+}
+
+export function accent(value: string): string {
+  return paint(BRAND_BLUE, value)
+}
+
+export function bold(value: string): string {
+  return paint(BOLD, value)
+}
+
+export function muted(value: string): string {
+  return paint(DIM, value)
+}
+
+export function success(value: string): string {
+  return paint(GREEN, value)
+}
+
+export function failure(value: string): string {
+  return paint(RED, value)
+}
+
+export function printBrand(subtitle?: string): void {
+  console.log()
+  console.log(`  ${accent('◤◢')} ${bold('rnx')}`)
+  if (subtitle) console.log(`  ${muted(subtitle)}`)
+}
+
+export function printPromptBlock(title: string, description: string[]): void {
+  console.log(`\n  ${accent('◆')} ${bold(title)}`)
+  for (const line of description) console.log(`    ${muted(line)}`)
+}
+
+export async function withSpinner<T>(label: string, run: () => Promise<T>): Promise<T> {
+  if (!process.stdout.isTTY) {
+    console.log(`  ${label}...`)
+    return run()
+  }
+
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+  let index = 0
+  const draw = () => {
+    process.stdout.write(`\r\x1b[2K  ${accent(frames[index++ % frames.length])} ${label}`)
+  }
+  draw()
+  const timer = setInterval(draw, 80)
+
+  try {
+    const result = await run()
+    clearInterval(timer)
+    process.stdout.write(`\r\x1b[2K  ${success('✓')} ${label}\n`)
+    return result
+  } catch (error) {
+    clearInterval(timer)
+    process.stdout.write(`\r\x1b[2K  ${failure('×')} ${label}\n`)
+    throw error
+  }
+}