rnxsim 0.1.416 → 0.1.418

package/cli/cloud-client.ts

@@ -1,19 +1,27 @@
 import { createHash, randomUUID } from 'node:crypto'
-import { closeSync, fstatSync, openSync, readFileSync } from 'node:fs'
+import { closeSync, fstatSync, openSync, readdirSync, readFileSync } from 'node:fs'
 import { dirname, extname, join, resolve } from 'node:path'
 import {
   embedMetroAssetFiles,
-  type MetroAssetVariant,
+  metroAssetScaleFilename,
+  metroIosAssetDestRelatives,
+  resolveMetroIosAssetDestFile,
 } from '../../contrast-bundler/src/metroAssetArtifact'
 import {
   buildRnxCloudArtifact,
   type RnxCloudArtifactReceipt,
 } from '../../contrast-bundler/src/metroCloudArtifact'
+import { inferMetroModuleIdentity } from '../../sootsim-engine/src/metro-fingerprint'
+import { loadMetroFingerprintRegistry } from '../../sootsim-engine/src/metro-fingerprint-registry-client'
 import {
   isRnxCloudCommandType,
   RNX_CLOUD_MAX_ARTIFACT_BYTES,
   type RnxCloudBoxCreateReceipt,
 } from '../src/cloud-contract'
+import {
+  RNX_METRO_MODULE_IDENTITY_VERSION,
+  type RNXMetroModuleIdentityMetadata,
+} from '../src/metro-production-bundle'
 import { rnxPublicBrand } from '../src/public-brand'
 import {
   createCloudSession,
@@ -74,16 +82,16 @@ function resolveCloudOrigin(value?: string): string {
 function readImmutableBundleSource(bundlePath: string): string {
   const filepath = resolve(bundlePath)
   if (extname(filepath) !== '.js') {
-    throw new Error('rnx ios --cloud requires one local Metro .js bundle')
+    throw new Error('rnx ios --nano 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')
+      throw new Error('rnx ios --nano bundle must be a regular local file')
     }
     if (before.size <= 0n) {
-      throw new Error('rnx ios --cloud bundle is empty')
+      throw new Error('rnx ios --nano bundle is empty')
     }
     const bytes = readFileSync(descriptor)
     const after = fstatSync(descriptor, { bigint: true })
@@ -94,16 +102,16 @@ function readImmutableBundleSource(bundlePath: string): string {
       before.mtimeNs !== after.mtimeNs ||
       bytes.length !== Number(before.size)
     ) {
-      throw new Error('rnx ios --cloud bundle changed while it was being read')
+      throw new Error('rnx ios --nano 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')
+      throw new Error('rnx ios --nano 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')
+      throw new Error('rnx ios --nano requires a Metro JavaScript bundle')
     }
     return source
   } finally {
@@ -111,46 +119,110 @@ function readImmutableBundleSource(bundlePath: string): string {
   }
 }
 
-// `react-native bundle --assets-dest <dir>` and `expo export:embed` write every
-// scale variant with getAssetDestPathIOS: the descriptor's httpServerLocation
-// without its leading slash, each `../` collapsed to `_`, then the asset name
-// with its scale suffix. reading that layout is what lets an ordinary Metro
-// build reach the cloud with no per-app script.
-function metroAssetDestPath(assetsPath: string, variant: MetroAssetVariant): string {
-  const { descriptor, scale } = variant
-  const suffix = scale === 1 ? '' : `@${scale}x`
-  return join(
-    assetsPath,
-    descriptor.httpServerLocation.slice(1).replace(/\.\.\//g, '_'),
-    `${descriptor.name}${suffix}.${descriptor.type}`,
-  )
+// `react-native bundle --assets-dest` dest paths are not always the JS
+// descriptor's httpServerLocation with `../` replaced by `_`. Metro 0.83 does
+// that (`__node_modules`); Metro 0.84 often dests `node_modules` and keeps the
+// project-root-relative app path. resolveMetroIosAssetDestFile matches both.
+function listMetroAssetDestFiles(assetsPath: string): string[] {
+  const files: string[] = []
+  const walk = (dir: string, prefix: string) => {
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+      if (entry.isDirectory()) walk(join(dir, entry.name), rel)
+      else if (entry.isFile()) files.push(rel)
+    }
+  }
+  walk(assetsPath, '')
+  return files
+}
+
+async function inferCloudModuleIdentity(
+  source: string,
+): Promise<RNXMetroModuleIdentityMetadata> {
+  let receipt
+  try {
+    receipt = await loadMetroFingerprintRegistry()
+  } catch (error) {
+    throw new Error(
+      `rnx Cloud could not load the Metro fingerprint registry needed to identify this bundle: ${
+        error instanceof Error ? error.message : String(error)
+      }. Build it through the published Metro plugin: withRNX(config, { productionBundles: true }) for the production graph, or withRNX(config, { developmentBundles: true }) for the development graph.`,
+    )
+  }
+  try {
+    const inferred = await inferMetroModuleIdentity({
+      source,
+      registry: receipt.registry,
+      registryIntegrity: receipt.integrity,
+    })
+    return {
+      version: RNX_METRO_MODULE_IDENTITY_VERSION,
+      identitySource: 'contrast-bundler',
+      modulePaths: inferred.modulePaths,
+      logicalSpecifiers: {},
+    }
+  } catch (error) {
+    throw new Error(
+      `rnx Cloud could not infer module identity for this Metro bundle: ${
+        error instanceof Error ? error.message : String(error)
+      }. Build it through the published Metro plugin: withRNX(config, { productionBundles: true }) for the production graph, or withRNX(config, { developmentBundles: true }) for the development graph.`,
+    )
+  }
 }
 
 /**
  * turns the Metro production bundle a caller built into the immutable artifact
  * the runner executes: every asset scale is read from the asset graph and
  * embedded, module identity is normalized, and the JavaScript is minified.
+ * an ordinary unannotated Metro production bundle is identified through the
+ * published fingerprint registry; a withRNX footer remains the fast path.
  */
 async function produceCloudArtifact(
   bundlePath: string,
   assetsPath: string,
 ): Promise<{ bytes: Buffer; sha256: string; receipt: RnxCloudArtifactReceipt }> {
   const source = readImmutableBundleSource(bundlePath)
+  const destFiles = listMetroAssetDestFiles(assetsPath)
   const embedded = await embedMetroAssetFiles(source, async (variant) => {
-    const file = metroAssetDestPath(assetsPath, variant)
-    try {
-      return readFileSync(file)
-    } catch {
-      throw new Error(
-        `rnx ios --cloud could not read ${file} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}. Build the bundle with --assets-dest, or pass --assets <dir>.`,
-      )
-    }
+    const relative = resolveMetroIosAssetDestFile(
+      destFiles,
+      variant.descriptor,
+      variant.scale,
+    )
+    if (relative) return readFileSync(join(assetsPath, relative))
+    // iOS copies only @1x..@3x, so a declared scale with no file is ordinary
+    // and the producer narrows the descriptor. an asset with no file at any
+    // scale is the real failure, and this is where the dest path a customer
+    // should look for is still known.
+    const written = variant.descriptor.scales.some((scale) =>
+      resolveMetroIosAssetDestFile(destFiles, variant.descriptor, scale),
+    )
+    if (written) return null
+    const filename = metroAssetScaleFilename(
+      variant.descriptor.name,
+      variant.descriptor.type,
+      variant.scale,
+    )
+    const classic =
+      metroIosAssetDestRelatives(variant.descriptor.httpServerLocation, filename)[0] ??
+      filename
+    throw new Error(
+      `rnx ios --nano could not read ${join(assetsPath, classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}. Build the bundle with --assets-dest, or pass --assets <dir>.`,
+    )
+  })
+  const artifact = await buildRnxCloudArtifact(embedded.code, {
+    inferModuleIdentity: inferCloudModuleIdentity,
   })
-  const artifact = await buildRnxCloudArtifact(embedded.code)
   const bytes = Buffer.from(artifact.code, 'utf8')
   if (bytes.length > MAX_RNX_CLOUD_BUNDLE_BYTES) {
     throw new Error(
-      `rnx ios --cloud artifact is ${bytes.length} bytes and exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit`,
+      `rnx ios --nano artifact is ${bytes.length} bytes and exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit`,
     )
   }
   return {
@@ -219,7 +291,7 @@ function readCreateResponse(
   }
 }
 
-// `rnx ios --cloud <bundle>` creates a nano box around the artifact with its
+// `rnx ios --nano <bundle>` creates a nano box around the artifact with its
 // first simulator in one request, and the shell then targets that box
 export async function createCloudBox(options: CreateCloudBoxOptions): Promise<{
   receipt: RnxCloudBoxCreateReceipt

package/cli/cloud-dispatch.ts

@@ -38,6 +38,39 @@ function firstVerb(positional: string[]): string | null {
   return positional.find((value) => !value.startsWith('-')) ?? null
 }
 
+const CLOUD_DO_VERBS = new Set([
+  'tap',
+  'tap-id',
+  'tap-text',
+  'tap-best',
+  'double-tap',
+  'long-press',
+  'sleep',
+  'settle',
+])
+
+function doChainVerbs(positional: string[]): string[] {
+  const verbs: string[] = []
+  let expectingVerb = true
+  for (const argument of positional) {
+    if (argument === '--then') {
+      expectingVerb = true
+      continue
+    }
+    if (expectingVerb && !argument.startsWith('-')) {
+      verbs.push(argument)
+      expectingVerb = false
+    }
+  }
+  return verbs
+}
+
+function supportsCloudDo(positional: string[]): boolean {
+  const verbs = doChainVerbs(positional)
+  if (verbs.length === 0) return true
+  return verbs.every((verb) => CLOUD_DO_VERBS.has(verb))
+}
+
 function supportsCloudRead(
   command: string,
   args: string[],
@@ -77,7 +110,8 @@ function supportsCloudRead(
       ].includes(arg),
     )
   }
-  if (command === 'do' || command === 'reset') return true
+  if (command === 'do') return supportsCloudDo(positional)
+  if (command === 'reset') return true
   return false
 }
 
@@ -95,10 +129,10 @@ export async function dispatchCloudBoundary({
   command,
   args,
 }: CloudBoundaryInvocation): Promise<CloudBoundaryResult> {
-  if (command === 'ios' && args.includes('--cloud')) return { handled: false }
-  if (command === 'android' && args.includes('--cloud')) {
+  if (command === 'ios' && args.includes('--nano')) return { handled: false }
+  if (command === 'android' && args.includes('--nano')) {
     console.error(
-      '  rnx android --cloud is not available; RNX Cloud currently supports iOS',
+      '  rnx android --nano is not available; RNX Cloud currently supports iOS',
     )
     return { handled: true, code: 1 }
   }