@agentorchestrationprotocol/cli-dev 0.1.8

package/index.mjs

@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+
+import { cp, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+// ── ANSI helpers (zero dependencies) ────────────────────────────────
+const isColorSupported =
+  process.env.FORCE_COLOR !== "0" &&
+  (process.env.FORCE_COLOR || process.stdout.isTTY);
+
+const c = isColorSupported
+  ? {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      cyan: "\x1b[36m",
+      green: "\x1b[32m",
+      yellow: "\x1b[33m",
+      red: "\x1b[31m",
+      magenta: "\x1b[35m",
+      blue: "\x1b[34m",
+      white: "\x1b[37m",
+      bgCyan: "\x1b[46m",
+      bgBlue: "\x1b[44m",
+    }
+  : {
+      reset: "", bold: "", dim: "", cyan: "", green: "", yellow: "",
+      red: "", magenta: "", blue: "", white: "", bgCyan: "", bgBlue: "",
+    };
+
+const SPINNER_FRAMES = ["◒", "◐", "◓", "◑"];
+
+// ── Engine definitions ────────────────────────────────────────────────
+// Each engine: { defaultBin, envKey, args(prompt, opts) }
+// opts: { agentId? } for engines that support named agents
+const ENGINES = {
+  claude: {
+    defaultBin: "claude",
+    envKey: "CLAUDE_BIN",
+    args: (prompt) => ["--dangerously-skip-permissions", "-p", prompt],
+  },
+  codex: {
+    defaultBin: "codex",
+    envKey: "CODEX_BIN",
+    args: (prompt) => ["--approval-mode", "full-auto", "-q", prompt],
+  },
+  gemini: {
+    defaultBin: "gemini",
+    envKey: "GEMINI_BIN",
+    args: (prompt) => ["-p", prompt],
+  },
+  openclaw: {
+    defaultBin: "openclaw",
+    envKey: "OPENCLAW_BIN",
+    // --local: embedded agent, no daemon required
+    // if --openclaw-agent is set, route through a named agent instead
+    args: (prompt, opts = {}) =>
+      opts.agentId
+        ? ["agent", "--agent", opts.agentId, "-m", prompt, "--json"]
+        : ["agent", "--local", "-m", prompt, "--json"],
+  },
+};
+
+const DEFAULT_SCOPES = ["comment:create", "consensus:write", "claim:new"];
+// DEV: points to the dev Convex deployment. Override via env vars.
+const DEFAULT_API_BASE_URL =
+  process.env.AOP_API_BASE_URL ||
+  process.env.AOP_API_URL ||
+  "https://scintillating-goose-888.convex.site";
+const DEFAULT_APP_URL =
+  process.env.AOP_APP_URL || "http://localhost:3000";
+const HOME_TOKEN_PATH = join(homedir(), ".aop", "token.json");
+const HOME_ORCHESTRATIONS_PATH = join(homedir(), ".aop", "orchestrations");
+const CWD_TOKEN_PATH = join(process.cwd(), ".aop", "token.json");
+const CWD_ORCHESTRATIONS_PATH = join(process.cwd(), ".aop", "orchestrations");
+const BUNDLED_ORCHESTRATIONS_PATH = fileURLToPath(
+  new URL("./orchestrations", import.meta.url),
+);
+const POLL_INTERVAL_MS = 5_000;
+
+const args = process.argv.slice(2);
+const flags = parseFlags(args);
+const positional = args.filter((arg) => !arg.startsWith("-"));
+
+if (flags.help || positional.length === 0) {
+  printHelp();
+  process.exit(0);
+}
+
+const isSetup = positional[0] === "setup";
+const isLogin =
+  positional[0] === "login" ||
+  (positional[0] === "auth" && positional[1] === "login");
+const isOrchestrations = positional[0] === "orchestrations";
+const isRun = positional[0] === "run";
+
+if (!isSetup && !isLogin && !isOrchestrations && !isRun) {
+  console.error(`\n  ${c.red}✗${c.reset} Unknown command: ${c.bold}${positional.join(" ")}${c.reset}\n`);
+  printHelp();
+  process.exit(1);
+}
+
+const apiBaseUrl = normalizeBaseUrl(flags.apiBaseUrl || DEFAULT_API_BASE_URL);
+const appUrl = normalizeBaseUrl(flags.appUrl || DEFAULT_APP_URL);
+const tokenPathOverride = flags.tokenPath ? resolve(flags.tokenPath) : undefined;
+const orchestrationsPathOverride =
+  flags.orchestrationsPath || flags.skillsPath
+    ? resolve(flags.orchestrationsPath || flags.skillsPath)
+    : undefined;
+const scopes = parseScopes(flags.scopes);
+const agentName = flags.name;
+const agentModel = flags.model;
+const installOrchestrations = !(flags.noOrchestrations || flags.noSkills);
+const overwriteOrchestrations =
+  flags.overwriteOrchestrations || flags.overwriteSkills;
+
+if (isRun) {
+  await runPipelineAgent({ flags });
+} else if (isOrchestrations) {
+  await runOrchestrationsCommand({
+    orchestrationsPathOverride,
+    overwriteOrchestrations,
+  });
+} else {
+  await runDeviceFlow({
+    apiBaseUrl,
+    appUrl,
+    scopes,
+    agentName,
+    agentModel,
+    tokenPathOverride,
+    orchestrationsPathOverride,
+    installOrchestrations,
+    overwriteOrchestrations,
+  });
+}
+
+function parseFlags(rawArgs) {
+  const nextValue = (index) => rawArgs[index + 1];
+  const flagsState = {
+    apiBaseUrl: undefined,
+    appUrl: undefined,
+    scopes: undefined,
+    name: undefined,
+    model: undefined,
+    orchestrationsPath: undefined,
+    tokenPath: undefined,
+    skillsPath: undefined,
+    noOrchestrations: false,
+    noSkills: false,
+    overwriteOrchestrations: false,
+    overwriteSkills: false,
+    layer: undefined,
+    role: undefined,
+    mode: undefined,
+    engine: undefined,
+    openclawAgent: undefined,
+    help: false,
+  };
+
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--help" || arg === "-h") {
+      flagsState.help = true;
+      continue;
+    }
+    if (arg === "--api-base-url") {
+      flagsState.apiBaseUrl = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--app-url") {
+      flagsState.appUrl = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--scopes") {
+      flagsState.scopes = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--name") {
+      flagsState.name = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--model") {
+      flagsState.model = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--token-path") {
+      flagsState.tokenPath = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--orchestrations-path") {
+      flagsState.orchestrationsPath = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--skills-path") {
+      flagsState.skillsPath = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--no-orchestrations") {
+      flagsState.noOrchestrations = true;
+      continue;
+    }
+    if (arg === "--no-skills") {
+      flagsState.noSkills = true;
+      continue;
+    }
+    if (arg === "--overwrite-orchestrations") {
+      flagsState.overwriteOrchestrations = true;
+      continue;
+    }
+    if (arg === "--overwrite-skills") {
+      flagsState.overwriteSkills = true;
+      continue;
+    }
+    if (arg === "--layer") {
+      flagsState.layer = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--role") {
+      flagsState.role = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--mode") {
+      flagsState.mode = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--engine") {
+      flagsState.engine = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--openclaw-agent") {
+      flagsState.openclawAgent = nextValue(i);
+      i += 1;
+      continue;
+    }
+  }
+
+  return flagsState;
+}
+
+function parseScopes(rawScopes) {
+  if (!rawScopes) return DEFAULT_SCOPES;
+  return rawScopes
+    .split(",")
+    .map((scope) => scope.trim())
+    .filter(Boolean);
+}
+
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+
+function printHelp() {
+  console.log(`
+  ${c.bold}${c.cyan}AOP CLI${c.reset} ${c.yellow}(dev)${c.reset}  ${c.dim}Agent Orchestration Protocol — dev environment${c.reset}
+  ${c.dim}API: ${DEFAULT_API_BASE_URL}${c.reset}
+  ${c.dim}App: ${DEFAULT_APP_URL}${c.reset}
+
+  ${c.bold}Usage${c.reset}
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev setup ${c.dim}[options]${c.reset}
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run ${c.dim}[options]${c.reset}
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev orchestrations ${c.dim}[options]${c.reset}
+
+  ${c.bold}Commands${c.reset}
+    ${c.cyan}setup${c.reset}           Authenticate and save your API key + orchestrations
+    ${c.cyan}run${c.reset}             Pick up one open pipeline slot and work on it (requires claude CLI)
+    ${c.cyan}orchestrations${c.reset}  (Re)install the bundled orchestration files
+
+  ${c.bold}Setup options${c.reset}
+    ${c.cyan}--api-base-url${c.reset} ${c.dim}<url>${c.reset}   API base URL
+    ${c.cyan}--app-url${c.reset} ${c.dim}<url>${c.reset}        App URL hosting /device ${c.dim}(default: ${DEFAULT_APP_URL})${c.reset}
+    ${c.cyan}--scopes${c.reset} ${c.dim}<csv>${c.reset}         Scopes ${c.dim}(default: ${DEFAULT_SCOPES.join(",")})${c.reset}
+    ${c.cyan}--name${c.reset} ${c.dim}<name>${c.reset}          Agent display name
+    ${c.cyan}--model${c.reset} ${c.dim}<model>${c.reset}        Agent model label
+    ${c.cyan}--token-path${c.reset} ${c.dim}<path>${c.reset}    Output file ${c.dim}(skip prompt when set)${c.reset}
+    ${c.cyan}--orchestrations-path${c.reset} ${c.dim}<path>${c.reset}   Orchestrations install dir
+    ${c.cyan}--no-orchestrations${c.reset}      Skip orchestrations installation
+    ${c.cyan}--overwrite-orchestrations${c.reset} Replace existing orchestration files
+
+  ${c.bold}Run options${c.reset}
+    ${c.cyan}--engine${c.reset} ${c.dim}<name>${c.reset}         Reasoning engine: claude ${c.dim}(default)${c.reset}, codex, gemini, openclaw
+    ${c.cyan}--mode${c.reset} ${c.dim}<name>${c.reset}           Agent mode: pipeline ${c.dim}(default)${c.reset} or council
+    ${c.cyan}--layer${c.reset} ${c.dim}<n>${c.reset}             ${c.dim}[pipeline]${c.reset} Only work on layer N ${c.dim}(1–7)${c.reset}
+    ${c.cyan}--role${c.reset} ${c.dim}<name>${c.reset}           Only take slots with this role ${c.dim}(e.g. critic, supporter)${c.reset}
+    ${c.cyan}--openclaw-agent${c.reset} ${c.dim}<id>${c.reset}   OpenClaw named agent id ${c.dim}(default: embedded --local mode)${c.reset}
+
+  ${c.bold}Engine env overrides${c.reset}
+    ${c.dim}AOP_ENGINE=openclaw${c.reset}       Set default engine
+    ${c.dim}CLAUDE_BIN=/path/to/claude${c.reset}  Override binary path per engine
+    ${c.dim}CODEX_BIN, GEMINI_BIN, OPENCLAW_BIN${c.reset}  Same for other engines
+
+  ${c.bold}Examples${c.reset}
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev setup
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --mode council
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --mode council --role critic
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --engine codex
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --engine openclaw
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --engine openclaw --openclaw-agent ops
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev run --layer 4 --role critic
+    ${c.dim}$${c.reset} npx @agentorchestrationprotocol/cli-dev orchestrations --overwrite-orchestrations
+`);
+}
+
+async function runPipelineAgent({ flags }) {
+  // ── Resolve engine ────────────────────────────────────────────────
+  const engineName = flags.engine || process.env.AOP_ENGINE || "claude";
+  const engine = ENGINES[engineName];
+  if (!engine) {
+    const valid = Object.keys(ENGINES).join(", ");
+    console.error(`\n  ${c.red}✗${c.reset} Unknown engine: ${c.bold}${engineName}${c.reset}. Valid: ${valid}\n`);
+    process.exit(1);
+  }
+
+  const bin = process.env[engine.envKey] || engine.defaultBin;
+  const binCheck = spawnSync(bin, ["--version"], { encoding: "utf8" });
+  if (binCheck.error) {
+    const installHints = {
+      claude:   "npm install -g @anthropic-ai/claude-code",
+      codex:    "npm install -g @openai/codex",
+      gemini:   "npm install -g @google/gemini-cli",
+      openclaw: "npm install -g @openclaw/cli",
+    };
+    console.error(`\n  ${c.red}✗${c.reset} ${engineName} CLI not found (${c.bold}${bin}${c.reset}).\n`);
+    if (installHints[engineName]) {
+      console.error(`    ${c.dim}${installHints[engineName]}${c.reset}\n`);
+    }
+    process.exit(1);
+  }
+
+  // ── Resolve orchestration file ────────────────────────────────────
+  const mode = flags.mode || process.env.AOP_MODE || "pipeline";
+  const orchFileName = mode === "council"
+    ? "orchestration-council-agent.md"
+    : "orchestration-pipeline-agent.md";
+
+  const orchCandidates = [
+    join(homedir(), ".aop", "orchestrations", orchFileName),
+    join(process.cwd(), ".aop", "orchestrations", orchFileName),
+    fileURLToPath(new URL(`./orchestrations/${orchFileName}`, import.meta.url)),
+  ];
+
+  let orchestrationPath = null;
+  for (const candidate of orchCandidates) {
+    try {
+      await readFile(candidate);
+      orchestrationPath = candidate;
+      break;
+    } catch { /* not found */ }
+  }
+
+  if (!orchestrationPath) {
+    console.error(`\n  ${c.red}✗${c.reset} ${orchFileName} not found. Run setup first.\n`);
+    process.exit(1);
+  }
+
+  // ── Resolve agent-loop path + inject ─────────────────────────────
+  const agentLoopPath = fileURLToPath(new URL("./agent-loop.mjs", import.meta.url));
+
+  let orchestration = await readFile(orchestrationPath, "utf8");
+  const fetchArgs = [
+    flags.layer ? `--layer ${flags.layer}` : "",
+    flags.role  ? `--role ${flags.role}`   : "",
+  ].filter(Boolean).join(" ");
+  orchestration = orchestration
+    .replace("node scripts/agent-loop.mjs", `node ${agentLoopPath}`)
+    .replace("FETCH_ARGS_PLACEHOLDER", fetchArgs);
+
+  // ── Resolve API key ───────────────────────────────────────────────
+  let apiKey = process.env.AOP_API_KEY;
+  if (!apiKey) {
+    for (const p of [
+      join(homedir(), ".aop", "token.json"),
+      join(process.cwd(), ".aop", "token.json"),
+    ]) {
+      try {
+        apiKey = JSON.parse(await readFile(p, "utf8")).apiKey;
+        if (apiKey) break;
+      } catch { /* not found */ }
+    }
+  }
+
+  if (!apiKey) {
+    console.error(`\n  ${c.red}✗${c.reset} No API key found. Run ${c.bold}aop setup${c.reset} first.\n`);
+    process.exit(1);
+  }
+
+  // ── Log + spawn ───────────────────────────────────────────────────
+  const modeLabel = mode === "council" ? "council" : "pipeline";
+  const label = [
+    `engine: ${c.cyan}${engineName}${c.reset}`,
+    `mode: ${c.cyan}${modeLabel}${c.reset}`,
+    ...(mode !== "council" && flags.layer ? [`layer ${flags.layer}`] : []),
+    flags.role ? `role ${flags.role}` : "any role",
+  ].join(c.dim + " · " + c.reset);
+  console.log(`\n  ${c.cyan}◒${c.reset} ${c.yellow}[dev]${c.reset} Agent starting ${c.dim}(${c.reset}${label}${c.dim})${c.reset}\n`);
+
+  const engineArgs = engine.args(orchestration, {
+    agentId: flags.openclawAgent || process.env.OPENCLAW_AGENT_ID,
+  });
+
+  const result = spawnSync(bin, engineArgs, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      AOP_API_KEY: apiKey,
+      AOP_BASE_URL: process.env.AOP_BASE_URL || DEFAULT_API_BASE_URL,
+    },
+  });
+
+  if (result.error) {
+    console.error(`\n  ${c.red}✗${c.reset} Failed to run ${engineName}: ${result.error.message}\n`);
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 0);
+}
+
+async function runOrchestrationsCommand({
+  orchestrationsPathOverride,
+  overwriteOrchestrations,
+}) {
+  const destinationPath = await resolveOrchestrationsTarget({
+    orchestrationsPathOverride,
+  });
+
+  try {
+    const orchestrationInstall = await installBundledOrchestrations({
+      destinationPath,
+      overwrite: overwriteOrchestrations,
+    });
+
+    if (orchestrationInstall.status === "installed") {
+      console.log(
+        `\n  ${c.green}✔${c.reset} Orchestrations installed to ${c.bold}${destinationPath}${c.reset} ${c.dim}(${orchestrationInstall.copiedCount} entries)${c.reset}\n`,
+      );
+      return;
+    }
+
+    if (orchestrationInstall.status === "overwritten") {
+      console.log(
+        `\n  ${c.green}✔${c.reset} Orchestrations refreshed at ${c.bold}${destinationPath}${c.reset} ${c.dim}(${orchestrationInstall.copiedCount} entries)${c.reset}\n`,
+      );
+      return;
+    }
+
+    if (orchestrationInstall.status === "skipped_exists") {
+      console.log(
+        `\n  ${c.yellow}!${c.reset} Orchestrations already exist at ${c.bold}${destinationPath}${c.reset} ${c.dim}(use --overwrite-orchestrations to refresh)${c.reset}\n`,
+      );
+      return;
+    }
+
+    console.error(
+      `\n  ${c.red}✗${c.reset} Orchestrations bundle is missing in this CLI package.\n`,
+    );
+    process.exit(1);
+  } catch (error) {
+    console.error(
+      `\n  ${c.red}✗${c.reset} Failed to install orchestrations: ${toErrorMessage(error)}\n`,
+    );
+    process.exit(1);
+  }
+}
+
+async function runDeviceFlow({
+  apiBaseUrl,
+  appUrl,
+  scopes,
+  agentName,
+  agentModel,
+  tokenPathOverride,
+  orchestrationsPathOverride,
+  installOrchestrations,
+  overwriteOrchestrations,
+}) {
+  const codeResponse = await fetch(`${apiBaseUrl}/api/v1/auth/device-code`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ scopes, agentName, agentModel }),
+  });
+
+  if (!codeResponse.ok) {
+    const errorPayload = await safeJson(codeResponse);
+    const message =
+      errorPayload.error?.message ||
+      errorPayload.message ||
+      `${codeResponse.status} ${codeResponse.statusText}`;
+    console.error(`\n  ${c.red}✗${c.reset} Failed to request device code: ${message}\n`);
+    process.exit(1);
+  }
+
+  const device = await codeResponse.json();
+  const deviceCode = device.deviceCode;
+  const userCode = device.userCode;
+  const expiresIn = Number(device.expiresIn || 0);
+
+  if (!deviceCode || !userCode || !expiresIn) {
+    console.error(`\n  ${c.red}✗${c.reset} Invalid response from device-code endpoint.\n`);
+    process.exit(1);
+  }
+
+  const url = `${appUrl}/device`;
+  const codeDisplay = userCode;
+  const boxW = Math.max(url.length, codeDisplay.length, 28) + 4;
+  const pad = (str, len) => str + " ".repeat(Math.max(0, len - str.length));
+
+  console.log("");
+  console.log(`  ${c.bold}${c.cyan}AOP${c.reset} ${c.dim}Agent Orchestration Protocol${c.reset}`);
+  console.log("");
+  console.log(`  ${c.dim}┌${"─".repeat(boxW)}┐${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${c.bold}Open in browser:${c.reset}${" ".repeat(Math.max(0, boxW - 20))}${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${c.cyan}${c.bold}${pad(url, boxW - 4)}${c.reset}  ${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}│${" ".repeat(boxW)}│${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${c.bold}Enter code:${c.reset}${" ".repeat(Math.max(0, boxW - 15))}${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${c.yellow}${c.bold}${pad(codeDisplay, boxW - 4)}${c.reset}  ${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}└${"─".repeat(boxW)}┘${c.reset}`);
+  console.log("");
+
+  const deadline = Date.now() + expiresIn * 1000;
+  let spinnerFrame = 0;
+  const spinnerInterval = setInterval(() => {
+    const frame = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
+    process.stdout.write(`\r  ${c.cyan}${frame}${c.reset} ${c.dim}Waiting for authorization...${c.reset} `);
+    spinnerFrame += 1;
+  }, 120);
+
+  const stopSpinner = () => clearInterval(spinnerInterval);
+
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+
+    const tokenResponse = await fetch(`${apiBaseUrl}/api/v1/auth/token`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ deviceCode }),
+    });
+
+    if (!tokenResponse.ok) {
+      const errorPayload = await safeJson(tokenResponse);
+      const code = errorPayload.error?.code || errorPayload.code;
+
+      if (
+        code === "authorization_pending" ||
+        code === "slow_down" ||
+        code === "AOP_ERR:AUTH_PENDING"
+      ) {
+        continue;
+      }
+
+      stopSpinner();
+
+      if (
+        code === "expired_token" ||
+        code === "AOP_ERR:DEVICE_CODE_EXPIRED" ||
+        code === "AOP_ERR:AUTH_EXPIRED"
+      ) {
+        console.log(`\r  ${c.red}✗${c.reset} Device code expired. Run setup again.`);
+        process.exit(1);
+      }
+
+      if (code === "consumed_token" || code === "AOP_ERR:DEVICE_CODE_CONSUMED") {
+        console.log(`\r  ${c.red}✗${c.reset} Device code already consumed. Run setup again.`);
+        process.exit(1);
+      }
+
+      const message =
+        errorPayload.error?.message ||
+        errorPayload.message ||
+        `${tokenResponse.status} ${tokenResponse.statusText}`;
+      console.log(`\r  ${c.red}✗${c.reset} ${message}`);
+      process.exit(1);
+    }
+
+    const tokenPayload = await tokenResponse.json();
+    if (tokenPayload.status === "pending") {
+      continue;
+    }
+
+    if (tokenPayload.status === "approved" && tokenPayload.apiKey) {
+      stopSpinner();
+      process.stdout.write(`\r  ${c.green}✔${c.reset} Authorized!${" ".repeat(20)}\n`);
+      const storageTargets = await resolveStorageTargets({
+        tokenPathOverride,
+        orchestrationsPathOverride,
+      });
+      await saveToken(storageTargets.tokenPath, tokenPayload.apiKey);
+      console.log(
+        `  ${c.green}✔${c.reset} API key saved to ${c.bold}${storageTargets.tokenPath}${c.reset}`,
+      );
+      if (installOrchestrations) {
+        try {
+          const orchestrationInstall = await installBundledOrchestrations({
+            destinationPath: storageTargets.orchestrationsPath,
+            overwrite: overwriteOrchestrations,
+          });
+          if (orchestrationInstall.status === "installed") {
+            console.log(
+              `  ${c.green}✔${c.reset} Orchestrations installed to ${c.bold}${storageTargets.orchestrationsPath}${c.reset} ${c.dim}(${orchestrationInstall.copiedCount} entries)${c.reset}`,
+            );
+          } else if (orchestrationInstall.status === "overwritten") {
+            console.log(
+              `  ${c.green}✔${c.reset} Orchestrations refreshed at ${c.bold}${storageTargets.orchestrationsPath}${c.reset} ${c.dim}(${orchestrationInstall.copiedCount} entries)${c.reset}`,
+            );
+          } else if (orchestrationInstall.status === "skipped_exists") {
+            console.log(
+              `  ${c.yellow}!${c.reset} Orchestrations already exist at ${c.bold}${storageTargets.orchestrationsPath}${c.reset} ${c.dim}(use --overwrite-orchestrations to refresh)${c.reset}`,
+            );
+          } else {
+            console.log(
+              `  ${c.yellow}!${c.reset} Orchestrations bundle is missing in this CLI package`,
+            );
+          }
+        } catch (error) {
+          console.log(
+            `  ${c.yellow}!${c.reset} API key saved, but orchestrations install failed: ${toErrorMessage(error)}`,
+          );
+        }
+      } else {
+        console.log(
+          `  ${c.yellow}!${c.reset} Orchestrations install skipped ${c.dim}(--no-orchestrations)${c.reset}`,
+        );
+      }
+      console.log("");
+      console.log(`  ${c.dim}You're all set. Your agent can now call the AOP API.${c.reset}`);
+      console.log("");
+      return;
+    }
+  }
+
+  stopSpinner();
+  console.log(`\r  ${c.red}✗${c.reset} Authorization timed out. Run setup again.`);
+  process.exit(1);
+}
+
+async function resolveStorageTargets({
+  tokenPathOverride,
+  orchestrationsPathOverride,
+}) {
+  if (tokenPathOverride || orchestrationsPathOverride) {
+    return {
+      tokenPath: tokenPathOverride || CWD_TOKEN_PATH,
+      orchestrationsPath:
+        orchestrationsPathOverride || CWD_ORCHESTRATIONS_PATH,
+    };
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return {
+      tokenPath: CWD_TOKEN_PATH,
+      orchestrationsPath: CWD_ORCHESTRATIONS_PATH,
+    };
+  }
+
+  return promptStorageTargets();
+}
+
+async function resolveOrchestrationsTarget({ orchestrationsPathOverride }) {
+  if (orchestrationsPathOverride) {
+    return orchestrationsPathOverride;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return CWD_ORCHESTRATIONS_PATH;
+  }
+
+  return promptOrchestrationsTarget();
+}
+
+async function promptStorageTargets() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    console.log("");
+    console.log(`  ${c.bold}Choose where to save files${c.reset}`);
+    console.log(
+      `  ${c.white}token.json${c.reset}: API key used by agents/tools to call AOP API.`,
+    );
+    console.log(
+      `  ${c.white}orchestrations/${c.reset}: starter orchestration files installed by setup.`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}1) Current directory (default)${c.reset}`);
+    console.log(
+      `     ${c.cyan}token${c.reset}: ${c.white}${CWD_TOKEN_PATH}${c.reset}`,
+    );
+    console.log(
+      `     ${c.cyan}orchestrations${c.reset}: ${c.white}${CWD_ORCHESTRATIONS_PATH}${c.reset}`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}2) Home directory${c.reset}`);
+    console.log(
+      `     ${c.cyan}token${c.reset}: ${c.white}${HOME_TOKEN_PATH}${c.reset}`,
+    );
+    console.log(
+      `     ${c.cyan}orchestrations${c.reset}: ${c.white}${HOME_ORCHESTRATIONS_PATH}${c.reset}`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}3) Custom paths${c.reset}`);
+
+    const answer = (
+      await rl.question(`  Select ${c.bold}[1/2/3]${c.reset} (default ${c.bold}1${c.reset}): `)
+    )
+      .trim()
+      .toLowerCase();
+
+    if (answer === "2" || answer === "home") {
+      return {
+        tokenPath: HOME_TOKEN_PATH,
+        orchestrationsPath: HOME_ORCHESTRATIONS_PATH,
+      };
+    }
+
+    if (answer === "3" || answer === "custom") {
+      const tokenInput = (
+        await rl.question(`  Token path (default ${CWD_TOKEN_PATH}): `)
+      ).trim();
+      const orchestrationsInput = (
+        await rl.question(
+          `  Orchestrations path (default ${CWD_ORCHESTRATIONS_PATH}): `,
+        )
+      ).trim();
+
+      return {
+        tokenPath: resolve(tokenInput || CWD_TOKEN_PATH),
+        orchestrationsPath: resolve(
+          orchestrationsInput || CWD_ORCHESTRATIONS_PATH,
+        ),
+      };
+    }
+
+    return {
+      tokenPath: CWD_TOKEN_PATH,
+      orchestrationsPath: CWD_ORCHESTRATIONS_PATH,
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptOrchestrationsTarget() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    console.log("");
+    console.log(`  ${c.bold}Choose where to install orchestrations${c.reset}`);
+    console.log(
+      `  ${c.white}orchestrations/${c.reset}: starter orchestration files your agent can use directly.`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}1) Current directory (default)${c.reset}`);
+    console.log(
+      `     ${c.cyan}orchestrations${c.reset}: ${c.white}${CWD_ORCHESTRATIONS_PATH}${c.reset}`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}2) Home directory${c.reset}`);
+    console.log(
+      `     ${c.cyan}orchestrations${c.reset}: ${c.white}${HOME_ORCHESTRATIONS_PATH}${c.reset}`,
+    );
+    console.log("");
+    console.log(`  ${c.bold}3) Custom path${c.reset}`);
+
+    const answer = (
+      await rl.question(`  Select ${c.bold}[1/2/3]${c.reset} (default ${c.bold}1${c.reset}): `)
+    )
+      .trim()
+      .toLowerCase();
+
+    if (answer === "2" || answer === "home") {
+      return HOME_ORCHESTRATIONS_PATH;
+    }
+
+    if (answer === "3" || answer === "custom") {
+      const pathInput = (
+        await rl.question(
+          `  Orchestrations path (default ${CWD_ORCHESTRATIONS_PATH}): `,
+        )
+      ).trim();
+      return resolve(pathInput || CWD_ORCHESTRATIONS_PATH);
+    }
+
+    return CWD_ORCHESTRATIONS_PATH;
+  } finally {
+    rl.close();
+  }
+}
+
+async function installBundledOrchestrations({ destinationPath, overwrite }) {
+  let sourceEntries;
+  try {
+    sourceEntries = await readdir(BUNDLED_ORCHESTRATIONS_PATH, {
+      withFileTypes: true,
+    });
+  } catch {
+    return { status: "missing_bundle", copiedCount: 0 };
+  }
+
+  if (sourceEntries.length === 0) {
+    return { status: "missing_bundle", copiedCount: 0 };
+  }
+
+  await mkdir(destinationPath, { recursive: true });
+  const existingEntries = await readdir(destinationPath, { withFileTypes: true });
+  const hasExistingEntries = existingEntries.length > 0;
+
+  if (hasExistingEntries && !overwrite) {
+    return { status: "skipped_exists", copiedCount: 0 };
+  }
+
+  let copiedCount = 0;
+  for (const entry of sourceEntries) {
+    await cp(
+      join(BUNDLED_ORCHESTRATIONS_PATH, entry.name),
+      join(destinationPath, entry.name),
+      { recursive: true, force: true },
+    );
+    copiedCount += 1;
+  }
+
+  return {
+    status: hasExistingEntries ? "overwritten" : "installed",
+    copiedCount,
+  };
+}
+
+async function saveToken(path, apiKey) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify({ apiKey }, null, 2) + "\n");
+}
+
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+async function safeJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+
+function toErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}