rnxsim 0.1.380 → 0.1.382

package/cli/cli-update.ts

@@ -0,0 +1,261 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { compareSemver } from '@contrast/runtime-delivery'
+import { getCliVersion } from '../src/cli-version'
+import { cliUpdateFilePath } from '../src/home-paths'
+import { isAgentEnv } from './commands/inspect/env'
+
+export const DEFAULT_CLI_RELEASE_ORIGIN = 'https://r2.rnxsim.com/rnx-cli'
+export const CLI_UPDATE_CHECK_INTERVAL_MS = 20 * 60 * 60 * 1000
+export const CLI_UPDATE_NOTIFICATION_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000
+
+const CLI_UPDATE_STATE_SCHEMA = 1 as const
+const CLI_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/
+let stateWriteSequence = 0
+
+interface CliUpdateState {
+  schema: typeof CLI_UPDATE_STATE_SCHEMA
+  latestVersion: string | null
+  checkedAt: number
+  lastAttemptAt: number
+  lastNotifiedVersion: string | null
+  lastNotifiedAt: number
+}
+
+export interface CliUpdateAvailability {
+  currentVersion: string
+  latestVersion: string
+  outdated: boolean
+}
+
+export interface CliUpdateInvocation {
+  command: string | null
+  commandArgs: readonly string[]
+  exitCode: number
+  standalone: boolean
+  stderrIsTTY: boolean
+  stdoutIsTTY: boolean
+  version: boolean
+  env?: Readonly<Record<string, string | undefined>>
+}
+
+function emptyState(): CliUpdateState {
+  return {
+    schema: CLI_UPDATE_STATE_SCHEMA,
+    latestVersion: null,
+    checkedAt: 0,
+    lastAttemptAt: 0,
+    lastNotifiedVersion: null,
+    lastNotifiedAt: 0,
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object'
+}
+
+function isTimestamp(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+}
+
+function readState(): CliUpdateState {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(cliUpdateFilePath(), 'utf8'))
+    if (
+      !isRecord(parsed) ||
+      parsed.schema !== CLI_UPDATE_STATE_SCHEMA ||
+      (parsed.latestVersion !== null &&
+        (typeof parsed.latestVersion !== 'string' ||
+          !CLI_VERSION_PATTERN.test(parsed.latestVersion))) ||
+      !isTimestamp(parsed.checkedAt) ||
+      !isTimestamp(parsed.lastAttemptAt) ||
+      (parsed.lastNotifiedVersion !== null &&
+        (typeof parsed.lastNotifiedVersion !== 'string' ||
+          !CLI_VERSION_PATTERN.test(parsed.lastNotifiedVersion))) ||
+      !isTimestamp(parsed.lastNotifiedAt)
+    ) {
+      return emptyState()
+    }
+    return {
+      schema: CLI_UPDATE_STATE_SCHEMA,
+      latestVersion: parsed.latestVersion,
+      checkedAt: parsed.checkedAt,
+      lastAttemptAt: parsed.lastAttemptAt,
+      lastNotifiedVersion: parsed.lastNotifiedVersion,
+      lastNotifiedAt: parsed.lastNotifiedAt,
+    }
+  } catch {
+    return emptyState()
+  }
+}
+
+function writeState(state: CliUpdateState): boolean {
+  const file = cliUpdateFilePath()
+  const temporary = `${file}.tmp-${process.pid}-${stateWriteSequence++}`
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(temporary, `${JSON.stringify(state)}\n`, 'utf8')
+    fs.renameSync(temporary, file)
+    return true
+  } catch {
+    try {
+      fs.rmSync(temporary, { force: true })
+    } catch {}
+    return false
+  }
+}
+
+function availability(
+  state: CliUpdateState,
+  currentVersion = getCliVersion(),
+): CliUpdateAvailability | null {
+  if (!state.latestVersion) return null
+  return {
+    currentVersion,
+    latestVersion: state.latestVersion,
+    outdated: compareSemver(state.latestVersion, currentVersion) > 0,
+  }
+}
+
+function envFlagIsOff(value: string | undefined): boolean {
+  return (
+    value === '0' || value?.toLowerCase() === 'false' || value?.toLowerCase() === 'off'
+  )
+}
+
+function envFlagIsOn(value: string | undefined): boolean {
+  return Boolean(value) && !envFlagIsOff(value)
+}
+
+export function automaticCliUpdateChecksEnabled(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): boolean {
+  return !envFlagIsOff(env.RNX_UPDATE_CHECK)
+}
+
+export function shouldUseAutomaticCliUpdateCheck(
+  invocation: CliUpdateInvocation,
+): boolean {
+  const env = invocation.env ?? process.env
+  if (
+    !invocation.standalone ||
+    invocation.exitCode !== 0 ||
+    invocation.version ||
+    !invocation.stdoutIsTTY ||
+    !invocation.stderrIsTTY ||
+    !automaticCliUpdateChecksEnabled(env) ||
+    envFlagIsOn(env.CI) ||
+    envFlagIsOn(env.GITHUB_ACTIONS) ||
+    envFlagIsOn(env.RNX_NO_PROMPT) ||
+    isAgentEnv(env) ||
+    invocation.commandArgs.includes('--json') ||
+    invocation.commandArgs.includes('--ci') ||
+    invocation.commandArgs.includes('--dry-run')
+  ) {
+    return false
+  }
+
+  return !['agent-wrapper', 'cleanup', 'daemon', 'serve', 'upgrade', 'version'].includes(
+    invocation.command ?? '',
+  )
+}
+
+export function claimAutomaticCliUpdateCheck(now = Date.now()): boolean {
+  const state = readState()
+  const lastCheck = Math.max(state.checkedAt, state.lastAttemptAt)
+  if (now >= lastCheck && now - lastCheck < CLI_UPDATE_CHECK_INTERVAL_MS) {
+    return false
+  }
+  return writeState({ ...state, lastAttemptAt: now })
+}
+
+export function readCachedCliUpdate(
+  currentVersion = getCliVersion(),
+): CliUpdateAvailability | null {
+  return availability(readState(), currentVersion)
+}
+
+export function takeCliUpdateNotification(
+  currentVersion = getCliVersion(),
+  now = Date.now(),
+): CliUpdateAvailability | null {
+  const state = readState()
+  const update = availability(state, currentVersion)
+  if (!update?.outdated || state.lastNotifiedVersion === update.latestVersion) return null
+  if (
+    now >= state.lastNotifiedAt &&
+    now - state.lastNotifiedAt < CLI_UPDATE_NOTIFICATION_COOLDOWN_MS
+  ) {
+    return null
+  }
+  if (
+    !writeState({
+      ...state,
+      lastNotifiedVersion: update.latestVersion,
+      lastNotifiedAt: now,
+    })
+  ) {
+    return null
+  }
+  return update
+}
+
+export async function fetchCliReleaseFile(
+  url: string,
+  timeoutMs: number,
+): Promise<Buffer> {
+  let response: Response
+  try {
+    response = await fetch(url, {
+      headers: { accept: 'application/octet-stream' },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+  } catch (error) {
+    throw new Error(
+      `could not reach the rnx update service: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  if (!response.ok) {
+    throw new Error(
+      `rnx update download failed: ${response.status} ${response.statusText}`,
+    )
+  }
+  return Buffer.from(await response.arrayBuffer())
+}
+
+export async function refreshCliUpdateCache(
+  options: { releaseOrigin?: string; now?: number; timeoutMs?: number } = {},
+): Promise<CliUpdateAvailability> {
+  const releaseOrigin = (options.releaseOrigin ?? DEFAULT_CLI_RELEASE_ORIGIN).replace(
+    /\/+$/,
+    '',
+  )
+  const latestVersion = (
+    await fetchCliReleaseFile(
+      `${releaseOrigin}/channels/stable`,
+      options.timeoutMs ?? 8_000,
+    )
+  )
+    .toString('utf8')
+    .trim()
+  if (!CLI_VERSION_PATTERN.test(latestVersion)) {
+    throw new Error(
+      `rnx update service returned an invalid version: ${latestVersion || '(empty)'}`,
+    )
+  }
+
+  const now = options.now ?? Date.now()
+  const state = readState()
+  const next: CliUpdateState = {
+    ...state,
+    latestVersion,
+    checkedAt: now,
+    lastAttemptAt: now,
+  }
+  writeState(next)
+  const update = availability(next)
+  if (!update) throw new Error('rnx update cache did not retain the latest version')
+  return update
+}

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)
+  }
+}