byob-cli 0.2.9

package/bin/byob.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline";
+import { spawn, spawnSync } from "node:child_process";
+import { copyFileSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+const PROD_AIR_URL = "https://air.api.byob.studio";
+const PROD_PRIM_URL = "https://prim.api.byob.studio";
+const DEFAULT_AIR_URL = process.env.BYOB_AIR_URL || PROD_AIR_URL;
+const DEFAULT_PRIM_URL = process.env.BYOB_PRIM_URL || PROD_PRIM_URL;
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function usage() {
+  return `BYOB CLI
+
+Usage:
+  byob mcp
+  byob mcp --multi-project
+  byob context [json_args]
+  byob resources
+  byob projects
+  byob tools
+  byob call <tool_name> [json_args]
+  byob status [json_args]
+  byob start [json_args]
+  byob deploy [json_args]
+  byob billing [json_args]
+  byob payment-url [json_args]
+  byob env-status [json_args]
+  byob grants [json_args]
+  byob dns [json_args]
+  byob device-code [--client-name name]
+  byob token <device_code>
+  byob refresh <refresh_token>
+  byob config
+  byob codex install
+  byob codex sync-skills
+
+Options:
+  --air-url <url>       Default: BYOB_AIR_URL or https://air.api.byob.studio
+  --prim-url <url>      Default: BYOB_PRIM_URL or https://prim.api.byob.studio
+  --project-id <id>     Default: BYOB_PROJECT_ID
+  --projects <ids>      Comma-separated fallback project ids. Default: BYOB_PROJECT_IDS
+  --multi-project       Route tools/call by arguments.project_id when present
+  --token <token>       Default: BYOB_AGENT_TOKEN
+  --timeout <seconds>   Default: 60
+  --client-name <name>  Used by device-code
+  --codex-bin <path>    Default: codex
+  --server-name <name>  Default: byob
+  --no-skill            Do not install the byob_cli Codex skill
+  --no-air-skills       Do not download BYOB AIR coding skills into Codex skills
+  --no-open             Do not try to open the browser approval URL
+`;
+}
+
+function parseArgs(argv) {
+  const opts = {
+    airUrl: DEFAULT_AIR_URL,
+    primUrl: DEFAULT_PRIM_URL,
+    projectId: process.env.BYOB_PROJECT_ID || "",
+    projectIds: (process.env.BYOB_PROJECT_IDS || "")
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean),
+    multiProject: process.env.BYOB_CLI_MULTI_PROJECT === "1",
+    token: process.env.BYOB_AGENT_TOKEN || "",
+    timeout: 60,
+    clientName: "Local coding agent",
+    codexBin: "codex",
+    serverName: "byob",
+    installSkill: true,
+    installAirSkills: true,
+    openBrowser: true,
+    rest: [],
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--air-url") opts.airUrl = argv[++i] || "";
+    else if (arg === "--prim-url") opts.primUrl = argv[++i] || "";
+    else if (arg === "--project-id") opts.projectId = argv[++i] || "";
+    else if (arg === "--projects") {
+      opts.projectIds = (argv[++i] || "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    } else if (arg === "--multi-project") opts.multiProject = true;
+    else if (arg === "--token") opts.token = argv[++i] || "";
+    else if (arg === "--timeout") opts.timeout = Number(argv[++i] || "60");
+    else if (arg === "--client-name") opts.clientName = argv[++i] || "";
+    else if (arg === "--codex-bin") opts.codexBin = argv[++i] || "codex";
+    else if (arg === "--server-name") opts.serverName = argv[++i] || "byob";
+    else if (arg === "--no-skill") opts.installSkill = false;
+    else if (arg === "--no-air-skills") opts.installAirSkills = false;
+    else if (arg === "--no-open") opts.openBrowser = false;
+    else if (arg === "--help" || arg === "-h") opts.rest.push("help");
+    else opts.rest.push(arg);
+  }
+  return opts;
+}
+
+function requireProject(opts) {
+  const projectId = opts.projectId || opts.projectIds[0] || "";
+  if (!projectId) {
+    throw new Error(
+      "Missing project id. Pass --project-id, set BYOB_PROJECT_ID, or set BYOB_PROJECT_IDS.",
+    );
+  }
+  return projectId;
+}
+
+function requireToken(opts) {
+  if (!opts.token) {
+    throw new Error("Missing agent token. Pass --token or set BYOB_AGENT_TOKEN.");
+  }
+  return opts.token;
+}
+
+function parseJsonArg(raw) {
+  if (!raw) return {};
+  const parsed = JSON.parse(raw);
+  if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+    throw new Error("Tool arguments must be a JSON object.");
+  }
+  return parsed;
+}
+
+async function jsonRequest(method, url, { body, token, timeoutSeconds = 60 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+  const headers = { Accept: "application/json" };
+  if (body !== undefined) headers["Content-Type"] = "application/json";
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const text = await res.text();
+    const payload = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+      const error = new Error(`HTTP ${res.status}`);
+      error.payload = payload;
+      error.status = res.status;
+      error.url = url;
+      throw error;
+    }
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function mcpUrl(opts, projectId = requireProject(opts)) {
+  return `${opts.airUrl.replace(/\/+$/, "")}/mcp/projects/${projectId}`;
+}
+
+function defaultProjectIds(opts) {
+  return [...new Set([opts.projectId, ...opts.projectIds].filter(Boolean))];
+}
+
+function projectFromRequest(opts, request) {
+  if (!opts.multiProject) return requireProject(opts);
+  const params = request?.params || {};
+  const args = params.arguments || {};
+  let explicitProjectId = args.project_id || params.project_id;
+  if (!explicitProjectId && params.uri) {
+    const match = String(params.uri).match(/^byob:\/\/project\/([^/]+)\/context$/);
+    if (match) explicitProjectId = match[1];
+  }
+  if (explicitProjectId) return explicitProjectId;
+  return requireProject(opts);
+}
+
+async function mcpRequest(opts, method, params = {}, requestId = Date.now(), projectId) {
+  return jsonRequest("POST", mcpUrl(opts, projectId), {
+    token: requireToken(opts),
+    timeoutSeconds: opts.timeout,
+    body: {
+      jsonrpc: "2.0",
+      id: requestId,
+      method,
+      params,
+    },
+  });
+}
+
+function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function printMcpResponse(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+
+function byobBanner() {
+  let logo = "";
+  try {
+    logo = readFileSync(join(PACKAGE_ROOT, "byob-logo.ascii"), "utf8").replace(/\s+$/, "");
+  } catch {
+    logo = "BYOB";
+  }
+  return `${logo}\n\nBuild Your Own Buzz\nhttps://byob.studio\n`;
+}
+
+function printWizardStep(message) {
+  process.stdout.write(`\n> ${message}\n`);
+}
+
+function commandExists(command) {
+  const result = spawnSync(
+    process.platform === "win32" ? "where" : "command",
+    process.platform === "win32" ? [command] : ["-v", command],
+    {
+      shell: process.platform !== "win32",
+      stdio: "ignore",
+    },
+  );
+  return result.status === 0;
+}
+
+function tryOpenUrl(url) {
+  if (!url) return false;
+  let command;
+  let args;
+
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+
+  if (process.platform !== "win32" && !commandExists(command)) return false;
+
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore",
+    shell: false,
+  });
+  child.unref();
+  return true;
+}
+
+async function serve(opts) {
+  requireProject(opts);
+  requireToken(opts);
+
+  const rl = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    const raw = line.trim();
+    if (!raw) continue;
+
+    let request;
+    try {
+      request = JSON.parse(raw);
+    } catch (error) {
+      printMcpResponse({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: `Parse error: ${error.message}` },
+      });
+      continue;
+    }
+
+    if (request.id === undefined) {
+      continue;
+    }
+
+    try {
+      const projectId = projectFromRequest(opts, request);
+      const response = await jsonRequest("POST", mcpUrl(opts, projectId), {
+        token: opts.token,
+        timeoutSeconds: opts.timeout,
+        body: request,
+      });
+      printMcpResponse(response);
+    } catch (error) {
+      printMcpResponse({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        error: {
+          code: -32603,
+          message: error.payload
+            ? JSON.stringify(error.payload)
+            : error.message || "BYOB CLI request failed",
+        },
+      });
+    }
+  }
+}
+
+function config(opts) {
+  const command = process.platform === "win32" ? "npx.cmd" : "npx";
+  const projectIds = defaultProjectIds(opts);
+  const snippet = {
+    mcpServers: {
+      byob: {
+        command,
+        args: [
+          "-y",
+          "byob-cli",
+          "mcp",
+          ...(opts.multiProject ? ["--multi-project"] : []),
+        ],
+        env: {
+          ...(opts.airUrl !== PROD_AIR_URL ? { BYOB_AIR_URL: opts.airUrl } : {}),
+          ...(opts.multiProject
+            ? {
+                BYOB_PROJECT_IDS: projectIds.length
+                  ? projectIds.join(",")
+                  : "<project_id_1>,<project_id_2>",
+                BYOB_CLI_MULTI_PROJECT: "1",
+              }
+            : { BYOB_PROJECT_ID: opts.projectId || "<project_id>" }),
+          BYOB_AGENT_TOKEN: opts.token ? "<agent_access_token>" : "<agent_access_token>",
+        },
+      },
+    },
+  };
+  printJson(snippet);
+}
+
+async function deviceCode(opts) {
+  const payload = await jsonRequest(
+    "POST",
+    `${opts.primUrl.replace(/\/+$/, "")}/oauth/device/code`,
+    { body: { client_name: opts.clientName }, timeoutSeconds: opts.timeout },
+  );
+  printJson(payload);
+}
+
+async function token(opts, deviceCodeValue) {
+  if (!deviceCodeValue) throw new Error("Missing device_code.");
+  const payload = await jsonRequest(
+    "POST",
+    `${opts.primUrl.replace(/\/+$/, "")}/oauth/token`,
+    {
+      body: {
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCodeValue,
+      },
+      timeoutSeconds: opts.timeout,
+    },
+  );
+  printJson(payload);
+}
+
+async function refresh(opts, refreshToken) {
+  if (!refreshToken) throw new Error("Missing refresh_token.");
+  const payload = await jsonRequest(
+    "POST",
+    `${opts.primUrl.replace(/\/+$/, "")}/oauth/token`,
+    {
+      body: {
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+      },
+      timeoutSeconds: opts.timeout,
+    },
+  );
+  printJson(payload);
+}
+
+function projectIdsFromTokenPayload(payload) {
+  const fromScope = String(payload.scope || "")
+    .split(/\s+/)
+    .map((scope) => (scope.startsWith("project:") ? scope.slice("project:".length) : ""))
+    .filter(Boolean);
+  const fromPayload = Array.isArray(payload.project_ids) ? payload.project_ids : [];
+  return [...new Set([...fromPayload, ...fromScope].filter(Boolean))];
+}
+
+async function exchangeDeviceCode(opts, deviceCodeValue) {
+  return jsonRequest("POST", `${opts.primUrl.replace(/\/+$/, "")}/oauth/token`, {
+    body: {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCodeValue,
+    },
+    timeoutSeconds: opts.timeout,
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function pollDeviceToken(opts, devicePayload) {
+  const startedAt = Date.now();
+  const expiresIn = Number(devicePayload.expires_in || 600);
+  const intervalMs = Math.max(1, Number(devicePayload.interval || 5)) * 1000;
+
+  while (Date.now() - startedAt < expiresIn * 1000) {
+    try {
+      return await exchangeDeviceCode(opts, devicePayload.device_code);
+    } catch (error) {
+      const code =
+        error.payload?.error ||
+        error.payload?.code ||
+        error.payload?.detail?.error ||
+        error.payload?.detail?.code;
+      if (code === "authorization_pending") {
+        await sleep(intervalMs);
+        continue;
+      }
+      throw error;
+    }
+  }
+
+  throw new Error("Device authorization timed out. Run the install command again.");
+}
+
+function runCodexMcpAdd(opts, tokenPayload, projectIds) {
+  const multiProject = opts.multiProject || projectIds.length > 1;
+  const args = [
+    "mcp",
+    "add",
+    opts.serverName,
+    ...(opts.airUrl !== PROD_AIR_URL ? ["--env", `BYOB_AIR_URL=${opts.airUrl}`] : []),
+    ...(opts.primUrl !== PROD_PRIM_URL ? ["--env", `BYOB_PRIM_URL=${opts.primUrl}`] : []),
+    ...(multiProject
+      ? [
+          "--env",
+          `BYOB_PROJECT_IDS=${projectIds.join(",")}`,
+          "--env",
+          "BYOB_CLI_MULTI_PROJECT=1",
+        ]
+      : ["--env", `BYOB_PROJECT_ID=${projectIds[0]}`]),
+    "--env",
+    `BYOB_AGENT_TOKEN=${tokenPayload.access_token}`,
+    "--",
+    process.platform === "win32" ? "npx.cmd" : "npx",
+    "-y",
+    "byob-cli",
+    "mcp",
+    ...(multiProject ? ["--multi-project"] : []),
+  ];
+
+  const result = spawnSync(opts.codexBin, args, {
+    stdio: "inherit",
+    env: process.env,
+  });
+  if (result.error) {
+    throw new Error(`Failed to run ${opts.codexBin}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`${opts.codexBin} mcp add failed with exit code ${result.status}`);
+  }
+}
+
+function installCodexSkill() {
+  const source = join(PACKAGE_ROOT, "skills", "byob_cli", "SKILL.md");
+  const targetDir = join(homedir(), ".agents", "skills", "byob_cli");
+  mkdirSync(targetDir, { recursive: true });
+  copyFileSync(source, join(targetDir, "SKILL.md"));
+  for (const entry of readdirSync(join(PACKAGE_ROOT, "skills", "byob_cli"))) {
+    if (entry === "SKILL.md") continue;
+    const sourcePath = join(PACKAGE_ROOT, "skills", "byob_cli", entry);
+    if (statSync(sourcePath).isFile()) {
+      copyFileSync(sourcePath, join(targetDir, entry));
+    }
+  }
+  return targetDir;
+}
+
+function codexSkillSlug(name) {
+  return String(name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^@/, "")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80);
+}
+
+function codexSkillNameFromUri(uri) {
+  const raw = String(uri || "").replace("byob://coding-skills/", "");
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function rewriteSkillFrontmatterName(markdown, skillName, folderName) {
+  const safeName = folderName;
+  const body = String(markdown || "");
+  if (!body.startsWith("---")) {
+    return `---\nname: ${safeName}\ndescription: BYOB coding skill synced from AIR for ${skillName}.\n---\n\n${body}`;
+  }
+  return body.replace(/^---\s*\n([\s\S]*?)\n---/, (match, fm) => {
+    const withoutName = fm
+      .split("\n")
+      .filter((line) => !line.trim().startsWith("name:"))
+      .join("\n")
+      .trim();
+    return `---\nname: ${safeName}\n${withoutName ? `${withoutName}\n` : ""}---`;
+  });
+}
+
+async function installAirCodingSkills(opts, projectIds) {
+  const projectId = projectIds[0] || requireProject(opts);
+  const listResponse = await mcpRequest(opts, "resources/list", {}, Date.now(), projectId);
+  const resources = listResponse?.result?.resources || [];
+  const skillResources = resources.filter((resource) =>
+    String(resource?.uri || "").startsWith("byob://coding-skills/"),
+  );
+  const installed = [];
+  for (const resource of skillResources) {
+    const skillName = resource?._meta?.byob_coding_skill?.name || codexSkillNameFromUri(resource.uri);
+    const slug = codexSkillSlug(skillName);
+    if (!slug) continue;
+    const folderName = `byob_${slug}`;
+    const targetDir = join(homedir(), ".agents", "skills", folderName);
+    const readResponse = await mcpRequest(
+      opts,
+      "resources/read",
+      { uri: resource.uri },
+      Date.now(),
+      projectId,
+    );
+    const content = readResponse?.result?.contents?.[0]?.text || "";
+    if (!content.trim()) continue;
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(
+      join(targetDir, "SKILL.md"),
+      rewriteSkillFrontmatterName(content, skillName, folderName),
+      "utf8",
+    );
+    installed.push(folderName);
+  }
+  return installed;
+}
+
+async function codexInstall(opts) {
+  let tokenPayload;
+  let projectIds = defaultProjectIds(opts);
+
+  process.stdout.write(byobBanner());
+  printWizardStep("Preparing Codex connection");
+
+  if (opts.token) {
+    printWizardStep("Using provided agent token");
+    tokenPayload = { access_token: opts.token, scope: projectIds.map((id) => `project:${id}`).join(" ") };
+  } else {
+    printWizardStep("Starting BYOB browser approval");
+    const devicePayload = await jsonRequest(
+      "POST",
+      `${opts.primUrl.replace(/\/+$/, "")}/oauth/device/code`,
+      { body: { client_name: opts.clientName || "Codex" }, timeoutSeconds: opts.timeout },
+    );
+    const approvalUrl = devicePayload.verification_uri_complete || devicePayload.verification_uri;
+    const opened = opts.openBrowser ? tryOpenUrl(approvalUrl) : false;
+    process.stdout.write(
+      [
+        "Open this URL to approve BYOB for Codex:",
+        approvalUrl,
+        opened ? "Opened the approval URL in your browser." : "",
+        "",
+        `User code: ${devicePayload.user_code}`,
+        "Waiting for approval...",
+        "",
+      ].join("\n"),
+    );
+    tokenPayload = await pollDeviceToken(opts, devicePayload);
+    projectIds = projectIdsFromTokenPayload(tokenPayload);
+  }
+
+  if (!tokenPayload.access_token) {
+    throw new Error("OAuth response did not include an access token.");
+  }
+  opts.token = tokenPayload.access_token;
+  if (!projectIds.length) {
+    throw new Error("No approved project ids were found. Approve at least one project or pass --project-id.");
+  }
+
+  printWizardStep("Writing Codex MCP config");
+  runCodexMcpAdd(opts, tokenPayload, projectIds);
+  printWizardStep("Installing BYOB Codex skill");
+  const skillDir = opts.installSkill ? installCodexSkill() : "";
+  let airSkillNames = [];
+  if (opts.installSkill && opts.installAirSkills) {
+    printWizardStep("Downloading BYOB AIR coding skills");
+    airSkillNames = await installAirCodingSkills(opts, projectIds);
+  }
+  process.stdout.write(
+    [
+      "",
+      `BYOB CLI installed for Codex as MCP server "${opts.serverName}" with ${projectIds.length} project(s).`,
+      skillDir ? `BYOB Codex skill installed at ${skillDir}.` : "",
+      airSkillNames.length
+        ? `BYOB AIR coding skills installed: ${airSkillNames.length}.`
+        : opts.installAirSkills
+          ? "No BYOB AIR coding skills were installed."
+          : "",
+      "Restart Codex or start a new session if the skill list is already open.",
+      "",
+    ]
+      .filter(Boolean)
+      .join("\n"),
+  );
+}
+
+async function codexSyncSkills(opts) {
+  const projectIds = defaultProjectIds(opts);
+  requireToken(opts);
+  requireProject(opts);
+
+  printWizardStep("Downloading BYOB AIR coding skills");
+  const airSkillNames = await installAirCodingSkills(opts, projectIds);
+  process.stdout.write(
+    [
+      "",
+      airSkillNames.length
+        ? `BYOB AIR coding skills synced: ${airSkillNames.length}.`
+        : "No BYOB AIR coding skills were synced.",
+      airSkillNames.length ? airSkillNames.join(", ") : "",
+      "Restart Codex or start a new session if the skill list is already open.",
+      "",
+    ]
+      .filter(Boolean)
+      .join("\n"),
+  );
+}
+
+async function callTool(opts, toolName, rawArgs) {
+  if (!toolName) throw new Error("Missing tool_name.");
+  const toolArgs = parseJsonArg(rawArgs);
+  const projectId = toolArgs.project_id || requireProject(opts);
+  const response = await mcpRequest(opts, "tools/call", {
+    name: toolName,
+    arguments: toolArgs,
+  }, Date.now(), projectId);
+  printJson(response);
+}
+
+async function aliasCall(opts, alias, rawArgs) {
+  const toolNames = {
+    status: "byob_project_status",
+    start: "byob_start_project",
+    deploy: "byob_deploy_project",
+    billing: "byob_billing_status",
+    credits: "byob_billing_status",
+    "payment-url": "byob_payment_url",
+    "env-status": "byob_project_env_status",
+    grants: "byob_list_agent_grants",
+    dns: "byob_custom_domain_dns_instructions",
+  };
+  await callTool(opts, toolNames[alias], rawArgs);
+}
+
+async function projects(opts) {
+  await callTool(opts, "byob_list_projects", "{}");
+}
+
+async function resources(opts) {
+  const response = await mcpRequest(opts, "resources/list");
+  printJson(response);
+}
+
+async function context(opts, rawArgs) {
+  const args = parseJsonArg(rawArgs);
+  const projectId = args.project_id || requireProject(opts);
+  const response = await mcpRequest(opts, "tools/call", {
+    name: "byob_current_project_context",
+    arguments: { project_id: projectId },
+  }, Date.now(), projectId);
+  printJson(response);
+}
+
+async function contextResource(opts, rawArgs) {
+  const args = parseJsonArg(rawArgs);
+  const projectId = args.project_id || requireProject(opts);
+  const uri = args.uri || `byob://project/${projectId}/context`;
+  const response = await mcpRequest(
+    opts,
+    "resources/read",
+    { uri },
+    Date.now(),
+    projectId,
+  );
+  printJson(response);
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const [command, first, second] = opts.rest;
+
+  if (!command || command === "help") {
+    process.stdout.write(usage());
+    return;
+  }
+
+  if (command === "mcp") return serve(opts);
+  if (command === "codex" && first === "install") return codexInstall(opts);
+  if (command === "codex" && first === "sync-skills") return codexSyncSkills(opts);
+  if (command === "config") return config(opts);
+  if (command === "device-code") return deviceCode(opts);
+  if (command === "token") return token(opts, first);
+  if (command === "refresh") return refresh(opts, first);
+  if (command === "context") return context(opts, first);
+  if (command === "context-resource") return contextResource(opts, first);
+  if (command === "resources") return resources(opts);
+  if (command === "projects") return projects(opts);
+  if (command === "initialize") return printJson(await mcpRequest(opts, "initialize"));
+  if (command === "tools") return printJson(await mcpRequest(opts, "tools/list"));
+  if (command === "call") return callTool(opts, first, second);
+  if (["status", "start", "deploy", "billing", "credits", "payment-url", "env-status", "grants", "dns"].includes(command)) {
+    return aliasCall(opts, command, first);
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+main().catch((error) => {
+  if (
+    error.status === 404 &&
+    typeof error.url === "string" &&
+    error.url.includes("/oauth/device/code")
+  ) {
+    process.stderr.write(
+      [
+        `BYOB OAuth device endpoint was not found at ${error.url}.`,
+        "If you are testing locally, pass --prim-url http://localhost:8087 --air-url http://localhost:8086.",
+        "If you are using production, deploy PRIM with the Agent OAuth routes first.",
+        "",
+      ].join("\n"),
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (error.payload) {
+    printJson(error.payload);
+  } else {
+    process.stderr.write(`${error.message}\n`);
+  }
+  process.exitCode = 1;
+});