peachsim 0.1.527

package/cli/commands/assert.ts

@@ -0,0 +1,542 @@
+// `rnx assert <verb> <verb-args...> <assertion-flags...>`
+//
+// thin wrapper that runs any read verb with --json forced on, captures the
+// JSON payload, and converts predicate flags into a bisect-friendly exit
+// code. see docs for the full flag surface — this file intentionally stays
+// small: every assertion is a pure function over the parsed JSON, and the
+// only runtime work is the retry loop for --within and the optional shell
+// out to `jq` for --jq.
+//
+// exit codes:
+//   0   assertion passed                    (bisect: good)
+//   1   assertion evaluated and failed      (bisect: bad)
+//   125 could not evaluate                  (bisect: skip)
+//   2   misuse — bad flags, unknown verb    (treated as bad by bisect)
+
+import { spawn } from 'child_process'
+import { rnxExit } from '../run-rnx'
+import { rnxSelfInvocation } from '../self-invocation'
+
+// READ_VERBS lists every command whose stdout we know is valid JSON under
+// --json. keeping this explicit means `rnx assert tap 100 200` fails
+// fast with a clear message instead of silently running a write verb and
+// trying to parse "  tapped 100,200" as JSON.
+const READ_VERBS = new Set([
+  // top-level
+  'describe',
+  'find',
+  'list',
+  'network',
+  'logs',
+  // get <noun>
+  'count',
+  'tree',
+  'url',
+  'a11y',
+  'node',
+  'layout',
+  'keyboard',
+  'errors',
+  'warnings',
+  'requests',
+  'animations',
+  'animation',
+  'state',
+  'sample-color',
+])
+
+// assertion flags that assert recognizes. everything else is passed through
+// to the inner verb untouched. keeping this as a set (rather than positional
+// parsing) means `rnx assert find --testid X --count 4` reads naturally.
+const BOOL_ASSERT_FLAGS = new Set([
+  '--exists',
+  '--empty',
+  '--negate',
+  '--quiet',
+  '--allow-timeout',
+  '!',
+])
+const VALUE_ASSERT_FLAGS = new Set([
+  '--count',
+  '--count-at-least',
+  '--count-at-most',
+  '--contains',
+  '--not-contains',
+  '--matches',
+  '--not-matches',
+  '--equals',
+  '--jq',
+  '--has-path',
+  '--within',
+])
+// --path-equals takes TWO values: <dotted.path> <value>
+const DUAL_VALUE_ASSERT_FLAGS = new Set(['--path-equals'])
+
+interface Predicate {
+  kind: string
+  args: string[]
+}
+
+interface AssertArgs {
+  verbArgs: string[]
+  predicates: Predicate[]
+  withinMs: number
+  negate: boolean
+  quiet: boolean
+  allowTimeout: boolean
+}
+
+function parseAssertArgs(raw: string[]): AssertArgs | { error: string } {
+  const verbArgs: string[] = []
+  const predicates: Predicate[] = []
+  let withinMs = 0
+  let negate = false
+  let quiet = false
+  let allowTimeout = false
+
+  for (let i = 0; i < raw.length; i++) {
+    const a = raw[i]
+    if (a === '--within') {
+      const v = Number(raw[i + 1])
+      if (!Number.isFinite(v) || v < 0) {
+        return { error: `--within requires a non-negative number, got: ${raw[i + 1]}` }
+      }
+      withinMs = v
+      i++
+      continue
+    }
+    if (a === '--negate' || a === '!') {
+      negate = true
+      continue
+    }
+    if (a === '--quiet') {
+      quiet = true
+      continue
+    }
+    if (a === '--allow-timeout') {
+      allowTimeout = true
+      continue
+    }
+    if (BOOL_ASSERT_FLAGS.has(a)) {
+      predicates.push({ kind: a, args: [] })
+      continue
+    }
+    if (VALUE_ASSERT_FLAGS.has(a)) {
+      const v = raw[i + 1]
+      if (v == null) return { error: `${a} requires a value` }
+      predicates.push({ kind: a, args: [v] })
+      i++
+      continue
+    }
+    if (DUAL_VALUE_ASSERT_FLAGS.has(a)) {
+      const v1 = raw[i + 1]
+      const v2 = raw[i + 2]
+      if (v1 == null || v2 == null) return { error: `${a} requires <path> <value>` }
+      predicates.push({ kind: a, args: [v1, v2] })
+      i += 2
+      continue
+    }
+    verbArgs.push(a)
+  }
+
+  if (verbArgs.length === 0)
+    return { error: 'assert requires a verb (e.g. find, describe, get errors)' }
+  return { verbArgs, predicates, withinMs, negate, quiet, allowTimeout }
+}
+
+// resolve the verb name the user typed. handles `get <noun>`, `do <verb>`,
+// and plain top-level verbs. returns null if the verb is unknown or is a
+// known write verb (which would never produce parseable json).
+function resolveReadVerb(verbArgs: string[]): string | null {
+  if (verbArgs[0] === 'get' || verbArgs[0] === 'debug') {
+    return READ_VERBS.has(verbArgs[1]) ? verbArgs[1] : null
+  }
+  if (verbArgs[0] === 'do' || verbArgs[0] === 'wait') return null
+  return READ_VERBS.has(verbArgs[0]) ? verbArgs[0] : null
+}
+
+interface VerbResult {
+  ok: boolean
+  payload: unknown
+  reason?: string
+}
+
+async function runVerbOnce(verbArgs: string[]): Promise<VerbResult> {
+  // re-invoke self through the real CLI entry, so every code path the user's
+  // verb would take, assert takes too.
+  const { executable, prefixArgs } = rnxSelfInvocation()
+  const args = [...prefixArgs, ...verbArgs, '--json']
+
+  return new Promise<VerbResult>((resolve) => {
+    const proc = spawn(executable, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    })
+    let stdout = ''
+    let stderr = ''
+    proc.stdout.on('data', (d) => (stdout += d.toString()))
+    proc.stderr.on('data', (d) => (stderr += d.toString()))
+    proc.on('error', (err) => {
+      resolve({ ok: false, payload: null, reason: `spawn failed: ${err.message}` })
+    })
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        // stderr tail usually has the bridge diagnostic — include a short
+        // slice so the skip message is actionable.
+        const tail = stderr.trim().split('\n').slice(-2).join(' | ').slice(0, 200)
+        resolve({
+          ok: false,
+          payload: null,
+          reason: `verb exited ${code}${tail ? `: ${tail}` : ''}`,
+        })
+        return
+      }
+      if (!stdout.trim()) {
+        resolve({ ok: false, payload: null, reason: 'verb produced no output' })
+        return
+      }
+      try {
+        const payload = JSON.parse(stdout)
+        resolve({ ok: true, payload })
+      } catch {
+        resolve({
+          ok: false,
+          payload: null,
+          reason: `verb output was not valid json: ${stdout.slice(0, 120)}`,
+        })
+      }
+    })
+  })
+}
+
+// read a dotted path against a JSON value. numeric segments index arrays,
+// anything else reads object keys. returns { found: false } for any missing
+// segment so callers can distinguish "path exists, value is null" from
+// "path doesn't exist."
+function readPath(
+  value: unknown,
+  path: string,
+): { found: true; value: unknown } | { found: false } {
+  const parts = path.split('.').filter((s) => s.length > 0)
+  let cur: unknown = value
+  for (const part of parts) {
+    if (cur == null) return { found: false }
+    if (Array.isArray(cur)) {
+      const idx = Number(part)
+      if (!Number.isInteger(idx) || idx < 0 || idx >= cur.length) return { found: false }
+      cur = cur[idx]
+      continue
+    }
+    if (typeof cur === 'object') {
+      const obj = cur as Record<string, unknown>
+      if (!(part in obj)) return { found: false }
+      cur = obj[part]
+      continue
+    }
+    return { found: false }
+  }
+  return { found: true, value: cur }
+}
+
+interface PredicateResult {
+  ok: boolean
+  reason: string
+}
+
+function lengthOf(payload: unknown): number | null {
+  if (Array.isArray(payload)) return payload.length
+  if (payload && typeof payload === 'object') return Object.keys(payload).length
+  return null
+}
+
+async function evalPredicate(
+  pred: Predicate,
+  payload: unknown,
+): Promise<PredicateResult> {
+  const { kind, args } = pred
+  switch (kind) {
+    case '--exists': {
+      if (payload == null) return { ok: false, reason: 'payload is null' }
+      const len = lengthOf(payload)
+      if (len === 0) return { ok: false, reason: 'payload is empty' }
+      return { ok: true, reason: 'exists' }
+    }
+    case '--empty': {
+      if (payload == null) return { ok: true, reason: 'payload is null' }
+      const len = lengthOf(payload)
+      if (len === 0) return { ok: true, reason: 'payload is empty' }
+      return { ok: false, reason: `payload has ${len} item(s)` }
+    }
+    case '--count': {
+      const want = Number(args[0])
+      const got = lengthOf(payload)
+      if (got == null)
+        return { ok: false, reason: `payload not countable (${typeof payload})` }
+      return {
+        ok: got === want,
+        reason: `count=${got}, want=${want}`,
+      }
+    }
+    case '--count-at-least': {
+      const want = Number(args[0])
+      const got = lengthOf(payload)
+      if (got == null) return { ok: false, reason: `payload not countable` }
+      return { ok: got >= want, reason: `count=${got}, want>=${want}` }
+    }
+    case '--count-at-most': {
+      const want = Number(args[0])
+      const got = lengthOf(payload)
+      if (got == null) return { ok: false, reason: `payload not countable` }
+      return { ok: got <= want, reason: `count=${got}, want<=${want}` }
+    }
+    case '--contains': {
+      const needle = args[0]
+      const hay = JSON.stringify(payload)
+      return {
+        ok: hay.includes(needle),
+        reason: hay.includes(needle) ? `contains "${needle}"` : `missing "${needle}"`,
+      }
+    }
+    case '--not-contains': {
+      const needle = args[0]
+      const hay = JSON.stringify(payload)
+      return {
+        ok: !hay.includes(needle),
+        reason: !hay.includes(needle)
+          ? `not contains "${needle}"`
+          : `unexpected "${needle}"`,
+      }
+    }
+    case '--matches': {
+      const re = new RegExp(args[0])
+      const hay = JSON.stringify(payload)
+      const ok = re.test(hay)
+      return {
+        ok,
+        reason: ok ? `matches /${args[0]}/` : `no match for /${args[0]}/`,
+      }
+    }
+    case '--not-matches': {
+      const re = new RegExp(args[0])
+      const hay = JSON.stringify(payload)
+      const ok = !re.test(hay)
+      return {
+        ok,
+        reason: ok ? `not matches /${args[0]}/` : `unexpected /${args[0]}/`,
+      }
+    }
+    case '--equals': {
+      const want = args[0]
+      const got =
+        typeof payload === 'string'
+          ? payload
+          : typeof payload === 'number' || typeof payload === 'boolean'
+            ? String(payload)
+            : JSON.stringify(payload)
+      return {
+        ok: got === want,
+        reason: `got=${JSON.stringify(got)}, want=${JSON.stringify(want)}`,
+      }
+    }
+    case '--has-path': {
+      const r = readPath(payload, args[0])
+      return {
+        ok: r.found,
+        reason: r.found ? `path ${args[0]} present` : `path ${args[0]} missing`,
+      }
+    }
+    case '--path-equals': {
+      const [path, want] = args
+      const r = readPath(payload, path)
+      if (!r.found) return { ok: false, reason: `path ${path} missing` }
+      const got =
+        typeof r.value === 'string' ||
+        typeof r.value === 'number' ||
+        typeof r.value === 'boolean'
+          ? String(r.value)
+          : JSON.stringify(r.value)
+      return { ok: got === want, reason: `${path}=${got}, want=${want}` }
+    }
+    case '--jq': {
+      // shell out to `jq`. if jq isn't installed we can't evaluate, so we
+      // bubble that up as a 125-skip rather than treating it as a failure.
+      const expr = args[0]
+      try {
+        const out = await runJq(expr, payload)
+        const trimmed = out.trim()
+        const truthy =
+          trimmed.length > 0 &&
+          trimmed !== 'null' &&
+          trimmed !== 'false' &&
+          trimmed !== '""'
+        return { ok: truthy, reason: `jq: ${trimmed.slice(0, 120)}` }
+      } catch (err: any) {
+        // throw so the caller can turn this into a 125 — consistent with how
+        // "verb crashed" is treated. we don't want bisect marking commits bad
+        // because jq isn't installed.
+        throw new Error(`jq evaluation failed: ${err.message}`)
+      }
+    }
+    default:
+      return { ok: false, reason: `unknown predicate ${kind}` }
+  }
+}
+
+function runJq(expr: string, payload: unknown): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('jq', [expr], { stdio: ['pipe', 'pipe', 'pipe'] })
+    let out = ''
+    let err = ''
+    proc.stdout.on('data', (d) => (out += d.toString()))
+    proc.stderr.on('data', (d) => (err += d.toString()))
+    proc.on('error', reject)
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(err.trim() || `jq exited ${code}`))
+        return
+      }
+      resolve(out)
+    })
+    proc.stdin.end(JSON.stringify(payload))
+  })
+}
+
+export async function runAssert(rawArgs: string[]): Promise<void> {
+  if (rawArgs[0] === '--help' || rawArgs[0] === '-h' || rawArgs.length === 0) {
+    printHelp()
+    rnxExit(rawArgs.length === 0 ? 2 : 0)
+  }
+
+  const parsed = parseAssertArgs(rawArgs)
+  if ('error' in parsed) {
+    process.stderr.write(`  assert: ${parsed.error}\n`)
+    rnxExit(2)
+  }
+
+  const { verbArgs, predicates, withinMs, negate, quiet, allowTimeout } = parsed
+
+  const verb = resolveReadVerb(verbArgs)
+  if (!verb) {
+    process.stderr.write(
+      `  assert: unknown or non-read verb: ${verbArgs.join(' ')}\n` +
+        `  supported: ${Array.from(READ_VERBS).sort().join(', ')}\n`,
+    )
+    rnxExit(2)
+  }
+
+  // default assertion when none given is --exists. matches the common
+  // "does this node / error / entry even show up?" check.
+  const effectivePredicates =
+    predicates.length > 0 ? predicates : [{ kind: '--exists', args: [] }]
+
+  const deadline = withinMs > 0 ? Date.now() + withinMs : 0
+  let attempts = 0
+  let lastFailReason = ''
+  let lastVerbSkipReason = ''
+
+  while (true) {
+    attempts++
+    const verbResult = await runVerbOnce(verbArgs)
+    if (!verbResult.ok) {
+      lastVerbSkipReason = verbResult.reason || 'verb failed'
+      if (Date.now() < deadline) {
+        await sleep(150)
+        continue
+      }
+      // out of retry budget. default is skip (125) because "verb couldn't
+      // evaluate" is distinct from "assertion evaluated and failed".
+      // --allow-timeout flips this to fail (1) — used when an auto-wait
+      // timeout inside the verb is a meaningful negative signal, not a
+      // "please bisect-skip this commit".
+      const exitCode = allowTimeout ? 1 : 125
+      if (!quiet) {
+        const label = exitCode === 1 ? 'fail' : 'skip'
+        process.stderr.write(`  assert: ${label} — ${lastVerbSkipReason}\n`)
+      }
+      rnxExit(exitCode)
+    }
+
+    let allPass = true
+    const reasons: string[] = []
+    try {
+      for (const pred of effectivePredicates) {
+        const r = await evalPredicate(pred, verbResult.payload)
+        reasons.push(`${pred.kind}: ${r.reason}`)
+        if (!r.ok) {
+          allPass = false
+          break
+        }
+      }
+    } catch (err: any) {
+      if (!quiet) process.stderr.write(`  assert: skip — ${err.message}\n`)
+      rnxExit(125)
+    }
+
+    const pass = negate ? !allPass : allPass
+    if (pass) {
+      if (!quiet) {
+        process.stderr.write(
+          `  assert: pass${attempts > 1 ? ` (attempt ${attempts})` : ''} — ${reasons.join('; ')}\n`,
+        )
+      }
+      rnxExit(0)
+    }
+
+    lastFailReason = reasons.join('; ')
+    if (Date.now() < deadline) {
+      await sleep(150)
+      continue
+    }
+    if (!quiet) {
+      process.stderr.write(
+        `  assert: fail${attempts > 1 ? ` after ${attempts} attempt(s)` : ''} — ${lastFailReason}\n`,
+      )
+    }
+    rnxExit(1)
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function printHelp(): void {
+  process.stdout.write(`
+rnx assert — run any read verb and convert its output into a bisect-friendly exit code.
+
+usage:
+  rnx assert <verb> <verb-args...> <assertion-flags...>
+
+exit codes:
+  0    assertion passed          (git bisect: good)
+  1    assertion failed          (git bisect: bad)
+  125  could not evaluate        (git bisect: skip — app not loaded, verb crashed)
+  2    misuse (bad flags/verb)
+
+assertion flags (AND'd when multiple are given):
+  --count <n>                    result array has exactly n items
+  --count-at-least <n>           length >= n
+  --count-at-most <n>            length <= n
+  --exists                       non-null, non-empty (default if no flag given)
+  --empty                        null or zero length
+  --contains <str>               JSON.stringify(result) contains str (repeatable)
+  --not-contains <str>           opposite
+  --matches <regex>              result (stringified) matches regex
+  --not-matches <regex>          opposite
+  --equals <literal>             scalar equality
+  --has-path <dotted.path>       nested path exists
+  --path-equals <path> <value>   nested path equals value
+  --jq <expr>                    jq expression is truthy (requires jq on PATH)
+  --within <ms>                  retry verb + predicates until pass or deadline
+  --allow-timeout                treat verb auto-wait timeout as a fail, not a skip
+  --negate, !                    flip pass/fail (does not flip skip)
+  --quiet                        suppress the one-line pass/fail summary
+
+examples:
+  rnx assert find --testid set-max-input --count 4
+  rnx assert describe --contains "swap-form-header"
+  rnx assert get errors --count 0
+  rnx assert find --testid submit --exists --within 3000
+  rnx assert describe --jq '.tree | contains("swap-form-header")'
+`)
+}

package/cli/commands/auth.ts

@@ -0,0 +1,71 @@
+import {
+  refreshSharedDesktopAuthSession,
+  sharedDesktopAuthAccounts,
+} from '../../src/auth/shared-session'
+import { CHOOSE_ACCOUNT_HINT, resolveCliAuth } from '../auth'
+import { rnxExit } from '../run-rnx'
+
+function printHelp(): void {
+  console.log(`
+rnx auth — inspect CLI auth
+
+usage:
+  rnx auth
+
+API keys are read from RNX_API_KEY.
+Use \`rnx login\` to sign in and \`rnx logout\` to clear the desktop session.
+`)
+}
+
+async function printStatus(): Promise<number> {
+  const auth = resolveCliAuth()
+  if (!auth) {
+    console.log('  not signed in')
+    console.log('  set RNX_API_KEY=sk_rnx_... or run `rnx login`')
+    return 1
+  }
+
+  if (auth.kind === 'api-key') {
+    console.log(`  api key ${auth.secret.slice(0, 14)}...`)
+    console.log(`  source: ${auth.envName} env var`)
+    return 0
+  }
+
+  if (auth.kind === 'github') {
+    console.log(`  github token (${auth.source})`)
+    console.log(`  repo: ${auth.repoId}`)
+    return 0
+  }
+
+  const current = await refreshSharedDesktopAuthSession(auth.origin)
+  const user = current?.user
+  const accounts = sharedDesktopAuthAccounts(user)
+  const accountId = current?.accountId ?? auth.accountId
+  const account = accounts.find((candidate) => candidate.id === accountId)
+  console.log(`  ${user?.email || user?.name || user?.id || 'signed in'}`)
+  console.log(
+    `  account: ${
+      account ? `${account.name} (${account.id})` : (accountId ?? CHOOSE_ACCOUNT_HINT)
+    }`,
+  )
+  console.log(`  origin: ${current?.origin ?? auth.origin}`)
+  if (current?.updatedAt) console.log(`  updated: ${current.updatedAt}`)
+  return 0
+}
+
+export async function runAuth(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const sub = args.find((arg) => !arg.startsWith('-'))
+  if (!sub || sub === 'status') {
+    process.exitCode = await printStatus()
+    return
+  }
+
+  console.error(`  unknown auth command: ${sub}`)
+  printHelp()
+  rnxExit(1)
+}

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

@@ -0,0 +1,71 @@
+// ProjectFilePlane over an already-built bundle held in memory.
+//
+// a prebuilt Box has no sources, so there is no checkout to index and nothing
+// on disk to stay in step with: the whole project is the bundle the page boots.
+// CheckoutFilePlane cannot serve this because it asks git what belongs to the
+// project, and a bundle produced by a build lives outside any checkout.
+//
+// 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'
+
+export class BundleFilePlane implements ProjectFilePlane {
+  private readonly parts = new Map<string, Uint8Array>()
+  private readonly entries = new Map<string, ProjectFileMeta>()
+
+  constructor(bundle: Uint8Array) {
+    if (bundle.byteLength === 0) throw new Error('a Box bundle cannot be empty')
+    for (
+      let offset = 0, index = 0;
+      offset < bundle.byteLength;
+      offset += PREBUILT_BUNDLE_PART_BYTES, index++
+    ) {
+      const part = bundle.subarray(offset, offset + PREBUILT_BUNDLE_PART_BYTES)
+      this.record(prebuiltBundlePartPath(index), part)
+    }
+  }
+
+  private record(path: string, content: Uint8Array): void {
+    this.parts.set(path, content)
+    this.entries.set(path, {
+      size: content.byteLength,
+      readOnly: false,
+      // a Metro bundle is JavaScript. the flag is what decides whether a shell
+      // may overwrite a file with text, and marking it binary would make the
+      // bundle unwritable from inside the box for no reason.
+      binary: false,
+    })
+  }
+
+  index(): ReadonlyMap<string, ProjectFileMeta> {
+    return this.entries
+  }
+
+  // nothing else can change this plane, so the index is already current.
+  refresh(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  async read(path: string): Promise<string> {
+    return new TextDecoder().decode(await this.readBytes(path))
+  }
+
+  readBytes(path: string): Promise<Uint8Array> {
+    const part = this.parts.get(path)
+    if (!part) return Promise.reject(new Error(`no such file: ${path}`))
+    return Promise.resolve(part)
+  }
+
+  write(path: string, content: Uint8Array): Promise<void> {
+    this.record(path, content)
+    return Promise.resolve()
+  }
+
+  delete(path: string): Promise<void> {
+    this.parts.delete(path)
+    this.entries.delete(path)
+    return Promise.resolve()
+  }
+}