peachsim 0.1.527

package/cli/commands/slides.ts

@@ -0,0 +1,357 @@
+// rnx screenshot slides — drive the live screenshot-mode composition from the
+// terminal. same pipeline as the in-shell UI (rail/strip): every mutation
+// goes through the shell's screenshotControl bridge so the browser UI
+// reflects each step live, captures auto-upload, and exports are the
+// composed App-Store canvases (bg + copy + posed device at export size).
+
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
+import {
+  callInBridge,
+  callInBridgeWrite,
+  createBridgeFromParsed,
+  evalInBridge,
+  parseBridgeCliArgs,
+  type WsBridge,
+} from '../ws-bridge'
+
+const HELP = `
+rnx screenshot slides — compose App Store screenshots in the live sim
+
+usage:
+  rnx screenshot slides                       list slides (alias: slides list)
+  rnx screenshot slides set <n> [fields]      patch a slide's copy/colors
+  rnx screenshot slides add                   append a blank slide (focuses it)
+  rnx screenshot slides remove <n>            delete a slide
+  rnx screenshot slides move <n> <position>   reorder a slide
+  rnx screenshot slides focus <n>             open a slide (device flips into it)
+  rnx screenshot slides overview              back to the gallery
+  rnx screenshot slides capture [<n>]         capture the live frame into a slide
+  rnx screenshot slides export [<n>] [--out <dir>]
+                                                  write composed App-Store PNG(s)
+
+set fields:
+  --title <text>          headline
+  --subtitle <text>       subheadline
+  --bg-top <color>        gradient top    (white gray slate black cyan blue
+  --bg-bottom <color>     gradient bottom  teal green lime gold orange coral
+  --title-color <color>   copy color override, or "auto"   red berry magenta
+  --title-size <s>        sm | md | lg | none              gray-light
+  --underlay <s>          black | white | none             gray-dark …)
+  --shadow <s>            light | medium | strong | none
+
+notes:
+  slides are addressed by 1-based index. screenshot mode is auto-enabled.
+  capture shoots whatever the sim currently shows — navigate the app first
+  (rnx do tap-id …), then capture.
+
+examples:
+  rnx screenshot slides set 1 --title "The ultimate MMA community." --bg-top cyan --bg-bottom black
+  rnx screenshot slides capture 1
+  rnx screenshot slides export --out ./exports
+`
+
+interface SlideRow {
+  index: number
+  id: string
+  title: string
+  subtitle: string
+  bgTop: string
+  bgBottom: string
+  titleColor: string | null
+  titleSize: string | null
+  titleUnderlay: string | null
+  titleShadow: string | null
+  captured: boolean
+  captureMode: string | null
+  focused: boolean
+  active: boolean
+}
+
+interface ControlState {
+  projectName: string
+  canvas: string
+  exportSize: { width: number; height: number }
+  deviceModel: string
+  slides: SlideRow[]
+}
+
+// my value flags, extracted before bridge-arg parsing.
+const VALUE_FLAGS: Record<string, string> = {
+  '--title': 'title',
+  '--subtitle': 'subtitle',
+  '--bg-top': 'bgTop',
+  '--bg-bottom': 'bgBottom',
+  '--title-color': 'titleColor',
+  '--title-size': 'titleSize',
+  '--underlay': 'titleUnderlay',
+  '--shadow': 'titleShadow',
+  '--out': 'out',
+}
+
+function extractFlags(args: string[]): {
+  rest: string[]
+  values: Record<string, string>
+  json: boolean
+} {
+  const rest: string[] = []
+  const values: Record<string, string> = {}
+  let json = false
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg === '--json') {
+      json = true
+      continue
+    }
+    const eq = arg.indexOf('=')
+    const flagName = eq > 0 ? arg.slice(0, eq) : arg
+    const key = VALUE_FLAGS[flagName]
+    if (key) {
+      if (eq > 0) {
+        values[key] = arg.slice(eq + 1)
+      } else {
+        values[key] = args[i + 1] ?? ''
+        i += 1
+      }
+      continue
+    }
+    rest.push(arg)
+  }
+  return { rest, values, json }
+}
+
+function parseSlideRef(raw: string | undefined): number | string | undefined {
+  if (!raw) return undefined
+  const n = Number(raw)
+  return Number.isInteger(n) && n > 0 ? n : raw
+}
+
+async function ensureScreenshotMode(bridge: WsBridge): Promise<void> {
+  const on = await evalInBridge<boolean>(
+    bridge,
+    `(async () => {
+      if (window.SootSim?.bridges?.settings?.get?.()?.screenshotMode) return true
+      window.dispatchEvent(new CustomEvent('sootsim:shell-command', {
+        detail: { type: 'fire-action', id: 'toggle-screenshot-mode' },
+      }))
+      const deadline = Date.now() + 2000
+      while (Date.now() < deadline) {
+        if (window.SootSim?.bridges?.settings?.get?.()?.screenshotMode) return true
+        await new Promise((r) => setTimeout(r, 40))
+      }
+      return false
+    })()`,
+    { acquireLock: true },
+  )
+  if (!on) {
+    throw new Error(
+      'could not enable screenshot mode — is this a browser sim with the screenshot plugin? (electron has no screenshot mode)',
+    )
+  }
+}
+
+function printState(state: ControlState) {
+  console.log(
+    `  ${state.projectName} — canvas ${state.canvas} (${state.exportSize.width}×${state.exportSize.height}), device ${state.deviceModel}`,
+  )
+  for (const s of state.slides) {
+    const marks = [
+      s.focused ? 'focused' : s.active ? 'active' : null,
+      s.captured ? `captured${s.captureMode === '3d' ? ' 3d' : ''}` : 'no capture',
+    ]
+      .filter(Boolean)
+      .join(', ')
+    const copy = s.title ? `"${s.title}"` : '(no title)'
+    const style = [
+      `bg ${s.bgTop}→${s.bgBottom}`,
+      s.titleColor ? `color ${s.titleColor}` : null,
+      s.titleSize ? `size ${s.titleSize}` : null,
+      s.titleUnderlay ? `underlay ${s.titleUnderlay}` : null,
+      s.titleShadow ? `shadow ${s.titleShadow}` : null,
+    ]
+      .filter(Boolean)
+      .join(', ')
+    console.log(`  ${s.index}. ${copy} — ${style} [${marks}]`)
+    if (s.subtitle) console.log(`     ${s.subtitle}`)
+  }
+}
+
+function dataUrlToBytes(dataUrl: string): Buffer {
+  const m = dataUrl.match(/^data:[^;]+;base64,(.+)$/)
+  if (!m) throw new Error('export returned an unexpected payload')
+  return Buffer.from(m[1], 'base64')
+}
+
+export async function runSlides(
+  args: string[],
+  opts: { port?: number; verbose?: boolean },
+): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP)
+    return
+  }
+  const { rest, values, json } = extractFlags(args)
+  const parsed = parseBridgeCliArgs(rest, {
+    port: opts.port,
+    // capture waits on focus animation + frame bake; export composes at
+    // full App-Store resolution — both can exceed the default 15s.
+    commandTimeoutMs: 45_000,
+  })
+  const sub = parsed.positional[0] ?? 'list'
+  const refArg = parseSlideRef(parsed.positional[1])
+  const positionArg = Number(parsed.positional[2])
+  const bridge = createBridgeFromParsed(parsed)
+  const emit = (state: ControlState) => {
+    if (json) console.log(JSON.stringify(state, null, 2))
+    else printState(state)
+  }
+
+  try {
+    await ensureScreenshotMode(bridge)
+    switch (sub) {
+      case 'list': {
+        emit(
+          await callInBridge<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.getState',
+          ),
+        )
+        break
+      }
+      case 'set': {
+        if (refArg == null)
+          throw new Error('usage: rnx screenshot slides set <n> --title … (see --help)')
+        const patch: Record<string, string> = {}
+        for (const key of [
+          'title',
+          'subtitle',
+          'bgTop',
+          'bgBottom',
+          'titleColor',
+          'titleSize',
+          'titleUnderlay',
+          'titleShadow',
+        ]) {
+          if (values[key] != null) patch[key] = values[key]
+        }
+        if (Object.keys(patch).length === 0) {
+          throw new Error('nothing to set — pass at least one field (see --help)')
+        }
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.setSlide',
+            refArg,
+            patch,
+          ),
+        )
+        break
+      }
+      case 'add': {
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.addSlide',
+          ),
+        )
+        break
+      }
+      case 'remove': {
+        if (refArg == null) throw new Error('usage: rnx screenshot slides remove <n>')
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.removeSlide',
+            refArg,
+          ),
+        )
+        break
+      }
+      case 'move': {
+        if (refArg == null || !Number.isInteger(positionArg) || positionArg < 1) {
+          throw new Error('usage: rnx screenshot slides move <n> <position>')
+        }
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.moveSlide',
+            refArg,
+            positionArg,
+          ),
+        )
+        break
+      }
+      case 'focus': {
+        if (refArg == null) throw new Error('usage: rnx screenshot slides focus <n>')
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.focusSlide',
+            refArg,
+          ),
+        )
+        break
+      }
+      case 'overview': {
+        emit(
+          await callInBridgeWrite<ControlState>(
+            bridge,
+            'SootSim.bridges.screenshotControl.overview',
+          ),
+        )
+        break
+      }
+      case 'capture': {
+        const state = await callInBridgeWrite<ControlState>(
+          bridge,
+          'SootSim.bridges.screenshotControl.capture',
+          ...(refArg != null ? [refArg] : []),
+        )
+        emit(state)
+        break
+      }
+      case 'export': {
+        const outDir = values.out
+          ? isAbsolute(values.out)
+            ? values.out
+            : resolve(process.cwd(), values.out)
+          : join(process.cwd(), 'screenshots')
+        const state = await callInBridge<ControlState>(
+          bridge,
+          'SootSim.bridges.screenshotControl.getState',
+        )
+        const targets =
+          refArg != null
+            ? state.slides.filter((s) => s.index === refArg || s.id === refArg)
+            : state.slides.filter((s) => s.captured)
+        if (targets.length === 0) {
+          throw new Error(
+            refArg != null
+              ? `no slide ${refArg}`
+              : 'no captured slides to export — capture first',
+          )
+        }
+        const written: string[] = []
+        for (const slide of targets) {
+          const result = await callInBridge<{
+            name: string
+            width: number
+            height: number
+            dataUrl: string
+          }>(bridge, 'SootSim.bridges.screenshotControl.exportSlide', slide.index)
+          const path = join(outDir, result.name)
+          mkdirSync(dirname(path), { recursive: true })
+          writeFileSync(path, dataUrlToBytes(result.dataUrl))
+          written.push(path)
+          console.log(`  saved: ${path} (${result.width}×${result.height})`)
+        }
+        if (json) console.log(JSON.stringify({ written }, null, 2))
+        break
+      }
+      default:
+        throw new Error(`unknown subcommand "${sub}" — see rnx screenshot slides --help`)
+    }
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/state.ts

@@ -0,0 +1,94 @@
+import { printBridgeFailureDiagnostics } from '../bridge-diagnostics'
+import {
+  type BridgeTransportOption,
+  createBridgeFromParsed,
+  parseBridgeCliArgs,
+} from '../ws-bridge'
+import { formatSemanticTree, isSimSemanticTree } from './inspect/core'
+import type { SimStateResult } from '../../src/bridge-contract'
+
+function isSimStateResult(value: unknown): value is SimStateResult {
+  return (
+    !!value &&
+    typeof value === 'object' &&
+    typeof Reflect.get(value, 'capturedAt') === 'number' &&
+    (Reflect.get(value, 'tree') === undefined ||
+      isSimSemanticTree(Reflect.get(value, 'tree')))
+  )
+}
+
+function printHelp(): void {
+  console.log(`
+rnx state - capture the current app state in one call
+
+usage:
+  rnx state [--json] [--sim <id>]
+
+options:
+  --json      print the complete structured result, including the screenshot
+  --sim <id>  target a specific sim
+  --port <p>  WS bridge port
+`)
+}
+
+export async function runState(
+  args: string[],
+  opts: { port?: number } & BridgeTransportOption = {},
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--json'],
+  })
+  if (parsed.positional.length > 0) {
+    console.error(`  unexpected state argument: ${parsed.positional[0]}`)
+    return 1
+  }
+
+  const bridge = (opts.createBridge ?? createBridgeFromParsed)(parsed)
+  try {
+    const value: unknown = await bridge.send({ type: 'state' })
+    if (!isSimStateResult(value)) {
+      throw new Error('state bridge returned an invalid result')
+    }
+
+    if (args.includes('--json')) {
+      console.log(JSON.stringify(value))
+      return 0
+    }
+
+    const route = value.route
+    console.log(`  route: ${route?.screen ?? route?.url ?? '(unknown)'}`)
+    if (route?.stack?.length) console.log(`  stack: ${route.stack.join(' > ')}`)
+    console.log(`  keyboard: ${value.keyboard?.visible ? 'visible' : 'hidden'}`)
+    console.log('')
+    console.log(value.tree ? formatSemanticTree(value.tree) : '')
+    console.log('')
+    if (value.recentErrors?.length) {
+      console.log(`  recent errors (${value.recentErrors.length}):`)
+      for (const error of value.recentErrors) {
+        console.log(`    [${error.level}] ${error.text}`)
+      }
+    } else {
+      console.log('  recent errors: none')
+    }
+    const screenshotLength =
+      typeof value.screenshot === 'string' ? value.screenshot.length : 0
+    console.log(
+      screenshotLength > 0
+        ? `  screenshot: captured (${screenshotLength} characters; use --json to read it)`
+        : '  screenshot: unavailable',
+    )
+    return 0
+  } catch (error) {
+    console.error(`  state failed: ${error instanceof Error ? error.message : error}`)
+    await printBridgeFailureDiagnostics(bridge)
+    return 1
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/storage.ts

@@ -0,0 +1,58 @@
+import { runProfile } from './profile'
+import { runReset } from './reset'
+
+interface StorageOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const VALUE_FLAGS = new Set(['--sim', '--port', '-p'])
+const SUBCOMMANDS = new Set(['profile', 'clear'])
+
+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 printHelp(): void {
+  console.log(`
+rnx storage — manage sim and app storage
+
+usage:
+  rnx storage profile <subcommand>
+  rnx storage clear [--full] [--sim <id>] [--json]
+
+subcommands:
+  profile list
+  profile create <id>
+  profile clear <id>
+  profile delete <id>
+  clear              clear the current guest app data and relaunch it
+`)
+}
+
+export async function runStorage(args: string[], opts: StorageOptions): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+
+  const sub = findSubcommand(args)
+  if (sub?.name === 'profile') {
+    return runProfile([...args.slice(0, sub.index), ...args.slice(sub.index + 1)], opts)
+  }
+  if (sub?.name === 'clear') {
+    return runReset([...args.slice(0, sub.index), ...args.slice(sub.index + 1)], opts)
+  }
+
+  console.error(`  unknown storage command: ${sub?.name ?? '(missing)'}`)
+  printHelp()
+  return 1
+}

package/cli/commands/telemetry.ts

@@ -0,0 +1,55 @@
+// `rnx config telemetry on|off` — retained as the command spelling for the
+// product analytics preference shown by guided setup and Settings.
+//
+// this is the process-wide preference; `DO_NOT_TRACK=1` still forces opt-out
+// for a single run regardless of what's stored (honored by isOptedOut in
+// telemetry.ts, the same cross-tool signal npm/turbo/supabase use).
+
+import {
+  configFilePath,
+  readPrivacyPreferences,
+  writePrivacyPreferences,
+} from '../../src/home-paths'
+import { rnxExit } from '../run-rnx'
+
+function printStatus(): void {
+  const preferences = readPrivacyPreferences()
+  const enabled = preferences.configured && preferences.productAnalytics
+  console.log(`  bounded diagnostics are ${enabled ? 'ON' : 'OFF'}`)
+  console.log('  permitted fields: package name/version/unsupported API or error class')
+  console.log(`  config: ${configFilePath()}`)
+  const doNotTrack = process.env.DO_NOT_TRACK
+  if (doNotTrack === '1' || doNotTrack === 'true') {
+    console.log(
+      `  note: DO_NOT_TRACK=${doNotTrack} is set — telemetry is off for this run`,
+    )
+  }
+}
+
+export async function runTelemetry(args: string[]): Promise<void> {
+  const sub = args.find((a) => !a.startsWith('-'))?.toLowerCase()
+
+  switch (sub) {
+    case undefined:
+    case 'status':
+      printStatus()
+      return
+
+    case 'on':
+      writePrivacyPreferences({ productAnalytics: true, crashReports: false })
+      console.log('  bounded diagnostics ON')
+      console.log(`  config: ${configFilePath()}`)
+      return
+
+    case 'off':
+      writePrivacyPreferences({ productAnalytics: false, crashReports: false })
+      console.log('  bounded diagnostics OFF')
+      console.log(`  config: ${configFilePath()}`)
+      return
+
+    default:
+      console.error(`  unknown telemetry action: ${sub}`)
+      console.error('  usage: rnx config telemetry [on|off|status]')
+      rnxExit(1)
+  }
+}