@paradigma-inc/flywheel 0.1.0 → 0.1.4

package/src/cli.mjs

@@ -1,422 +1,574 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { randomBytes } from "node:crypto";
-import os from "node:os";
+import { Command } from "commander";
+import { checkbox, select } from "@inquirer/prompts";
+import ora from "ora";
+import pc from "picocolors";
 import path from "node:path";
-import readline from "node:readline/promises";
+import { randomBytes } from "node:crypto";
 
 import {
-  AGENT_CONFIG,
-  HOST_LABELS,
-  HOSTS,
+  ALL_HOST_NAMES,
   SERVER_NAME,
+  SETUP_HOST_NAMES,
+  detectHosts,
+  getHost,
   normalizeHosts,
-  normalizeScope,
-  resolveHostConfigPath,
 } from "./agents.mjs";
 import {
+  appendTomlServer,
+  mergeServerEntry,
   readJsonConfig,
+  readTomlServerExists,
+  readYamlConfig,
   removeCodexTomlServer,
   removeJsonServerEntry,
-  upsertCodexTomlServer,
-  upsertJsonServerEntry,
+  resolveMcpPath,
   writeJsonConfig,
+  writeYamlConfig,
 } from "./mcp-writer.mjs";
 import { acquireApiKeyViaBrowserBridge } from "./setup-auth.mjs";
 
-// This setup flow intentionally follows Context7's structure:
-// - packages/cli/src/commands/setup.ts
-// - packages/cli/src/setup/agents.ts
-// - packages/cli/src/setup/mcp-writer.ts
 const DEFAULT_BASE_URL =
   process.env.FLYWHEEL_PUBLIC_BASE_URL || "https://flywheel.paradigma.inc";
-const DEFAULT_SCOPE = "global";
-const SHARED_KEY_PATH = path.join(
-  os.homedir(),
-  ".config",
-  "flywheel",
-  "mcp-api-key",
-);
-
-function printHelp() {
-  console.log(`flywheel
-
-Commands:
-  setup       Configure Flywheel MCP for codex/claude/opencode
-  uninstall   Remove Flywheel MCP entries from host configs
-
-Options:
-  --hosts <list>       Comma-separated: codex,claude,opencode
-  --scope <scope>      global | project | all (uninstall only)
-  --base-url <url>     Flywheel base URL (default: ${DEFAULT_BASE_URL})
-  --server-url <url>   MCP server URL (default: <base-url>/mcp-server)
-  --api-key <key>      Use API key directly (skip browser auth)
-  --name <name>        API key name to create during browser setup
-  --yes                Non-interactive defaults
-  --delete-key         Uninstall: also remove ~/.config/flywheel/mcp-api-key
-  -h, --help           Show this help
-`);
+
+const log = {
+  info: (message) => console.log(pc.cyan(message)),
+  warn: (message) => console.log(pc.yellow(`⚠ ${message}`)),
+  error: (message) => console.log(pc.red(`✖ ${message}`)),
+  plain: (message) => console.log(message),
+  blank: () => console.log(""),
+};
+
+const CHECKBOX_THEME = {
+  style: {
+    highlight: (text) => pc.green(text),
+    disabledChoice: (text) => ` ${pc.dim("◯")} ${pc.dim(text)}`,
+  },
+};
+
+function normalizeBaseUrl(value) {
+  const normalized = String(value || "").trim();
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(normalized);
+  } catch {
+    throw new Error("Base URL must be a valid absolute URL.");
+  }
+
+  if (parsedUrl.pathname !== "/" || parsedUrl.search || parsedUrl.hash) {
+    throw new Error(
+      "Base URL must be a public Flywheel origin without a path, query, or hash.",
+    );
+  }
+
+  return parsedUrl.origin;
 }
 
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const command = args[0];
-  const options = {
-    hosts: null,
-    scope: null,
-    baseUrl: null,
-    serverUrl: null,
-    apiKey: null,
-    name: null,
-    yes: false,
-    deleteKey: false,
-    help: false,
-  };
+function normalizeServerName(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    throw new Error("Server name cannot be empty.");
+  }
+  return normalized;
+}
+
+function selectedHostsFromOptions(options) {
+  const hosts = [];
+  if (options.claude) hosts.push("claude");
+  if (options.opencode) hosts.push("opencode");
+  if (options.codex) hosts.push("codex");
+  if (options.cursor) hosts.push("cursor");
+  if (options.piMono) hosts.push("pi-mono");
+  if (options.hermesAgent) hosts.push("hermes-agent");
+  if (options.openclaw) hosts.push("openclaw");
+  return hosts;
+}
+
+function parseHostsList(value) {
+  if (!value) return [];
+  return normalizeHosts(
+    String(value)
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean),
+  );
+}
+
+function mcpCandidatesForScope(host, scope) {
+  if (scope === "global") return host.mcp.globalPaths;
+  return host.mcp.projectPaths.map((candidate) =>
+    path.join(process.cwd(), candidate),
+  );
+}
 
-  for (let i = 1; i < args.length; i += 1) {
-    const arg = args[i];
-    const next = args[i + 1];
-    switch (arg) {
-      case "--hosts":
-        options.hosts = next || "";
-        i += 1;
-        break;
-      case "--scope":
-        options.scope = next || "";
-        i += 1;
-        break;
-      case "--base-url":
-        options.baseUrl = next || "";
-        i += 1;
-        break;
-      case "--server-url":
-        options.serverUrl = next || "";
-        i += 1;
-        break;
-      case "--api-key":
-        options.apiKey = next || "";
-        i += 1;
-        break;
-      case "--name":
-        options.name = next || "";
-        i += 1;
-        break;
-      case "--yes":
-      case "-y":
-        options.yes = true;
-        break;
-      case "--delete-key":
-        options.deleteKey = true;
-        break;
-      case "--help":
-      case "-h":
-        options.help = true;
-        break;
-      default:
-        throw new Error(`Unknown option: ${arg}`);
+function readConfigSection(config, configKey) {
+  const pathParts = Array.isArray(configKey) ? configKey : [configKey];
+  let current = config && typeof config === "object" ? config : {};
+  for (const part of pathParts) {
+    if (
+      !current ||
+      typeof current !== "object" ||
+      Array.isArray(current) ||
+      !(part in current)
+    ) {
+      return {};
     }
+    const next = current[part];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      return {};
+    }
+    current = next;
   }
+  return current;
+}
 
-  return { command, options };
+async function isAlreadyConfigured(hostName, scope, serverName) {
+  const host = getHost(hostName);
+  const mcpPath = await resolveMcpPath(mcpCandidatesForScope(host, scope));
+  if (host.mcp.configType === "toml") {
+    return readTomlServerExists(mcpPath, serverName);
+  }
+  const existing =
+    host.mcp.configType === "yaml"
+      ? await readYamlConfig(mcpPath)
+      : await readJsonConfig(mcpPath);
+  const section = readConfigSection(existing, host.mcp.configKey);
+  return serverName in section;
 }
 
-function parseHostsValue(value) {
-  if (!value) return [...HOSTS];
-  const pieces = String(value)
-    .split(",")
-    .map((v) => v.trim())
-    .filter(Boolean);
-  return normalizeHosts(pieces);
+async function promptHosts(scope, detected, serverName) {
+  const choices = await Promise.all(
+    ALL_HOST_NAMES.map(async (hostName) => {
+      const configured = await isAlreadyConfigured(
+        hostName,
+        scope,
+        serverName,
+      ).catch(() => false);
+      return {
+        name: SETUP_HOST_NAMES[hostName],
+        value: hostName,
+        checked: detected.includes(hostName),
+        disabled: configured ? "(already configured)" : false,
+      };
+    }),
+  );
+
+  if (choices.every((choice) => Boolean(choice.disabled))) {
+    log.info("Flywheel is already configured for all detected hosts.");
+    return null;
+  }
+
+  try {
+    return await checkbox({
+      message: "Which hosts do you want to set up?",
+      choices,
+      loop: false,
+      theme: CHECKBOX_THEME,
+      validate: (selected) =>
+        selected.length > 0 || "Select at least one host.",
+    });
+  } catch {
+    return null;
+  }
 }
 
-async function promptLine(rl, message, defaultValue = "") {
-  const suffix = defaultValue ? ` (${defaultValue})` : "";
-  const answer = await rl.question(`${message}${suffix}: `);
-  const trimmed = answer.trim();
-  return trimmed || defaultValue;
+async function resolveHosts(options, scope, serverName) {
+  const explicit = selectedHostsFromOptions(options);
+  if (explicit.length > 0) return explicit;
+
+  const detected = await detectHosts(scope);
+  if (detected.length > 0 && options.yes) return detected;
+
+  log.blank();
+  const selected = await promptHosts(scope, detected, serverName);
+  if (!selected) {
+    log.warn("Setup cancelled");
+    return [];
+  }
+  return selected;
 }
 
-async function resolveSetupInputs(options) {
-  let scope = normalizeScope(options.scope || DEFAULT_SCOPE);
-  let hosts = parseHostsValue(options.hosts);
-  let baseUrl = (options.baseUrl || DEFAULT_BASE_URL).trim().replace(/\/$/, "");
+async function resolveApiKey(options, baseUrl) {
+  if (options.apiKey) return options.apiKey.trim();
 
-  if (!options.yes) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
+  const spinner = ora("Configuring authentication...").start();
+  try {
+    const keyName = `flywheel-setup-${randomBytes(3).toString("hex")}`;
+    const authResult = await acquireApiKeyViaBrowserBridge({
+      baseUrl,
+      keyName,
     });
-    try {
-      const promptedScope = await promptLine(
-        rl,
-        "Scope [global/project]",
-        scope,
-      );
-      scope = normalizeScope(promptedScope);
+    spinner.succeed("Authenticated");
+    return authResult.apiKey;
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    throw error;
+  }
+}
 
-      const promptedHosts = await promptLine(
-        rl,
-        "Hosts (comma-separated codex,claude,opencode)",
-        hosts.join(","),
-      );
-      hosts = parseHostsValue(promptedHosts);
+async function setupHost(hostName, scope, serverUrl, apiKey, serverName) {
+  const host = getHost(hostName);
+  const mcpPath = await resolveMcpPath(mcpCandidatesForScope(host, scope));
 
-      baseUrl = (await promptLine(rl, "Flywheel base URL", baseUrl)).replace(
-        /\/$/,
-        "",
-      );
-    } finally {
-      rl.close();
+  if (host.mcp.configType === "toml") {
+    const { alreadyExists } = await appendTomlServer(
+      mcpPath,
+      serverName,
+      host.mcp.buildEntry({ serverUrl, apiKey }),
+    );
+    return {
+      host: host.displayName,
+      status: alreadyExists ? "already configured" : "configured with API Key",
+      filePath: mcpPath,
+    };
+  }
+
+  const existing =
+    host.mcp.configType === "yaml"
+      ? await readYamlConfig(mcpPath)
+      : await readJsonConfig(mcpPath);
+  const { config, alreadyExists } = mergeServerEntry(
+    existing,
+    host.mcp.configKey,
+    serverName,
+    host.mcp.buildEntry({ serverUrl, apiKey }),
+  );
+  if (config !== existing) {
+    if (host.mcp.configType === "yaml") {
+      await writeYamlConfig(mcpPath, config);
+    } else {
+      await writeJsonConfig(mcpPath, config);
     }
   }
+  return {
+    host: host.displayName,
+    status: alreadyExists ? "already configured" : "configured with API Key",
+    filePath: mcpPath,
+  };
+}
+
+function printSetupResults(results, scope, serverUrl) {
+  log.blank();
+  log.plain(pc.green("✔ Flywheel setup complete"));
+  log.blank();
+  log.plain(`  Scope: ${pc.bold(scope)}`);
+  log.plain(`  Server URL: ${pc.bold(serverUrl)}`);
+  for (const result of results) {
+    const icon = result.status.startsWith("configured")
+      ? pc.green("+")
+      : pc.dim("~");
+    log.plain(`  ${pc.bold(result.host)}`);
+    log.plain(`    ${icon} ${result.status}`);
+    log.plain(`      ${pc.dim(result.filePath)}`);
+  }
+  log.blank();
+}
+
+async function runSetupCommand(options) {
+  const scope = options.project ? "project" : "global";
+  const baseUrl = normalizeBaseUrl(options.baseUrl || DEFAULT_BASE_URL);
+  const serverUrl = `${baseUrl}/mcp-server`;
+  const serverName = normalizeServerName(options.name || SERVER_NAME);
+  const hosts = await resolveHosts(options, scope, serverName);
+  if (hosts.length === 0) return;
+
+  const apiKey = await resolveApiKey(options, baseUrl);
+  if (!apiKey) {
+    log.warn("Setup cancelled");
+    return;
+  }
 
-  const serverUrl = (options.serverUrl || `${baseUrl}/mcp-server`)
+  const spinner = ora("Setting up Flywheel...").start();
+  const results = [];
+  for (const hostName of hosts) {
+    spinner.text = `Setting up ${getHost(hostName).displayName}...`;
+    // eslint-disable-next-line no-await-in-loop
+    results.push(
+      await setupHost(hostName, scope, serverUrl, apiKey, serverName),
+    );
+  }
+  spinner.succeed("Setup complete");
+  printSetupResults(results, scope, serverUrl);
+}
+
+function parseUninstallScope(value) {
+  const normalized = String(value || "")
     .trim()
-    .replace(/\/$/, "");
+    .toLowerCase();
+  if (
+    normalized === "global" ||
+    normalized === "project" ||
+    normalized === "all"
+  ) {
+    return normalized;
+  }
+  return "all";
+}
 
-  return {
-    scope,
-    hosts,
-    baseUrl,
-    serverUrl,
-  };
+function scopesFromUninstallScope(scope) {
+  return scope === "all" ? ["global", "project"] : [scope];
 }
 
-async function resolveUninstallInputs(options) {
-  let scope = (options.scope || "all").trim().toLowerCase();
-  if (!["all", "global", "project"].includes(scope)) {
-    scope = "all";
+async function isConfiguredForUninstallScope(hostName, scope, serverName) {
+  const scopes = scopesFromUninstallScope(scope);
+  for (const singleScope of scopes) {
+    // eslint-disable-next-line no-await-in-loop
+    const configured = await isAlreadyConfigured(
+      hostName,
+      singleScope,
+      serverName,
+    ).catch(() => false);
+    if (configured) return true;
   }
-  let hosts = parseHostsValue(options.hosts);
+  return false;
+}
 
-  if (!options.yes) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
+async function promptUninstallScope(defaultScope) {
+  try {
+    return await select({
+      message: "Which scope do you want to uninstall from?",
+      choices: [
+        { name: "All (global and project)", value: "all" },
+        { name: "Global", value: "global" },
+        { name: "Project", value: "project" },
+      ],
+      default: defaultScope,
+      theme: CHECKBOX_THEME,
     });
-    try {
-      const promptedScope = await promptLine(
-        rl,
-        "Scope [all/global/project]",
+  } catch {
+    return null;
+  }
+}
+
+async function promptUninstallHosts(scope, serverName) {
+  const choices = await Promise.all(
+    ALL_HOST_NAMES.map(async (hostName) => {
+      const configured = await isConfiguredForUninstallScope(
+        hostName,
         scope,
+        serverName,
       );
-      scope = ["all", "global", "project"].includes(promptedScope)
-        ? promptedScope
-        : "all";
-      const promptedHosts = await promptLine(
-        rl,
-        "Hosts (comma-separated codex,claude,opencode)",
-        hosts.join(","),
-      );
-      hosts = parseHostsValue(promptedHosts);
-    } finally {
-      rl.close();
-    }
+      return {
+        name: SETUP_HOST_NAMES[hostName],
+        value: hostName,
+        checked: configured,
+        disabled: configured ? false : "(not configured)",
+      };
+    }),
+  );
+
+  if (choices.every((choice) => Boolean(choice.disabled))) {
+    log.info("Flywheel is not configured for the selected scope.");
+    return null;
   }
 
-  return { scope, hosts };
+  try {
+    return await checkbox({
+      message: "Which hosts do you want to uninstall?",
+      choices,
+      loop: false,
+      theme: CHECKBOX_THEME,
+      validate: (selected) =>
+        selected.length > 0 || "Select at least one host.",
+    });
+  } catch {
+    return null;
+  }
 }
 
-async function writeSharedApiKey(apiKey) {
-  await mkdir(path.dirname(SHARED_KEY_PATH), { recursive: true });
-  await writeFile(SHARED_KEY_PATH, `${apiKey.trim()}\n`, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-}
+async function resolveUninstallTargets(options, serverName) {
+  const explicitHostsFromFlags = selectedHostsFromOptions(options);
+  const explicitHostsFromList =
+    explicitHostsFromFlags.length === 0 ? parseHostsList(options.hosts) : [];
+  const hasExplicitHosts =
+    explicitHostsFromFlags.length > 0 || explicitHostsFromList.length > 0;
+  const hasExplicitScope =
+    typeof options.scope === "string" && options.scope.trim().length > 0;
+
+  let scope = parseUninstallScope(options.scope || "all");
+  let hosts =
+    explicitHostsFromFlags.length > 0
+      ? explicitHostsFromFlags
+      : explicitHostsFromList.length > 0
+        ? explicitHostsFromList
+        : [...ALL_HOST_NAMES];
 
-async function configureHost({ host, scope, serverUrl, apiKey }) {
-  const config = AGENT_CONFIG[host];
-  const filePath = resolveHostConfigPath(host, scope);
-  const entry = config.buildEntry({ serverUrl, apiKey });
+  if (!options.yes) {
+    if (!hasExplicitScope) {
+      log.blank();
+      const selectedScope = await promptUninstallScope(scope);
+      if (!selectedScope) {
+        log.warn("Uninstall cancelled");
+        return null;
+      }
+      scope = selectedScope;
+    }
 
-  if (config.configType === "toml") {
-    const result = await upsertCodexTomlServer({
-      filePath,
-      serverName: SERVER_NAME,
-      entry,
-    });
-    return {
-      host,
-      filePath,
-      status: result.changed
-        ? result.hadExisting
-          ? "updated"
-          : "installed"
-        : "already configured",
-    };
+    if (!hasExplicitHosts) {
+      const selectedHosts = await promptUninstallHosts(scope, serverName);
+      if (!selectedHosts) {
+        log.warn("Uninstall cancelled");
+        return null;
+      }
+      hosts = selectedHosts;
+    }
   }
 
-  const current = await readJsonConfig(filePath);
-  const next = upsertJsonServerEntry({
-    config: current,
-    configKey: config.configKey,
-    serverName: SERVER_NAME,
-    entry,
-  });
-  if (next.changed) {
-    await writeJsonConfig(filePath, next.config);
-  }
-  return {
-    host,
-    filePath,
-    status: next.changed
-      ? next.hadExisting
-        ? "updated"
-        : "installed"
-      : "already configured",
-  };
+  return { scope, hosts };
 }
 
-async function removeHostConfig({ host, scope }) {
-  const config = AGENT_CONFIG[host];
-  const filePath = resolveHostConfigPath(host, scope);
+async function removeHostConfig(hostName, scope, serverName) {
+  const host = getHost(hostName);
+  const filePath = await resolveMcpPath(mcpCandidatesForScope(host, scope));
 
-  if (config.configType === "toml") {
+  if (host.mcp.configType === "toml") {
     const result = await removeCodexTomlServer({
       filePath,
-      serverName: SERVER_NAME,
+      serverName,
     });
     return {
-      host,
+      host: host.displayName,
       scope,
       filePath,
       status: result.changed ? "removed" : "not present",
     };
   }
 
-  const current = await readJsonConfig(filePath);
+  const current =
+    host.mcp.configType === "yaml"
+      ? await readYamlConfig(filePath)
+      : await readJsonConfig(filePath);
   const next = removeJsonServerEntry({
     config: current,
-    configKey: config.configKey,
-    serverName: SERVER_NAME,
+    configKey: host.mcp.configKey,
+    serverName,
   });
   if (next.changed) {
-    await writeJsonConfig(filePath, next.config);
+    if (host.mcp.configType === "yaml") {
+      await writeYamlConfig(filePath, next.config);
+    } else {
+      await writeJsonConfig(filePath, next.config);
+    }
   }
   return {
-    host,
+    host: host.displayName,
     scope,
     filePath,
     status: next.changed ? "removed" : "not present",
   };
 }
 
-function printSetupSummary({ scope, serverUrl, results }) {
-  console.log("\nFlywheel MCP setup complete\n");
-  console.log(`Scope: ${scope}`);
-  console.log(`Server URL: ${serverUrl}`);
-  for (const result of results) {
-    console.log(
-      `- ${HOST_LABELS[result.host]}: ${result.status}\n  ${result.filePath}`,
-    );
+async function runUninstallCommand(options) {
+  const serverName = normalizeServerName(options.name || SERVER_NAME);
+  const resolved = await resolveUninstallTargets(options, serverName);
+  if (!resolved) return;
+  const { scope, hosts } = resolved;
+  const scopes = scopesFromUninstallScope(scope);
+
+  const spinner = ora("Removing Flywheel MCP entries...").start();
+  const results = [];
+  for (const singleScope of scopes) {
+    for (const host of hosts) {
+      spinner.text = `Removing from ${getHost(host).displayName} (${singleScope})...`;
+      // eslint-disable-next-line no-await-in-loop
+      results.push(await removeHostConfig(host, singleScope, serverName));
+    }
   }
-  console.log(`\nStored API key: ${SHARED_KEY_PATH}`);
-}
+  spinner.succeed("Uninstall complete");
 
-function printUninstallSummary(results, deletedKey) {
-  console.log("\nFlywheel MCP uninstall complete\n");
+  log.blank();
+  log.plain(pc.green("✔ Flywheel uninstall complete"));
+  log.blank();
   for (const result of results) {
-    console.log(
-      `- ${HOST_LABELS[result.host]} (${result.scope}): ${result.status}\n  ${result.filePath}`,
-    );
-  }
-  if (deletedKey) {
-    console.log(`\nDeleted shared API key: ${SHARED_KEY_PATH}`);
+    const icon = result.status === "removed" ? pc.green("-") : pc.dim("~");
+    log.plain(`  ${pc.bold(result.host)} ${pc.dim(`(${result.scope})`)}`);
+    log.plain(`    ${icon} ${result.status}`);
+    log.plain(`      ${pc.dim(result.filePath)}`);
   }
+  log.blank();
 }
 
-async function runSetup(options) {
-  const inputs = await resolveSetupInputs(options);
-  const keyName =
-    (options.name || `flywheel-setup-${cryptoRandomHex(3)}`).trim() ||
-    `flywheel-setup-${cryptoRandomHex(3)}`;
-
-  const apiKey =
-    (options.apiKey && options.apiKey.trim()) ||
-    (
-      await acquireApiKeyViaBrowserBridge({
-        baseUrl: inputs.baseUrl,
-        keyName,
-      })
-    ).apiKey;
-
-  if (!apiKey || !apiKey.trim()) {
-    throw new Error("No API key available for setup.");
-  }
-
-  await writeSharedApiKey(apiKey);
-
-  const results = [];
-  for (const host of inputs.hosts) {
-    results.push(
-      await configureHost({
-        host,
-        scope: inputs.scope,
-        serverUrl: inputs.serverUrl,
-        apiKey,
-      }),
+function buildProgram() {
+  const program = new Command();
+  program
+    .name("flywheel")
+    .description("Flywheel setup CLI")
+    .addHelpText(
+      "after",
+      `
+Examples:
+  ${pc.green("npx @paradigma-inc/flywheel setup")}
+  ${pc.green("npx @paradigma-inc/flywheel setup --codex --project")}
+  ${pc.green("npx @paradigma-inc/flywheel setup --yes --codex --claude --cursor")}
+  ${pc.green(
+    "npx @paradigma-inc/flywheel uninstall --scope all --hosts codex,claude,opencode,cursor,pi-mono,hermes-agent,openclaw",
+  )}
+`,
     );
-  }
 
-  printSetupSummary({
-    scope: inputs.scope,
-    serverUrl: inputs.serverUrl,
-    results,
-  });
-}
-
-async function runUninstall(options) {
-  const inputs = await resolveUninstallInputs(options);
-  const scopes =
-    inputs.scope === "all" ? ["global", "project"] : [inputs.scope];
-
-  const results = [];
-  for (const scope of scopes) {
-    for (const host of inputs.hosts) {
-      results.push(await removeHostConfig({ host, scope }));
-    }
-  }
-
-  let deletedKey = false;
-  if (options.deleteKey) {
-    try {
-      await rm(SHARED_KEY_PATH, { force: true });
-      deletedKey = true;
-    } catch {
-      deletedKey = false;
-    }
-  }
+  program
+    .command("setup")
+    .description("Set up Flywheel for your AI coding host")
+    .option("--claude", "Set up for Claude Code")
+    .option("--opencode", "Set up for OpenCode")
+    .option("--codex", "Set up for Codex")
+    .option("--cursor", "Set up for Cursor")
+    .option("--pi-mono", "Set up for Pi (pi-mono)")
+    .option("--hermes-agent", "Set up for Hermes Agent")
+    .option("--openclaw", "Set up for OpenClaw")
+    .option(
+      "-p, --project",
+      "Configure for current project instead of globally",
+    )
+    .option("-y, --yes", "Skip host selection prompts")
+    .option("--api-key <key>", "Use API key authentication")
+    .option(
+      "--base-url <url>",
+      `Public Flywheel origin used for setup and MCP config (default: ${DEFAULT_BASE_URL})`,
+    )
+    .option("--name <name>", `MCP server name (default: ${SERVER_NAME})`)
+    .action(async (options) => {
+      await runSetupCommand(options);
+    });
 
-  printUninstallSummary(results, deletedKey);
-}
+  program
+    .command("uninstall")
+    .description("Remove Flywheel MCP entries from host configs")
+    .option("--claude", "Uninstall for Claude Code")
+    .option("--opencode", "Uninstall for OpenCode")
+    .option("--codex", "Uninstall for Codex")
+    .option("--cursor", "Uninstall for Cursor")
+    .option("--pi-mono", "Uninstall for Pi (pi-mono)")
+    .option("--hermes-agent", "Uninstall for Hermes Agent")
+    .option("--openclaw", "Uninstall for OpenClaw")
+    .option(
+      "--hosts <list>",
+      "Comma-separated: codex,claude,opencode,cursor,pi-mono,hermes-agent,openclaw",
+    )
+    .option("--scope <scope>", "all | global | project")
+    .option(
+      "--name <name>",
+      `MCP server name to remove (default: ${SERVER_NAME})`,
+    )
+    .option("-y, --yes", "Skip uninstall selection prompts")
+    .action(async (options) => {
+      await runUninstallCommand(options);
+    });
 
-function cryptoRandomHex(bytes) {
-  return randomBytes(bytes).toString("hex");
+  return program;
 }
 
 export async function runCli(argv = process.argv) {
-  const { command, options } = parseArgs(argv);
-
-  if (
-    !command ||
-    options.help ||
-    command === "help" ||
-    command === "--help" ||
-    command === "-h"
-  ) {
-    printHelp();
-    return;
-  }
-
-  if (command === "setup") {
-    await runSetup(options);
-    return;
-  }
-
-  if (command === "uninstall") {
-    await runUninstall(options);
-    return;
+  try {
+    const program = buildProgram();
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (error instanceof Error && error.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    if (error instanceof Error && /cancelled/i.test(error.message)) {
+      log.warn(error.message);
+      process.exit(0);
+    }
+    throw error;
   }
-
-  throw new Error(`Unknown command '${command}'. Use --help for usage.`);
 }