peachsim 0.1.527

package/cli/commands/agent.ts

@@ -0,0 +1,439 @@
+// user-facing `rnx agent` command tree.
+//
+// session-lifecycle commands (start, prompt, end, watch) route through
+// the bridge daemon — the daemon owns the single FIFO reader per
+// session, so concurrent cli watches + electron UI subscribers no longer
+// steal bytes from each other. the daemon auto-spawns on first use via
+// `connectToDaemon`.
+//
+// disk-only inspection commands (projects, sessions, paths, transcript,
+// attach, project show/remove) read the attached-projects JSON directly —
+// no daemon needed, so `rnx agent projects` stays fast when no
+// wrapper is live.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  AgentDaemonError,
+  connectToDaemon,
+  type AgentDaemonClient,
+} from '../../src/agent-daemon-client'
+import { parseAgentEventLine, type AgentEvent } from '../../src/agent-events'
+import {
+  eventsFifoPath,
+  pidIsAlive,
+  promptFifoPath,
+  sessionDir,
+  transcriptPath,
+  type Provider,
+} from '../../src/agent-sessions'
+import {
+  costThisWeek,
+  deleteProject,
+  findProjectById,
+  getUserDataDir,
+  listProjects,
+  listSessions,
+  upsertProject,
+  type AgentSession,
+  type AttachedProject,
+} from '../../src/attached-projects'
+import { printCommandHelp } from '../help'
+import { resolveDefaultBridgePort } from '../ws-bridge'
+
+// the bridge this invocation talks to: `-p`, else the same dev-bridge or
+// daemon pick every other command makes (PORT_OFFSET and SOOTSIM_BRIDGE_PORT
+// included).
+let daemonPort = 0
+
+export async function runAgentCommand(
+  argv: string[],
+  opts: { port?: number } = {},
+): Promise<number> {
+  daemonPort = opts.port ?? resolveDefaultBridgePort()
+  const [sub, ...rest] = argv
+  try {
+    switch (sub) {
+      case undefined:
+      case '--help':
+      case '-h':
+      case 'help':
+        printHelp()
+        return 0
+      case 'attach':
+        return await cmdAttach(rest)
+      case 'projects':
+        return await cmdProjects()
+      case 'project':
+        return await cmdProject(rest)
+      case 'sessions':
+        return await cmdSessions(rest)
+      case 'start':
+        return await cmdStart(rest)
+      case 'prompt':
+        return await cmdPrompt(rest)
+      case 'watch':
+        return await cmdWatch(rest)
+      case 'transcript':
+        return await cmdTranscript(rest)
+      case 'end':
+        return await cmdEnd(rest)
+      case 'paths':
+        return await cmdPaths()
+      default:
+        process.stderr.write(`unknown agent subcommand: ${sub}\n`)
+        printHelp()
+        return 2
+    }
+  } catch (err) {
+    if (err instanceof AgentDaemonError) {
+      process.stderr.write(`${err.message}\n`)
+      return 1
+    }
+    throw err
+  }
+}
+
+/** open a daemon client for a single command. callers are responsible for
+ *  closing the client when done so the CLI process exits promptly. */
+async function withDaemon<T>(fn: (client: AgentDaemonClient) => Promise<T>): Promise<T> {
+  const client = await connectToDaemon({
+    port: daemonPort,
+    clientLabel: 'sootsim-agent-cli',
+  })
+  try {
+    return await fn(client)
+  } finally {
+    client.close()
+  }
+}
+
+function printHelp(): void {
+  // delegate to the meta-driven renderer so bare `rnx agent`, `--help`,
+  // and `unknown subcommand` paths all show the same rich help (header,
+  // options, examples) instead of a sparse hand-coded summary.
+  printCommandHelp('agent')
+}
+
+// --- arg parsing ---
+
+function parseFlags(
+  argv: string[],
+  known: Record<string, 'value' | 'bool'>,
+): { flags: Record<string, string | boolean>; positional: string[] } {
+  const flags: Record<string, string | boolean> = {}
+  const positional: string[] = []
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    const kind = known[arg]
+    if (kind === 'value') {
+      flags[arg] = argv[i + 1] ?? ''
+      i++
+    } else if (kind === 'bool') {
+      flags[arg] = true
+    } else {
+      positional.push(arg)
+    }
+  }
+  return { flags, positional }
+}
+
+function resolveProvider(raw: unknown, fallback: Provider = 'codex'): Provider {
+  if (raw === 'codex' || raw === 'claude') return raw
+  return fallback
+}
+
+// --- subcommands ---
+
+async function cmdAttach(argv: string[]): Promise<number> {
+  const { flags, positional } = parseFlags(argv, {
+    '--name': 'value',
+    '--provider': 'value',
+  })
+  const dir = positional[0]
+  if (!dir) {
+    process.stderr.write(
+      'usage: rnx agent attach <dir> [--name X] [--provider codex|claude]\n',
+    )
+    return 2
+  }
+  const absolute = path.resolve(dir)
+  if (!fs.existsSync(absolute)) {
+    process.stderr.write(`directory does not exist: ${absolute}\n`)
+    return 1
+  }
+  const project = upsertProject({
+    cwd: absolute,
+    name: (flags['--name'] as string) || path.basename(absolute),
+    preferredProvider: resolveProvider(flags['--provider']),
+    sourceRoots: [absolute],
+  })
+  process.stdout.write(
+    `✓ attached "${project.name}" (id: ${project.id})\n` +
+      `  cwd: ${project.cwd}\n` +
+      `  framework: ${project.framework}\n` +
+      `  preferred provider: ${project.preferredProvider}\n`,
+  )
+  return 0
+}
+
+async function cmdProjects(): Promise<number> {
+  const projects = [...listProjects()].sort((a, b) => b.updatedAt - a.updatedAt)
+  if (projects.length === 0) {
+    process.stdout.write('no attached projects yet. try `rnx agent attach <dir>`.\n')
+    return 0
+  }
+  const header = `${'ID'.padEnd(18)} ${'NAME'.padEnd(20)} ${'FRAMEWORK'.padEnd(10)} ${'PROVIDER'.padEnd(8)} ${'7D COST'.padEnd(10)} CWD\n`
+  process.stdout.write(header)
+  for (const p of projects) {
+    const cost = costThisWeek(p)
+    const costCell = cost > 0 ? `$${cost.toFixed(2)}` : '—'
+    process.stdout.write(
+      `${p.id.padEnd(18)} ${truncate(p.name, 20).padEnd(20)} ${p.framework.padEnd(10)} ${p.preferredProvider.padEnd(8)} ${costCell.padEnd(10)} ${p.cwd}\n`,
+    )
+  }
+  return 0
+}
+
+async function cmdProject(argv: string[]): Promise<number> {
+  const [action, id] = argv
+  if (action === 'show') {
+    if (!id) {
+      process.stderr.write('usage: rnx agent project show <id>\n')
+      return 2
+    }
+    const project = findProjectById(id)
+    if (!project) {
+      process.stderr.write(`no project with id=${id}\n`)
+      return 1
+    }
+    process.stdout.write(JSON.stringify(project, null, 2) + '\n')
+    return 0
+  }
+  if (action === 'remove') {
+    if (!id) {
+      process.stderr.write('usage: rnx agent project remove <id>\n')
+      return 2
+    }
+    deleteProject(id)
+    process.stdout.write(`✓ removed project ${id}\n`)
+    return 0
+  }
+  process.stderr.write('usage: rnx agent project [show|remove] <id>\n')
+  return 2
+}
+
+async function cmdSessions(argv: string[]): Promise<number> {
+  const { flags } = parseFlags(argv, { '--project': 'value', '--all': 'bool' })
+  const projectId = (flags['--project'] as string) || undefined
+  const showAll = flags['--all'] === true
+  let sessions = listSessions(projectId)
+  if (!showAll) {
+    sessions = sessions.filter((s) => s.status !== 'ended')
+  }
+  sessions = sessions.sort((a, b) => b.lastSeenAt - a.lastSeenAt)
+  if (sessions.length === 0) {
+    process.stdout.write(
+      showAll ? 'no sessions.\n' : 'no active sessions. pass --all to include ended.\n',
+    )
+    return 0
+  }
+  const header = `${'SESSION'.padEnd(26)} ${'PROJECT'.padEnd(18)} ${'PROVIDER'.padEnd(8)} ${'STATUS'.padEnd(16)} ${'ALIVE'.padEnd(5)} LAST PROMPT\n`
+  process.stdout.write(header)
+  for (const s of sessions) {
+    const alive = pidIsAlive(s.wrapperPid, s.id) ? 'yes' : 'no'
+    const prompt = s.lastPrompt ? truncate(s.lastPrompt, 40) : ''
+    process.stdout.write(
+      `${shortId(s.id).padEnd(26)} ${shortId(s.projectId).padEnd(18)} ${s.provider.padEnd(8)} ${s.status.padEnd(16)} ${alive.padEnd(5)} ${prompt}\n`,
+    )
+  }
+  return 0
+}
+
+async function cmdStart(argv: string[]): Promise<number> {
+  const { flags, positional } = parseFlags(argv, {
+    '--provider': 'value',
+    '--codex-bin': 'value',
+    '--claude-bin': 'value',
+    '--fresh-thread': 'bool',
+  })
+  const projectId = positional[0]
+  if (!projectId) {
+    process.stderr.write(
+      'usage: rnx agent start <projectId> [--provider codex|claude] [--fresh-thread]\n',
+    )
+    return 2
+  }
+  const result = await withDaemon((client) =>
+    client.startSession({
+      projectId,
+      provider:
+        resolveProvider(flags['--provider'], undefined as unknown as Provider) ||
+        undefined,
+      codexBin: (flags['--codex-bin'] as string) || undefined,
+      claudeBin: (flags['--claude-bin'] as string) || undefined,
+      freshThread: flags['--fresh-thread'] === true,
+    }),
+  )
+  const project = findProjectById(result.session.projectId)!
+  process.stdout.write(
+    `✓ session ${result.session.id} started\n` +
+      `  project: ${project.name} (${project.id})\n` +
+      `  provider: ${result.session.provider}\n` +
+      `  pid: ${result.wrapperPid}\n` +
+      `  prompt with: rnx agent prompt ${result.session.id} "<text>"\n` +
+      `  watch events: rnx agent watch ${result.session.id}\n`,
+  )
+  return 0
+}
+
+async function cmdPrompt(argv: string[]): Promise<number> {
+  const [sessionId, ...rest] = argv
+  const text = rest.join(' ')
+  if (!sessionId || !text) {
+    process.stderr.write('usage: rnx agent prompt <sessionId> "<text>"\n')
+    return 2
+  }
+  await withDaemon((client) => client.sendPrompt(sessionId, { text }))
+  process.stdout.write(`✓ prompt sent to ${sessionId}\n`)
+  return 0
+}
+
+async function cmdWatch(argv: string[]): Promise<number> {
+  const sessionId = argv[0]
+  if (!sessionId) {
+    process.stderr.write('usage: rnx agent watch <sessionId>\n')
+    return 2
+  }
+  process.stdout.write(`watching ${sessionId}\n---\n`)
+  // the daemon owns the FIFO reader. we stay subscribed until SIGINT —
+  // this is the one command that requires a persistent daemon client.
+  const client = await connectToDaemon({
+    port: daemonPort,
+    clientLabel: 'sootsim-agent-watch',
+  })
+  let resolveExit: (code: number) => void
+  const exit = new Promise<number>((resolve) => {
+    resolveExit = resolve
+  })
+  const offEvent = client.onAgentEvent(({ sessionId: sid, event }) => {
+    if (sid !== sessionId) return
+    process.stdout.write(formatEvent(event) + '\n')
+  })
+  const offDisconnect = client.onDisconnect(() => {
+    process.stderr.write('\n[rnx] daemon disconnected; exiting watch.\n')
+    resolveExit(1)
+  })
+  try {
+    await client.subscribeEvents(sessionId)
+  } catch (err) {
+    offEvent()
+    offDisconnect()
+    client.close()
+    throw err
+  }
+  process.on('SIGINT', () => {
+    offEvent()
+    offDisconnect()
+    void client.unsubscribeEvents(sessionId).catch(() => {})
+    client.close()
+    resolveExit(130)
+  })
+  return exit
+}
+
+function formatEvent(ev: AgentEvent): string {
+  const ts = fmtTs(ev.ts)
+  switch (ev.type) {
+    case 'ready':
+      return `[${ts}] ready           ${ev.provider} @ ${ev.cwd}`
+    case 'prompt-received':
+      return `[${ts}] prompt          "${truncate(ev.text, 120)}"`
+    case 'turn-started':
+      return `[${ts}] turn-started    ${ev.turnId ?? ''}`
+    case 'turn-message':
+      return `[${ts}] turn-message    ${ev.delta.replace(/\s+$/, '')}`
+    case 'turn-reasoning':
+      return `[${ts}] turn-reasoning  ${truncate(ev.delta, 200)}`
+    case 'tool-call':
+      return `[${ts}] tool-call       ${ev.name}`
+    case 'file-edited':
+      return `[${ts}] file-edited     ${ev.kind.padEnd(6)} ${ev.path}`
+    case 'turn-completed':
+      return `[${ts}] turn-completed  ${ev.durationMs}ms  files=${ev.filesTouched.length}`
+    case 'approval-needed':
+      return `[${ts}] approval        ${ev.kind}`
+    case 'error':
+      return `[${ts}] error           ${ev.message}`
+    case 'exited':
+      return `[${ts}] exited          code=${ev.code}`
+    case 'file-diff-delta':
+      return `[${ts}] file-diff-delta ${ev.path}`
+    case 'turn-plan':
+      return `[${ts}] turn-plan       steps=${ev.steps.length}`
+    default:
+      return `[${ts}] ${(ev as { type: string }).type}`
+  }
+}
+
+async function cmdTranscript(argv: string[]): Promise<number> {
+  const sessionId = argv[0]
+  if (!sessionId) {
+    process.stderr.write('usage: rnx agent transcript <sessionId>\n')
+    return 2
+  }
+  const p = transcriptPath(sessionId)
+  if (!fs.existsSync(p)) {
+    process.stderr.write(`transcript not found: ${p}\n`)
+    return 1
+  }
+  process.stdout.write(fs.readFileSync(p, 'utf8'))
+  return 0
+}
+
+async function cmdEnd(argv: string[]): Promise<number> {
+  const sessionId = argv[0]
+  if (!sessionId) {
+    process.stderr.write('usage: rnx agent end <sessionId>\n')
+    return 2
+  }
+  await withDaemon((client) => client.endSession(sessionId))
+  process.stdout.write(`✓ ended session ${sessionId}\n`)
+  return 0
+}
+
+async function cmdPaths(): Promise<number> {
+  const dir = getUserDataDir()
+  process.stdout.write(
+    `userData:    ${dir}\n` +
+      `state:       ${path.join(dir, 'attached-projects.json')}\n` +
+      `sessions:    ${path.join(dir, 'sessions')}\n` +
+      `transcripts: ${path.join(dir, 'transcripts')}\n` +
+      `locks:       ${path.join(dir, 'locks')}\n`,
+  )
+  return 0
+}
+
+// --- utilities ---
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s
+  return s.slice(0, max - 1) + '…'
+}
+function shortId(id: string): string {
+  return id.length > 14 ? `${id.slice(0, 14)}…` : id
+}
+function fmtTs(ts: number): string {
+  return new Date(ts).toISOString().replace('T', ' ').slice(0, 19)
+}
+
+// keep these importable for the legacy e2e script paths — the canonical
+// source of truth is now `sootsim/agent-sessions`.
+export const __internals = {
+  sessionDir,
+  promptFifoPath,
+  eventsFifoPath,
+  transcriptPath,
+  parseAgentEventLine,
+}
+export type { AgentSession, AttachedProject }

package/cli/commands/app-fonts.ts

@@ -0,0 +1,99 @@
+// rnx app-fonts stage — fetch the config-plugin fonts declared on an
+// engine `?appFonts=` wire, gzip them, and merge asset descriptors into a
+// build's asset manifest.
+//
+// the branch-build path (app/api/github/agent/run.sh) captures the metro
+// __packager_asset graph itself, but config-plugin fonts (expo-font etc.) only
+// live in the native binary — never the bundle — so that capture misses them.
+// rather than reimplement font fetch/gzip/hash in bash, run.sh calls this once
+// after the asset capture; the descriptors land in the same manifest the
+// upload step already PUTs, keyed by sha256(url) so the rendered build resolves
+// each font through /api/preview/share/fetch?url=<fontUrl> identically to the
+// preview path (`rnx record upload`). both pipelines share fetchAppFontFiles.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { gzipSync } from 'node:zlib'
+import { fetchAppFontFiles } from '../app-fonts'
+import { rnxExit } from '../run-rnx'
+
+type ManifestEntry = {
+  url: string
+  urlhash: string
+  contentType: string
+  encoding: 'gzip'
+  sizeBytes: number
+  rawBytes: number
+}
+
+function flag(args: string[], name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`)
+  if (idx !== -1 && idx + 1 < args.length) return args[idx + 1]
+  const inline = args.find((a) => a.startsWith(`--${name}=`))
+  return inline ? inline.slice(name.length + 3) : undefined
+}
+
+async function stage(args: string[]): Promise<void> {
+  const wire = flag(args, 'wire') || ''
+  const outDir = flag(args, 'out-dir')
+  const manifestPath = flag(args, 'manifest')
+  if (!outDir || !manifestPath) {
+    console.error(
+      '  usage: rnx app-fonts stage --wire <wire> --out-dir <dir> --manifest <path>',
+    )
+    rnxExit(1)
+  }
+  if (!wire.trim()) {
+    console.log('no app fonts declared — nothing to stage')
+    return
+  }
+
+  mkdirSync(outDir, { recursive: true })
+  const fonts = await fetchAppFontFiles(wire, {
+    onStaged: ({ url, byteLength }) =>
+      console.log(`  staged app font: ${url} (${(byteLength / 1024).toFixed(1)} KiB)`),
+    onError: (url, err) =>
+      console.error(
+        `  warning: failed to fetch app font ${url}: ${err instanceof Error ? err.message : err}`,
+      ),
+  })
+
+  const descriptors: ManifestEntry[] = []
+  for (const font of fonts) {
+    const gz = gzipSync(font.bytes)
+    writeFileSync(join(outDir, font.urlhash), gz)
+    descriptors.push({
+      url: font.url,
+      urlhash: font.urlhash,
+      contentType: font.contentType,
+      encoding: 'gzip',
+      sizeBytes: gz.length,
+      rawBytes: font.bytes.byteLength,
+    })
+  }
+
+  let existing: ManifestEntry[] = []
+  if (existsSync(manifestPath)) {
+    try {
+      const parsed: unknown = JSON.parse(readFileSync(manifestPath, 'utf8'))
+      if (Array.isArray(parsed)) existing = parsed as ManifestEntry[]
+    } catch {}
+  }
+  const seen = new Set(existing.map((e) => e.urlhash))
+  const merged = [...existing, ...descriptors.filter((d) => !seen.has(d.urlhash))]
+  writeFileSync(manifestPath, JSON.stringify(merged))
+  console.log(
+    `staged ${descriptors.length} app font(s); manifest now has ${merged.length} file(s)`,
+  )
+}
+
+export async function runAppFonts(args: string[]): Promise<void> {
+  const sub = args[0]
+  if (sub === 'stage') {
+    await stage(args.slice(1))
+    return
+  }
+  console.error(`  unknown app-fonts subcommand: ${sub ?? '(none)'}`)
+  console.error('  available: stage')
+  rnxExit(1)
+}