rnxsim 0.1.313 → 0.1.314

package/cli/commands/cpu-profile.ts

@@ -0,0 +1,269 @@
+// sootsim perf cpu — capture a sampled CPU trace from the tenant worker.
+//
+// the JS Self-Profiler API (`new Profiler()`) cannot be constructed in a
+// dedicated-worker scope, and sootsim runs the guest app in the tenant worker,
+// so the old in-worker approach was unsupported (F28). this implementation
+// attaches Chromium's `Profiler` CDP domain to the worker target instead —
+// which works for workers and returns the .cpuprofile shape directly.
+//
+// dedicated workers are not top-level CDP targets, so we connect to the page
+// target, `Target.setAutoAttach` to discover the worker child sessions, and
+// route `Profiler.*` to each worker via its sessionId (flatten mode).
+//
+// the user's normal sootsim tab runs in plain Chrome without a debug port.
+// the easiest way to get a profilable sim is to open one with a CDP port —
+// it stays driveable over the WS bridge, so you can scroll/navigate while
+// profiling (the playwright driver passes --remote-debugging-port through):
+//
+//   sootsim open <metro-port> --new --driver playwright --cdp-port 9222
+//   sootsim perf cpu --cdp-port 9222 --match <metro-port> --duration 5
+//
+// (a standalone CDP Chrome also works for profiling a static page, but it
+// does NOT register on the bridge, so it can't be driven — see printNoCdp.)
+//
+// interact with the app during the capture window. the reference probe that
+// also drives the interaction itself lives at
+// scripts/debug/cdp-worker-cpu-profile.ts.
+
+import { mkdirSync, writeFileSync } from 'fs'
+import { dirname, resolve } from 'path'
+import { WebSocket } from 'ws'
+
+interface ProfileOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+// compact CDP client with flatten-mode sessionId routing — one ws to the page
+// target carries the page session plus every auto-attached worker session.
+class Cdp {
+  private ws: WebSocket
+  private nextId = 1
+  private pending = new Map<number, { res: (v: any) => void; rej: (e: any) => void }>()
+  private listeners = new Set<(method: string, params: any) => void>()
+  private ready: Promise<void>
+
+  constructor(wsUrl: string) {
+    this.ws = new WebSocket(wsUrl, { maxPayload: 1 << 28 })
+    this.ready = new Promise((res, rej) => {
+      this.ws.once('open', () => res())
+      this.ws.once('error', rej)
+    })
+    this.ws.on('message', (data) => {
+      const msg = JSON.parse(data.toString())
+      if (msg.id && this.pending.has(msg.id)) {
+        const { res, rej } = this.pending.get(msg.id)!
+        this.pending.delete(msg.id)
+        msg.error ? rej(new Error(JSON.stringify(msg.error))) : res(msg.result)
+      } else if (msg.method) {
+        for (const l of this.listeners) l(msg.method, msg.params)
+      }
+    })
+  }
+
+  waitOpen() {
+    return this.ready
+  }
+
+  on(l: (method: string, params: any) => void) {
+    this.listeners.add(l)
+  }
+
+  send(
+    method: string,
+    params: Record<string, unknown> = {},
+    sessionId?: string,
+  ): Promise<any> {
+    const id = this.nextId++
+    return new Promise((res, rej) => {
+      this.pending.set(id, { res, rej })
+      this.ws.send(
+        JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }),
+      )
+    })
+  }
+
+  close() {
+    try {
+      this.ws.close()
+    } catch {}
+  }
+}
+
+interface CdpTarget {
+  type: string
+  url: string
+  webSocketDebuggerUrl: string
+}
+
+export async function runCpuProfile(
+  args: string[],
+  opts: ProfileOptions,
+): Promise<number> {
+  const duration = Number(valueOf(args, '--duration') ?? '5')
+  if (!Number.isFinite(duration) || duration <= 0) {
+    console.error('  --duration must be a positive number (seconds)')
+    return 1
+  }
+  const sampleInterval = Number(valueOf(args, '--sample-interval') ?? '0.1') // ms
+  const cdpPort = Number(
+    valueOf(args, '--cdp-port') ?? process.env.SOOTSIM_CDP_PORT ?? '9222',
+  )
+  // optional substring filter to pick the right page when several sims share
+  // the CDP browser (e.g. `--match 8089` or `--match /rn/8089`).
+  const match = valueOf(args, '--match') ?? '/rn/'
+  const outputArg = valueOf(args, '--output') ?? valueOf(args, '-o')
+  const outputPath = resolve(process.cwd(), outputArg ?? '/tmp/sootsim.cpuprofile')
+
+  // locate the page target on the CDP endpoint. NOTE: Chrome's DevTools HTTP
+  // `/json` endpoints reject any Host header that isn't `localhost` (a
+  // DNS-rebinding guard) — `http://127.0.0.1:<port>/json/list` returns
+  // "Not found" / 404, so we must use the `localhost` hostname here. (this is
+  // what made the command silently fall into the no-CDP path even with a live
+  // CDP browser.)
+  let targets: CdpTarget[] = []
+  try {
+    targets = (await (
+      await fetch(`http://localhost:${cdpPort}/json/list`)
+    ).json()) as CdpTarget[]
+  } catch {
+    printNoCdp(cdpPort)
+    return 1
+  }
+  const page = targets.find((t) => t.type === 'page' && t.url.includes(match))
+  if (!page) {
+    console.error(`  no page target matching "${match}" on CDP :${cdpPort}`)
+    console.error(`  open targets: ${targets.map((t) => t.url).join(', ') || '(none)'}`)
+    return 1
+  }
+
+  const cdp = new Cdp(page.webSocketDebuggerUrl)
+  await cdp.waitOpen()
+  try {
+    // discover worker child sessions via auto-attach.
+    const workers = new Map<string, string>() // sessionId -> url
+    cdp.on((method, params) => {
+      if (method === 'Target.attachedToTarget' && params.targetInfo?.type === 'worker') {
+        workers.set(params.sessionId, params.targetInfo.url)
+      }
+      if (method === 'Target.detachedFromTarget') workers.delete(params.sessionId)
+    })
+    await cdp.send('Target.setAutoAttach', {
+      autoAttach: true,
+      waitForDebuggerOnStart: false,
+      flatten: true,
+    })
+    // auto-attach events arrive asynchronously after the call resolves.
+    await sleep(500)
+    if (workers.size === 0) {
+      console.error('  no worker targets attached — is the app loaded in this tab?')
+      return 1
+    }
+
+    for (const sid of workers.keys()) {
+      await cdp.send('Profiler.enable', {}, sid)
+      await cdp.send(
+        'Profiler.setSamplingInterval',
+        { interval: sampleInterval * 1000 },
+        sid,
+      ) // µs
+      await cdp.send('Profiler.start', {}, sid)
+    }
+    console.log(
+      `  recording ${duration}s across ${workers.size} worker(s) — interact now…`,
+    )
+    await sleep(duration * 1000)
+
+    const results: Array<{ url: string; profile: any }> = []
+    for (const [sid, url] of workers) {
+      const { profile } = await cdp.send('Profiler.stop', {}, sid)
+      results.push({ url, profile })
+    }
+    results.sort((a, b) => b.profile.samples.length - a.profile.samples.length)
+
+    mkdirSync(dirname(outputPath), { recursive: true })
+    // save the busiest worker (the tenant during interaction) to the main path;
+    // others get a suffix so a multi-worker capture isn't lost.
+    results.forEach((r, i) => {
+      const path =
+        i === 0 ? outputPath : outputPath.replace(/(\.[^.]+)?$/, `.worker${i}$1`)
+      writeFileSync(path, JSON.stringify(r.profile))
+      console.log(`  ${shortUrl(r.url)}: ${r.profile.samples.length} samples → ${path}`)
+      if (opts.verbose && r.profile.samples.length > 0) {
+        for (const fn of topSelfTime(r.profile, 12)) {
+          console.log(`      ${fn.pct.toFixed(1).padStart(5)}%  ${fn.name}  ${fn.url}`)
+        }
+      }
+    })
+    console.log('  open in chrome devtools → Performance → Load profile to inspect.')
+    return 0
+  } finally {
+    cdp.close()
+  }
+}
+
+function printNoCdp(cdpPort: number) {
+  console.error(`  perf cpu needs a CDP-enabled browser on :${cdpPort}.`)
+  console.error(
+    "  the tenant worker can't be profiled via the JS Self-Profiler API (F28),",
+  )
+  console.error('  so the sim must expose Chrome remote debugging. easiest path —')
+  console.error('  open the sim with a CDP port (it stays driveable over the bridge,')
+  console.error('  so you can scroll/navigate while profiling):')
+  console.error('')
+  console.error(
+    `    rnxsim open <metro-port> --new --driver playwright --cdp-port ${cdpPort}`,
+  )
+  console.error(`    rnxsim perf cpu --cdp-port ${cdpPort} --match <metro-port>`)
+  console.error('')
+  console.error('  or launch a standalone CDP Chrome (not bridge-driveable):')
+  console.error('')
+  console.error('    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \\')
+  console.error(
+    `      --remote-debugging-port=${cdpPort} --user-data-dir=/tmp/sootsim-cdp \\`,
+  )
+  console.error('      --no-sandbox --disable-gpu-sandbox \\')
+  // never suggest swiftshader — software rendering pegs every core for the
+  // browser's lifetime (documented machine-freeze cause). metal is the real
+  // rendering path anyway, so the profile is representative.
+  console.error('      --use-gl=angle --use-angle=metal \\')
+  console.error('      "http://localhost:5173/rn/<metro-port>" &')
+  console.error('')
+  console.error('  override the port with --cdp-port or $SOOTSIM_CDP_PORT.')
+}
+
+function shortUrl(url: string): string {
+  if (!url) return '(native)'
+  return url
+    .replace(/^https?:\/\/[^/]+/, '')
+    .replace(/\?.*$/, '')
+    .slice(-50)
+}
+
+function topSelfTime(profile: any, topN: number) {
+  const total = profile.samples.length || 1
+  const byFn = new Map<string, { self: number; name: string; url: string }>()
+  for (const node of profile.nodes) {
+    const f = node.callFrame
+    const key = `${f.functionName || '(anonymous)'}@${shortUrl(f.url)}:${f.lineNumber}`
+    const cur = byFn.get(key) ?? {
+      self: 0,
+      name: f.functionName || '(anonymous)',
+      url: `${shortUrl(f.url)}:${f.lineNumber}`,
+    }
+    cur.self += node.hitCount ?? 0
+    byFn.set(key, cur)
+  }
+  return [...byFn.values()]
+    .map((v) => ({ ...v, pct: (v.self / total) * 100 }))
+    .sort((a, b) => b.self - a.self)
+    .slice(0, topN)
+}
+
+function valueOf(args: string[], flag: string): string | undefined {
+  const i = args.indexOf(flag)
+  if (i < 0 || i === args.length - 1) return undefined
+  return args[i + 1]
+}

package/cli/commands/daemon-mac-app.ts

@@ -0,0 +1,169 @@
+// generate + ad-hoc sign the SootSim Daemon.app wrapper that the launchd
+// agent points its ProgramArguments at.
+//
+// why this exists: macOS Background Task Management (the "X wants to run in
+// the background" prompt + the Login Items entry) reads the *signer* of
+// ProgramArguments[0] to decide what name to display. when launchd is
+// pointed at bun directly the entry shows "software from Jarred Sumner"
+// because that's bun's code-signing identity. wrapping the real invocation
+// in an ad-hoc-signed `.app` lets BTM read CFBundleDisplayName from the
+// bundle Info.plist instead, so the entry reads "SootSim Daemon".
+//
+// the bundle is regenerated every time `daemonInstall` runs — it's tiny
+// (a plist + a shell launcher) and the launcher embeds a snapshot of the
+// invocation, so an `npm update -g sootsim` followed by `sootsim daemon
+// install --force` is the documented upgrade path. there's no notarization
+// or Developer ID signing here yet; ad-hoc + hardened runtime is enough to
+// fix the attribution, and a real signed bundle (shipped via the runtime
+// CDN) is a follow-up.
+
+import { execFileSync } from 'child_process'
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from 'fs'
+import { dirname } from 'path'
+import {
+  daemonAppBundlePath,
+  daemonAppDir,
+  daemonAppLauncherPath,
+} from '../../src/home-paths'
+
+const BUNDLE_IDENTIFIER = 'dev.sootsim.daemon'
+const BUNDLE_DISPLAY_NAME = 'SootSim Daemon'
+// kept in sync with package.json on release. exact value doesn't matter for
+// BTM display — macOS only reads it for "About this app" surfaces — so we
+// hardcode it rather than reach back into the package.json from a runtime
+// path that varies between npm-global, bun-compiled standalone, and dev
+// checkouts.
+const BUNDLE_VERSION = '0.1.36'
+
+export interface DaemonInvocation {
+  /** absolute path to the executable launchd should spawn. */
+  executable: string
+  /** arguments passed to the executable (before server/--port flags). */
+  prefixArgs: string[]
+}
+
+export interface DaemonAppPaths {
+  /** the rebuilt .app bundle. */
+  bundlePath: string
+  /** the Mach-O / shell launcher inside the bundle. launchd points here. */
+  launcherPath: string
+}
+
+/** rebuild ~/.sootsim/daemon-app/SootSim Daemon.app/ for the given invocation
+ *  and re-sign it ad-hoc. safe to call repeatedly; the directory is wiped
+ *  before write so stale state from earlier installs can't leak through. */
+export function ensureDaemonApp(
+  invocation: DaemonInvocation,
+  port: number,
+  logDir: { stdout: string; stderr: string },
+): DaemonAppPaths {
+  const bundlePath = daemonAppBundlePath()
+  const launcherPath = daemonAppLauncherPath()
+  const contentsDir = dirname(dirname(launcherPath))
+  const macOSDir = dirname(launcherPath)
+  const resourcesDir = `${contentsDir}/Resources`
+
+  rmSync(bundlePath, { recursive: true, force: true })
+  mkdirSync(daemonAppDir(), { recursive: true })
+  mkdirSync(macOSDir, { recursive: true })
+  mkdirSync(resourcesDir, { recursive: true })
+
+  writeFileSync(`${contentsDir}/Info.plist`, renderInfoPlist())
+  writeFileSync(`${contentsDir}/PkgInfo`, 'APPL????')
+  writeFileSync(launcherPath, renderLauncherScript(invocation, port, logDir))
+  chmodSync(launcherPath, 0o755)
+
+  // ad-hoc sign the bundle so macOS treats it as a real .app and BTM reads
+  // its Info.plist. `--deep` covers the inner launcher script + future
+  // resources without us having to enumerate them. signing is best-effort —
+  // an unsigned bundle still works for launchd, it just falls back to the
+  // worse BTM display, which is no worse than the status quo.
+  try {
+    execFileSync('codesign', ['--force', '--sign', '-', '--deep', bundlePath], {
+      stdio: 'pipe',
+    })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.warn(
+      `  warning: ad-hoc codesign of ${bundlePath} failed: ${msg}\n` +
+        `  the daemon will still run, but Login Items may show a generic name.`,
+    )
+  }
+
+  return { bundlePath, launcherPath }
+}
+
+function renderInfoPlist(): string {
+  // LSUIElement + LSBackgroundOnly together hide the app from the Dock and
+  // the Cmd-Tab switcher. CFBundleDisplayName is what Login Items shows.
+  // NSHumanReadableCopyright is what "About" surfaces show.
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key><string>en</string>
+  <key>CFBundleDisplayName</key><string>${BUNDLE_DISPLAY_NAME}</string>
+  <key>CFBundleExecutable</key><string>sootsim-daemon</string>
+  <key>CFBundleIdentifier</key><string>${BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
+  <key>CFBundleName</key><string>${BUNDLE_DISPLAY_NAME}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleShortVersionString</key><string>${BUNDLE_VERSION}</string>
+  <key>CFBundleSignature</key><string>????</string>
+  <key>CFBundleVersion</key><string>${BUNDLE_VERSION}</string>
+  <key>LSBackgroundOnly</key><true/>
+  <key>LSUIElement</key><true/>
+  <key>LSMinimumSystemVersion</key><string>13.0</string>
+  <key>NSHumanReadableCopyright</key><string>Tamagui LLC</string>
+</dict>
+</plist>
+`
+}
+
+function renderLauncherScript(
+  invocation: DaemonInvocation,
+  port: number,
+  logDir: { stdout: string; stderr: string },
+): string {
+  // `exec` replaces the shell process with bun/node, so launchd's PID
+  // tracking + KeepAlive both follow the real daemon process. stdout/stderr
+  // are already redirected by the launchd plist's StandardOutPath /
+  // StandardErrorPath, so we don't redirect again here — doing so would
+  // hide log output from `launchctl print`.
+  const parts = [
+    invocation.executable,
+    ...invocation.prefixArgs,
+    'serve',
+    '--quiet',
+    '--port',
+    String(port),
+  ]
+  const quoted = parts.map(shellSingleQuote).join(' ')
+  const stdout = shellSingleQuote(logDir.stdout)
+  const stderr = shellSingleQuote(logDir.stderr)
+  return `#!/bin/sh
+# SootSim Daemon launcher — auto-generated by 'rnxsim setup'.
+# launchd spawns this; we exec the real rnxsim invocation in place so
+# launchd tracks the daemon process, not the shell wrapper.
+#
+# stdout: ${logDir.stdout}
+# stderr: ${logDir.stderr}
+# a missing or broken executable can make launchd retry forever. truncate a
+# retry log before it passes 10 MiB so that failure stays bounded on disk.
+for log_path in ${stdout} ${stderr}; do
+  if [ -f "$log_path" ]; then
+    log_bytes=$(wc -c < "$log_path" 2>/dev/null || echo 0)
+    if [ "$log_bytes" -gt 10485760 ]; then
+      : > "$log_path"
+    fi
+  fi
+done
+exec ${quoted}
+`
+}
+
+function shellSingleQuote(value: string): string {
+  // single-quote everything and escape embedded single quotes the POSIX way.
+  // safe for paths containing spaces, $, backticks, etc.
+  return `'${value.replace(/'/g, `'\\''`)}'`
+}