mcpsmgr 0.1.0

package/dist/index.js

@@ -0,0 +1,1631 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/utils/config.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { existsSync } from "fs";
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var BASE_DIR = join(homedir(), ".mcps-manager");
+var paths = {
+  baseDir: BASE_DIR,
+  serversDir: join(BASE_DIR, "servers"),
+  configFile: join(BASE_DIR, "config.json"),
+  serverFile: (name) => join(BASE_DIR, "servers", `${name}.json`)
+};
+
+// src/utils/config.ts
+async function readGlobalConfig() {
+  const raw = await readFile(paths.configFile, "utf-8");
+  return JSON.parse(raw);
+}
+async function writeGlobalConfig(config) {
+  if (!existsSync(paths.baseDir)) {
+    await mkdir(paths.baseDir, { recursive: true });
+    await chmod(paths.baseDir, 448);
+  }
+  await writeFile(paths.configFile, JSON.stringify(config, null, 2), "utf-8");
+  await chmod(paths.configFile, 384);
+}
+function configExists() {
+  return existsSync(paths.configFile);
+}
+
+// src/commands/setup.ts
+import { mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { input, select, confirm } from "@inquirer/prompts";
+
+// src/utils/prompt.ts
+function isUserCancellation(error) {
+  return error instanceof Error && error.name === "ExitPromptError";
+}
+
+// src/commands/setup.ts
+var GLM_ENDPOINTS = [
+  {
+    name: "Coding Plan (GLM-5)",
+    value: "https://open.bigmodel.cn/api/coding/paas/v4/chat/completions"
+  },
+  {
+    name: "General (GLM-5)",
+    value: "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+  }
+];
+async function setupCommand() {
+  try {
+    await setupCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function setupCommandInner() {
+  if (configExists()) {
+    const overwrite = await confirm({
+      message: "Configuration already exists. Overwrite?"
+    });
+    if (!overwrite) {
+      console.log("Setup cancelled.");
+      return;
+    }
+  }
+  if (!existsSync2(paths.baseDir)) {
+    await mkdir2(paths.baseDir, { recursive: true });
+    await chmod2(paths.baseDir, 448);
+  }
+  if (!existsSync2(paths.serversDir)) {
+    await mkdir2(paths.serversDir, { recursive: true });
+  }
+  const glmApiKey = await input({
+    message: "Enter GLM5 API Key:",
+    validate: (v) => v.trim().length > 0 ? true : "API key is required"
+  });
+  const glmEndpoint = await select({
+    message: "Select GLM5 endpoint:",
+    choices: GLM_ENDPOINTS.map((e) => ({ name: e.name, value: e.value }))
+  });
+  const config = {
+    glm: {
+      apiKey: glmApiKey.trim(),
+      endpoint: glmEndpoint
+    },
+    webReader: {
+      apiKey: glmApiKey.trim(),
+      url: "https://open.bigmodel.cn/api/mcp/web_reader/mcp"
+    }
+  };
+  await writeGlobalConfig(config);
+  console.log("Setup complete. Configuration saved to ~/.mcps-manager/config.json");
+}
+
+// src/commands/server-add.ts
+import { confirm as confirm2, input as input2, password } from "@inquirer/prompts";
+
+// src/utils/server-store.ts
+import { readFile as readFile2, writeFile as writeFile2, readdir, unlink, mkdir as mkdir3, chmod as chmod3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+async function readServerDefinition(name) {
+  const filePath = paths.serverFile(name);
+  if (!existsSync3(filePath)) {
+    return void 0;
+  }
+  const raw = await readFile2(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function writeServerDefinition(definition) {
+  if (!existsSync3(paths.serversDir)) {
+    await mkdir3(paths.serversDir, { recursive: true });
+  }
+  const filePath = paths.serverFile(definition.name);
+  await writeFile2(filePath, JSON.stringify(definition, null, 2), "utf-8");
+  await chmod3(filePath, 384);
+}
+async function removeServerDefinition(name) {
+  const filePath = paths.serverFile(name);
+  if (!existsSync3(filePath)) {
+    return false;
+  }
+  await unlink(filePath);
+  return true;
+}
+async function listServerDefinitions() {
+  if (!existsSync3(paths.serversDir)) {
+    return [];
+  }
+  const files = await readdir(paths.serversDir);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  const results = [];
+  for (const file of jsonFiles) {
+    const raw = await readFile2(
+      paths.serverFile(file.replace(".json", "")),
+      "utf-8"
+    );
+    results.push(JSON.parse(raw));
+  }
+  return results;
+}
+function serverExists(name) {
+  return existsSync3(paths.serverFile(name));
+}
+
+// src/services/web-reader.ts
+function parseSseResponse(raw) {
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data:")) {
+      return JSON.parse(line.slice(5));
+    }
+  }
+  return JSON.parse(raw);
+}
+async function mcpInitialize(endpoint, apiKey) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "mcpsmgr", version: "0.1.0" }
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `MCP initialize failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const sessionId = response.headers.get("mcp-session-id");
+  if (!sessionId) {
+    throw new Error("MCP server did not return session ID");
+  }
+  return sessionId;
+}
+async function mcpToolCall(endpoint, apiKey, sessionId, toolName, args) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${apiKey}`,
+      "Mcp-Session-Id": sessionId
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 2,
+      method: "tools/call",
+      params: { name: toolName, arguments: args }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `MCP tools/call failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const raw = await response.text();
+  const parsed = parseSseResponse(raw);
+  if (parsed.error) {
+    throw new Error(`MCP error: ${parsed.error.message}`);
+  }
+  const contents = parsed.result?.content ?? [];
+  const full = contents.map((c) => c.text).join("\n");
+  const MAX_CONTENT_LENGTH = 3e4;
+  if (full.length > MAX_CONTENT_LENGTH) {
+    return full.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Content truncated]";
+  }
+  return full;
+}
+var cachedSessionId;
+async function fetchWebContent(config, url) {
+  const endpoint = config.webReader.url;
+  const apiKey = config.webReader.apiKey;
+  if (!cachedSessionId) {
+    cachedSessionId = await mcpInitialize(endpoint, apiKey);
+  }
+  try {
+    return await mcpToolCall(endpoint, apiKey, cachedSessionId, "webReader", {
+      url,
+      timeout: 20
+    });
+  } catch {
+    cachedSessionId = await mcpInitialize(endpoint, apiKey);
+    return await mcpToolCall(endpoint, apiKey, cachedSessionId, "webReader", {
+      url,
+      timeout: 20
+    });
+  }
+}
+
+// src/services/system-prompt.ts
+var ANALYSIS_SYSTEM_PROMPT = `You are an MCP (Model Context Protocol) server configuration analyst. Your task is to analyze documentation for an MCP server and extract configuration details for 5 different coding agents.
+
+The 5 agents and their configuration differences:
+
+1. **Claude Code** (.mcp.json)
+   - Format: { "type": "stdio"|"http", "command": "...", "args": [...] }
+   - HTTP: { "type": "http", "url": "...", "headers": {...} }
+   - IMPORTANT: Do NOT use "env" field. Environment variables will be handled separately.
+
+2. **Codex CLI** (.codex/config.toml)
+   - TOML format: command = "...", args = [...]
+   - Same key names as Claude Code but in TOML
+   - IMPORTANT: Do NOT use "env" field.
+
+3. **Gemini CLI** (.gemini/settings.json)
+   - Format: { "command": "...", "args": [...] }
+   - No "type" field needed
+   - IMPORTANT: Do NOT use "env" field.
+
+4. **OpenCode** (opencode.json)
+   - Format: { "type": "local"|"remote", "command": ["cmd", "arg1", ...] }
+   - command is an ARRAY including the command itself
+   - type is "local" for stdio, "remote" for http
+   - IMPORTANT: Do NOT use "environment" field.
+
+5. **Antigravity** (~/.gemini/antigravity/mcp_config.json)
+   - Format: { "command": "...", "args": [...] }
+   - HTTP: { "serverUrl": "...", "headers": {...} } (note: "serverUrl" not "url")
+   - IMPORTANT: Do NOT use "env" field.
+
+You have access to a webReader tool to fetch web page content. Use it to read the documentation URL provided.
+
+After analyzing the documentation, return a JSON object with this exact structure:
+\`\`\`json
+{
+  "name": "server-name",
+  "default": {
+    "transport": "stdio",
+    "command": "npx",
+    "args": ["-y", "@scope/package"],
+  },
+  "overrides": {
+    "opencode": {
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "@scope/package"],
+      "env": {}
+    }
+  },
+  "requiredEnvVars": ["API_KEY"]
+}
+\`\`\`
+
+Rules:
+- "name" should be a kebab-case identifier for the server
+- "default" should be the most common configuration (usually works for Claude Code, Codex CLI, Gemini CLI)
+- Only add "overrides" for agents that need DIFFERENT configuration from the default
+- OpenCode usually needs an override because its command format differs (array vs string+args)
+- "requiredEnvVars" lists environment variable names the user needs to provide values for
+- Transport is either "stdio" or "http"
+- Return ONLY the JSON object, no markdown fences, no explanation`;
+
+// src/services/glm-client.ts
+var WEB_READER_TOOL = {
+  type: "function",
+  function: {
+    name: "webReader",
+    description: "Fetch and read the content of a web page given its URL",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL of the web page to read"
+        }
+      },
+      required: ["url"]
+    }
+  }
+};
+async function callGlm(config, messages) {
+  const response = await fetch(config.glm.endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.glm.apiKey}`
+    },
+    body: JSON.stringify({
+      model: "glm-5",
+      messages,
+      tools: [WEB_READER_TOOL],
+      tool_choice: "auto"
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `GLM5 API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+async function analyzeWithGlm(config, userMessage) {
+  const messages = [
+    { role: "system", content: ANALYSIS_SYSTEM_PROMPT },
+    { role: "user", content: userMessage }
+  ];
+  const MAX_ROUNDS = 10;
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    const response = await callGlm(config, messages);
+    const choice = response.choices.at(0);
+    if (!choice) {
+      throw new Error("GLM5 returned empty response");
+    }
+    const assistantMessage = choice.message;
+    messages.push({
+      role: "assistant",
+      content: assistantMessage.content,
+      tool_calls: assistantMessage.tool_calls
+    });
+    if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
+      return parseAnalysisResult(assistantMessage.content ?? "");
+    }
+    for (const toolCall of assistantMessage.tool_calls) {
+      if (toolCall.function.name === "webReader") {
+        const args = JSON.parse(toolCall.function.arguments);
+        let toolResult;
+        try {
+          toolResult = await fetchWebContent(config, args.url);
+        } catch (error) {
+          toolResult = `Error fetching URL: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        messages.push({
+          role: "tool",
+          content: toolResult,
+          tool_call_id: toolCall.id
+        });
+      }
+    }
+  }
+  throw new Error("GLM5 analysis exceeded maximum rounds");
+}
+function parseAnalysisResult(content) {
+  const cleaned = content.replace(/```json\s*/g, "").replace(/```\s*/g, "").trim();
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error(`Cannot extract JSON from GLM5 response: ${cleaned.slice(0, 200)}`);
+  }
+  const result = JSON.parse(jsonMatch[0]);
+  if (!result.name || !result.default) {
+    throw new Error("Invalid analysis result: missing name or default config");
+  }
+  return result;
+}
+function buildUserMessage(input3) {
+  if (isGitHubRepo(input3)) {
+    const url = `https://github.com/${input3}`;
+    return `Please analyze the MCP server at ${url}. Start by reading the README at ${url}/blob/main/README.md`;
+  }
+  return `Please analyze the MCP server documentation at: ${input3}`;
+}
+function isGitHubRepo(input3) {
+  if (input3.startsWith("http") || input3.startsWith("@")) {
+    return false;
+  }
+  const parts = input3.split("/");
+  return parts.length === 2 && parts.every((p) => p.length > 0);
+}
+function isValidInput(input3) {
+  if (input3.startsWith("http://") || input3.startsWith("https://")) {
+    return { valid: true };
+  }
+  if (isGitHubRepo(input3)) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    reason: 'Invalid input format. Provide a URL (https://...) or GitHub owner/repo (e.g., "anthropics/mcp-brave-search")'
+  };
+}
+
+// src/commands/server-add.ts
+async function serverAddCommand(source) {
+  try {
+    await serverAddCommandInner(source);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function serverAddCommandInner(source) {
+  const urlInput = source ?? await input2({
+    message: "Enter MCP server URL or GitHub owner/repo (leave empty for manual):"
+  });
+  if (urlInput.trim() === "") {
+    await manualAddFlow();
+    return;
+  }
+  const validation = isValidInput(urlInput.trim());
+  if (!validation.valid) {
+    console.error(`Error: ${validation.reason}`);
+    process.exitCode = 1;
+    return;
+  }
+  const config = await readGlobalConfig();
+  console.log("Analyzing documentation with GLM5...");
+  let analysis;
+  try {
+    const userMessage = buildUserMessage(urlInput.trim());
+    analysis = await analyzeWithGlm(config, userMessage);
+  } catch (error) {
+    console.error(
+      `GLM5 analysis failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    const fallback = await confirm2({
+      message: "Would you like to configure manually instead?"
+    });
+    if (fallback) {
+      await manualAddFlow();
+    }
+    return;
+  }
+  displayAnalysisResult(analysis, urlInput.trim());
+  const trust = await confirm2({
+    message: "Trust this analysis result?"
+  });
+  if (!trust) {
+    const manual = await confirm2({
+      message: "Configure manually instead?"
+    });
+    if (manual) {
+      await manualAddFlow();
+    }
+    return;
+  }
+  if (serverExists(analysis.name)) {
+    console.error(
+      `Error: Server "${analysis.name}" already exists. Run "mcpsmgr server remove ${analysis.name}" first.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const env = {};
+  for (const varName of analysis.requiredEnvVars) {
+    const value = await password({
+      message: `Enter value for ${varName} (stored locally, never sent to servers):`,
+      mask: "*"
+    });
+    env[varName] = value;
+  }
+  const defaultConfig = analysis.default.transport === "stdio" ? {
+    transport: "stdio",
+    command: analysis.default.command ?? "",
+    args: [...analysis.default.args ?? []],
+    env: { ...analysis.default.env ?? {}, ...env }
+  } : {
+    transport: "http",
+    url: analysis.default.url ?? "",
+    headers: { ...analysis.default.headers ?? {} }
+  };
+  const definition = {
+    name: analysis.name,
+    source: urlInput.trim(),
+    default: defaultConfig,
+    overrides: analysis.overrides
+  };
+  await writeServerDefinition(definition);
+  console.log(`Server "${analysis.name}" saved to central repository.`);
+}
+function displayAnalysisResult(result, source) {
+  console.log("\n--- Analysis Result ---");
+  console.log(`Name: ${result.name}`);
+  console.log(`Source: ${source}`);
+  console.log(`Transport: ${result.default.transport}`);
+  if (result.default.transport === "stdio") {
+    console.log(`Command: ${result.default.command}`);
+    console.log(`Args: ${JSON.stringify(result.default.args)}`);
+  } else {
+    console.log(`URL: ${result.default.url}`);
+  }
+  if (Object.keys(result.overrides).length > 0) {
+    console.log("Agent overrides:");
+    for (const [agent, override] of Object.entries(result.overrides)) {
+      console.log(`  ${agent}: ${JSON.stringify(override)}`);
+    }
+  }
+  if (result.requiredEnvVars.length > 0) {
+    console.log(
+      `Required env vars: ${result.requiredEnvVars.join(", ")}`
+    );
+  }
+  console.log("---\n");
+}
+async function manualAddFlow() {
+  const name = await input2({
+    message: "Server name (kebab-case):",
+    validate: (v) => /^[a-z][a-z0-9-]*$/.test(v.trim()) ? true : "Must be kebab-case"
+  });
+  if (serverExists(name.trim())) {
+    console.error(
+      `Error: Server "${name.trim()}" already exists. Run "mcpsmgr server remove ${name.trim()}" first.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const source = await input2({
+    message: "Source URL (optional):"
+  });
+  const command = await input2({
+    message: "Command (e.g., npx):",
+    validate: (v) => v.trim().length > 0 ? true : "Command is required"
+  });
+  const argsStr = await input2({
+    message: "Args (comma-separated, e.g., -y,@scope/package):"
+  });
+  const args = argsStr.trim().split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+  const envPairs = {};
+  let addMore = true;
+  while (addMore) {
+    const envName = await input2({
+      message: "Env var name (leave empty to finish):"
+    });
+    if (envName.trim() === "") break;
+    const envValue = await password({
+      message: `Value for ${envName.trim()} (stored locally, never sent to servers):`,
+      mask: "*"
+    });
+    envPairs[envName.trim()] = envValue;
+    addMore = true;
+  }
+  const config = {
+    transport: "stdio",
+    command: command.trim(),
+    args,
+    env: envPairs
+  };
+  const definition = {
+    name: name.trim(),
+    source: source.trim(),
+    default: config,
+    overrides: {}
+  };
+  await writeServerDefinition(definition);
+  console.log(`Server "${name.trim()}" saved to central repository.`);
+}
+
+// src/commands/server-remove.ts
+async function serverRemoveCommand(name) {
+  if (!serverExists(name)) {
+    console.error(`Error: Server "${name}" does not exist in central repository.`);
+    process.exitCode = 1;
+    return;
+  }
+  await removeServerDefinition(name);
+  console.log(`Server "${name}" removed from central repository.`);
+}
+
+// src/commands/server-list.ts
+async function serverListCommand() {
+  const servers = await listServerDefinitions();
+  if (servers.length === 0) {
+    console.log('No servers in central repository. Use "mcpsmgr server add" to add one.');
+    return;
+  }
+  console.log("\nCentral Repository Servers:\n");
+  for (const server2 of servers) {
+    const overrideCount = Object.keys(server2.overrides).length;
+    const overrideInfo = overrideCount > 0 ? ` (${overrideCount} overrides)` : "";
+    console.log(
+      `  ${server2.name} [${server2.default.transport}]${overrideInfo}`
+    );
+    if (server2.source) {
+      console.log(`    source: ${server2.source}`);
+    }
+  }
+  console.log();
+}
+
+// src/commands/init.ts
+import { checkbox, confirm as confirm3 } from "@inquirer/prompts";
+
+// src/adapters/index.ts
+import { existsSync as existsSync6 } from "fs";
+
+// src/adapters/claude-code.ts
+import { join as join2 } from "path";
+
+// src/adapters/json-file.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { dirname } from "path";
+async function readJsonFile(filePath) {
+  if (!existsSync4(filePath)) {
+    return {};
+  }
+  const raw = await readFile3(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function writeJsonFile(filePath, data) {
+  const dir = dirname(filePath);
+  if (!existsSync4(dir)) {
+    await mkdir4(dir, { recursive: true });
+  }
+  await writeFile3(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// src/adapters/env-args.ts
+var ENV_VAR_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*=/;
+function buildEnvArgs(env) {
+  return Object.entries(env).map(([key, value]) => `${key}=${value}`);
+}
+function parseEnvArgs(args) {
+  const env = {};
+  for (let i = 0; i < args.length; i++) {
+    if (ENV_VAR_PATTERN.test(args[i])) {
+      const eqIndex = args[i].indexOf("=");
+      env[args[i].slice(0, eqIndex)] = args[i].slice(eqIndex + 1);
+    } else {
+      return { env, commandIndex: i };
+    }
+  }
+  return { env, commandIndex: args.length };
+}
+function resolveEnvInArgs(args, env) {
+  const substitutedKeys = /* @__PURE__ */ new Set();
+  const resolvedArgs = args.map(
+    (arg) => arg.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+      if (varName in env) {
+        substitutedKeys.add(varName);
+        return env[varName];
+      }
+      return match;
+    })
+  );
+  const remainingEnv = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!substitutedKeys.has(key)) {
+      remainingEnv[key] = value;
+    }
+  }
+  return { resolvedArgs, remainingEnv };
+}
+
+// src/adapters/claude-code.ts
+function toAgentFormat(config) {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        type: "stdio",
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs]
+      };
+    }
+    return {
+      type: "stdio",
+      command: config.command,
+      args: resolvedArgs
+    };
+  }
+  return {
+    type: "http",
+    url: config.url,
+    headers: { ...config.headers }
+  };
+}
+function fromAgentFormat(_name, raw) {
+  const type = raw["type"];
+  if (type === "stdio") {
+    const command = raw["command"];
+    const rawArgs = raw["args"] ?? [];
+    const legacyEnv = raw["env"];
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      return { transport: "stdio", command, args: rawArgs, env: legacyEnv };
+    }
+    if (command === "env") {
+      const { env, commandIndex } = parseEnvArgs(rawArgs);
+      return {
+        transport: "stdio",
+        command: rawArgs[commandIndex] ?? "",
+        args: rawArgs.slice(commandIndex + 1),
+        env
+      };
+    }
+    return { transport: "stdio", command, args: rawArgs, env: {} };
+  }
+  if (type === "http") {
+    return {
+      transport: "http",
+      url: raw["url"],
+      headers: raw["headers"] ?? {}
+    };
+  }
+  return void 0;
+}
+var claudeCodeAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  configPath: (projectDir) => join2(projectDir, ".mcp.json"),
+  isGlobal: false,
+  toAgentFormat,
+  fromAgentFormat,
+  async read(projectDir) {
+    const filePath = join2(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    return data["mcpServers"] ?? {};
+  },
+  async write(projectDir, serverName, config) {
+    const filePath = join2(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Claude Code config`
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat(config) }
+    };
+    await writeJsonFile(filePath, updated);
+  },
+  async remove(projectDir, serverName) {
+    const filePath = join2(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(filePath, { ...data, mcpServers: rest });
+  },
+  async has(projectDir, serverName) {
+    const filePath = join2(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    return serverName in servers;
+  }
+};
+
+// src/adapters/codex-cli.ts
+import { join as join3 } from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { dirname as dirname2 } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function toAgentFormat2(config) {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs]
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs
+    };
+  }
+  return {
+    url: config.url,
+    headers: { ...config.headers }
+  };
+}
+function fromAgentFormat2(_name, raw) {
+  if (raw["command"]) {
+    const command = raw["command"];
+    const rawArgs = raw["args"] ?? [];
+    const legacyEnv = raw["env"];
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      return { transport: "stdio", command, args: rawArgs, env: legacyEnv };
+    }
+    if (command === "env") {
+      const { env, commandIndex } = parseEnvArgs(rawArgs);
+      return {
+        transport: "stdio",
+        command: rawArgs[commandIndex] ?? "",
+        args: rawArgs.slice(commandIndex + 1),
+        env
+      };
+    }
+    return { transport: "stdio", command, args: rawArgs, env: {} };
+  }
+  if (raw["url"]) {
+    return {
+      transport: "http",
+      url: raw["url"],
+      headers: raw["headers"] ?? {}
+    };
+  }
+  return void 0;
+}
+async function readTomlFile(filePath) {
+  if (!existsSync5(filePath)) {
+    return { raw: "", parsed: {} };
+  }
+  const raw = await readFile4(filePath, "utf-8");
+  const parsed = parseToml(raw);
+  return { raw, parsed };
+}
+async function writeTomlFile(filePath, data) {
+  const dir = dirname2(filePath);
+  if (!existsSync5(dir)) {
+    await mkdir5(dir, { recursive: true });
+  }
+  await writeFile4(filePath, stringifyToml(data) + "\n", "utf-8");
+}
+var codexCliAdapter = {
+  id: "codex-cli",
+  name: "Codex CLI",
+  configPath: (projectDir) => join3(projectDir, ".codex", "config.toml"),
+  isGlobal: false,
+  toAgentFormat: toAgentFormat2,
+  fromAgentFormat: fromAgentFormat2,
+  async read(projectDir) {
+    const filePath = join3(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    return parsed["mcp_servers"] ?? {};
+  },
+  async write(projectDir, serverName, config) {
+    const filePath = join3(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = parsed["mcp_servers"] ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Codex CLI config`
+      );
+    }
+    const updated = {
+      ...parsed,
+      mcp_servers: { ...servers, [serverName]: toAgentFormat2(config) }
+    };
+    await writeTomlFile(filePath, updated);
+  },
+  async remove(projectDir, serverName) {
+    const filePath = join3(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = parsed["mcp_servers"] ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeTomlFile(filePath, { ...parsed, mcp_servers: rest });
+  },
+  async has(projectDir, serverName) {
+    const filePath = join3(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = parsed["mcp_servers"] ?? {};
+    return serverName in servers;
+  }
+};
+
+// src/adapters/gemini-cli.ts
+import { join as join4 } from "path";
+function toAgentFormat3(config) {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs]
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs
+    };
+  }
+  return {
+    url: config.url,
+    headers: { ...config.headers }
+  };
+}
+function fromAgentFormat3(_name, raw) {
+  if (raw["command"]) {
+    const command = raw["command"];
+    const rawArgs = raw["args"] ?? [];
+    const legacyEnv = raw["env"];
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      return { transport: "stdio", command, args: rawArgs, env: legacyEnv };
+    }
+    if (command === "env") {
+      const { env, commandIndex } = parseEnvArgs(rawArgs);
+      return {
+        transport: "stdio",
+        command: rawArgs[commandIndex] ?? "",
+        args: rawArgs.slice(commandIndex + 1),
+        env
+      };
+    }
+    return { transport: "stdio", command, args: rawArgs, env: {} };
+  }
+  if (raw["url"]) {
+    return {
+      transport: "http",
+      url: raw["url"],
+      headers: raw["headers"] ?? {}
+    };
+  }
+  return void 0;
+}
+var geminiCliAdapter = {
+  id: "gemini-cli",
+  name: "Gemini CLI",
+  configPath: (projectDir) => join4(projectDir, ".gemini", "settings.json"),
+  isGlobal: false,
+  toAgentFormat: toAgentFormat3,
+  fromAgentFormat: fromAgentFormat3,
+  async read(projectDir) {
+    const filePath = join4(projectDir, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    return data["mcpServers"] ?? {};
+  },
+  async write(projectDir, serverName, config) {
+    const filePath = join4(projectDir, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Gemini CLI config`
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat3(config) }
+    };
+    await writeJsonFile(filePath, updated);
+  },
+  async remove(projectDir, serverName) {
+    const filePath = join4(projectDir, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(filePath, { ...data, mcpServers: rest });
+  },
+  async has(projectDir, serverName) {
+    const filePath = join4(projectDir, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcpServers"] ?? {};
+    return serverName in servers;
+  }
+};
+
+// src/adapters/opencode.ts
+import { join as join5 } from "path";
+function toAgentFormat4(config) {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        type: "local",
+        command: ["env", ...envArgs, config.command, ...resolvedArgs]
+      };
+    }
+    return {
+      type: "local",
+      command: [config.command, ...resolvedArgs]
+    };
+  }
+  return {
+    type: "remote",
+    url: config.url,
+    headers: { ...config.headers }
+  };
+}
+function fromAgentFormat4(_name, raw) {
+  const type = raw["type"];
+  if (type === "local") {
+    const commandArr = raw["command"];
+    const legacyEnv = raw["environment"];
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      const [command2 = "", ...args2] = commandArr;
+      return { transport: "stdio", command: command2, args: args2, env: legacyEnv };
+    }
+    if (commandArr[0] === "env") {
+      const { env, commandIndex } = parseEnvArgs(commandArr.slice(1));
+      const actualIndex = commandIndex + 1;
+      return {
+        transport: "stdio",
+        command: commandArr[actualIndex] ?? "",
+        args: commandArr.slice(actualIndex + 1),
+        env
+      };
+    }
+    const [command = "", ...args] = commandArr;
+    return { transport: "stdio", command, args, env: {} };
+  }
+  if (type === "remote") {
+    return {
+      transport: "http",
+      url: raw["url"],
+      headers: raw["headers"] ?? {}
+    };
+  }
+  return void 0;
+}
+var opencodeAdapter = {
+  id: "opencode",
+  name: "OpenCode",
+  configPath: (projectDir) => join5(projectDir, "opencode.json"),
+  isGlobal: false,
+  toAgentFormat: toAgentFormat4,
+  fromAgentFormat: fromAgentFormat4,
+  async read(projectDir) {
+    const filePath = join5(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    return data["mcp"] ?? {};
+  },
+  async write(projectDir, serverName, config) {
+    const filePath = join5(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcp"] ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in OpenCode config`
+      );
+    }
+    const updated = {
+      ...data,
+      mcp: { ...servers, [serverName]: toAgentFormat4(config) }
+    };
+    await writeJsonFile(filePath, updated);
+  },
+  async remove(projectDir, serverName) {
+    const filePath = join5(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcp"] ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(filePath, { ...data, mcp: rest });
+  },
+  async has(projectDir, serverName) {
+    const filePath = join5(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = data["mcp"] ?? {};
+    return serverName in servers;
+  }
+};
+
+// src/adapters/antigravity.ts
+import { homedir as homedir2 } from "os";
+import { join as join6 } from "path";
+var GLOBAL_CONFIG_PATH = join6(
+  homedir2(),
+  ".gemini",
+  "antigravity",
+  "mcp_config.json"
+);
+function toAgentFormat5(config) {
+  if (config.transport === "stdio") {
+    const { resolvedArgs, remainingEnv } = resolveEnvInArgs(
+      config.args,
+      config.env
+    );
+    const envArgs = buildEnvArgs(remainingEnv);
+    if (envArgs.length > 0) {
+      return {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs]
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs
+    };
+  }
+  return {
+    serverUrl: config.url,
+    headers: { ...config.headers }
+  };
+}
+function fromAgentFormat5(_name, raw) {
+  if (raw["command"]) {
+    const command = raw["command"];
+    const rawArgs = raw["args"] ?? [];
+    const legacyEnv = raw["env"];
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      return { transport: "stdio", command, args: rawArgs, env: legacyEnv };
+    }
+    if (command === "env") {
+      const { env, commandIndex } = parseEnvArgs(rawArgs);
+      return {
+        transport: "stdio",
+        command: rawArgs[commandIndex] ?? "",
+        args: rawArgs.slice(commandIndex + 1),
+        env
+      };
+    }
+    return { transport: "stdio", command, args: rawArgs, env: {} };
+  }
+  if (raw["serverUrl"]) {
+    return {
+      transport: "http",
+      url: raw["serverUrl"],
+      headers: raw["headers"] ?? {}
+    };
+  }
+  return void 0;
+}
+var antigravityAdapter = {
+  id: "antigravity",
+  name: "Antigravity",
+  configPath: () => GLOBAL_CONFIG_PATH,
+  isGlobal: true,
+  toAgentFormat: toAgentFormat5,
+  fromAgentFormat: fromAgentFormat5,
+  async read() {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    return data["mcpServers"] ?? {};
+  },
+  async write(_projectDir, serverName, config) {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    const servers = data["mcpServers"] ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Antigravity config`
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat5(config) }
+    };
+    await writeJsonFile(GLOBAL_CONFIG_PATH, updated);
+  },
+  async remove(_projectDir, serverName) {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    const servers = data["mcpServers"] ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(GLOBAL_CONFIG_PATH, { ...data, mcpServers: rest });
+  },
+  async has(_projectDir, serverName) {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    const servers = data["mcpServers"] ?? {};
+    return serverName in servers;
+  }
+};
+
+// src/adapters/index.ts
+var allAdapters = [
+  claudeCodeAdapter,
+  codexCliAdapter,
+  geminiCliAdapter,
+  opencodeAdapter,
+  antigravityAdapter
+];
+function detectAgents(projectDir) {
+  return allAdapters.filter((adapter) => {
+    if (adapter.isGlobal) {
+      return existsSync6(adapter.configPath(projectDir));
+    }
+    return existsSync6(adapter.configPath(projectDir));
+  });
+}
+
+// src/utils/resolve-config.ts
+function resolveConfig(definition, adapter) {
+  const override = definition.overrides[adapter.id];
+  if (override) {
+    const base = definition.default;
+    return { ...base, ...override };
+  }
+  return definition.default;
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  try {
+    await initCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function initCommandInner() {
+  const projectDir = process.cwd();
+  const servers = await listServerDefinitions();
+  if (servers.length === 0) {
+    console.log(
+      'Central repository is empty. Use "mcpsmgr server add" to add servers first.'
+    );
+    return;
+  }
+  const detected = detectAgents(projectDir);
+  const detectedIds = new Set(detected.map((a) => a.id));
+  const selectedAgents = await checkbox({
+    message: "Select agents to configure:",
+    choices: allAdapters.map((adapter) => ({
+      name: `${adapter.name}${detectedIds.has(adapter.id) ? " (detected)" : ""}${adapter.isGlobal ? " [global]" : ""}`,
+      value: adapter,
+      checked: detectedIds.has(adapter.id) && !adapter.isGlobal
+    }))
+  });
+  if (selectedAgents.length === 0) {
+    console.log("No agents selected.");
+    return;
+  }
+  const agentServerMap = /* @__PURE__ */ new Map();
+  const detectedServers = /* @__PURE__ */ new Set();
+  for (const agent of selectedAgents) {
+    try {
+      const existing = await agent.read(projectDir);
+      const names = new Set(Object.keys(existing));
+      agentServerMap.set(agent.id, names);
+      for (const name of names) {
+        detectedServers.add(name);
+      }
+    } catch {
+    }
+  }
+  const selectedServers = await checkbox({
+    message: "Select servers to deploy:",
+    choices: servers.map((s) => ({
+      name: `${s.name}${detectedServers.has(s.name) ? " (detected)" : ""} [${s.default.transport}]`,
+      value: s,
+      checked: detectedServers.has(s.name)
+    }))
+  });
+  const selectedServerNames = new Set(selectedServers.map((s) => s.name));
+  const removals = /* @__PURE__ */ new Map();
+  for (const serverName of detectedServers) {
+    if (!selectedServerNames.has(serverName)) {
+      const agents = selectedAgents.filter((a) => {
+        const agentServers = agentServerMap.get(a.id);
+        return agentServers?.has(serverName);
+      });
+      if (agents.length > 0) {
+        removals.set(serverName, agents);
+      }
+    }
+  }
+  if (selectedServers.length === 0 && removals.size === 0) {
+    console.log("No servers selected.");
+    return;
+  }
+  console.log("\nPlan:");
+  for (const agent of selectedAgents) {
+    console.log(`  ${agent.name}:`);
+    for (const server2 of selectedServers) {
+      console.log(`    + ${server2.name}`);
+    }
+    for (const [serverName, agents] of removals) {
+      if (agents.some((a) => a.id === agent.id)) {
+        console.log(`    - ${serverName}`);
+      }
+    }
+  }
+  const proceed = await confirm3({ message: "Proceed?" });
+  if (!proceed) {
+    console.log("Cancelled.");
+    return;
+  }
+  for (const agent of selectedAgents) {
+    for (const server2 of selectedServers) {
+      try {
+        const config = resolveConfig(server2, agent);
+        await agent.write(projectDir, server2.name, config);
+        console.log(`  + ${server2.name} -> ${agent.name}`);
+      } catch (error) {
+        console.warn(
+          `  ! ${server2.name} -> ${agent.name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  for (const [serverName, agents] of removals) {
+    for (const agent of agents) {
+      try {
+        await agent.remove(projectDir, serverName);
+        console.log(`  - ${serverName} <- ${agent.name}`);
+      } catch (error) {
+        console.warn(
+          `  ! ${serverName} <- ${agent.name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  console.log("\nDone.");
+}
+
+// src/commands/add.ts
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+async function addCommand(serverName) {
+  try {
+    await addCommandInner(serverName);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function addCommandInner(serverName) {
+  const projectDir = process.cwd();
+  if (!serverExists(serverName)) {
+    console.error(
+      `Error: Server "${serverName}" not found in central repository.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const definition = await readServerDefinition(serverName);
+  if (!definition) {
+    console.error(`Error: Failed to read server definition for "${serverName}".`);
+    process.exitCode = 1;
+    return;
+  }
+  const detected = detectAgents(projectDir);
+  if (detected.length === 0) {
+    console.log(
+      'No agent config files detected in this project. Use "mcpsmgr init" first.'
+    );
+    return;
+  }
+  const selectedAgents = await checkbox2({
+    message: `Select agents to add "${serverName}" to:`,
+    choices: detected.map((adapter) => ({
+      name: `${adapter.name}${adapter.isGlobal ? " [global]" : ""}`,
+      value: adapter,
+      checked: !adapter.isGlobal
+    }))
+  });
+  if (selectedAgents.length === 0) {
+    console.log("No agents selected.");
+    return;
+  }
+  for (const agent of selectedAgents) {
+    try {
+      const config = resolveConfig(definition, agent);
+      await agent.write(projectDir, serverName, config);
+      console.log(`  + ${serverName} -> ${agent.name}`);
+    } catch (error) {
+      console.warn(
+        `  ! ${serverName} -> ${agent.name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+// src/commands/remove.ts
+import { checkbox as checkbox3 } from "@inquirer/prompts";
+async function removeCommand(serverName) {
+  try {
+    await removeCommandInner(serverName);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function removeCommandInner(serverName) {
+  const projectDir = process.cwd();
+  const agentsWithServer = [];
+  for (const adapter of allAdapters) {
+    try {
+      const has = await adapter.has(projectDir, serverName);
+      if (has) {
+        agentsWithServer.push(adapter);
+      }
+    } catch {
+    }
+  }
+  if (agentsWithServer.length === 0) {
+    console.log(
+      `Server "${serverName}" not found in any agent configuration.`
+    );
+    return;
+  }
+  const selectedAgents = await checkbox3({
+    message: `Remove "${serverName}" from which agents?`,
+    choices: agentsWithServer.map((adapter) => ({
+      name: `${adapter.name}${adapter.isGlobal ? " [global]" : ""}`,
+      value: adapter,
+      checked: !adapter.isGlobal
+    }))
+  });
+  if (selectedAgents.length === 0) {
+    console.log("No agents selected.");
+    return;
+  }
+  for (const agent of selectedAgents) {
+    try {
+      await agent.remove(projectDir, serverName);
+      console.log(`  - ${serverName} <- ${agent.name}`);
+    } catch (error) {
+      console.warn(
+        `  ! ${serverName} <- ${agent.name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+// src/commands/sync.ts
+import { confirm as confirm4 } from "@inquirer/prompts";
+async function syncCommand() {
+  try {
+    await syncCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+async function syncCommandInner() {
+  const projectDir = process.cwd();
+  const definitions = await listServerDefinitions();
+  if (definitions.length === 0) {
+    console.log("Central repository is empty. Nothing to sync.");
+    return;
+  }
+  const changes = [];
+  for (const adapter of allAdapters) {
+    let servers;
+    try {
+      servers = await adapter.read(projectDir);
+    } catch {
+      continue;
+    }
+    for (const definition of definitions) {
+      if (!(definition.name in servers)) {
+        continue;
+      }
+      const currentRaw = servers[definition.name];
+      const desired = resolveConfig(definition, adapter);
+      const desiredRaw = adapter.toAgentFormat(desired);
+      if (JSON.stringify(currentRaw) !== JSON.stringify(desiredRaw)) {
+        changes.push({
+          agentName: adapter.name,
+          serverName: definition.name,
+          action: "update"
+        });
+      }
+    }
+  }
+  if (changes.length === 0) {
+    console.log("All agent configurations are up to date.");
+    return;
+  }
+  console.log("\nSync preview:");
+  for (const change of changes) {
+    console.log(`  ~ ${change.serverName} -> ${change.agentName}`);
+  }
+  const proceed = await confirm4({ message: "Apply changes?" });
+  if (!proceed) {
+    console.log("Cancelled.");
+    return;
+  }
+  for (const adapter of allAdapters) {
+    for (const definition of definitions) {
+      const relevant = changes.find(
+        (c) => c.agentName === adapter.name && c.serverName === definition.name
+      );
+      if (!relevant) continue;
+      try {
+        await adapter.remove(projectDir, definition.name);
+        const config = resolveConfig(definition, adapter);
+        await adapter.write(projectDir, definition.name, config);
+        console.log(`  ~ ${definition.name} -> ${adapter.name} (updated)`);
+      } catch (error) {
+        console.warn(
+          `  ! ${definition.name} -> ${adapter.name}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  console.log("\nSync complete.");
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  const projectDir = process.cwd();
+  const matrix = {};
+  const activeAdapters = [];
+  for (const adapter of allAdapters) {
+    let servers;
+    try {
+      servers = await adapter.read(projectDir);
+    } catch {
+      continue;
+    }
+    if (Object.keys(servers).length === 0) continue;
+    activeAdapters.push(adapter);
+    for (const [name, raw] of Object.entries(servers)) {
+      if (!matrix[name]) {
+        matrix[name] = {};
+      }
+      const config = adapter.fromAgentFormat(
+        name,
+        raw
+      );
+      matrix[name][adapter.id] = {
+        transport: config?.transport ?? "?"
+      };
+    }
+  }
+  if (Object.keys(matrix).length === 0) {
+    console.log(
+      'No MCP servers found in any agent configuration. Use "mcpsmgr init" to get started.'
+    );
+    return;
+  }
+  const serverNames = Object.keys(matrix).sort();
+  const agentIds = activeAdapters.map((a) => a.id);
+  const agentNames = activeAdapters.map((a) => a.name);
+  const colWidths = [
+    Math.max(6, ...serverNames.map((n) => n.length)),
+    ...agentNames.map((n) => Math.max(n.length, 5))
+  ];
+  const header = [
+    "Server".padEnd(colWidths.at(0) ?? 6),
+    ...agentNames.map((n, i) => n.padEnd(colWidths.at(i + 1) ?? 5))
+  ].join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  console.log(`
+${header}`);
+  console.log(separator);
+  for (const name of serverNames) {
+    const cells = [
+      name.padEnd(colWidths.at(0) ?? 6),
+      ...agentIds.map((id, i) => {
+        const entry = matrix[name][id];
+        const val = entry ? entry.transport : "-";
+        return val.padEnd(colWidths.at(i + 1) ?? 5);
+      })
+    ];
+    console.log(cells.join("  "));
+  }
+  console.log();
+}
+
+// src/index.ts
+function requireSetup() {
+  if (!configExists()) {
+    console.error(
+      'mcpsmgr is not configured. Run "mcpsmgr setup" first.'
+    );
+    process.exit(1);
+  }
+}
+program.name("mcpsmgr").description("Unified MCP server manager for multiple coding agents").version("0.1.0");
+program.command("setup").description("Initialize mcpsmgr configuration").action(setupCommand);
+var server = program.command("server").description("Manage MCP server definitions in central repository");
+server.command("add [source]").description("Add an MCP server (URL or GitHub owner/repo)").action((source) => {
+  requireSetup();
+  return serverAddCommand(source);
+});
+server.command("remove <name>").description("Remove an MCP server from central repository").action((name) => {
+  requireSetup();
+  return serverRemoveCommand(name);
+});
+server.command("list").description("List all servers in central repository").action(() => {
+  requireSetup();
+  return serverListCommand();
+});
+program.command("init").description("Initialize MCP servers for current project").action(() => {
+  requireSetup();
+  return initCommand();
+});
+program.command("add <server-name>").description("Add a server from central repository to current project").action((serverName) => {
+  requireSetup();
+  return addCommand(serverName);
+});
+program.command("remove <server-name>").description("Remove a server from current project agent configs").action((serverName) => {
+  requireSetup();
+  return removeCommand(serverName);
+});
+program.command("sync").description("Sync central repository changes to project agent configs").action(() => {
+  requireSetup();
+  return syncCommand();
+});
+program.command("list").description("List MCP servers across all agent configs in current project").action(() => {
+  requireSetup();
+  return listCommand();
+});
+program.parse();
+//# sourceMappingURL=index.js.map