peachsim 0.1.527 → 0.1.571

package/cli/cloud-test-tunnel.ts

@@ -0,0 +1,354 @@
+// rnx test --cloud live-dev-stack publisher (tunnel CLI half).
+//
+// when --app names a live packager (http loopback) instead of a prebuilt
+// bundle, the submitter publishes that stack through a token-gated
+// cloudflared quick tunnel and submits the tunnel origin plus the mode-2
+// fields (hostHeader, jobToken, sidecarPorts). the recorder projects the
+// origin back to loopback (scripts/runner/sootsim-recorder.ts), so flows
+// keep their unmodified localhost authorities.
+//
+// the handshake mirrors packages/contrast-runner/src/hosted.ts, which this
+// published package cannot import: Bearer-gated proxy between cloudflared
+// and the dev server, --http-host-header on the dev authority, forwarded
+// headers stripped so Metro emits loopback authorities the recorder
+// mirrors. header names must match hostedPorts.ts and loopback-proxy.mjs.
+
+import { spawn, spawnSync, type ChildProcess } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs'
+import { createServer, request as httpRequest } from 'node:http'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+// must match packages/contrast-runner/src/hostedPorts.ts.
+const UPSTREAM_PORT_HEADER = 'x-contrast-upstream-port'
+const APPLICATION_AUTH_HEADER = 'x-contrast-application-authorization'
+const MAX_SIDECAR_PORTS = 8
+
+export type CloudTestSidecarResult =
+  | { ok: true; ports: number[] }
+  | { ok: false; message: string }
+
+// same grammar as the jobs API (parseHostedSidecarPorts): comma-separated
+// ports 1-65535, at most 8, deduped, primary excluded.
+export function parseCloudTestSidecarPorts(
+  value: string | null | undefined,
+  primaryPort?: number,
+): CloudTestSidecarResult {
+  if (!value?.trim()) return { ok: true, ports: [] }
+  const values = value.split(',').map((part) => part.trim())
+  if (values.length > MAX_SIDECAR_PORTS) {
+    return {
+      ok: false,
+      message: `sidecar-ports accepts at most ${MAX_SIDECAR_PORTS} ports`,
+    }
+  }
+  const ports: number[] = []
+  for (const raw of values) {
+    if (!/^[1-9][0-9]{0,4}$/.test(raw)) {
+      return {
+        ok: false,
+        message: 'sidecar-ports must be a comma-separated list of ports from 1 to 65535',
+      }
+    }
+    const port = Number(raw)
+    if (port > 65_535) {
+      return {
+        ok: false,
+        message: 'sidecar-ports must be a comma-separated list of ports from 1 to 65535',
+      }
+    }
+    if (port !== primaryPort && !ports.includes(port)) ports.push(port)
+  }
+  return { ok: true, ports }
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  return (
+    hostname === 'localhost' ||
+    hostname === '127.0.0.1' ||
+    hostname === '[::1]' ||
+    hostname === '::1'
+  )
+}
+
+// a live dev stack is an http(s) loopback URL: the packager the recorder
+// cannot reach directly. https loopback is accepted for tunnels that
+// terminate TLS locally; everything else (files, https remotes, share ids)
+// stays on the prebuilt path.
+export function parseLiveDevStackApp(app: string): { port: number } | null {
+  if (!app.startsWith('http://') && !app.startsWith('https://')) return null
+  let url: URL
+  try {
+    url = new URL(app)
+  } catch {
+    return null
+  }
+  if (!isLoopbackHostname(url.hostname)) return null
+  const port = Number(url.port)
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) return null
+  return { port }
+}
+
+function resolveUpstreamPort(
+  value: string | string[] | undefined,
+  primaryPort: number,
+  sidecarPorts: readonly number[],
+): number | null {
+  if (value === undefined) return primaryPort
+  if (Array.isArray(value) || !/^[1-9][0-9]{0,4}$/.test(value)) return null
+  const port = Number(value)
+  return sidecarPorts.includes(port) ? port : null
+}
+
+// Bearer-gating reverse proxy between cloudflared and the dev server.
+// rejects without the per-job token; strips cloudflared forwarding headers
+// so Metro builds absolute URLs on the dev authority the recorder mirrors.
+export function startCloudTestTokenProxy(
+  listenPort: number,
+  upstreamPort: number,
+  sidecarPorts: readonly number[],
+  token: string,
+): Promise<{ close: () => void } | null> {
+  const server = createServer((req, res) => {
+    const auth = req.headers.authorization || ''
+    if (auth !== `Bearer ${token}`) {
+      res.writeHead(401, { 'content-type': 'text/plain' })
+      res.end('unauthorized')
+      return
+    }
+    const headers = { ...req.headers }
+    const applicationAuthorization = headers[APPLICATION_AUTH_HEADER]
+    delete headers[APPLICATION_AUTH_HEADER]
+    delete headers.authorization
+    if (typeof applicationAuthorization === 'string') {
+      headers.authorization = applicationAuthorization
+    }
+    const selectedPort = resolveUpstreamPort(
+      headers[UPSTREAM_PORT_HEADER],
+      upstreamPort,
+      sidecarPorts,
+    )
+    delete headers[UPSTREAM_PORT_HEADER]
+    if (selectedPort === null) {
+      res.writeHead(403, { 'content-type': 'text/plain' })
+      res.end('upstream port is not enabled for this run')
+      return
+    }
+    if (selectedPort !== upstreamPort) headers.host = `127.0.0.1:${selectedPort}`
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase()
+      if (lower.startsWith('x-forwarded-') || lower.startsWith('cf-')) {
+        delete headers[key]
+      }
+    }
+    const up = httpRequest(
+      {
+        host: '127.0.0.1',
+        port: selectedPort,
+        path: req.url,
+        method: req.method,
+        headers,
+      },
+      (upRes) => {
+        res.writeHead(upRes.statusCode || 502, upRes.headers)
+        upRes.pipe(res)
+      },
+    )
+    up.on('error', (err) => {
+      res.writeHead(502, { 'content-type': 'text/plain' })
+      res.end(`upstream error: ${err.message}`)
+    })
+    req.pipe(up)
+  })
+  return new Promise((resolve) => {
+    server.on('error', () => resolve(null))
+    server.listen(listenPort, '127.0.0.1', () => {
+      resolve({ close: () => server.close() })
+    })
+  })
+}
+
+function cloudflaredAvailable(): boolean {
+  const probe = spawnSync('cloudflared', ['--version'], { stdio: 'ignore' })
+  return probe.status === 0
+}
+
+async function ensureCloudflared(): Promise<boolean> {
+  if (cloudflaredAvailable()) return true
+  const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' }
+  const arch = archMap[process.arch]
+  const osMap: Record<string, string> = { linux: 'linux', darwin: 'darwin' }
+  const os = osMap[process.platform]
+  if (!arch || !os) return false
+  const dest = join(tmpdir(), 'rnx-cloudflared')
+  const binary = join(dest, 'cloudflared')
+  if (existsSync(binary)) {
+    process.env.PATH = `${dest}:${process.env.PATH ?? ''}`
+    return cloudflaredAvailable()
+  }
+  // linux publishes a bare binary; darwin publishes a tarball.
+  const asset =
+    os === 'darwin' ? `cloudflared-${os}-${arch}.tgz` : `cloudflared-${os}-${arch}`
+  try {
+    const res = await fetch(
+      `https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`,
+    )
+    if (!res.ok) return false
+    mkdirSync(dest, { recursive: true })
+    if (os === 'darwin') {
+      const tgz = join(dest, asset)
+      writeFileSync(tgz, Buffer.from(await res.arrayBuffer()))
+      const untar = spawnSync('tar', ['-xzf', tgz, '-C', dest])
+      try {
+        unlinkSync(tgz)
+      } catch {}
+      if (untar.status !== 0 || !existsSync(binary)) return false
+    } else {
+      writeFileSync(binary, Buffer.from(await res.arrayBuffer()))
+    }
+  } catch {
+    return false
+  }
+  chmodSync(binary, 0o755)
+  process.env.PATH = `${dest}:${process.env.PATH ?? ''}`
+  return cloudflaredAvailable()
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function childAlive(child: ChildProcess): boolean {
+  return child.exitCode === null && child.signalCode === null
+}
+
+async function launchQuickTunnel(
+  originUrl: string,
+  hostHeader: string,
+  logFile: string,
+): Promise<{ url: string; child: ChildProcess } | null> {
+  writeFileSync(logFile, '')
+  const child = spawn(
+    'cloudflared',
+    [
+      'tunnel',
+      '--url',
+      originUrl,
+      '--http-host-header',
+      hostHeader,
+      '--protocol',
+      'http2',
+      '--no-autoupdate',
+    ],
+    { stdio: ['ignore', 'pipe', 'pipe'] },
+  )
+  // cloudflared logs the tunnel URL to stderr; mirror both streams into the
+  // log file and poll it for the trycloudflare origin.
+  const lines: string[] = []
+  child.stderr?.on('data', (chunk) => {
+    lines.push(String(chunk))
+    writeFileSync(logFile, lines.join(''))
+  })
+  child.stdout?.on('data', (chunk) => {
+    lines.push(String(chunk))
+    writeFileSync(logFile, lines.join(''))
+  })
+  for (let i = 0; i < 60; i++) {
+    let text = ''
+    try {
+      text = readFileSync(logFile, 'utf8')
+    } catch {
+      text = ''
+    }
+    const match = text.match(/https:\/\/[-a-z0-9]+\.trycloudflare\.com/g)
+    const url = match?.[match.length - 1]
+    if (url) return { url, child }
+    if (!childAlive(child)) return null
+    await sleep(1000)
+  }
+  child.kill()
+  return null
+}
+
+export interface PublishedLiveDevStack {
+  targetUrl: string
+  hostHeader: string
+  jobToken: string
+  sidecarPorts: number[]
+  close: () => void
+}
+
+// publish a live dev stack for one hosted test run. the caller keeps the
+// returned tunnel open until the job reaches a terminal state, then closes
+// it. throws on any setup failure with a message the CLI prints.
+export async function publishLiveDevStack(args: {
+  devPort: number
+  sidecarPorts: readonly number[]
+}): Promise<PublishedLiveDevStack> {
+  const { devPort, sidecarPorts } = args
+  const jobToken = randomBytes(16).toString('hex')
+  // free loopback port for the token proxy; the advertised authority stays
+  // the dev server's own port so Metro URLs resolve on the recorder.
+  const { Server } = await import('node:net')
+  const proxyPort = await new Promise<number>((resolve, reject) => {
+    const probe = new Server()
+    probe.once('error', reject)
+    probe.listen(0, '127.0.0.1', () => {
+      const address = probe.address()
+      const port = address && typeof address === 'object' ? address.port : 0
+      probe.close(() => resolve(port))
+    })
+  })
+  if (!proxyPort) throw new Error('could not allocate a tunnel proxy port')
+  const proxy = await startCloudTestTokenProxy(proxyPort, devPort, sidecarPorts, jobToken)
+  if (!proxy) {
+    throw new Error(`could not start the tunnel token proxy on 127.0.0.1:${proxyPort}`)
+  }
+  const closeProxy = proxy.close
+  const hostHeader = `127.0.0.1:${devPort}`
+  if (!(await ensureCloudflared())) {
+    closeProxy()
+    throw new Error(
+      'cloudflared is required for live dev stacks (rnx test --cloud with http://localhost:<port>). install it or check your network.',
+    )
+  }
+  const logFile = join(tmpdir(), `rnx-test-tunnel-${Date.now()}-${proxyPort}.log`)
+  const tunnel = await launchQuickTunnel(
+    `http://127.0.0.1:${proxyPort}`,
+    hostHeader,
+    logFile,
+  )
+  if (!tunnel) {
+    closeProxy()
+    let tail = ''
+    try {
+      tail = readFileSync(logFile, 'utf8').slice(-500)
+    } catch {
+      tail = ''
+    }
+    throw new Error(
+      `could not establish the cloudflared tunnel for the live dev stack${tail ? `: ${tail.trim().split('\n').pop()}` : ''}`,
+    )
+  }
+  let closed = false
+  return {
+    targetUrl: tunnel.url,
+    hostHeader,
+    jobToken,
+    sidecarPorts: [...sidecarPorts],
+    close: () => {
+      if (closed) return
+      closed = true
+      tunnel.child.kill()
+      closeProxy()
+    },
+  }
+}

package/cli/commands/box/bundle-plane.ts

@@ -8,8 +8,8 @@
 // the bundle is split here rather than by the caller, so the one place that
 // decides where the parts go is the one place that decides how big they are.
 
-import { PREBUILT_BUNDLE_PART_BYTES, prebuiltBundlePartPath } from '@rnx/box/template'
-import type { ProjectFileMeta, ProjectFilePlane } from '@rnx/box/plane'
+import { PREBUILT_BUNDLE_PART_BYTES, prebuiltBundlePartPath } from '@peach/box/template'
+import type { ProjectFileMeta, ProjectFilePlane } from '@peach/box/plane'
 
 export class BundleFilePlane implements ProjectFilePlane {
   private readonly parts = new Map<string, Uint8Array>()

package/cli/commands/box/checkout-plane.ts

@@ -12,7 +12,7 @@
 import { execFileSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
-import type { ProjectFileMeta, ProjectFilePlane } from '@rnx/box/plane'
+import type { ProjectFileMeta, ProjectFilePlane } from '@peach/box/plane'
 
 export class CheckoutRequiresGitError extends Error {}
 

package/cli/commands/box/rnx-command.ts

@@ -8,8 +8,8 @@
 
 import { spawn } from 'node:child_process'
 import path from 'node:path'
-import { defineCommand, type CustomCommand } from '@rnx/box/shell'
-import { PROJECT_MOUNT } from '@rnx/box/shell'
+import { defineCommand, type CustomCommand } from '@peach/box/shell'
+import { PROJECT_MOUNT } from '@peach/box/shell'
 import { rnxPublicBrand } from '../../../src/public-brand'
 import { rnxSelfInvocation } from '../../self-invocation'
 import { RNX_PLACEMENT_ENV } from '../../ws-bridge'

package/cli/commands/box/search-command.ts

@@ -32,8 +32,8 @@
 // whose "no match here" had to be merged.
 
 import { spawn } from 'node:child_process'
-import { defineCommand, type CustomCommand } from '@rnx/box/shell'
-import { PROJECT_MOUNT } from '@rnx/box/shell'
+import { defineCommand, type CustomCommand } from '@peach/box/shell'
+import { PROJECT_MOUNT } from '@peach/box/shell'
 
 // generous next to a 414ms p95: this bounds a wedged child, it does not cut off
 // a large search.

package/cli/commands/box.ts

@@ -13,23 +13,23 @@
 import { spawn } from 'node:child_process'
 import path from 'node:path'
 import { createInterface } from 'node:readline'
-import { BoxClientError, createBoxClient } from '@rnx/box/client'
-import { createBoxHostProvider } from '@rnx/box/host'
-import { PROJECT_MOUNT } from '@rnx/box/shell'
-import { terminalBoxStack } from '@rnx/box/stack'
+import { BoxClientError, createBoxClient } from '@peach/box/client'
+import { createBoxHostProvider } from '@peach/box/host'
+import { PROJECT_MOUNT } from '@peach/box/shell'
+import { terminalBoxStack } from '@peach/box/stack'
 import {
   BoxTemplateRegistry,
   prebuiltBundleBoxTemplate,
   sourceControlBoxTemplate,
   terminalBoxTemplate,
-} from '@rnx/box/template'
+} from '@peach/box/template'
 import {
   cloudBoxConnectUrl,
   createCloudBoxProvider,
   ensureCloudBoxBrowser,
   heartbeatSession,
   resolveCloudBoxReference,
-} from 'rnx-cloud-box/client'
+} from 'peach-cloud-box/client'
 import { readDefaultBox, writeDefaultBox } from '../../src/home-paths'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { authHeaderOrExit, cloudAccountIdOrExit, type CliAuth } from '../auth'
@@ -41,8 +41,8 @@ import { CheckoutFilePlane, CheckoutRequiresGitError } from './box/checkout-plan
 import { sharePlane } from './box/plane-share'
 import { createRnxCommand } from './box/rnx-command'
 import { createSearchCommand } from './box/search-command'
-import type { BoxShellSession } from '@rnx/box/client'
-import type { BoxTemplateResolution } from '@rnx/box/template'
+import type { BoxShellSession } from '@peach/box/client'
+import type { BoxTemplateResolution } from '@peach/box/template'
 
 interface BoxCommandOptions {
   port?: number

package/cli/commands/compat.ts

@@ -8,7 +8,7 @@ import {
   formatScanCounts,
   scanDeps,
   type ScanResult,
-} from '@sootsim/compat/web'
+} from '@peach/compat/web'
 import { findProjectRoot, scanWorkspace } from './detect'
 
 interface PackageManifest {

package/cli/commands/control.ts

@@ -6,7 +6,7 @@ import {
   devices,
   listSelectableDeviceModels,
   type DeviceModel,
-} from 'sootsim-engine/settings'
+} from 'peach-engine/settings'
 import { WebSocket } from 'ws'
 import { probePort } from '../../scripts/dev-server-scanner'
 import { isAppDeepLinkTarget, openAppUrl } from '../../src/app-url'
@@ -425,14 +425,20 @@ async function resolveConnectionInputForCli(target: string): Promise<ResolvedDev
     try {
       return await resolveConnectionInput(normalized)
     } catch (error) {
-      if (!(error instanceof Error) || !error.message.startsWith("could not resolve a native bundle")) {
+      if (
+        !(error instanceof Error) ||
+        !error.message.startsWith('could not resolve a native bundle')
+      ) {
         throw error
       }
       lastError = error
     }
     await sleep(DEV_BUNDLE_RESOLVE_INTERVAL_MS)
   }
-  throw lastError ?? new Error("could not resolve a native bundle for " + normalized + " after retrying.")
+  throw (
+    lastError ??
+    new Error('could not resolve a native bundle for ' + normalized + ' after retrying.')
+  )
 }
 
 function getShellRoutePrefix(pathname: string): string {
@@ -1368,6 +1374,19 @@ export async function runOpenCommand(
   }
   const target = parsed.positional[0] || ''
 
+  // `--port` is the WS BRIDGE port; the app/dev-server port is positional. the
+  // two read identically at a glance, so `rnx open --new --port 4260` used to
+  // launch the Connect launcher against the default bridge and report success,
+  // and the probe that followed measured whatever sim happened to be selected.
+  // there is no meaningful `open --port` without a target, so refuse it.
+  if (!target && args.includes('--port')) {
+    const portValue = args[args.indexOf('--port') + 1] ?? '<number>'
+    console.error(
+      `  rnx open: --port is the WS bridge port, not the app port. to open the app on ${portValue}, pass it positionally: \`rnx open ${portValue}\``,
+    )
+    rnxExit(1)
+  }
+
   if (isAppDeepLinkTarget(target)) {
     if (openInNewSim) {
       console.error(

package/cli/commands/detox.ts

@@ -433,7 +433,7 @@ function initDetoxProject(): void {
 
 /** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
-  preset: 'rnxsim/detox',
+  preset: 'peachsim/detox',
   rootDir: __dirname,
   testMatch: ['<rootDir>/e2e/**/*.test.ts', '<rootDir>/e2e/**/*.test.js'],
 }

package/cli/commands/device.ts

@@ -3,7 +3,7 @@ import {
   getDevice,
   listSelectableDeviceModels,
   type DeviceModel,
-} from 'sootsim-engine/settings'
+} from 'peach-engine/settings'
 import { rnxExit } from '../run-rnx'
 import {
   callInBridge,

package/cli/commands/diagnose.ts

@@ -32,7 +32,7 @@ import type {
   SootSimTimelineEvent,
   SootSimTimelineQuery,
   SootSimTimelineQueryResult,
-} from '@rnx/globals'
+} from '@peach/globals'
 
 interface DiagnoseOptions {
   port?: number

package/cli/commands/film.ts

@@ -148,7 +148,7 @@ examples:
     )
     if (!started) {
       console.error(
-        '  film: engine recording store did not start (is @rnx/plugin-recording installed?)',
+        '  film: engine recording store did not start (is @peach/plugin-recording installed?)',
       )
       return 1
     }

package/cli/commands/flow.ts

@@ -58,6 +58,8 @@ const FLOW_BOOLEAN_FLAGS = [
   '--proof',
   '--no-shell',
   '--shell-only',
+  '--dry-run',
+  '--no-run',
 ]
 
 const FLOW_VALUE_FLAGS = [
@@ -210,12 +212,14 @@ rnx maestro — author and run Maestro YAML flows
 
 usage:
   rnx maestro test <flow.yaml> [options]
+  rnx maestro load <flow.yaml> [options]
   rnx maestro start
   rnx maestro keep
   rnx maestro end [--output <path>] [--validate] [--video]
   rnx maestro validate <path>
 
 options:
+  --dry-run, --no-run  load flow into the runner idle without executing steps
   --record             record a webm artifact while the flow runs
   --profile            capture perf stats while the flow runs
   --out <dir>          output directory (default: /tmp/rnx-recordings)
@@ -621,7 +625,10 @@ flow extension:
     // pr-preview run, so allow it for preview uploads. local flow recording
     // writes a file and matches `rnx record --mode video`.
     allowGitHubRecording: preview,
-    requireRecordingEntitlement: preview,
+    // a test_run bills its recording from balance at finalize (preflighted
+    // at upload init), not from a plan entitlement: the plan gate would
+    // refuse every pay-as-you-go hosted test.
+    requireRecordingEntitlement: preview && previewBillingKind !== 'test_run',
     // 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 (simId) => {
@@ -665,6 +672,7 @@ flow extension:
   let previewScreenshotPath: string | null = null
   let failureBundleDir: string | null = null
   let exitCode = 0
+  const dryRun = args.includes('--dry-run') || args.includes('--no-run')
   const startsWithLaunchApp = !!steps[0]?.launchApp
   try {
     if (!startsWithLaunchApp) {
@@ -694,7 +702,21 @@ flow extension:
     if (preview && !startsWithLaunchApp && !process.env.RNX_PREVIEW_RESET_DONE) {
       await driver.launchApp({ clearState: true })
     }
-    if (record) {
+    if (dryRun) {
+      await driver.planFlow(steps, { dryRun: true })
+      console.log(
+        `[flow] flow loaded (${steps.length} steps) — waiting for play in test runner…`,
+      )
+      await driver.liveStatus?.waitForStart()
+      console.log('[flow] starting flow playback…')
+      if (record) {
+        if (startsWithLaunchApp) {
+          driver.prepareRecording()
+        } else {
+          await driver.startRecording()
+        }
+      }
+    } else if (record) {
       if (startsWithLaunchApp) {
         driver.prepareRecording()
       } else {
@@ -723,7 +745,7 @@ flow extension:
         )
       }
     }
-    await driver.runFlow(steps)
+    await driver.runFlow(steps, { skipPlan: dryRun })
     if (profile) {
       profileResult = await driver.stopProfile()
     }
@@ -923,6 +945,41 @@ flow extension:
     }
   }
 
+  if (dryRun) {
+    console.log('[flow] run completed — waiting for reset or new action in test runner…')
+    while (true) {
+      const action = await driver.liveStatus?.waitForResetOrRerun()
+      if (action === 'reset') {
+        console.log('[flow] reset requested from devtools — resetting runner state')
+        driver.resetFlowState()
+        await driver.planFlow(steps, { dryRun: true })
+        console.log('[flow] flow reloaded — waiting for play in test runner…')
+        await driver.liveStatus?.waitForStart()
+        console.log('[flow] re-running flow playback…')
+        try {
+          await driver.runFlow(steps, { skipPlan: true })
+          await driver.liveStatus?.end('passed')
+          console.log('\n  + completed replay successfully\n')
+        } catch (replayErr: any) {
+          console.error(`\n  x failed replay: ${replayErr?.message || replayErr}\n`)
+          await driver.liveStatus?.end('failed')
+        }
+      } else if (action === 'start') {
+        console.log('[flow] play requested from devtools — re-running flow playback…')
+        try {
+          await driver.runFlow(steps, { skipPlan: true })
+          await driver.liveStatus?.end('passed')
+          console.log('\n  + completed replay successfully\n')
+        } catch (replayErr: any) {
+          console.error(`\n  x failed replay: ${replayErr?.message || replayErr}\n`)
+          await driver.liveStatus?.end('failed')
+        }
+      } else {
+        break
+      }
+    }
+  }
+
   lastFlowTraceSteps = driver.getFlowTraceSteps()
 
   bridge.close()

package/cli/commands/inspect/actions.ts

@@ -2,7 +2,7 @@ import { inspectTree, type InspectBridge } from './core'
 import { resolveTargetCoords, type ResolvedTargetCoords } from './resolve-target'
 import { waitForSootsimIdle } from './settling'
 import type { SimSemanticNode } from '../../../src/bridge-contract'
-import type { SootSimReplayTarget } from '@rnx/globals'
+import type { SootSimReplayTarget } from '@peach/globals'
 
 export type TapFailure = 'not-found' | 'missed' | 'special'