rnxsim 0.1.381 → 0.1.382

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(),
-  }
-}