@onyx-robotics/agent 0.1.0

package/src/commands/listen.ts

@@ -0,0 +1,327 @@
+import { watch, type FSWatcher } from "node:fs"
+import { stat } from "node:fs/promises"
+import { basename } from "node:path"
+
+import type {
+  LocalResearchEvent,
+  LocalResearchHistoryRecord,
+} from "../protocol"
+
+import { readEvents } from "../lib/events"
+import {
+  currentBranch,
+  gitResult,
+  nameFromGitBranch,
+  repoRoot,
+} from "../lib/git"
+import { historyPath, readHistory } from "../lib/history"
+import { onyxStateDir, readLastRun, readOutbox, readState } from "../lib/outbox"
+import { branchStateKey } from "../lib/project"
+import { formatAge, renderFrame, type ListenModel } from "../lib/tui"
+
+const CSI = "\x1b["
+const RENDER_INTERVAL_MS = 500
+const RENDER_MIN_GAP_MS = 100
+// Matches the spinner's frame duration in lib/tui.ts.
+const SPINNER_REDRAW_MS = 120
+// The session counts as live for 2 minutes after the last event/commit, or
+// for the whole eval window while a run is in flight (default timeout 600s).
+const ACTIVE_WINDOW_MS = 2 * 60_000
+const EVAL_ACTIVE_WINDOW_MS = 10 * 60_000
+// While idle, rebuild the model every Nth interval tick (2s instead of 500ms)
+// to keep git spawns and file reads minimal on constrained hardware.
+const IDLE_REBUILD_EVERY = 4
+
+// history.jsonl is re-read (and Zod-parsed) only when its mtime/size changes;
+// the parse of a long history is the most expensive part of a rebuild.
+let historyCache: {
+  key: string
+  records: LocalResearchHistoryRecord[]
+} | null = null
+
+async function readHistoryCached(
+  root: string
+): Promise<LocalResearchHistoryRecord[]> {
+  let key: string
+  try {
+    const stats = await stat(await historyPath(root))
+    key = `${stats.mtimeMs}:${stats.size}`
+  } catch {
+    historyCache = null
+    return []
+  }
+  if (historyCache?.key === key) return historyCache.records
+  const { records } = await readHistory(root)
+  historyCache = { key, records }
+  return records
+}
+
+function describeEvent(event: LocalResearchEvent, nowMs: number) {
+  const sha = event.commitSha ? event.commitSha.slice(0, 7) : null
+  const labels: Record<LocalResearchEvent["type"], string> = {
+    branch_created: "branch created",
+    exp_run_started: "running eval",
+    eval_finished: "eval finished",
+    checks_finished: "checks",
+    run_finished: "measured",
+    exp_logged: "logged",
+    flush_finished: "sync",
+    pushed: "pushed",
+  }
+  const parts = [labels[event.type], sha, event.message].filter(Boolean)
+  return `${parts.join(" · ")} · ${formatAge(event.ts, nowMs)}`
+}
+
+/** Latest commit on HEAD as a live-activity candidate. */
+async function headCommitInfo(root: string) {
+  const result = await gitResult(
+    ["log", "-1", "--format=%H%x09%cI%x09%s"],
+    root
+  )
+  if (result.code !== 0) return null
+  const [sha, committedAt, subject] = result.stdout.trim().split("\t")
+  if (!sha) return null
+  return { sha, committedAt: committedAt ?? "", subject: subject ?? "" }
+}
+
+async function buildModel(root: string): Promise<ListenModel> {
+  const state = await readState(root)
+  const gitBranch = await currentBranch(root).catch(() => "")
+  const branchName = gitBranch ? nameFromGitBranch(gitBranch) : null
+
+  const records = await readHistoryCached(root)
+  // Ascending — the most recent experiment renders at the bottom of the
+  // table. Copy before sorting/pushing so the cached array stays untouched.
+  const rows = (
+    branchName
+      ? records.filter((record) => record.branchName === branchName)
+      : [...records]
+  ).sort((a, b) =>
+    a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0
+  )
+
+  // Surface a measured-but-unlogged run at the bottom of the table.
+  const lastRun = await readLastRun(root)
+  if (lastRun && !rows.some((row) => row.runRef === lastRun.runRef)) {
+    rows.push({
+      schemaVersion: 1,
+      source: "local",
+      branchName: lastRun.branchName,
+      runRef: lastRun.runRef,
+      commitSha: lastRun.commitSha,
+      status: lastRun.status,
+      name: `(unlogged) ${lastRun.commitSha.slice(0, 7)}`,
+      primaryMetricName: lastRun.primaryMetricName,
+      primaryMetricValue: lastRun.primaryMetricValue,
+      metrics: lastRun.metrics,
+      agentNotes: lastRun.agentNotes,
+      startedAt: lastRun.startedAt ?? null,
+      completedAt: lastRun.completedAt ?? null,
+      createdAt: lastRun.createdAt,
+    })
+  }
+
+  const meta = branchName
+    ? state.branches[branchStateKey(state.projectPath ?? "", branchName)]
+    : undefined
+  const metricName = meta?.metricName ?? rows[0]?.primaryMetricName ?? null
+  const metricDirection = meta?.metricDirection ?? "maximize"
+  const measured = rows.filter(
+    (row) =>
+      (row.status === "succeeded" || row.status === "accepted") &&
+      row.primaryMetricValue !== null
+  )
+  const bestValue = measured.length
+    ? measured.reduce(
+        (best, row) =>
+          metricDirection === "minimize"
+            ? Math.min(best, row.primaryMetricValue as number)
+            : Math.max(best, row.primaryMetricValue as number),
+        metricDirection === "minimize" ? Infinity : -Infinity
+      )
+    : null
+
+  // Activity: most recent of (latest CLI event, latest commit on HEAD).
+  const nowMs = Date.now()
+  const [latestEvent] = (await readEvents(root, { tail: 1 })).slice(-1)
+  const head = await headCommitInfo(root)
+  let activity: string | null = latestEvent
+    ? describeEvent(latestEvent, nowMs)
+    : null
+  if (
+    head &&
+    (!latestEvent || Date.parse(head.committedAt) > Date.parse(latestEvent.ts))
+  ) {
+    activity = `committed ${head.sha.slice(0, 7)} · ${head.subject} · ${formatAge(head.committedAt, nowMs)}`
+  }
+
+  // Live while an eval is in flight (exp_run_started without a newer event,
+  // bounded by the eval timeout) or anything happened in the last 2 minutes.
+  const eventMs = latestEvent ? Date.parse(latestEvent.ts) : Number.NaN
+  const commitMs = head ? Date.parse(head.committedAt) : Number.NaN
+  const lastActivityMs = Math.max(
+    Number.isFinite(eventMs) ? eventMs : 0,
+    Number.isFinite(commitMs) ? commitMs : 0
+  )
+  const evalInFlight =
+    latestEvent?.type === "exp_run_started" &&
+    Number.isFinite(eventMs) &&
+    nowMs - eventMs < EVAL_ACTIVE_WINDOW_MS
+  const active =
+    evalInFlight ||
+    (lastActivityMs > 0 && nowMs - lastActivityMs < ACTIVE_WINDOW_MS)
+
+  const { records: outboxRecords } = await readOutbox(root)
+
+  return {
+    projectName: basename(root),
+    branchName: gitBranch || null,
+    metricName,
+    metricUnit: meta?.metricUnit ?? null,
+    metricDirection,
+    bestValue,
+    activity,
+    active,
+    rows,
+    pendingOutbox: outboxRecords.length,
+    syncedCount: records.filter((record) => record.source === "api").length,
+  }
+}
+
+function frameText(lines: string[], live: boolean) {
+  if (!live) return `${lines.join("\n")}\n`
+  // Home the cursor, clear each line as it's rewritten, clear the remainder.
+  return `${CSI}H${lines.map((line) => `${line}${CSI}K`).join("\n")}\n${CSI}J`
+}
+
+/**
+ * Live, read-only view of the current repo's research session: tails
+ * `.git/onyx/` (events, history, last-run, outbox) and polls git for new
+ * commits. With no TTY it prints a single snapshot and exits.
+ */
+export async function commandListen() {
+  const root = await repoRoot()
+  await onyxStateDir(root) // ensure .git/onyx exists so fs.watch can attach
+
+  const size = () => ({
+    columns: process.stdout.columns ?? 100,
+    rows: process.stdout.rows ?? 30,
+    nowMs: Date.now(),
+  })
+
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    const model = await buildModel(root)
+    process.stdout.write(
+      frameText(renderFrame(model, { ...size(), color: false }), false)
+    )
+    return
+  }
+
+  let closed = false
+  let renderTimer: ReturnType<typeof setTimeout> | null = null
+  let lastRenderAt = 0
+  let interval: ReturnType<typeof setInterval> | null = null
+  let spinnerInterval: ReturnType<typeof setInterval> | null = null
+  let watcher: FSWatcher | null = null
+  let resolveQuit = () => {}
+  let cachedModel: ListenModel | null = null
+  let rebuilding = false
+  let lastFrame = ""
+
+  const draw = () => {
+    if (closed || !cachedModel) return
+    const frame = frameText(renderFrame(cachedModel, size()), true)
+    // Identical frames (idle, no age changes) skip the terminal write.
+    if (frame === lastFrame) return
+    lastFrame = frame
+    process.stdout.write(frame)
+  }
+
+  const render = async () => {
+    if (closed || rebuilding) return
+    rebuilding = true
+    try {
+      const model = await buildModel(root)
+      cachedModel = model
+    } finally {
+      rebuilding = false
+    }
+    draw()
+  }
+
+  const requestRender = () => {
+    if (closed || renderTimer) return
+    const wait = Math.max(0, RENDER_MIN_GAP_MS - (Date.now() - lastRenderAt))
+    renderTimer = setTimeout(() => {
+      renderTimer = null
+      lastRenderAt = Date.now()
+      void render().catch(() => {})
+    }, wait)
+  }
+
+  const onKey = (key: string) => {
+    if (key === "q" || key === "Q" || key === "\x03") quit()
+  }
+
+  const cleanup = () => {
+    if (closed) return
+    closed = true
+    if (renderTimer) clearTimeout(renderTimer)
+    if (interval) clearInterval(interval)
+    if (spinnerInterval) clearInterval(spinnerInterval)
+    watcher?.close()
+    process.stdin.off("data", onKey)
+    process.stdout.off("resize", requestRender)
+    process.off("SIGINT", quit)
+    process.off("SIGTERM", quit)
+    if (process.stdin.isTTY) process.stdin.setRawMode(false)
+    process.stdin.pause()
+    // Show the cursor and leave the alternate screen buffer.
+    process.stdout.write(`${CSI}?25h${CSI}?1049l`)
+  }
+
+  const quit = () => {
+    cleanup()
+    resolveQuit()
+  }
+
+  // Enter the alternate screen buffer and hide the cursor.
+  process.stdout.write(`${CSI}?1049h${CSI}?25l${CSI}2J`)
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+  process.stdin.setEncoding("utf8")
+  process.stdin.on("data", onKey)
+  process.stdout.on("resize", requestRender)
+  process.on("SIGINT", quit)
+  process.on("SIGTERM", quit)
+  process.on("exit", cleanup)
+
+  try {
+    watcher = watch(await onyxStateDir(root), requestRender)
+  } catch {
+    // Interval polling still keeps the view fresh.
+  }
+  // While idle, rebuild less often — fs.watch still wakes the loop the
+  // moment an agent writes to .git/onyx/, so liveness returns instantly.
+  let idleTicks = 0
+  interval = setInterval(() => {
+    if (cachedModel && !cachedModel.active) {
+      idleTicks += 1
+      if (idleTicks % IDLE_REBUILD_EVERY !== 0) return
+    } else {
+      idleTicks = 0
+    }
+    requestRender()
+  }, RENDER_INTERVAL_MS)
+  // Fast tick redraws the cached model so the activity spinner animates
+  // without re-reading files or spawning git between data refreshes. Idle
+  // sessions skip it entirely (the static frame can't change between ticks).
+  spinnerInterval = setInterval(() => {
+    if (cachedModel?.active) draw()
+  }, SPINNER_REDRAW_MS)
+  requestRender()
+
+  await new Promise<void>((resolve) => {
+    resolveQuit = resolve
+  })
+}

package/src/commands/login.ts

@@ -0,0 +1,198 @@
+import { randomUUID } from "node:crypto"
+
+import { optionalFlag, type Args } from "../lib/args"
+import {
+  apiBaseUrl,
+  normalizeProfileName,
+  readConfig,
+  type CliProfile,
+  type Config,
+  writeConfig,
+} from "../lib/config"
+import { openBrowser, waitForCliLogin, type CliLoginResult } from "../lib/login"
+
+export type CliLoginProfileManifestEntry = {
+  profileName: string
+  teamId: string
+  apiUrl: string
+  apiKeyId?: string
+}
+
+export function loginProfileManifest(
+  config: Config
+): CliLoginProfileManifestEntry[] {
+  return Object.entries(config.profiles).map(([profileName, profile]) => ({
+    profileName,
+    teamId: profile.teamId,
+    apiUrl: profile.apiUrl,
+    ...(profile.apiKeyId ? { apiKeyId: profile.apiKeyId } : {}),
+  }))
+}
+
+export function encodeLoginProfileManifest(
+  profiles: CliLoginProfileManifestEntry[]
+) {
+  return Buffer.from(JSON.stringify(profiles), "utf8").toString("base64url")
+}
+
+export function profileNameForTeam(teamName: string) {
+  const [firstWord = ""] = teamName.trim().split(/\s+/)
+  return normalizeProfileName(firstWord) || "team"
+}
+
+export function profileNameForLoginResult({
+  config,
+  apiUrl,
+  teamId,
+  teamName,
+}: {
+  config: Config
+  apiUrl: string
+  teamId: string
+  teamName: string
+}) {
+  const existing = Object.entries(config.profiles).find(
+    ([, profile]) => profile.teamId === teamId && profile.apiUrl === apiUrl
+  )
+
+  if (existing) {
+    return existing[0]
+  }
+
+  const baseName = profileNameForTeam(teamName)
+  let candidate = baseName
+  let suffix = 2
+
+  while (config.profiles[candidate]) {
+    candidate = `${baseName}-${suffix}`
+    suffix += 1
+  }
+
+  return candidate
+}
+
+export function buildCliLoginUrl({
+  baseUrl,
+  redirectUri,
+  state,
+  profiles,
+  refresh,
+}: {
+  baseUrl: string
+  redirectUri: string
+  state: string
+  profiles: CliLoginProfileManifestEntry[]
+  refresh: boolean
+}) {
+  const loginUrl = new URL("/cli/login", baseUrl)
+  loginUrl.searchParams.set("redirect_uri", redirectUri)
+  loginUrl.searchParams.set("state", state)
+  loginUrl.searchParams.set("profiles", encodeLoginProfileManifest(profiles))
+  if (refresh) {
+    loginUrl.searchParams.set("refresh", "true")
+  }
+
+  return loginUrl
+}
+
+function storedProfileFromLoginResult({
+  apiUrl,
+  result,
+}: {
+  apiUrl: string
+  result: CliLoginResult
+}): CliProfile {
+  if (!result.apiKey) {
+    throw new Error("Login callback did not include an API key.")
+  }
+
+  return {
+    apiUrl,
+    apiKey: result.apiKey,
+    ...(result.apiKeyId ? { apiKeyId: result.apiKeyId } : {}),
+    teamId: result.teamId,
+    teamName: result.teamName,
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+export async function saveLoginProfile({
+  baseUrl,
+  result,
+}: {
+  baseUrl: string
+  result: CliLoginResult
+}) {
+  const config = await readConfig()
+  const apiUrl = result.apiUrl ?? baseUrl
+  const profileName = profileNameForLoginResult({
+    config,
+    apiUrl,
+    teamId: result.teamId,
+    teamName: result.teamName,
+  })
+
+  if (result.alreadyConfigured) {
+    if (!config.profiles[profileName]) {
+      throw new Error(
+        "Login selected an already configured team, but no matching local profile was found."
+      )
+    }
+
+    await writeConfig({
+      ...config,
+      currentProfile: profileName,
+    })
+    return { profileName, alreadyConfigured: true }
+  }
+
+  await writeConfig({
+    profiles: {
+      ...config.profiles,
+      [profileName]: storedProfileFromLoginResult({ apiUrl, result }),
+    },
+    currentProfile: profileName,
+  })
+
+  return { profileName, alreadyConfigured: false }
+}
+
+export async function commandLogin(args: Args) {
+  const baseUrl = await apiBaseUrl(args, { allowDefault: true })
+  const port = Number(args.options.port ?? 8765)
+  const state = randomUUID()
+  const redirectUri = `http://127.0.0.1:${port}/callback`
+  const config = await readConfig()
+  const loginUrl = buildCliLoginUrl({
+    baseUrl,
+    redirectUri,
+    state,
+    profiles: loginProfileManifest(config),
+    refresh: optionalFlag(args, "refresh"),
+  })
+
+  const loginPromise = waitForCliLogin({
+    port,
+    state,
+    timeoutMs: Number(args.options.timeout ?? 120_000),
+  })
+
+  if (optionalFlag(args, "print-url")) {
+    console.log(loginUrl.toString())
+  } else {
+    await openBrowser(loginUrl.toString())
+    console.log("Waiting for browser login...")
+  }
+
+  const result = await loginPromise
+  const saved = await saveLoginProfile({ baseUrl, result })
+  if (saved.alreadyConfigured) {
+    console.log(
+      `Using existing profile ${saved.profileName} for ${result.teamName} (${result.teamId})`
+    )
+  } else {
+    console.log(
+      `Logged in profile ${saved.profileName} for ${result.teamName} (${result.teamId})`
+    )
+  }
+}

package/src/commands/profile.ts

@@ -0,0 +1,112 @@
+import type { Args } from "../lib/args"
+import { normalizeProfileName, readConfig, writeConfig } from "../lib/config"
+
+const API_KEY_ENV_NAME = /^[A-Z_][A-Z0-9_]*$/
+
+export async function commandProfile(args: Args) {
+  const sub = args.positional[1]
+
+  if (sub === "list") {
+    return commandProfileList()
+  }
+
+  if (sub === "use") {
+    return commandProfileUse(args)
+  }
+
+  if (sub === "set-api-key-env") {
+    return commandProfileSetApiKeyEnv(args)
+  }
+
+  throw new Error(
+    "Usage: onyx profile list | onyx profile use <name> | onyx profile set-api-key-env <name> <ENV_VAR>"
+  )
+}
+
+export async function commandProfileList() {
+  const config = await readConfig()
+  const entries = Object.entries(config.profiles).sort(([left], [right]) =>
+    left.localeCompare(right)
+  )
+
+  if (entries.length === 0) {
+    console.log("No profiles. Run `onyx login`.")
+    return
+  }
+
+  for (const [name, profile] of entries) {
+    const marker = name === config.currentProfile ? "*" : " "
+    const credentialSource = profile.apiKeyEnv
+      ? `env:${profile.apiKeyEnv} (${
+          process.env[profile.apiKeyEnv]?.trim() ? "set" : "missing"
+        })`
+      : profile.apiKey
+        ? "stored key"
+        : "missing key"
+    console.log(
+      `${marker} ${name}\t${profile.teamName}\t${profile.teamId}\t${profile.apiUrl}\t${credentialSource}`
+    )
+  }
+}
+
+export async function commandProfileUse(args: Args) {
+  const requested = args.positional[2]
+  if (!requested) {
+    throw new Error("Usage: onyx profile use <name>")
+  }
+
+  const name = normalizeProfileName(requested)
+  if (!name) {
+    throw new Error("Profile name must contain at least one letter or number")
+  }
+
+  const config = await readConfig()
+  if (!config.profiles[name]) {
+    throw new Error(`Unknown Onyx CLI profile "${name}".`)
+  }
+
+  await writeConfig({
+    ...config,
+    currentProfile: name,
+  })
+  console.log(`Using profile ${name}`)
+}
+
+export async function commandProfileSetApiKeyEnv(args: Args) {
+  const requested = args.positional[2]
+  const envVarName = args.positional[3]
+  if (!requested || !envVarName) {
+    throw new Error("Usage: onyx profile set-api-key-env <name> <ENV_VAR>")
+  }
+
+  const name = normalizeProfileName(requested)
+  if (!name) {
+    throw new Error("Profile name must contain at least one letter or number")
+  }
+
+  if (!API_KEY_ENV_NAME.test(envVarName)) {
+    throw new Error("Environment variable name must match /^[A-Z_][A-Z0-9_]*$/")
+  }
+
+  const config = await readConfig()
+  const profile = config.profiles[name]
+  if (!profile) {
+    throw new Error(`Unknown Onyx CLI profile "${name}".`)
+  }
+
+  const nextProfile = {
+    ...profile,
+    apiKeyEnv: envVarName,
+    updatedAt: new Date().toISOString(),
+  }
+  delete nextProfile.apiKey
+
+  await writeConfig({
+    ...config,
+    profiles: {
+      ...config.profiles,
+      [name]: nextProfile,
+    },
+  })
+  console.log(`Profile ${name} now reads its API key from ${envVarName}`)
+}