mcpcm 1.0.3

package/dist/cli.js

@@ -0,0 +1,1383 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/add.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/agents.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+var home = homedir();
+var isMac = platform() === "darwin";
+var isWindows = platform() === "win32";
+function getVscodeGlobalPath() {
+  if (isMac) {
+    return join(home, "Library/Application Support/Code/User/mcp.json");
+  } else if (isWindows) {
+    return join(home, "AppData/Roaming/Code/User/mcp.json");
+  } else {
+    return join(home, ".config/Code/User/mcp.json");
+  }
+}
+var agents = {
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    projectConfigPath: ".cursor/mcp.json",
+    globalConfigPath: join(home, ".cursor/mcp.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".cursor"))
+  },
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    projectConfigPath: ".mcp.json",
+    globalConfigPath: join(home, ".claude.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".claude.json"))
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    projectConfigPath: ".gemini/mcp_config.json",
+    globalConfigPath: join(home, ".gemini/antigravity/mcp_config.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".gemini/antigravity")) || existsSync(join(home, ".gemini"))
+  },
+  windsurf: {
+    name: "windsurf",
+    displayName: "Windsurf",
+    projectConfigPath: ".windsurf/mcp_config.json",
+    globalConfigPath: join(home, ".codeium/windsurf/mcp_config.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".codeium/windsurf"))
+  },
+  vscode: {
+    name: "vscode",
+    displayName: "VS Code / GitHub Copilot",
+    projectConfigPath: ".vscode/mcp.json",
+    globalConfigPath: getVscodeGlobalPath(),
+    configFormat: "json",
+    mcpConfigKey: "servers",
+    detectInstalled: async () => {
+      if (isMac) {
+        return existsSync(join(home, "Library/Application Support/Code"));
+      } else if (isWindows) {
+        return existsSync(join(home, "AppData/Roaming/Code"));
+      }
+      return existsSync(join(home, ".config/Code"));
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    projectConfigPath: ".codex/config.toml",
+    globalConfigPath: join(home, ".codex/config.toml"),
+    configFormat: "toml",
+    mcpConfigKey: "mcp_servers",
+    detectInstalled: async () => existsSync(join(home, ".codex"))
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    projectConfigPath: null,
+    globalConfigPath: join(home, ".config/opencode/opencode.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".config/opencode"))
+  },
+  "gemini-cli": {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    projectConfigPath: ".gemini/settings.json",
+    globalConfigPath: join(home, ".gemini/settings.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".gemini"))
+  },
+  qoder: {
+    name: "qoder",
+    displayName: "Qoder",
+    projectConfigPath: null,
+    globalConfigPath: null,
+    // Managed via qodercli
+    configFormat: "json",
+    mcpConfigKey: null,
+    detectInstalled: async () => false
+    // Cannot detect programmatically
+  },
+  "qwen-code": {
+    name: "qwen-code",
+    displayName: "Qwen Code",
+    projectConfigPath: ".qwen/settings.json",
+    globalConfigPath: join(home, ".qwen/settings.json"),
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(home, ".qwen"))
+  },
+  trae: {
+    name: "trae",
+    displayName: "Trae",
+    projectConfigPath: ".trae/mcp.json",
+    globalConfigPath: null,
+    configFormat: "json",
+    mcpConfigKey: "mcpServers",
+    detectInstalled: async () => existsSync(join(process.cwd(), ".trae"))
+  }
+};
+function getAllAgentTypes() {
+  return Object.keys(agents);
+}
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (await config.detectInstalled()) {
+      installed.push(type);
+    }
+  }
+  return installed;
+}
+function getAgentConfig(type) {
+  return agents[type];
+}
+function isValidAgentType(type) {
+  return type in agents;
+}
+
+// src/config-reader.ts
+import { readFileSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { parse as parseToml } from "@iarna/toml";
+
+// src/utils.ts
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[38;5;102m";
+var TEXT = "\x1B[38;5;145m";
+var GREEN = "\x1B[38;5;78m";
+var YELLOW = "\x1B[38;5;220m";
+var RED = "\x1B[38;5;196m";
+var CYAN = "\x1B[38;5;87m";
+function expandPath(path) {
+  if (path.startsWith("~")) {
+    return join2(homedir2(), path.slice(1));
+  }
+  return path;
+}
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function safeParseJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function formatServerConfig(name, config) {
+  const command = config["command"] || "unknown";
+  const args = config["args"] || [];
+  const argsStr = args.length > 0 ? ` ${args.join(" ")}` : "";
+  return `${CYAN}${name}${RESET}: ${DIM}${command}${argsStr}${RESET}`;
+}
+function success(message) {
+  console.log(`${GREEN}\u2713${RESET} ${message}`);
+}
+function error(message) {
+  console.log(`${RED}\u2717${RESET} ${message}`);
+}
+function warn(message) {
+  console.log(`${YELLOW}!${RESET} ${message}`);
+}
+function info(message) {
+  console.log(`${DIM}${message}${RESET}`);
+}
+function verbose(message, isVerbose) {
+  if (isVerbose) {
+    console.log(`${DIM}[verbose] ${message}${RESET}`);
+  }
+}
+
+// src/config-reader.ts
+function readConfigFile(filePath, format, mcpConfigKey, verboseMode = false) {
+  const expandedPath = expandPath(filePath);
+  if (!existsSync3(expandedPath)) {
+    verbose(`Config file not found: ${expandedPath}`, verboseMode);
+    return { config: null, rawContent: null, path: expandedPath, exists: false };
+  }
+  try {
+    const content = readFileSync(expandedPath, "utf-8");
+    let parsed;
+    if (format === "toml") {
+      parsed = parseToml(content);
+    } else {
+      const jsonParsed = safeParseJson(content);
+      if (!jsonParsed) {
+        return {
+          config: null,
+          rawContent: null,
+          path: expandedPath,
+          exists: true,
+          error: "Invalid JSON"
+        };
+      }
+      parsed = jsonParsed;
+    }
+    let mcpServers = {};
+    if (mcpConfigKey) {
+      const servers = parsed[mcpConfigKey];
+      if (servers && typeof servers === "object") {
+        mcpServers = servers;
+      }
+    } else {
+      if (parsed["mcpServers"] && typeof parsed["mcpServers"] === "object") {
+        mcpServers = parsed["mcpServers"];
+      }
+    }
+    verbose(`Read config from ${expandedPath}: ${Object.keys(mcpServers).length} servers`, verboseMode);
+    return {
+      config: { mcpServers },
+      rawContent: parsed,
+      path: expandedPath,
+      exists: true
+    };
+  } catch (err) {
+    return {
+      config: null,
+      rawContent: null,
+      path: expandedPath,
+      exists: true,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function readGlobalConfig(agentType, verboseMode = false) {
+  const agent = getAgentConfig(agentType);
+  if (!agent.globalConfigPath) {
+    return {
+      config: null,
+      rawContent: null,
+      path: "",
+      exists: false,
+      error: "No global config path"
+    };
+  }
+  return readConfigFile(
+    agent.globalConfigPath,
+    agent.configFormat,
+    agent.mcpConfigKey,
+    verboseMode
+  );
+}
+function readProjectConfig(agentType, projectDir = process.cwd(), verboseMode = false) {
+  const agent = getAgentConfig(agentType);
+  if (!agent.projectConfigPath) {
+    return {
+      config: null,
+      rawContent: null,
+      path: "",
+      exists: false,
+      error: "No project config path"
+    };
+  }
+  const fullPath = join3(projectDir, agent.projectConfigPath);
+  return readConfigFile(fullPath, agent.configFormat, agent.mcpConfigKey, verboseMode);
+}
+function parseMcpConfigString(jsonString) {
+  const parsed = safeParseJson(jsonString);
+  if (!parsed) return null;
+  if (parsed["mcpServers"] && typeof parsed["mcpServers"] === "object") {
+    return { mcpServers: parsed["mcpServers"] };
+  }
+  const firstValue = Object.values(parsed)[0];
+  if (firstValue && typeof firstValue === "object" && "command" in firstValue) {
+    return { mcpServers: parsed };
+  }
+  return null;
+}
+
+// src/config-writer.ts
+import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { parse as parseToml2, stringify as stringifyToml } from "@iarna/toml";
+function mergeMcpConfigs(existing, incoming, replace = false) {
+  if (replace) {
+    return {
+      mcpServers: {
+        ...existing.mcpServers,
+        ...incoming.mcpServers
+      }
+    };
+  }
+  const merged = { ...existing.mcpServers };
+  for (const [name, config] of Object.entries(incoming.mcpServers)) {
+    if (merged[name]) {
+      merged[name] = { ...merged[name], ...config };
+    } else {
+      merged[name] = config;
+    }
+  }
+  return { mcpServers: merged };
+}
+function removeServersFromConfig(config, serverNames) {
+  const filtered = { ...config.mcpServers };
+  for (const name of serverNames) {
+    delete filtered[name];
+  }
+  return { mcpServers: filtered };
+}
+function writeConfigFile(filePath, config, format, mcpConfigKey, existingContent = null, verboseMode = false) {
+  const expandedPath = expandPath(filePath);
+  try {
+    ensureDir(expandedPath);
+    let content;
+    if (existingContent) {
+      content = { ...existingContent };
+    } else if (existsSync4(expandedPath)) {
+      const existing = readFileSync2(expandedPath, "utf-8");
+      if (format === "toml") {
+        content = parseToml2(existing);
+      } else {
+        content = safeParseJson(existing) || {};
+      }
+    } else {
+      content = {};
+    }
+    const key = mcpConfigKey || "mcpServers";
+    content[key] = config.mcpServers;
+    let output;
+    if (format === "toml") {
+      output = stringifyToml(content);
+    } else {
+      output = JSON.stringify(content, null, 2);
+    }
+    writeFileSync(expandedPath, output, "utf-8");
+    verbose(`Wrote config to ${expandedPath}`, verboseMode);
+    return { success: true, path: expandedPath };
+  } catch (err) {
+    return {
+      success: false,
+      path: expandedPath,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function writeGlobalConfig(agentType, config, existingContent = null, verboseMode = false) {
+  const agent = getAgentConfig(agentType);
+  if (!agent.globalConfigPath) {
+    return { success: false, path: "", error: "No global config path" };
+  }
+  return writeConfigFile(
+    agent.globalConfigPath,
+    config,
+    agent.configFormat,
+    agent.mcpConfigKey,
+    existingContent,
+    verboseMode
+  );
+}
+function writeProjectConfig(agentType, config, existingContent = null, projectDir = process.cwd(), verboseMode = false) {
+  const agent = getAgentConfig(agentType);
+  if (!agent.projectConfigPath) {
+    return { success: false, path: "", error: "No project config path" };
+  }
+  const fullPath = join4(projectDir, agent.projectConfigPath);
+  return writeConfigFile(
+    fullPath,
+    config,
+    agent.configFormat,
+    agent.mcpConfigKey,
+    existingContent,
+    verboseMode
+  );
+}
+
+// src/commands/add.ts
+function parseAddOptions(args) {
+  const options = {};
+  let input = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agents = [];
+      while (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        i++;
+        const agentName = args[i];
+        if (agentName && isValidAgentType(agentName)) {
+          options.agents.push(agentName);
+        } else if (agentName) {
+          warn(`Unknown agent: ${agentName}`);
+        }
+      }
+    } else if (arg === "--global" || arg === "-g") {
+      options.global = true;
+    } else if (arg === "--workspace" || arg === "-w") {
+      options.workspace = true;
+    } else if (arg === "--replace" || arg === "-r") {
+      options.replace = true;
+    } else if (arg === "--file" || arg === "-f") {
+      options.file = args[++i];
+    } else if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+    } else if (!arg?.startsWith("-") && !input) {
+      input = arg ?? null;
+    }
+  }
+  return { input, options };
+}
+async function runAdd(input, options) {
+  verbose("Running add command", options.verbose ?? false);
+  let mcpConfig = null;
+  if (options.file) {
+    try {
+      const content = readFileSync3(options.file, "utf-8");
+      mcpConfig = parseMcpConfigString(content);
+      if (!mcpConfig) {
+        error(`Invalid MCP config in file: ${options.file}`);
+        return;
+      }
+      verbose(`Read config from file: ${options.file}`, options.verbose ?? false);
+    } catch (err) {
+      error(`Failed to read file: ${options.file}`);
+      return;
+    }
+  } else if (input) {
+    mcpConfig = parseMcpConfigString(input);
+    if (!mcpConfig) {
+      error("Invalid MCP config JSON");
+      return;
+    }
+  } else {
+    error("No MCP config provided. Use JSON string or --file option.");
+    console.log(`
+${DIM}Example:${RESET}`);
+    console.log(
+      `  mcpcm add '{"mcpServers":{"my-server":{"command":"node","args":["/path/to/server.js"]}}}' --agent cursor`
+    );
+    console.log(`  mcpcm add --file mcp.json --global`);
+    return;
+  }
+  const serverNames = Object.keys(mcpConfig.mcpServers);
+  info(`Adding ${serverNames.length} MCP server(s): ${serverNames.join(", ")}`);
+  let targetAgents = [];
+  if (options.agents && options.agents.length > 0) {
+    targetAgents = options.agents;
+  } else if (options.global) {
+    targetAgents = await detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      warn("No installed agents detected. Specify agents with --agent.");
+      return;
+    }
+  } else if (options.workspace) {
+    targetAgents = getAllAgentTypes().filter((t) => agents[t].projectConfigPath !== null);
+  } else {
+    error("Specify target with --agent, --global, or --workspace");
+    return;
+  }
+  verbose(`Target agents: ${targetAgents.join(", ")}`, options.verbose ?? false);
+  let successCount = 0;
+  let failCount = 0;
+  const allSkippedServers = /* @__PURE__ */ new Map();
+  for (const agentType of targetAgents) {
+    const agent = agents[agentType];
+    if (options.workspace) {
+      if (!agent.projectConfigPath) {
+        verbose(`${agent.displayName} doesn't support project config`, options.verbose ?? false);
+        continue;
+      }
+      const existing = readProjectConfig(agentType, process.cwd(), options.verbose);
+      const existingServers = Object.keys(existing.config?.mcpServers || {});
+      const incomingServers = Object.keys(mcpConfig.mcpServers);
+      const duplicates = incomingServers.filter((s) => existingServers.includes(s));
+      const newServers = incomingServers.filter((s) => !existingServers.includes(s));
+      for (const dup of duplicates) {
+        const agents2 = allSkippedServers.get(dup) || [];
+        agents2.push(agent.displayName);
+        allSkippedServers.set(dup, agents2);
+      }
+      if (newServers.length === 0) {
+        warn(`${agent.displayName}: all servers already exist (skipped)`);
+        continue;
+      }
+      const filteredConfig = {
+        mcpServers: Object.fromEntries(
+          Object.entries(mcpConfig.mcpServers).filter(([name]) => newServers.includes(name))
+        )
+      };
+      const merged = mergeMcpConfigs(
+        existing.config || { mcpServers: {} },
+        filteredConfig,
+        options.replace
+      );
+      const result = writeProjectConfig(
+        agentType,
+        merged,
+        existing.rawContent,
+        process.cwd(),
+        options.verbose
+      );
+      if (result.success) {
+        if (duplicates.length > 0) {
+          success(
+            `${agent.displayName}: added ${newServers.join(", ")} (skipped: ${duplicates.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: ${result.path}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    } else {
+      if (!agent.globalConfigPath) {
+        verbose(`${agent.displayName} doesn't support global config`, options.verbose ?? false);
+        continue;
+      }
+      const existing = readGlobalConfig(agentType, options.verbose);
+      const existingServers = Object.keys(existing.config?.mcpServers || {});
+      const incomingServers = Object.keys(mcpConfig.mcpServers);
+      const duplicates = incomingServers.filter((s) => existingServers.includes(s));
+      const newServers = incomingServers.filter((s) => !existingServers.includes(s));
+      for (const dup of duplicates) {
+        const agents2 = allSkippedServers.get(dup) || [];
+        agents2.push(agent.displayName);
+        allSkippedServers.set(dup, agents2);
+      }
+      if (newServers.length === 0) {
+        warn(`${agent.displayName}: all servers already exist (skipped)`);
+        continue;
+      }
+      const filteredConfig = {
+        mcpServers: Object.fromEntries(
+          Object.entries(mcpConfig.mcpServers).filter(([name]) => newServers.includes(name))
+        )
+      };
+      const merged = mergeMcpConfigs(
+        existing.config || { mcpServers: {} },
+        filteredConfig,
+        options.replace
+      );
+      const result = writeGlobalConfig(agentType, merged, existing.rawContent, options.verbose);
+      if (result.success) {
+        if (duplicates.length > 0) {
+          success(
+            `${agent.displayName}: added ${newServers.join(", ")} (skipped: ${duplicates.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: ${result.path}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    success(`Added to ${successCount} agent(s)`);
+  }
+  if (failCount > 0) {
+    error(`Failed for ${failCount} agent(s)`);
+  }
+  if (allSkippedServers.size > 0) {
+    console.log();
+    warn(`Skipped ${allSkippedServers.size} existing server(s):`);
+    for (const [serverName, agentNames] of allSkippedServers) {
+      console.log(`  ${DIM}${serverName}${RESET} \u2192 ${agentNames.join(", ")}`);
+    }
+    console.log(`
+${DIM}Use 'mcpcm update' to modify existing servers.${RESET}`);
+  }
+}
+
+// src/commands/del.ts
+function parseDelOptions(args) {
+  const options = {};
+  const serverNames = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agents = [];
+      while (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        i++;
+        const agentName = args[i];
+        if (agentName && isValidAgentType(agentName)) {
+          options.agents.push(agentName);
+        } else if (agentName) {
+          warn(`Unknown agent: ${agentName}`);
+        }
+      }
+    } else if (arg === "--global" || arg === "-g") {
+      options.global = true;
+    } else if (arg === "--workspace" || arg === "-w") {
+      options.workspace = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+    } else if (!arg?.startsWith("-")) {
+      if (typeof arg === "string") {
+        serverNames.push(arg);
+      }
+    }
+  }
+  return { serverNames, options };
+}
+async function runDel(serverNames, options) {
+  verbose("Running del command", options.verbose ?? false);
+  if (serverNames.length === 0) {
+    error("No server name provided");
+    console.log(`
+${DIM}Example:${RESET}`);
+    console.log(`  mcpcm del my-server --agent cursor`);
+    console.log(`  mcpcm del my-server --global`);
+    return;
+  }
+  info(`Deleting MCP server(s): ${serverNames.join(", ")}`);
+  let targetAgents = [];
+  if (options.agents && options.agents.length > 0) {
+    targetAgents = options.agents;
+  } else if (options.global) {
+    targetAgents = await detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      warn("No installed agents detected.");
+      return;
+    }
+  } else if (options.workspace) {
+    targetAgents = getAllAgentTypes().filter((t) => agents[t].projectConfigPath !== null);
+  } else {
+    error("Specify target with --agent, --global, or --workspace");
+    return;
+  }
+  let successCount = 0;
+  let failCount = 0;
+  const allNotFoundServers = /* @__PURE__ */ new Map();
+  for (const agentType of targetAgents) {
+    const agent = agents[agentType];
+    if (options.workspace) {
+      if (!agent.projectConfigPath) continue;
+      const existing = readProjectConfig(agentType, process.cwd(), options.verbose);
+      if (!existing.config) continue;
+      const existingServers = Object.keys(existing.config.mcpServers || {});
+      const toDelete = serverNames.filter((s) => existingServers.includes(s));
+      const notFound = serverNames.filter((s) => !existingServers.includes(s));
+      for (const nf of notFound) {
+        const agents2 = allNotFoundServers.get(nf) || [];
+        agents2.push(agent.displayName);
+        allNotFoundServers.set(nf, agents2);
+      }
+      if (toDelete.length === 0) {
+        warn(`${agent.displayName}: no matching servers found (skipped)`);
+        continue;
+      }
+      const updated = removeServersFromConfig(existing.config, toDelete);
+      const result = writeProjectConfig(
+        agentType,
+        updated,
+        existing.rawContent,
+        process.cwd(),
+        options.verbose
+      );
+      if (result.success) {
+        if (notFound.length > 0) {
+          success(
+            `${agent.displayName}: deleted ${toDelete.join(", ")} (not found: ${notFound.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: deleted ${toDelete.join(", ")}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    } else {
+      if (!agent.globalConfigPath) continue;
+      const existing = readGlobalConfig(agentType, options.verbose);
+      if (!existing.config) continue;
+      const existingServers = Object.keys(existing.config.mcpServers || {});
+      const toDelete = serverNames.filter((s) => existingServers.includes(s));
+      const notFound = serverNames.filter((s) => !existingServers.includes(s));
+      for (const nf of notFound) {
+        const agents2 = allNotFoundServers.get(nf) || [];
+        agents2.push(agent.displayName);
+        allNotFoundServers.set(nf, agents2);
+      }
+      if (toDelete.length === 0) {
+        warn(`${agent.displayName}: no matching servers found (skipped)`);
+        continue;
+      }
+      const updated = removeServersFromConfig(existing.config, toDelete);
+      const result = writeGlobalConfig(agentType, updated, existing.rawContent, options.verbose);
+      if (result.success) {
+        if (notFound.length > 0) {
+          success(
+            `${agent.displayName}: deleted ${toDelete.join(", ")} (not found: ${notFound.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: deleted ${toDelete.join(", ")}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    success(`Deleted from ${successCount} agent(s)`);
+  }
+  if (failCount > 0) {
+    error(`Failed for ${failCount} agent(s)`);
+  }
+  if (allNotFoundServers.size > 0) {
+    console.log();
+    warn(`${allNotFoundServers.size} server(s) not found:`);
+    for (const [serverName, agentNames] of allNotFoundServers) {
+      console.log(`  ${DIM}${serverName}${RESET} \u2192 ${agentNames.join(", ")}`);
+    }
+  }
+}
+
+// src/commands/list.ts
+function parseListOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agents = [];
+      while (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        i++;
+        const agentName = args[i];
+        if (agentName && isValidAgentType(agentName)) {
+          options.agents.push(agentName);
+        } else if (agentName) {
+          warn(`Unknown agent: ${agentName}`);
+        }
+      }
+    } else if (arg === "--global" || arg === "-g") {
+      options.global = true;
+    } else if (arg === "--workspace" || arg === "-w") {
+      options.workspace = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+    }
+  }
+  return options;
+}
+async function runList(options) {
+  let targetAgents = [];
+  if (options.agents && options.agents.length > 0) {
+    targetAgents = options.agents;
+  } else {
+    targetAgents = await detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      info("No installed agents detected.");
+      console.log(`
+${DIM}Supported agents:${RESET}`);
+      for (const type of getAllAgentTypes()) {
+        console.log(`  ${agents[type].displayName} (--agent ${type})`);
+      }
+      return;
+    }
+  }
+  let totalServers = 0;
+  for (const agentType of targetAgents) {
+    const agent = agents[agentType];
+    let hasOutput = false;
+    if (!options.workspace) {
+      const globalConfig = readGlobalConfig(agentType, options.verbose);
+      if (globalConfig.config && Object.keys(globalConfig.config.mcpServers).length > 0) {
+        if (!hasOutput) {
+          console.log(`
+${BOLD}${agent.displayName}${RESET}`);
+          hasOutput = true;
+        }
+        console.log(`  ${DIM}Global:${RESET} ${globalConfig.path}`);
+        for (const [name, config] of Object.entries(globalConfig.config.mcpServers)) {
+          console.log(`    ${formatServerConfig(name, config)}`);
+          totalServers++;
+        }
+      }
+    }
+    if (!options.global) {
+      const projectConfig = readProjectConfig(agentType, process.cwd(), options.verbose);
+      if (projectConfig.config && Object.keys(projectConfig.config.mcpServers).length > 0) {
+        if (!hasOutput) {
+          console.log(`
+${BOLD}${agent.displayName}${RESET}`);
+          hasOutput = true;
+        }
+        console.log(`  ${DIM}Project:${RESET} ${projectConfig.path}`);
+        for (const [name, config] of Object.entries(projectConfig.config.mcpServers)) {
+          console.log(`    ${formatServerConfig(name, config)}`);
+          totalServers++;
+        }
+      }
+    }
+  }
+  console.log();
+  if (totalServers > 0) {
+    console.log(`${GREEN}Total:${RESET} ${totalServers} MCP server(s)`);
+  } else {
+    info("No MCP servers configured");
+  }
+}
+
+// src/commands/find.ts
+async function runFind(args) {
+  const serverName = args[0];
+  const verbose2 = args.includes("--verbose") || args.includes("-v");
+  if (!serverName) {
+    info("Usage: mcpcm find <server-name>");
+    console.log(`
+${DIM}Example:${RESET}`);
+    console.log(`  mcpcm find easeim`);
+    return;
+  }
+  console.log(`
+${DIM}Searching for "${serverName}"...${RESET}
+`);
+  const results = [];
+  for (const agentType of getAllAgentTypes()) {
+    const agent = agents[agentType];
+    if (agent.globalConfigPath) {
+      const globalConfig = readGlobalConfig(agentType, verbose2);
+      if (globalConfig.config?.mcpServers[serverName]) {
+        results.push({
+          agent: agentType,
+          scope: "global",
+          path: globalConfig.path,
+          config: globalConfig.config.mcpServers[serverName]
+        });
+      }
+    }
+    if (agent.projectConfigPath) {
+      const projectConfig = readProjectConfig(agentType, process.cwd(), verbose2);
+      if (projectConfig.config?.mcpServers[serverName]) {
+        results.push({
+          agent: agentType,
+          scope: "project",
+          path: projectConfig.path,
+          config: projectConfig.config.mcpServers[serverName]
+        });
+      }
+    }
+  }
+  if (results.length === 0) {
+    info(`"${serverName}" not found in any MCP configuration`);
+    return;
+  }
+  console.log(`${GREEN}\u2713${RESET} ${BOLD}${serverName}${RESET} found in:
+`);
+  for (const result of results) {
+    const agent = agents[result.agent];
+    const scopeLabel = result.scope === "global" ? "global" : "project";
+    console.log(
+      `  ${CYAN}${agent.displayName}${RESET} (${scopeLabel}): ${DIM}${result.path}${RESET}`
+    );
+    if (verbose2) {
+      const config = result.config;
+      console.log(`    ${DIM}command:${RESET} ${config.command}`);
+      if (config.args && config.args.length > 0) {
+        console.log(`    ${DIM}args:${RESET} ${config.args.join(" ")}`);
+      }
+      if (config.env) {
+        console.log(`    ${DIM}env:${RESET} ${JSON.stringify(config.env)}`);
+      }
+    }
+  }
+  console.log();
+}
+
+// src/commands/sync.ts
+function parseSyncOptions(args) {
+  let from = null;
+  const to = [];
+  let toAll = false;
+  let verboseMode = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--from" || arg === "-f") {
+      const agentName = args[++i];
+      if (agentName && isValidAgentType(agentName)) {
+        from = agentName;
+      } else {
+        warn(`Unknown agent: ${agentName}`);
+      }
+    } else if (arg === "--to" || arg === "-t") {
+      while (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        i++;
+        const agentName = args[i];
+        if (agentName && isValidAgentType(agentName)) {
+          to.push(agentName);
+        } else if (agentName) {
+          warn(`Unknown agent: ${agentName}`);
+        }
+      }
+    } else if (arg === "--to-all") {
+      toAll = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      verboseMode = true;
+    }
+  }
+  if (!from) {
+    error("Missing --from agent");
+    return null;
+  }
+  return { from, to: to.length > 0 ? to : void 0, toAll, verbose: verboseMode };
+}
+async function runSync(options) {
+  verbose("Running sync command", options.verbose ?? false);
+  const sourceConfig = readGlobalConfig(options.from, options.verbose);
+  if (!sourceConfig.config || Object.keys(sourceConfig.config.mcpServers).length === 0) {
+    error(`No MCP servers found in ${agents[options.from].displayName}'s global config`);
+    return;
+  }
+  info(
+    `Syncing ${Object.keys(sourceConfig.config.mcpServers).length} server(s) from ${agents[options.from].displayName}`
+  );
+  let targetAgents = [];
+  if (options.toAll) {
+    targetAgents = await detectInstalledAgents();
+    targetAgents = targetAgents.filter((a) => a !== options.from);
+  } else if (options.to && options.to.length > 0) {
+    targetAgents = options.to.filter((a) => a !== options.from);
+  } else {
+    error("Specify target with --to or --to-all");
+    return;
+  }
+  if (targetAgents.length === 0) {
+    warn("No target agents to sync to");
+    return;
+  }
+  let successCount = 0;
+  let failCount = 0;
+  for (const agentType of targetAgents) {
+    const agent = agents[agentType];
+    if (!agent.globalConfigPath) {
+      verbose(`${agent.displayName} doesn't support global config`, options.verbose ?? false);
+      continue;
+    }
+    const existing = readGlobalConfig(agentType, options.verbose);
+    const merged = mergeMcpConfigs(
+      existing.config || { mcpServers: {} },
+      sourceConfig.config,
+      false
+      // Always merge, don't replace
+    );
+    const result = writeGlobalConfig(agentType, merged, existing.rawContent, options.verbose);
+    if (result.success) {
+      success(`${agent.displayName}: ${result.path}`);
+      successCount++;
+    } else {
+      error(`${agent.displayName}: ${result.error}`);
+      failCount++;
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    success(`Synced to ${successCount} agent(s)`);
+  }
+  if (failCount > 0) {
+    error(`Failed for ${failCount} agent(s)`);
+  }
+}
+
+// src/commands/update.ts
+import { readFileSync as readFileSync4 } from "fs";
+function parseUpdateOptions(args) {
+  const options = {};
+  let input = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agents = [];
+      while (i + 1 < args.length && !args[i + 1]?.startsWith("-")) {
+        i++;
+        const agentName = args[i];
+        if (agentName && isValidAgentType(agentName)) {
+          options.agents.push(agentName);
+        } else if (agentName) {
+          warn(`Unknown agent: ${agentName}`);
+        }
+      }
+    } else if (arg === "--global" || arg === "-g") {
+      options.global = true;
+    } else if (arg === "--workspace" || arg === "-w") {
+      options.workspace = true;
+    } else if (arg === "--replace" || arg === "-r") {
+      options.replace = true;
+    } else if (arg === "--file" || arg === "-f") {
+      options.file = args[++i];
+    } else if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+    } else if (!arg?.startsWith("-") && !input) {
+      input = arg ?? null;
+    }
+  }
+  return { input, options };
+}
+async function runUpdate(input, options) {
+  verbose("Running update command", options.verbose ?? false);
+  let mcpConfig = null;
+  if (options.file) {
+    try {
+      const content = readFileSync4(options.file, "utf-8");
+      mcpConfig = parseMcpConfigString(content);
+      if (!mcpConfig) {
+        error(`Invalid MCP config in file: ${options.file}`);
+        return;
+      }
+      verbose(`Read config from file: ${options.file}`, options.verbose ?? false);
+    } catch (err) {
+      error(`Failed to read file: ${options.file}`);
+      return;
+    }
+  } else if (input) {
+    mcpConfig = parseMcpConfigString(input);
+    if (!mcpConfig) {
+      error("Invalid MCP config JSON");
+      return;
+    }
+  } else {
+    error("No MCP config provided. Use JSON string or --file option.");
+    console.log(`
+${DIM}Example:${RESET}`);
+    console.log(
+      `  mcpcm update '{"mcpServers":{"my-server":{"command":"node","args":["/path/to/server.js"]}}}' --agent cursor`
+    );
+    console.log(`  mcpcm update --file mcp.json --global`);
+    return;
+  }
+  const serverNames = Object.keys(mcpConfig.mcpServers);
+  info(`Updating ${serverNames.length} MCP server(s): ${serverNames.join(", ")}`);
+  let targetAgents = [];
+  if (options.agents && options.agents.length > 0) {
+    targetAgents = options.agents;
+  } else if (options.global) {
+    targetAgents = await detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      warn("No installed agents detected. Specify agents with --agent.");
+      return;
+    }
+  } else if (options.workspace) {
+    targetAgents = getAllAgentTypes().filter((t) => agents[t].projectConfigPath !== null);
+  } else {
+    error("Specify target with --agent, --global, or --workspace");
+    return;
+  }
+  verbose(`Target agents: ${targetAgents.join(", ")}`, options.verbose ?? false);
+  let successCount = 0;
+  let failCount = 0;
+  const allSkippedServers = /* @__PURE__ */ new Map();
+  for (const agentType of targetAgents) {
+    const agent = agents[agentType];
+    if (options.workspace) {
+      if (!agent.projectConfigPath) {
+        verbose(`${agent.displayName} doesn't support project config`, options.verbose ?? false);
+        continue;
+      }
+      const existing = readProjectConfig(agentType, process.cwd(), options.verbose);
+      const existingServers = Object.keys(existing.config?.mcpServers || {});
+      const incomingServers = Object.keys(mcpConfig.mcpServers);
+      const toUpdate = incomingServers.filter((s) => existingServers.includes(s));
+      const notFound = incomingServers.filter((s) => !existingServers.includes(s));
+      for (const nf of notFound) {
+        const agents2 = allSkippedServers.get(nf) || [];
+        agents2.push(agent.displayName);
+        allSkippedServers.set(nf, agents2);
+      }
+      if (toUpdate.length === 0) {
+        warn(`${agent.displayName}: no matching servers found (skipped)`);
+        continue;
+      }
+      const filteredConfig = {
+        mcpServers: Object.fromEntries(
+          Object.entries(mcpConfig.mcpServers).filter(([name]) => toUpdate.includes(name))
+        )
+      };
+      const merged = mergeMcpConfigs(
+        existing.config || { mcpServers: {} },
+        filteredConfig,
+        true
+        // Always replace for update
+      );
+      const result = writeProjectConfig(
+        agentType,
+        merged,
+        existing.rawContent,
+        process.cwd(),
+        options.verbose
+      );
+      if (result.success) {
+        if (notFound.length > 0) {
+          success(
+            `${agent.displayName}: updated ${toUpdate.join(", ")} (skipped: ${notFound.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: updated ${toUpdate.join(", ")}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    } else {
+      if (!agent.globalConfigPath) {
+        verbose(`${agent.displayName} doesn't support global config`, options.verbose ?? false);
+        continue;
+      }
+      const existing = readGlobalConfig(agentType, options.verbose);
+      const existingServers = Object.keys(existing.config?.mcpServers || {});
+      const incomingServers = Object.keys(mcpConfig.mcpServers);
+      const toUpdate = incomingServers.filter((s) => existingServers.includes(s));
+      const notFound = incomingServers.filter((s) => !existingServers.includes(s));
+      for (const nf of notFound) {
+        const agents2 = allSkippedServers.get(nf) || [];
+        agents2.push(agent.displayName);
+        allSkippedServers.set(nf, agents2);
+      }
+      if (toUpdate.length === 0) {
+        warn(`${agent.displayName}: no matching servers found (skipped)`);
+        continue;
+      }
+      const filteredConfig = {
+        mcpServers: Object.fromEntries(
+          Object.entries(mcpConfig.mcpServers).filter(([name]) => toUpdate.includes(name))
+        )
+      };
+      const merged = mergeMcpConfigs(
+        existing.config || { mcpServers: {} },
+        filteredConfig,
+        true
+        // Always replace for update
+      );
+      const result = writeGlobalConfig(agentType, merged, existing.rawContent, options.verbose);
+      if (result.success) {
+        if (notFound.length > 0) {
+          success(
+            `${agent.displayName}: updated ${toUpdate.join(", ")} (skipped: ${notFound.join(", ")})`
+          );
+        } else {
+          success(`${agent.displayName}: updated ${toUpdate.join(", ")}`);
+        }
+        successCount++;
+      } else {
+        error(`${agent.displayName}: ${result.error}`);
+        failCount++;
+      }
+    }
+  }
+  console.log();
+  if (successCount > 0) {
+    success(`Updated ${successCount} agent(s)`);
+  }
+  if (failCount > 0) {
+    error(`Failed for ${failCount} agent(s)`);
+  }
+  if (allSkippedServers.size > 0) {
+    console.log();
+    warn(`Skipped ${allSkippedServers.size} server(s) not found:`);
+    for (const [serverName, agentNames] of allSkippedServers) {
+      console.log(`  ${DIM}${serverName}${RESET} \u2192 ${agentNames.join(", ")}`);
+    }
+    console.log(`
+${DIM}Use 'mcpcm add' to add new servers.${RESET}`);
+  }
+}
+
+// src/cli.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function getVersion() {
+  try {
+    const pkgPath = join5(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "1.0.0";
+  }
+}
+var VERSION = getVersion();
+var LOGO_LINES = [
+  "\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551",
+  "\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551",
+  "\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551     \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551",
+  "\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551",
+  "\u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D      \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D"
+];
+var GRAYS = [
+  "\x1B[38;5;250m",
+  "\x1B[38;5;248m",
+  "\x1B[38;5;245m",
+  "\x1B[38;5;243m",
+  "\x1B[38;5;240m",
+  "\x1B[38;5;238m"
+];
+function showLogo() {
+  console.log();
+  LOGO_LINES.forEach((line, i) => {
+    console.log(`${GRAYS[i]}${line}${RESET}`);
+  });
+}
+function showBanner() {
+  showLogo();
+  console.log();
+  console.log(
+    `${DIM}MCP Configuration Manager - Manage MCP server configuration across AI Agents${RESET}`
+  );
+  console.log();
+  console.log(`  ${DIM}$${RESET} ${TEXT}mcpcm add${RESET}     ${DIM}Add MCP server config${RESET}`);
+  console.log(
+    `  ${DIM}$${RESET} ${TEXT}mcpcm del${RESET}     ${DIM}Delete MCP server config${RESET}`
+  );
+  console.log(`  ${DIM}$${RESET} ${TEXT}mcpcm list${RESET}    ${DIM}List all MCP configs${RESET}`);
+  console.log(`  ${DIM}$${RESET} ${TEXT}mcpcm find${RESET}    ${DIM}Find MCP server${RESET}`);
+  console.log(
+    `  ${DIM}$${RESET} ${TEXT}mcpcm sync${RESET}    ${DIM}Sync configs between agents${RESET}`
+  );
+  console.log();
+  console.log(`${DIM}Run${RESET} mcpcm --help ${DIM}for more info${RESET}`);
+  console.log();
+}
+function showHelp() {
+  const agentList = getAllAgentTypes().join(", ");
+  console.log(`
+${BOLD}Usage:${RESET} mcpcm <command> [options]
+
+${BOLD}Commands:${RESET}
+  add <json>          Add MCP server config from JSON string
+  add --file <path>   Add MCP server config from file
+  update              Update MCP server config (same as add)
+  del <name>          Delete MCP server by name
+  list                List all MCP configurations
+  find <name>         Find where an MCP server is configured
+  sync                Sync configs from one agent to others
+
+${BOLD}Target Options:${RESET}
+  -a, --agent <name>  Target specific agent(s)
+  -g, --global        Target all installed agents (global configs)
+  -w, --workspace     Target project-level configs
+
+${BOLD}Add/Update Options:${RESET}
+  -f, --file <path>   Read config from JSON/TOML file
+  -r, --replace       Replace configs instead of merging
+
+${BOLD}Sync Options:${RESET}
+  --from <agent>      Source agent to sync from
+  --to <agent>        Target agent(s) to sync to
+  --to-all            Sync to all installed agents
+
+${BOLD}Other Options:${RESET}
+  -v, --verbose       Show detailed output
+  -h, --help          Show this help message
+  --version           Show version number
+
+${BOLD}Supported Agents:${RESET}
+  ${DIM}${agentList}${RESET}
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} mcpcm add '{"mcpServers":{"my-server":{"command":"node","args":["/path/to/server"]}}}' --agent cursor
+  ${DIM}$${RESET} mcpcm add --file mcp.json --global
+  ${DIM}$${RESET} mcpcm del my-server --agent cursor
+  ${DIM}$${RESET} mcpcm list --global
+  ${DIM}$${RESET} mcpcm find my-server
+  ${DIM}$${RESET} mcpcm sync --from cursor --to antigravity claude-code
+  ${DIM}$${RESET} mcpcm sync --from cursor --to-all
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    showBanner();
+    return;
+  }
+  const command = args[0];
+  const restArgs = args.slice(1);
+  switch (command) {
+    case "add":
+    case "a": {
+      showLogo();
+      console.log();
+      const { input, options } = parseAddOptions(restArgs);
+      await runAdd(input, options);
+      break;
+    }
+    case "update":
+    case "u": {
+      showLogo();
+      console.log();
+      const { input, options } = parseUpdateOptions(restArgs);
+      await runUpdate(input, options);
+      break;
+    }
+    case "del":
+    case "delete":
+    case "d": {
+      showLogo();
+      console.log();
+      const { serverNames, options } = parseDelOptions(restArgs);
+      await runDel(serverNames, options);
+      break;
+    }
+    case "list":
+    case "ls":
+    case "l": {
+      showLogo();
+      console.log();
+      const options = parseListOptions(restArgs);
+      await runList(options);
+      break;
+    }
+    case "find":
+    case "search":
+    case "f": {
+      showLogo();
+      await runFind(restArgs);
+      break;
+    }
+    case "sync":
+    case "s": {
+      showLogo();
+      console.log();
+      const options = parseSyncOptions(restArgs);
+      if (options) {
+        await runSync(options);
+      }
+      break;
+    }
+    case "--help":
+    case "-h":
+    case "help":
+      showHelp();
+      break;
+    case "--version":
+    case "-v":
+      console.log(VERSION);
+      break;
+    default:
+      console.log(`Unknown command: ${command}`);
+      console.log(`Run ${BOLD}mcpcm --help${RESET} for usage.`);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});