peachsim 0.1.527

package/cli/commands/diagnose.ts

@@ -0,0 +1,589 @@
+// rnx get diagnosis — composed read commands for "what just went wrong?"
+//
+// the demo-friendly compact diagnostic surface called out in
+// plans/expensify-sootsim-agent-device-demo.md. one command, one round
+// of bridge calls, one paste-able output that beats the agent-device
+// sed/grep workflow in both speed and information density.
+//
+// usage:
+//   rnx get diagnosis [--since 90s] [--include react,network,console,screen,fetch,alert]
+//   rnx get diagnosis --json
+//
+// the output is grouped by source (timeline, network, react, console)
+// rather than chronological. for chronological order use
+// `rnx what-happened` directly. `recent` is the only subcommand
+// today; `diagnose <something-else>` may be added later (e.g. boot,
+// scrolling-jank, idle-burn).
+//
+// design note: every dimension here is a single bridge call against an
+// existing primitive. this command exists to remove the agent's tax of
+// chaining commands and reformatting four output styles, not to add a
+// new data source. when a new data source becomes worth surfacing in a
+// "diagnose" pass, add it as one more parallel call here.
+
+import { getCliIdentityKey } from '../current-sim'
+import {
+  callInBridge,
+  createBridgeFromParsed,
+  parseBridgeCliArgs,
+  type WsBridge,
+} from '../ws-bridge'
+import type {
+  SootSimTimelineEvent,
+  SootSimTimelineQuery,
+  SootSimTimelineQueryResult,
+} from '@rnx/globals'
+
+interface DiagnoseOptions {
+  port?: number
+  verbose?: boolean
+}
+
+interface NetworkEntry {
+  id: string
+  url: string
+  displayUrl?: string
+  method?: string
+  status?: number | null
+  durationMs?: number | null
+  error?: string | null
+  // observability store uses startTs (epoch ms) as the entry's start
+  // time. accept either name for forward-compat with any future
+  // rename.
+  startTs?: number
+  startedAt?: number
+  responseAt?: number | null
+  responseSize?: number | null
+  size?: number | null
+}
+
+interface SlowRow {
+  displayName: string
+  totalMs: number
+  avgMs: number
+  commitCount: number
+  slowestCommit: number
+  slowestMs: number
+}
+
+interface RerenderRow {
+  displayName: string
+  count?: number
+  renders?: number
+  causes?: Record<string, number>
+}
+
+interface LogEntry {
+  level: string
+  // observability ring uses `ts` (epoch ms) and `args` (string[]).
+  // older shapes had `t` + `message`. accept both.
+  ts?: number
+  t?: number
+  args?: unknown[]
+  message?: string
+  source?: string
+  context?: string
+}
+
+function logTs(e: LogEntry): number {
+  return e.ts ?? e.t ?? 0
+}
+
+function logMessage(e: LogEntry): string {
+  if (typeof e.message === 'string' && e.message.length > 0) return e.message
+  if (Array.isArray(e.args)) {
+    return e.args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')
+  }
+  return ''
+}
+
+const DEFAULT_INCLUDES = new Set(['timeline', 'network', 'react', 'console', 'screen'])
+
+function printHelp(): void {
+  console.log(`
+rnx get diagnosis — compact "what just went wrong?" report
+
+usage:
+  rnx get diagnosis [--since <duration>] [--include <csv>] [--json]
+
+options:
+  --since <d>           absolute window for timeline + network (e.g. 90s, 2m, 500ms; default 90s)
+  --include <csv>       comma-separated dimensions: timeline, network, react, console, screen
+                        (default: all)
+  --slow-threshold <n>  network slow-request threshold in ms (default 1000)
+  --limit <n>           rows to print per react table (default 8)
+  --json                emit a single structured JSON document
+
+the diagnose report runs every dimension in parallel against the same
+sim and returns a grouped summary. use \`rnx what-happened\`
+for chronological events, \`rnx network\` for full request inspection,
+\`rnx perf react summary\` for the React tables on their own.
+
+examples:
+  rnx get diagnosis
+  rnx get diagnosis --since 30s --include network,react
+  rnx get diagnosis --json > /tmp/diagnosis.json
+`)
+}
+
+function parseSinceMs(value: string | undefined, fallback: number): number {
+  if (!value) return fallback
+  const m = /^(\d+(?:\.\d+)?)(ms|s|m)?$/.exec(value.trim())
+  if (!m) return fallback
+  const n = Number(m[1])
+  const unit = m[2] ?? 'ms'
+  return unit === 's' ? n * 1000 : unit === 'm' ? n * 60_000 : n
+}
+
+function parseCsv(value: string | undefined): Set<string> {
+  if (!value) return DEFAULT_INCLUDES
+  const out = new Set<string>()
+  for (const raw of value.split(',')) {
+    const trimmed = raw.trim().toLowerCase()
+    if (trimmed) out.add(trimmed)
+  }
+  return out
+}
+
+function valueOf(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag)
+  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1]
+  const prefix = `${flag}=`
+  return args.find((a) => a.startsWith(prefix))?.slice(prefix.length)
+}
+
+function numberFlag(args: string[], flag: string, fallback: number): number {
+  const raw = valueOf(args, flag)
+  if (raw === undefined) return fallback
+  const n = Number(raw)
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : fallback
+}
+
+interface TimelineSlice {
+  events: SootSimTimelineEvent[]
+  byKind: Record<string, number>
+  total: number
+  errors: SootSimTimelineEvent[]
+  alerts: SootSimTimelineEvent[]
+  screens: SootSimTimelineEvent[]
+}
+
+async function fetchTimeline(bridge: WsBridge, sinceMs: number): Promise<TimelineSlice> {
+  const query: SootSimTimelineQuery = {
+    limit: 500,
+    since: Date.now() - sinceMs,
+  }
+  const result = await callInBridge<SootSimTimelineQueryResult>(
+    bridge,
+    'SootSim.bridges.timeline.recent',
+    query,
+  )
+  const events = result.events ?? []
+  const byKind: Record<string, number> = {}
+  const errors: SootSimTimelineEvent[] = []
+  const alerts: SootSimTimelineEvent[] = []
+  const screens: SootSimTimelineEvent[] = []
+  for (const ev of events) {
+    byKind[ev.kind] = (byKind[ev.kind] ?? 0) + 1
+    const data = ev.data as Record<string, unknown> | null
+    const level = data && typeof data === 'object' ? (data.level as string) : undefined
+    if (ev.kind === 'console' && (level === 'error' || level === 'warn')) {
+      errors.push(ev)
+    }
+    if (ev.kind === 'alert' || ev.kind === 'actionsheet' || ev.kind === 'picker') {
+      alerts.push(ev)
+    }
+    if (ev.kind === 'screen' || ev.kind === 'route') {
+      screens.push(ev)
+    }
+  }
+  return {
+    events,
+    byKind,
+    total: events.length,
+    errors,
+    alerts,
+    screens,
+  }
+}
+
+interface NetworkSlice {
+  total: number
+  failed: NetworkEntry[]
+  slow: NetworkEntry[]
+  inFlight: number
+  slowThresholdMs: number
+}
+
+async function fetchNetwork(
+  bridge: WsBridge,
+  sinceMs: number,
+  slowThresholdMs: number,
+): Promise<NetworkSlice | { error: string }> {
+  // re-uses the observability store the existing `network` command
+  // reads from. local filtering keeps this command independent of any
+  // new bridge surface and lets it run against today's engine.
+  const result = (await bridge.send({
+    type: 'evaluate',
+    code: `(() => {
+      const obs = window.__sootsimObservability;
+      if (!obs) return { ok: false };
+      return { ok: true, entries: obs.network.getSnapshot() };
+    })()`,
+  })) as { ok: boolean; entries?: NetworkEntry[] }
+  if (!result || !result.ok) {
+    return { error: 'observability bridge not installed' }
+  }
+  const all = result.entries ?? []
+  const cutoff = Date.now() - sinceMs
+  // observability ring uses startTs; older shapes used startedAt. accept
+  // both so this command works against both shapes without a feature
+  // detection round-trip.
+  const inWindow = all.filter((e) => (e.startTs ?? e.startedAt ?? 0) >= cutoff)
+  const failed = inWindow.filter(
+    (e) => !!e.error || (e.status != null && e.status >= 400),
+  )
+  const slow = inWindow
+    .filter((e) => e.durationMs != null && e.durationMs >= slowThresholdMs)
+    .sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0))
+  const inFlight = inWindow.filter((e) => e.durationMs == null).length
+  return {
+    total: inWindow.length,
+    failed,
+    slow,
+    inFlight,
+    slowThresholdMs,
+  }
+}
+
+interface ReactSlice {
+  commits: number
+  slow: SlowRow[]
+  rerenders: RerenderRow[]
+  durationWarning?: string
+  error?: string
+}
+
+async function fetchReact(bridge: WsBridge, limit: number): Promise<ReactSlice> {
+  const [slowResult, rerendersResult] = (await Promise.all([
+    callInBridge(bridge, 'SootSim.bridges.reactProfile.slow', { limit }),
+    callInBridge(bridge, 'SootSim.bridges.reactProfile.rerenders', { limit }),
+  ])) as [
+    {
+      rows?: SlowRow[]
+      commits?: number
+      error?: string
+      durationWarning?: string
+    },
+    { rows?: RerenderRow[]; commits?: number; error?: string },
+  ]
+  return {
+    commits: slowResult.commits ?? rerendersResult.commits ?? 0,
+    slow: slowResult.rows ?? [],
+    rerenders: rerendersResult.rows ?? [],
+    durationWarning: slowResult.durationWarning,
+    error: slowResult.error ?? rerendersResult.error,
+  }
+}
+
+async function fetchConsoleErrors(
+  bridge: WsBridge,
+  sinceMs: number,
+): Promise<{ entries: LogEntry[]; total: number } | { error: string }> {
+  const result = (await bridge.send({
+    type: 'evaluate',
+    code: `(() => {
+      const obs = window.__sootsimObservability;
+      if (!obs) return { ok: false };
+      return { ok: true, entries: obs.logs.getSnapshot() };
+    })()`,
+  })) as { ok: boolean; entries?: LogEntry[] }
+  if (!result || !result.ok) {
+    return { error: 'observability bridge not installed' }
+  }
+  const cutoff = Date.now() - sinceMs
+  const all = result.entries ?? []
+  const errs = all.filter(
+    (e) => logTs(e) >= cutoff && (e.level === 'error' || e.level === 'warn'),
+  )
+  return { entries: errs.slice(-20), total: errs.length }
+}
+
+function formatNetworkRow(entry: NetworkEntry): string {
+  const status = entry.error ? 'err' : entry.status != null ? String(entry.status) : '...'
+  const method = (entry.method ?? 'GET').padEnd(6)
+  const dur = entry.durationMs != null ? `${entry.durationMs.toFixed(0)}ms` : '...'
+  const url = entry.displayUrl ?? entry.url
+  // shorten long urls to 96 chars in the diagnose report — full
+  // detail is one `rnx network get <id>` away.
+  const shortUrl = url.length > 96 ? `${url.slice(0, 92)}…` : url
+  return `    ${status.padStart(3)} ${method} ${dur.padStart(7)}  ${shortUrl}  (${entry.id})`
+}
+
+function formatTimelineRow(ev: SootSimTimelineEvent, anchorMs: number): string {
+  const dt = ((ev.t - anchorMs) / 1000).toFixed(2)
+  const sign = ev.t >= anchorMs ? '-' : '+'
+  const data = ev.data as Record<string, unknown> | null
+  let payload = ''
+  if (data && typeof data === 'object') {
+    const message = (data.message ?? '').toString().slice(0, 120)
+    const title = (data.title ?? data.name ?? data.path ?? data.url ?? '').toString()
+    const phase = (data.phase ?? '').toString()
+    payload = [phase, title, message].filter(Boolean).join(' · ')
+  }
+  return `    -${dt.padStart(5)}s [${ev.kind}] ${payload}`
+}
+
+function formatTable(headers: string[], rows: string[][], indent: string): string {
+  if (rows.length === 0) return `${indent}(no rows)`
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((row) => row[i]?.length ?? 0)),
+  )
+  const line = (cells: string[]) =>
+    cells
+      .map((cell, i) => cell.padEnd(widths[i]))
+      .join('  ')
+      .trimEnd()
+  return [
+    line(headers),
+    line(headers.map((h) => '-'.repeat(h.length))),
+    ...rows.map(line),
+  ]
+    .map((row) => `${indent}${row}`)
+    .join('\n')
+}
+
+export async function runDiagnose(
+  args: string[],
+  opts: DiagnoseOptions,
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return 0
+  }
+
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--json', '--help', '-h'],
+    stripValueFlags: ['--since', '--include', '--limit', '--slow-threshold'],
+  })
+
+  const sub = parsed.positional[0] ?? 'recent'
+  if (sub !== 'recent') {
+    console.error(`  unknown subcommand: ${sub}`)
+    console.error('  did you mean: rnx get diagnosis ?')
+    return 1
+  }
+
+  const sinceMs = parseSinceMs(valueOf(args, '--since'), 90_000)
+  const include = parseCsv(valueOf(args, '--include'))
+  const reactLimit = numberFlag(args, '--limit', 8)
+  const slowThresholdMs = numberFlag(args, '--slow-threshold', 1000)
+  const wantsJson = args.includes('--json')
+
+  const bridge = createBridgeFromParsed(parsed)
+  try {
+    // run every requested dimension in parallel — one bridge round-trip
+    // per primitive, no chained CLI invocations. on a healthy sim
+    // this finishes in a single tick.
+    const tasks: Array<Promise<unknown>> = []
+    const ordered: string[] = []
+    if (include.has('timeline') || include.has('screen') || include.has('alert')) {
+      ordered.push('timeline')
+      tasks.push(fetchTimeline(bridge, sinceMs))
+    }
+    if (include.has('network') || include.has('fetch')) {
+      ordered.push('network')
+      tasks.push(fetchNetwork(bridge, sinceMs, slowThresholdMs))
+    }
+    if (include.has('react')) {
+      ordered.push('react')
+      tasks.push(fetchReact(bridge, reactLimit))
+    }
+    if (include.has('console')) {
+      ordered.push('console')
+      tasks.push(fetchConsoleErrors(bridge, sinceMs))
+    }
+
+    // always probe the engine build id (one cheap eval). a reused sim
+    // session on a stale engine silently produced false QA verdicts
+    // (QA F20-5); surfacing the build here makes the staleness checkable.
+    const engineBuild = await bridge
+      .send({
+        type: 'evaluate',
+        code: `globalThis.__sootsimEngineBuild ?? null`,
+      })
+      .then((v) => (typeof v === 'string' ? v : null))
+      .catch(() => null)
+
+    const results = await Promise.all(tasks)
+    const slices: Record<string, unknown> = {}
+    for (let i = 0; i < ordered.length; i++) slices[ordered[i]] = results[i]
+
+    if (wantsJson) {
+      console.log(
+        JSON.stringify(
+          {
+            generatedAt: Date.now(),
+            engineBuild,
+            sinceMs,
+            include: Array.from(include),
+            slices,
+          },
+          null,
+          2,
+        ),
+      )
+      return 0
+    }
+
+    // human render — one section per slice. terse, scannable, demo-paste-friendly.
+    const now = Date.now()
+    console.log(
+      `  diagnose recent (last ${(sinceMs / 1000).toFixed(0)}s, include: ${Array.from(include).sort().join(',')}):`,
+    )
+    console.log(
+      `  engine build: ${engineBuild ?? 'unknown (no build stamp — likely a stale or pre-F20-5 engine)'}`,
+    )
+
+    if (slices.timeline) {
+      const t = slices.timeline as TimelineSlice
+      console.log(`\n  timeline — ${t.total} event(s) in window`)
+      const summary = Object.entries(t.byKind)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, n]) => `${n} ${k}`)
+        .join(' · ')
+      if (summary) console.log(`    summary: ${summary}`)
+      if (t.screens.length) {
+        const last = t.screens[t.screens.length - 1]
+        const data = last.data as Record<string, unknown> | null
+        const name = data ? (data.name ?? data.activeName ?? data.path ?? '?') : '?'
+        console.log(`    last screen: ${String(name)}`)
+      }
+      if (t.alerts.length) {
+        console.log(`    alerts (${t.alerts.length}):`)
+        for (const a of t.alerts.slice(-5)) {
+          console.log(formatTimelineRow(a, now))
+        }
+      }
+      if (t.errors.length) {
+        console.log(`    console errors/warns from timeline (${t.errors.length}):`)
+        for (const e of t.errors.slice(-5)) {
+          console.log(formatTimelineRow(e, now))
+        }
+      }
+    }
+
+    if (slices.network) {
+      const n = slices.network as NetworkSlice | { error: string }
+      if ('error' in n) {
+        console.log(`\n  network — ${n.error}`)
+      } else {
+        console.log(
+          `\n  network — ${n.total} request(s), ${n.failed.length} failed, ${n.slow.length} slow (>${n.slowThresholdMs}ms), ${n.inFlight} in-flight`,
+        )
+        if (n.failed.length) {
+          console.log(`    failed:`)
+          for (const e of n.failed.slice(-8)) console.log(formatNetworkRow(e))
+        }
+        if (n.slow.length) {
+          console.log(`    slowest:`)
+          for (const e of n.slow.slice(0, 5)) console.log(formatNetworkRow(e))
+        }
+      }
+    }
+
+    if (slices.react) {
+      const r = slices.react as ReactSlice
+      console.log(`\n  react — ${r.commits} commit(s)`)
+      if (r.error) console.log(`    warning: ${r.error}`)
+      if (r.durationWarning) console.log(`    warning: ${r.durationWarning}`)
+      const allZero =
+        r.slow.length > 0 && r.slow.every((row) => row.totalMs <= 0 && row.slowestMs <= 0)
+      if (allZero && !r.durationWarning) {
+        console.log(
+          `    warning: every commit reports actualDuration=0ms — bundle has React profiler timer disabled`,
+        )
+      }
+      if (r.slow.length) {
+        console.log('    slowest:')
+        console.log(
+          formatTable(
+            ['component', 'total', 'commits', 'slowest'],
+            r.slow
+              .slice(0, reactLimit)
+              .map((row) => [
+                row.displayName,
+                `${row.totalMs.toFixed(2)}ms`,
+                String(row.commitCount),
+                `${row.slowestMs.toFixed(2)}ms`,
+              ]),
+            '      ',
+          ),
+        )
+      }
+      if (r.rerenders.length) {
+        console.log('    most rerenders:')
+        console.log(
+          formatTable(
+            ['component', 'renders', 'top causes'],
+            r.rerenders.slice(0, reactLimit).map((row) => {
+              const causes = Object.entries(row.causes ?? {})
+                .filter(([, v]) => v > 0)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([k, v]) => `${k}:${v}`)
+                .join(', ')
+              return [
+                row.displayName,
+                String(row.renders ?? row.count ?? 0),
+                causes || '-',
+              ]
+            }),
+            '      ',
+          ),
+        )
+      }
+    }
+
+    if (slices.console) {
+      const c = slices.console as
+        | { entries: LogEntry[]; total: number }
+        | { error: string }
+      if ('error' in c) {
+        console.log(`\n  console — ${c.error}`)
+      } else {
+        console.log(`\n  console errors/warns — ${c.total} in window`)
+        for (const log of c.entries.slice(-8)) {
+          const dt = ((logTs(log) - now) / 1000).toFixed(2)
+          const msg = logMessage(log).slice(0, 160)
+          console.log(`    -${dt.padStart(5)}s [${log.level}] ${msg}`)
+        }
+      }
+    }
+
+    // close with the per-identity cursor advance hint, mirroring
+    // what-happened's footer.
+    const identityKey = getCliIdentityKey()
+    if (identityKey) {
+      console.log(
+        `\n  next: rnx what-happened (cursor advances) · rnx network get <id> · rnx perf react why <fiber-id>`,
+      )
+    }
+    return 0
+  } catch (err) {
+    // a bridge call rejecting (most commonly "no sim connected") must not
+    // escape as a raw stack trace with a 0 exit code — `get diagnosis` is the
+    // "what just went wrong" command; failing it should read cleanly and
+    // exit non-zero so `rnx get diagnosis && …` chains behave.
+    const msg = err instanceof Error ? err.message : String(err)
+    if (/no sim connected/i.test(msg)) {
+      console.error('  no sim connected — open one first: rnx open <metroPort>')
+    } else {
+      console.error(`  diagnose failed: ${msg}`)
+    }
+    return 1
+  } finally {
+    bridge.close()
+  }
+}