rnxsim 0.1.313 → 0.1.314

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 '@sootsim/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(`
+rnxsim permissions — inspect and change simulated operating-system permissions
+
+usage:
+  rnxsim permissions list [--json]
+  rnxsim permissions get <app-id> [--json]
+  rnxsim permissions set <app-id> <kind> <status> [--once] [--accuracy full|reduced] [--json]
+  rnxsim 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/profile.ts

@@ -0,0 +1,108 @@
+// sootsim 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(`
+rnxsim storage profile — manage isolated storage profiles
+
+usage:
+  rnxsim storage profile ls
+  rnxsim storage profile create <id>
+  rnxsim storage profile clear <id>
+  rnxsim 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:
+  rnxsim storage profile ls
+  rnxsim storage profile create qa
+  rnxsim open 8081 --profile qa
+  rnxsim open 8081 --profile qa --driver playwright
+  rnxsim storage profile clear qa
+  rnxsim 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] ?? 'ls'
+  try {
+    switch (subcommand) {
+      case 'ls':
+      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':
+      case 'rm': {
+        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(`
+rnxsim perf react — inspect React component render cost in the tenant worker
+
+usage:
+  rnxsim perf react profile start [--include-props] [--max-commits N]
+  rnxsim perf react profile stop
+  rnxsim perf react summary [--limit 10] [--json]
+  rnxsim perf react slow [--limit 5] [--json]
+  rnxsim perf react rerenders [--limit 5] [--json]
+  rnxsim perf react tree [--depth 3] [--find <name>] [--json]
+  rnxsim 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:
+  rnxsim perf react profile start
+  rnxsim do tap-text Inbox
+  rnxsim perf react profile stop
+  rnxsim perf react summary --limit 10
+  rnxsim perf react slow --limit 10
+  rnxsim 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: rnxsim 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()
+  }
+}