rnxsim 0.1.518 → 0.1.520

package/cli/cloud-client.ts

@@ -11,6 +11,7 @@ import { dirname, extname, join, resolve } from 'node:path'
 import {
   embedMetroAssetFiles,
   extractAssetDescriptors,
+  isEmbeddedAssetDescriptor,
   metroAssetPlaceholderBytes,
   metroAssetScaleFilename,
   metroIosAssetDestRelatives,
@@ -27,44 +28,31 @@ import { inferMetroModuleIdentity } from '../../sootsim-engine/src/metro-fingerp
 import { isLoopbackHost } from '../src/backend-origin.ts'
 import {
   isRnxCloudCommandType,
+  isRnxCloudSimStatus,
   RNX_CLOUD_MAX_ARTIFACT_BYTES,
   RNX_CLOUD_TOKEN_SCOPES,
   rnxCloudCommandScope,
   rnxCloudScopesAllowCommand,
   type RnxCloudBoxCreateReceipt,
-  type RnxCloudCreateReceipt,
+  type RnxCloudClaim,
+  type RnxCloudSimCreateResponse,
+  type RnxCloudSimInstance,
+  type RnxCloudSimView,
 } from '../src/cloud-contract.ts'
 import {
   RNX_METRO_MODULE_IDENTITY_VERSION,
   type RNXMetroModuleIdentityMetadata,
 } from '../src/metro-production-bundle.ts'
 import { rnxPublicBrand } from '../src/public-brand.ts'
-import { CHOOSE_ACCOUNT_HINT, resolveCliAuth } from './auth.ts'
+import { CHOOSE_ACCOUNT_HINT } from './auth.ts'
 import {
   createCloudSession,
   normalizeCloudOrigin,
   readCloudSession,
-  type CloudBoxSession,
   type CloudSession,
   type CloudSimSession,
   type RemotePlatform,
 } from './cloud-session.ts'
-
-export class UnsupportedRemoteHostError extends Error {
-  readonly code = 'unsupported_host' as const
-  readonly platform: string
-  readonly host: string
-
-  constructor(platform: string, host: string, message?: string) {
-    super(
-      message ??
-        `rnx remote ${platform} does not support --${host}: rnxsim/cloud only creates iOS simulators`,
-    )
-    this.name = 'UnsupportedRemoteHostError'
-    this.platform = platform
-    this.host = host
-  }
-}
 import { detectProject } from './commands/detect.ts'
 import type { StorageSnapshot } from '../../sootsim-engine/src/preview/storage-snapshot-contract.ts'
 import type {
@@ -129,7 +117,12 @@ function failureSentence(text: string): string | null {
   }
   if (!isRecord(parsed)) return null
   if (isRecord(parsed.error) && typeof parsed.error.message === 'string') {
-    return parsed.error.message
+    // the code is the contract a script matches on; the message is for people.
+    const code =
+      typeof parsed.error.code === 'string' && parsed.error.code
+        ? ` [${parsed.error.code}]`
+        : ''
+    return `${parsed.error.message}${code}`
   }
   if (typeof parsed.message === 'string') return parsed.message
   if (typeof parsed.error === 'string') return parsed.error
@@ -693,20 +686,68 @@ export async function producePreviewArtifact(
   )
 }
 
-async function produceArtifact(
+export interface CloudBoxArtifactProduction {
+  bytes: Buffer
+  assetsDirectory: string | null
+  warnings: string[]
+}
+
+/** prepares a prebuilt bundle for a Box by embedding any beside-the-bundle Metro assets. */
+export async function produceCloudBoxArtifact(
+  bundlePath: string,
+): Promise<CloudBoxArtifactProduction> {
+  const prepared = await embedBundleAssets(
+    bundlePath,
+    'rnx box create',
+    'allow-placeholders',
+  )
+  const warnings: string[] = []
+  if (prepared.search.unconfirmed && prepared.dest) {
+    warnings.push(
+      `rnx box create read this bundle's assets from ${prepared.dest.directory} on layout alone: every asset declares a scale that directory does not hold, so not one of Metro's hashes could be reproduced. Confirm these are the images this bundle was built against.`,
+    )
+  }
+  if (prepared.substituted.length > 0) {
+    warnings.push(
+      `rnx box create embedded a placeholder image for ${prepared.substituted.length} asset(s) no scale of which is in ${prepared.search.searched.join(', ') || 'any asset dest directory'}: ${prepared.substituted.join(', ')}. Rebuild with \`react-native bundle --assets-dest\` to ship the real images.`,
+    )
+  }
+  return {
+    bytes: Buffer.from(prepared.code, 'utf8'),
+    assetsDirectory: prepared.dest?.directory ?? null,
+    warnings,
+  }
+}
+
+async function embedBundleAssets(
   bundlePath: string,
-  maxBytes: number,
   command: string,
   assetPolicy: 'allow-placeholders' | 'require-assets',
-): Promise<CloudArtifactProduction> {
+): Promise<{
+  source: string
+  code: string
+  search: MetroAssetSearch
+  dest: MetroAssetDest | null
+  substituted: string[]
+}> {
   const source = await loadBundleSource(bundlePath)
-  const descriptors = extractAssetDescriptors(source)
+  const descriptors = extractAssetDescriptors(source).filter(
+    (descriptor) => !isEmbeddedAssetDescriptor(descriptor),
+  )
+  if (descriptors.length === 0) {
+    return {
+      source,
+      code: source,
+      search: { dest: null, searched: [], truncated: false, unconfirmed: false },
+      dest: null,
+      substituted: [],
+    }
+  }
   // an https bundle has no local tree to search, and a bundle with no assets
   // has nothing to search for.
-  const search: MetroAssetSearch =
-    descriptors.length > 0 && !isRemoteBundleInput(bundlePath)
-      ? searchMetroAssetDest(bundlePath, descriptors)
-      : { dest: null, searched: [], truncated: false, unconfirmed: false }
+  const search: MetroAssetSearch = !isRemoteBundleInput(bundlePath)
+    ? searchMetroAssetDest(bundlePath, descriptors)
+    : { dest: null, searched: [], truncated: false, unconfirmed: false }
   const dest = search.dest
   // `embedMetroAssetFiles` re-parses the bundle, so its descriptors are equal
   // to the ones the search placed but not the same objects.
@@ -768,7 +809,23 @@ async function produceArtifact(
       `${command} could not read ${join(dest?.directory ?? '.', classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`,
     )
   })
-  const artifact = await buildRnxCloudArtifact(embedded.code, {
+  return {
+    source,
+    code: embedded.code,
+    search,
+    dest,
+    substituted,
+  }
+}
+
+async function produceArtifact(
+  bundlePath: string,
+  maxBytes: number,
+  command: string,
+  assetPolicy: 'allow-placeholders' | 'require-assets',
+): Promise<CloudArtifactProduction> {
+  const prepared = await embedBundleAssets(bundlePath, command, assetPolicy)
+  const artifact = await buildRnxCloudArtifact(prepared.code, {
     inferModuleIdentity: inferCloudModuleIdentity,
   })
   const bytes = Buffer.from(artifact.code, 'utf8')
@@ -779,14 +836,14 @@ async function produceArtifact(
     )
   }
   const warnings: string[] = []
-  if (search.unconfirmed && dest) {
+  if (prepared.search.unconfirmed && prepared.dest) {
     warnings.push(
-      `${command} read this bundle's assets from ${dest.directory} on layout alone: every asset declares a scale that directory does not hold, so not one of Metro's hashes could be reproduced. Confirm these are the images this bundle was built against.`,
+      `${command} read this bundle's assets from ${prepared.dest.directory} on layout alone: every asset declares a scale that directory does not hold, so not one of Metro's hashes could be reproduced. Confirm these are the images this bundle was built against.`,
     )
   }
-  if (substituted.length > 0) {
+  if (prepared.substituted.length > 0) {
     warnings.push(
-      `${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(', ')}. Rebuild with \`react-native bundle --assets-dest\` to ship the real images.`,
+      `${command} embedded a placeholder image for ${prepared.substituted.length} asset(s) no scale of which is in ${prepared.search.searched.join(', ') || 'any asset dest directory'}: ${prepared.substituted.join(', ')}. Rebuild with \`react-native bundle --assets-dest\` to ship the real images.`,
     )
   }
   // an artifact this close to the ceiling is one asset away from being refused,
@@ -800,7 +857,7 @@ async function produceArtifact(
     bytes,
     sha256: createHash('sha256').update(bytes).digest('hex'),
     receipt: artifact.receipt,
-    assetsDirectory: dest?.directory ?? null,
+    assetsDirectory: prepared.dest?.directory ?? null,
     warnings,
   }
 }
@@ -864,8 +921,8 @@ function readCreateResponse(
   }
 }
 
-// `rnx ios --remote <bundle>` creates the remote host for the artifact and its
-// first simulator in one request, and the shell then targets that simulator
+// "send to box" wraps the running app in a nano box with its first simulator
+// in one request, and the shell then targets that simulator
 export async function createCloudBox(options: CreateCloudBoxOptions): Promise<{
   receipt: RnxCloudBoxCreateReceipt
   session: CloudSession
@@ -874,9 +931,6 @@ export async function createCloudBox(options: CreateCloudBoxOptions): Promise<{
   warnings: string[]
 }> {
   const platform = options.platform ?? 'ios'
-  if (platform === 'android') {
-    throw new UnsupportedRemoteHostError('android', 'nano')
-  }
   const apiOrigin = resolveCloudOrigin(options.apiOrigin)
   const artifact = await produceCloudArtifact(options.bundlePath)
   const boxName = options.boxName?.trim()
@@ -949,23 +1003,323 @@ export async function createCloudBox(options: CreateCloudBoxOptions): Promise<{
   }
 }
 
+// one customer plane: the sim-service instance API. every `rnx remote`
+// simulator is created, listed, read, and deleted here; the box stays the
+// host behind it and is never the addressed object.
+
+export interface CreateRemoteSimOptions {
+  bundlePath: string
+  device: string
+  authorization: string
+  /** the account to bill when the authorization is a session token; an api key names its own */
+  accountId: string | null
+  platform: RemotePlatform
+  apiOrigin?: string
+  /** match an existing simulator for the same artifact and labels instead of creating */
+  reuse?: boolean
+}
+
+function readStringMap(value: unknown): Record<string, string> {
+  if (!isRecord(value)) return {}
+  const labels: Record<string, string> = {}
+  for (const [key, label] of Object.entries(value)) {
+    if (typeof label === 'string') labels[key] = label
+  }
+  return labels
+}
+
+function readSimCreateResponse(
+  value: unknown,
+  expectedBytes: number,
+  expectedSha256: string,
+): RnxCloudSimCreateResponse {
+  if (!isRecord(value)) throw new Error('remote simulator create returned invalid JSON')
+  const artifactId = `sha256:${expectedSha256}` as const
+  const artifact = isRecord(value.artifact) ? value.artifact : null
+  const claim = isRecord(value.claim) ? value.claim : null
+  if (
+    typeof value.simId !== 'string' ||
+    !value.simId ||
+    !artifact ||
+    artifact.id !== artifactId ||
+    artifact.bytes !== expectedBytes ||
+    !claim ||
+    typeof claim.id !== 'string' ||
+    !claim.id ||
+    typeof claim.expiresAt !== 'number' ||
+    typeof value.token !== 'string' ||
+    !value.token ||
+    typeof value.status !== 'string' ||
+    !isRnxCloudSimStatus(value.status) ||
+    (value.streamUrl !== null && typeof value.streamUrl !== 'string')
+  ) {
+    throw new Error('remote simulator create returned an invalid receipt')
+  }
+  return {
+    simId: value.simId,
+    artifact: { id: artifactId, bytes: expectedBytes },
+    claim: { id: claim.id, expiresAt: claim.expiresAt },
+    token: value.token,
+    status: value.status,
+    labels: readStringMap(value.labels),
+    streamUrl: value.streamUrl,
+  }
+}
+
+// `rnx remote ios|android <bundle>` creates one simulator through the
+// instance API and waits for its app to answer ready. both platforms run
+// this same typed path: an android create is refused by the service with a
+// typed 400, never by a cli-side branch.
+export async function createRemoteSim(options: CreateRemoteSimOptions): Promise<{
+  receipt: RnxCloudSimCreateResponse
+  session: CloudSession
+  artifact: RnxCloudArtifactReceipt
+  assetsDirectory: string | null
+  warnings: string[]
+  reused: boolean
+}> {
+  const apiOrigin = resolveCloudOrigin(options.apiOrigin)
+  const artifact = await produceCloudArtifact(options.bundlePath)
+  const query = new URLSearchParams({
+    labels: `rnx.remote=1,rnx.platform=${options.platform},rnx.bundle=${artifact.sha256.slice(0, 12)}`,
+    wait: 'true',
+  })
+  if (options.reuse) query.set('reuseIfExists', 'true')
+  const headers: Record<string, string> = {
+    authorization: options.authorization,
+    'content-type': 'application/javascript',
+    'x-rnx-artifact-sha256': artifact.sha256,
+    'x-rnx-platform': options.platform,
+    'x-rnx-device': options.device,
+    ...(options.accountId ? { 'x-rnx-account-id': options.accountId } : null),
+  }
+  let response: Response
+  try {
+    response = await fetch(`${apiOrigin}/v1/sims?${query}`, {
+      method: 'POST',
+      headers,
+      body: new Uint8Array(artifact.bytes),
+    })
+  } catch (error) {
+    throw new Error(
+      `${REMOTE_COMMAND} could not reach ${apiOrigin}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  const responseText = await response.text()
+  if (!response.ok) throw responseError(response.status, responseText)
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(responseText)
+  } catch {
+    throw new Error('remote simulator create returned unreadable JSON')
+  }
+  const receipt = readSimCreateResponse(parsed, artifact.bytes.length, artifact.sha256)
+  const session = createCloudSession({
+    simId: receipt.simId,
+    apiOrigin,
+    claimId: receipt.claim.id,
+    token: receipt.token,
+    streamUrl: receipt.streamUrl,
+    platform: options.platform,
+    device: options.device,
+    artifact: {
+      sha256: artifact.sha256,
+      bytes: artifact.bytes.length,
+    },
+  })
+  return {
+    receipt,
+    session,
+    artifact: artifact.receipt,
+    assetsDirectory: artifact.assetsDirectory,
+    warnings: artifact.warnings,
+    reused: response.status === 200,
+  }
+}
+
+function readSimView(value: unknown): RnxCloudSimView {
+  if (!isRecord(value) || !isRecord(value.labels)) {
+    throw new Error('remote simulator list returned an invalid simulator')
+  }
+  const labels: Record<string, string> = {}
+  for (const [key, label] of Object.entries(value.labels)) {
+    if (typeof label !== 'string') {
+      throw new Error('remote simulator list returned an invalid simulator')
+    }
+    labels[key] = label
+  }
+  const artifact = isRecord(value.artifact) ? value.artifact : null
+  const claimValue = isRecord(value.claim) ? value.claim : null
+  let claim: RnxCloudClaim | null = null
+  if (claimValue !== null) {
+    if (
+      typeof claimValue.id !== 'string' ||
+      !claimValue.id ||
+      typeof claimValue.expiresAt !== 'number'
+    ) {
+      throw new Error('remote simulator list returned an invalid simulator')
+    }
+    claim = { id: claimValue.id, expiresAt: claimValue.expiresAt }
+  }
+  const inactivityTimeoutMs = value.inactivityTimeoutMs
+  const hardTimeoutAt = value.hardTimeoutAt
+  if (
+    typeof value.simId !== 'string' ||
+    !value.simId ||
+    typeof value.status !== 'string' ||
+    !isRnxCloudSimStatus(value.status) ||
+    !artifact ||
+    typeof artifact.sha256 !== 'string' ||
+    typeof artifact.bytes !== 'number' ||
+    typeof value.createdAt !== 'number' ||
+    typeof value.lastActiveAt !== 'number' ||
+    (typeof inactivityTimeoutMs !== 'number' && inactivityTimeoutMs !== null) ||
+    (typeof hardTimeoutAt !== 'number' && hardTimeoutAt !== null)
+  ) {
+    throw new Error('remote simulator list returned an invalid simulator')
+  }
+  return {
+    simId: value.simId,
+    status: value.status,
+    labels,
+    artifact: { sha256: artifact.sha256, bytes: artifact.bytes },
+    claim,
+    createdAt: value.createdAt,
+    lastActiveAt: value.lastActiveAt,
+    inactivityTimeoutMs,
+    hardTimeoutAt,
+  }
+}
+
+// `rnx remote list`: the simulators this account runs that `rnx remote` made.
+export async function listRemoteSims(options: {
+  apiOrigin?: string
+  authorization: string
+  accountId?: string | null
+}): Promise<RnxCloudSimView[]> {
+  const apiOrigin = resolveCloudOrigin(options.apiOrigin)
+  const selector = new URLSearchParams({ labelSelector: 'rnx.remote=1' })
+  const headers: Record<string, string> = { authorization: options.authorization }
+  if (options.accountId) headers['x-rnx-account-id'] = options.accountId
+  let response: Response
+  try {
+    response = await fetch(`${apiOrigin}/v1/sims?${selector}`, { headers })
+  } catch (error) {
+    throw new Error(
+      `${REMOTE_COMMAND} could not reach ${apiOrigin}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  const responseText = await response.text()
+  if (!response.ok) throw responseError(response.status, responseText)
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(responseText)
+  } catch {
+    throw new Error('remote simulator list returned unreadable JSON')
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.sims)) {
+    throw new Error('remote simulator list returned invalid JSON')
+  }
+  return parsed.sims.map(readSimView)
+}
+
+// one simulator reread by id: the reattach liveness probe, and the fresh
+// watch url an api-key caller mints with it. a simulator this account no
+// longer runs reads back as missing rather than forbidden, so 404 is null
+// and anything else refused throws.
+export async function getRemoteSim(options: {
+  apiOrigin?: string
+  simId: string
+  authorization: string
+}): Promise<RnxCloudSimInstance | null> {
+  const apiOrigin = resolveCloudOrigin(options.apiOrigin)
+  let response: Response
+  try {
+    response = await fetch(`${apiOrigin}/v1/sims/${encodeURIComponent(options.simId)}`, {
+      headers: { authorization: options.authorization },
+    })
+  } catch (error) {
+    throw new Error(
+      `${REMOTE_COMMAND} could not reach ${apiOrigin}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  const responseText = await response.text()
+  if (response.status === 404) return null
+  if (!response.ok) throw responseError(response.status, responseText)
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(responseText)
+  } catch {
+    throw new Error('remote simulator read returned unreadable JSON')
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.sim)) {
+    throw new Error('remote simulator read returned invalid JSON')
+  }
+  const view = readSimView(parsed.sim)
+  const streamUrl = parsed.sim.streamUrl
+  if (streamUrl !== null && streamUrl !== undefined && typeof streamUrl !== 'string') {
+    throw new Error('remote simulator read returned an invalid watch url')
+  }
+  return {
+    ...view,
+    streamUrl: typeof streamUrl === 'string' ? streamUrl : null,
+  }
+}
+
+// `rnx remote stop <id>`: delete one simulator by id. missing is null so the
+// caller can name what was not there; anything else refused throws.
+export async function deleteRemoteSim(options: {
+  apiOrigin?: string
+  simId: string
+  authorization: string
+  accountId?: string | null
+}): Promise<{ simId: string; status: string } | null> {
+  const apiOrigin = resolveCloudOrigin(options.apiOrigin)
+  const headers: Record<string, string> = { authorization: options.authorization }
+  if (options.accountId) headers['x-rnx-account-id'] = options.accountId
+  let response: Response
+  try {
+    response = await fetch(`${apiOrigin}/v1/sims/${encodeURIComponent(options.simId)}`, {
+      method: 'DELETE',
+      headers,
+    })
+  } catch (error) {
+    throw new Error(
+      `${REMOTE_COMMAND} could not reach ${apiOrigin}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  const responseText = await response.text()
+  if (response.status === 404) return null
+  if (!response.ok) throw responseError(response.status, responseText)
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(responseText)
+  } catch {
+    throw new Error('remote simulator delete returned unreadable JSON')
+  }
+  if (
+    !isRecord(parsed) ||
+    typeof parsed.simId !== 'string' ||
+    typeof parsed.status !== 'string'
+  ) {
+    throw new Error('remote simulator delete returned invalid JSON')
+  }
+  return { simId: parsed.simId, status: parsed.status }
+}
+
 export function resolveCloudSessionForParsed(
   parsed: Pick<ParsedBridgeCliArgs, 'simId' | 'simIdSource'>,
 ): 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}; ${
@@ -1082,107 +1436,12 @@ 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, admitted by caller
- * scope exactly like the nano plane, 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'))
-  }
-
-  resolveReloadedSim(): Promise<string | null> {
-    // cloud sims carry no local browser host, so there is no lineage to follow
-    return Promise.resolve(null)
-  }
-
-  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: Pick<ParsedBridgeCliArgs, 'simId' | 'simIdSource'>,
 ): WsBridge | null {
   const session = resolveCloudSessionForParsed(parsed)
   if (!session) return null
-  return session.service === 'box'
-    ? new CloudBoxBridge(session)
-    : new CloudBridge(session)
+  return new CloudBridge(session)
 }
 
 function readClaimResponse(value: unknown): { id: string; expiresAt: number } {
@@ -1240,32 +1499,17 @@ export async function confirmCloudSimulator(session: CloudSimSession): Promise<v
   }
 }
 
-// deletes the box, which closes every simulator it holds
-export async function closeCloudBox(session: CloudSession): Promise<void> {
-  if (session.service === 'box') {
-    const auth = resolveCliAuth()
-    let authHeader = `Bearer ${session.boxToken}`
-    if (auth?.kind === 'api-key') {
-      authHeader = `Bearer ${auth.secret}`
-    } else if (auth?.kind === 'session') {
-      authHeader = `Bearer ${auth.token}`
-    }
-    let response: Response
-    try {
-      response = await fetch(
-        `${session.apiOrigin}/v1/boxes/${encodeURIComponent(session.boxId)}/stop`,
-        {
-          method: 'POST',
-          headers: { authorization: authHeader },
-        },
-      )
-    } catch (error) {
-      throw new Error(
-        `could not reach box ${session.boxId} at ${session.apiOrigin}: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      )
-    }
+export async function closeCloudSession(session: CloudSession): Promise<void> {
+  const boxId = session.boxId
+  const boxToken = session.boxToken
+  if (boxId && boxToken) {
+    const response = await fetch(
+      `${session.apiOrigin}/v1/boxes/${encodeURIComponent(boxId)}`,
+      {
+        method: 'DELETE',
+        headers: { authorization: `Bearer ${boxToken}` },
+      },
+    )
     const text = await response.text()
     if (!response.ok && response.status !== 404) {
       throw responseError(response.status, text)
@@ -1273,10 +1517,10 @@ export async function closeCloudBox(session: CloudSession): Promise<void> {
     return
   }
   const response = await fetch(
-    `${session.apiOrigin}/v1/boxes/${encodeURIComponent(session.boxId)}`,
+    `${session.apiOrigin}/v1/sims/${encodeURIComponent(session.simId)}`,
     {
       method: 'DELETE',
-      headers: { authorization: `Bearer ${session.boxToken}` },
+      headers: { authorization: `Bearer ${session.token}` },
     },
   )
   const text = await response.text()
@@ -1284,115 +1528,3 @@ export async function closeCloudBox(session: CloudSession): Promise<void> {
     throw responseError(response.status, text)
   }
 }
-
-export interface AddCloudSimulatorOptions {
-  device: string
-  authorization: string
-  accountId: string | null
-}
-
-export async function addCloudSimulator(
-  session: CloudSession,
-  options: AddCloudSimulatorOptions,
-): Promise<{
-  receipt: RnxCloudCreateReceipt
-  session: CloudSession
-}> {
-  let response: Response
-  try {
-    response = await fetch(
-      `${session.apiOrigin}/v1/boxes/${encodeURIComponent(session.boxId)}/simulators`,
-      {
-        method: 'POST',
-        headers: {
-          authorization: `Bearer ${session.boxToken}`,
-          'x-rnx-account-authorization': options.authorization,
-          'content-type': 'application/json',
-          ...(options.accountId ? { 'x-rnx-account-id': options.accountId } : {}),
-        },
-        body: JSON.stringify({ device: options.device }),
-      },
-    )
-  } catch (error) {
-    throw new Error(
-      `could not reach the remote simulator at ${session.apiOrigin}: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    )
-  }
-  const responseText = await response.text()
-  if (!response.ok) {
-    if (response.status === 404) {
-      try {
-        const parsed: unknown = JSON.parse(responseText)
-        if (
-          isRecord(parsed) &&
-          (parsed.error === 'unknown_artifact' ||
-            (isRecord(parsed.error) && parsed.error.code === 'unknown_artifact'))
-        ) {
-          throw new Error(
-            'this remote simulator does not hold a new bundle; run `rnx close` and create again',
-          )
-        }
-      } catch (err) {
-        if (
-          err instanceof Error &&
-          err.message.startsWith('this remote simulator does not hold')
-        ) {
-          throw err
-        }
-      }
-      throw new Error(
-        'this remote simulator does not hold a new bundle; run `rnx close` and create again',
-      )
-    }
-    throw responseError(response.status, responseText)
-  }
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(responseText)
-  } catch {
-    throw new Error('remote simulator create returned unreadable JSON')
-  }
-  if (!isRecord(parsed) || !isRecord(parsed.simulator)) {
-    throw new Error('remote simulator create returned an invalid receipt')
-  }
-  const simulator = parsed.simulator
-  const simId = simulator.simId
-  const claim = isRecord(simulator.claim) ? simulator.claim : null
-  const token = simulator.token
-  const artifact = isRecord(simulator.artifact) ? simulator.artifact : null
-  if (
-    typeof simId !== 'string' ||
-    !simId ||
-    !claim ||
-    typeof claim.id !== 'string' ||
-    !claim.id ||
-    typeof claim.expiresAt !== 'number' ||
-    typeof token !== 'string' ||
-    !token ||
-    !artifact ||
-    typeof artifact.id !== 'string' ||
-    typeof artifact.bytes !== 'number'
-  ) {
-    throw new Error('remote simulator create returned an invalid receipt')
-  }
-  const receipt: RnxCloudCreateReceipt = {
-    simId,
-    artifact: { id: artifact.id as `sha256:${string}`, bytes: artifact.bytes },
-    claim: { id: claim.id, expiresAt: claim.expiresAt },
-  }
-  const updatedSession = createCloudSession({
-    ...session,
-    simId,
-    claimId: claim.id,
-    token,
-    platform: 'ios',
-    device: options.device,
-    artifact: {
-      sha256: artifact.id.replace(/^sha256:/, ''),
-      bytes: artifact.bytes,
-    },
-  })
-  return { receipt, session: updatedSession }
-}