peachsim 0.1.527

package/cli/commands/perf.ts

@@ -0,0 +1,67 @@
+import { runCpuProfile } from './cpu-profile'
+import { runInspect } from './inspect'
+import { runReact } from './react'
+
+interface PerfOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const VALUE_FLAGS = new Set(['--sim', '--port', '-p'])
+const SUBCOMMANDS = new Set(['cpu', 'react', 'shell', 'scroll'])
+
+function findSubcommand(args: string[]): { name: string; index: number } | null {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('-')) {
+      if (VALUE_FLAGS.has(arg)) i++
+      continue
+    }
+    return SUBCOMMANDS.has(arg) ? { name: arg, index: i } : null
+  }
+  return null
+}
+
+function withoutSubcommand(args: string[], index: number): string[] {
+  return [...args.slice(0, index), ...args.slice(index + 1)]
+}
+
+function printHelp(): void {
+  console.log(`
+rnx perf — performance profiling tools
+
+usage:
+  rnx perf cpu [options]
+  rnx perf react <subcommand> [options]
+  rnx perf shell <start|stop|transition> [options]
+  rnx perf scroll <start|stop> [options]
+
+examples:
+  rnx perf cpu --duration 5 --output /tmp/trace.cpuprofile
+    # writes page + every worker profile and a role-labelled manifest
+  rnx perf react summary --limit 10
+  rnx perf shell start
+  rnx perf shell stop --json
+  rnx perf scroll start
+  rnx perf scroll stop --json
+`)
+}
+
+export async function runPerf(args: string[], opts: PerfOptions): Promise<number> {
+  const sub = findSubcommand(args)
+  if (!sub) {
+    printHelp()
+    return args.includes('--help') || args.includes('-h') ? 0 : 1
+  }
+
+  const rest = withoutSubcommand(args, sub.index)
+  if (sub.name === 'cpu') return runCpuProfile(rest, opts)
+  if (sub.name === 'react') return runReact(rest, opts)
+
+  const inspectArgs = rest.includes('--help') || rest.includes('-h') ? [] : rest
+  await runInspect(['debug', 'perf', ...inspectArgs], {
+    ...opts,
+    internalPerfCommand: sub.name === 'scroll' ? 'scroll' : 'shell',
+  })
+  return typeof process.exitCode === 'number' ? process.exitCode : 0
+}

package/cli/commands/permissions.ts

@@ -0,0 +1,203 @@
+import {
+  callInBridge,
+  callInBridgeWrite,
+  createBridgeFromParsed,
+  parseBridgeCliArgs,
+} from '../ws-bridge'
+import type {
+  AppSettingsSnapshot,
+  SystemPermissionApp,
+  SystemPermissionKind,
+  SystemPermissionMutation,
+  SystemPermissionStatus,
+} from '@rnx/globals'
+
+interface PermissionsOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const STATUSES: readonly SystemPermissionStatus[] = [
+  'not-determined',
+  'restricted',
+  'denied',
+  'authorized',
+  'limited',
+  'provisional',
+  'ephemeral',
+  'unavailable',
+]
+
+const KINDS: readonly SystemPermissionKind[] = [
+  'app-tracking-transparency',
+  'bluetooth',
+  'calendars',
+  'camera',
+  'contacts',
+  'face-id',
+  'local-network',
+  'location-always',
+  'location-when-in-use',
+  'media-library',
+  'microphone',
+  'motion',
+  'notifications',
+  'photo-library',
+  'photo-library-add-only',
+  'reminders',
+  'siri',
+  'speech-recognition',
+]
+
+function printHelp(): void {
+  console.log(`
+rnx permissions — inspect and change simulated operating-system permissions
+
+usage:
+  rnx permissions list [--json]
+  rnx permissions get <app-id> [--json]
+  rnx permissions set <app-id> <kind> <status> [--once] [--accuracy full|reduced] [--json]
+  rnx permissions reset <app-id> [kind] [--json]
+`)
+}
+
+function print(value: unknown, json: boolean): void {
+  console.log(json ? JSON.stringify(value, null, 2) : value)
+}
+
+function flagValue(args: string[], flag: string): string | undefined {
+  const index = args.indexOf(flag)
+  return index >= 0 ? args[index + 1] : undefined
+}
+
+function permissionKind(value: string): SystemPermissionKind | null {
+  return KINDS.find((candidate) => candidate === value) ?? null
+}
+
+function permissionStatus(value: string): SystemPermissionStatus | null {
+  return STATUSES.find((candidate) => candidate === value) ?? null
+}
+
+function mutationFor(
+  status: SystemPermissionStatus,
+  once: boolean,
+  accuracy: 'full' | 'reduced' | undefined,
+): SystemPermissionMutation {
+  switch (status) {
+    case 'authorized':
+      return {
+        status,
+        ...(once ? { authorizationScope: 'once' } : null),
+        ...(accuracy ? { locationAccuracy: accuracy } : null),
+      }
+    case 'not-determined':
+    case 'restricted':
+    case 'denied':
+    case 'limited':
+    case 'provisional':
+    case 'ephemeral':
+    case 'unavailable':
+      return { status }
+  }
+}
+
+export async function runPermissions(
+  args: string[],
+  opts: PermissionsOptions,
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--json', '--once'],
+    stripValueFlags: ['--accuracy'],
+  })
+  const [command, appId, kindValue, statusValue] = parsed.positional
+  if (!command) {
+    printHelp()
+    return 1
+  }
+  const json = args.includes('--json')
+  const bridge = createBridgeFromParsed(parsed)
+  try {
+    if (command === 'list') {
+      const apps = await callInBridge<readonly SystemPermissionApp[]>(
+        bridge,
+        'SootSim.bridges.test.permissionListApps',
+      )
+      print(
+        json ? apps : apps.map((app) => `${app.appId}\t${app.displayName}`).join('\n'),
+        json,
+      )
+      return 0
+    }
+    if (!appId) throw new Error(`${command} requires an app id`)
+    if (command === 'get') {
+      const snapshot = await callInBridge<AppSettingsSnapshot>(
+        bridge,
+        'SootSim.bridges.test.permissionGetAppSettings',
+        appId,
+      )
+      print(snapshot, json)
+      return 0
+    }
+    if (command === 'reset') {
+      if (kindValue) {
+        const kind = permissionKind(kindValue)
+        if (!kind) throw new Error(`unknown permission kind: ${kindValue}`)
+        await callInBridgeWrite<AppSettingsSnapshot>(
+          bridge,
+          'SootSim.bridges.test.permissionSetAppPermission',
+          appId,
+          kind,
+          { status: 'not-determined' },
+        )
+      } else {
+        await callInBridgeWrite<void>(
+          bridge,
+          'SootSim.bridges.test.permissionResetApp',
+          appId,
+        )
+      }
+      const snapshot = await callInBridge<AppSettingsSnapshot>(
+        bridge,
+        'SootSim.bridges.test.permissionGetAppSettings',
+        appId,
+      )
+      print(snapshot, json)
+      return 0
+    }
+    if (command !== 'set') throw new Error(`unknown permissions command: ${command}`)
+    if (!kindValue || !statusValue) {
+      throw new Error('set requires an app id, permission kind, and status')
+    }
+    const kind = permissionKind(kindValue)
+    if (!kind) throw new Error(`unknown permission kind: ${kindValue}`)
+    const status = permissionStatus(statusValue)
+    if (!status) throw new Error(`unknown permission status: ${statusValue}`)
+    const accuracyValue = flagValue(args, '--accuracy')
+    const accuracy =
+      accuracyValue === 'full' || accuracyValue === 'reduced' ? accuracyValue : undefined
+    if (accuracyValue && !accuracy) {
+      throw new Error(`unknown location accuracy: ${accuracyValue}`)
+    }
+    const snapshot = await callInBridgeWrite<AppSettingsSnapshot>(
+      bridge,
+      'SootSim.bridges.test.permissionSetAppPermission',
+      appId,
+      kind,
+      mutationFor(status, args.includes('--once'), accuracy),
+    )
+    print(snapshot, json)
+    return 0
+  } catch (error) {
+    console.error(
+      `  permissions failed: ${error instanceof Error ? error.message : error}`,
+    )
+    return 1
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/platform.ts

@@ -0,0 +1,410 @@
+// `rnx ios` and `rnx android` — start a simulator on that platform.
+//
+// the platform picks the device; the command context picks where the sim runs
+// (this machine, a local box, or the `rnx remote` namespace). this file resolves
+// the device and hands the rest to the normal open path.
+
+import {
+  DEFAULT_DEVICE_BY_PLATFORM,
+  devices,
+  getRuntimePlatform,
+  listSelectableDeviceModels,
+  type DeviceModel,
+  type RuntimePlatform,
+} from 'sootsim-engine/settings'
+import { settingsStore } from 'sootsim-engine/settings/store'
+import { rnxPublicBrand } from '../../src/public-brand'
+import { rethrowIfExit } from '../run-rnx'
+import type { CloudSession } from '../cloud-session'
+
+const PLATFORM_LABEL: Record<RuntimePlatform, string> = {
+  ios: 'iOS',
+  android: 'Android',
+}
+
+function isDeviceModel(value: string): value is DeviceModel {
+  return value in devices
+}
+
+// flags this command reads for itself rather than treating as the bundle.
+const REMOTE_VALUE_FLAGS = new Set(['--device'])
+
+function remoteInputFromArgs(
+  args: string[],
+  platform: RuntimePlatform,
+): {
+  bundlePath: string
+  reuse: boolean
+  fresh: boolean
+} {
+  const positional: string[] = []
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]
+    if (arg === '--remote' || arg === '--reuse' || arg === '--new') continue
+    if (REMOTE_VALUE_FLAGS.has(arg)) {
+      const value = args[++index] ?? null
+      if (!value) throw new Error(`rnx remote ${platform} ${arg} requires a value`)
+      continue
+    }
+    const assigned = arg.match(/^(--[a-z-]+)=(.*)$/)
+    if (assigned && REMOTE_VALUE_FLAGS.has(assigned[1] ?? '')) {
+      const value = assigned[2] ?? ''
+      if (!value)
+        throw new Error(`rnx remote ${platform} ${assigned[1]} requires a value`)
+      continue
+    }
+    if (
+      arg === '--sim' ||
+      arg === '--session' ||
+      arg === '--tab' ||
+      arg.startsWith('--sim=') ||
+      arg.startsWith('--session=') ||
+      arg.startsWith('--tab=')
+    ) {
+      throw new Error(
+        `rnx remote ${platform} creates a new simulator and cannot target --sim`,
+      )
+    }
+    if (arg.startsWith('-')) {
+      throw new Error(`rnx remote ${platform} does not support ${arg}`)
+    }
+    positional.push(arg)
+  }
+  if (positional.length !== 1 || !positional[0]) {
+    throw new Error(
+      `usage: rnx remote ${platform} <local bundle.js|https://bundle-url> [--device <model>] [--reuse|--new]`,
+    )
+  }
+  const reuse = args.includes('--reuse')
+  const fresh = args.includes('--new')
+  if (reuse && fresh) {
+    throw new Error(`rnx remote ${platform} cannot combine --reuse and --new`)
+  }
+  return { bundlePath: positional[0], reuse, fresh }
+}
+
+export async function runPlatformCommand(
+  platform: RuntimePlatform,
+  args: string[],
+  opts: { port?: number } = {},
+): Promise<number | undefined> {
+  // `--device` is applied to the settings store before dispatch, so a
+  // contradiction shows up here as a platform mismatch. refuse it by name
+  // rather than silently overriding whichever one the user meant.
+  const assignedDevice = args.find((arg) => arg.startsWith('--device='))
+  const explicitDevice =
+    args.find((_, i) => args[i - 1] === '--device') ?? assignedDevice?.slice(9)
+  let selectedDevice: DeviceModel
+  if (explicitDevice !== undefined) {
+    if (!isDeviceModel(explicitDevice)) {
+      console.error(
+        `  ${rnxPublicBrand.commandName} ${platform}: unknown device "${explicitDevice}"\n` +
+          `  run \`${rnxPublicBrand.commandName} device list\` to see valid models`,
+      )
+      return 1
+    }
+    const devicePlatform = getRuntimePlatform(explicitDevice)
+    if (devicePlatform !== platform) {
+      console.error(
+        `  ${rnxPublicBrand.commandName} ${platform}: --device ${explicitDevice} is ` +
+          `${PLATFORM_LABEL[devicePlatform]}, not ${PLATFORM_LABEL[platform]}.\n` +
+          `  pick one of: ${listSelectableDeviceModels()
+            .filter((model) => getRuntimePlatform(model) === platform)
+            .join(', ')}`,
+      )
+      return 1
+    }
+    selectedDevice = explicitDevice
+  } else {
+    // keep the user's own device when it already belongs to the platform they
+    // asked for, so `rnx ios` after `rnx device set iphone-16` does not
+    // silently snap back to the default model.
+    const current = settingsStore.get('deviceModel')
+    if (getRuntimePlatform(current) !== platform) {
+      settingsStore.apply({ deviceModel: DEFAULT_DEVICE_BY_PLATFORM[platform] })
+      selectedDevice = DEFAULT_DEVICE_BY_PLATFORM[platform]
+    } else {
+      selectedDevice = current
+    }
+  }
+
+  if (args.includes('--remote')) {
+    try {
+      return await runRemoteCreate(platform, args, selectedDevice)
+    } catch (error) {
+      rethrowIfExit(error)
+      console.error(
+        `  ${rnxPublicBrand.commandName} ${platform} --remote failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      )
+      return 1
+    }
+  }
+
+  // leftover `--*` tokens are not bundle targets. parse the same flags `open`
+  // consumes, then refuse anything still starting with `-`.
+  const { parseBridgeCliArgs } = await import('../ws-bridge')
+  const leftover = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: [
+      '--new',
+      '--headless',
+      '--headed',
+      '--ephemeral',
+      '--hot',
+      '--no-hmr',
+      '--no-describe',
+      '--quiet',
+      '--remote',
+    ],
+    stripValueFlags: [
+      '--base-url',
+      '--replace',
+      '--driver',
+      '--profile',
+      '--cdp-port',
+      '--device',
+      '--viewport',
+      '--remap',
+    ],
+  }).positional.find((value) => value.startsWith('-'))
+  if (leftover) {
+    console.error(`  unknown flag: ${leftover}`)
+    return 1
+  }
+
+  const { runOpenCommand } = await import('./control')
+  await runOpenCommand(args, { port: opts.port })
+  return 0
+}
+
+/** Runs the existing remote session path without changing the local platform commands. */
+export function runRemotePlatformCommand(
+  platform: RuntimePlatform,
+  args: string[],
+  opts: { port?: number } = {},
+): Promise<number | undefined> {
+  return runPlatformCommand(platform, ['--remote', ...args], opts)
+}
+
+const REMOTE_COMMANDS_HELP =
+  '  commands: describe, find, get tree|node|count|memory, wait ready|selector, do, reset, logs, state, screenshot'
+
+/**
+ * `rnx remote ios|android <bundle>` on the one customer plane: one typed
+ * create through the instance API for both platforms, and a reattach to the
+ * shell's own simulator when it already runs this bundle. the box stays the
+ * host behind the API and is never created or addressed here.
+ */
+async function runRemoteCreate(
+  platform: RuntimePlatform,
+  args: string[],
+  selectedDevice: string,
+): Promise<number> {
+  const input = remoteInputFromArgs(args, platform)
+  const [
+    { authHeaderOrExit, cloudAccountIdOrExit },
+    {
+      claimCloudSimulator,
+      closeCloudSession,
+      createRemoteSim,
+      getRemoteSim,
+      produceCloudArtifact,
+    },
+    {
+      createCloudSession,
+      publishCloudSessionToShell,
+      readCloudSession,
+      requireCloudSessionShellUpdate,
+    },
+    { openInBrowser },
+  ] = await Promise.all([
+    import('../auth'),
+    import('../cloud-client'),
+    import('../cloud-session'),
+    import('./box'),
+  ])
+  const artifact = await produceCloudArtifact(input.bundlePath)
+  const descriptor = requireCloudSessionShellUpdate()
+  const { auth, header } = authHeaderOrExit(`${platform} --remote`)
+  const accountId = cloudAccountIdOrExit(auth)
+
+  const existingSession = readCloudSession()
+  if (
+    existingSession &&
+    !input.fresh &&
+    existingSession.platform === platform &&
+    existingSession.artifact?.sha256 === artifact.sha256
+  ) {
+    // an api key reads the simulator back through the account, which mints a
+    // fresh watch url with the read. any other credential rereads with the
+    // simulator's own token and keeps the stored watch url.
+    const live = await getRemoteSim({
+      apiOrigin: existingSession.apiOrigin,
+      simId: existingSession.simId,
+      authorization: auth.kind === 'api-key' ? header : `Bearer ${existingSession.token}`,
+    })
+    if (live && (live.status === 'open' || live.status === 'hibernated')) {
+      const claimed = await claimCloudSimulator(existingSession)
+      const streamUrl = live.streamUrl ?? existingSession.streamUrl ?? null
+      const session = createCloudSession({
+        ...existingSession,
+        claimId: claimed.claim.id,
+        ...(streamUrl ? { streamUrl } : {}),
+      })
+      publishCloudSessionToShell(session, descriptor)
+      console.log(
+        `  reconnected to remote simulator: ${existingSession.simId} (${platform})`,
+      )
+      console.log(`  claim expires: ${claimed.claim.expiresAt}`)
+      console.log(REMOTE_COMMANDS_HELP)
+      return 0
+    }
+  }
+
+  // the new session supersedes the old one, so the shell update channel
+  // carries exactly one update: the shell accepts nothing else.
+  if (existingSession) await closeCloudSession(existingSession)
+  const created = await createRemoteSim({
+    bundlePath: input.bundlePath,
+    device: selectedDevice,
+    authorization: header,
+    accountId,
+    platform,
+    reuse: input.reuse,
+  })
+  try {
+    publishCloudSessionToShell(created.session, descriptor)
+  } catch (error) {
+    await closeCloudSession(created.session)
+    throw error
+  }
+  const receipt = created.receipt
+  const produced = created.artifact
+  console.log(`  remote simulator: ${receipt.simId}${created.reused ? ' (reused)' : ''}`)
+  console.log(`  platform: ${platform}`)
+  console.log(`  device: ${selectedDevice}`)
+  console.log(`  artifact: ${receipt.artifact.id} (${receipt.artifact.bytes} bytes)`)
+  console.log(
+    `  source bundle: sha256:${produced.source.sha256} (${produced.source.bytes} bytes)`,
+  )
+  console.log(
+    `  normalized modules: ${produced.modules}; javascript ${produced.javascript.sourceBytes} -> ${produced.javascript.minifiedBytes} bytes`,
+  )
+  console.log(
+    `  embedded assets: ${produced.assets.descriptors} descriptors, ${produced.assets.variants} scales, ${produced.assets.bytes} bytes (${produced.assets.encodedBytes} encoded)`,
+  )
+  // the dest directory was chosen by resolving this bundle's descriptors
+  // against it, so say which one won rather than leaving it invisible.
+  if (created.assetsDirectory) {
+    console.log(`  asset dest: ${created.assetsDirectory}`)
+  }
+  console.log(`  claim expires: ${receipt.claim.expiresAt}`)
+  console.log(REMOTE_COMMANDS_HELP)
+  for (const warning of created.warnings) console.warn(`  warning: ${warning}`)
+  if (!created.session.streamUrl) {
+    console.log('  the service minted no watch url for this simulator')
+    return 0
+  }
+  return openInBrowser(created.session.streamUrl)
+}
+
+/** `rnx remote list`: the simulators this account runs that `rnx remote` made. */
+export async function runRemoteList(args: string[]): Promise<number> {
+  try {
+    let json = false
+    for (const arg of args) {
+      if (arg === '--json') {
+        json = true
+        continue
+      }
+      throw new Error(`usage: rnx remote list [--json]`)
+    }
+    const [{ authHeaderOrExit, cloudAccountIdOrExit }, { listRemoteSims }] =
+      await Promise.all([import('../auth'), import('../cloud-client')])
+    const { auth, header } = authHeaderOrExit('remote list')
+    const accountId = cloudAccountIdOrExit(auth)
+    const sims = await listRemoteSims({ authorization: header, accountId })
+    if (json) {
+      console.log(JSON.stringify({ sims }))
+      return 0
+    }
+    if (sims.length === 0) {
+      console.log('  no remote simulators are running')
+      return 0
+    }
+    for (const sim of sims) {
+      const platformLabel = sim.labels['rnx.platform'] ?? 'unknown'
+      console.log(
+        `  ${sim.simId}  ${sim.status}  ${platformLabel}  sha256:${sim.artifact.sha256.slice(0, 12)}`,
+      )
+    }
+    return 0
+  } catch (error) {
+    rethrowIfExit(error)
+    console.error(
+      `  ${rnxPublicBrand.commandName} remote list failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+    return 1
+  }
+}
+
+/** `rnx remote stop <id>`: delete one remote simulator by id. */
+export async function runRemoteStop(args: string[]): Promise<number> {
+  try {
+    const positional = args.filter((arg) => !arg.startsWith('-'))
+    if (
+      args.some((arg) => arg.startsWith('-')) ||
+      positional.length !== 1 ||
+      !positional[0]
+    ) {
+      throw new Error(`usage: rnx remote stop <sim-id>`)
+    }
+    const simId = positional[0]
+    const [
+      { authHeaderOrExit, cloudAccountIdOrExit },
+      { deleteRemoteSim },
+      { publishCloudSessionToShell, readCloudSession, requireCloudSessionShellUpdate },
+    ] = await Promise.all([
+      import('../auth'),
+      import('../cloud-client'),
+      import('../cloud-session'),
+    ])
+    let current: CloudSession | null = null
+    try {
+      current = readCloudSession()
+    } catch {
+      current = null
+    }
+    // stopping the shell's own simulator clears the shell with it, so the
+    // update channel is required before anything is deleted.
+    const descriptor = current?.simId === simId ? requireCloudSessionShellUpdate() : null
+    const { auth, header } = authHeaderOrExit('remote stop')
+    const accountId = cloudAccountIdOrExit(auth)
+    const deleted = await deleteRemoteSim({
+      simId,
+      authorization: header,
+      accountId,
+    })
+    if (!deleted) {
+      console.error(
+        `  ${rnxPublicBrand.commandName} remote stop: ${simId} does not exist`,
+      )
+      return 1
+    }
+    if (descriptor !== null) publishCloudSessionToShell(null, descriptor)
+    console.log(`  stopped remote simulator: ${deleted.simId}`)
+    return 0
+  } catch (error) {
+    rethrowIfExit(error)
+    console.error(
+      `  ${rnxPublicBrand.commandName} remote stop failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+    return 1
+  }
+}