peachsim 0.1.527

package/cli/app-splash.ts

@@ -0,0 +1,171 @@
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import {
+  configPluginSplashFromExpoConfig,
+  type ConfigPluginSplashSpec,
+} from 'sootsim-engine/engine/config-plugin-splash'
+import { resolveAppProject } from './app-project'
+
+const require = createRequire(import.meta.url)
+
+// the filesystem scan and the engine's metro-manifest scan share the same
+// parser (config-plugin-splash.ts) and produce the same resolved spec.
+export type DiscoveredAppSplashSpec = ConfigPluginSplashSpec
+
+type ExpoConfigGetter = (dir: string, opts: Record<string, unknown>) => { exp?: unknown }
+
+function localOriginOf(value: string): string | null {
+  try {
+    const url = new URL(value)
+    const host = url.hostname.replace(/^\[|\]$/g, '').toLowerCase()
+    if (
+      host === 'localhost' ||
+      host.endsWith('.localhost') ||
+      host === '0.0.0.0' ||
+      host === '::1' ||
+      /^127(?:\.\d{1,3}){3}$/.test(host)
+    ) {
+      return url.origin
+    }
+  } catch {}
+  return null
+}
+
+// discover the app's configured splash by evaluating its expo config on the
+// filesystem (mirrors discoverNativeLinkedAppFonts exactly). returns null when
+// no splash is configured, no app config is found, or the bundle isn't local.
+export function discoverConfigPluginAppSplash(opts: {
+  bundleUrl: string
+  projectDir: string
+  platform?: string
+}): DiscoveredAppSplashSpec | null {
+  const metroOrigin = localOriginOf(opts.bundleUrl)
+  if (!metroOrigin) return null
+
+  const project = resolveAppProject(opts.projectDir)
+  const selectedAppDir = project?.appDir ?? null
+  if (!selectedAppDir) return null
+
+  const platform = (opts.platform || process.env.CONTRAST_PLATFORM || 'ios').toLowerCase()
+
+  let getConfig: ExpoConfigGetter | null = null
+  try {
+    const modulePath = require.resolve('@expo/config', {
+      paths: [selectedAppDir],
+    })
+    const mod = require(modulePath) as { getConfig?: unknown }
+    if (typeof mod.getConfig === 'function') {
+      getConfig = mod.getConfig as ExpoConfigGetter
+    }
+  } catch {}
+  if (!getConfig) return null
+
+  let exp: unknown
+  try {
+    const result = getConfig(selectedAppDir, { skipSDKVersionRequirement: true })
+    if (result?.exp && typeof result.exp === 'object') exp = result.exp
+  } catch {}
+  if (!exp || typeof exp !== 'object') return null
+
+  return configPluginSplashFromExpoConfig(
+    exp,
+    platform === 'android' ? 'android' : 'ios',
+    metroOrigin,
+  )
+}
+
+// encode a resolved splash spec into the `?appSplash=` engine-URL wire value
+// (URL-safe JSON). the engine decodes it with parseAppSplashSpec.
+export function encodeAppSplashWire(spec: DiscoveredAppSplashSpec): string {
+  return encodeURIComponent(JSON.stringify(spec))
+}
+
+// parse a stamped `?appSplash=` wire value back into a spec (or null). used by
+// the preview upload path to learn the splash image url it must stage.
+export function parseAppSplashWire(wire: string): DiscoveredAppSplashSpec | null {
+  if (!wire) return null
+  try {
+    const decoded = JSON.parse(decodeURIComponent(wire)) as unknown
+    if (!decoded || typeof decoded !== 'object') return null
+    const spec = decoded as Record<string, unknown>
+    if (
+      spec.source !== 'expo-splash-screen' &&
+      spec.source !== 'expo-legacy' &&
+      spec.source !== 'react-native-bootsplash'
+    )
+      return null
+    if (typeof spec.backgroundColor !== 'string') return null
+    return decoded as DiscoveredAppSplashSpec
+  } catch {
+    return null
+  }
+}
+
+// every distinct image url a splash spec references (base + dark variant). used
+// by the preview upload path so both the light and dark splash images get
+// staged as share assets.
+export function splashImageUrls(spec: DiscoveredAppSplashSpec): string[] {
+  const urls = new Set<string>()
+  if (spec.imageUrl) urls.add(spec.imageUrl)
+  if (spec.dark?.imageUrl) urls.add(spec.dark.imageUrl)
+  return [...urls]
+}
+
+// content type for a splash image url, by extension. config splash images ship
+// as png/jpg/webp/gif/svg; fall back to octet-stream so the share store still
+// serves bytes the engine's <img> can load.
+export function splashImageContentType(url: string): string {
+  const ext = (url.split('?')[0].split('.').pop() || '').toLowerCase()
+  if (ext === 'png') return 'image/png'
+  if (ext === 'jpg' || ext === 'jpeg') return 'image/jpeg'
+  if (ext === 'webp') return 'image/webp'
+  if (ext === 'gif') return 'image/gif'
+  if (ext === 'svg') return 'image/svg+xml'
+  return 'application/octet-stream'
+}
+
+export type FetchedAppSplashImage = {
+  url: string
+  // sha256(url) — the share-store key, matching the font/asset convention.
+  urlhash: string
+  contentType: string
+  bytes: Uint8Array
+}
+
+// fetch every splash image declared on an `?appSplash=` wire. like the config-
+// plugin fonts, these images live in the native binary / launch storyboard,
+// never in the metro bundle graph, so the preview upload path backfills them by
+// re-fetching the declared urls off the still-live metro — the same staging
+// pattern fetchAppFontFiles uses, keyed by sha256(url).
+export async function fetchAppSplashImages(
+  wire: string,
+  hooks?: {
+    onStaged?: (info: { url: string; byteLength: number }) => void
+    onError?: (url: string, err: unknown) => void
+  },
+): Promise<FetchedAppSplashImage[]> {
+  const spec = parseAppSplashWire(wire)
+  if (!spec) return []
+  const out: FetchedAppSplashImage[] = []
+  const seen = new Set<string>()
+  for (const url of splashImageUrls(spec)) {
+    const urlhash = createHash('sha256').update(url).digest('hex')
+    if (seen.has(urlhash)) continue
+    seen.add(urlhash)
+    try {
+      const res = await fetch(url)
+      if (!res.ok) {
+        hooks?.onError?.(url, new Error(`${res.status} ${res.statusText}`))
+        continue
+      }
+      const bytes = new Uint8Array(await res.arrayBuffer())
+      out.push({ url, urlhash, contentType: splashImageContentType(url), bytes })
+      hooks?.onStaged?.({ url, byteLength: bytes.byteLength })
+    } catch (err) {
+      hooks?.onError?.(url, err)
+    }
+  }
+  return out
+}

package/cli/app-state-reset.ts

@@ -0,0 +1,26 @@
+// resets the guest app through the engine lifecycle bridge. a storage reset
+// replaces the tenant worker before clearing its scoped stores, which is the
+// maestro `clearState` contract. a plain reload keeps the faster reload path.
+//
+// this replaces a host-realm `localStorage.clear()` + `indexedDB.deleteDatabase`
+// loop that was wrong twice: (1) `localStorage.clear()` wiped engine settings
+// and every co-tenant sim's tenant storage, not just this app's; (2) the delete
+// loop ran in the host realm where the only database is the engine's own
+// `preview-share-state`, which the engine holds open — `deleteDatabase` then
+// hung forever (no success/error/blocked event fired), so the whole eval timed
+// out at 60s and never cleared the guest's secure-store session either. that
+// was the bluesky e2e suite's blanket setupApp failure.
+export function resetGuestAppStateEval(resetStorage: boolean): string {
+  return `(async () => {
+    const bridge = globalThis.SootSim && globalThis.SootSim.bridges && globalThis.SootSim.bridges.hotRemount
+    if (!bridge) return false
+    if (${resetStorage ? 'true' : 'false'}) {
+      if (typeof bridge.resetExternalApp !== 'function') return false
+      const result = await bridge.resetExternalApp({ strategy: 'full' })
+      return result.failures.length === 0 && result.relaunched
+    }
+    if (typeof bridge.reloadExternalApp !== 'function') return false
+    await bridge.reloadExternalApp()
+    return true
+  })()`
+}

package/cli/auth.ts

@@ -0,0 +1,184 @@
+// rnx cli auth resolution for cloud-hitting commands.
+//
+// priority order (first match wins):
+//   1. RNX_API_KEY — ci path
+//   2. CONTRAST_INSTALLATION_TOKEN/GITHUB_TOKEN + repo env — github action
+//      preview uploads from the Contrast runner, no extra secret
+//   3. desktop session token from shared desktop auth (`rnx login`)
+//
+// callers wanting an auth header: `authHeaderOrExit('upload')`.
+
+import {
+  readSharedDesktopAuthSession,
+  sharedDesktopAuthAccounts,
+} from '../src/auth/shared-session.ts'
+import { rnxExit } from './run-rnx.ts'
+
+export type CliApiKeyEnvName = 'RNX_API_KEY'
+
+export type CliAuth =
+  | { kind: 'api-key'; secret: string; source: 'env'; envName: CliApiKeyEnvName }
+  | {
+      kind: 'github'
+      token: string
+      // historical name: this is the github owner/repo slug, not the
+      // numeric repository id.
+      repoId: string
+      repositoryId: string | null
+      owner: string | null
+      repo: string | null
+      installationId: string | null
+      source: 'contrast-runner' | 'github-actions'
+    }
+  | {
+      kind: 'session'
+      token: string
+      origin: string
+      // the account this sign-in bills cloud sessions to. null when the person
+      // belongs to several accounts and has not chosen one with `rnx login
+      // --account`; a person with exactly one account never has to choose.
+      accountId: string | null
+    }
+
+export type GitHubUploadIdentity = {
+  repoId: string
+  owner?: string
+  repo?: string
+  installationId?: string | null
+}
+
+// ─── resolution ────────────────────────────────────────────────────────────
+
+const GITHUB_TOKEN_PREFIXES = ['ghs_', 'ghp_', 'gho_', 'ghu_', 'github_pat_']
+
+function looksLikeGitHubToken(token: string | undefined): boolean {
+  // github's 2026 stateless installation tokens (`secrets.GITHUB_TOKEN` /
+  // github.token in actions) are ~520 chars and vary by payload — keep them
+  // opaque with NO upper length cap, matching the canonical server-side check
+  // in src/github/token.ts. the length floor + prefix is only a cheap typo
+  // guard before the cloud endpoints verify real repo access. an upper cap
+  // here silently rejects the long actions token, so resolveCliAuth() returns
+  // null and every CI `record start` dies with "set RNX_API_KEY".
+  return Boolean(
+    token &&
+    token.length >= 20 &&
+    GITHUB_TOKEN_PREFIXES.some((prefix) => token.startsWith(prefix)),
+  )
+}
+
+function resolveGitHubActionsAuth(): CliAuth | null {
+  const contrastRunnerToken = process.env.CONTRAST_INSTALLATION_TOKEN?.trim()
+  const githubActionsToken = process.env.GITHUB_TOKEN?.trim()
+  const token = contrastRunnerToken || githubActionsToken
+  if (!looksLikeGitHubToken(token)) return null
+
+  const repoSlug = (
+    process.env.CONTRAST_REPO ||
+    process.env.GITHUB_REPOSITORY ||
+    ''
+  ).trim()
+  if (!repoSlug) return null
+  const [owner, repo] = repoSlug.includes('/') ? repoSlug.split('/', 2) : [null, null]
+  const repositoryId = (
+    process.env.CONTRAST_REPO_ID ||
+    process.env.GITHUB_REPOSITORY_ID ||
+    ''
+  ).trim()
+
+  const installationId = (
+    process.env.CONTRAST_INSTALLATION_ID ||
+    process.env.GITHUB_APP_INSTALLATION_ID ||
+    ''
+  ).trim()
+
+  return {
+    kind: 'github',
+    token: token!,
+    repoId: repoSlug,
+    repositoryId: repositoryId || null,
+    owner: owner || null,
+    repo: repo || null,
+    installationId: installationId || null,
+    source: contrastRunnerToken ? 'contrast-runner' : 'github-actions',
+  }
+}
+
+function isCliApiKeySecret(secret: string): boolean {
+  return secret.startsWith('sk_rnx_')
+}
+
+function readApiKeyFromEnv(): { secret: string; envName: CliApiKeyEnvName } | null {
+  const envName = 'RNX_API_KEY'
+  const secret = process.env[envName]?.trim()
+  return secret && isCliApiKeySecret(secret) ? { secret, envName } : null
+}
+
+export function resolveCliAuth(): CliAuth | null {
+  const envKey = readApiKeyFromEnv()
+  if (envKey) {
+    return {
+      kind: 'api-key',
+      secret: envKey.secret,
+      source: 'env',
+      envName: envKey.envName,
+    }
+  }
+  const githubAuth = resolveGitHubActionsAuth()
+  if (githubAuth) return githubAuth
+  const session = readSharedDesktopAuthSession()
+  if (session?.token) {
+    const accounts = sharedDesktopAuthAccounts(session.user)
+    return {
+      kind: 'session',
+      token: session.token,
+      origin: session.origin,
+      accountId:
+        session.accountId ?? (accounts.length === 1 ? (accounts[0]?.id ?? null) : null),
+    }
+  }
+  return null
+}
+
+export const CHOOSE_ACCOUNT_HINT =
+  'this sign-in belongs to several accounts; run `rnx login --account <name>` to choose the one to bill'
+
+// the account a request that opens a paid cloud session names. an api key
+// names its own account, so it sends none; a session token has to say.
+export function cloudAccountIdOrExit(auth: CliAuth): string | null {
+  if (auth.kind !== 'session') return null
+  if (auth.accountId) return auth.accountId
+  process.stderr.write(`\n  ${CHOOSE_ACCOUNT_HINT}\n\n`)
+  rnxExit(1)
+}
+
+export function authHeaderValue(auth: CliAuth): string {
+  return auth.kind === 'api-key' ? `Bearer ${auth.secret}` : `Bearer ${auth.token}`
+}
+
+export function githubUploadIdentity(auth: CliAuth | null): GitHubUploadIdentity | null {
+  if (!auth || auth.kind !== 'github') return null
+  return {
+    repoId: auth.repoId,
+    owner: auth.owner ?? undefined,
+    repo: auth.repo ?? undefined,
+    installationId: auth.installationId,
+  }
+}
+
+// fail fast with a friendly message — use at the top of cloud-hitting
+// commands that can't proceed without auth.
+export function authHeaderOrExit(commandLabel: string): {
+  auth: CliAuth
+  header: string
+} {
+  const auth = resolveCliAuth()
+  if (auth) return { auth, header: authHeaderValue(auth) }
+
+  process.stderr.write(
+    `\n  rnx ${commandLabel} needs to be authenticated.\n\n` +
+      `  pick one:\n` +
+      `    • run \`rnx login\` to sign in with your GH account\n` +
+      `    • set RNX_API_KEY=sk_rnx_... (recommended for CI)\n\n`,
+  )
+  rnxExit(1)
+}

package/cli/bin.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+// rnx CLI entry point. the full command and verb surface lives in the
+// registry at `packages/rnx-skills/src/cli/meta.ts` — help output,
+// website docs, and agent skills all read from there. do not duplicate
+// command listings in this file; run `rnx --help` for the canonical
+// surface.
+//
+// this file only routes. the hidden entry points below each take over the
+// whole process, so the CLI itself lives in `./main` and is imported only once
+// none of them has claimed the run.
+
+import { RNX_INTERNAL_COMMAND } from './internal-child'
+
+if (process.argv[2] === '__shell-init') {
+  const { renderRnxShellInit } = await import('./shell-init')
+  try {
+    process.stdout.write(renderRnxShellInit(process.argv[3] ?? ''))
+    process.exit(0)
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`)
+    process.exit(1)
+  }
+}
+
+if (process.argv[2] === '__cloud-confirm') {
+  try {
+    const [{ confirmCloudSimulator }, { readCloudSession }] = await Promise.all([
+      import('./cloud-client'),
+      import('./cloud-session'),
+    ])
+    const session = readCloudSession()
+    if (!session) throw new Error('RNX cloud confirmation has no shell session')
+    // a box has no claim to keep alive: its simulator is held by the Box page
+    // for as long as the box runs, so a shell on a box confirms nothing.
+    if (session.service === 'sim') await confirmCloudSimulator(session)
+    process.exit(0)
+  } catch (error) {
+    process.stderr.write(
+      `RNX cloud confirmation failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`,
+    )
+    process.exit(1)
+  }
+}
+
+// child processes this CLI spawns as itself: the detached browser host,
+// playwright's installer, maestro's blocking fetch worker. unlike the two
+// above, these do not exit on the way out — the installer and the browser host
+// are still working when their handler returns, and the process ends when that
+// work does. so this is the branch that must skip the CLI rather than the CLI
+// that must skip it.
+if (process.argv[2] === RNX_INTERNAL_COMMAND) {
+  const { runInternalChild } = await import('./internal-child')
+  await runInternalChild(process.argv.slice(3))
+} else {
+  await import('./main')
+}

package/cli/bridge-diagnostics.ts

@@ -0,0 +1,226 @@
+import { MERGED_CONSOLE_COUNT_EVAL, inspectErrors } from './commands/inspect/core'
+import { formatLogTimestamp } from './commands/inspect/shared'
+import type { WsBridge } from './ws-bridge'
+import type { SootSimRequestEntry } from '@rnx/globals'
+
+interface ConsoleSummaryOptions {
+  includeTail?: boolean
+  errorsCommand?: string
+  warningsCommand?: string
+}
+
+interface RequestSummaryOptions {
+  includeTail?: boolean
+  requestsCommand?: string
+}
+
+interface FailureDiagnosticsOptions {
+  errorsCommand?: string
+  warningsCommand?: string
+  requestsCommand?: string
+}
+
+function formatRequestMessage(entry: SootSimRequestEntry) {
+  const target = entry.displayUrl || entry.url
+  if (entry.status != null) {
+    return `${entry.method} ${target} -> ${entry.status}${entry.statusText ? ` ${entry.statusText}` : ''}`
+  }
+  if (entry.error) {
+    return `${entry.method} ${target} -> ${entry.error}`
+  }
+  return `${entry.method} ${target}`
+}
+
+async function callTestBridge<T = unknown>(
+  bridge: WsBridge,
+  method: string,
+  ...args: unknown[]
+) {
+  return bridge.send({
+    type: 'call',
+    path: `__sootsimTest.${method}`,
+    args,
+  }) as Promise<T>
+}
+
+export async function printBridgeConsoleSummary(
+  bridge: WsBridge,
+  opts: ConsoleSummaryOptions = {},
+) {
+  const counts = (await bridge.send({
+    type: 'evaluate',
+    code: MERGED_CONSOLE_COUNT_EVAL,
+  })) as { errors?: number; warnings?: number; total?: number } | null
+
+  if (!counts || typeof counts !== 'object') return
+
+  const errors = Math.max(0, Number(counts.errors) || 0)
+  const warnings = Math.max(0, Number(counts.warnings) || 0)
+  if (errors === 0 && warnings === 0) return
+
+  const parts = []
+  if (errors > 0) parts.push(`${errors} console error${errors === 1 ? '' : 's'}`)
+  if (warnings > 0) {
+    parts.push(`${warnings} console warning${warnings === 1 ? '' : 's'}`)
+  }
+  console.log(`\n  console: ${parts.join(', ')}`)
+  if (opts.errorsCommand) console.log(`  inspect: ${opts.errorsCommand}`)
+  if (warnings > 0 && opts.warningsCommand) {
+    console.log(`  inspect: ${opts.warningsCommand}`)
+  }
+
+  if (!opts.includeTail || errors === 0) return
+
+  // merged read (ws-bridge buffer + observability) so forwarded render-worker
+  // errors are shown in the tail, not just counted.
+  const recentErrors = await inspectErrors(bridge, 5)
+  if (!Array.isArray(recentErrors) || recentErrors.length === 0) return
+
+  console.log('\n  recent console errors:\n')
+  for (const entry of recentErrors as Array<{
+    timestamp: number
+    args?: unknown[]
+  }>) {
+    const time = formatLogTimestamp(entry.timestamp)
+    const msg = Array.isArray(entry.args)
+      ? entry.args
+          .map((value) =>
+            typeof value === 'object' ? JSON.stringify(value) : String(value),
+          )
+          .join(' ')
+      : String(entry)
+    console.log(`  [${time}] ${msg}`)
+  }
+}
+
+export async function printBridgeRequestSummary(
+  bridge: WsBridge,
+  opts: RequestSummaryOptions = {},
+) {
+  const counts = await callTestBridge<{ failed?: number; total?: number }>(
+    bridge,
+    'getRequestCounts',
+  )
+  if (!counts || typeof counts !== 'object') return
+
+  const failed = Math.max(0, Number(counts.failed) || 0)
+  if (failed === 0) return
+
+  console.log(`\n  network: ${failed} failed request${failed === 1 ? '' : 's'}`)
+  if (opts.requestsCommand) console.log(`  inspect: ${opts.requestsCommand}`)
+
+  if (!opts.includeTail) return
+
+  const recentFailed = await callTestBridge<SootSimRequestEntry[]>(
+    bridge,
+    'getFailedRequests',
+    5,
+  )
+  if (!Array.isArray(recentFailed) || recentFailed.length === 0) return
+
+  console.log('\n  recent failed requests:\n')
+  for (const entry of recentFailed) {
+    const time = formatLogTimestamp(entry.timestamp)
+    console.log(`  [${time}] ${formatRequestMessage(entry)}`)
+    if (entry.responseBody) {
+      console.log(`    ${entry.responseBody}`)
+    } else if (entry.error) {
+      console.log(`    ${entry.error}`)
+    }
+  }
+}
+
+interface BridgeStateSummary {
+  url?: string
+  simId?: string | null
+  nodeCount?: number
+  mode?: string
+  shell?: {
+    state?: string | null
+    activeApp?: string | null
+    showSwitcher?: boolean
+    switcherPhase?: string | null
+  } | null
+}
+
+export async function printBridgeStateSummary(bridge: WsBridge) {
+  const state = (await bridge.send({
+    type: 'evaluate',
+    code: `(async () => {
+      const test = window.__sootsimTest
+      const mainShell = window.SootSim?.bridges?.mainShell
+      let shell = null
+      try {
+        shell = typeof mainShell?.getState === 'function' ? await mainShell.getState() : null
+      } catch {}
+      let nodeCount = 0
+      try {
+        nodeCount = typeof test?.getNodeCount === 'function' ? await test.getNodeCount() : 0
+      } catch {}
+      return {
+        url: window.location.href,
+        simId: window.__sootsimSimId || null,
+        nodeCount,
+        mode: window.__sootsimRenderHost ? 'render-worker' : 'main-thread',
+        shell: shell
+          ? {
+              state: shell.state || null,
+              activeApp: shell.activeApp || null,
+              showSwitcher: !!shell.showSwitcher,
+              switcherPhase: shell.switcherPhase || null,
+            }
+          : null,
+      }
+    })()`,
+  })) as BridgeStateSummary | null
+
+  if (!state || typeof state !== 'object') return
+
+  console.log('\n  state:')
+  if (state.simId) console.log(`    sim: ${state.simId}`)
+  if (state.url) console.log(`    url: ${state.url}`)
+  if (state.mode) console.log(`    mode: ${state.mode}`)
+  const nodeCount = Number(state.nodeCount) || 0
+  console.log(`    nodes: ${nodeCount}${nodeCount > 10 ? ' (ready)' : ' (not ready)'}`)
+
+  const shell = state.shell
+  if (shell && typeof shell === 'object') {
+    const shellParts = [
+      shell.state ? `state=${shell.state}` : null,
+      shell.activeApp ? `app=${shell.activeApp}` : null,
+      shell.showSwitcher ? 'switcher=open' : null,
+      shell.switcherPhase ? `phase=${shell.switcherPhase}` : null,
+    ].filter(Boolean)
+    if (shellParts.length > 0) {
+      console.log(`    shell: ${shellParts.join(' ')}`)
+    }
+  }
+}
+
+export async function printBridgeFailureDiagnostics(
+  bridge: WsBridge,
+  opts: FailureDiagnosticsOptions = {},
+) {
+  try {
+    await printBridgeStateSummary(bridge)
+  } catch {
+    // ignore state snapshot failures while already handling a failure
+  }
+  try {
+    await printBridgeConsoleSummary(bridge, {
+      includeTail: true,
+      errorsCommand: opts.errorsCommand,
+      warningsCommand: opts.warningsCommand,
+    })
+  } catch {
+    // ignore console snapshot failures while already handling a failure
+  }
+  try {
+    await printBridgeRequestSummary(bridge, {
+      includeTail: true,
+      requestsCommand: opts.requestsCommand,
+    })
+  } catch {
+    // ignore request snapshot failures while already handling a failure
+  }
+}