peachsim 0.1.1625 → 0.1.1640

package/cli/bridge-flow-runner.ts

@@ -2175,48 +2175,58 @@ export class SootSimBridgeFlowRunner {
     await sleep(120)
   }
 
+  // maestro's android driver sends Back. its ios driver never presses a key:
+  // while the keyboard shows it swipes from the screen center up 3%, then
+  // left 3%, and the app's own handling of those touches dismisses it, or
+  // presses whatever sits under the center
   async hideKeyboard() {
-    // CLI flows need "dismiss keyboard" to mean "get the focused TextInput
-    // out of the way before the next tap", not just "ask shell chrome to
-    // animate down eventually". If the TextInput stays focused, the next tap
-    // can still be swallowed by keyboard-dismiss policy on ScrollViews.
-    try {
-      await this.callTest<boolean>('blurFocusedTextInput')
-    } catch {
-      // fall through to the shell-level dismiss below; older bridges may not
-      // expose the text-input helper yet.
+    if (this.js.maestro.platform.toLowerCase() === 'android') {
+      await this.back()
+      await sleep(300)
+      await this.waitForAppToSettle()
+      return
     }
+    if (!(await this.isKeyboardVisible())) return
+    const screen = await this.screenBounds()
+    const center = parsePoint('50%,50%', screen)
+    await this.xctestSwipe(center, parsePoint('50%,47%', screen), 50)
+    if (!(await this.isKeyboardVisible())) return
+    await this.xctestSwipe(center, parsePoint('47%,50%', screen), 50)
+    await this.waitForAppToSettle()
+  }
 
-    await this.bridge.send({
-      type: 'keyboard',
-      simId: this.opts.simId,
-      action: 'dismiss',
-    })
+  // the xctest runner's swipe: press, move to the end over its 100ms tap
+  // duration, rest there for the requested duration, then lift, so the
+  // finger leaves at rest rather than flinging
+  private async xctestSwipe(
+    from: { x: number; y: number },
+    to: { x: number; y: number },
+    durationMs: number,
+  ) {
+    const moves = 6
+    const steps: PerformStep[] = [{ type: 'touchDown', x: from.x, y: from.y }]
+    for (let i = 1; i <= moves; i++) {
+      steps.push({ type: 'wait', ms: 100 / moves })
+      steps.push({
+        type: 'touchMove',
+        x: from.x + ((to.x - from.x) * i) / moves,
+        y: from.y + ((to.y - from.y) * i) / moves,
+      })
+    }
+    steps.push({ type: 'wait', ms: durationMs })
+    steps.push({ type: 'touchUp', x: to.x, y: to.y })
+    const result = await this.perform(steps)
+    if (!result?.ok) throw new Error(`swipe failed: ${result?.error ?? 'swipe missed'}`)
+    await this.waitForAppToSettle()
+  }
 
-    const deadline = Date.now() + 3000
-    do {
-      // the host test bridge proxies the tenant, so isTextInputFocused
-      // resolves a promise; reading it unawaited is always truthy.
-      const state = await this.evaluate<{
-        visible: boolean
-        focused: boolean
-      }>(`(async () => {
-        const keyboard =
-          window.__sootsimKeyboard ??
-          window.SootSim?.bridges?.keyboard ??
-          null
-        const test = window.__sootsimTest
-        return {
-          visible: !!keyboard?.isVisible?.(),
-          focused: !!(await test?.isTextInputFocused?.()),
-        }
-      })()`)
-      if (!state?.visible && !state?.focused) {
-        await sleep(80)
-        return
-      }
-      await sleep(80)
-    } while (Date.now() < deadline)
+  private async isKeyboardVisible(): Promise<boolean> {
+    const visible = await this.evaluate<boolean>(`(() => {
+      const keyboard =
+        window.__sootsimKeyboard ?? window.SootSim?.bridges?.keyboard ?? null
+      return !!keyboard?.isVisible?.()
+    })()`)
+    return visible === true
   }
 
   async eraseText(count: number) {
@@ -2765,8 +2775,15 @@ export class SootSimBridgeFlowRunner {
               : { x: centerX, y: screen.height * 0.1 }
       const element = await this.findElement(target)
       if (element) {
-        const { x, y } = element.absolutePosition
-        const { width, height } = element.layout
+        // maestro computes visibility from integer edges, as it does selection.
+        const { x, y, width, height } = accessibilityBounds({
+          frame: {
+            x: element.absolutePosition.x,
+            y: element.absolutePosition.y,
+            width: element.layout.width,
+            height: element.layout.height,
+          },
+        })
         const shownX = Math.max(0, Math.min(x + width, screen.width) - Math.max(x, 0))
         const shownY = Math.max(0, Math.min(y + height, screen.height) - Math.max(y, 0))
         const share = width * height > 0 ? (shownX * shownY) / (width * height) : 0
@@ -2892,6 +2909,12 @@ export class SootSimBridgeFlowRunner {
     const wantsClear = !!(opts && typeof opts === 'object' && opts.clearState)
     const wantsResetRuntime = readBooleanKey(opts, 'resetRuntime')
     const wantsForeground = isObjectRecord(opts) && opts.stopApp === false
+    // maestro's launchApp clears the keychain, then app state, then sets
+    // permissions and launches
+    if (readBooleanKey(opts, 'clearKeychain')) {
+      if (!this.firstLaunchDone && !this.appStopped) await this.waitForTree(120000)
+      await this.clearKeychain()
+    }
     await this.setLaunchPermissions(isObjectRecord(opts) ? opts.permissions : undefined)
 
     if (!this.firstLaunchDone) {
@@ -2982,9 +3005,7 @@ export class SootSimBridgeFlowRunner {
 
   private async setLaunchPermissions(permissions: unknown) {
     const statuses = maestroLaunchPermissions(permissions)
-    const state = await getShellState(this.bridge)
-    const appId = readStringKey(state, 'activeApp') || readRecentShellAppId(state)
-    if (!appId) throw new Error('launchApp: no simulator app to set permissions for')
+    const appId = await this.callTest<string>('permissionGuestAppId')
     for (const [kind, status] of statuses) {
       await this.callTest('permissionSetAppPermission', appId, kind, {
         status,
@@ -3082,11 +3103,11 @@ export class SootSimBridgeFlowRunner {
   }
 
   async startProfile() {
-    const result = await this.evaluate<any>(`(() => {
+    const result = await this.evaluate<any>(`(async () => {
       if (!window.__sootsimShellPerf) {
         return { error: "shell frame profile unavailable (__sootsimShellPerf missing on the page)" }
       }
-      window.__sootsimShellPerf.start()
+      await window.__sootsimShellPerf.start()
       return { started: true }
     })()`)
     if (result?.error) {

package/cli/cloud-client.ts

@@ -27,6 +27,10 @@ import {
 import { rewriteGuestImportMeta } from '../../peach-engine/src/guest-import-meta.ts'
 import { loadMetroFingerprintRegistry } from '../../peach-engine/src/metro-fingerprint-registry-client.ts'
 import { inferMetroModuleIdentity } from '../../peach-engine/src/metro-fingerprint.ts'
+import {
+  isNativeJavaScriptBundle,
+  isRolldownBundle,
+} from '../../peach-engine/src/preview/bundle-layout'
 import { isLoopbackHost } from '../src/backend-origin.ts'
 import {
   isRnxCloudCommandType,
@@ -172,7 +176,7 @@ function resolveCloudOrigin(value?: string): string {
 function readImmutableBundleSource(bundlePath: string, command: string): string {
   const filepath = resolve(bundlePath)
   if (extname(filepath) !== '.js') {
-    throw new Error(`${command} requires one local Metro .js bundle`)
+    throw new Error(`${command} requires one local .js bundle`)
   }
   const descriptor = openSync(filepath, 'r')
   try {
@@ -200,9 +204,6 @@ function readImmutableBundleSource(bundlePath: string, command: string): string
     } catch {
       throw new Error(`${command} bundle must be valid UTF-8 JavaScript`)
     }
-    if (source.includes('\0') || !source.includes('__d(') || !source.includes('__r(')) {
-      throw new Error(`${command} requires a Metro JavaScript bundle`)
-    }
     return source
   } finally {
     closeSync(descriptor)
@@ -231,9 +232,6 @@ async function fetchBundleSource(bundleUrl: string, command: string): Promise<st
   if (text.length === 0) {
     throw new Error(`${command} bundle is empty`)
   }
-  if (text.includes('\0') || !text.includes('__d(') || !text.includes('__r(')) {
-    throw new Error(`${command} requires a Metro JavaScript bundle`)
-  }
   return text
 }
 
@@ -260,6 +258,9 @@ async function loadBundleSource(bundleInput: string, command: string): Promise<s
   const source = isRemoteBundleInput(bundleInput)
     ? await fetchBundleSource(bundleInput, command)
     : readImmutableBundleSource(bundleInput, command)
+  if (!isNativeJavaScriptBundle(source)) {
+    throw new Error(`${command} requires a supported React Native JavaScript bundle`)
+  }
   // validate the actual runtime script form without executing guest code or
   // allocating a host.
   try {
@@ -728,25 +729,44 @@ export async function produceCloudArtifact(
   maxBytes: number = MAX_RNX_CLOUD_BUNDLE_BYTES,
   assetsDirectory?: string,
 ): Promise<CloudArtifactProduction> {
-  return produceArtifact(
+  const prepared = await embedBundleAssets(
     bundlePath,
-    maxBytes,
     REMOTE_COMMAND,
     assetsDirectory ? 'require-assets' : 'allow-placeholders',
     assetsDirectory,
   )
+  return produceArtifact(prepared, maxBytes, REMOTE_COMMAND)
 }
 
 /** prepares a standalone preview whose bytes must represent every Metro asset. */
-export async function producePreviewArtifact(
-  bundlePath: string,
-): Promise<CloudArtifactProduction> {
-  return produceArtifact(
-    bundlePath,
-    Number.POSITIVE_INFINITY,
-    PREVIEW_COMMAND,
-    'require-assets',
-  )
+export async function producePreviewArtifact(bundlePath: string) {
+  const prepared = await embedBundleAssets(bundlePath, PREVIEW_COMMAND, 'require-assets')
+  if (!isRolldownBundle(prepared.source)) {
+    return {
+      ...(await produceArtifact(prepared, Number.POSITIVE_INFINITY, PREVIEW_COMMAND)),
+      minified: true,
+    }
+  }
+  const bytes = Buffer.from(prepared.code, 'utf8')
+  const sha256 = createHash('sha256').update(bytes).digest('hex')
+  return {
+    bytes,
+    sha256,
+    minified: false,
+    receipt: {
+      source: {
+        sha256: createHash('sha256').update(prepared.source).digest('hex'),
+        bytes: Buffer.byteLength(prepared.source, 'utf8'),
+      },
+      artifact: { sha256, bytes: bytes.byteLength },
+    },
+    warnings:
+      prepared.search.unconfirmed && prepared.dest
+        ? [
+            `peach preview could not authenticate asset hashes in ${prepared.dest.directory}; confirm these are the assets this bundle was built against.`,
+          ]
+        : [],
+  }
 }
 
 export interface CloudBoxArtifactProduction {
@@ -890,18 +910,10 @@ async function embedBundleAssets(
 }
 
 async function produceArtifact(
-  bundlePath: string,
+  prepared: Awaited<ReturnType<typeof embedBundleAssets>>,
   maxBytes: number,
   command: string,
-  assetPolicy: 'allow-placeholders' | 'require-assets',
-  assetsDirectory?: string,
 ): Promise<CloudArtifactProduction> {
-  const prepared = await embedBundleAssets(
-    bundlePath,
-    command,
-    assetPolicy,
-    assetsDirectory,
-  )
   const artifact = await buildRnxCloudArtifact(prepared.code, {
     inferModuleIdentity: (source) => inferCloudModuleIdentity(source, command),
   })
@@ -1453,12 +1465,17 @@ function cloudCommand(command: {
 class CloudBridge implements WsBridge {
   readonly plane = 'cloud' as const
 
-  constructor(private readonly session: CloudSimSession) {}
+  constructor(
+    private readonly session: CloudSimSession,
+    private readonly explicitTimeoutMs?: number,
+  ) {}
 
   async send(
     command: { type: string; [key: string]: unknown },
-    options?: { timeoutMs?: number },
+    options?: { timeoutMs?: number; defaultTimeoutMs?: number },
   ): Promise<unknown> {
+    const timeoutMs =
+      options?.timeoutMs ?? this.explicitTimeoutMs ?? options?.defaultTimeoutMs
     const body: CloudCommandEnvelope = {
       id: randomUUID(),
       claimId: this.session.claimId,
@@ -1475,9 +1492,7 @@ class CloudBridge implements WsBridge {
             'content-type': 'application/json',
           },
           body: JSON.stringify(body),
-          ...(options?.timeoutMs
-            ? { signal: AbortSignal.timeout(options.timeoutMs) }
-            : {}),
+          ...(timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {}),
         },
       )
     } catch (error) {
@@ -1538,12 +1553,17 @@ class CloudBridge implements WsBridge {
 class CloudBoxBridge implements WsBridge {
   readonly plane = 'cloud' as const
 
-  constructor(private readonly session: CloudBoxSession) {}
+  constructor(
+    private readonly session: CloudBoxSession,
+    private readonly explicitTimeoutMs?: number,
+  ) {}
 
   async send(
     command: { type: string; [key: string]: unknown },
-    options?: { timeoutMs?: number },
+    options?: { timeoutMs?: number; defaultTimeoutMs?: number },
   ): Promise<unknown> {
+    const timeoutMs =
+      options?.timeoutMs ?? this.explicitTimeoutMs ?? options?.defaultTimeoutMs
     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.
@@ -1562,9 +1582,7 @@ class CloudBoxBridge implements WsBridge {
             'content-type': 'application/json',
           },
           body: JSON.stringify({ id, command: payload }),
-          ...(options?.timeoutMs
-            ? { signal: AbortSignal.timeout(options.timeoutMs) }
-            : {}),
+          ...(timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {}),
         },
       )
     } catch (error) {
@@ -1619,13 +1637,15 @@ class CloudBoxBridge implements WsBridge {
 }
 
 export function createCloudBridgeForParsed(
-  parsed: Pick<ParsedBridgeCliArgs, 'simId' | 'simIdSource'>,
+  parsed: Pick<ParsedBridgeCliArgs, 'simId' | 'simIdSource'> &
+    Partial<Pick<ParsedBridgeCliArgs, 'explicitTimeout' | 'commandTimeoutMs'>>,
 ): WsBridge | null {
   const session = resolveCloudSessionForParsed(parsed)
   if (!session) return null
+  const timeoutMs = parsed.explicitTimeout ? parsed.commandTimeoutMs : undefined
   return session.service === 'box'
-    ? new CloudBoxBridge(session)
-    : new CloudBridge(session)
+    ? new CloudBoxBridge(session, timeoutMs)
+    : new CloudBridge(session, timeoutMs)
 }
 
 // deletes the box, which ends the simulator it holds. a cloud session box is

package/cli/command-registry.ts

@@ -128,6 +128,7 @@ const VALUE_FLAGS = new Set([
   '--timeout',
   '--device',
   '--posture',
+  '--render-resolution',
   '--os-version',
   '--ios-target',
   '--output',