@great-arrow/cli 0.1.68 → 0.7.0

package/dist/index.js

@@ -9373,6 +9373,52 @@ function classifyRequestFailure(error62) {
   }
   return { kind, message, hint: FAILURE_HINTS[kind] };
 }
+var DEFAULT_ORIGIN = "https://www.greatarrow.ai";
+var LEVEL_WORDS = {
+  passkey: "a passkey",
+  verified: "a verified identity"
+};
+function actionLink(url2, apiUrl) {
+  try {
+    return new URL(url2, apiUrl || DEFAULT_ORIGIN).toString();
+  } catch {
+    return url2;
+  }
+}
+function policyRefusal(body, apiUrl) {
+  let record2 = body;
+  if (typeof body === "string") {
+    try {
+      record2 = JSON.parse(body);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof record2 !== "object" || record2 === null) return null;
+  let r = record2;
+  if (typeof r.error === "object" && r.error !== null) {
+    const data = r.error.data;
+    if (typeof data !== "object" || data === null) return null;
+    r = data;
+  }
+  const url2 = typeof r.actionUrl === "string" && r.actionUrl ? actionLink(r.actionUrl, apiUrl) : null;
+  if (r.error === "identity_assurance_required") {
+    const need = LEVEL_WORDS[typeof r.required === "string" ? r.required : ""] ?? "a stronger sign-in";
+    return {
+      code: r.error,
+      message: `This workspace requires ${need} on your account.`,
+      hint: url2 ? `Open ${url2} to add it, then try again.` : "Add it under Account \u2192 Security, then try again."
+    };
+  }
+  if (r.error === "owner_approval_required") {
+    return {
+      code: r.error,
+      message: typeof r.message === "string" && r.message ? r.message : "Only the workspace owner can do this.",
+      hint: url2 ? `Open ${url2} to continue.` : "Ask the workspace owner to do it, or to change it on the Access page."
+    };
+  }
+  return null;
+}
 var SERVER_CODE = /^[a-z][a-z0-9_]{0,63}$/;
 function withServerCode(error62, body) {
   try {
@@ -9437,7 +9483,7 @@ function isNodeError(value) {
 
 // src/lib/version.ts
 var CLI_PACKAGE_NAME = "@great-arrow/cli";
-var CLI_VERSION = "0.1.68";
+var CLI_VERSION = "0.7.0";
 var GAD_INSTALL_VERSION = "2026.08.08";
 var GAD_INSTALL_MIN_VERSION = "2026.06.22";
 var GAD_INSTALL_HEADER = "X-GAD-Install-Version";
@@ -10919,11 +10965,11 @@ var EXIT_SESSION_EXPIRED = 2;
 var EXIT_NOT_OAUTH = 3;
 function authCommand() {
   const cmd = new Command("auth").description("Authentication helpers");
-  cmd.command("token").description("Print a fresh OAuth access token, refreshing it if needed").option("--json", "Output {accessToken, accessExpiresAt, apiUrl} as JSON").action(async (options, actionCommand) => {
+  cmd.command("token").description("Print a fresh OAuth access token, refreshing it if needed").option("--json", "Output {accessToken, accessExpiresAt, apiUrl} as JSON").action(async (options, actionCommand2) => {
     try {
       const t = await getFreshOAuthAccessToken();
       writeCliLocator();
-      const jsonOutput = options.json || actionCommand.optsWithGlobals().json;
+      const jsonOutput = options.json || actionCommand2.optsWithGlobals().json;
       process.stdout.write(
         jsonOutput ? `${JSON.stringify(t)}
 ` : `${t.accessToken}
@@ -11056,6 +11102,8 @@ var ERROR_ENVELOPE_KEYS = /* @__PURE__ */ new Set([
   "details",
   "error_description",
   "reauth_url",
+  "actionUrl",
+  "achieved",
   "required",
   "ok",
   "success",
@@ -11073,6 +11121,8 @@ function cleanErrorText(text3) {
 }
 function hintFrom(record2) {
   if (nonEmpty(record2.hint)) return record2.hint;
+  if (nonEmpty(record2.actionUrl))
+    return `Open ${actionLink(record2.actionUrl, process.env.GAD_API_URL)} to continue.`;
   if (nonEmpty(record2.reauth_url))
     return `Re-authorize this connection: ${record2.reauth_url}`;
   return void 0;
@@ -11700,6 +11750,13 @@ var GadClient = class {
     const status = response.status;
     const body = await response.text().catch(() => "");
     if (status === 403) {
+      const refusal2 = policyRefusal(body, this.apiUrl);
+      if (refusal2) {
+        throw withServerCode(
+          new CliError(refusal2.message, 1 /* AUTH_ERROR */, refusal2.hint),
+          JSON.stringify({ error: refusal2.code })
+        );
+      }
       throw withServerCode(
         new CliError(
           "Permission denied (HTTP 403).",
@@ -11792,6 +11849,10 @@ var GadClient = class {
           message: data.error.message
         }
       });
+      const refusal2 = policyRefusal(data, this.apiUrl);
+      if (refusal2) {
+        throw new CliError(refusal2.message, 1 /* AUTH_ERROR */, refusal2.hint);
+      }
       const code = data.error.code === -32001 ? 1 /* AUTH_ERROR */ : 2 /* NETWORK_ERROR */;
       throw new CliError(
         data.error.message,
@@ -40833,9 +40894,9 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
     }
     return { status: status.value, value: input2.data };
   }
-  _regex(regex2, validation, message) {
+  _regex(regex2, validation2, message) {
     return this.refinement((data) => regex2.test(data), {
-      validation,
+      validation: validation2,
       code: ZodIssueCode2.invalid_string,
       ...errorUtil.errToObj(message)
     });
@@ -50175,6 +50236,248 @@ function callCommand() {
   });
 }
 
+// src/commands/board.ts
+var TOOL = "board_autopilot";
+function asObject4(json3) {
+  if (!json3.startsWith("{")) return null;
+  try {
+    const data = JSON.parse(json3);
+    return data && typeof data === "object" && !Array.isArray(data) ? data : null;
+  } catch (error62) {
+    void error62;
+    return null;
+  }
+}
+function parseToolResult(result) {
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    return { text: "", data: result };
+  }
+  if (typeof result !== "string") return { text: "", data: null };
+  const cut = result.lastIndexOf("\n");
+  const tail = result.slice(cut + 1).trim();
+  const candidates = [
+    [result.slice(0, Math.max(cut, 0)), tail],
+    ["", result.trim()]
+  ];
+  for (const [text3, json3] of candidates) {
+    const data = asObject4(json3);
+    if (data) return { text: text3, data };
+  }
+  return { text: result, data: null };
+}
+function validation(message, hint) {
+  return new CliError(message, 3 /* VALIDATION_ERROR */, hint);
+}
+function hostedP90(plan) {
+  const q = plan?.quotes?.find((x) => x.executor === "hosted");
+  return typeof q?.p90Usd === "number" ? q.p90Usd : null;
+}
+function buildStartArgs(runId, plan, opts) {
+  if (!opts.healthUrl)
+    throw validation(
+      "--yes needs --health-url <url>.",
+      "The run watches this URL after every merge and rolls back when it fails."
+    );
+  if (!opts.versionUrl)
+    throw validation(
+      "--yes needs --version-url <url>.",
+      "The run reads the serving version here to know a merge reached production."
+    );
+  let cap;
+  if (opts.cap !== void 0) {
+    cap = Number(opts.cap);
+    if (!Number.isFinite(cap) || cap <= 0)
+      throw validation("--cap must be a positive dollar amount.");
+  } else {
+    cap = hostedP90(plan);
+  }
+  if (cap === null)
+    throw validation(
+      "The plan carried no hosted quote to default the cap from.",
+      "Pass --cap <usd>."
+    );
+  if (cap <= 0)
+    throw validation(
+      "The hosted quote is $0, so there is no cap to default to.",
+      "Pass --cap <usd>."
+    );
+  const rejected = new Set(opts.reject ?? []);
+  if (plan?.findings) {
+    const known = new Set(plan.findings.map((f) => f.id));
+    const unknown2 = [...rejected].filter((id) => !known.has(id));
+    if (unknown2.length > 0)
+      throw validation(
+        `--reject: unknown finding id(s): ${unknown2.join(", ")}.`,
+        "Run without --yes to list finding ids."
+      );
+  }
+  const args = {
+    action: "start",
+    run_id: runId,
+    accepted_finding_ids: (plan?.findings ?? []).map((f) => f.id).filter((id) => !rejected.has(id)),
+    cap_usd: cap,
+    notify: { email: opts.email !== false, push: opts.push !== false },
+    health_check_url: opts.healthUrl,
+    version_url: opts.versionUrl
+  };
+  if (opts.types)
+    args.card_types = opts.types.split(",").map((t) => t.trim()).filter(Boolean);
+  return args;
+}
+async function callBoard(client2, args) {
+  let result;
+  try {
+    result = await client2.mcpCall("gad_call", gadCallArgs(TOOL, args));
+  } catch (error62) {
+    if (!(error62 instanceof McpToolError)) throw error62;
+    throw validation(`${TOOL}: ${error62.message}`, error62.hint);
+  }
+  const failure2 = callFailure(result);
+  if (failure2) {
+    throw new CliError(
+      `${TOOL}: ${failure2.message}`,
+      failure2.code === "feature_disabled" || failure2.code === "insufficient_scope" ? 1 /* AUTH_ERROR */ : 3 /* VALIDATION_ERROR */
+    );
+  }
+  return result;
+}
+function printPlan(fmt, plan) {
+  const row = (r) => r;
+  const f = plan.findings ?? [];
+  const c = plan.cards ?? [];
+  const q = plan.quotes ?? [];
+  process.stdout.write(`
+Board cleanups (${f.length})
+`);
+  fmt.table(f.map(row), [
+    { key: "id", header: "Finding" },
+    { key: "kind", header: "Kind" },
+    { key: "todoId", header: "Card" }
+  ]);
+  process.stdout.write(`
+Cards (${c.length})
+`);
+  fmt.table(
+    c.map((x) => row({ ...x, completable: x.completable ? "yes" : "no" })),
+    [
+      { key: "title", header: "Title" },
+      { key: "type", header: "Type" },
+      { key: "completable", header: "Runs alone" },
+      { key: "reason", header: "Why" }
+    ]
+  );
+  process.stdout.write("\nQuotes (USD)\n");
+  fmt.table(
+    q.map(
+      (x) => row({
+        ...x,
+        status: x.available ? "available" : x.comingSoon ? "soon" : "n/a"
+      })
+    ),
+    [
+      { key: "label", header: "Executor" },
+      { key: "status", header: "Status" },
+      { key: "p50Usd", header: "p50" },
+      { key: "p90Usd", header: "p90" }
+    ]
+  );
+}
+function makeFormatter(command) {
+  const g = globalOutputOpts(command);
+  return {
+    g,
+    fmt: createFormatter({
+      json: g.json,
+      quiet: g.quiet,
+      isTTY: isTTY(),
+      noColor: g.noColor
+    })
+  };
+}
+async function makeClient() {
+  const auth = await resolveAuth();
+  return new GadClient({
+    token: auth.token,
+    getToken: auth.getToken,
+    apiUrl: auth.apiUrl
+  });
+}
+function emit(result, json3, quiet = false) {
+  const { text: text3, data } = parseToolResult(result);
+  if (json3) {
+    process.stdout.write(
+      `${typeof result === "string" ? result : JSON.stringify(result)}
+`
+    );
+  } else if (text3 && !quiet) {
+    process.stdout.write(`${text3}
+`);
+  }
+  return data;
+}
+async function runClear(opts, command) {
+  if (opts.yes)
+    buildStartArgs(
+      "pending",
+      { quotes: [{ executor: "hosted", p90Usd: 1 }] },
+      opts
+    );
+  const { g, fmt } = makeFormatter(command);
+  const client2 = await makeClient();
+  const planResult = await callBoard(client2, {
+    action: "plan",
+    ...opts.goal ? { goal_id: opts.goal } : {}
+  });
+  const data = emit(planResult, g.json && !opts.yes, g.quiet);
+  const run4 = data?.run ?? null;
+  if (!g.json && !g.quiet && run4?.plan) printPlan(fmt, run4.plan);
+  if (!opts.yes) {
+    if (!g.json && !g.quiet && run4?.id)
+      process.stdout.write(
+        `
+Nothing has changed. Start with: gad board clear${opts.goal ? ` --goal ${opts.goal}` : ""} --yes --health-url <url> --version-url <url>
+`
+      );
+    return;
+  }
+  if (!run4?.id) throw validation("The plan reply carried no run id.");
+  const startResult = await callBoard(
+    client2,
+    buildStartArgs(run4.id, run4.plan, opts)
+  );
+  emit(startResult, g.json, g.quiet);
+}
+function actionCommand(action) {
+  return new Command(action).description(`${action} a clear-the-board run`).option("--run <id>", "Run id (status defaults to the latest run)").option("--card <id>", "Undo only this card (undo)").action(async (opts, command) => {
+    if (action !== "status" && !opts.run)
+      throw validation(`${action} needs --run <id>.`);
+    if (opts.card && action !== "undo")
+      throw validation("--card only applies to undo.");
+    const { g } = makeFormatter(command);
+    const client2 = await makeClient();
+    const result = await callBoard(client2, {
+      action,
+      ...opts.run ? { run_id: opts.run } : {},
+      ...opts.card ? { card_id: opts.card } : {}
+    });
+    emit(result, g.json, g.quiet);
+  });
+}
+function boardCommand() {
+  const clear = new Command("clear").description("Preview, start, watch, stop or undo a clear-the-board run").option("--goal <id>", "Limit the run to one Goal").option("--yes", "Start the run after planning").option("--health-url <url>", "URL probed after each merge (needs --yes)").option(
+    "--version-url <url>",
+    "URL that reports the serving sha (needs --yes)"
+  ).option("--cap <usd>", "Spend cap in USD (default: hosted p90 quote)").option("--types <list>", "Comma-separated card types, e.g. code").option("--no-email", "Do not email when the run finishes").option("--no-push", "Do not push-notify when the run finishes").option(
+    "--reject <findingId...>",
+    "Finding ids to leave out of the accepted set"
+  ).option("--json", "Output the raw tool result");
+  clear.action(runClear);
+  clear.addCommand(actionCommand("status"));
+  clear.addCommand(actionCommand("stop"));
+  clear.addCommand(actionCommand("undo"));
+  return new Command("board").description("Clear the board: tidy cards and run the safe ones").addCommand(clear);
+}
+
 // src/commands/keys.ts
 import { createInterface as createInterface3 } from "node:readline";
 import { Writable } from "node:stream";
@@ -55000,8 +55303,8 @@ var program2 = new Command().name("gad").description("Great Arrow Digital CLI \u
 );
 program2.hook(
   "preAction",
-  async (_thisCommand, actionCommand) => {
-    const options = actionCommand.optsWithGlobals();
+  async (_thisCommand, actionCommand2) => {
+    const options = actionCommand2.optsWithGlobals();
     const config2 = await loadConfig();
     setCommandWorkspaceTarget(options.workspace, config2.default_workspace);
   }
@@ -55021,6 +55324,7 @@ program2.addCommand(todo_default);
 program2.addCommand(nextCommand());
 program2.addCommand(discoverCommand());
 program2.addCommand(callCommand());
+program2.addCommand(boardCommand());
 program2.addCommand(claim_default);
 program2.addCommand(work_default());
 program2.addCommand(worktree_default);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@great-arrow/cli",
-  "version": "0.1.68",
+  "version": "0.7.0",
   "description": "GreatArrow.ai CLI tool",
   "type": "module",
   "bin": {