rnxsim 0.1.313 → 0.1.314

package/cli/commands/maestro.ts

@@ -0,0 +1,453 @@
+// sootsim maestro — drop-in replacement for the real `maestro` cli.
+//
+// users with an existing `.maestro/` directory can swap `maestro test`
+// for `sootsim maestro test` and have their flows execute against
+// sootsim's in-browser engine. the heavy lifting lives in `flow.ts` +
+// `bridge-flow-runner.ts`; this file just re-maps the maestro argv shape
+// onto the existing flow runner and handles directory iteration + init.
+
+import * as fs from 'fs'
+import * as path from 'path'
+import yaml from 'yaml'
+import { resolveCliAuth } from '../auth'
+import { parseFlowFile } from '../flow-file'
+import { registerRun, shouldRegisterRun, stepSummaryFromTrace } from '../run-registry'
+import {
+  getLastFlowPreviewUploadResult,
+  getLastFlowTraceSteps,
+  hoistLeadingSimFlag,
+  runMaestroAuthoring,
+  runFlowPlayback,
+} from './flow'
+import { resolveDefaultUploadOrigin } from './upload'
+
+export interface RunMaestroOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const MAESTRO_DIRS = ['.maestro', 'maestro']
+
+function printHelp() {
+  console.log(`
+rnxsim maestro — author and run Maestro YAML flows against rnx
+
+usage:
+  rnxsim maestro                         # discover .maestro/ or maestro/ in cwd, run all
+  rnxsim maestro test <flow-or-dir>      # mirrors "maestro test"
+  rnxsim maestro test .maestro/          # every *.yaml / *.yml in a directory
+  rnxsim maestro generate "<goal>"       # generate, run, and upload a Maestro flow
+  rnxsim maestro start|keep|end          # author a flow from live CLI actions
+  rnxsim maestro validate <flow>         # validate a Maestro YAML file
+  rnxsim maestro init                    # scaffold .maestro/login.yaml
+  rnxsim maestro --list-compat           # print supported/unsupported verbs
+
+options:
+  --env KEY=VALUE        set env vars for \${KEY} interpolation (repeatable)
+  --continuous           re-run the flow on file changes (alias for --watch)
+  --format <fmt>         accepted for maestro cli compat (not used)
+  --new                  force a fresh browser window for this run
+  --headed               force a fresh, VISIBLE window (implies --new,
+                         overrides --headless) — watch the flow run live
+  --record               record a webm while the flow runs
+  --preview              record events+video, upload, and print /preview/<id>
+  --preview-open         open the uploaded preview link after a successful run
+  --preview-origin <url> upload target for --preview
+  --preview-public-origin <url>
+                         public link origin for --preview
+  --slow <ms>            delay between steps for natural pacing
+
+examples:
+  rnxsim maestro test .maestro/login.yaml
+  rnxsim maestro test .maestro/
+  rnxsim maestro generate "log in and verify the welcome screen"
+  rnxsim maestro start
+  rnxsim maestro end --output .maestro/login.yaml --validate
+  rnxsim maestro --env USERNAME=alice test .maestro/login.yaml
+  rnxsim maestro init
+`)
+}
+
+function printCompatMatrix() {
+  console.log(`
+rnxsim maestro — compatibility matrix
+
+supported verbs:
+  launchApp, stopApp, clearState, clearKeychain (warn-only),
+  tapOn, tapAtCoords, longPressOn,
+  inputText, pressKey, dispatchKey, hideKeyboard, eraseText,
+  assertVisible, assertNotVisible, assertTreeContains,
+  waitFor, extendedWaitUntil, waitForAnimationToEnd,
+  scroll, scrollUntilVisible, scrollTo, swipe, pinch,
+  takeScreenshot, dumpTree, back,
+  repeat (times), runFlow (file / inline commands / env / when),
+  runScript (maestro JS: http, json(), output, env vars, console.log),
+  evalScript, copyTextFrom (\${maestro.copiedText}), openLink,
+  when: (visible / notVisible / platform / true),
+  optional:, label:, onFlowStart, onFlowComplete,
+  \${...} JS-expression interpolation at step execution time
+  (env vars as globals, output.*, maestro.*, \${EXPR || 'default'}).
+
+workspace mode (directory runs):
+  config.yaml / config.yml discovery, flows: inclusion globs,
+  includeTags / excludeTags against flow frontmatter tags.
+
+partial:
+  clearKeychain — warn-only, rnx has no keychain surface.
+  when.platform — rnx reports iOS.
+  openLink — dispatched into the app via the Linking emulation
+    (react-navigation deep links work); no OS-level Safari fallback.
+  launchApp.arguments — ignored; rnx has no native process.
+  launchApp.resetRuntime — sootsim-only extension for recorded benchmarks:
+    keep tenant storage/auth, but soft-reload the guest app inside launchApp.
+  takeScreenshot — maestro string form works unchanged; rnx also accepts
+    { path, withFrame } for framed export.
+  env — rnx seeds the JS env from the full shell environment, not just
+    MAESTRO_* (so \${SOOTSIM_*} credentials resolve); a bare \${NAME} that is
+    undefined fails the step loudly instead of typing "undefined".
+
+not yet implemented (will throw "unsupported maestro verb"):
+  travel, setLocation, setAirplaneMode, killApp, faker,
+  addMedia, startRecording, stopRecording (use --record flag),
+  repeat.while (only repeat.times is supported).
+`)
+}
+
+function looksLikeFlag(s: string): boolean {
+  return s.startsWith('-')
+}
+
+// extract --env KEY=VALUE pairs from argv and apply to process.env for the
+// duration of the run. returns argv with the consumed flags removed so the
+// rest can be forwarded to runFlowPlayback verbatim.
+function applyEnvFlags(args: string[]): string[] {
+  const out: string[] = []
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--env' || args[i] === '-e') {
+      const kv = args[i + 1]
+      if (!kv || !kv.includes('=')) {
+        throw new Error(`--env expects KEY=VALUE (got ${JSON.stringify(kv ?? '')})`)
+      }
+      const eq = kv.indexOf('=')
+      const key = kv.slice(0, eq)
+      const value = kv.slice(eq + 1)
+      process.env[key] = value
+      i += 1
+      continue
+    }
+    out.push(args[i])
+  }
+  return out
+}
+
+// Remove Maestro-only flags that the shared runner does not know.
+// these are accepted so users can literally s/maestro/sootsim maestro/ in
+// their scripts without edits.
+function stripUnknownMaestroFlags(args: string[]): string[] {
+  const out: string[] = []
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--format' || a === '--output' || a === '--device' || a === '-d') {
+      i += 1
+      continue
+    }
+    if (a === '--continuous') {
+      // map to --watch for runFlowPlayback's existing watch path if one
+      // exists; today runFlowPlayback has no watch mode, so we drop the
+      // flag and log a warning rather than silently changing behavior.
+      console.warn('  warn: --continuous is not yet implemented in rnx — running once')
+      continue
+    }
+    out.push(a)
+  }
+  return out
+}
+
+function findDefaultMaestroTarget(cwd: string): string | null {
+  for (const dir of MAESTRO_DIRS) {
+    const abs = path.join(cwd, dir)
+    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) return abs
+  }
+  return null
+}
+
+interface MaestroWorkspaceConfig {
+  flows?: string[]
+  includeTags?: string[]
+  excludeTags?: string[]
+}
+
+// workspace planning for directory targets — mirrors maestro's
+// WorkspaceExecutionPlanner: discover config.yaml/config.yml in the
+// directory, walk it recursively for *.yaml/*.yml flow files (config files
+// excluded), keep the ones matching the config's `flows:` globs (default
+// `*` = top level only), then filter by includeTags/excludeTags against
+// each flow's frontmatter `tags:`.
+export function collectFlowFiles(target: string): string[] {
+  const stat = fs.statSync(target)
+  if (stat.isFile()) return [target]
+  if (!stat.isDirectory()) {
+    throw new Error(`not a file or directory: ${target}`)
+  }
+
+  let config: MaestroWorkspaceConfig = {}
+  const configPath = ['config.yaml', 'config.yml']
+    .map((name) => path.join(target, name))
+    .find((p) => fs.existsSync(p))
+  if (configPath) {
+    // yaml.parse returns any; shape-check the fields we use below instead
+    // of trusting the file
+    const parsed = yaml.parse(fs.readFileSync(configPath, 'utf8'))
+    if (parsed && typeof parsed === 'object') {
+      config = parsed
+    }
+  }
+
+  const globs =
+    Array.isArray(config.flows) && config.flows.length > 0 ? config.flows : ['*']
+  const isFlowFile = (rel: string) => {
+    const base = path.basename(rel)
+    if (base.startsWith('.')) return false
+    if (!base.endsWith('.yaml') && !base.endsWith('.yml')) return false
+    if (base === 'config.yaml' || base === 'config.yml') return false
+    return true
+  }
+  const matched = new Set<string>()
+  for (const glob of globs) {
+    for (const rel of fs.globSync(glob, { cwd: target })) {
+      if (!isFlowFile(rel)) continue
+      const abs = path.join(target, rel)
+      if (fs.existsSync(abs) && fs.statSync(abs).isFile()) matched.add(abs)
+    }
+  }
+  let files = [...matched].sort()
+
+  const includeTags = Array.isArray(config.includeTags) ? config.includeTags : []
+  const excludeTags = Array.isArray(config.excludeTags) ? config.excludeTags : []
+  if (includeTags.length > 0 || excludeTags.length > 0) {
+    files = files.filter((file) => {
+      const { frontmatter } = parseFlowFile(fs.readFileSync(file, 'utf8'))
+      const tags: string[] = Array.isArray(frontmatter.tags) ? frontmatter.tags : []
+      if (includeTags.length > 0 && !tags.some((t) => includeTags.includes(t))) {
+        return false
+      }
+      if (tags.some((t) => excludeTags.includes(t))) return false
+      return true
+    })
+  }
+  return files
+}
+
+async function runInit(cwd: string): Promise<number> {
+  const dir = path.join(cwd, '.maestro')
+  fs.mkdirSync(dir, { recursive: true })
+  const outPath = path.join(dir, 'login.yaml')
+  if (fs.existsSync(outPath)) {
+    console.error(`  error: ${outPath} already exists`)
+    return 1
+  }
+  const starter = `# rnxsim maestro starter flow — drop-in compatible with the maestro cli.
+# run: rnxsim maestro test .maestro/login.yaml
+appId: com.example.app
+---
+- launchApp
+- tapOn:
+    id: "email"
+- inputText: "user@example.com"
+- tapOn:
+    id: "password"
+- inputText: "secret123"
+- tapOn: "Sign in"
+- assertVisible: "Welcome"
+`
+  fs.writeFileSync(outPath, starter, 'utf8')
+  console.log(`  + wrote ${outPath}`)
+  console.log(`  next: rnxsim maestro test .maestro/login.yaml`)
+  return 0
+}
+
+export async function runMaestro(
+  args: string[],
+  opts: RunMaestroOptions = {},
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+  if (args.includes('--list-compat')) {
+    printCompatMatrix()
+    return 0
+  }
+
+  let remaining: string[]
+  try {
+    remaining = applyEnvFlags(args)
+  } catch (err) {
+    console.error(`  error: ${(err as Error).message}`)
+    return 1
+  }
+  // bin.ts prepends the global `--sim <id>` to argv. without hoisting it
+  // out, `remaining[0]` is `--sim` instead of the `test` subcommand, so
+  // maestro auto-discovered a default flow and forwarded `--sim`/`test`/
+  // the path as bogus flow args — the explicit sim was silently dropped
+  // (QA F21-4). hoist it to the tail so it still rides into forwardArgs →
+  // runFlowPlayback, where parseBridgeCliArgs sees simIdSource === 'flag'.
+  remaining = hoistLeadingSimFlag(remaining)
+
+  const cwd = process.cwd()
+  const sub = remaining[0]
+
+  if (sub === 'init') {
+    return runInit(cwd)
+  }
+  if (sub === 'generate') {
+    const { runMaestroGenerate } = await import('./maestro-generate')
+    return runMaestroGenerate(remaining.slice(1))
+  }
+  if (
+    sub === 'start' ||
+    sub === 'keep' ||
+    sub === 'good' ||
+    sub === 'end' ||
+    sub === 'validate'
+  ) {
+    return runMaestroAuthoring(remaining)
+  }
+  remaining = stripUnknownMaestroFlags(remaining)
+
+  // resolve the target flow file or directory.
+  let target: string | null = null
+  let forwardArgs: string[]
+
+  if (sub === 'test') {
+    // `sootsim maestro test <flow-or-dir> [flags...]`
+    const positional = remaining.slice(1).find((a) => !looksLikeFlag(a))
+    if (positional) {
+      target = path.resolve(cwd, positional)
+      forwardArgs = remaining.slice(1).filter((a) => a !== positional)
+    } else {
+      target = findDefaultMaestroTarget(cwd)
+      forwardArgs = remaining.slice(1)
+    }
+  } else if (sub && !looksLikeFlag(sub)) {
+    // `sootsim maestro <flow-or-dir>` — tolerate the shorthand.
+    target = path.resolve(cwd, sub)
+    forwardArgs = remaining.slice(1)
+  } else {
+    // no positional — auto-discover.
+    target = findDefaultMaestroTarget(cwd)
+    forwardArgs = remaining
+  }
+
+  if (!target) {
+    console.error(`
+  error: no maestro flows found.
+  expected one of: ${MAESTRO_DIRS.map((d) => `./${d}/`).join(', ')}
+  or pass a flow explicitly:    rnxsim maestro test path/to/flow.yaml
+  or scaffold a starter flow:   rnxsim maestro init
+`)
+    return 1
+  }
+
+  if (!fs.existsSync(target)) {
+    console.error(`  error: ${target} not found`)
+    return 1
+  }
+
+  let files: string[]
+  try {
+    files = collectFlowFiles(target)
+  } catch (err) {
+    console.error(`  error: ${(err as Error).message}`)
+    return 1
+  }
+
+  if (files.length === 0) {
+    console.error(`  error: no *.yaml or *.yml files found in ${target}`)
+    return 1
+  }
+
+  console.log(`
+  rnxsim maestro — ${files.length} flow${files.length === 1 ? '' : 's'}
+  root: ${path.relative(cwd, target) || '.'}
+`)
+
+  // registration target for hosted run rows — resolved once per invocation.
+  const auth = resolveCliAuth()
+  const flagValue = (name: string) => {
+    const index = forwardArgs.indexOf(name)
+    return index >= 0 ? forwardArgs[index + 1] : undefined
+  }
+  // only `registerRun` below consumes this, and only for runs that register.
+  // resolving it up front probed https://contrast.localhost:3000 and blocked
+  // every flow — including ones that upload and register nothing — for the
+  // probe's full 2s timeout whenever no local Contrast stack was listening.
+  // resolve on first use instead, and keep the one probe per invocation.
+  let registerOriginPromise: Promise<string> | null = null
+  const registerOrigin = () =>
+    (registerOriginPromise ??= resolveDefaultUploadOrigin(
+      flagValue('--preview-origin') ?? flagValue('--origin'),
+    ))
+
+  let worstExit = 0
+  const results: Array<{ file: string; exit: number }> = []
+  for (const file of files) {
+    console.log(`\n  ▶ ${path.relative(cwd, file)}`)
+    const playbackArgs = [file, ...forwardArgs]
+    // `--port` is the BRIDGE port everywhere else in the CLI, so forward it as
+    // one. sending it on as `--url` made it an app target instead, which left
+    // the playback bridge on whichever world resolveBridgeWorld picks by
+    // default (a live Vite dev shell selected from the development registry).
+    // so `sootsim --port <installed daemon> maestro …` silently ran the flow
+    // against the dev engine, then failed trying to resolve a bundle at the
+    // bridge port. an explicit command-level `--port` still wins, since
+    // parseBridgeCliArgs takes the last occurrence.
+    if (opts.port) {
+      playbackArgs.push('--port', String(opts.port))
+    }
+    let exit = 0
+    const startedAt = Date.now()
+    try {
+      exit = await runFlowPlayback(playbackArgs)
+    } catch (err) {
+      console.error(`  x ${(err as Error).message}`)
+      exit = 1
+    }
+    results.push({ file, exit })
+    if (exit !== 0 && worstExit === 0) worstExit = exit
+
+    const upload = getLastFlowPreviewUploadResult()
+    if (shouldRegisterRun({ uploadedShare: Boolean(upload), auth })) {
+      const traceSteps = getLastFlowTraceSteps()
+      const failedStep = traceSteps.find((step) => step.status === 'failure')
+      const run = await registerRun({
+        origin: await registerOrigin(),
+        kind: 'maestro',
+        name: path.relative(cwd, file),
+        status: exit === 0 ? 'passed' : 'failed',
+        failureMessage: exit === 0 ? null : (failedStep?.error ?? 'flow playback failed'),
+        previewShareId: upload?.shareId ?? null,
+        owner: flagValue('--owner') ?? null,
+        repo: flagValue('--repo') ?? null,
+        durationMs: Date.now() - startedAt,
+        ...stepSummaryFromTrace(traceSteps),
+        auth,
+      })
+      if (run) {
+        console.log(`  run: ${run.id}${run.traceUrl ? ` · replay: ${run.traceUrl}` : ''}`)
+      }
+    }
+  }
+
+  if (files.length > 1) {
+    console.log(`\n  maestro summary:`)
+    for (const r of results) {
+      const label = r.exit === 0 ? 'pass' : 'fail'
+      console.log(`    ${label}  ${path.relative(cwd, r.file)}`)
+    }
+    const passed = results.filter((r) => r.exit === 0).length
+    console.log(`  ${passed}/${results.length} passed`)
+  }
+
+  return worstExit
+}

package/cli/commands/mode.ts

@@ -0,0 +1,57 @@
+import { runScreenshotMode } from './screenshot-mode'
+import { runThreeMode } from './three-mode'
+
+interface ModeOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const VALUE_FLAGS = new Set(['--sim', '--port', '-p'])
+const SUBCOMMANDS = new Set(['screenshot', 'three'])
+
+function findSubcommand(args: string[]): { name: string; index: number } | null {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('-')) {
+      if (VALUE_FLAGS.has(arg)) i++
+      continue
+    }
+    return SUBCOMMANDS.has(arg) ? { name: arg, index: i } : null
+  }
+  return null
+}
+
+function withoutSubcommand(args: string[], index: number): string[] {
+  return [...args.slice(0, index), ...args.slice(index + 1)]
+}
+
+function printHelp(): void {
+  console.log(`
+rnxsim mode — toggle live display modes
+
+usage:
+  rnxsim mode screenshot [on|off|toggle]
+  rnxsim mode three [on|off|toggle]
+  rnxsim mode three configure [options]
+`)
+}
+
+export async function runMode(args: string[], opts: ModeOptions): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const sub = findSubcommand(args)
+  if (!sub) {
+    printHelp()
+    process.exit(1)
+  }
+
+  const rest = withoutSubcommand(args, sub.index)
+  if (sub.name === 'screenshot') {
+    await runScreenshotMode(rest, opts)
+    return
+  }
+  await runThreeMode(rest, opts)
+}

package/cli/commands/no-bridge-hint.ts

@@ -0,0 +1,80 @@
+// shared hint printed when the CLI has no bridge or no desktop companion.
+
+import { findDesktopCompanion } from '../desktop-companion'
+import type { BridgeSimInfo } from '../ws-bridge'
+
+export function printMissingCompanionHint() {
+  console.error('  no rnxsim desktop companion found.')
+  console.error('')
+  console.error('  install the desktop app:')
+  console.error('    rnxsim desktop install')
+  console.error('')
+  console.error('  or run setup to install the background daemon:')
+  console.error('    rnxsim setup')
+  console.error('')
+}
+
+export function printMissingBridgeHint(port: number) {
+  const companion = findDesktopCompanion()
+  console.log(`  note: no rnx bridge detected on port ${port}`)
+  if (companion) {
+    console.log(`  launch the installed companion with:`)
+    console.log(`    rnxsim desktop`)
+    return
+  }
+  console.log('')
+  console.log('  run `rnxsim setup` to install the background daemon,')
+  console.log('  or run `rnxsim serve` in another shell for a foreground bridge.')
+}
+
+export function printMissingSimHint(port: number) {
+  console.error('')
+  console.error(`  no sim is connected to the rnx bridge on port ${port}.`)
+  console.error('')
+  console.error('  start your app dev server, then open it in rnx:')
+  console.error('    npx expo start --localhost --port 8081')
+  console.error('    rnxsim open 8081')
+  console.error('')
+  console.error('  then inspect the live app:')
+  console.error('    rnxsim describe')
+}
+
+// printed when a command targeted a specific `--sim <id>` that the bridge
+// does not know — distinct from printMissingSimHint, which assumes the bridge
+// has no sims at all. when other sims *are* connected, "no sim is connected"
+// is a flat-out lie; list the valid ids instead so the user can pick one.
+export async function printUnknownSimHint(
+  bridge: { listSims: () => Promise<BridgeSimInfo[]> },
+  port: number,
+  requestedId: string,
+) {
+  let sims: BridgeSimInfo[] = []
+  try {
+    sims = await bridge.listSims()
+  } catch {
+    // bridge unreachable while reporting — fall through to the generic hint
+  }
+  console.error('')
+  if (sims.length === 0) {
+    printMissingSimHint(port)
+    return
+  }
+  console.error(
+    `  no sim with id "${requestedId}" is connected to the bridge on port ${port}.`,
+  )
+  console.error('')
+  console.error('  connected sims:')
+  for (const sim of sims) {
+    const flags = [
+      sim.isPrimary ? 'primary' : null,
+      sim.readyState,
+      sim.userVisible === false ? 'hidden' : sim.userVisible === true ? 'visible' : null,
+      sim.userFocused ? 'focused' : null,
+    ]
+      .filter(Boolean)
+      .join(', ')
+    console.error(`    ${sim.id}  (${flags})`)
+  }
+  console.error('')
+  console.error('  pass a valid --sim id, or run `rnxsim list` to see all sessions.')
+}

package/cli/commands/perf.ts

@@ -0,0 +1,66 @@
+import { runCpuProfile } from './cpu-profile'
+import { runInspect } from './inspect'
+import { runReact } from './react'
+
+interface PerfOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const VALUE_FLAGS = new Set(['--sim', '--port', '-p'])
+const SUBCOMMANDS = new Set(['cpu', 'react', 'shell', 'scroll'])
+
+function findSubcommand(args: string[]): { name: string; index: number } | null {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('-')) {
+      if (VALUE_FLAGS.has(arg)) i++
+      continue
+    }
+    return SUBCOMMANDS.has(arg) ? { name: arg, index: i } : null
+  }
+  return null
+}
+
+function withoutSubcommand(args: string[], index: number): string[] {
+  return [...args.slice(0, index), ...args.slice(index + 1)]
+}
+
+function printHelp(): void {
+  console.log(`
+rnxsim perf — performance profiling tools
+
+usage:
+  rnxsim perf cpu [options]
+  rnxsim perf react <subcommand> [options]
+  rnxsim perf shell <start|stop|transition> [options]
+  rnxsim perf scroll <start|stop> [options]
+
+examples:
+  rnxsim perf cpu --duration 5 --output /tmp/trace.cpuprofile
+  rnxsim perf react summary --limit 10
+  rnxsim perf shell start
+  rnxsim perf shell stop --json
+  rnxsim perf scroll start
+  rnxsim perf scroll stop --json
+`)
+}
+
+export async function runPerf(args: string[], opts: PerfOptions): Promise<number> {
+  const sub = findSubcommand(args)
+  if (!sub) {
+    printHelp()
+    return args.includes('--help') || args.includes('-h') ? 0 : 1
+  }
+
+  const rest = withoutSubcommand(args, sub.index)
+  if (sub.name === 'cpu') return runCpuProfile(rest, opts)
+  if (sub.name === 'react') return runReact(rest, opts)
+
+  const inspectArgs = rest.includes('--help') || rest.includes('-h') ? [] : rest
+  await runInspect(['debug', 'perf', ...inspectArgs], {
+    ...opts,
+    internalPerfCommand: sub.name === 'scroll' ? 'scroll' : 'shell',
+  })
+  return typeof process.exitCode === 'number' ? process.exitCode : 0
+}