peachsim 0.1.527

package/cli/commands/do-chain.ts

@@ -0,0 +1,408 @@
+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[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.RNX_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.simIdSource === 'flag' ? parsed.simId : undefined,
+      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/electron.ts

@@ -0,0 +1,94 @@
+// rnx desktop — launch the installed desktop companion via the
+// electron driver. the driver wraps findDesktopCompanion +
+// launchDesktopCompanion, so this command is a thin CLI surface that
+// parses options, prompts for install, and delegates everything else.
+
+import { ensureProfile } from '../../src/profiles'
+import { findDesktopCompanion } from '../desktop-companion'
+import { electronDriver } from '../drivers'
+import { confirm } from '../prompt'
+import { rnxExit } from '../run-rnx'
+import { buildShellUrl } from './control'
+import { printMissingCompanionHint } from './no-bridge-hint'
+
+interface ElectronOptions {
+  port?: number
+  device?: string
+}
+
+function parseInlinePort(args: string[]): number | undefined {
+  const portIdx = args.indexOf('--port')
+  if (portIdx < 0) return undefined
+  const raw = args[portIdx + 1]
+  const port = raw ? Number(raw) : Number.NaN
+  if (!Number.isInteger(port) || port <= 0) {
+    console.error(`  invalid --port value: ${raw || '(missing)'}`)
+    rnxExit(1)
+  }
+  return port
+}
+
+export async function resolveElectronLaunchUrl(
+  args: string[],
+  opts: ElectronOptions,
+): Promise<string | undefined> {
+  const targetPort = parseInlinePort(args) ?? opts.port
+  return targetPort ? buildShellUrl(String(targetPort)) : undefined
+}
+
+export async function runElectron(args: string[], opts: ElectronOptions) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+rnx desktop — launch the desktop companion
+
+usage:
+  rnx desktop [options]
+
+options:
+  --port <number>     connect to running dev server on this port
+  --profile <id>      launch with an isolated persistent storage profile
+  --ephemeral         launch with a temporary isolated storage profile
+
+examples:
+  rnx desktop
+  rnx desktop --port 5173
+  rnx desktop --profile qa
+`)
+    rnxExit(0)
+  }
+
+  const profileArg = args.find((_, i) => args[i - 1] === '--profile')
+  const ephemeralProfile = args.includes('--ephemeral')
+  if (profileArg && ephemeralProfile) {
+    console.error('  rnx desktop: --profile cannot be combined with --ephemeral')
+    rnxExit(1)
+  }
+  const profileId = profileArg ? ensureProfile(profileArg).id : undefined
+  let install = findDesktopCompanion()
+  if (!install) {
+    printMissingCompanionHint()
+    const canPrompt =
+      process.stdin.isTTY && process.env.CI !== '1' && process.env.RNX_NO_PROMPT !== '1'
+    if (canPrompt && (await confirm('run rnx desktop install now?', true))) {
+      console.log()
+      const { runInstallDesktop } = await import('./install-desktop')
+      await runInstallDesktop(['--yes'])
+      install = findDesktopCompanion()
+    }
+    if (!install) rnxExit(1)
+  }
+  console.log(`  launching ${install.path}`)
+
+  const url = await resolveElectronLaunchUrl(args, opts)
+  const result = await electronDriver.launch({
+    url,
+    device: opts.device,
+    profileId,
+    ephemeralProfile,
+  })
+  if (!result.launched) {
+    console.error(`  ${result.message}`)
+    rnxExit(1)
+  }
+  console.log(`  ${result.message}`)
+}