peachsim 0.1.527 → 0.1.570

package/cli/cloud-client.ts

@@ -23,8 +23,8 @@ import {
   buildRnxCloudArtifact,
   type RnxCloudArtifactReceipt,
 } from '../../contrast-bundler/src/metroCloudArtifact.ts'
-import { loadMetroFingerprintRegistry } from '../../sootsim-engine/src/metro-fingerprint-registry-client.ts'
-import { inferMetroModuleIdentity } from '../../sootsim-engine/src/metro-fingerprint.ts'
+import { loadMetroFingerprintRegistry } from '../../peach-engine/src/metro-fingerprint-registry-client.ts'
+import { inferMetroModuleIdentity } from '../../peach-engine/src/metro-fingerprint.ts'
 import { isLoopbackHost } from '../src/backend-origin.ts'
 import {
   isRnxCloudCommandType,
@@ -44,17 +44,18 @@ import {
   type RNXMetroModuleIdentityMetadata,
 } from '../src/metro-production-bundle.ts'
 import { rnxPublicBrand } from '../src/public-brand.ts'
-import { CHOOSE_ACCOUNT_HINT } from './auth.ts'
+import { CHOOSE_ACCOUNT_HINT, resolveCliAuth } from './auth.ts'
 import {
   createCloudSession,
   normalizeCloudOrigin,
   readCloudSession,
+  type CloudBoxSession,
   type CloudSession,
   type CloudSimSession,
   type RemotePlatform,
 } from './cloud-session.ts'
 import { detectProject } from './commands/detect.ts'
-import type { StorageSnapshot } from '../../sootsim-engine/src/preview/storage-snapshot-contract.ts'
+import type { StorageSnapshot } from '../../peach-engine/src/preview/storage-snapshot-contract.ts'
 import type {
   BridgeClaimResult,
   BridgeSimInfo,
@@ -69,6 +70,22 @@ export const MAX_RNX_CLOUD_BUNDLE_BYTES = RNX_CLOUD_MAX_ARTIFACT_BYTES
 const REMOTE_COMMAND = 'rnx remote'
 const PREVIEW_COMMAND = 'rnx preview'
 
+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}: peachsim/cloud only creates iOS simulators`,
+    )
+    this.name = 'UnsupportedRemoteHostError'
+    this.platform = platform
+    this.host = host
+  }
+}
+
 // 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.
@@ -1072,7 +1089,7 @@ function readSimCreateResponse(
 // typed 400, never by a cli-side branch.
 export async function createRemoteSim(options: CreateRemoteSimOptions): Promise<{
   receipt: RnxCloudSimCreateResponse
-  session: CloudSession
+  session: CloudSimSession
   artifact: RnxCloudArtifactReceipt
   assetsDirectory: string | null
   warnings: string[]
@@ -1320,6 +1337,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}; ${
@@ -1436,12 +1465,248 @@ class CloudBridge implements WsBridge {
   close(): void {}
 }
 
+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 new CloudBridge(session)
+  return session.service === 'box'
+    ? new CloudBoxBridge(session)
+    : new CloudBridge(session)
+}
+
+// stops the box, which ends the simulator it holds. an account api key stops
+// with its own authority; a session login stops with the login, falling back
+// to the box token the session already holds.
+export async function closeCloudBox(session: CloudSession): Promise<void> {
+  if (session.service !== 'box') {
+    if (!session.boxId || !session.boxToken) return
+    const response = await fetch(
+      `${session.apiOrigin}/v1/boxes/${encodeURIComponent(session.boxId)}`,
+      {
+        method: 'DELETE',
+        headers: { authorization: `Bearer ${session.boxToken}` },
+      },
+    )
+    const text = await response.text()
+    if (!response.ok && response.status !== 404) {
+      throw responseError(response.status, text)
+    }
+    return
+  }
+  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)
+      }`,
+    )
+  }
+  const text = await response.text()
+  if (!response.ok && response.status !== 404) {
+    throw responseError(response.status, text)
+  }
+}
+
+export interface BoxDisplayGrant {
+  url: string
+  authToken: string
+  expectedPeer: unknown
+}
+
+// how long `rnx remote` waits for a fresh box's page to attach its simulator
+// before giving up on the watch url. the page boots the bundle after the
+// browser is up, and a large bundle takes a while to parse.
+const BOX_DISPLAY_GRANT_WAIT_MS = 180_000
+const BOX_DISPLAY_GRANT_RETRY_MS = 2_000
+
+function readBoxDisplayGrant(value: unknown): BoxDisplayGrant {
+  if (!isRecord(value) || !isRecord(value.grant)) {
+    throw new Error('box display-grant returned an invalid grant')
+  }
+  const grant = value.grant
+  if (
+    typeof grant.url !== 'string' ||
+    !grant.url ||
+    typeof grant.authToken !== 'string' ||
+    !grant.authToken ||
+    !isRecord(grant.expectedPeer)
+  ) {
+    throw new Error('box display-grant returned an invalid grant')
+  }
+  return { url: grant.url, authToken: grant.authToken, expectedPeer: grant.expectedPeer }
+}
+
+// mints a watch-only display grant from the box and builds the bare shell
+// watch url for it: the same /sootsim/#remoteEngine fragment the nano service
+// mints, pointed at the box's display socket instead. the box token stays in
+// this process; only the grant travels in the fragment.
+export async function requestBoxWatchUrl(options: {
+  apiOrigin: string
+  boxId: string
+  boxToken: string
+}): Promise<string> {
+  const started = Date.now()
+  for (;;) {
+    let response: Response
+    try {
+      response = await fetch(
+        `${options.apiOrigin}/v1/boxes/${encodeURIComponent(options.boxId)}/display-grant`,
+        {
+          method: 'POST',
+          headers: {
+            authorization: `Bearer ${options.boxToken}`,
+            'content-type': 'application/json',
+          },
+          body: '{}',
+        },
+      )
+    } catch (error) {
+      throw new Error(
+        `could not reach box ${options.boxId} at ${options.apiOrigin}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      )
+    }
+    if (response.status === 409) {
+      // the page has not attached its simulator yet. this is the normal state
+      // right after a create, so wait rather than refusing.
+      if (Date.now() - started >= BOX_DISPLAY_GRANT_WAIT_MS) {
+        throw new Error(
+          `box ${options.boxId} has no simulator hosting it yet; try again once its page has booted`,
+        )
+      }
+      await new Promise((resolve) => setTimeout(resolve, BOX_DISPLAY_GRANT_RETRY_MS))
+      continue
+    }
+    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 display-grant returned unreadable JSON')
+    }
+    const grant = readBoxDisplayGrant(parsed)
+    const watch = new URL('/sootsim/', rnxPublicBrand.origin)
+    // the shell boots its stage at its own default device, while the box page
+    // hosts its simulator at the grant's device profile. without ?device= the
+    // tenant refuses the host hello on dimensions and paints nothing — the
+    // same param SimPage and BoxHostPage already set on their stage urls.
+    if (
+      isRecord(grant.expectedPeer) &&
+      typeof grant.expectedPeer.deviceProfile === 'string' &&
+      grant.expectedPeer.deviceProfile
+    ) {
+      watch.searchParams.set('device', grant.expectedPeer.deviceProfile)
+    }
+    watch.hash = `remoteEngine=${encodeURIComponent(
+      JSON.stringify({
+        url: grant.url,
+        authToken: grant.authToken,
+        expectedPeer: grant.expectedPeer,
+      }),
+    )}`
+    return watch.toString()
+  }
 }
 
 function readClaimResponse(value: unknown): { id: string; expiresAt: number } {
@@ -1516,6 +1781,8 @@ export async function closeCloudSession(session: CloudSession): Promise<void> {
     }
     return
   }
+  // box sessions close through closeCloudBox; only sim sessions reach this leg.
+  if (session.service !== 'sim') return
   const response = await fetch(
     `${session.apiOrigin}/v1/sims/${encodeURIComponent(session.simId)}`,
     {

package/cli/cloud-dispatch.ts

@@ -157,9 +157,14 @@ export async function dispatchCloudBoundary({
     }
     try {
       const descriptor = cloudSession.requireCloudSessionShellUpdate()
-      await cloudClient.closeCloudSession(session)
+      if (session.service === 'box') await cloudClient.closeCloudBox(session)
+      else await cloudClient.closeCloudSession(session)
       cloudSession.publishCloudSessionToShell(null, descriptor)
-      console.log(`  closed: remote simulator ${session.simId}`)
+      console.log(
+        session.service === 'box'
+          ? `  closed: remote box ${session.boxId}`
+          : `  closed: remote simulator ${session.simId}`,
+      )
       return { handled: true, code: 0 }
     } catch (error) {
       console.error(
@@ -169,6 +174,21 @@ export async function dispatchCloudBoundary({
     }
   }
 
+  // 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. claim is specific
+  // to nano.
+  if (session.service === 'box') {
+    if (command === 'claim') {
+      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

@@ -10,9 +10,10 @@ 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 remote target: one simulator on the instance API, addressed by
-// its own id and token.
-export type CloudSession = CloudSimSession
+// 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
 
 export type RemotePlatform = 'ios' | 'android'
 
@@ -43,6 +44,23 @@ export interface CloudSimSession {
   boxToken?: 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
+  platform?: RemotePlatform
+  device?: string
+  artifact?: CloudSessionArtifactIdentity
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
@@ -106,8 +124,35 @@ export function createCloudSession(input: {
   return session
 }
 
+export function createCloudBoxSession(input: {
+  boxId: string
+  boxToken: string
+  apiOrigin: string
+  platform?: RemotePlatform
+  device?: string
+  artifact?: CloudSessionArtifactIdentity
+}): CloudBoxSession {
+  const session: CloudBoxSession = {
+    version: CLOUD_SESSION_VERSION,
+    service: 'box',
+    boxId: input.boxId.trim(),
+    boxToken: input.boxToken,
+    apiOrigin: normalizeCloudOrigin(input.apiOrigin.trim()),
+    ...(input.platform ? { platform: input.platform } : {}),
+    ...(input.device?.trim() ? { device: input.device.trim() } : {}),
+    ...(input.artifact ? { artifact: input.artifact } : {}),
+  }
+  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 {
-  const validated = createCloudSession(session)
+  const validated =
+    session.service === 'box'
+      ? createCloudBoxSession(session)
+      : createCloudSession(session)
   return Buffer.from(JSON.stringify(validated), 'utf8').toString('base64url')
 }
 
@@ -154,6 +199,17 @@ export function parseCloudSession(encoded: string): CloudSession {
   const boxId = typeof parsed.boxId === 'string' ? parsed.boxId : undefined
   const boxToken = typeof parsed.boxToken === 'string' ? parsed.boxToken : undefined
   try {
+    if (parsed.service === 'box') {
+      if (!boxId || !boxToken) throw new Error('unreadable cloud box session')
+      return createCloudBoxSession({
+        boxId,
+        boxToken,
+        apiOrigin,
+        platform,
+        device,
+        artifact,
+      })
+    }
     const simId = parsed.simId
     const claimId = parsed.claimId
     const token = parsed.token