peachsim 0.1.527

package/cli/commands/preview.ts

@@ -0,0 +1,103 @@
+import { createHash } from 'node:crypto'
+import { brotliBundle } from 'sootsim-engine/preview/compress-node'
+import {
+  runPresignedUpload,
+  type InitRequestBody,
+} from 'sootsim-engine/preview/presigned-upload'
+import { authHeaderValue, cloudAccountIdOrExit, resolveCliAuth } from '../auth'
+import { producePreviewArtifact } from '../cloud-client'
+import { openUrl } from '../open-url'
+import { resolveDefaultUploadOrigin, resolvePublicPreviewOrigin } from './upload'
+
+function takeValue(args: string[], flag: string): string | null {
+  const index = args.indexOf(flag)
+  if (index < 0) return null
+  const value = args[index + 1]
+  args.splice(index, 2)
+  if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value`)
+  return value
+}
+
+export async function runPreview(args: string[]): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+rnx preview — publish a prebuilt React Native bundle as a standalone share
+
+usage:
+  rnx preview <bundle.js|https://bundle-url> [--platform ios|android] [--open]
+
+The share contains the immutable build and its automatically discovered Metro assets. It is not a recorded replay.
+`)
+    return 0
+  }
+  try {
+    const input = [...args]
+    const origin = await resolveDefaultUploadOrigin(
+      takeValue(input, '--origin') ?? undefined,
+    )
+    const publicOrigin = resolvePublicPreviewOrigin(
+      origin,
+      takeValue(input, '--public-origin') ?? undefined,
+    )
+    const platform = takeValue(input, '--platform') ?? 'ios'
+    const openIndex = input.indexOf('--open')
+    const open = openIndex >= 0
+    if (open) input.splice(openIndex, 1)
+    if (platform !== 'ios' && platform !== 'android') {
+      throw new Error('--platform must be ios or android')
+    }
+    if (input.length !== 1 || input[0]?.startsWith('-')) {
+      throw new Error('usage: rnx preview <bundle.js|https://bundle-url>')
+    }
+    const auth = resolveCliAuth()
+    if (!auth) throw new Error('rnx preview needs `rnx login` or RNX_API_KEY')
+    const accountId = cloudAccountIdOrExit(auth)
+
+    const artifact = await producePreviewArtifact(input[0])
+    const bundle = brotliBundle(artifact.bytes)
+    const initBody: InitRequestBody = {
+      kind: 'build',
+      buildPlatform: platform,
+      contentHash: createHash('sha256').update(artifact.bytes).digest('hex'),
+      bundleSizeBytes: artifact.bytes.byteLength,
+      bundleContentType: 'application/javascript',
+      bundleEncoding: 'br',
+      bundleMinified: true,
+      bundleOrigin: null,
+      entry: null,
+      isTransformed: false,
+      deviceSpec:
+        platform === 'android'
+          ? { model: 'pixel-8', width: 412, height: 915 }
+          : { model: 'iphone-16', width: 402, height: 874 },
+      files: [],
+    }
+    const { finalize } = await runPresignedUpload({
+      originBase: origin,
+      endpoints: {
+        init: '/api/v1/previews',
+        finalize: '/api/v1/previews/finalize',
+      },
+      initBody,
+      bundleBytes: bundle,
+      filesByHash: new Map(),
+      authHeader: authHeaderValue(auth),
+      accountId,
+    })
+    const url = finalize.url.startsWith('http')
+      ? finalize.url
+      : `${publicOrigin}${finalize.url}`
+    console.log(`  preview: ${url}`)
+    console.log(
+      `  artifact: sha256:${artifact.sha256} (${artifact.bytes.byteLength} bytes)`,
+    )
+    for (const warning of artifact.warnings) console.warn(`  warning: ${warning}`)
+    if (open) await openUrl(url)
+    return 0
+  } catch (error) {
+    console.error(
+      `  rnx preview failed: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return 1
+  }
+}

package/cli/commands/profile.ts

@@ -0,0 +1,106 @@
+// rnx storage profile — manage isolated app storage profiles.
+
+import {
+  clearProfileStorage,
+  createProfile,
+  deleteProfile,
+  ensureProfile,
+  listProfiles,
+} from '../../src/profiles'
+
+interface ProfileOptions {
+  port?: number
+  verbose?: boolean
+}
+
+function printHelp() {
+  console.log(`
+rnx storage profile — manage isolated storage profiles
+
+usage:
+  rnx storage profile list
+  rnx storage profile create <id>
+  rnx storage profile clear <id>
+  rnx storage profile delete <id>
+
+profiles isolate cookies, localStorage, IndexedDB, cache, permissions, and
+service workers in Electron and Playwright launches. Plain browser-tab launches
+cannot honor profiles and will fail clearly if a profile is requested.
+
+examples:
+  rnx storage profile list
+  rnx storage profile create qa
+  rnx open 8081 --profile qa
+  rnx open 8081 --profile qa --driver playwright
+  rnx storage profile clear qa
+  rnx storage profile delete qa
+`)
+}
+
+export async function runProfile(args: string[], _opts: ProfileOptions): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+
+  const subcommand = args[0] ?? 'list'
+  try {
+    switch (subcommand) {
+      case 'list': {
+        const profiles = listProfiles()
+        for (const profile of profiles) {
+          console.log(`  ${profile.id}`)
+        }
+        return 0
+      }
+      case 'create': {
+        const id = args[1]
+        if (!id) {
+          console.error('  profile create expects <id>')
+          return 1
+        }
+        const profile = createProfile(id)
+        console.log(`  created profile: ${profile.id}`)
+        return 0
+      }
+      case 'ensure': {
+        const id = args[1]
+        if (!id) {
+          console.error('  profile ensure expects <id>')
+          return 1
+        }
+        const profile = ensureProfile(id)
+        console.log(`  profile: ${profile.id}`)
+        return 0
+      }
+      case 'clear': {
+        const id = args[1]
+        if (!id) {
+          console.error('  profile clear expects <id>')
+          return 1
+        }
+        ensureProfile(id)
+        clearProfileStorage(id)
+        console.log(`  cleared profile: ${id}`)
+        return 0
+      }
+      case 'delete': {
+        const id = args[1]
+        if (!id) {
+          console.error('  profile delete expects <id>')
+          return 1
+        }
+        const profile = deleteProfile(id)
+        console.log(`  deleted profile: ${profile.id}`)
+        return 0
+      }
+      default:
+        console.error(`  unknown profile command: ${subcommand}`)
+        printHelp()
+        return 1
+    }
+  } catch (err) {
+    console.error(`  profile failed: ${err instanceof Error ? err.message : String(err)}`)
+    return 1
+  }
+}

package/cli/commands/react.ts

@@ -0,0 +1,353 @@
+import {
+  callInBridge,
+  callInBridgeWrite,
+  createBridgeFromParsed,
+  parseBridgeCliArgs,
+} from '../ws-bridge'
+
+interface ReactOptions {
+  port?: number
+  verbose?: boolean
+}
+
+interface SlowRow {
+  displayName: string
+  totalMs: number
+  avgMs: number
+  commitCount: number
+  slowestCommit: number
+  slowestMs: number
+}
+
+interface RerenderRow {
+  displayName: string
+  count: number
+  renders?: number
+  causes: Record<string, number>
+}
+
+interface TreeRow {
+  id: number
+  displayName: string
+  kind: string
+  depth: number
+  childCount: number
+}
+
+function printHelp() {
+  console.log(`
+rnx perf react — inspect React component render cost in the tenant worker
+
+usage:
+  rnx perf react profile start [--include-props] [--max-commits N]
+  rnx perf react profile stop
+  rnx perf react summary [--limit 10] [--json]
+  rnx perf react slow [--limit 5] [--json]
+  rnx perf react rerenders [--limit 5] [--json]
+  rnx perf react tree [--depth 3] [--find <name>] [--json]
+  rnx perf react why <fiber-id> [--json]
+
+\`react summary\` is the demo-friendly shortcut: it runs both slow and
+rerenders in one round-trip, prints them as a single table per side,
+and surfaces the duration-zero warning prominently when the bundle is
+running without React profiler timers.
+
+examples:
+  rnx perf react profile start
+  rnx do tap-text Inbox
+  rnx perf react profile stop
+  rnx perf react summary --limit 10
+  rnx perf react slow --limit 10
+  rnx perf react rerenders --json
+`)
+}
+
+function valueOf(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag)
+  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1]
+  const prefix = `${flag}=`
+  const found = args.find((arg) => arg.startsWith(prefix))
+  return found ? found.slice(prefix.length) : undefined
+}
+
+function numberFlag(args: string[], flag: string, fallback: number): number {
+  const raw = valueOf(args, flag)
+  if (raw === undefined) return fallback
+  const value = Number(raw)
+  return Number.isFinite(value) && value > 0 ? Math.round(value) : fallback
+}
+
+function formatTable(headers: string[], rows: string[][]): string {
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((row) => row[i]?.length ?? 0)),
+  )
+  const line = (cells: string[]) =>
+    cells
+      .map((cell, i) => cell.padEnd(widths[i]))
+      .join('  ')
+      .trimEnd()
+  return [
+    line(headers),
+    line(headers.map((h) => '-'.repeat(h.length))),
+    ...rows.map(line),
+  ]
+    .map((row) => `  ${row}`)
+    .join('\n')
+}
+
+function printJson(value: unknown) {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+function printSlow(result: {
+  rows?: SlowRow[]
+  commits?: number
+  error?: string
+  durationWarning?: string
+}) {
+  if (result.error) console.error(`  warning: ${result.error}`)
+  if (result.durationWarning) console.error(`  warning: ${result.durationWarning}`)
+  const rows = result.rows ?? []
+  if (rows.length === 0) {
+    console.log(`  no React render samples yet (${result.commits ?? 0} commit(s))`)
+    return
+  }
+  console.log(
+    formatTable(
+      ['component', 'total', 'avg', 'commits', 'slowest'],
+      rows.map((row) => [
+        row.displayName,
+        `${row.totalMs.toFixed(2)}ms`,
+        `${row.avgMs.toFixed(2)}ms`,
+        String(row.commitCount),
+        `#${row.slowestCommit} ${row.slowestMs.toFixed(2)}ms`,
+      ]),
+    ),
+  )
+}
+
+function printRerenders(result: {
+  rows?: RerenderRow[]
+  commits?: number
+  error?: string
+}) {
+  if (result.error) console.error(`  warning: ${result.error}`)
+  const rows = result.rows ?? []
+  if (rows.length === 0) {
+    console.log(`  no React render samples yet (${result.commits ?? 0} commit(s))`)
+    return
+  }
+  console.log(
+    formatTable(
+      ['component', 'renders', 'causes'],
+      rows.map((row) => {
+        const causes = Object.entries(row.causes ?? {})
+          .filter(([, count]) => count > 0)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 4)
+          .map(([cause, count]) => `${cause}:${count}`)
+          .join(', ')
+        return [row.displayName, String(row.renders ?? row.count), causes || '-']
+      }),
+    ),
+  )
+}
+
+function printTree(result: { rows?: TreeRow[]; roots?: number; error?: string }) {
+  if (result.error) console.error(`  warning: ${result.error}`)
+  const rows = result.rows ?? []
+  if (rows.length === 0) {
+    console.log(`  no React tree data yet (${result.roots ?? 0} root(s))`)
+    return
+  }
+  for (const row of rows) {
+    const indent = '  '.repeat(row.depth)
+    console.log(
+      `  ${indent}@${row.id} ${row.displayName} [${row.kind}] children=${row.childCount}`,
+    )
+  }
+}
+
+function printWhy(result: { sample?: any; error?: string }) {
+  if (result.error) {
+    console.error(`  ${result.error}`)
+    return
+  }
+  const sample = result.sample
+  if (!sample) {
+    console.log('  no sample')
+    return
+  }
+  console.log(`  @${sample.fiberId} ${sample.displayName}`)
+  console.log(`  duration: ${Number(sample.actualDuration ?? 0).toFixed(2)}ms`)
+  console.log(`  causes:   ${(sample.causes ?? []).join(', ') || '-'}`)
+  if (sample.propDiffs?.length) {
+    console.log('  props:')
+    for (const diff of sample.propDiffs) {
+      const values =
+        'old' in diff || 'new' in diff
+          ? ` ${JSON.stringify(diff.old)} → ${JSON.stringify(diff.new)}`
+          : ''
+      console.log(`    ${diff.key}${values}`)
+    }
+  }
+  if (sample.parentChain?.length) {
+    console.log(`  parents:  ${sample.parentChain.join(' ← ')}`)
+  }
+}
+
+export async function runReact(args: string[], opts: ReactOptions): Promise<number> {
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--json', '--include-props', '--help', '-h'],
+    stripValueFlags: ['--limit', '--depth', '--find', '--max-commits'],
+  })
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+
+  const [first, second] = parsed.positional
+  const json = args.includes('--json')
+  const bridge = createBridgeFromParsed(parsed)
+
+  try {
+    if (first === 'profile' && second === 'start') {
+      const result = await callInBridgeWrite(
+        bridge,
+        'SootSim.bridges.reactProfile.start',
+        {
+          includeProps: args.includes('--include-props'),
+          maxCommits: numberFlag(args, '--max-commits', 2000),
+        },
+      )
+      if (json) printJson(result)
+      else console.log('  React profile started')
+      return 0
+    }
+
+    if (first === 'profile' && second === 'stop') {
+      const result = (await callInBridgeWrite(
+        bridge,
+        'SootSim.bridges.reactProfile.stop',
+      )) as { commits?: number; error?: string }
+      if (json) printJson(result)
+      else {
+        console.log(`  React profile stopped (${result.commits ?? 0} commit(s))`)
+        if (result.error) console.error(`  warning: ${result.error}`)
+      }
+      return result.error ? 1 : 0
+    }
+
+    if (first === 'summary') {
+      // run slow + rerenders in parallel against the existing bridge.
+      // demo-friendly: one command, one table per dimension, plus a
+      // single duration-zero warning that's easy to call out on stage.
+      const limit = numberFlag(args, '--limit', 10)
+      const [slowResult, rerendersResult] = (await Promise.all([
+        callInBridge(bridge, 'SootSim.bridges.reactProfile.slow', { limit }),
+        callInBridge(bridge, 'SootSim.bridges.reactProfile.rerenders', { limit }),
+      ])) as [
+        {
+          rows?: SlowRow[]
+          commits?: number
+          error?: string
+          durationWarning?: string
+        },
+        { rows?: RerenderRow[]; commits?: number; error?: string },
+      ]
+      if (json) {
+        printJson({
+          commits: slowResult.commits ?? rerendersResult.commits ?? 0,
+          slow: slowResult,
+          rerenders: rerendersResult,
+        })
+        return 0
+      }
+      const commits = slowResult.commits ?? rerendersResult.commits ?? 0
+      console.log(`  React profile summary (${commits} commit(s)):`)
+      if (slowResult.error) console.error(`  warning: ${slowResult.error}`)
+      if (slowResult.durationWarning) {
+        console.error(`  warning: ${slowResult.durationWarning}`)
+      }
+      if (rerendersResult.error) {
+        console.error(`  warning: ${rerendersResult.error}`)
+      }
+      console.log('\n  slowest renders:')
+      printSlow(slowResult)
+      console.log('\n  most rerenders:')
+      printRerenders(rerendersResult)
+      // hint about the actualDuration-zero limitation when the slow
+      // table is empty/zero — the demo-stage signal is "no timer
+      // data, expect rerenders rows only".
+      const slowestRow = slowResult.rows?.[0]
+      const allZero =
+        slowResult.rows && slowResult.rows.length > 0
+          ? slowResult.rows.every((r) => r.totalMs <= 0 && r.slowestMs <= 0)
+          : false
+      if (allZero && !slowResult.durationWarning) {
+        console.error(
+          `\n  warning: every commit reports actualDuration=0ms — the React profiler timer is disabled in this bundle (rerender counts are still accurate; ${slowestRow?.displayName ? `top-listed: ${slowestRow.displayName}` : 'no slow signal'}).`,
+        )
+      }
+      return 0
+    }
+
+    if (first === 'slow') {
+      const result = (await callInBridge(bridge, 'SootSim.bridges.reactProfile.slow', {
+        limit: numberFlag(args, '--limit', 10),
+      })) as {
+        rows?: SlowRow[]
+        commits?: number
+        error?: string
+        durationWarning?: string
+      }
+      if (json) printJson(result)
+      else printSlow(result)
+      return 0
+    }
+
+    if (first === 'rerenders') {
+      const result = (await callInBridge(
+        bridge,
+        'SootSim.bridges.reactProfile.rerenders',
+        { limit: numberFlag(args, '--limit', 10) },
+      )) as { rows?: RerenderRow[]; commits?: number; error?: string }
+      if (json) printJson(result)
+      else printRerenders(result)
+      return 0
+    }
+
+    if (first === 'tree') {
+      const result = (await callInBridge(bridge, 'SootSim.bridges.reactProfile.tree', {
+        depth: numberFlag(args, '--depth', 3),
+        find: valueOf(args, '--find'),
+      })) as { rows?: TreeRow[]; roots?: number; error?: string }
+      if (json) printJson(result)
+      else printTree(result)
+      return 0
+    }
+
+    if (first === 'why') {
+      const fiberId = Number(second)
+      if (!Number.isFinite(fiberId) || fiberId <= 0) {
+        console.error('  usage: rnx perf react why <fiber-id>')
+        return 1
+      }
+      const result = (await callInBridge(
+        bridge,
+        'SootSim.bridges.reactProfile.why',
+        Math.round(fiberId),
+      )) as { sample?: unknown; error?: string }
+      if (json) printJson(result)
+      else printWhy(result)
+      return result.error ? 1 : 0
+    }
+
+    printHelp()
+    return first ? 1 : 0
+  } finally {
+    bridge.close()
+  }
+}