rnxsim 0.1.381 → 0.1.383

package/src/host/bridge-host.ts

@@ -165,7 +165,7 @@ interface BridgeCliLease {
 }
 
 // interactive commands change app state and must respect the lease.
-// observational/lifecycle commands (evaluate/tree/query/resolve/screenshot/focus/call/close)
+// observational/lifecycle commands (evaluate/tree/query/resolve/screenshot/capture/focus/call/close)
 // pass through without taking or checking a lease so cleanup never gets stuck
 // behind a stale cli owner.
 // `call` used to acquire a lease too, but most call paths are queries
@@ -228,7 +228,7 @@ export interface BridgeHostOptions {
   portFallbackCount?: number
   /** when true, write ~/.rnx/daemon.json on successful bind + update
    *  it on a heartbeat interval + remove it on close. only the standalone
-   *  `sootsim serve` process should set this — tests, vite plugin, and
+   *  `rnx serve` process should set this — tests, vite plugin, and
    *  anything embedded should leave it off to avoid clobbering a real
    *  daemon's lockfile. defaults to false. */
   writeLockfile?: boolean
@@ -249,7 +249,7 @@ export interface BridgeHostOptions {
    *  resolves the daemon's own loopback host (localhost:<runtimePort>) to
    *  the dev `contrast.localhost:3000` stack, so a *prod* CLI user's preview
    *  recording would upload to a localhost stack that doesn't exist. the
-   *  `sootsim serve` command resolves this with the same probe the
+   *  `rnx serve` command resolves this with the same probe the
    *  upload itself uses (`resolveDefaultUploadOrigin`). */
   contrastOrigin?: string
   /** override the abandoned-sim GC TTL (ms). defaults to
@@ -325,7 +325,7 @@ const CAMERA_FIXTURE_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/
  *     the same server on the same port, but a daemon whose preferred 7668
  *     was taken falls back to 7669+. without this the runtime page would
  *     hardcode the 7668 default in `resolveBridgePort` and register on a
- *     *different* daemon (or none), so `sootsim open` times out waiting for
+ *     *different* daemon (or none), so `rnx open` times out waiting for
  *     a sim that connected to the wrong bridge.
  *   - `window.__sootsimContrastOrigin` — the contrast origin for auth /
  *     billing / preview uploads. the daemon serves runtimes from its own
@@ -400,8 +400,8 @@ export class SootSimBridgeHost {
   private static USER_BOOT_LEASE_TTL_MS = 60_000
   private static SIM_RECONNECT_TTL_MS = 30_000
   // abandoned-tab GC. the ws heartbeat only reaps sims whose socket went
-  // dead — but a background tab from a prior `sootsim open` / QA / test run
-  // keeps its socket alive (the page still pongs) forever, so `sootsim list`
+  // dead — but a background tab from a prior `rnx open` / QA / test run
+  // keeps its socket alive (the page still pongs) forever, so `rnx list`
   // accretes dozens of zombie sims that all time out on every command (QA
   // F21-3, carried F19-2). reap a sim only when it is provably nobody's:
   // not primary, not user-focused, no CLI attached, no active lease, and no
@@ -409,7 +409,7 @@ export class SootSimBridgeHost {
   // terminal 4001 code, so the client closes the abandoned window instead
   // of reconnecting the zombie straight back in.
   private static SIM_IDLE_REAP_TTL_MS = 30 * 60_000
-  // automation sims (spawned by the playwright driver: `sootsim open --driver
+  // automation sims (spawned by the playwright driver: `rnx open --driver
   // playwright`, the factory/screenshot capture path — `meta.sootsimHostDriver
   // === 'playwright'`) are unattended one-shot browsers, never a human's tab. a
   // capture run opens one per slide/app/retry and the 30-min human/dev TTL lets
@@ -440,7 +440,7 @@ export class SootSimBridgeHost {
   // dropped, sim crashed) leave their server-side WebSocket sitting "open"
   // forever. ping every WS_HEARTBEAT_INTERVAL_MS; if the previous round's
   // ping was never answered, terminate(). that fires 'close' which runs the
-  // sim-cleanup path and stops `sootsim list` from showing 8 zombie
+  // sim-cleanup path and stops `rnx list` from showing 8 zombie
   // sims that all time out on every command.
   private wsHeartbeatTimer: NodeJS.Timeout | null = null
   private wsIsAlive = new WeakMap<WebSocket, boolean>()
@@ -462,7 +462,7 @@ export class SootSimBridgeHost {
   constructor(opts: BridgeHostOptions = {}) {
     this.preferredPort = opts.port || DEFAULT_SOOTSIM_BRIDGE_PORT
     this.port = this.preferredPort
-    // default off — callers that want the lockfile (sootsim serve) opt in.
+    // default off — callers that want the lockfile (rnx serve) opt in.
     this.shouldWriteLockfile = opts.writeLockfile === true
     this.shouldWriteDevLockfile = opts.writeDevLockfile === true
     this.getShellPort = opts.getShellPort ?? null
@@ -1920,7 +1920,7 @@ export class SootSimBridgeHost {
     this.reapIdleSims(now)
   }
 
-  // GC abandoned sims so `sootsim list` stays usable across long dev / QA /
+  // GC abandoned sims so `rnx list` stays usable across long dev / QA /
   // test sessions (F21-3). conservative on purpose: a sim is only reaped
   // when every "someone cares about this" signal is absent.
   //
@@ -1936,7 +1936,7 @@ export class SootSimBridgeHost {
   // using is the primary and/or holds a fresh user-active lease; one that is
   // none of those and idle past the TTL is abandoned regardless of a stale
   // focus flag.
-  // automation sims are spawned by the playwright driver (`sootsim open
+  // automation sims are spawned by the playwright driver (`rnx open
   // --driver playwright`, the factory/screenshot capture path), which tags them
   // with `meta.sootsimHostDriver === 'playwright'` via the host's addInitScript.
   // they are unattended one-shot browsers, never a human's tab, so they get a
@@ -2551,6 +2551,8 @@ export class SootSimBridgeHost {
         return 'evaluated page state'
       case 'screenshot':
         return 'captured screenshot'
+      case 'capture':
+        return 'captured app screen'
       case 'tap':
         return 'sent tap event'
       case 'keyboard':

package/src/host/plane-host.ts

@@ -17,9 +17,9 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { dispatchPlaneCommand, indexVersion } from '@contrast/harness/plane'
+import { dispatchPlaneCommand, indexVersion } from '@rnx/box/plane'
 import { CheckoutFilePlane } from '../../cli/commands/box/checkout-plane'
-import type { ProjectFilePlane } from '@contrast/harness/plane'
+import type { ProjectFilePlane } from '@rnx/box/plane'
 import type { WebSocket } from 'ws'
 
 const WS_OPEN = 1

package/src/index.ts

@@ -35,6 +35,31 @@ export type {
   SimSemanticResolveSelector,
   SimSemanticSelector,
 } from './bridge-contract'
+export {
+  isRnxCaptureRegionAtlas,
+  isRnxScreenCapture,
+  rnxCaptureRasterRegions,
+  rnxRasterFrames,
+  RNX_SCREEN_CAPTURE_VERSION,
+  selectRnxRasterNodeIds,
+  type RnxCaptureAccessibility,
+  type RnxCaptureAccessibilityState,
+  type RnxCaptureAccessibilityValue,
+  type RnxCaptureAtlasRegion,
+  type RnxCaptureInteractionState,
+  type RnxCaptureNode,
+  type RnxCaptureRect,
+  type RnxCaptureRegionAtlas,
+  type RnxCaptureRegionRequest,
+  type RnxCaptureSource,
+  type RnxCaptureStyleTokenBinding,
+  type RnxCaptureTextLine,
+  type RnxCaptureTextSegment,
+  type RnxCaptureTree,
+  type RnxCaptureVisualEvidence,
+  type RnxRasterRegionTree,
+  type RnxScreenCapture,
+} from './capture-contract'
 
 export { rnxPlugin } from './vite-plugin-one'
 export { default as metroPlugin } from './metro-plugin'

package/src/native-dev-bundle-url.ts

@@ -42,7 +42,7 @@ export function alignLoopbackBundleUrlWithProbe(
 // unreliably on small CI runners (tens of seconds when metro is warm,
 // minutes cold, sometimes past any wait-ready budget). a minified bundle
 // parses/executes far faster and reboots reliably. gated on
-// SOOTSIM_PREVIEW_PROD_BUNDLE so normal interactive `sootsim open` keeps
+// SOOTSIM_PREVIEW_PROD_BUNDLE so normal interactive `rnx open` keeps
 // dev=true. app-agnostic: rewrites whatever metro/launchAsset advertised.
 function applyPreviewProdBundle(parsed: URL): void {
   if (!process.env.SOOTSIM_PREVIEW_PROD_BUNDLE) return
@@ -95,7 +95,7 @@ export function normalizeNativeDevBundleUrl(bundleUrl: string): string {
   }
 }
 
-// explicit override used by `sootsim open` to flip metro's `hot` query when
+// explicit override used by `rnx open` to flip metro's `hot` query when
 // the caller knows their context: interactive opens want `hot=true` so metro
 // includes its HMR/react-refresh runtime in the bundle prelude and pushes
 // edits as `update` events; `--driver playwright` / agent-test runs want

package/src/screenshots/orchestrate.ts

@@ -20,7 +20,7 @@ export interface RunScreenshotsOverrides {
   captureOnly?: boolean
   composeOnly?: boolean
   // copy/colors pulled from the team's org deck to overlay onto the plan's
-  // compose slides (sootsim screenshot appstore --org … --repo …).
+  // compose slides (rnx screenshot appstore --org … --repo …).
   orgDeckFrames?: OrgDeckFrame[] | null
 }
 

package/src/screenshots/org-deck.ts

@@ -1,6 +1,6 @@
 // fetch the team's screenshot deck (the copy / colors founders set up in the
 // org dashboard) and overlay it onto a screenshots plan, so the programmatic
-// `sootsim screenshot appstore --plan … --org … --repo …` flow renders the org's
+// `rnx screenshot appstore --plan … --org … --repo …` flow renders the org's
 // words + brand gradient instead of the local yaml's. the plan still owns
 // which screen each slide captures and the device frame; the deck owns copy +
 // colors. 3d scenes don't translate to the cli's 2d composer, so only copy and

package/src/settings-bundle.ts

@@ -1,7 +1,7 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { parsePlistSource } from './plist.ts'
-import type { AppPreferenceValue, AppSettingsSpecifier } from '@sootsim/globals'
+import type { AppPreferenceValue, AppSettingsSpecifier } from '@rnx/globals'
 
 const MAX_PLIST_BYTES = 1_048_576
 const MAX_CHILD_DEPTH = 8

package/src/sim-client.ts

@@ -334,6 +334,10 @@ export class SimClient implements WsBridge, InspectBridge {
     return openAppUrl(this, target)
   }
 
+  async setAppearance(appearance: 'light' | 'dark'): Promise<void> {
+    await this.send({ type: 'setAppearance', appearance })
+  }
+
   /**
    * block until the guest app has mounted and painted real content.
    * throws SimReadyTimeoutError (with the last probe status) on timeout.

package/src/vite-plugin-one.ts

@@ -84,7 +84,7 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
             : DEFAULT_SOOTSIM_BRIDGE_PORT
         // inject the bridge port + a default bundle (only when the URL has none,
         // so the CLI's resolved bundle wins), and PRESERVE the existing query.
-        // preserving the query is essential: `sootsim open` stamps the open URL
+        // preserving the query is essential: `rnx open` stamps the open URL
         // with `inspectOpen=<token>` and matches the registered sim by that
         // token (waitForSimMatch). the old code forced `?bundle=` only and
         // stripped inspectOpen, so the sim registered but never matched and
@@ -122,7 +122,7 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
       // bundle. dev-bundle-resolution's resolvePortViaServerScan fetches
       // `/__server-scan` RELATIVE to the shell origin; when the shell is loaded
       // from this target origin, that hits here. without it the request SPA-
-      // falls-back to 404 and the bundle never resolves (sootsim open hangs).
+      // falls-back to 404 and the bundle never resolves (rnx open hangs).
       // we describe only this server (the shell drives THIS app) — no localhost-
       // wide scan, so the published plugin pulls in no shell-only scanner
       // internals. shape matches DiscoveredServer enough for the resolver.

package/src/vite-plugin.ts

@@ -1,4 +1,4 @@
-// sootsim vite plugin — use in any vite project to get react-native resolution,
+// rnx vite plugin — use in any vite project to get react-native resolution,
 // native dep stubbing, and external app support.
 //
 // usage:

package/cli/commands/box/cloud-box.ts

@@ -1,294 +0,0 @@
-// the client half of a cloud box: create it, seed this checkout into it, and
-// run its shell over the box's own WebSocket.
-//
-// the box holds the files and the shell; this process holds neither. so the
-// REPL here sends `shell:exec` and prints what comes back, and `cwd` is
-// whatever the box last reported rather than anything tracked locally. that is
-// the whole difference between the two placements, and it is why the same
-// readline loop drives both.
-//
-// there is no default endpoint. a cloud box has to be deployed before one can
-// exist, and pointing at a URL that answers nothing would advertise a
-// capability that always fails.
-
-import { WebSocket } from 'ws'
-import type { CheckoutFilePlane } from './checkout-plane'
-import type { HarnessShellResult } from '@contrast/harness/shell'
-
-// a checkout is 15k files on this repo, so seeding is batched by BYTES rather
-// than by count: one request carrying every file would be a single multi-
-// hundred-megabyte body, and one request per file would be 15k round trips.
-const SEED_BATCH_BYTES = 4 * 1024 * 1024
-// base64 costs 4 bytes for every 3, and a request carries the encoded size.
-const BASE64_OVERHEAD = 4 / 3
-
-export interface CloudBoxSession {
-  readonly cwd: string
-  exec(command: string): Promise<HarnessShellResult>
-  close(): void
-}
-
-export class CloudBoxError extends Error {}
-
-function endpointOf(base: string, name: string, verb: string): string {
-  return `${base.replace(/\/+$/, '')}/v1/boxes/${encodeURIComponent(name)}/${verb}`
-}
-
-async function boxFetch(
-  base: string,
-  name: string,
-  verb: string,
-  token: string | null,
-  body?: unknown,
-): Promise<Record<string, unknown>> {
-  const headers: Record<string, string> = { 'content-type': 'application/json' }
-  if (token) headers.authorization = `Bearer ${token}`
-  let response: Response
-  try {
-    response = await fetch(endpointOf(base, name, verb), {
-      method: body === undefined ? 'GET' : 'POST',
-      headers,
-      body: body === undefined ? undefined : JSON.stringify(body),
-    })
-  } catch (error) {
-    throw new CloudBoxError(
-      `could not reach the box service at ${base}: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    )
-  }
-  const text = await response.text()
-  const parsed = text ? JSON.parse(text) : {}
-  if (!response.ok) {
-    throw new CloudBoxError(
-      String(parsed.error ?? `box ${verb} failed (${response.status})`),
-    )
-  }
-  return parsed
-}
-
-/**
- * create the box and copy this checkout into it.
- *
- * `apiKey` is the ACCOUNT's key, which the box service forwards to
- * /v1/rnx/sessions to authenticate the caller and start the session that pays
- * for the box. the box's own token comes back minted by the box; a caller does
- * not choose it.
- */
-export async function createCloudBox(options: {
-  endpoint: string
-  name: string
-  apiKey: string
-  plane: CheckoutFilePlane
-  onProgress?: (seeded: number, total: number) => void
-}): Promise<{ files: number; token: string; sessionId: string }> {
-  const { endpoint, name, apiKey, plane } = options
-  const created = await boxFetch(endpoint, name, 'create', apiKey, { name })
-  const token = String(created.token ?? '')
-  if (!token) throw new CloudBoxError('the box service returned no access token')
-
-  const paths = [...plane.index().keys()].sort()
-  let batch: [string, string][] = []
-  let batchBytes = 0
-  let seeded = 0
-
-  const flush = async () => {
-    if (batch.length === 0) return
-    await boxFetch(endpoint, name, 'seed', token, { files: batch })
-    seeded += batch.length
-    options.onProgress?.(seeded, paths.length)
-    batch = []
-    batchBytes = 0
-  }
-
-  for (const path of paths) {
-    const bytes = await plane.readBytes(path)
-    batch.push([path, Buffer.from(bytes).toString('base64')])
-    batchBytes += bytes.byteLength * BASE64_OVERHEAD
-    if (batchBytes >= SEED_BATCH_BYTES) await flush()
-  }
-  await flush()
-
-  const status = await boxFetch(endpoint, name, 'status', token)
-  return {
-    files: Number(status.files ?? 0),
-    token,
-    sessionId: String(status.sessionId ?? ''),
-  }
-}
-
-/**
- * stop a box, or stop and wipe it.
- *
- * takes the ACCOUNT key, not the box token: it ends the session the account is
- * billed for, which the box deliberately cannot do on its own.
- */
-export async function stopCloudBox(options: {
-  endpoint: string
-  name: string
-  apiKey: string
-  purge?: boolean
-}): Promise<Record<string, unknown>> {
-  return boxFetch(
-    options.endpoint,
-    options.name,
-    options.purge ? 'delete' : 'stop',
-    options.apiKey,
-    {},
-  )
-}
-
-/**
- * the account's running boxes, from the session meter rather than from the box
- * service. the meter already knows what this account is running and what it
- * cost, so a second per-account index of boxes would be a second answer to the
- * same question, free to drift.
- */
-export async function listCloudBoxes(options: {
-  apiOrigin: string
-  apiKey: string
-}): Promise<{ id: string; name: string | null; startedAt: string; meteredMs: number }[]> {
-  const response = await fetch(
-    `${options.apiOrigin.replace(/\/+$/, '')}/v1/rnx/sessions`,
-    {
-      headers: { authorization: `Bearer ${options.apiKey}` },
-    },
-  )
-  const text = await response.text()
-  const parsed = text ? JSON.parse(text) : {}
-  if (!response.ok) {
-    throw new CloudBoxError(
-      String(parsed.message ?? parsed.error ?? 'could not list boxes'),
-    )
-  }
-  const sessions = Array.isArray(parsed.sessions) ? parsed.sessions : []
-  return sessions
-    .filter((session: { kind?: string }) => session.kind === 'box')
-    .map((session: Record<string, unknown>) => ({
-      id: String(session.id),
-      name: typeof session.name === 'string' ? session.name : null,
-      startedAt: String(session.startedAt ?? ''),
-      meteredMs: Number(session.meteredMs ?? 0),
-    }))
-}
-
-/**
- * bank the wall clock while a box is open.
- *
- * the box holds no account credential and so cannot heartbeat for itself; the
- * client that is actually using it does. when this process dies the heartbeats
- * stop and the site's stale sweep closes the session at the last one, which is
- * why there is no second idle timer in the box.
- */
-export function heartbeatSession(options: {
-  apiOrigin: string
-  apiKey: string
-  sessionId: string
-  everyMs?: number
-}): { stop: () => void } {
-  const url = `${options.apiOrigin.replace(/\/+$/, '')}/v1/rnx/sessions/${encodeURIComponent(
-    options.sessionId,
-  )}`
-  const timer = setInterval(() => {
-    void fetch(url, {
-      method: 'POST',
-      headers: { authorization: `Bearer ${options.apiKey}` },
-    }).catch(() => {
-      // a missed heartbeat is not an error worth interrupting a shell for.
-      // the sweep closes the session at the last one that landed.
-    })
-  }, options.everyMs ?? 60_000)
-  // do not hold the process open just to keep billing alive
-  timer.unref?.()
-  return { stop: () => clearInterval(timer) }
-}
-
-/** open the box's socket and return a session the REPL can drive. */
-export async function connectCloudBox(options: {
-  endpoint: string
-  name: string
-  token: string
-}): Promise<CloudBoxSession> {
-  const { endpoint, name, token } = options
-  const url = endpointOf(endpoint, name, 'connect').replace(/^http/, 'ws')
-  // as a subprotocol, not a header. a browser cannot set a header on a
-  // WebSocket, and the box takes the token one way rather than one way per
-  // kind of caller.
-  const socket = new WebSocket(url, [`rnx-box-token.${token}`])
-
-  // a persistent handler, installed before the handshake can fail. ws emits
-  // 'error' again after a refused upgrade, and a `once` listener consumed by
-  // the rejection leaves that second emit unhandled, which crashes the
-  // process rather than failing the command.
-  let socketError: string | null = null
-  socket.on('error', (error) => {
-    socketError = error.message
-  })
-  await new Promise<void>((resolve, reject) => {
-    socket.once('open', resolve)
-    socket.once('error', (error) => {
-      socket.close()
-      reject(error)
-    })
-  }).catch(async (error: unknown) => {
-    // ws's handshake error text is runtime-specific: node says "Unexpected
-    // server response: 401" and bun says "Expected 101 status code" with no
-    // status at all. so ask the service itself why, over plain HTTP, and
-    // report THAT. this runs only on the failure path.
-    const reason = await boxFetch(endpoint, name, 'status', token).then(
-      () => null,
-      (failure: unknown) =>
-        failure instanceof Error ? failure.message : String(failure),
-    )
-    const fallback = error instanceof Error ? error.message : String(error)
-    throw new CloudBoxError(`could not open the box shell: ${reason ?? fallback}`)
-  })
-
-  let nextId = 0
-  const waiting = new Map<number, (reply: Record<string, unknown>) => void>()
-  socket.on('message', (data) => {
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(String(data))
-    } catch {
-      return
-    }
-    if (typeof parsed !== 'object' || parsed === null) return
-    const reply = parsed as Record<string, unknown>
-    const resolve = waiting.get(Number(reply.id))
-    if (!resolve) return
-    waiting.delete(Number(reply.id))
-    resolve(reply)
-  })
-
-  // the socket dying mid-command must fail the command rather than hang the
-  // prompt forever, so every waiter is settled when it closes.
-  let closedReason: string | null = null
-  const settleAll = (reason: string) => {
-    closedReason = reason
-    for (const [id, resolve] of waiting) resolve({ id, error: reason })
-    waiting.clear()
-  }
-  socket.on('close', () => settleAll(socketError ?? 'the box closed the connection'))
-  socket.on('error', (error) => settleAll(error.message))
-
-  let cwd = '/project'
-  return {
-    get cwd() {
-      return cwd
-    },
-    async exec(command: string): Promise<HarnessShellResult> {
-      if (closedReason) throw new CloudBoxError(closedReason)
-      const id = nextId++
-      const reply = await new Promise<Record<string, unknown>>((resolve) => {
-        waiting.set(id, resolve)
-        socket.send(JSON.stringify({ type: 'shell:exec', id, command }))
-      })
-      if (reply.error) throw new CloudBoxError(String(reply.error))
-      const result = reply.result as HarnessShellResult
-      if (result.cwd) cwd = result.cwd
-      return result
-    },
-    close: () => socket.close(),
-  }
-}