peachsim 0.1.527

package/cli/commands/camera.ts

@@ -0,0 +1,266 @@
+// rnx camera drives the host-owned camera source. fixture video uses the
+// same hidden video, canvas frame pump, ImageBitmap transfer, and
+// BarcodeDetector loop as a real device camera. `do scan` remains the narrow
+// synthetic special case for callers that have a payload string but no media.
+
+import { createHash, randomUUID } from 'node:crypto'
+import { createReadStream } from 'node:fs'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { cameraFixturesDir } from '../../src/home-paths'
+import { printBridgeFailureDiagnostics } from '../bridge-diagnostics'
+import {
+  createBridgeFromParsed,
+  evalInBridge,
+  parseBridgeCliArgs,
+  type WsBridge,
+} from '../ws-bridge'
+import type { CameraCommand, CameraResult } from '../../src/bridge-contract'
+
+const CAMERA_FIXTURE_ROUTE = '/__camera-fixtures/'
+const VIDEO_EXTENSIONS = new Set(['.m4v', '.mov', '.mp4', '.webm'])
+
+function printHelp() {
+  console.log(`
+rnx camera — control the simulator camera source
+
+usage:
+  rnx camera play <file> [--loop] [--rate <number>]
+  rnx camera stop
+  rnx camera status [--json]
+  rnx do scan <text> [--format <web-format>]
+
+subcommands:
+  play <file>   replace the active camera source with a local video fixture
+  stop          clear fixture mode and restore the live camera source
+  status        report live, fixture, or idle source state
+  scan <text>   inject a synthetic barcode result into an active scan session
+
+options:
+  --loop        loop fixture playback
+  --rate <n>    fixture playback rate (default: 1)
+  --format <f>  synthetic BarcodeDetector format (default: qr_code)
+  --json        print status/result as JSON
+  --sim <id>    target a specific sim
+  --port <p>    WS bridge port (default: 7668)
+
+examples:
+  rnx camera play ./fixtures/qr.mp4 --loop
+  rnx camera play ./fixtures/document.webm --rate 2
+  rnx camera status
+  rnx camera stop
+  rnx do scan "https://example.com" --format qr_code
+`)
+}
+
+function isCameraResult(value: unknown): value is CameraResult {
+  if (!value || typeof value !== 'object') return false
+  const ok = Reflect.get(value, 'ok')
+  const source = Reflect.get(value, 'source')
+  return (
+    typeof ok === 'boolean' &&
+    (source === 'live' || source === 'fixture' || source === 'idle')
+  )
+}
+
+async function sendCameraCommand(
+  bridge: WsBridge,
+  camera: CameraCommand,
+): Promise<CameraResult> {
+  const result: unknown = await bridge.send({ type: 'camera', camera })
+  if (!isCameraResult(result)) {
+    throw new Error('camera bridge returned an invalid result')
+  }
+  return result
+}
+
+function printCameraResult(result: CameraResult, json: boolean): void {
+  if (json) {
+    console.log(JSON.stringify(result))
+    return
+  }
+  if (result.source === 'fixture') {
+    console.log(
+      `  camera source: fixture (${result.url ?? 'unknown url'}, ${
+        result.loop ? 'looping' : 'once'
+      }, ${result.rate ?? 1}x)`,
+    )
+  } else if (result.source === 'live') {
+    console.log('  camera source: live')
+  } else if (result.url) {
+    console.log(
+      `  camera source: idle (fixture queued: ${result.url}, ${
+        result.loop ? 'looping' : 'once'
+      }, ${result.rate ?? 1}x)`,
+    )
+  } else {
+    console.log('  camera source: idle')
+  }
+  if (!result.ok && result.error) console.error(`  camera failed: ${result.error}`)
+}
+
+export async function runCamera(
+  args: string[],
+  opts: { port?: number } = {},
+): Promise<number> {
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--help', '-h', '--json', '--loop'],
+    stripValueFlags: ['--format', '--rate'],
+  })
+  const positional = parsed.positional
+  const subcommand = positional[0]
+  if (
+    !subcommand ||
+    subcommand === 'help' ||
+    args.includes('--help') ||
+    args.includes('-h')
+  ) {
+    printHelp()
+    return subcommand ? 0 : 1
+  }
+
+  const bridge = createBridgeFromParsed(parsed)
+  const json = args.includes('--json')
+  try {
+    if (subcommand === 'scan') {
+      const text = positional[1]
+      if (!text) {
+        console.error('  usage: rnx do scan <text>')
+        return 1
+      }
+      const formatFlag = args.indexOf('--format')
+      const format = formatFlag >= 0 ? args[formatFlag + 1] : 'qr_code'
+      if (!format) {
+        console.error('  --format requires a value')
+        return 1
+      }
+      const injected = await evalInBridge<boolean>(
+        bridge,
+        `globalThis.__sootsimCameraInjectScan?.(${JSON.stringify(text)}, ${JSON.stringify(format)}) ?? false`,
+      )
+      if (!injected) {
+        console.error(
+          '  no active barcode scan session. open a scanning <CameraView> first',
+        )
+        return 1
+      }
+      console.log(`  injected ${format} scan: ${text}`)
+      return 0
+    }
+
+    if (subcommand === 'status') {
+      const result = await sendCameraCommand(bridge, { action: 'status' })
+      printCameraResult(result, json)
+      return result.ok ? 0 : 1
+    }
+
+    if (subcommand === 'stop') {
+      const result = await sendCameraCommand(bridge, { action: 'stop' })
+      printCameraResult(result, json)
+      return result.ok ? 0 : 1
+    }
+
+    if (subcommand === 'play') {
+      const input = positional[1]
+      if (!input) {
+        console.error('  usage: rnx camera play <file> [--loop] [--rate <number>]')
+        return 1
+      }
+      const sourcePath = path.resolve(input)
+      const extension = path.extname(sourcePath).toLowerCase()
+      if (!VIDEO_EXTENSIONS.has(extension)) {
+        console.error(
+          `  unsupported camera fixture extension ${extension || '(none)'}. use mp4, webm, mov, or m4v`,
+        )
+        return 1
+      }
+      let sourceStat
+      try {
+        sourceStat = await fs.stat(sourcePath)
+      } catch {
+        console.error(`  camera fixture not found: ${sourcePath}`)
+        return 1
+      }
+      if (!sourceStat.isFile() || sourceStat.size === 0) {
+        console.error(`  camera fixture must be a non-empty file: ${sourcePath}`)
+        return 1
+      }
+
+      const rateFlag = args.indexOf('--rate')
+      const rawRate = rateFlag >= 0 ? args[rateFlag + 1] : undefined
+      const rate = rawRate === undefined ? 1 : Number(rawRate)
+      if (!Number.isFinite(rate) || rate <= 0) {
+        console.error('  --rate must be a positive finite number')
+        return 1
+      }
+
+      const fixtureDirectory = cameraFixturesDir()
+      await fs.mkdir(fixtureDirectory, { recursive: true })
+      const digest = createHash('sha256')
+      await new Promise<void>((resolve, reject) => {
+        const input = createReadStream(sourcePath)
+        input.on('data', (chunk) => digest.update(chunk))
+        input.once('error', reject)
+        input.once('end', resolve)
+      })
+      const filename = `${digest.digest('hex')}${extension}`
+      const servedPath = path.join(fixtureDirectory, filename)
+      let staged = false
+      try {
+        const servedStat = await fs.lstat(servedPath)
+        if (!servedStat.isFile()) {
+          throw new Error(`camera fixture cache entry is not a file: ${servedPath}`)
+        }
+        staged = true
+      } catch (error) {
+        if (
+          !error ||
+          typeof error !== 'object' ||
+          Reflect.get(error, 'code') !== 'ENOENT'
+        ) {
+          throw error
+        }
+      }
+      if (!staged) {
+        const temporaryPath = path.join(
+          fixtureDirectory,
+          `.${filename}.${process.pid}-${randomUUID()}.tmp`,
+        )
+        await fs.copyFile(sourcePath, temporaryPath)
+        try {
+          await fs.link(temporaryPath, servedPath)
+        } catch (error) {
+          if (
+            !error ||
+            typeof error !== 'object' ||
+            Reflect.get(error, 'code') !== 'EEXIST'
+          ) {
+            throw error
+          }
+        } finally {
+          await fs.unlink(temporaryPath).catch(() => {})
+        }
+      }
+      const url = `http://127.0.0.1:${parsed.wsPort}${CAMERA_FIXTURE_ROUTE}${filename}`
+      const result = await sendCameraCommand(bridge, {
+        action: 'play',
+        url,
+        loop: args.includes('--loop'),
+        rate,
+      })
+      printCameraResult(result, json)
+      return result.ok ? 0 : 1
+    }
+
+    console.error(`  unknown camera subcommand: ${subcommand}`)
+    printHelp()
+    return 1
+  } catch (error) {
+    console.error(`  camera failed: ${error instanceof Error ? error.message : error}`)
+    await printBridgeFailureDiagnostics(bridge)
+    return 1
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/cleanup.ts

@@ -0,0 +1,169 @@
+import {
+  applyAutomaticSootsimCleanup,
+  applySootsimCleanup,
+  formatSootsimBytes,
+  planSootsimCleanup,
+  type SootsimCleanupEntry,
+  type SootsimCleanupKind,
+} from '../../src/disk-cleanup'
+
+const KIND_LABELS: Record<SootsimCleanupKind, string> = {
+  'browser-cache': 'browser caches',
+  'camera-fixture': 'staged camera fixture videos',
+  recording: 'recordings and captured frames',
+  'runtime-archive': 'downloaded runtime archives',
+  'runtime-version': 'inactive runtime versions',
+}
+
+function summarize(entries: SootsimCleanupEntry[]): string[] {
+  const byKind = new Map<SootsimCleanupKind, { bytes: number; count: number }>()
+  for (const entry of entries) {
+    const current = byKind.get(entry.kind) ?? { bytes: 0, count: 0 }
+    current.bytes += entry.bytes
+    current.count++
+    byKind.set(entry.kind, current)
+  }
+  return [...byKind]
+    .sort((left, right) => right[1].bytes - left[1].bytes)
+    .map(
+      ([kind, summary]) =>
+        `  ${KIND_LABELS[kind]}: ${formatSootsimBytes(summary.bytes)} (${summary.count} ${
+          summary.count === 1 ? 'item' : 'items'
+        })`,
+    )
+}
+
+function printHelp(): void {
+  console.log(`
+rnx cleanup — inspect and reclaim local rnx disk usage
+
+usage:
+  rnx cleanup
+  rnx cleanup --apply
+  rnx cleanup --aggressive
+  rnx cleanup --apply --aggressive
+
+The default is a read-only preview. --apply removes downloaded runtime archives,
+old runtimes outside a two-version rollback window, and disposable browser
+caches. It never removes the active runtime, a runtime serving a connected
+simulator, cookies, localStorage, IndexedDB, service workers, or other persistent
+app storage.
+
+--aggressive additionally removes the rollback runtime plus user-created
+recordings and captured frames. It still preserves the active runtime and app storage.
+`)
+}
+
+export async function runCleanup(args: string[]): Promise<number> {
+  if (args.length === 1 && args[0] === '--automatic-worker') {
+    try {
+      const result = applyAutomaticSootsimCleanup()
+      if (result.status === 'complete') {
+        process.stderr.write(
+          result.reclaimedBytes > 0
+            ? `  rnx automatic cleanup reclaimed ${formatSootsimBytes(
+                result.reclaimedBytes,
+              )}; active runtimes and app data were kept.\n`
+            : '  rnx automatic cleanup found no obsolete local data.\n',
+        )
+      } else if (result.status === 'deferred') {
+        process.stderr.write(
+          `  rnx automatic cleanup reclaimed ${formatSootsimBytes(
+            result.reclaimedBytes,
+          )}; ${formatSootsimBytes(
+            result.deferredInUseBytes,
+          )} is in use and will be retried on a later run.\n`,
+        )
+      }
+      return 0
+    } catch (error) {
+      process.stderr.write(
+        `  rnx automatic cleanup will retry on the next run: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`,
+      )
+      return 0
+    }
+  }
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+  const known = new Set(['--aggressive', '--apply'])
+  const unknown = args.find((arg) => !known.has(arg))
+  if (unknown) {
+    console.error(`  cleanup: unknown option ${unknown}`)
+    printHelp()
+    return 1
+  }
+
+  const aggressive = args.includes('--aggressive')
+  const apply = args.includes('--apply')
+  const plan = planSootsimCleanup({ aggressive })
+  const selected = plan.entries.filter((entry) => entry.selected)
+  const safe = selected.filter((entry) => entry.state === 'safe')
+  const aggressiveOnly = plan.entries.filter(
+    (entry) => entry.state === 'aggressive' && entry.selected,
+  )
+  const inUse = plan.entries.filter((entry) => entry.state === 'in-use')
+  const inUseBrowserCaches = inUse.filter((entry) => entry.kind === 'browser-cache')
+  const inUseRuntimes = inUse.filter((entry) => entry.kind === 'runtime-version')
+  const rollback = plan.entries.find(
+    (entry) => entry.kind === 'runtime-version' && entry.state === 'aggressive',
+  )
+
+  console.log(`  rnx data home: ${plan.home}`)
+  console.log(`  current size: ${formatSootsimBytes(plan.totalBytes)}`)
+  console.log(`  active runtime: ${plan.activeRuntime ?? '(none installed)'}`)
+  console.log('')
+  console.log(apply ? '  safe items selected for removal:' : '  safe to reclaim:')
+  for (const line of summarize(safe)) console.log(line)
+  if (safe.length === 0) console.log('  nothing')
+
+  if (aggressiveOnly.length > 0) {
+    console.log('')
+    console.log('  aggressive additions:')
+    for (const line of summarize(aggressiveOnly)) console.log(line)
+  }
+
+  console.log('')
+  console.log('  protected:')
+  if (plan.activeRuntime) console.log(`  active runtime ${plan.activeRuntime} (in use)`)
+  for (const entry of inUseRuntimes) {
+    console.log(`  running daemon runtime ${entry.path}`)
+  }
+  if (rollback && !aggressive) {
+    console.log(`  rollback runtime ${rollback.path}`)
+  }
+  console.log('  cookies, localStorage, IndexedDB, service workers, and profile data')
+  if (!aggressive) {
+    console.log('  recordings and captured frames (use --aggressive to remove)')
+  }
+  if (inUseBrowserCaches.length > 0) {
+    console.log(
+      `  ${formatSootsimBytes(
+        inUseBrowserCaches.reduce((total, entry) => total + entry.bytes, 0),
+      )} ` + `of browser cache is open; close rnx and rerun cleanup`,
+    )
+  }
+
+  console.log('')
+  console.log(`  reclaimable now: ${formatSootsimBytes(plan.reclaimableBytes)}`)
+  if (!apply) {
+    console.log(
+      `  preview only — run \`rnx cleanup --apply${
+        aggressive ? ' --aggressive' : ''
+      }\` to remove these items`,
+    )
+    return 0
+  }
+
+  const result = applySootsimCleanup({ aggressive })
+  console.log(
+    `  removed ${result.removedPaths.length} ${
+      result.removedPaths.length === 1 ? 'item' : 'items'
+    }; reclaimed ${formatSootsimBytes(result.reclaimedBytes)}`,
+  )
+  console.log(`  remaining rnx data: ${formatSootsimBytes(result.remainingBytes)}`)
+  return 0
+}

package/cli/commands/compat.ts

@@ -0,0 +1,176 @@
+// rnx compat — scan dependencies with the shared compatibility engine.
+
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import {
+  COMPAT_RESULT_CAVEAT,
+  formatDetailedScanLines,
+  formatScanCounts,
+  scanDeps,
+  type ScanResult,
+} from '@sootsim/compat/web'
+import { findProjectRoot, scanWorkspace } from './detect'
+
+interface PackageManifest {
+  name?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+export async function runCompat(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+rnx compat — check package compatibility
+
+usage:
+  rnx compat [package-name]
+  rnx compat --json
+  rnx compat --brief
+
+flags:
+  --json       machine-readable output
+  --brief      one-line summary
+  --app <dir>  target directory (default: cwd)
+`)
+    return
+  }
+
+  const appIndex = args.indexOf('--app')
+  const appDir =
+    appIndex >= 0 && args[appIndex + 1] ? resolve(args[appIndex + 1]) : process.cwd()
+  const packageName = args.find(
+    (arg, index) => !arg.startsWith('-') && (appIndex < 0 || index !== appIndex + 1),
+  )
+  const pkg = readPackageJson(appDir)
+  if (!pkg) {
+    console.error(`  no package.json found in ${appDir}`)
+    process.exitCode = 1
+    return
+  }
+
+  if (packageName) {
+    report(args, scanOnePackage(appDir, pkg, packageName))
+    return
+  }
+
+  const here = scanDeps(installedManifest(appDir, pkg))
+  if (here.packages.length > 0 || appIndex >= 0) {
+    report(args, here)
+    return
+  }
+
+  // a monorepo root manifest is not the app. it carries react-native and expo
+  // so the workspace resolves and little else, so scanning it reports a
+  // project with nothing to check while the real app sits in a subdirectory.
+  const workspaceRoot = findProjectRoot(appDir)
+  const elsewhere = scanWorkspace(workspaceRoot).apps.flatMap((app) => {
+    if (resolve(app.dir) === appDir) return []
+    const manifest = readPackageJson(app.dir)
+    if (!manifest) return []
+    const result = scanDeps(installedManifest(app.dir, manifest))
+    return result.packages.length > 0 ? [{ dir: app.dir, result }] : []
+  })
+
+  if (elsewhere.length === 1) {
+    const only = elsewhere[0]
+    console.log(`\n  scanning ${relative(appDir, only.dir) || '.'}`)
+    report(args, only.result)
+    return
+  }
+  if (elsewhere.length > 1) {
+    console.log(`\n  this workspace has more than one app. scan one with --app:`)
+    for (const entry of elsewhere) {
+      console.log(`    rnx compat --app ${relative(appDir, entry.dir)}`)
+    }
+    console.log()
+    return
+  }
+  report(args, here)
+}
+
+function report(args: string[], result: ScanResult): void {
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(result, null, 2))
+    return
+  }
+  if (args.includes('--brief')) {
+    console.log(`  ${formatScanCounts(result)}`)
+    console.log(`  ${COMPAT_RESULT_CAVEAT}`)
+    return
+  }
+
+  console.log(`\n  rnx compatibility report`)
+  console.log(`  ${formatScanCounts(result)}\n`)
+  for (const line of formatDetailedScanLines(result)) console.log(`    ${line}`)
+  const supported = result.packages.filter((item) => item.status === 'full').length
+  if (supported > 0) console.log(`    supported: ${supported} packages`)
+  const notRelevant = result.packages.filter(
+    (item) => item.status === 'not-relevant',
+  ).length
+  if (notRelevant > 0) console.log(`    not relevant at runtime: ${notRelevant} packages`)
+  if (result.packages.length === 0) {
+    console.log(`    no React Native ecosystem packages detected`)
+  }
+  console.log(`\n  ${COMPAT_RESULT_CAVEAT}\n`)
+}
+
+// the declared range is often not a version: pnpm and bun catalogs write
+// `catalog:`, a workspace dependency writes `workspace:*`, and a pinned tarball
+// writes a URL. none of those match a verified version range, so a whole app
+// reports as unverified. the installed tree holds the version that will
+// actually run, so ask it, and keep the declared range for anything the project
+// has not installed.
+function installedManifest(appDir: string, pkg: PackageManifest): PackageManifest {
+  const resolveVersion = (name: string, declared: string): string => {
+    let dir = appDir
+    while (true) {
+      const manifest = join(dir, 'node_modules', name, 'package.json')
+      if (existsSync(manifest)) {
+        try {
+          const parsed: unknown = JSON.parse(readFileSync(manifest, 'utf8'))
+          if (parsed && typeof parsed === 'object' && 'version' in parsed) {
+            const version = parsed.version
+            if (typeof version === 'string') return version
+          }
+        } catch {}
+        return declared
+      }
+      const parent = dirname(dir)
+      if (parent === dir) return declared
+      dir = parent
+    }
+  }
+  const mapped = (deps: Record<string, string> | undefined) =>
+    deps &&
+    Object.fromEntries(
+      Object.entries(deps).map(([name, declared]) => [
+        name,
+        resolveVersion(name, declared),
+      ]),
+    )
+  return {
+    name: pkg.name,
+    dependencies: mapped(pkg.dependencies),
+    devDependencies: mapped(pkg.devDependencies),
+  }
+}
+
+function readPackageJson(appDir: string): PackageManifest | null {
+  const packagePath = resolve(appDir, 'package.json')
+  if (!existsSync(packagePath)) return null
+  const parsed: unknown = JSON.parse(readFileSync(packagePath, 'utf8'))
+  return parsed && typeof parsed === 'object' ? parsed : null
+}
+
+function scanOnePackage(
+  appDir: string,
+  pkg: PackageManifest,
+  packageName: string,
+): ScanResult {
+  const installed = installedManifest(appDir, pkg)
+  const version =
+    installed.dependencies?.[packageName] ??
+    installed.devDependencies?.[packageName] ??
+    '*'
+  return scanDeps({ dependencies: { [packageName]: version } })
+}

package/cli/commands/config.ts

@@ -0,0 +1,34 @@
+import { rnxExit } from '../run-rnx'
+import { runTelemetry } from './telemetry'
+
+function printHelp(): void {
+  console.log(`
+rnx config — manage local CLI preferences
+
+usage:
+  rnx config telemetry [on|off|status]
+
+environment:
+  RNX_HINTS=off          suppress CLI hints
+  RNX_HINTS=always       show every CLI hint every time
+  RNX_UPDATE_CHECK=off   disable background CLI update checks and notices
+`)
+}
+
+export async function runConfig(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const sub = args.find((arg) => !arg.startsWith('-'))
+  if (sub === 'telemetry') {
+    const index = args.indexOf(sub)
+    await runTelemetry([...args.slice(0, index), ...args.slice(index + 1)])
+    return
+  }
+
+  console.error(`  unknown config command: ${sub ?? '(missing)'}`)
+  printHelp()
+  rnxExit(1)
+}