rnxsim 0.1.442 → 0.1.444

package/cli/bin.ts

@@ -31,7 +31,9 @@ if (process.argv[2] === '__cloud-confirm') {
     ])
     const session = readCloudSession()
     if (!session) throw new Error('RNX cloud confirmation has no shell session')
-    await confirmCloudSimulator(session)
+    // a box has no claim to keep alive: its simulator is held by the Box page
+    // for as long as the box runs, so a shell on a box confirms nothing.
+    if (session.service === 'sim') await confirmCloudSimulator(session)
     process.exit(0)
   } catch (error) {
     process.stderr.write(

package/cli/cloud-client.ts

@@ -41,7 +41,9 @@ import {
   createCloudSession,
   normalizeCloudOrigin,
   readCloudSession,
+  type CloudBoxSession,
   type CloudSession,
+  type CloudSimSession,
 } from './cloud-session'
 import { detectProject, findProjectRoot } from './commands/detect'
 import type { StorageSnapshot } from '../../sootsim-engine/src/preview/storage-snapshot-contract'
@@ -58,10 +60,6 @@ export const MAX_RNX_CLOUD_BUNDLE_BYTES = RNX_CLOUD_MAX_ARTIFACT_BYTES
 // every message this module writes names the command through this constant.
 const REMOTE_COMMAND = 'rnx ios --remote'
 
-// an artifact this close to the ceiling is one asset away from being refused,
-// and the producer knows which assets it would be.
-const WARN_ARTIFACT_BYTES = Math.floor(MAX_RNX_CLOUD_BUNDLE_BYTES * 0.8)
-
 // a Metro asset dest is a shallow tree of images. a walk that runs past this
 // is pointed at something else entirely, and its extra entries cannot resolve
 // an asset anyway.
@@ -372,12 +370,19 @@ function distinctByContent(directory: string, options: readonly string[]): strin
  * reproduce, however complete that dest is. those come back neither verified
  * nor mismatched, and the caller refuses when a whole bundle is like that
  * rather than picking a directory it cannot check.
+ *
+ * a source tree holding both `icon.png` and `icon@1x.png` declares scale 1
+ * twice, and Metro hashes both files while a dest keeps one file per scale. the
+ * expo asset plugin records one md5 per declared file in `fileHashes`, and
+ * that is the identity check for such a descriptor: the file chosen for a
+ * scale must be one of the files Metro hashed at that scale.
  */
 function placeMetroDescriptor(
   listing: MetroAssetDestListing,
   descriptor: MetroAssetDescriptor,
 ): DescriptorPlacement {
-  const perScale = descriptor.scales.map((scale) =>
+  const scales = [...new Set(descriptor.scales)]
+  const perScale = scales.map((scale) =>
     distinctByContent(
       listing.directory,
       resolveMetroIosAssetDestFiles(listing.files, descriptor, scale),
@@ -387,7 +392,7 @@ function placeMetroDescriptor(
   // below is. one that resolved to several is left for the hash to settle.
   const files = new Map<number, string>()
   const ambiguous: string[] = []
-  descriptor.scales.forEach((scale, index) => {
+  scales.forEach((scale, index) => {
     const options = perScale[index] ?? []
     if (options.length === 1 && options[0]) files.set(scale, options[0])
     else if (options.length > 1) ambiguous.push(...options)
@@ -395,6 +400,12 @@ function placeMetroDescriptor(
   if (perScale.length === 0 || perScale.some((options) => options.length === 0)) {
     return { files, ambiguous, verified: false, mismatched: false }
   }
+  // a descriptor that is already embedded carries the embedder's sha256s in
+  // `fileHashes`; only Metro's own md5 per source file is an identity here.
+  const fileHashes =
+    !descriptor.fileUris && descriptor.fileHashes?.length === descriptor.scales.length
+      ? descriptor.fileHashes
+      : null
   for (const combination of placementCombinations(perScale)) {
     let bytes: Buffer[]
     try {
@@ -404,14 +415,29 @@ function placeMetroDescriptor(
     } catch {
       continue
     }
-    if (metroDescriptorHash(bytes) !== descriptor.hash) continue
+    const identical = fileHashes
+      ? bytes.every((file, index) => {
+          const digest = createHash('md5').update(file).digest('hex')
+          return descriptor.scales.some(
+            (scale, declared) =>
+              scale === scales[index] && fileHashes[declared] === digest,
+          )
+        })
+      : scales.length === descriptor.scales.length &&
+        metroDescriptorHash(bytes) === descriptor.hash
+    if (!identical) continue
     const chosen = new Map<number, string>()
-    descriptor.scales.forEach((scale, index) => {
+    scales.forEach((scale, index) => {
       const relative = combination[index]
       if (relative) chosen.set(scale, relative)
     })
     return { files: chosen, ambiguous: [], verified: true, mismatched: false }
   }
+  // a duplicated scale with no per-file md5 leaves Metro's digest covering a
+  // file this dest does not hold, so nothing here can be called wrong.
+  if (!fileHashes && scales.length !== descriptor.scales.length) {
+    return { files, ambiguous, verified: false, mismatched: false }
+  }
   // every declared scale is here and no arrangement of them is this asset, so
   // the directory holds different images under these names.
   return { files, ambiguous, verified: false, mismatched: true }
@@ -625,6 +651,11 @@ export interface CloudArtifactProduction {
 export async function produceCloudArtifact(
   bundlePath: string,
   assetsPath?: string,
+  /**
+   * the largest artifact the consumer accepts. the nano simulator's limit is
+   * the default; a box that accepts a larger artifact passes its own.
+   */
+  maxBytes: number = MAX_RNX_CLOUD_BUNDLE_BYTES,
 ): Promise<CloudArtifactProduction> {
   const source = await loadBundleSource(bundlePath)
   const descriptors = extractAssetDescriptors(source)
@@ -703,9 +734,9 @@ export async function produceCloudArtifact(
   })
   const bytes = Buffer.from(artifact.code, 'utf8')
   const assets = artifact.receipt.assets
-  if (bytes.length > MAX_RNX_CLOUD_BUNDLE_BYTES) {
+  if (bytes.length > maxBytes) {
     throw new Error(
-      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes and exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit. Embedded assets weigh ${assets.bytes} bytes on disk, and base64 embedding costs about a third on top of that, so the practical asset budget is roughly 15 MB.${largestEmbeddedAssets(assets.sizes, 10)}`,
+      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes and exceeds the ${maxBytes}-byte limit. Embedded assets weigh ${assets.bytes} bytes on disk, and base64 embedding costs about a third on top of that, so the practical asset budget is roughly ${Math.round((maxBytes * 0.75) / 1e6)} MB.${largestEmbeddedAssets(assets.sizes, 10)}`,
     )
   }
   const warnings: string[] = []
@@ -714,9 +745,11 @@ export async function produceCloudArtifact(
       `${REMOTE_COMMAND} embedded a placeholder image for ${substituted.length} asset(s) no scale of which is in ${search.searched.join(', ') || 'any asset dest directory'}: ${substituted.join(', ')}. Build the bundle with --assets-dest, or pass --assets <dir>, to ship the real images.`,
     )
   }
-  if (bytes.length >= WARN_ARTIFACT_BYTES) {
+  // an artifact this close to the ceiling is one asset away from being refused,
+  // and the producer knows which assets it would be.
+  if (bytes.length >= Math.floor(maxBytes * 0.8)) {
     warnings.push(
-      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes, ${Math.round((bytes.length / MAX_RNX_CLOUD_BUNDLE_BYTES) * 100)}% of the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit.${largestEmbeddedAssets(assets.sizes, 5)}`,
+      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes, ${Math.round((bytes.length / maxBytes) * 100)}% of the ${maxBytes}-byte limit.${largestEmbeddedAssets(assets.sizes, 5)}`,
     )
   }
   return {
@@ -867,6 +900,18 @@ export function resolveCloudSessionForParsed(
 ): CloudSession | null {
   const session = readCloudSession()
   if (!session) return null
+  // a box holds one simulator and names it by the box, so --sim names a box
+  // rather than a sim there and this shell already knows which box it is on.
+  if (session.service === 'box') {
+    if (parsed.simIdSource === 'flag' && parsed.simId !== session.boxId) {
+      throw new Error(
+        `this shell is connected to box ${session.boxId}; ${
+          parsed.simId ? `--sim ${parsed.simId}` : 'the requested simulator'
+        } is not available in this shell`,
+      )
+    }
+    return session
+  }
   if (parsed.simIdSource === 'flag' && parsed.simId !== session.simId) {
     throw new Error(
       `this shell is connected to remote simulator ${session.simId}; ${
@@ -894,7 +939,7 @@ function cloudCommand(command: {
 class CloudBridge implements WsBridge {
   readonly plane = 'cloud' as const
 
-  constructor(private readonly session: CloudSession) {}
+  constructor(private readonly session: CloudSimSession) {}
 
   async send(
     command: { type: string; [key: string]: unknown },
@@ -971,9 +1016,100 @@ class CloudBridge implements WsBridge {
   close(): void {}
 }
 
+/**
+ * a micro box's bridge.
+ *
+ * the box holds no simulator of its own: the one it shows lives in its Box
+ * page, which runs the same shell the local CLI drives over the daemon bridge.
+ * so this transport moves the whole bridge vocabulary rather than the nano
+ * subset (every verb that works against a local sim works against a box), and
+ * the box service is only the relay in the middle. that is also why there is
+ * no claim: the box token addresses the box, and the page answers for it.
+ */
+class CloudBoxBridge implements WsBridge {
+  readonly plane = 'cloud' as const
+
+  constructor(private readonly session: CloudBoxSession) {}
+
+  async send(
+    command: { type: string; [key: string]: unknown },
+    options?: { timeoutMs?: number },
+  ): Promise<unknown> {
+    const id = randomUUID()
+    // the wire id is this request's, so the command carries none. `simId` names
+    // a local sim among several and a box has exactly one.
+    const payload: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(command)) {
+      if (key !== 'id' && key !== 'simId') payload[key] = value
+    }
+    let response: Response
+    try {
+      response = await fetch(
+        `${this.session.apiOrigin}/v1/boxes/${encodeURIComponent(this.session.boxId)}/commands`,
+        {
+          method: 'POST',
+          headers: {
+            authorization: `Bearer ${this.session.boxToken}`,
+            'content-type': 'application/json',
+          },
+          body: JSON.stringify({ id, command: payload }),
+          ...(options?.timeoutMs
+            ? { signal: AbortSignal.timeout(options.timeoutMs) }
+            : {}),
+        },
+      )
+    } catch (error) {
+      throw new Error(
+        `could not reach box ${this.session.boxId} at ${this.session.apiOrigin}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      )
+    }
+    const text = await response.text()
+    if (!response.ok) throw responseError(response.status, text)
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(text)
+    } catch {
+      throw new Error('box command returned unreadable JSON')
+    }
+    if (!isRecord(parsed) || parsed.id !== id) {
+      throw new Error('box command returned an invalid command receipt')
+    }
+    if (typeof parsed.error === 'string' && parsed.error) throw new Error(parsed.error)
+    if (!Object.hasOwn(parsed, 'result')) {
+      throw new Error('box command receipt has no result')
+    }
+    return parsed.result
+  }
+
+  listSims(): Promise<BridgeSimInfo[]> {
+    return Promise.reject(new Error('a box does not expose a local simulator list'))
+  }
+
+  focusSim(): Promise<never> {
+    return Promise.reject(new Error('a box simulator has no browser window to focus'))
+  }
+
+  closeSim(): Promise<never> {
+    return Promise.reject(new Error('close a box simulator with rnx box stop'))
+  }
+
+  claim(): Promise<BridgeClaimResult> {
+    return Promise.reject(
+      new Error('a box simulator is held by its Box page and has nothing to claim'),
+    )
+  }
+
+  close(): void {}
+}
+
 export function createCloudBridgeForParsed(parsed: ParsedBridgeCliArgs): WsBridge | null {
   const session = resolveCloudSessionForParsed(parsed)
-  return session ? new CloudBridge(session) : null
+  if (!session) return null
+  return session.service === 'box'
+    ? new CloudBoxBridge(session)
+    : new CloudBridge(session)
 }
 
 function readClaimResponse(value: unknown): { id: string; expiresAt: number } {
@@ -990,11 +1126,11 @@ function readClaimResponse(value: unknown): { id: string; expiresAt: number } {
 }
 
 export async function claimCloudSimulator(
-  session: CloudSession,
+  session: CloudSimSession,
   options: { force?: boolean } = {},
 ): Promise<{
   claim: { id: string; expiresAt: number }
-  session: CloudSession
+  session: CloudSimSession
 }> {
   const response = await fetch(
     `${session.apiOrigin}/v1/sims/${encodeURIComponent(session.simId)}/claim`,
@@ -1024,7 +1160,7 @@ export async function claimCloudSimulator(
   }
 }
 
-export async function confirmCloudSimulator(session: CloudSession): Promise<void> {
+export async function confirmCloudSimulator(session: CloudSimSession): Promise<void> {
   const confirmed = await claimCloudSimulator(session)
   if (confirmed.session.claimId !== session.claimId) {
     throw new Error('remote simulator confirmation replaced the initial claim')

package/cli/cloud-dispatch.ts

@@ -158,6 +158,21 @@ export async function dispatchCloudBoundary({
   }
   if (!session) return { handled: false }
 
+  // a box relays the whole bridge vocabulary to the page hosting its
+  // simulator, which runs the same shell the local CLI drives. so there is no
+  // subset to police: every command below reaches it through the ordinary
+  // bridge, which createBridgeFromParsed points at the box. the two exceptions
+  // are the two commands that are about a nano claim, which a box has none of.
+  if (session.service === 'box') {
+    if (command === 'claim' || command === 'close') {
+      console.error(
+        `  rnx ${command} is not available for a box; its simulator is held by the Box page. use rnx box stop to end the box.`,
+      )
+      return { handled: true, code: 1 }
+    }
+    return { handled: false }
+  }
+
   if (command === 'claim') {
     try {
       const descriptor = cloudSession.requireCloudSessionShellUpdate()

package/cli/cloud-session.ts

@@ -1,7 +1,7 @@
 import { fstatSync, writeSync } from 'node:fs'
 import { isLoopbackHost } from '../src/backend-origin'
 
-const CLOUD_SESSION_VERSION = 2 as const
+const CLOUD_SESSION_VERSION = 3 as const
 const SHELL_UPDATE_FD_ENV = 'RNX_SHELL_UPDATE_FD'
 const MAX_ENCODED_SESSION_BYTES = 32 * 1024
 
@@ -10,10 +10,19 @@ export const RNX_SHELL_UPDATE_PREFIX = '__RNX_SHELL_UPDATE_V1__'
 export const RNX_SHELL_UPDATE_SET_PREFIX = `${RNX_SHELL_UPDATE_PREFIX}set:`
 export const RNX_SHELL_UPDATE_UNSET = `${RNX_SHELL_UPDATE_PREFIX}unset`
 
-// the shell's target: one remote host, addressed by the box token, and the
-// simulator inside it that ordinary commands reach with the simulator token
-export interface CloudSession {
-  version: 2
+// the shell's remote target. two services answer rnx commands and they are
+// addressed differently, so the session names which one it is rather than
+// leaving a reader to infer it from which fields happen to be filled in.
+export type CloudSession = CloudSimSession | CloudBoxSession
+
+/**
+ * one remote host, addressed by the box token, and the simulator inside it
+ * that ordinary commands reach with the simulator token. this is what
+ * `rnx ios --remote` produces.
+ */
+export interface CloudSimSession {
+  version: 3
+  service: 'sim'
   boxId: string
   boxToken: string
   simId: string
@@ -22,6 +31,20 @@ export interface CloudSession {
   token: string
 }
 
+/**
+ * a micro box, whose simulator lives in its own Box page rather than in the
+ * service. there is nothing to claim and no separate simulator token: the box
+ * token addresses the box, and the box relays each command to the page that
+ * is hosting it.
+ */
+export interface CloudBoxSession {
+  version: 3
+  service: 'box'
+  boxId: string
+  boxToken: string
+  apiOrigin: string
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
@@ -56,16 +79,17 @@ export function createCloudSession(input: {
   apiOrigin: string
   claimId: string
   token: string
-}): CloudSession {
+}): CloudSimSession {
   const session = {
     version: CLOUD_SESSION_VERSION,
+    service: 'sim',
     boxId: input.boxId.trim(),
     boxToken: input.boxToken,
     simId: input.simId.trim(),
     apiOrigin: normalizeCloudOrigin(input.apiOrigin.trim()),
     claimId: input.claimId.trim(),
     token: input.token,
-  } satisfies CloudSession
+  } satisfies CloudSimSession
   if (
     !session.boxId ||
     !session.boxToken ||
@@ -78,10 +102,30 @@ export function createCloudSession(input: {
   return session
 }
 
+export function createCloudBoxSession(input: {
+  boxId: string
+  boxToken: string
+  apiOrigin: string
+}): CloudBoxSession {
+  const session = {
+    version: CLOUD_SESSION_VERSION,
+    service: 'box',
+    boxId: input.boxId.trim(),
+    boxToken: input.boxToken,
+    apiOrigin: normalizeCloudOrigin(input.apiOrigin.trim()),
+  } satisfies CloudBoxSession
+  if (!session.boxId || !session.boxToken) {
+    throw new Error('cloud box session requires a box, an origin, and a box token')
+  }
+  return session
+}
+
 export function serializeCloudSession(session: CloudSession): string {
-  return Buffer.from(JSON.stringify(createCloudSession(session)), 'utf8').toString(
-    'base64url',
-  )
+  const validated =
+    session.service === 'sim'
+      ? createCloudSession(session)
+      : createCloudBoxSession(session)
+  return Buffer.from(JSON.stringify(validated), 'utf8').toString('base64url')
 }
 
 export function parseCloudSession(encoded: string): CloudSession {
@@ -108,21 +152,29 @@ export function parseCloudSession(encoded: string): CloudSession {
   }
   const boxId = parsed.boxId
   const boxToken = parsed.boxToken
-  const simId = parsed.simId
   const apiOrigin = parsed.apiOrigin
-  const claimId = parsed.claimId
-  const token = parsed.token
   if (
     typeof boxId !== 'string' ||
     typeof boxToken !== 'string' ||
-    typeof simId !== 'string' ||
-    typeof apiOrigin !== 'string' ||
-    typeof claimId !== 'string' ||
-    typeof token !== 'string'
+    typeof apiOrigin !== 'string'
   ) {
     throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`)
   }
   try {
+    if (parsed.service === 'box') {
+      return createCloudBoxSession({ boxId, boxToken, apiOrigin })
+    }
+    const simId = parsed.simId
+    const claimId = parsed.claimId
+    const token = parsed.token
+    if (
+      parsed.service !== 'sim' ||
+      typeof simId !== 'string' ||
+      typeof claimId !== 'string' ||
+      typeof token !== 'string'
+    ) {
+      throw new Error('unreadable cloud session')
+    }
     return createCloudSession({ boxId, boxToken, simId, apiOrigin, claimId, token })
   } catch {
     throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`)

package/cli/commands/box/bundle-plane.ts

@@ -0,0 +1,71 @@
+// ProjectFilePlane over an already-built bundle held in memory.
+//
+// a prebuilt Box has no sources, so there is no checkout to index and nothing
+// on disk to stay in step with: the whole project is the bundle the page boots.
+// CheckoutFilePlane cannot serve this because it asks git what belongs to the
+// project, and a bundle produced by a build lives outside any checkout.
+//
+// the bundle is split here rather than by the caller, so the one place that
+// decides where the parts go is the one place that decides how big they are.
+
+import { PREBUILT_BUNDLE_PART_BYTES, prebuiltBundlePartPath } from '@rnx/box/template'
+import type { ProjectFileMeta, ProjectFilePlane } from '@rnx/box/plane'
+
+export class BundleFilePlane implements ProjectFilePlane {
+  private readonly parts = new Map<string, Uint8Array>()
+  private readonly entries = new Map<string, ProjectFileMeta>()
+
+  constructor(bundle: Uint8Array) {
+    if (bundle.byteLength === 0) throw new Error('a Box bundle cannot be empty')
+    for (
+      let offset = 0, index = 0;
+      offset < bundle.byteLength;
+      offset += PREBUILT_BUNDLE_PART_BYTES, index++
+    ) {
+      const part = bundle.subarray(offset, offset + PREBUILT_BUNDLE_PART_BYTES)
+      this.record(prebuiltBundlePartPath(index), part)
+    }
+  }
+
+  private record(path: string, content: Uint8Array): void {
+    this.parts.set(path, content)
+    this.entries.set(path, {
+      size: content.byteLength,
+      readOnly: false,
+      // a Metro bundle is JavaScript. the flag is what decides whether a shell
+      // may overwrite a file with text, and marking it binary would make the
+      // bundle unwritable from inside the box for no reason.
+      binary: false,
+    })
+  }
+
+  index(): ReadonlyMap<string, ProjectFileMeta> {
+    return this.entries
+  }
+
+  // nothing else can change this plane, so the index is already current.
+  refresh(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  async read(path: string): Promise<string> {
+    return new TextDecoder().decode(await this.readBytes(path))
+  }
+
+  readBytes(path: string): Promise<Uint8Array> {
+    const part = this.parts.get(path)
+    if (!part) return Promise.reject(new Error(`no such file: ${path}`))
+    return Promise.resolve(part)
+  }
+
+  write(path: string, content: Uint8Array): Promise<void> {
+    this.record(path, content)
+    return Promise.resolve()
+  }
+
+  delete(path: string): Promise<void> {
+    this.parts.delete(path)
+    this.entries.delete(path)
+    return Promise.resolve()
+  }
+}