rnxsim 0.1.313 → 0.1.314

package/cli/commands/screenshots.ts

@@ -0,0 +1,127 @@
+import { runScreenshotsPlan } from '../../src/screenshots/orchestrate'
+import { fetchOrgDeckFrames, type OrgDeckFrame } from '../../src/screenshots/org-deck'
+import { authHeaderValue, resolveCliAuth } from '../auth'
+
+interface RunScreenshotsOptions {
+  port?: number
+  verbose?: boolean
+}
+
+export async function runScreenshots(
+  args: string[],
+  _opts: RunScreenshotsOptions = {},
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+rnxsim screenshot appstore — capture and compose app-store screenshot sets
+
+usage:
+  rnxsim screenshot appstore --plan <plan.yaml> [options]
+
+options:
+  --plan <path>         screenshot plan yaml
+  --sim <id>            reuse a live sim for capture
+  --app <target>        override plan app target (port, url, or shell url)
+  --device <model>      override plan capture device for this run
+  --org <slug>          overlay copy/colors from a team's org screenshot deck
+  --repo <name>         repo for --org (both required to pull the org deck)
+  --api-origin <url>    contrast origin to fetch the deck from (default: the
+                        signed-in session origin, else https://contrast.dev)
+  --capture-only        stop after raw/framed intermediates
+  --compose-only        skip flow capture, reuse existing raw screenshots
+
+examples:
+  rnxsim screenshot appstore --plan app-store.yaml
+  rnxsim screenshot appstore --plan app-store.yaml --sim a9
+  rnxsim screenshot appstore --plan app-store.yaml --org acme --repo mobile
+`)
+    return 0
+  }
+
+  const getFlag = (name: string) => args.find((_, i) => args[i - 1] === name)
+  const consumedValueFlags = new Set([
+    '--plan',
+    '--sim',
+    '--app',
+    '--device',
+    '--org',
+    '--repo',
+    '--api-origin',
+  ])
+  const positional = args.filter((arg, index) => {
+    if (arg.startsWith('-')) return false
+    const previous = args[index - 1]
+    return !previous || !consumedValueFlags.has(previous)
+  })
+  const planPath = getFlag('--plan') || positional[0]
+  if (!planPath) {
+    console.error('  error: screenshots plan path is required (`--plan <path>`).')
+    return 1
+  }
+
+  const simId = getFlag('--sim')?.trim() || null
+  const appTarget = getFlag('--app')?.trim() || null
+  const deviceModel = getFlag('--device')?.trim() || null
+  const org = getFlag('--org')?.trim() || null
+  const repo = getFlag('--repo')?.trim() || null
+  const apiOrigin = getFlag('--api-origin')?.trim() || null
+  const captureOnly = args.includes('--capture-only')
+  const composeOnly = args.includes('--compose-only')
+
+  let orgDeckFrames: OrgDeckFrame[] | null = null
+  if (org || repo) {
+    if (!org || !repo) {
+      console.error('  error: --org and --repo must be passed together.')
+      return 1
+    }
+    const auth = resolveCliAuth()
+    if (!auth) {
+      console.error(
+        '  error: --org/--repo needs auth — run `rnxsim login` or set RNX_API_KEY.',
+      )
+      return 1
+    }
+    const origin =
+      apiOrigin || (auth.kind === 'session' ? auth.origin : 'https://contrast.dev')
+    try {
+      orgDeckFrames = await fetchOrgDeckFrames({
+        org,
+        repo,
+        origin,
+        authHeader: authHeaderValue(auth),
+      })
+    } catch (err) {
+      console.error(`  ${(err as Error).message}`)
+      return 1
+    }
+    if (!orgDeckFrames || orgDeckFrames.length === 0) {
+      console.log(
+        `  note: no org deck for ${org}/${repo} — composing with the plan's copy/colors.`,
+      )
+    } else {
+      console.log(`  org deck: ${orgDeckFrames.length} slide(s) from ${org}/${repo}`)
+    }
+  }
+
+  try {
+    const result = await runScreenshotsPlan(planPath, {
+      simId,
+      appTarget,
+      deviceModel,
+      captureOnly,
+      composeOnly,
+      orgDeckFrames,
+    })
+    console.log(`  capture manifest: ${result.capture.manifestPath}`)
+    if (result.compose) {
+      console.log(`  compose manifest: ${result.compose.manifestPath}`)
+      console.log(`  exports: ${result.compose.outputs.length}`)
+    } else {
+      console.log('  compose skipped')
+    }
+    return 0
+  } catch (err) {
+    console.error(`  screenshots failed: ${(err as Error).message}`)
+    return 1
+  }
+}

package/cli/commands/serve.ts

@@ -0,0 +1,168 @@
+// sootsim serve — foreground bridge host
+//
+// hosts the WS bridge + runtime HTTP server on port 7668 (or --port) so
+// CLI commands and electron windows both work against one bridge. sims
+// connect over ws to register themselves; cli clients connect to drive
+// them; electron fetches renderer assets over http from the same port.
+//
+// run in the foreground (ctrl-c to stop). the persistent launchd/systemd
+// daemon installation is handled by `sootsim setup`.
+
+import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
+import {
+  ensureSootsimHome,
+  isDaemonLockfileFresh,
+  readDaemonLockfile,
+} from '../../src/home-paths'
+import { SootSimBridgeHost } from '../../src/host/bridge-host'
+import { flushCliTelemetry, trackCliEvent } from '../telemetry'
+import { resolveDefaultUploadOrigin } from './upload'
+
+// launchd sets `XPC_SERVICE_NAME` to the agent label and systemd sets
+// `INVOCATION_ID` for unit-managed processes. either tells us this bridge
+// boot is the daemon firing rather than a user running `sootsim serve`
+// in a terminal — useful for filtering daemon traffic in posthog.
+//
+function runningUnderDaemon(): boolean {
+  const xpc = process.env.XPC_SERVICE_NAME || ''
+  if (xpc.includes('dev.sootsim.daemon')) return true
+  if (process.env.INVOCATION_ID) return true
+  return false
+}
+
+interface ServeOptions {
+  port?: number
+}
+
+export async function runServe(args: string[], opts: ServeOptions = {}) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+rnxsim serve — run the rnx bridge in the foreground
+
+hosts the WS bridge that CLI commands talk to. once running, any rnx
+renderer (browser, electron, headless playwright) that connects to port 7668
+becomes drivable from 'rnxsim describe', 'rnxsim do tap', etc.
+
+usage:
+  rnxsim serve [options]
+
+options:
+  --port <n>        bridge port (defaults to ${DEFAULT_SOOTSIM_BRIDGE_PORT})
+  --quiet           suppress per-connection logging
+
+examples:
+  rnxsim serve
+  rnxsim serve --port 7668 --quiet
+`)
+    process.exit(0)
+  }
+
+  const portArgIdx = args.indexOf('--port')
+  const port =
+    portArgIdx >= 0 && args[portArgIdx + 1]
+      ? Number(args[portArgIdx + 1])
+      : (opts.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT)
+  if (Number.isNaN(port)) {
+    console.error(`  invalid --port value: ${args[portArgIdx + 1]}`)
+    process.exit(1)
+  }
+  const quiet = args.includes('--quiet') || args.includes('-q')
+
+  // only one bridge per sootsim home. refuse to start a second one
+  // regardless of requested port, since both would try to write the same
+  // daemon.json and electron/cli clients only read one lockfile.
+  const existingLock = readDaemonLockfile()
+  if (existingLock && isDaemonLockfileFresh(existingLock)) {
+    console.error(
+      `  an rnx bridge is already running (pid ${existingLock.pid}, port ${existingLock.bridgePort})`,
+    )
+    console.error(`  stop it with 'rnxsim daemon stop' first`)
+    process.exit(1)
+  }
+
+  ensureSootsimHome()
+  // resolve the contrast origin the same way uploads do (probe a local
+  // :3000 stack, else prod) so served runtimes talk auth/billing/preview
+  // to the same origin the CLI's own entitlement + upload paths use.
+  const contrastOrigin = await resolveDefaultUploadOrigin()
+  const host = new SootSimBridgeHost({
+    port,
+    writeLockfile: true,
+    contrastOrigin,
+  })
+  const boundPort = await host.startAsync({ silent: quiet })
+
+  const started = Date.now()
+  const log = (line: string) => {
+    if (quiet) return
+    process.stdout.write(`${line}\n`)
+  }
+
+  const lastSimIds = new Set<string>()
+  const tickInterval = setInterval(() => {
+    const sims = host.listSims()
+    const currentIds = new Set(sims.map((b) => b.id))
+    for (const b of sims) {
+      if (!lastSimIds.has(b.id)) {
+        const label = b.title || b.url || b.origin || '(unknown)'
+        log(`  + ${b.id}  ${label}`)
+      }
+    }
+    for (const id of lastSimIds) {
+      if (!currentIds.has(id)) log(`  - ${id}`)
+    }
+    lastSimIds.clear()
+    for (const id of currentIds) lastSimIds.add(id)
+  }, 500)
+
+  // single boot heartbeat so we know the bridge is alive on this machine.
+  // not periodic — frequency would pollute posthog volumes for no signal.
+  // explicitly flush: this process pins the event loop with a never-
+  // resolving promise (line 155), so beforeExit will not fire and the
+  // event would otherwise sit in the queue until SIGTERM dropped it.
+  trackCliEvent({
+    event: 'daemon_heartbeat',
+    properties: {
+      bridge_port: boundPort,
+      under_daemon: runningUnderDaemon(),
+      platform: process.platform,
+      subsource: 'daemon',
+    },
+  })
+  void flushCliTelemetry()
+
+  log(`rnx bridge listening on ws://localhost:${boundPort} (runtime http on same port)`)
+  if (boundPort !== port) {
+    log(`  (preferred port ${port} was taken — fell back to ${boundPort})`)
+  }
+  log(`  ready for browser, electron, or headless playwright sims to connect`)
+  log(`  (ctrl-c to stop)`)
+
+  const shutdown = async (signal: NodeJS.Signals) => {
+    clearInterval(tickInterval)
+    log(
+      `\n  ${signal} received — shutting down after ${Math.round((Date.now() - started) / 1000)}s`,
+    )
+    try {
+      await host.close()
+    } catch {}
+    process.exit(0)
+  }
+  process.on('SIGINT', () => shutdown('SIGINT'))
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+  // closing the terminal that spawned us sends SIGHUP — treat it like a
+  // clean shutdown so the lockfile doesn't linger.
+  process.on('SIGHUP', () => shutdown('SIGHUP'))
+  // last-ditch lockfile cleanup on any synchronous exit path. the
+  // close() call above is async so we can't await it here, but removing
+  // the lockfile is cheap + idempotent.
+  process.on('exit', () => {
+    try {
+      host.removeLockfile()
+    } catch {}
+  })
+
+  // keep the event loop alive even if ws/http servers all close — we want
+  // the process to live until an explicit signal.
+  await new Promise<never>(() => {})
+}