rnxsim 0.1.513 → 0.1.515

package/src/cloud.ts

@@ -14,6 +14,9 @@ import {
   isRnxCloudCommandType,
   RNX_CLOUD_COMMAND_TYPES,
   RNX_CLOUD_MAX_ARTIFACT_BYTES,
+  RNX_CLOUD_TOKEN_SCOPES,
+  rnxCloudCommandScope,
+  rnxCloudScopesAllowCommand,
   type RnxCloudBoxCreateReceipt,
   type RnxCloudClaim,
   type RnxCloudCreateReceipt,
@@ -26,6 +29,15 @@ export type { RnxCloudClaim, RnxCloudCreateReceipt, RnxScreenCapture }
 const DEFAULT_DEVICE = 'iphone-16'
 const DEFAULT_WAIT_READY_MS = 20_000
 
+// how many times a request goes back after a retryable refusal or a server
+// error. the sim service passes the account's own 429 bodies through, so the
+// code on the body is what decides: `rate_limited` carries a `retry-after`
+// and is worth waiting for, while `concurrency_limit` refuses until the
+// customer stops something and retrying only hammers a closed door.
+// `early_access` and 402 never change on retry either.
+const CLOUD_MAX_RETRIES = 2
+const CLOUD_NEVER_RETRY_CODES = new Set(['concurrency_limit', 'early_access'])
+
 export type RemoteCommand = {
   type: (typeof RNX_CLOUD_COMMAND_TYPES)[number]
   [key: string]: unknown
@@ -117,6 +129,86 @@ function responseError(status: number, text: string): Error {
   )
 }
 
+function readCloudErrorCode(text: string): string | null {
+  // the account api answers `{ error: 'code', message }` and the sim service
+  // `{ error: { code, message } }`; both reach this client, so both read.
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(text)
+  } catch {
+    return null
+  }
+  if (!isRecord(parsed)) return null
+  if (typeof parsed.error === 'string') return parsed.error
+  if (isRecord(parsed.error) && typeof parsed.error.code === 'string') {
+    return parsed.error.code
+  }
+  return null
+}
+
+function readRetryAfterMs(response: Response, text: string): number | null {
+  const header = response.headers.get('retry-after')
+  if (header !== null) {
+    const seconds = Number(header.trim())
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(text)
+  } catch {
+    return null
+  }
+  if (
+    isRecord(parsed) &&
+    typeof parsed.retryAfterMs === 'number' &&
+    Number.isFinite(parsed.retryAfterMs) &&
+    parsed.retryAfterMs >= 0
+  ) {
+    return parsed.retryAfterMs
+  }
+  return null
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+// one fetch with the cloud retry policy: `rate_limited` waits out its
+// `retry-after` and 5xx goes again at once, each at most twice, and nothing
+// else is retried. the body is buffered only on a retryable status, so every
+// other refusal reaches the caller on its original response.
+async function fetchWithCloudRetry(
+  url: string,
+  init: RequestInit,
+  options?: { timeoutMs?: number },
+): Promise<Response> {
+  let attempt = 0
+  for (;;) {
+    const response = await fetch(
+      url,
+      options?.timeoutMs === undefined
+        ? init
+        : { ...init, signal: AbortSignal.timeout(options.timeoutMs) },
+    )
+    if (response.ok) return response
+    const retryableStatus = response.status === 429 || response.status >= 500
+    if (!retryableStatus || attempt >= CLOUD_MAX_RETRIES) return response
+    const text = await response.text()
+    const code = readCloudErrorCode(text)
+    const retryable =
+      response.status >= 500
+        ? !(code !== null && CLOUD_NEVER_RETRY_CODES.has(code))
+        : code === 'rate_limited'
+    if (!retryable) {
+      return new Response(text, { status: response.status, headers: response.headers })
+    }
+    if (response.status === 429) {
+      await sleep(readRetryAfterMs(response, text) ?? 1000)
+    }
+    attempt += 1
+  }
+}
+
 function copyArrayBuffer(bytes: Uint8Array): ArrayBuffer {
   const copy = new ArrayBuffer(bytes.byteLength)
   new Uint8Array(copy).set(bytes)
@@ -249,6 +341,13 @@ function cloudCommand(command: { type: string; [key: string]: unknown }): Remote
   if (!isRnxCloudCommandType(command.type)) {
     throw new Error(`RNX Cloud does not support bridge command type ${command.type}`)
   }
+  // the customer sdk never carries debug: evaluate/call/close belong to the
+  // account api key caller. refusing here names the scope before a request.
+  if (!rnxCloudScopesAllowCommand(RNX_CLOUD_TOKEN_SCOPES, command.type)) {
+    throw new Error(
+      `RNX Cloud command ${command.type} requires the ${rnxCloudCommandScope(command.type)} scope`,
+    )
+  }
   return { ...clean, type: command.type }
 }
 
@@ -325,7 +424,7 @@ export class RemoteSimulator {
     }
     let response: Response
     try {
-      response = await fetch(
+      response = await fetchWithCloudRetry(
         `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}/commands`,
         {
           method: 'POST',
@@ -334,10 +433,8 @@ export class RemoteSimulator {
             'content-type': 'application/json',
           },
           body: JSON.stringify(body),
-          ...(options?.timeoutMs
-            ? { signal: AbortSignal.timeout(options.timeoutMs) }
-            : {}),
         },
+        options?.timeoutMs === undefined ? undefined : { timeoutMs: options.timeoutMs },
       )
     } catch (error) {
       throw new Error(
@@ -365,7 +462,7 @@ export class RemoteSimulator {
   }
 
   async confirm(): Promise<RnxCloudClaim> {
-    const response = await fetch(
+    const response = await fetchWithCloudRetry(
       `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}/claim`,
       {
         method: 'POST',
@@ -393,7 +490,7 @@ export class RemoteSimulator {
   }
 
   async close(): Promise<void> {
-    const response = await fetch(
+    const response = await fetchWithCloudRetry(
       `${this.session.origin}/v1/boxes/${encodeURIComponent(this.session.boxId)}`,
       {
         method: 'DELETE',
@@ -427,7 +524,7 @@ export async function createRemoteSimulator(
   const device = input.device?.trim() || DEFAULT_DEVICE
   let response: Response
   try {
-    response = await fetch(`${origin}/v1/boxes`, {
+    response = await fetchWithCloudRetry(`${origin}/v1/boxes`, {
       method: 'POST',
       headers: {
         authorization: input.authorization,