rnxsim 0.1.365 → 0.1.367

package/cli/commands/do-chain.ts

@@ -0,0 +1,412 @@
+import { BridgeInputError } from '../../src/bridge-contract-input'
+import type { SimPerformStep } from '../../src/sim-client'
+
+interface TargetedDoubleTapAction {
+  type: 'targetedDoubleTap'
+  id: string
+  gapMs: number
+}
+
+interface TargetedLongPressAction {
+  type: 'targetedLongPress'
+  id: string
+  durationMs: number
+}
+
+export type DoChainAction =
+  | SimPerformStep
+  | TargetedDoubleTapAction
+  | TargetedLongPressAction
+
+const DO_CHAIN_ACTIONS = new Set([
+  'tap',
+  'tap-id',
+  'tap-text',
+  'double-tap',
+  'long-press',
+  'type',
+  'type-into',
+  'key',
+  'key-sequence',
+  'dismiss',
+  'scroll',
+  'drag',
+  'swipe',
+  'pinch',
+  'touch',
+  'sleep',
+])
+
+export function hasDoChain(args: string[]): boolean {
+  return args.includes('--then')
+}
+
+function invalidAction(index: number, usage: string): never {
+  throw new BridgeInputError(
+    `do chain action ${index + 1} has invalid arguments; usage: rnx do ${usage}`,
+  )
+}
+
+function finiteNumber(value: string | undefined, index: number, usage: string): number {
+  const parsed = Number(value)
+  if (value === undefined || !Number.isFinite(parsed)) invalidAction(index, usage)
+  return parsed
+}
+
+export function parseDoChainActions(args: string[]): DoChainAction[] {
+  const segments: string[][] = [[]]
+  for (const argument of args) {
+    if (argument !== '--then') {
+      segments[segments.length - 1].push(argument)
+      continue
+    }
+    if (segments[segments.length - 1].length === 0) {
+      throw new BridgeInputError('do chain contains an empty action')
+    }
+    segments.push([])
+  }
+  if (segments.length < 2) {
+    throw new BridgeInputError('do chain needs at least two actions separated by --then')
+  }
+  if (segments[segments.length - 1].length === 0) {
+    throw new BridgeInputError('do chain cannot end with --then')
+  }
+
+  return segments.flatMap((segment, index): DoChainAction[] => {
+    const [action, ...values] = segment
+    if (!action) throw new BridgeInputError('do chain contains an empty action')
+    if (!DO_CHAIN_ACTIONS.has(action)) {
+      throw new BridgeInputError(
+        `do chain action ${index + 1} cannot batch ${JSON.stringify(action)}; run it as a separate rnx do command`,
+      )
+    }
+
+    switch (action) {
+      case 'tap': {
+        if (values.length === 1 && !Number.isFinite(Number(values[0]))) {
+          return [{ type: 'tapId', id: values[0] }]
+        }
+        if (values.length !== 2) invalidAction(index, 'tap <testid> | <x> <y>')
+        return [
+          {
+            type: 'tap',
+            x: finiteNumber(values[0], index, 'tap <testid> | <x> <y>'),
+            y: finiteNumber(values[1], index, 'tap <testid> | <x> <y>'),
+          },
+        ]
+      }
+
+      case 'tap-id':
+        if (values.length !== 1) invalidAction(index, 'tap-id <id>')
+        return [{ type: 'tapId', id: values[0] }]
+
+      case 'tap-text': {
+        const text = values.join(' ')
+        if (!text) invalidAction(index, 'tap-text <text>')
+        return [{ type: 'tapText', text }]
+      }
+
+      case 'double-tap': {
+        const usage = 'double-tap <testid> [gapMs] | <x> <y> [gapMs]'
+        if (values.length > 0 && !Number.isFinite(Number(values[0]))) {
+          if (values.length > 2) invalidAction(index, usage)
+          return [
+            {
+              type: 'targetedDoubleTap',
+              id: values[0],
+              gapMs:
+                values.length === 2
+                  ? Math.max(0, Math.round(finiteNumber(values[1], index, usage)))
+                  : 80,
+            },
+          ]
+        }
+        if (values.length < 2 || values.length > 3) invalidAction(index, usage)
+        return [
+          {
+            type: 'doubleTap',
+            x: finiteNumber(values[0], index, usage),
+            y: finiteNumber(values[1], index, usage),
+            gapMs:
+              values.length === 3
+                ? Math.max(0, Math.round(finiteNumber(values[2], index, usage)))
+                : 80,
+          },
+        ]
+      }
+
+      case 'long-press': {
+        const usage = 'long-press <testid> [durationMs] | <x> <y> [durationMs]'
+        if (values.length > 0 && !Number.isFinite(Number(values[0]))) {
+          if (values.length > 2) invalidAction(index, usage)
+          return [
+            {
+              type: 'targetedLongPress',
+              id: values[0],
+              durationMs:
+                values.length === 2
+                  ? Math.max(0, Math.round(finiteNumber(values[1], index, usage)))
+                  : 600,
+            },
+          ]
+        }
+        if (values.length < 2 || values.length > 3) invalidAction(index, usage)
+        return [
+          {
+            type: 'longPress',
+            x: finiteNumber(values[0], index, usage),
+            y: finiteNumber(values[1], index, usage),
+            durationMs:
+              values.length === 3
+                ? Math.max(0, Math.round(finiteNumber(values[2], index, usage)))
+                : 600,
+          },
+        ]
+      }
+
+      case 'type': {
+        const text = values.join(' ')
+        if (!text) invalidAction(index, 'type <text>')
+        return [{ type: 'type', text }]
+      }
+
+      case 'type-into': {
+        const text = values.slice(1).join(' ')
+        if (!values[0] || !text) invalidAction(index, 'type-into <id> <text>')
+        return [
+          { type: 'tapId', id: values[0] },
+          { type: 'type', text },
+        ]
+      }
+
+      case 'key':
+        if (values.length !== 1) invalidAction(index, 'key <name>')
+        return [{ type: 'key', key: values[0] }]
+
+      case 'key-sequence':
+        if (values.length === 0) invalidAction(index, 'key-sequence <key> [<key> ...]')
+        return values.map((key) => ({ type: 'key', key }))
+
+      case 'dismiss':
+        if (values.length !== 0) invalidAction(index, 'dismiss')
+        return [{ type: 'dismissKeyboard' }]
+
+      case 'scroll': {
+        const usage = 'scroll <id> <x> <y>'
+        if (values.length !== 3) invalidAction(index, usage)
+        return [
+          {
+            type: 'scroll',
+            id: values[0],
+            x: finiteNumber(values[1], index, usage),
+            y: finiteNumber(values[2], index, usage),
+            animated: false,
+          },
+        ]
+      }
+
+      case 'drag':
+      case 'swipe': {
+        const usage = `${action} <x1> <y1> <x2> <y2> [steps] [stepMs]`
+        if (values.length < 4 || values.length > 6) invalidAction(index, usage)
+        const defaultSteps = action === 'swipe' ? 10 : 12
+        const defaultStepMs = action === 'swipe' ? 8 : 16
+        return [
+          {
+            type: 'drag',
+            fromX: finiteNumber(values[0], index, usage),
+            fromY: finiteNumber(values[1], index, usage),
+            toX: finiteNumber(values[2], index, usage),
+            toY: finiteNumber(values[3], index, usage),
+            steps:
+              values.length >= 5
+                ? Math.max(1, Math.round(finiteNumber(values[4], index, usage)))
+                : defaultSteps,
+            stepMs:
+              values.length === 6
+                ? Math.max(0, Math.round(finiteNumber(values[5], index, usage)))
+                : defaultStepMs,
+          },
+        ]
+      }
+
+      case 'pinch': {
+        const usage = "pinch <x1> <y1> <x2> <y2> <x1'> <y1'> <x2'> <y2'> [steps] [stepMs]"
+        if (values.length < 8 || values.length > 10) invalidAction(index, usage)
+        return [
+          {
+            type: 'pinch',
+            fromX1: finiteNumber(values[0], index, usage),
+            fromY1: finiteNumber(values[1], index, usage),
+            fromX2: finiteNumber(values[2], index, usage),
+            fromY2: finiteNumber(values[3], index, usage),
+            toX1: finiteNumber(values[4], index, usage),
+            toY1: finiteNumber(values[5], index, usage),
+            toX2: finiteNumber(values[6], index, usage),
+            toY2: finiteNumber(values[7], index, usage),
+            steps:
+              values.length >= 9
+                ? Math.max(1, Math.round(finiteNumber(values[8], index, usage)))
+                : 12,
+            stepMs:
+              values.length === 10
+                ? Math.max(0, Math.round(finiteNumber(values[9], index, usage)))
+                : 16,
+          },
+        ]
+      }
+
+      case 'touch': {
+        const usage = 'touch <down|move|up|cancel> <x> <y> [pointerId]'
+        if (values.length < 3 || values.length > 4) invalidAction(index, usage)
+        const phase = values[0]
+        if (
+          phase !== 'down' &&
+          phase !== 'move' &&
+          phase !== 'up' &&
+          phase !== 'cancel'
+        ) {
+          invalidAction(index, usage)
+        }
+        const pointerId =
+          values.length === 4
+            ? Math.max(1, Math.round(finiteNumber(values[3], index, usage)))
+            : 999
+        if (phase === 'cancel') return [{ type: 'touchCancel', pointerId }]
+        return [
+          {
+            type:
+              phase === 'down' ? 'touchDown' : phase === 'move' ? 'touchMove' : 'touchUp',
+            x: finiteNumber(values[1], index, usage),
+            y: finiteNumber(values[2], index, usage),
+            pointerId,
+          },
+        ]
+      }
+
+      case 'sleep': {
+        const usage = 'sleep [seconds]'
+        if (values.length > 1) invalidAction(index, usage)
+        const seconds = values.length === 1 ? finiteNumber(values[0], index, usage) : 0.5
+        if (seconds < 0) invalidAction(index, usage)
+        return [{ type: 'wait', ms: Math.round(seconds * 1000) }]
+      }
+
+      default:
+        throw new BridgeInputError(
+          `do chain action ${index + 1} cannot batch ${JSON.stringify(action)}`,
+        )
+    }
+  })
+}
+
+export async function runDoChain(
+  args: string[],
+  opts: { port?: number } = {},
+): Promise<number> {
+  const [connectModule, simClientModule, bridgeModule, envModule, targetModule] =
+    await Promise.all([
+      import('../../src/connect'),
+      import('../../src/sim-client'),
+      import('../ws-bridge'),
+      import('./inspect/env'),
+      import('./inspect/resolve-target'),
+    ])
+  const { connect } = connectModule
+  const { SimPerformError } = simClientModule
+  const { checkSimHealth, parseBridgeCliArgs } = bridgeModule
+  const { isAgentEnv } = envModule
+  const { resolveTargetCoords } = targetModule
+  const wantsJson = args.includes('--json')
+  const skipSettle =
+    args.includes('--no-wait') || process.env.SOOTSIM_NO_AUTO_WAIT === '1'
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    commandTimeoutMs: 30_000,
+    stripBooleanFlags: ['--json', '--no-wait'],
+  })
+  if (!Number.isFinite(parsed.commandTimeoutMs) || parsed.commandTimeoutMs <= 0) {
+    console.error('  do chain: --timeout must be a positive number')
+    return 1
+  }
+
+  let actions: DoChainAction[]
+  try {
+    actions = parseDoChainActions(parsed.positional)
+  } catch (error) {
+    console.error(`  do chain: ${error instanceof Error ? error.message : error}`)
+    return 1
+  }
+
+  let sim: Awaited<ReturnType<typeof connect>> | null = null
+  try {
+    sim = await connect({
+      port: parsed.wsPort,
+      sim: parsed.simId,
+      timeoutMs: parsed.commandTimeoutMs,
+    })
+    await checkSimHealth(sim)
+
+    const steps: SimPerformStep[] = []
+    for (const action of actions) {
+      if (action.type !== 'targetedDoubleTap' && action.type !== 'targetedLongPress') {
+        steps.push(action)
+        continue
+      }
+      const target = await resolveTargetCoords(sim, { mode: 'testid', value: action.id })
+      if (!target) {
+        throw new BridgeInputError(
+          `do chain could not find testID ${JSON.stringify(action.id)}`,
+        )
+      }
+      steps.push(
+        action.type === 'targetedDoubleTap'
+          ? {
+              type: 'doubleTap',
+              x: target.x,
+              y: target.y,
+              gapMs: action.gapMs,
+            }
+          : {
+              type: 'longPress',
+              x: target.x,
+              y: target.y,
+              durationMs: action.durationMs,
+            },
+      )
+    }
+
+    const result = await sim.perform(steps, { timeoutMs: parsed.commandTimeoutMs })
+    if (!skipSettle) {
+      try {
+        const budgetMs = isAgentEnv() ? 400 : 200
+        const settled = await sim.settle({ maxMs: budgetMs })
+        if (!settled.settled) {
+          process.stderr.write(
+            `  ⚠ auto-wait timed out after ${settled.elapsed ?? budgetMs}ms. next command may see mid-animation state. use \`rnx do settle\` for a longer wait.\n`,
+          )
+        }
+      } catch {}
+    }
+
+    if (wantsJson) {
+      console.log(JSON.stringify(result))
+    } else {
+      console.log(
+        `  completed ${result.completed} batched ${result.completed === 1 ? 'step' : 'steps'} in ${result.durationMs}ms`,
+      )
+    }
+    return 0
+  } catch (error) {
+    if (error instanceof SimPerformError && wantsJson) {
+      console.log(JSON.stringify(error.result))
+    } else {
+      console.error(
+        `  do chain failed: ${error instanceof Error ? error.message : error}`,
+      )
+    }
+    return 1
+  } finally {
+    sim?.close()
+  }
+}

package/cli/commands/flow.ts

@@ -456,16 +456,6 @@ flow extension:
       })
     }
     if (!targetDevice) return false
-    const currentUrl = await bridge.send({
-      type: 'evaluate',
-      simId: driver.simId,
-      code: 'window.location.href',
-    })
-    if (typeof currentUrl === 'string' && currentUrl.length > 0) {
-      const nextUrl = new URL(currentUrl)
-      nextUrl.searchParams.set('device', targetDevice)
-      driver.setSimRouteHint(nextUrl.toString())
-    }
     return Boolean(
       await bridge.send({
         type: 'call',
@@ -494,7 +484,8 @@ flow extension:
     requireRecordingEntitlement: preview,
     // re-arm the event recorder after every launchApp-with-reload. the
     // recorder lives in-page state and gets wiped by window.location.reload.
-    onAfterLaunch: async () => {
+    onAfterLaunch: async (simId) => {
+      if (simId) saveCurrentSimId(simId)
       const deviceChanged = await applyFlowFrontmatter()
       if (deviceChanged) await driver.waitForTree(120000)
       if (!preview) return