rnxsim 0.1.313 → 0.1.314

package/cli/commands/inspect/wait-ready.ts

@@ -0,0 +1,74 @@
+import { inspectWaitReady, resolveMaxMsFlag, waitReadyReason } from './core'
+import { waitForSootsimIdle } from './settling'
+import type { WsBridge } from '../../ws-bridge'
+
+// blocks until the guest app bundle has finished loading and painted real
+// inspectable content. the persistent window flag
+// `__sootsimExternalAppReady` is necessary but not sufficient: shell-owned
+// canvas can expose a stable launch/loading tree before the app content lands.
+// the polling loop lives in inspect/core.ts (`inspectWaitReady`) so the CLI
+// and the agent share it; this handler just parses flags and reports.
+export async function runWaitReadySubcommand(opts: {
+  bridge: WsBridge
+  args: string[]
+}): Promise<void> {
+  const { bridge, args } = opts
+  // default 20s because cold guest bundles (uniswap, expensify, bluesky)
+  // routinely take 10-15s to evaluate + mount.
+  const timeoutMs = resolveMaxMsFlag(args, 20000)
+
+  const {
+    ready,
+    elapsedMs,
+    nodes,
+    targets,
+    liveFrameActive,
+    liveFrameChannels,
+    flag,
+    loadingText,
+    externalReady,
+    externalError,
+    suppressedEntryError,
+    errors,
+    bridgeError,
+  } = await inspectWaitReady(bridge, timeoutMs, {
+    onProgress(status) {
+      console.error(
+        `  still waiting after ${status.elapsedMs}ms — ${waitReadyReason(status)} (nodes: ${status.nodes}, targets: ${status.targets}, live surfaces: ${status.liveFrameActive ? status.liveFrameChannels : 0}, errors: ${status.errors})`,
+      )
+    },
+  })
+  if (ready) {
+    const remainingMs = timeoutMs - elapsedMs
+    const idleBudgetMs = Math.max(100, Math.min(10_000, remainingMs))
+    const idle = await waitForSootsimIdle({
+      bridge,
+      maxMs: idleBudgetMs,
+      pollMs: 32,
+      stablePolls: 2,
+    })
+    if (!idle.settled) {
+      console.error(
+        `  ⚠ wait ready timed out after ${elapsedMs + idle.elapsed}ms — app mounted but did not settle (nodes: ${nodes}, targets: ${targets})`,
+      )
+      process.exit(1)
+    }
+    console.log(
+      `  ready in ${elapsedMs + idle.elapsed}ms: ${nodes} nodes, ${targets} targets${liveFrameActive ? `, ${liveFrameChannels} live surfaces` : ''}`,
+    )
+    return
+  }
+  const reason = waitReadyReason({
+    externalError,
+    loadingText,
+    externalReady,
+    flag,
+    targets,
+    suppressedEntryError,
+    bridgeError,
+  })
+  console.error(
+    `  ⚠ wait ready timed out after ${elapsedMs}ms — ${reason} (nodes: ${nodes}, targets: ${targets}, live surfaces: ${liveFrameActive ? liveFrameChannels : 0}, errors: ${errors})`,
+  )
+  process.exit(1)
+}

package/cli/commands/inspect/wait-selector.ts

@@ -0,0 +1,54 @@
+import { inspectWaitSelector } from './core'
+import type { WsBridge } from '../../ws-bridge'
+
+// blocks until a node with the given testID is present and laid out, or — with
+// `--gone` — until it is absent. the polling logic lives in inspect/core.ts
+// (`inspectWaitSelector`); this handler parses args and reports.
+export async function runWaitSelectorSubcommand(opts: {
+  bridge: WsBridge
+  args: string[]
+  positional: string[]
+  inspectUsage: (name: string, tail: string) => string
+}): Promise<void> {
+  const { bridge, args, positional, inspectUsage } = opts
+  const testId = positional[1]
+  if (!testId) {
+    console.error(inspectUsage('wait selector', '<testid> [--max-ms 5000] [--gone]'))
+    process.exit(1)
+  }
+  const maxMsIdx = args.indexOf('--max-ms')
+  const timeoutMs =
+    maxMsIdx >= 0 && args[maxMsIdx + 1] ? Math.max(100, Number(args[maxMsIdx + 1])) : 5000
+  const gone = args.includes('--gone')
+
+  const { found, node, elapsed } = await inspectWaitSelector(bridge, testId, timeoutMs, {
+    gone,
+  })
+
+  if (gone) {
+    if (found) {
+      console.log(`  #${testId} gone after ${elapsed}ms`)
+    } else {
+      console.error(
+        `  ⚠ wait selector #${testId} --gone timed out after ${elapsed ?? timeoutMs}ms (still present)`,
+      )
+      process.exit(1)
+    }
+    return
+  }
+
+  if (found && node) {
+    const loc = node.absolutePosition
+      ? `@(${Math.round(node.absolutePosition.x)},${Math.round(node.absolutePosition.y)})`
+      : ''
+    const size = node.layout
+      ? `${Math.round(node.layout.width)}x${Math.round(node.layout.height)}`
+      : '?x?'
+    console.log(`  found #${testId} in ${elapsed}ms ${size} ${loc}`)
+  } else {
+    console.error(
+      `  ⚠ wait selector #${testId} timed out after ${elapsed ?? timeoutMs}ms`,
+    )
+    process.exit(1)
+  }
+}

package/cli/commands/inspect/wait.ts

@@ -0,0 +1,31 @@
+import { rememberFlowCandidate } from '../../flow-session'
+import { waitForSimReady } from './shared'
+
+export async function runWaitSubcommand(opts: {
+  wsPort: number
+  commandTimeoutMs: number
+  simId?: string
+  simIdSource?: 'flag' | 'saved' | 'none'
+  positional: string[]
+}): Promise<void> {
+  const { wsPort, commandTimeoutMs, simId, simIdSource, positional } = opts
+  const seconds = positional[1] ? Number(positional[1]) : 30
+  const timeoutMs = Math.max(1000, (Number.isFinite(seconds) ? seconds : 30) * 1000)
+  const attempts = Math.max(1, Math.ceil(timeoutMs / 500))
+  console.log(`  waiting for sim reconnect...`)
+  const ready = await waitForSimReady(wsPort, commandTimeoutMs, simId, {
+    attempts,
+    simIdSource,
+  })
+  if (!ready) {
+    console.error(`  timed out waiting for sim reconnect`)
+    process.exit(1)
+  }
+  ready.bridge.close()
+  rememberFlowCandidate({
+    source: 'inspect wait',
+    step: { wait: timeoutMs },
+    summary: `wait ${Math.round(timeoutMs / 1000)}s`,
+  })
+  console.log(`  ready: ${ready.count} nodes`)
+}