firegoat 0.28.0 → 0.29.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.28.0",
+  version: "0.29.0",
   repository: {
     type: "git",
     url: "git+https://github.com/firegoat-ai/firegoat-cli.git"
@@ -7265,8 +7265,146 @@ import { homedir } from "node:os";
 import { join as join3 } from "node:path";
 
 // src/home.ts
+import { execFile } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join as join2 } from "node:path";
+import { promisify } from "node:util";
+
+// src/process.ts
+import { execFileSync, spawn } from "node:child_process";
+var NPM_INJECTED = /^(npm_config_|npm_lifecycle_|npm_package_)|^(npm_execpath|npm_node_execpath|npm_command|INIT_CWD)$/;
+var CLAUDE_SESSION = /^(CLAUDECODE|CLAUDE_CODE_.+|CLAUDE_PID|CLAUDE_ENV_FILE|CLAUDE_SESSION_ID|CLAUDE_PROJECT_DIR|CLAUDE_EFFORT|CLAUDE_AGENT_SDK_.+|CLAUDE_PLUGIN_ROOT|CLAUDE_PLUGIN_DATA|CLAUDE_SKILL_DIR)$/;
+var CLAUDE_AUTH = /^CLAUDE_CODE_(OAUTH_TOKEN|OAUTH_REFRESH_TOKEN|USE_[A-Z_]+|SKIP_[A-Z]+_AUTH|CLIENT_CERT|CLIENT_KEY|CLIENT_KEY_PASSPHRASE)$/;
+function hostEnv() {
+  return Object.fromEntries(Object.entries(process.env).filter(([k]) => !NPM_INJECTED.test(k) && !k.startsWith("FIREGOAT_") && (!CLAUDE_SESSION.test(k) || CLAUDE_AUTH.test(k))));
+}
+var GRACE_MS = 5000;
+var liveGroups = new Set;
+var signalsHooked = false;
+function hookSignals() {
+  if (signalsHooked)
+    return;
+  signalsHooked = true;
+  const onSignal = (signal) => {
+    for (const g of liveGroups)
+      try {
+        process.kill(-g, "SIGKILL");
+      } catch {}
+    process.kill(process.pid, signal);
+  };
+  for (const s of ["SIGINT", "SIGTERM", "SIGHUP"])
+    process.once(s, onSignal);
+}
+function forgetGroup(pgid) {
+  liveGroups.delete(pgid);
+}
+function processTree(pid) {
+  const children = new Map;
+  const ps = execFileSync("ps", ["-A", "-o", "pid=,ppid="], {
+    encoding: "utf8"
+  });
+  for (const line of ps.split(`
+`)) {
+    const [child, parent] = line.trim().split(/\s+/).map(Number);
+    if (!child || parent === undefined)
+      continue;
+    children.set(parent, [...children.get(parent) ?? [], child]);
+  }
+  const tree = [pid];
+  for (let i = 0;i < tree.length; i++)
+    tree.push(...children.get(tree[i]) ?? []);
+  return tree;
+}
+function killTree(pid, group) {
+  if (group)
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {}
+  let tree = [pid];
+  let problem;
+  try {
+    tree = processTree(pid);
+  } catch (e) {
+    problem = e.message;
+  }
+  for (const p of tree)
+    try {
+      process.kill(p, "SIGKILL");
+    } catch {}
+  return problem;
+}
+function run(opts) {
+  return new Promise((resolve) => {
+    const detached = opts.detached === true;
+    if (detached)
+      hookSignals();
+    const child = spawn(opts.cmd, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached
+    });
+    if (child.pid !== undefined) {
+      if (detached)
+        liveGroups.add(child.pid);
+      opts.onSpawn?.(child.pid);
+    }
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (child.pid === undefined)
+        return;
+      const problem = killTree(child.pid, detached);
+      if (problem)
+        opts.onStderr(Buffer.from(`firegoat: timed out; could not list ${opts.cmd}'s child processes (${problem}), killed only ${opts.cmd}
+`));
+    }, opts.timeoutMs);
+    const done = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    child.stdout.on("data", opts.onStdout);
+    child.stderr.on("data", opts.onStderr);
+    opts.finalSeen?.then(() => setTimeout(() => done({ code: null, timedOut: false, ended: true }), GRACE_MS).unref());
+    child.on("error", (error) => done({ code: null, timedOut, error }));
+    child.on("close", (code) => done({ code, timedOut }));
+    child.on("exit", (code) => setTimeout(() => {
+      child.stdout.destroy();
+      child.stderr.destroy();
+      done({ code, timedOut });
+    }, 2000).unref());
+  });
+}
+async function runShell(opts) {
+  opts.log.write(`$ ${opts.run}
+`);
+  const r = await run({
+    cmd: "/bin/sh",
+    args: ["-c", opts.run],
+    cwd: opts.cwd,
+    env: opts.env,
+    timeoutMs: opts.timeoutMs,
+    onStdout: (c) => opts.log.write(c),
+    onStderr: (c) => opts.log.write(c)
+  });
+  let error;
+  if (r.error)
+    error = `could not start /bin/sh: ${r.error.message}`;
+  else if (r.timedOut)
+    error = `timed out after ${opts.timeoutMs / 1000}s`;
+  else if (r.code === null)
+    error = "killed by a signal";
+  opts.log.write(`[exit ${r.code ?? "none"}${error ? `: ${error}` : ""}]
+
+`);
+  return error ? { run: opts.run, code: r.code, error } : { run: opts.run, code: r.code };
+}
+
+// src/home.ts
 function homeEnv(home) {
   return {
     HOME: home,
@@ -7287,6 +7425,23 @@ function makeRunHome(dir) {
 `).join(""));
   return { home, envFile };
 }
+async function makeRunKeychain(home) {
+  const keychain = join2(home, "Library", "Keychains", "login.keychain-db");
+  const env = { ...hostEnv(), HOME: home };
+  mkdirSync(join2(home, "Library", "Keychains"), { recursive: true });
+  for (const args of [
+    ["create-keychain", "-p", "", keychain],
+    ["set-keychain-settings", keychain]
+  ]) {
+    try {
+      await promisify(execFile)("security", args, { env, timeout: 30000 });
+    } catch (e) {
+      const err = e;
+      return `could not create the run's login keychain (security ${args[0]} ${keychain}): ${err.stderr?.trim() || err.message}`;
+    }
+  }
+  return null;
+}
 
 // src/harnesses/codex.ts
 var FLAGS2 = [
@@ -7879,6 +8034,7 @@ function validHarnesses() {
 // src/config.ts
 var CONFIG_FILE = "firegoat.yaml";
 var DEFAULT_TIMEOUT = 600;
+var DEFAULT_PARALLEL = 4;
 
 class ConfigError extends Error {
 }
@@ -7916,6 +8072,7 @@ function parseConfig(text) {
     fail("(root)", "must be a mapping");
   onlyKeys(raw, "(root)", [
     "runs",
+    "parallel",
     "harness",
     "model",
     "build",
@@ -7927,6 +8084,7 @@ function parseConfig(text) {
     "tests"
   ]);
   const runs = posInt(raw.runs, "runs", 1);
+  const parallel = posInt(raw.parallel, "parallel", DEFAULT_PARALLEL);
   const harnesses = raw.harness === undefined ? [DEFAULT_HARNESS] : nameList(raw.harness, "harness", "a harness name");
   harnesses.forEach((h, i) => {
     if (!HARNESSES.has(h))
@@ -7990,6 +8148,7 @@ function parseConfig(text) {
   });
   return {
     runs,
+    parallel,
     harnesses,
     models,
     build,
@@ -8173,6 +8332,7 @@ import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   appendFileSync,
   createWriteStream as createWriteStream2,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   writeFileSync as writeFileSync5
 } from "node:fs";
@@ -8530,142 +8690,6 @@ function ensureFiregoatDir(root) {
 // src/git.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { basename, dirname } from "node:path";
-
-// src/process.ts
-import { execFileSync, spawn } from "node:child_process";
-var NPM_INJECTED = /^(npm_config_|npm_lifecycle_|npm_package_)|^(npm_execpath|npm_node_execpath|npm_command|INIT_CWD)$/;
-var CLAUDE_SESSION = /^(CLAUDECODE|CLAUDE_CODE_.+|CLAUDE_PID|CLAUDE_ENV_FILE|CLAUDE_SESSION_ID|CLAUDE_PROJECT_DIR|CLAUDE_EFFORT|CLAUDE_AGENT_SDK_.+|CLAUDE_PLUGIN_ROOT|CLAUDE_PLUGIN_DATA|CLAUDE_SKILL_DIR)$/;
-var CLAUDE_AUTH = /^CLAUDE_CODE_(OAUTH_TOKEN|OAUTH_REFRESH_TOKEN|USE_[A-Z_]+|SKIP_[A-Z]+_AUTH|CLIENT_CERT|CLIENT_KEY|CLIENT_KEY_PASSPHRASE)$/;
-function hostEnv() {
-  return Object.fromEntries(Object.entries(process.env).filter(([k]) => !NPM_INJECTED.test(k) && !k.startsWith("FIREGOAT_") && (!CLAUDE_SESSION.test(k) || CLAUDE_AUTH.test(k))));
-}
-var GRACE_MS = 5000;
-var liveGroups = new Set;
-var signalsHooked = false;
-function hookSignals() {
-  if (signalsHooked)
-    return;
-  signalsHooked = true;
-  const onSignal = (signal) => {
-    for (const g of liveGroups)
-      try {
-        process.kill(-g, "SIGKILL");
-      } catch {}
-    process.kill(process.pid, signal);
-  };
-  for (const s of ["SIGINT", "SIGTERM", "SIGHUP"])
-    process.once(s, onSignal);
-}
-function forgetGroup(pgid) {
-  liveGroups.delete(pgid);
-}
-function processTree(pid) {
-  const children = new Map;
-  const ps = execFileSync("ps", ["-A", "-o", "pid=,ppid="], {
-    encoding: "utf8"
-  });
-  for (const line of ps.split(`
-`)) {
-    const [child, parent] = line.trim().split(/\s+/).map(Number);
-    if (!child || parent === undefined)
-      continue;
-    children.set(parent, [...children.get(parent) ?? [], child]);
-  }
-  const tree = [pid];
-  for (let i = 0;i < tree.length; i++)
-    tree.push(...children.get(tree[i]) ?? []);
-  return tree;
-}
-function killTree(pid, group) {
-  if (group)
-    try {
-      process.kill(-pid, "SIGKILL");
-    } catch {}
-  let tree = [pid];
-  let problem;
-  try {
-    tree = processTree(pid);
-  } catch (e) {
-    problem = e.message;
-  }
-  for (const p of tree)
-    try {
-      process.kill(p, "SIGKILL");
-    } catch {}
-  return problem;
-}
-function run(opts) {
-  return new Promise((resolve) => {
-    const detached = opts.detached === true;
-    if (detached)
-      hookSignals();
-    const child = spawn(opts.cmd, opts.args, {
-      cwd: opts.cwd,
-      env: opts.env,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached
-    });
-    if (child.pid !== undefined) {
-      if (detached)
-        liveGroups.add(child.pid);
-      opts.onSpawn?.(child.pid);
-    }
-    let timedOut = false;
-    let settled = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      if (child.pid === undefined)
-        return;
-      const problem = killTree(child.pid, detached);
-      if (problem)
-        opts.onStderr(Buffer.from(`firegoat: timed out; could not list ${opts.cmd}'s child processes (${problem}), killed only ${opts.cmd}
-`));
-    }, opts.timeoutMs);
-    const done = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(r);
-    };
-    child.stdout.on("data", opts.onStdout);
-    child.stderr.on("data", opts.onStderr);
-    opts.finalSeen?.then(() => setTimeout(() => done({ code: null, timedOut: false, ended: true }), GRACE_MS).unref());
-    child.on("error", (error) => done({ code: null, timedOut, error }));
-    child.on("close", (code) => done({ code, timedOut }));
-    child.on("exit", (code) => setTimeout(() => {
-      child.stdout.destroy();
-      child.stderr.destroy();
-      done({ code, timedOut });
-    }, 2000).unref());
-  });
-}
-async function runShell(opts) {
-  opts.log.write(`$ ${opts.run}
-`);
-  const r = await run({
-    cmd: "/bin/sh",
-    args: ["-c", opts.run],
-    cwd: opts.cwd,
-    env: opts.env,
-    timeoutMs: opts.timeoutMs,
-    onStdout: (c) => opts.log.write(c),
-    onStderr: (c) => opts.log.write(c)
-  });
-  let error;
-  if (r.error)
-    error = `could not start /bin/sh: ${r.error.message}`;
-  else if (r.timedOut)
-    error = `timed out after ${opts.timeoutMs / 1000}s`;
-  else if (r.code === null)
-    error = "killed by a signal";
-  opts.log.write(`[exit ${r.code ?? "none"}${error ? `: ${error}` : ""}]
-
-`);
-  return error ? { run: opts.run, code: r.code, error } : { run: opts.run, code: r.code };
-}
-
-// src/git.ts
 function git(dir, args) {
   const r = spawnSync3("git", args, {
     cwd: dir,
@@ -8834,6 +8858,9 @@ firegoat.yaml, committed.
 
 firegoat.yaml reference:
   runs: 1                     Runs per test
+  parallel: 4                 Runs at once (default 4; 1 runs them one after
+                              another, e.g. when tests share one cloud
+                              account); eval --parallel overrides
   harness: <name> | [<name>, ...]
                               The agent CLI: claude-code (default), codex-cli
                               or grok-cli.
@@ -8946,7 +8973,11 @@ firegoat.yaml reference:
   Checks also get $FIREGOAT_TRANSCRIPT, a short plain-text
   transcript, greppable line by line (format: eval --help, Transcript). So
   '^\\[[0-9]+\\] \\$ .*foo' matches only commands. Checks also get
-  $FIREGOAT_SESSION (the harness's full session file, JSON lines).
+  $FIREGOAT_SESSION (the harness's full session file, JSON lines). cleanup gets
+  $FIREGOAT_TRANSCRIPT once the agent has run (also after a claude error or a
+  timeout), and $FIREGOAT_SESSION when the harness saved a session file; neither
+  is set when install failed before the agent started, so a cleanup that reads
+  them should fail on an unset one: grep ... "\${FIREGOAT_TRANSCRIPT:?}".
 
   The agent never gets vars, only env:. The vars npm/npx set for firegoat itself
   (npm_config_*, npm_lifecycle_*, npm_package_*, npm_execpath, npm_node_execpath,
@@ -9102,10 +9133,13 @@ Every run gets its own HOME, ~/.firegoat/runs/<hash>/<random>/home next to work
 $FIREGOAT_HOME: tools that keep state in ~ start fresh and parallel runs don't
 collide. claude itself keeps your real HOME (its login is there) and sources
 home.env next to it (CLAUDE_ENV_FILE) before each Bash command the agent runs; install,
-checks and cleanup get the run's HOME directly; build keeps yours. Limits: claude's
-own Read/Write tools expand ~ to your real home; getpwuid lookups (os.userInfo,
-python pwd) still see it; keychain logins (gh, docker, git credential helpers) look
-logged out inside a run, so log tools in from install: or with env: tokens; the
+checks and cleanup get the run's HOME directly; build keeps yours. On macOS the run's
+home has its own empty, password-less login keychain (Library/Keychains), so a
+browser the agent starts doesn't ask you for one; your keychain is never touched.
+Limits: claude's own Read/Write tools expand ~ to your real home; getpwuid lookups
+(os.userInfo, python pwd) still see it; keychain logins (gh, docker, git credential
+helpers) look logged out inside a run, so log tools in from install: or with env:
+tokens; the
 fresh home has no .gitconfig, so set user.name/user.email in install: if the agent
 commits; claude's shell snapshot still sources your real ~/.zshrc.
 
@@ -9129,14 +9163,16 @@ firegoat.yaml, fixtures and build: stay in the current folder.
   --model NAME       The harness's --model, replacing model: in firegoat.yaml;
                      repeat it (--model a --model b) to run each test runs times
                      per model
-  --parallel N       Runs at once (default 4; 1 runs them one after another).
+  --parallel N       Runs at once (overrides parallel: in firegoat.yaml;
+                     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}} (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. The verdict comes
-                     last, after runs: totals {pass, fail, error}, status
+                     last, after runs: totals {pass, fail, error}, tier
+                     (S/A/B/C, as printed; null when no run was graded), 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,
@@ -9174,7 +9210,7 @@ Output: .firegoat/runs/<runId>/
                           ran), git {branch, commit, dirty} (no git outside a
                           repo), harnesses, upload {origin, email} (null when
                           not uploading), runs (every run.json), then the
-                          verdict: totals, status and exitCode
+                          verdict: totals, tier, status and exitCode
   ../index.jsonl          One line per eval: runId, startedAt, dir, branch,
                           commit, harnesses, passed, failed, notGraded, cost (null when
                           any run's cost is unknown), uploaded, uploadFailed
@@ -9191,7 +9227,8 @@ Output: .firegoat/runs/<runId>/
                           claudeSession (the session.jsonl uploaded: claude's
                           own file, else <test>/<n>/session.jsonl made from the
                           stream) and sessionId (its id, the trace's), stderr,
-                          checksLog, cleanupLog; startedAt; upload ({status: "uploaded",
+                          checksLog, cleanupLog; turns and cost (null when the
+                          harness reports none), durationMs, startedAt; upload ({status: "uploaded",
                           url} | {status: "failed", error} | {status:
                           "skipped", reason}, null when not uploading)
   <test>/<n>/transcript.txt  What the agent did, below
@@ -10543,9 +10580,9 @@ async function uploadRun(t, r) {
         run: clip(c.run, MAX_TEXT, "…"),
         code: c.code
       })),
-      num_turns: r.num_turns,
+      num_turns: r.turns,
       cost: r.cost,
-      duration_ms: r.duration_ms,
+      duration_ms: r.durationMs,
       harness: r.harness,
       model,
       ...git && { git }
@@ -10624,7 +10661,6 @@ function parseArgs(args) {
     names: [],
     models: [],
     harnesses: [],
-    parallel: 4,
     json: false,
     noUpload: false,
     dryRun: false,
@@ -10835,9 +10871,9 @@ async function runOne(opts) {
     cleanup: [],
     cleanupLog: join10(dir, "cleanup.txt"),
     leftover: [],
-    num_turns: null,
+    turns: null,
     cost: null,
-    duration_ms: 0,
+    durationMs: 0,
     startedAt: new Date(started).toISOString(),
     upload: null
   };
@@ -10858,13 +10894,17 @@ async function runOne(opts) {
     r.cleanup = await runAllSteps({
       commands: steps.cleanup,
       cwd: workdir,
-      env: stepEnv,
+      env: {
+        ...stepEnv,
+        ...existsSync6(r.transcript) && { FIREGOAT_TRANSCRIPT: r.transcript },
+        ...r.session !== null && { FIREGOAT_SESSION: r.session }
+      },
       logPath: r.cleanupLog
     });
   r.leftover = await stopLeftovers({ group: agent.group, workdir });
   r.status = status;
   r.reason = reason;
-  r.duration_ms = Date.now() - started;
+  r.durationMs = Date.now() - started;
   writeRunJson(r);
   return r;
 }
@@ -10874,6 +10914,11 @@ function withoutOldPwd(env) {
 async function attempt(opts, r, steps, env, stepEnv, homeEnvFile, agent) {
   const { test, n } = opts;
   const { dir, workdir } = r;
+  if (process.platform === "darwin") {
+    const error = await makeRunKeychain(r.home);
+    if (error)
+      return ["error", `not graded: ${error}`];
+  }
   if (steps.install.length > 0) {
     const error = await runSteps({
       what: "install",
@@ -10947,7 +10992,7 @@ async function attempt(opts, r, steps, env, stepEnv, homeEnvFile, agent) {
     final: outcome.final,
     workdir
   });
-  r.num_turns = outcome.turns;
+  r.turns = outcome.turns;
   r.cost = outcome.cost;
   if (!outcome.ok)
     return ["error", `not graded: ${outcome.reason}`];
@@ -11045,6 +11090,7 @@ async function evalCommand(args, root) {
     tests = tests.filter((t) => opts.names.includes(t.name));
   }
   const runs = opts.runs ?? config.runs;
+  const parallel = opts.parallel ?? config.parallel;
   const models = opts.models.length > 0 ? opts.models : config.models;
   const harnessNames = opts.harnesses.length > 0 ? opts.harnesses : config.harnesses;
   if (opts.harnessBin !== undefined && harnessNames.length !== 1)
@@ -11055,7 +11101,7 @@ async function evalCommand(args, root) {
     testCount: tests.length,
     runCount: tests.length * runs * Math.max(models.length, 1) * harnesses.length,
     modelCount: models.length,
-    parallel: opts.parallel
+    parallel
   });
   const vars = { ...config.vars, ...opts.vars };
   const missing = [
@@ -11215,11 +11261,11 @@ async function evalCommand(args, root) {
     results[i] = r;
     Object.assign(row, {
       state: r.status,
-      reportedTurns: r.num_turns,
+      reportedTurns: r.turns,
       reason: r.reason,
       checks: r.checks,
       cost: r.cost,
-      seconds: Math.round(r.duration_ms / 1000),
+      seconds: Math.round(r.durationMs / 1000),
       command: undefined
     });
     ui.update();
@@ -11237,7 +11283,7 @@ async function evalCommand(args, root) {
     while (next < rows.length)
       await runAt(next++);
   };
-  await Promise.all(Array.from({ length: Math.min(opts.parallel, rows.length) }, worker));
+  await Promise.all(Array.from({ length: Math.min(parallel, rows.length) }, worker));
   const totals = { pass: 0, fail: 0, error: 0 };
   for (const r of results)
     totals[r.status]++;
@@ -11266,6 +11312,7 @@ async function evalCommand(args, root) {
     upload: upload && { origin: upload.origin, email: upload.email },
     runs: results,
     totals,
+    tier: tier(rows),
     status,
     exitCode
   };
@@ -11586,7 +11633,7 @@ firegoat ${package_default.version}` : `firegoat ${package_default.version}`,
 
 // src/init.ts
 import { spawn as spawn4, spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync7, writeFileSync as writeFileSync6 } from "node:fs";
 import { basename as basename3, join as join11 } from "node:path";
 
 // src/login.ts
@@ -11900,6 +11947,10 @@ function template(product) {
 # How many times to run each test.
 runs: 1
 
+# Optional: how many runs at once (default 4). 1 runs them one after another,
+# e.g. when tests share one cloud account. eval --parallel N overrides it.
+# parallel: 1
+
 # Optional: the agent CLI each test runs on: claude-code (default), codex-cli or grok-cli.
 # A list runs every test \`runs\` times per harness. eval --harness NAME overrides it.
 # harness: [claude-code, codex-cli]
@@ -12162,7 +12213,7 @@ ${INIT_HELP}`);
   }
   ensureFiregoatDir(cwd);
   const configPath = join11(cwd, CONFIG_FILE);
-  const keep = existsSync6(configPath) && !force;
+  const keep = existsSync7(configPath) && !force;
   if (!keep)
     writeFileSync6(configPath, template(basename3(cwd)));
   if (ui) {

package/package.json

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