firegoat 0.23.0 → 0.24.0

package/dist/cli.js

@@ -6947,7 +6947,7 @@ var require_public_api = __commonJS(function(exports) {
 // package.json
 var package_default = {
   name: "firegoat",
-  version: "0.23.0",
+  version: "0.24.0",
   repository: {
     type: "git",
     url: "git+https://github.com/firegoat-ai/firegoat-cli.git"
@@ -7086,9 +7086,9 @@ function parseConfig(text) {
   ]);
   const runs = posInt(raw.runs, "runs", 1);
   const models = parseModels(raw.model);
-  const build = commands(raw.build, "build");
-  const install = commands(raw.install, "install");
-  const cleanup = commands(raw.cleanup, "cleanup");
+  const build = commands(raw.build, "build", EVAL_PLACEHOLDERS);
+  const install = commands(raw.install, "install", RUN_PLACEHOLDERS);
+  const cleanup = commands(raw.cleanup, "cleanup", RUN_PLACEHOLDERS);
   const vars = parseVars(raw.vars);
   const env = parseEnv(raw.env, "env");
   const claudeArgs = parseClaudeArgs(raw.claude_args, "claude_args");
@@ -7125,7 +7125,9 @@ function parseConfig(text) {
       if (!isRecord(c))
         fail(cp, "must be a mapping");
       onlyKeys(c, cp, ["run"]);
-      checks.push({ run: str(c.run, `${cp}.run`) });
+      const run = str(c.run, `${cp}.run`);
+      checkPlaceholders(run, `${cp}.run`, RUN_PLACEHOLDERS);
+      checks.push({ run });
     });
     return {
       name,
@@ -7134,8 +7136,8 @@ function parseConfig(text) {
       checks,
       timeout: posInt(t.timeout, `${p}.timeout`, DEFAULT_TIMEOUT),
       env: { ...env, ...parseEnv(t.env, `${p}.env`) },
-      install: commands(t.install, `${p}.install`),
-      cleanup: commands(t.cleanup, `${p}.cleanup`),
+      install: commands(t.install, `${p}.install`, RUN_PLACEHOLDERS),
+      cleanup: commands(t.cleanup, `${p}.cleanup`, RUN_PLACEHOLDERS),
       claudeArgs: [
         ...claudeArgs,
         ...parseClaudeArgs(t.claude_args, `${p}.claude_args`)
@@ -7154,14 +7156,18 @@ function parseConfig(text) {
   };
 }
 var NAME = /^[A-Za-z0-9._-]+$/;
-function commands(raw, path) {
+function commands(raw, path, allowed) {
   if (raw === undefined)
     return [];
-  if (typeof raw === "string")
-    return [str(raw, path)];
-  if (!Array.isArray(raw))
+  if (typeof raw !== "string" && !Array.isArray(raw))
     fail(path, "must be a shell command or a list of them");
-  return raw.map((c, i) => str(c, `${path}[${i}]`));
+  const list = typeof raw === "string" ? [raw] : raw;
+  return list.map((c, i) => {
+    const p = typeof raw === "string" ? path : `${path}[${i}]`;
+    const cmd = str(c, p);
+    checkPlaceholders(cmd, p, allowed);
+    return cmd;
+  });
 }
 function parseModels(raw) {
   if (raw === undefined)
@@ -7211,7 +7217,7 @@ function parseClaudeArgs(raw, path) {
       for (const f of flags)
         if (arg === f || arg.startsWith(`${f}=`))
           fail(p, `${f} is not allowed: ${why}`);
-    checkPlaceholders(arg, p);
+    checkPlaceholders(arg, p, RUN_PLACEHOLDERS);
     return arg;
   });
 }
@@ -7267,16 +7273,16 @@ function parseEnv(raw, path) {
       fail(p, "is set by firegoat and cannot be overridden (reserved: PATH, CLAUDE_CONFIG_DIR, CLAUDE_SECURESTORAGE_CONFIG_DIR, FIREGOAT_*)");
     if (typeof v !== "string")
       fail(p, "must be a string (quote numbers and booleans)");
-    checkPlaceholders(v, p);
+    checkPlaceholders(v, p, RUN_PLACEHOLDERS);
     out[k] = v;
   }
   return out;
 }
-function checkPlaceholders(v, p) {
+function checkPlaceholders(v, p, allowed) {
   for (const m of v.matchAll(ANY_PLACEHOLDER)) {
     const name = m[1];
-    if (!/^vars\.[A-Za-z0-9_]+$/.test(name) && !RUN_PLACEHOLDERS.includes(name))
-      fail(p, `unknown placeholder ${m[0]} (allowed: {{vars.KEY}}, ${RUN_PLACEHOLDERS.map((n) => `{{${n}}}`).join(", ")})`);
+    if (!/^vars\.[A-Za-z0-9_]+$/.test(name) && !allowed.includes(name))
+      fail(p, `unknown placeholder ${m[0]} (allowed: {{vars.KEY}}, ${allowed.map((n) => `{{${n}}}`).join(", ")})`);
   }
 }
 function isEvalLevel(value) {
@@ -7287,13 +7293,16 @@ function isEvalLevel(value) {
   });
 }
 function renderValue(value, vars, run, where) {
-  return value.replace(ENV_REF, (whole, name, braced, bare) => {
-    const key = name ?? braced ?? bare;
-    const filled = key.startsWith("vars.") ? vars[key.slice("vars.".length)] : run[key];
-    if (filled === undefined)
-      throw new ConfigError(`${where}: no value for ${whole}`);
-    return filled;
-  });
+  return value.replace(ENV_REF, (whole, name, braced, bare) => lookup(whole, name ?? braced ?? bare, vars, run, where));
+}
+function renderStep(cmd, vars, run, where) {
+  return cmd.replace(ANY_PLACEHOLDER, (whole, name) => lookup(whole, name, vars, run, where));
+}
+function lookup(whole, key, vars, run, where) {
+  const filled = key.startsWith("vars.") ? vars[key.slice("vars.".length)] : run[key];
+  if (filled === undefined)
+    throw new ConfigError(`${where}: no value for ${whole}`);
+  return filled;
 }
 function renderEnv(env, vars, run) {
   const out = {};
@@ -8071,8 +8080,9 @@ firegoat.yaml reference:
                               what the agent left running (servers, daemons).
                               Every step runs; a failure is a warning (run.json
                               cleanup, <test>/<n>/cleanup.txt), never the verdict
-  vars: {KEY: value}          Defaults for {{vars.KEY}} in prompts and checks;
-                              --var KEY=value overrides
+  vars: {KEY: value}          Defaults for {{vars.KEY}} in prompts, checks and
+                              build, install and cleanup steps; --var KEY=value
+                              overrides. A missing value is a config error
   env: {NAME: value}          Env vars for the agent, and for install, checks
                               and cleanup of the same run; values are strings and can
                               use {{vars.KEY}}, {{run.id}}, {{run.n}},
@@ -8123,6 +8133,11 @@ firegoat.yaml reference:
   from a template project, commit it as e.g. fixtures/starter-app/, then:
     build: cp -R fixtures/starter-app "$FIREGOAT_OUT/starter-app"
     install: cp -R "$FIREGOAT_OUT/starter-app/." .
+  Placeholders in build, install, cleanup and checks: {{vars.KEY}}, {{run.id}},
+  {{run.n}}, {{test.name}} (build: only {{vars.KEY}} and {{run.id}}); others are
+  config errors. Values are pasted into the shell text as-is, unquoted: quote
+  them yourself ('{{vars.KEY}}'), or use the env var below ("$KEY"), which is safe
+  for any value.
   The build, install and cleanup commands and the checks get the vars as env
   vars, plus $FIREGOAT_OUT and $FIREGOAT_WORKDIR; install, checks and cleanup also
   get $FIREGOAT_HOME, the run's own home, as HOME (build keeps your real HOME).
@@ -8269,10 +8284,12 @@ fixtures and build: stay in the current folder.
   --parallel N       Runs at once (default 4; 1 runs them one after another).
                      Each run has its own HOME; state outside it (a fixed port,
                      /tmp paths) can still collide: use 1 then
-  --var KEY=value    Fills {{vars.KEY}}; env for build, install, checks and
-                     cleanup
+  --var KEY=value    Fills {{vars.KEY}} (prompts, checks, build, install,
+                     cleanup); env for build, install, checks and cleanup
   --json             The summary as JSON on stdout (or {error, exitCode} if eval
-                     stops early); progress goes to stderr
+                     stops early); progress goes to stderr. The verdict comes
+                     last, after runs: totals {pass, fail, error}, status
+                     ("pass", "fail" or "error" = not graded) and exitCode
   --no-upload        Keep runs local even when logged in to firegoat.ai
   --dry-run          Check firegoat.yaml as eval would (test names, --var,
                      --model, missing vars), print each planned run
@@ -8281,7 +8298,8 @@ fixtures and build: stay in the current folder.
                      runs/<runId>/) and exit 0. Builds nothing, starts no
                      claude, uploads nothing, writes no files. Config errors
                      exit 3. With --json: {dryRun, build, runs: [{test, n,
-                     model, claudeArgs, install, checks, cleanup}]}
+                     model, claudeArgs, install, checks, cleanup}]}, steps
+                     and checks with their placeholders filled
   --claude-bin PATH  Path to claude (default: claude on PATH)
 
 Upload: after firegoat login (or with FIREGOAT_API_KEY), each run's claude session,
@@ -8295,9 +8313,11 @@ Runs without a session file are not uploaded. FIREGOAT_BASE_URL points elsewhere
 (default https://firegoat.ai/evals). See firegoat login --help.
 
 Output: .firegoat/runs/<runId>/
-  summary.json            Every run, plus totals, dir (where eval ran),
-                          git {branch, commit, dirty} (no git outside a repo)
-                          and upload {origin, email} (null when not uploading)
+  summary.json            firegoatVersion, runId, runsDir, dir (where eval
+                          ran), git {branch, commit, dirty} (no git outside a
+                          repo), upload {origin, email} (null when not
+                          uploading), runs (every run.json), then the verdict:
+                          totals, status and exitCode
   ../index.jsonl          One line per eval: runId, startedAt, dir, branch,
                           commit, passed, failed, notGraded, cost (null when
                           any run's cost is unknown), uploaded, uploadFailed
@@ -9212,6 +9232,19 @@ function runFill(runId, n, testName, out, dir) {
 function renderClaudeArgs(test, vars, fill) {
   return test.claudeArgs.map((a, i) => renderValue(a, vars, fill, `claude_args[${i}]`));
 }
+function renderSteps(what, commands, vars, fill) {
+  return commands.map((c, i) => renderStep(c, vars, fill, `${what}[${i}]`));
+}
+function renderRunSteps(test, top, vars, fill) {
+  return {
+    install: renderSteps("install", [...top.install, ...test.install], vars, fill),
+    checks: renderSteps("checks", test.checks.map((c) => c.run), vars, fill),
+    cleanup: renderSteps("cleanup", [...test.cleanup, ...top.cleanup], vars, fill)
+  };
+}
+function renderBuild(config, vars, runId) {
+  return renderSteps("build", config.build, vars, { "run.id": runId });
+}
 function planRuns(tests, models, runs) {
   const matrix = models.length > 0 ? models : [null];
   return tests.flatMap((t) => matrix.flatMap((model, m) => Array.from({ length: runs }, (_, i) => ({
@@ -9230,13 +9263,12 @@ function dryRun(opts) {
     return {
       ...p,
       claudeArgs: renderClaudeArgs(test, opts.vars, fill),
-      install: [...opts.config.install, ...test.install],
-      checks: test.checks.map((c) => render(c.run, opts.vars)),
-      cleanup: [...test.cleanup, ...opts.config.cleanup]
+      ...renderRunSteps(test, opts.config, opts.vars, fill)
     };
   });
+  const build = renderBuild(opts.config, opts.vars, DRY_RUN_ID);
   if (opts.json) {
-    console.log(JSON.stringify({ dryRun: true, build: opts.config.build, runs }, null, 2));
+    console.log(JSON.stringify({ dryRun: true, build, runs }, null, 2));
     return;
   }
   const count = (n, what) => `${n} ${what}${n === 1 ? "" : "s"}`;
@@ -9286,11 +9318,11 @@ async function runOne(opts) {
     FIREGOAT_WORKDIR: workdir,
     FIREGOAT_HOME: home
   };
-  const [status, reason] = await attempt(opts, r, env, stepEnv, envFile);
-  const cleanup = [...test.cleanup, ...opts.cleanup];
-  if (cleanup.length > 0)
+  const steps = renderRunSteps(test, opts, opts.vars, fill);
+  const [status, reason] = await attempt(opts, r, steps, env, stepEnv, envFile);
+  if (steps.cleanup.length > 0)
     r.cleanup = await runAllSteps({
-      commands: cleanup,
+      commands: steps.cleanup,
       cwd: workdir,
       env: stepEnv,
       logPath: r.cleanupLog
@@ -9301,14 +9333,13 @@ async function runOne(opts) {
   writeRunJson(r);
   return r;
 }
-async function attempt(opts, r, env, stepEnv, homeEnvFile) {
+async function attempt(opts, r, steps, env, stepEnv, homeEnvFile) {
   const { test, n } = opts;
   const { dir, workdir } = r;
-  const install = [...opts.install, ...test.install];
-  if (install.length > 0) {
+  if (steps.install.length > 0) {
     const error = await runSteps({
       what: "install",
-      commands: install,
+      commands: steps.install,
       cwd: workdir,
       env: stepEnv,
       logPath: join7(dir, "install.txt")
@@ -9362,9 +9393,9 @@ async function attempt(opts, r, env, stepEnv, homeEnvFile) {
     ];
   const log = createWriteStream2(r.checksLog);
   try {
-    for (const c of test.checks)
+    for (const run of steps.checks)
       r.checks.push(await runShell({
-        run: render(c.run, opts.vars),
+        run,
         cwd: workdir,
         env: {
           ...stepEnv,
@@ -9462,8 +9493,10 @@ async function evalCommand(args, root) {
       t.prompt,
       ...t.checks.map((c) => c.run),
       ...Object.values(t.env),
-      ...t.claudeArgs
-    ]).flatMap(varRefs).filter((k) => !(k in vars)))
+      ...t.claudeArgs,
+      ...t.install,
+      ...t.cleanup
+    ]).concat(config.build, config.install, config.cleanup).flatMap(varRefs).filter((k) => !(k in vars)))
   ];
   if (missing.length > 0)
     return fatal(EXIT.usage, `No value for ${missing.map((k) => `{{vars.${k}}}`).join(", ")}: pass --var ${missing[0]}=... or set it under vars: in firegoat.yaml`, "config");
@@ -9546,7 +9579,7 @@ async function evalCommand(args, root) {
     ui.build("running");
     const error = await runSteps({
       what: "build",
-      commands: config.build,
+      commands: renderBuild(config, vars, runId),
       cwd: root,
       env: {
         ...stepEnv,
@@ -9624,6 +9657,12 @@ async function evalCommand(args, root) {
     uploaded,
     uploadFailed: uploadsFailed
   });
+  const status = totals.error > 0 ? "error" : totals.fail > 0 ? "fail" : "pass";
+  const exitCode = {
+    error: EXIT.notGraded,
+    fail: EXIT.fail,
+    pass: EXIT.pass
+  }[status];
   const doc = {
     firegoatVersion: package_default.version,
     runId,
@@ -9631,8 +9670,10 @@ async function evalCommand(args, root) {
     dir: root,
     ...repo && { git: repo.info },
     upload: upload && { origin: upload.origin, email: upload.email },
+    runs: results,
     totals,
-    runs: results
+    status,
+    exitCode
   };
   writeFileSync4(join7(runDir, "summary.json"), `${JSON.stringify(doc, null, 2)}
 `);
@@ -9666,11 +9707,11 @@ async function evalCommand(args, root) {
     console.error(`firegoat eval: ${uploadsFailed} upload${uploadsFailed === 1 ? "" : "s"} failed (each run's upload.error in summary.json)`);
   if (opts.json)
     console.log(JSON.stringify(doc, null, 2));
-  if (totals.error > 0)
+  if (status === "error")
     failWith("not_graded");
-  else if (totals.fail > 0)
+  else if (status === "fail")
     failWith("checks_failed");
-  return totals.error > 0 ? EXIT.notGraded : totals.fail > 0 ? EXIT.fail : EXIT.pass;
+  return exitCode;
 }
 
 // src/feedback.ts
@@ -9946,10 +9987,9 @@ firegoat ${package_default.version}` : `firegoat ${package_default.version}`,
 }
 
 // src/init.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { basename as basename4, join as join8 } from "node:path";
-import { createInterface } from "node:readline/promises";
 
 // src/login.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -9979,7 +10019,7 @@ function openBrowser(url) {
   } catch {}
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function loginFlow(say, interactive) {
+async function loginFlow(show, interactive) {
   const base = baseUrl();
   const origin = new URL(base).origin;
   const cfgStep = "GET /api/traces/oauth/config";
@@ -10024,8 +10064,11 @@ async function loginFlow(say, interactive) {
   let interval = Math.min(Math.max(rawInterval ?? 5, 5), MAX_INTERVAL_S);
   const expiresS = Math.min(expiresIn, MAX_EXPIRES_S);
   const deadline = Date.now() + expiresS * 1000;
-  say(TERMS);
-  say(`Open ${printable(page.href, 500)} and enter code ${userCode} (expires in ${Math.max(1, Math.round(expiresS / 60))}m).`);
+  show({
+    page: printable(page.href, 500),
+    code: userCode,
+    minutes: Math.max(1, Math.round(expiresS / 60))
+  });
   if (interactive)
     openBrowser(page.href);
   const tokStep = "Token request";
@@ -10093,7 +10136,10 @@ ${LOGIN_HELP}`);
     console.error("Note: FIREGOAT_API_KEY is set, so eval uses it instead of this login.");
   try {
     console.log(UPLOAD_NOTICE);
-    const email = await loginFlow((l) => console.log(l), Boolean(process.stdout.isTTY));
+    const email = await loginFlow(({ page, code, minutes }) => {
+      console.log(TERMS);
+      console.log(`Open ${page} and enter code ${code} (expires in ${minutes}m).`);
+    }, Boolean(process.stdout.isTTY));
     console.log(`Logged in as ${email}. Key saved to ${credentialsPath()}.`);
     return EXIT.pass;
   } catch (e) {
@@ -10130,6 +10176,102 @@ ${LOGOUT_HELP}`);
   return EXIT.pass;
 }
 
+// src/tty.ts
+import { emitKeypressEvents } from "node:readline";
+var ANSI2 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var visible = (s) => s.replace(ANSI2, "");
+function liveBlock(out = process.stdout) {
+  let drawn = 0;
+  const rowsOf = (line) => Math.max(1, Math.ceil(visible(line).length / (out.columns || 80)));
+  return {
+    draw(lines) {
+      out.write(`${drawn > 0 ? `\x1B[${drawn}A\x1B[J` : ""}${lines.join(`
+`)}
+`);
+      drawn = lines.reduce((n, l) => n + rowsOf(l), 0);
+    }
+  };
+}
+function animate(block, render) {
+  let frame = 0;
+  const draw = () => block.draw(render(SPIN[frame++ % SPIN.length]));
+  draw();
+  const timer = setInterval(draw, 120);
+  return () => clearInterval(timer);
+}
+function wrap(text, indent, width) {
+  const room = Math.max(10, width - indent.length);
+  const lines = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    for (let w = word;w.length > 0; ) {
+      const next = line ? `${line} ${w}` : w;
+      if (next.length <= room) {
+        line = next;
+        w = "";
+      } else if (line) {
+        lines.push(line);
+        line = "";
+      } else {
+        lines.push(w.slice(0, room));
+        w = w.slice(room);
+      }
+    }
+  }
+  if (line)
+    lines.push(line);
+  return lines.map((l) => indent + l);
+}
+function abortError() {
+  return Object.assign(new Error("Aborted"), { code: "ABORT_ERR" });
+}
+function select(block, count, render, initial = 0) {
+  const input = process.stdin;
+  let current = initial;
+  block.draw(render(current));
+  return new Promise((resolve, reject) => {
+    const restore = () => {
+      input.off("keypress", onKey);
+      input.off("end", onEnd);
+      process.off("exit", showCursor);
+      input.setRawMode(false);
+      input.pause();
+      showCursor();
+    };
+    const onKey = (_, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && (key.name === "c" || key.name === "d")) {
+        restore();
+        reject(abortError());
+      } else if (key.name === "return" || key.name === "enter") {
+        restore();
+        resolve(current);
+      } else if (key.name === "up" || key.name === "k") {
+        current = (current + count - 1) % count;
+        block.draw(render(current));
+      } else if (key.name === "down" || key.name === "j") {
+        current = (current + 1) % count;
+        block.draw(render(current));
+      }
+    };
+    const onEnd = () => {
+      restore();
+      reject(abortError());
+    };
+    emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    process.stdout.write("\x1B[?25l");
+    process.on("exit", showCursor);
+    input.on("keypress", onKey);
+    input.on("end", onEnd);
+  });
+}
+function showCursor() {
+  process.stdout.write("\x1B[?25h");
+}
+
 // src/init.ts
 var SKILLS_ARGV = [
   "skills",
@@ -10204,12 +10346,18 @@ runs: 1
 #   MYTOOL_HOME: "$FIREGOAT_HOME/.mytool"
 #   UV_FIND_LINKS: "$FIREGOAT_OUT"
 
+# Optional: values for {{vars.KEY}} in prompts, checks and build/install/cleanup
+# steps (pasted in as-is, unquoted); eval --var KEY=value overrides them. Steps
+# and checks also get each one as an env var ("$KEY": safe for any value).
+# vars:
+#   ACCOUNT: acme-test
+
 tests:
   # A smoke test that firegoat and claude work. Replace it with tests for your
   # product: the firegoat-onboarding skill writes them.
   - name: goat
     # What a user would ask their agent.
-    prompt: Who's the GOAT? Answer in one short sentence.
+    prompt: "Who's the GOAT? Hint: it's me, the person typing this. Answer in one short sentence with the word GOAT in it."
     # True when the user's problem is solved. Not graded by firegoat: it goes to
     # your agent (eval --json, run.json) to judge.
     end_goal: Claude answers that you (the user) are the goat, e.g. YOU'RE THE GOAT.
@@ -10218,7 +10366,7 @@ tests:
     checks:
       - run: >-
           test -s "$FIREGOAT_TRANSCRIPT" &&
-          grep -Eiq '^agent: .*goat' "$FIREGOAT_TRANSCRIPT"
+          grep -Eiq '^agent: .*(you.*goat|goat.*you)' "$FIREGOAT_TRANSCRIPT"
     # Seconds before the agent run is stopped.
     timeout: 600
 `;
@@ -10236,61 +10384,115 @@ function copyToClipboard(text) {
     return !r.error && r.status === 0;
   });
 }
-async function ask(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return (await rl.question(question)).trim();
-  } finally {
-    rl.close();
+var LOGIN_HINT = "Runs stay local: npx firegoat login uploads them to firegoat.ai";
+function cut(s, n) {
+  return s.length <= n ? s : `${s.slice(0, Math.max(0, n - 1))}~`;
+}
+
+class Timeline {
+  paint;
+  width;
+  static INDENT = " ".repeat(9);
+  constructor(paint, width) {
+    this.paint = paint;
+    this.width = width;
+  }
+  line(mark, n, label, status = "") {
+    const head = `  ${mark}  ${this.paint("90", String(n).padStart(2, "0"))}  `;
+    if (!status)
+      return head + cut(label, this.width - 9);
+    return `${head}${label.padEnd(28)}${this.paint("90", cut(status, this.width - 37))}`;
+  }
+  done(n, label, status) {
+    return this.line(this.paint("32", "●"), n, label, status);
+  }
+  failed(n, label) {
+    return this.line(this.paint("31", "●"), n, label, "Failed");
+  }
+  busy(spin, n, label, status) {
+    return this.line(this.paint("38;5;208", spin), n, label, status);
+  }
+  detail(text) {
+    return wrap(text, Timeline.INDENT, this.width).map((l) => this.paint("90", l));
+  }
+  gap() {
+    console.log(this.paint("90", "  │"));
+  }
+  ask(block, n, question, options) {
+    const cols = Math.max(...options.map(([l]) => l.length)) + 3;
+    const room = this.width - Timeline.INDENT.length - 2;
+    return select(block, options.length, (current) => [
+      this.line(this.paint("38;5;208", "◉"), n, question),
+      ...options.map(([label, note], i) => {
+        const text = cut(`${label.padEnd(cols)}${note}`, room);
+        return i === current ? `${Timeline.INDENT}${this.paint("38;5;208", `● ${text}`)}` : this.paint("90", `${Timeline.INDENT}○ ${text}`);
+      }),
+      this.paint("90", `${Timeline.INDENT}Up/down to move, enter to pick`)
+    ]);
   }
 }
-async function askYes(question) {
-  const a = await ask(`${question} [Y/n] `);
-  return a === "" || /^y(es)?$/i.test(a);
-}
-async function askScope(question) {
-  for (;; ) {
-    const a = await ask(`${question} [G/l/n] `);
-    if (a === "" || /^g(lobal)?$/i.test(a))
-      return "global";
-    if (/^l(ocal)?$/i.test(a))
-      return "local";
-    if (/^no?$/i.test(a))
-      return "none";
-    process.stdout.write("\x1B[1A\x1B[2K");
-  }
+function runQuiet(cmd, args, opts) {
+  return new Promise((resolve) => {
+    const child = spawn3(cmd, args, {
+      ...opts,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    const collect = (d) => {
+      output += d;
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+    child.on("error", (error) => resolve({ status: null, output, error }));
+    child.on("close", (status) => resolve({ status, output }));
+  });
 }
-var LOGIN_HINT = "Runs stay local: npx firegoat login uploads them to firegoat.ai";
-async function loginStep(interactive, done, paint) {
+async function loginStep(ui) {
   const label = "firegoat.ai login";
-  const uploadsOn = () => console.log(`      ${paint("90", UPLOADS_ON)}`);
   const key = resolveKey(baseUrl());
-  if (key) {
-    const who = key.source === "env" ? "FIREGOAT_API_KEY is set" : `Logged in as ${key.email}`;
-    if (interactive) {
-      done(label, who);
-      uploadsOn();
-    } else
-      console.log(`${who}
-${UPLOADS_ON}`);
+  const who = key ? key.source === "env" ? "FIREGOAT_API_KEY is set" : `Logged in as ${key.email}` : undefined;
+  if (!ui) {
+    console.log(who ? `${who}
+${UPLOADS_ON}` : LOGIN_HINT);
     return EXIT.pass;
   }
-  if (!interactive) {
-    console.log(LOGIN_HINT);
+  const block = liveBlock();
+  if (who) {
+    block.draw([ui.done(4, label, who), ...ui.detail(UPLOADS_ON)]);
     return EXIT.pass;
   }
-  console.log(`  ${paint("90", UPLOAD_NOTICE)}`);
-  const yes = await askYes(`  ${paint("38;5;208", "◉")}  ${paint("90", "04")}  Login to firegoat.ai to upload runs?`);
-  if (!yes) {
-    done(label, "Skipped (npx firegoat login later)");
+  const picked = await ui.ask(block, 4, "Login to firegoat.ai to upload runs?", [
+    ["Yes", "Opens firegoat.ai in your browser"],
+    ["Not now", "Runs stay local"]
+  ]);
+  if (picked !== 0) {
+    block.draw([ui.done(4, label, "Skipped (npx firegoat login later)")]);
     return EXIT.pass;
   }
+  let status = "Connecting";
+  let details = [];
+  const stop = animate(block, (spin) => [
+    ui.busy(spin, 4, label, status),
+    ...details
+  ]);
   try {
-    const email = await loginFlow((l) => console.log(`  ${l}`), true);
-    done(label, `Logged in as ${email}`);
-    uploadsOn();
+    const email = await loginFlow(({ page, code, minutes }) => {
+      status = "Waiting for the browser";
+      details = [
+        ...ui.detail(TERMS),
+        ...ui.detail(`Open ${page}`),
+        ...ui.detail(`Code: ${code} (expires in ${minutes}m)`)
+      ];
+    }, true);
+    stop();
+    block.draw([
+      ui.done(4, label, `Logged in as ${email}`),
+      ...ui.detail(UPLOADS_ON)
+    ]);
     return EXIT.pass;
   } catch (e) {
+    stop();
+    block.draw([ui.failed(4, label), ...details]);
     if (!(e instanceof ApiError))
       throw e;
     failWith(e instanceof NetworkError ? "network" : "login_failed");
@@ -10336,8 +10538,8 @@ ${INIT_HELP}`);
   const paint = (code, text) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
   const width = Math.min(process.stdout.columns || 80, 80);
   const rule = paint("90", ` ${"─".repeat(width - 2)}`);
-  const step = (n, label, status) => console.log(`  ${paint("32", "●")}  ${paint("90", String(n).padStart(2, "0"))}  ${label.padEnd(28)}${paint("90", status)}`);
-  if (interactive) {
+  const ui = interactive ? new Timeline(paint, width) : undefined;
+  if (ui) {
     for (const line of logoHeader(paint, "firegoat init", paint("90", "Get agent-ready."), width))
       console.log(line);
     console.log(rule);
@@ -10347,39 +10549,45 @@ ${INIT_HELP}`);
   const keep = existsSync4(configPath) && !force;
   if (!keep)
     writeFileSync5(configPath, template(basename4(cwd)));
-  if (interactive) {
-    step(1, CONFIG_FILE, keep ? "Kept (--force replaces it)" : "Created");
-    console.log(paint("90", "  │"));
-    step(2, ".firegoat/", "Ready");
+  if (ui) {
+    console.log(ui.done(1, CONFIG_FILE, keep ? "Kept (--force replaces it)" : "Created"));
+    ui.gap();
+    console.log(ui.done(2, ".firegoat/", "Ready"));
   } else
     console.log(keep ? `Kept ${CONFIG_FILE} (--force replaces it)` : `Wrote ${CONFIG_FILE}: replace the goat smoke test with tests for your product`);
-  if (interactive && !noSkills)
-    console.log(paint("90", "  │"));
-  if (interactive && !noSkills && !localSkills) {
-    scope = await askScope(`  ${paint("38;5;208", "◉")}  ${paint("90", "03")}  Install the firegoat-onboarding skill globally (~/.claude/skills) or in this repo (.claude/skills)?`);
-    process.stdout.write("\x1B[1A\x1B[2K");
+  const skill = "firegoat-onboarding skill";
+  const block = liveBlock();
+  ui?.gap();
+  if (ui && !noSkills && !localSkills) {
+    const picked = await ui.ask(block, 3, "Install the firegoat-onboarding skill", [
+      ["Global", skillsDir("global")],
+      ["This repo", `${skillsDir("local")} (commit it for your team)`],
+      ["Skip", "Don't install it"]
+    ]);
+    scope = ["global", "local", "none"][picked] ?? "none";
     initSkills(scope);
   }
   if (scope !== "none") {
     const argv = [...SKILLS_ARGV, ...scope === "global" ? ["-g"] : []];
     const where = skillsDir(scope);
-    if (!interactive)
+    if (!ui)
       console.log(`Installing the skill: npx ${argv.join(" ")}`);
     const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => k !== "npm_config_package" && !k.startsWith("FIREGOAT_")));
-    const r = spawnSync3("npx", ["-y", ...argv], {
-      cwd,
-      env,
-      stdio: "pipe",
-      encoding: "utf8"
-    });
+    const stop = ui ? animate(block, (spin) => [
+      ui.busy(spin, 3, skill, `Installing → ${where}`)
+    ]) : undefined;
+    const r = await runQuiet("npx", ["-y", ...argv], { cwd, env });
+    stop?.();
     if (r.error || r.status !== 0) {
       failWith("skills_failed");
-      process.stderr.write(`${r.stdout ?? ""}${r.stderr ?? ""}`);
+      if (ui)
+        block.draw([ui.failed(3, skill)]);
+      process.stderr.write(r.output);
       console.error(`firegoat init: Installing the skill failed (${r.error?.message ?? `exit ${r.status}`}). Run it yourself: npx ${argv.join(" ")}`);
       return EXIT.notGraded;
     }
-    if (interactive)
-      step(3, "firegoat-onboarding skill", `Installed → ${where}`);
+    if (ui)
+      block.draw([ui.done(3, skill, `Installed → ${where}`)]);
     else
       console.log(`Installed skill firegoat-onboarding in ${where}`);
     const ignored = scope === "local" && spawnSync3("git", ["check-ignore", "-q", ".claude/skills"], {
@@ -10388,32 +10596,35 @@ ${INIT_HELP}`);
     }).status === 0;
     if (ignored)
       console.error("Warning: git ignores .claude/skills, so teammates and CI won't get the skill. Commit them with: git add -f .claude/skills");
-  } else if (interactive)
-    step(3, "firegoat-onboarding skill", "Skipped");
+  } else if (ui)
+    block.draw([ui.done(3, skill, "Skipped")]);
   if (login) {
-    if (interactive)
-      console.log(paint("90", "  │"));
-    const loginExit = await loginStep(interactive, (label, status) => step(4, label, status), paint);
+    ui?.gap();
+    const loginExit = await loginStep(ui);
     if (loginExit !== EXIT.pass)
       return loginExit;
   }
   const telemetryOn = telemetryEnabled();
-  if (!interactive) {
+  if (!ui) {
     if (telemetryOn)
       console.log(TELEMETRY_NOTICE);
     console.log(`
 Prompt for your coding agent: ${AGENT_PROMPT}`);
     return EXIT.pass;
   }
-  if (telemetryOn)
-    console.log(`  ${paint("90", TELEMETRY_NOTICE)}`);
   console.log(rule);
+  console.log("");
   console.log(`  Next: hand this to your coding agent
 `);
   console.log(AGENT_PROMPT);
   console.log("");
   const copied = copyToClipboard(AGENT_PROMPT);
   console.log(`  ${copied ? `${paint("32", "✓ Prompt copied!")}   ` : ""}Then: ${paint("36", "npx firegoat@latest eval")}`);
+  if (telemetryOn) {
+    console.log("");
+    for (const l of wrap(TELEMETRY_NOTICE, "  ", width))
+      console.log(paint("90", l));
+  }
   return EXIT.pass;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "firegoat",
-	"version": "0.23.0",
+	"version": "0.24.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/firegoat-ai/firegoat-cli.git"