rnxsim 0.1.381 → 0.1.383

package/cli/cloud-client.ts

@@ -0,0 +1,407 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { closeSync, fstatSync, openSync, readFileSync } from 'node:fs'
+import { extname, resolve } from 'node:path'
+import { assertSelfContainedMetroArtifactAssets } from '../../contrast-bundler/src/metroAssetArtifact'
+import {
+  RNX_CLOUD_MAX_ARTIFACT_BYTES,
+  type RnxCloudCreateReceipt,
+} from '../src/cloud-contract'
+import { rnxPublicBrand } from '../src/public-brand'
+import {
+  createCloudSession,
+  normalizeCloudOrigin,
+  readCloudSession,
+  type CloudSession,
+} from './cloud-session'
+import type {
+  BridgeClaimResult,
+  BridgeSimInfo,
+  ParsedBridgeCliArgs,
+  WsBridge,
+} from './ws-bridge'
+
+export const DEFAULT_RNX_CLOUD_ORIGIN = rnxPublicBrand.origin
+export const MAX_RNX_CLOUD_BUNDLE_BYTES = RNX_CLOUD_MAX_ARTIFACT_BYTES
+
+interface CreateCloudSimulatorOptions {
+  bundlePath: string
+  device: string
+  authorization: string
+  apiOrigin?: string
+}
+
+interface CloudCommandEnvelope {
+  id: string
+  claimId: string
+  command: Record<string, unknown>
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function responseError(status: number, text: string): Error {
+  if (text) {
+    try {
+      const parsed: unknown = JSON.parse(text)
+      const error = isRecord(parsed) ? parsed.error : null
+      if (isRecord(error) && typeof error.message === 'string') {
+        return new Error(`RNX Cloud request failed (${status}): ${error.message}`)
+      }
+    } catch {}
+  }
+  return new Error(
+    `RNX Cloud request failed (${status})${text.trim() ? `: ${text.trim()}` : ''}`,
+  )
+}
+
+function resolveCloudOrigin(value?: string): string {
+  const configured = value?.trim() || process.env.RNX_CLOUD_ORIGIN?.trim()
+  const source = configured || DEFAULT_RNX_CLOUD_ORIGIN
+  return normalizeCloudOrigin(source)
+}
+
+async function readImmutableBundle(
+  bundlePath: string,
+): Promise<{ bytes: Buffer; sha256: string }> {
+  const filepath = resolve(bundlePath)
+  if (extname(filepath) !== '.js') {
+    throw new Error('rnx ios --cloud requires one local Metro .js bundle')
+  }
+  const descriptor = openSync(filepath, 'r')
+  try {
+    const before = fstatSync(descriptor, { bigint: true })
+    if (!before.isFile()) {
+      throw new Error('rnx ios --cloud bundle must be a regular local file')
+    }
+    if (before.size <= 0n) {
+      throw new Error('rnx ios --cloud bundle is empty')
+    }
+    if (before.size > BigInt(MAX_RNX_CLOUD_BUNDLE_BYTES)) {
+      throw new Error(
+        `rnx ios --cloud bundle exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit`,
+      )
+    }
+    const bytes = readFileSync(descriptor)
+    const after = fstatSync(descriptor, { bigint: true })
+    if (
+      before.dev !== after.dev ||
+      before.ino !== after.ino ||
+      before.size !== after.size ||
+      before.mtimeNs !== after.mtimeNs ||
+      bytes.length !== Number(before.size)
+    ) {
+      throw new Error('rnx ios --cloud bundle changed while it was being read')
+    }
+    let source: string
+    try {
+      source = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+    } catch {
+      throw new Error('rnx ios --cloud bundle must be valid UTF-8 JavaScript')
+    }
+    if (source.includes('\0') || !source.includes('__d(') || !source.includes('__r(')) {
+      throw new Error('rnx ios --cloud requires a Metro JavaScript bundle')
+    }
+    await assertSelfContainedMetroArtifactAssets(source)
+    return {
+      bytes,
+      sha256: createHash('sha256').update(bytes).digest('hex'),
+    }
+  } finally {
+    closeSync(descriptor)
+  }
+}
+
+function readCreateResponse(
+  value: unknown,
+  expectedBytes: number,
+  expectedSha256: string,
+): {
+  receipt: RnxCloudCreateReceipt
+  token: string
+} {
+  if (!isRecord(value)) throw new Error('RNX Cloud create returned invalid JSON')
+  const simId = value.simId
+  const artifact = value.artifact
+  const claim = value.claim
+  const token = value.token
+  if (
+    typeof simId !== 'string' ||
+    !simId ||
+    !isRecord(artifact) ||
+    typeof artifact.id !== 'string' ||
+    artifact.id !== `sha256:${expectedSha256}` ||
+    typeof artifact.bytes !== 'number' ||
+    !Number.isInteger(artifact.bytes) ||
+    artifact.bytes !== expectedBytes ||
+    !isRecord(claim) ||
+    typeof claim.id !== 'string' ||
+    !claim.id ||
+    typeof claim.expiresAt !== 'number' ||
+    typeof token !== 'string' ||
+    !token
+  ) {
+    throw new Error('RNX Cloud create returned an invalid simulator receipt')
+  }
+  return {
+    receipt: {
+      simId,
+      artifact: { id: `sha256:${expectedSha256}`, bytes: artifact.bytes },
+      claim: { id: claim.id, expiresAt: claim.expiresAt },
+    },
+    token,
+  }
+}
+
+export async function createCloudSimulator(
+  options: CreateCloudSimulatorOptions,
+): Promise<{ receipt: RnxCloudCreateReceipt; session: CloudSession }> {
+  const apiOrigin = resolveCloudOrigin(options.apiOrigin)
+  const artifact = await readImmutableBundle(options.bundlePath)
+  let response: Response
+  try {
+    response = await fetch(`${apiOrigin}/v1/sims`, {
+      method: 'POST',
+      headers: {
+        authorization: options.authorization,
+        'content-type': 'application/javascript',
+        'x-rnx-artifact-sha256': artifact.sha256,
+        'x-rnx-platform': 'ios',
+        'x-rnx-device': options.device,
+      },
+      body: new Uint8Array(artifact.bytes),
+    })
+  } catch (error) {
+    throw new Error(
+      `could not reach RNX Cloud at ${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('RNX Cloud create returned unreadable JSON')
+  }
+  const created = readCreateResponse(parsed, artifact.bytes.length, artifact.sha256)
+  const session = createCloudSession({
+    simId: created.receipt.simId,
+    apiOrigin,
+    claimId: created.receipt.claim.id,
+    token: created.token,
+  })
+  return { receipt: created.receipt, session }
+}
+
+export function resolveCloudSessionForParsed(
+  parsed: Pick<ParsedBridgeCliArgs, 'simId' | 'simIdSource'>,
+): CloudSession | null {
+  const session = readCloudSession()
+  if (!session) return null
+  if (parsed.simIdSource === 'flag' && parsed.simId !== session.simId) {
+    throw new Error(
+      `this shell is connected to RNX Cloud simulator ${session.simId}; ${
+        parsed.simId ? `--sim ${parsed.simId}` : 'the requested simulator'
+      } is not available in this shell`,
+    )
+  }
+  return session
+}
+
+function cloudCommand(command: {
+  type: string
+  [key: string]: unknown
+}): Record<string, unknown> {
+  const clean: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(command)) {
+    if (key !== 'id' && key !== 'simId') clean[key] = value
+  }
+  if (command.type === 'query') {
+    const query = command.query
+    if (
+      !isRecord(query) ||
+      (query.kind !== 'tree' && query.kind !== 'find' && query.kind !== 'count')
+    ) {
+      throw new Error('RNX Cloud supports only structured tree, node, and count queries')
+    }
+    return clean
+  }
+  if (command.type === 'waitFor') {
+    const options = command.waitForOptions
+    const condition = isRecord(options) ? options.condition : null
+    if (
+      !isRecord(condition) ||
+      (condition.type !== 'ready' &&
+        condition.type !== 'present' &&
+        condition.type !== 'absent')
+    ) {
+      throw new Error('RNX Cloud supports only ready and selector waits')
+    }
+    return clean
+  }
+  if (command.type === 'state') return clean
+  if (command.type === 'capture' || command.type === 'captureRegions') return clean
+  if (command.type === 'setAppearance' || command.type === 'openUrl') return clean
+  if (
+    command.type === 'screenshot' &&
+    command.crop === undefined &&
+    command.captureFilter === undefined &&
+    (command.layers === undefined || command.layers === 'tenant')
+  ) {
+    return clean
+  }
+  throw new Error(`RNX Cloud does not support bridge command type ${command.type}`)
+}
+
+class CloudBridge implements WsBridge {
+  readonly plane = 'cloud' as const
+
+  constructor(private readonly session: CloudSession) {}
+
+  async send(
+    command: { type: string; [key: string]: unknown },
+    options?: { timeoutMs?: number },
+  ): Promise<unknown> {
+    const body: CloudCommandEnvelope = {
+      id: randomUUID(),
+      claimId: this.session.claimId,
+      command: cloudCommand(command),
+    }
+    let response: Response
+    try {
+      response = await fetch(
+        `${this.session.apiOrigin}/v1/sims/${encodeURIComponent(this.session.simId)}/commands`,
+        {
+          method: 'POST',
+          headers: {
+            authorization: `Bearer ${this.session.token}`,
+            'content-type': 'application/json',
+          },
+          body: JSON.stringify(body),
+          ...(options?.timeoutMs
+            ? { signal: AbortSignal.timeout(options.timeoutMs) }
+            : {}),
+        },
+      )
+    } catch (error) {
+      throw new Error(
+        `could not reach RNX Cloud 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('RNX Cloud command returned unreadable JSON')
+    }
+    if (!isRecord(parsed) || parsed.id !== body.id) {
+      throw new Error('RNX Cloud 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('RNX Cloud command receipt has no result')
+    }
+    return parsed.result
+  }
+
+  listSims(): Promise<BridgeSimInfo[]> {
+    return Promise.reject(new Error('RNX Cloud does not expose a local simulator list'))
+  }
+
+  focusSim(): Promise<never> {
+    return Promise.reject(
+      new Error('RNX Cloud simulators have no browser window to focus'),
+    )
+  }
+
+  closeSim(): Promise<never> {
+    return Promise.reject(new Error('RNX Cloud close uses the simulator DELETE route'))
+  }
+
+  claim(): Promise<BridgeClaimResult> {
+    return Promise.reject(new Error('RNX Cloud claim uses the simulator claim route'))
+  }
+
+  close(): void {}
+}
+
+export function createCloudBridgeForParsed(parsed: ParsedBridgeCliArgs): WsBridge | null {
+  const session = resolveCloudSessionForParsed(parsed)
+  return session ? new CloudBridge(session) : null
+}
+
+function readClaimResponse(value: unknown): { id: string; expiresAt: number } {
+  const claim = isRecord(value) ? value.claim : null
+  if (
+    !isRecord(claim) ||
+    typeof claim.id !== 'string' ||
+    !claim.id ||
+    typeof claim.expiresAt !== 'number'
+  ) {
+    throw new Error('RNX Cloud claim returned an invalid receipt')
+  }
+  return { id: claim.id, expiresAt: claim.expiresAt }
+}
+
+export async function claimCloudSimulator(
+  session: CloudSession,
+  options: { force?: boolean } = {},
+): Promise<{
+  claim: { id: string; expiresAt: number }
+  session: CloudSession
+}> {
+  const response = await fetch(
+    `${session.apiOrigin}/v1/sims/${encodeURIComponent(session.simId)}/claim`,
+    {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${session.token}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(
+        options.force ? { force: true } : { claimId: session.claimId },
+      ),
+    },
+  )
+  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('RNX Cloud claim returned unreadable JSON')
+  }
+  const claim = readClaimResponse(parsed)
+  return {
+    claim,
+    session: createCloudSession({ ...session, claimId: claim.id }),
+  }
+}
+
+export async function confirmCloudSimulator(session: CloudSession): Promise<void> {
+  const confirmed = await claimCloudSimulator(session)
+  if (confirmed.session.claimId !== session.claimId) {
+    throw new Error('RNX Cloud confirmation replaced the initial claim')
+  }
+}
+
+export async function closeCloudSimulator(session: CloudSession): Promise<void> {
+  const response = await fetch(
+    `${session.apiOrigin}/v1/sims/${encodeURIComponent(session.simId)}`,
+    {
+      method: 'DELETE',
+      headers: { authorization: `Bearer ${session.token}` },
+    },
+  )
+  const text = await response.text()
+  if (!response.ok && response.status !== 404) {
+    throw responseError(response.status, text)
+  }
+}

package/cli/cloud-dispatch.ts

@@ -0,0 +1,165 @@
+interface CloudBoundaryInvocation {
+  command: string
+  args: string[]
+}
+
+export type CloudBoundaryResult = { handled: false } | { handled: true; code: number }
+
+const CLOUD_TARGET_COMMANDS = new Set([
+  'assert',
+  'camera',
+  'claim',
+  'close',
+  'debug',
+  'describe',
+  'detox',
+  'do',
+  'film',
+  'find',
+  'get',
+  'logs',
+  'maestro',
+  'mode',
+  'network',
+  'perf',
+  'permissions',
+  'record',
+  'reset',
+  'screenshot',
+  'shell',
+  'state',
+  'storage',
+  'timeline',
+  'wait',
+  'what-happened',
+])
+
+function firstVerb(positional: string[]): string | null {
+  return positional.find((value) => !value.startsWith('-')) ?? null
+}
+
+function supportsCloudRead(
+  command: string,
+  args: string[],
+  positional: string[],
+): boolean {
+  if (command === 'describe' || command === 'find') return true
+  if (command === 'state') return firstVerb(positional) === null
+  if (command === 'get') {
+    const verb = firstVerb(positional)
+    return verb === 'tree' || verb === 'node' || verb === 'count'
+  }
+  if (command === 'wait') {
+    const verb = firstVerb(positional)
+    return verb === 'ready' || verb === 'selector'
+  }
+  if (command === 'logs') {
+    const verb = firstVerb(positional)
+    return (
+      !args.includes('--tail') &&
+      !args.includes('-f') &&
+      verb !== 'tail' &&
+      verb !== 'clear' &&
+      verb !== 'purge'
+    )
+  }
+  if (command === 'screenshot') {
+    return !args.some((arg) =>
+      [
+        '--area',
+        '--gallery',
+        '--id',
+        '--no-shell',
+        '--shell-only',
+        '--text',
+        '--themes',
+        '--with-frame',
+      ].includes(arg),
+    )
+  }
+  return false
+}
+
+function refuseCloudInvocation(
+  command: string,
+  positional: string[],
+): CloudBoundaryResult {
+  const verb = firstVerb(positional)
+  const name = verb ? `${command} ${verb}` : command
+  console.error(`  rnx ${name} is not available for an RNX Cloud simulator`)
+  return { handled: true, code: 1 }
+}
+
+export async function dispatchCloudBoundary({
+  command,
+  args,
+}: CloudBoundaryInvocation): Promise<CloudBoundaryResult> {
+  if (command === 'ios' && args.includes('--cloud')) return { handled: false }
+  if (command === 'android' && args.includes('--cloud')) {
+    console.error(
+      '  rnx android --cloud is not available; RNX Cloud currently supports iOS',
+    )
+    return { handled: true, code: 1 }
+  }
+  if (!CLOUD_TARGET_COMMANDS.has(command)) return { handled: false }
+
+  const [{ parseBridgeCliArgs }, cloudClient, cloudSession] = await Promise.all([
+    import('./ws-bridge'),
+    import('./cloud-client'),
+    import('./cloud-session'),
+  ])
+  const parsed = parseBridgeCliArgs(args)
+  const positionalTarget =
+    command === 'claim' || command === 'close' ? firstVerb(parsed.positional) : null
+  const target: Pick<typeof parsed, 'simId' | 'simIdSource'> = positionalTarget
+    ? { simId: positionalTarget, simIdSource: 'flag' }
+    : parsed
+  let session
+  try {
+    session = cloudClient.resolveCloudSessionForParsed(target)
+  } catch (error) {
+    console.error(`  ${error instanceof Error ? error.message : String(error)}`)
+    return { handled: true, code: 1 }
+  }
+  if (!session) return { handled: false }
+
+  if (command === 'claim') {
+    try {
+      const descriptor = cloudSession.requireCloudSessionShellUpdate()
+      const claimed = await cloudClient.claimCloudSimulator(session, {
+        force: args.includes('--force'),
+      })
+      cloudSession.publishCloudSessionToShell(claimed.session, descriptor)
+      console.log(`  claimed: ${session.simId}`)
+      console.log(`  expires: ${claimed.claim.expiresAt}`)
+      return { handled: true, code: 0 }
+    } catch (error) {
+      console.error(
+        `  claim failed: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      return { handled: true, code: 1 }
+    }
+  }
+
+  if (command === 'close') {
+    if (args.includes('--all') || args.includes('--others')) {
+      return refuseCloudInvocation(command, parsed.positional)
+    }
+    try {
+      const descriptor = cloudSession.requireCloudSessionShellUpdate()
+      await cloudClient.closeCloudSimulator(session)
+      cloudSession.publishCloudSessionToShell(null, descriptor)
+      console.log(`  closed: ${session.simId}`)
+      return { handled: true, code: 0 }
+    } catch (error) {
+      console.error(
+        `  close failed: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      return { handled: true, code: 1 }
+    }
+  }
+
+  return supportsCloudRead(command, args, parsed.positional)
+    ? { handled: false }
+    : refuseCloudInvocation(command, parsed.positional)
+}