rnxsim 0.1.366 → 0.1.367

package/cli/commands/box.ts

@@ -0,0 +1,200 @@
+// `rnx box` — the box environment.
+//
+// bare `rnx box` is LOCAL and mounts the current checkout at /project. `rnx box
+// create` provisions a durable cloud box. everything else in the namespace is
+// cloud lifecycle. the cloud side is not built yet; those verbs fail by name
+// and say what works instead, so nothing advertises a capability that always
+// fails.
+
+import path from 'node:path'
+import { createInterface } from 'node:readline'
+import { createHarnessShell, HarnessProjectFs, PROJECT_MOUNT } from '@contrast/harness'
+import { rnxPublicBrand } from '../../src/public-brand'
+import { findRepositoryPackageRoot } from '../setup-repository'
+import { resolvePlacement } from '../ws-bridge'
+import { CheckoutFilePlane, CheckoutRequiresGitError } from './box/checkout-plane'
+import { createRnxCommand } from './box/rnx-command'
+
+interface BoxCommandOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const CLOUD_SUBCOMMANDS = new Set(['create', 'ls', 'connect', 'stop', 'delete'])
+
+function usage(): void {
+  const rnx = rnxPublicBrand.commandName
+  console.log(`
+  ${rnx} box — start a local box and enter its shell
+
+  usage:
+    ${rnx} box                     start a local box over the current checkout
+    ${rnx} box create              create a cloud box and enter its shell
+    ${rnx} box create --name=<n>   create a named cloud box
+
+  a local box mounts this checkout at ${PROJECT_MOUNT}, gives you a shell with
+  ls, cat, find, rg, sed, pipes and redirects, and registers ${rnx} itself as a
+  shell command. writes go straight to the checkout — there is no second copy.
+`)
+}
+
+export async function runBox(
+  args: string[],
+  opts: BoxCommandOptions = {},
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    usage()
+    return 0
+  }
+
+  // a box inside a box would mount the same checkout twice and give the
+  // user two shells writing through one filesystem. refuse at the top rather
+  // than letting the second one start and quietly race the first.
+  const placement = resolvePlacement()
+  if (placement === 'local-box') {
+    console.error(
+      `  ${rnxPublicBrand.commandName} box: you are already in a box.\n` +
+        `  this shell is the box — run ${rnxPublicBrand.commandName} commands directly, or \`exit\` to leave.`,
+    )
+    return 1
+  }
+
+  const subcommand = args.find((arg) => !arg.startsWith('-'))
+  if (subcommand !== undefined) {
+    if (CLOUD_SUBCOMMANDS.has(subcommand)) {
+      console.error(
+        `  ${rnxPublicBrand.commandName} box ${subcommand} needs a cloud box, which is not built yet.\n` +
+          `  \`${rnxPublicBrand.commandName} box\` runs the same shell locally over this checkout.`,
+      )
+      return 1
+    }
+    console.error(
+      `  unknown command: ${rnxPublicBrand.commandName} box ${subcommand}\n` +
+        `  run \`${rnxPublicBrand.commandName} box --help\` to see the box surface.`,
+    )
+    return 1
+  }
+
+  return runLocalBox(opts)
+}
+
+async function runLocalBox(opts: BoxCommandOptions): Promise<number> {
+  // findRepositoryPackageRoot answers both halves of what a box needs: the
+  // nearest package.json, and only when it sits inside a git repository. git
+  // is what decides which files belong to the project, so a box without it
+  // would have to walk the whole directory tree — measured at 230k files on
+  // this repo against 15k from git.
+  const root = findRepositoryPackageRoot(process.cwd())
+  if (!root) {
+    console.error(
+      `  ${rnxPublicBrand.commandName} box: no project here.\n` +
+        `  the box needs a directory inside a git repository that has a\n` +
+        `  package.json. it asks git which files belong to the project, so it\n` +
+        `  never walks node_modules or build output. run \`git init\` if this is\n` +
+        `  a new project.`,
+    )
+    return 1
+  }
+
+  const plane = new CheckoutFilePlane(root)
+  try {
+    await plane.refresh()
+  } catch (error) {
+    if (error instanceof CheckoutRequiresGitError) {
+      console.error(`  ${rnxPublicBrand.commandName} box: ${error.message}`)
+      return 1
+    }
+    throw error
+  }
+
+  const shell = createHarnessShell({
+    projectFs: new HarnessProjectFs(plane),
+    commands: [createRnxCommand({ root, shellCwd: () => shell.cwd })],
+  })
+
+  const relative = path.relative(root, process.cwd())
+  console.log(`  ...starting local box`)
+  console.log(`  ...mounting ${root} at ${PROJECT_MOUNT}`)
+  console.log(`  ...accessing shell\n`)
+  if (opts.verbose) {
+    console.log(`  ${plane.index().size} project files indexed\n`)
+  }
+
+  return repl(shell, plane, relative)
+}
+
+async function repl(
+  shell: ReturnType<typeof createHarnessShell>,
+  plane: CheckoutFilePlane,
+  startRelative: string,
+): Promise<number> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+
+  // enter where the user was standing, so `rnx box` from a subdirectory does
+  // not silently teleport them to the project root.
+  if (startRelative && !startRelative.startsWith('..')) {
+    await shell.exec(`cd ${JSON.stringify(startRelative)}`)
+  }
+
+  const prompt = () => {
+    rl.setPrompt(`${shell.cwd} > `)
+    rl.prompt()
+  }
+
+  // readline delivers a pasted block, or a piped script, as a burst of `line`
+  // events. run them one at a time in order — dropping the ones that arrive
+  // while a command is running would silently execute only the first line of
+  // a paste.
+  let queue: Promise<void> = Promise.resolve()
+  // stdin ended: stop printing prompts, but still finish what is already
+  // queued — piping a script in must run every line, not just the first.
+  let inputEnded = false
+  // the user typed `exit`: abandon anything still queued behind it.
+  let stopped = false
+
+  const run = async (command: string) => {
+    if (stopped) return
+    try {
+      // the checkout is shared with editors, agents, and the user's own
+      // terminal, so re-read the file set before every command rather than
+      // trusting a snapshot taken when the box started.
+      await plane.refresh()
+      const result = await shell.exec(command)
+      if (result.text && result.text !== '(no output)') console.log(result.text)
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error))
+    }
+    if (!inputEnded && !stopped) prompt()
+  }
+
+  return new Promise<number>((resolve) => {
+    prompt()
+
+    rl.on('line', (line) => {
+      const command = line.trim()
+      if (!command) {
+        queue = queue.then(() => {
+          if (!inputEnded && !stopped) prompt()
+        })
+        return
+      }
+      if (command === 'exit' || command === 'quit') {
+        queue = queue.then(() => {
+          stopped = true
+          rl.close()
+        })
+        return
+      }
+      queue = queue.then(() => run(command))
+    })
+
+    rl.on('close', () => {
+      inputEnded = true
+      // let any already-queued command finish before the process exits.
+      queue.then(() => {
+        console.log()
+        resolve(0)
+      })
+    })
+  })
+}

package/cli/commands/control.ts

@@ -66,7 +66,7 @@ import {
   worldForBridgePort,
   type BridgeSimInfo,
 } from '../ws-bridge'
-import { WAIT_READY_PROBE, readyProbeHasContent, type ReadyProbe } from './inspect/core'
+import { inspectDescribe, inspectWaitReady } from './inspect/core'
 import { isAgentEnv } from './inspect/env'
 import type { DriverId, DriverLaunchResult } from '../drivers/types'
 
@@ -1248,19 +1248,12 @@ async function maybeDescribeAfterOpen(wsPort: number, simId: string, args: strin
       simIdSource: 'flag',
     })
     try {
-      let readyProbe: ReadyProbe | null = null
+      let readyProbe: Awaited<ReturnType<typeof inspectWaitReady>> | null = null
       try {
-        readyProbe = (await bridge.send({
-          type: 'evaluate',
-          code: WAIT_READY_PROBE,
-        })) as ReadyProbe | null
+        readyProbe = await inspectWaitReady(bridge, 1)
       } catch {}
       if (readyProbe) {
-        const readyEnough =
-          readyProbe.flag === true &&
-          !readyProbe.loadingText &&
-          readyProbeHasContent(readyProbe)
-        if (!readyEnough) {
+        if (!readyProbe.ready) {
           const reason = readyProbe.loadingText
             ? `still showing "${readyProbe.loadingText}"`
             : readyProbe.flag !== true
@@ -1274,29 +1267,16 @@ async function maybeDescribeAfterOpen(wsPort: number, simId: string, args: strin
           console.log('  before interacting, run: rnx wait ready --max-ms 120000')
         }
       }
-      const dumpOpts = { describe: true, verbose: false, filter: '' }
-      const code = `(async () => {
-        const t = window.__sootsimTest
-        const ms = window.SootSim?.bridges?.mainShell
-        if (!t) return null
-        let shell = null
-        try { shell = ms?.getState ? await ms.getState() : null } catch {}
-        const tree = await t.dumpTree(12, ${JSON.stringify(dumpOpts)})
-        return { tree, shell }
-      })()`
-      const result = (await bridge.send({ type: 'evaluate', code })) as {
-        tree: string | null
-        shell: { state?: string; activeApp?: string } | null
-      } | null
+      const result = await inspectDescribe(bridge, {
+        describe: true,
+        verbose: false,
+        filter: '',
+        compact: true,
+        hideXy: false,
+        maxDepth: 12,
+      })
       if (!result?.tree) return
       console.log('')
-      if (result.shell?.state) {
-        const parts = [
-          `state=${result.shell.state}`,
-          result.shell.activeApp ? `app=${result.shell.activeApp}` : null,
-        ].filter(Boolean)
-        console.log(`  shell: ${parts.join(' ')}`)
-      }
       console.log(result.tree)
     } finally {
       bridge.close()

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',