mcpman 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1407 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/clients/types.ts
+var ConfigParseError, ConfigWriteError;
+var init_types = __esm({
+  "src/clients/types.ts"() {
+    "use strict";
+    init_cjs_shims();
+    ConfigParseError = class extends Error {
+      constructor(configPath, cause) {
+        super(`Failed to parse config: ${configPath} \u2014 ${String(cause)}`);
+        this.configPath = configPath;
+        this.name = "ConfigParseError";
+      }
+    };
+    ConfigWriteError = class extends Error {
+      constructor(configPath, cause) {
+        super(`Failed to write config: ${configPath} \u2014 ${String(cause)}`);
+        this.configPath = configPath;
+        this.name = "ConfigWriteError";
+      }
+    };
+  }
+});
+
+// src/clients/base-client-handler.ts
+async function atomicWrite(filePath, content) {
+  const tmpPath = `${filePath}.tmp`;
+  try {
+    await import_node_fs.default.promises.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+    await import_node_fs.default.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await import_node_fs.default.promises.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await import_node_fs.default.promises.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function pathExists(p5) {
+  try {
+    await import_node_fs.default.promises.access(p5);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var import_node_fs, import_node_path, BaseClientHandler;
+var init_base_client_handler = __esm({
+  "src/clients/base-client-handler.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs = __toESM(require("fs"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    init_types();
+    BaseClientHandler = class {
+      async isInstalled() {
+        const dir = import_node_path.default.dirname(this.getConfigPath());
+        return pathExists(dir);
+      }
+      /** Read raw JSON from disk, return empty object if file missing */
+      async readRaw() {
+        const configPath = this.getConfigPath();
+        try {
+          const raw = await import_node_fs.default.promises.readFile(configPath, "utf-8");
+          return JSON.parse(raw);
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return {};
+          }
+          throw new ConfigParseError(configPath, err);
+        }
+      }
+      /** Serialize raw object to disk atomically */
+      async writeRaw(data) {
+        const configPath = this.getConfigPath();
+        try {
+          await atomicWrite(configPath, JSON.stringify(data, null, 2));
+        } catch (err) {
+          throw new ConfigWriteError(configPath, err);
+        }
+      }
+      /** Convert raw JSON to ClientConfig — override for non-standard formats */
+      toClientConfig(raw) {
+        const mcpServers = raw.mcpServers ?? {};
+        return { servers: mcpServers };
+      }
+      /** Merge ClientConfig back into raw JSON — override for non-standard formats */
+      fromClientConfig(raw, config) {
+        return { ...raw, mcpServers: config.servers };
+      }
+      async readConfig() {
+        const raw = await this.readRaw();
+        return this.toClientConfig(raw);
+      }
+      async writeConfig(config) {
+        const raw = await this.readRaw();
+        await this.writeRaw(this.fromClientConfig(raw, config));
+      }
+      async addServer(name, entry) {
+        const config = await this.readConfig();
+        config.servers[name] = entry;
+        await this.writeConfig(config);
+      }
+      async removeServer(name) {
+        const config = await this.readConfig();
+        delete config.servers[name];
+        await this.writeConfig(config);
+      }
+    };
+  }
+});
+
+// src/utils/paths.ts
+function getHomedir() {
+  return import_node_os.default.homedir();
+}
+function getAppDataDir() {
+  const home = getHomedir();
+  if (process.platform === "darwin") {
+    return import_node_path2.default.join(home, "Library", "Application Support");
+  }
+  if (process.platform === "win32") {
+    return process.env.APPDATA ?? import_node_path2.default.join(home, "AppData", "Roaming");
+  }
+  return process.env.XDG_CONFIG_HOME ?? import_node_path2.default.join(home, ".config");
+}
+function resolveConfigPath(client) {
+  const appData = getAppDataDir();
+  const home = getHomedir();
+  switch (client) {
+    case "claude-desktop":
+      return import_node_path2.default.join(appData, "Claude", "claude_desktop_config.json");
+    case "cursor":
+      return import_node_path2.default.join(
+        appData,
+        "Cursor",
+        "User",
+        "globalStorage",
+        "cursor.mcp",
+        "mcp.json"
+      );
+    case "windsurf":
+      return import_node_path2.default.join(
+        appData,
+        "Windsurf",
+        "User",
+        "globalStorage",
+        "windsurf.mcpConfigJson",
+        "mcp.json"
+      );
+    case "vscode":
+      if (process.platform === "darwin") {
+        return import_node_path2.default.join(appData, "Code", "User", "settings.json");
+      }
+      if (process.platform === "win32") {
+        return import_node_path2.default.join(appData, "Code", "User", "settings.json");
+      }
+      return import_node_path2.default.join(home, ".config", "Code", "User", "settings.json");
+  }
+}
+var import_node_os, import_node_path2;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_os = __toESM(require("os"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
+  }
+});
+
+// src/clients/claude-desktop.ts
+var ClaudeDesktopHandler;
+var init_claude_desktop = __esm({
+  "src/clients/claude-desktop.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_base_client_handler();
+    init_paths();
+    ClaudeDesktopHandler = class extends BaseClientHandler {
+      type = "claude-desktop";
+      displayName = "Claude Desktop";
+      getConfigPath() {
+        return resolveConfigPath("claude-desktop");
+      }
+    };
+  }
+});
+
+// src/clients/cursor.ts
+var CursorHandler;
+var init_cursor = __esm({
+  "src/clients/cursor.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_base_client_handler();
+    init_paths();
+    CursorHandler = class extends BaseClientHandler {
+      type = "cursor";
+      displayName = "Cursor";
+      getConfigPath() {
+        return resolveConfigPath("cursor");
+      }
+    };
+  }
+});
+
+// src/clients/vscode.ts
+var VSCodeHandler;
+var init_vscode = __esm({
+  "src/clients/vscode.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_base_client_handler();
+    init_paths();
+    VSCodeHandler = class extends BaseClientHandler {
+      type = "vscode";
+      displayName = "VS Code";
+      getConfigPath() {
+        return resolveConfigPath("vscode");
+      }
+      toClientConfig(raw) {
+        const mcp = raw.mcp ?? {};
+        const servers = mcp.servers ?? {};
+        return { servers };
+      }
+      fromClientConfig(raw, config) {
+        const existingMcp = raw.mcp ?? {};
+        return {
+          ...raw,
+          mcp: { ...existingMcp, servers: config.servers }
+        };
+      }
+    };
+  }
+});
+
+// src/clients/windsurf.ts
+var WindsurfHandler;
+var init_windsurf = __esm({
+  "src/clients/windsurf.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_base_client_handler();
+    init_paths();
+    WindsurfHandler = class extends BaseClientHandler {
+      type = "windsurf";
+      displayName = "Windsurf";
+      getConfigPath() {
+        return resolveConfigPath("windsurf");
+      }
+    };
+  }
+});
+
+// src/clients/client-detector.ts
+var client_detector_exports = {};
+__export(client_detector_exports, {
+  getAllClientTypes: () => getAllClientTypes,
+  getClient: () => getClient,
+  getInstalledClients: () => getInstalledClients
+});
+function getAllClientTypes() {
+  return ["claude-desktop", "cursor", "vscode", "windsurf"];
+}
+function getClient(type) {
+  switch (type) {
+    case "claude-desktop":
+      return new ClaudeDesktopHandler();
+    case "cursor":
+      return new CursorHandler();
+    case "vscode":
+      return new VSCodeHandler();
+    case "windsurf":
+      return new WindsurfHandler();
+  }
+}
+async function getInstalledClients() {
+  const all = getAllClientTypes().map(getClient);
+  const results = await Promise.all(
+    all.map(async (handler) => ({ handler, installed: await handler.isInstalled() }))
+  );
+  return results.filter((r) => r.installed).map((r) => r.handler);
+}
+var init_client_detector = __esm({
+  "src/clients/client-detector.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_claude_desktop();
+    init_cursor();
+    init_vscode();
+    init_windsurf();
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+var import_citty6 = require("citty");
+
+// src/commands/doctor.ts
+init_cjs_shims();
+var import_citty = require("citty");
+var import_picocolors = __toESM(require("picocolors"), 1);
+
+// src/core/server-inventory.ts
+init_cjs_shims();
+init_client_detector();
+async function getInstalledServers(clientFilter) {
+  const clients = await getInstalledClients();
+  const filtered = clientFilter ? clients.filter((c) => c.type === clientFilter) : clients;
+  const serverMap = /* @__PURE__ */ new Map();
+  for (const client of filtered) {
+    let config;
+    try {
+      config = await client.readConfig();
+    } catch {
+      continue;
+    }
+    for (const [name, entry] of Object.entries(config.servers)) {
+      const existing = serverMap.get(name);
+      if (existing) {
+        if (!existing.clients.includes(client.type)) {
+          existing.clients.push(client.type);
+        }
+      } else {
+        serverMap.set(name, {
+          name,
+          clients: [client.type],
+          config: entry,
+          status: "unknown"
+        });
+      }
+    }
+  }
+  return Array.from(serverMap.values());
+}
+
+// src/core/health-checker.ts
+init_cjs_shims();
+
+// src/core/diagnostics.ts
+init_cjs_shims();
+var import_node_util = require("util");
+var import_node_child_process2 = require("child_process");
+
+// src/core/mcp-process-checks.ts
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+async function checkProcessSpawn(command, args, env, timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill("SIGTERM");
+        resolve({ name: "Process", passed: true, message: "starts successfully (still running)" });
+      }
+    }, timeoutMs);
+    child.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ name: "Process", passed: false, message: `spawn error: ${err.message}` });
+      }
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        if (code === 0 || code === null) {
+          resolve({ name: "Process", passed: true, message: "exits cleanly" });
+        } else {
+          resolve({ name: "Process", passed: false, message: `exits with code ${code}` });
+        }
+      }
+    });
+  });
+}
+var MCP_INIT_REQUEST = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "mcpman-doctor", version: "0.1.0" }
+  }
+});
+async function checkMcpHandshake(command, args, env, timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const start = Date.now();
+    let stdout = "";
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const done = (result) => {
+      if (!settled) {
+        settled = true;
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        resolve(result);
+      }
+    };
+    const timer = setTimeout(() => {
+      done({ name: "MCP handshake", passed: false, message: "no response (timeout 5s)" });
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      done({ name: "MCP handshake", passed: false, message: `spawn error: ${err.message}` });
+    });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (parsed.jsonrpc === "2.0" && parsed.id === 1) {
+            clearTimeout(timer);
+            done({ name: "MCP handshake", passed: true, message: `responds in ${Date.now() - start}ms` });
+            return;
+          }
+        } catch {
+        }
+      }
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (!settled) {
+        done({ name: "MCP handshake", passed: false, message: `process exited with code ${code} before responding` });
+      }
+    });
+    child.stdin?.write(MCP_INIT_REQUEST + "\n");
+  });
+}
+
+// src/core/diagnostics.ts
+var execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+async function checkRuntime(command) {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  const runtimeCmd = command === "npx" ? "node" : command === "uvx" ? "python3" : command;
+  try {
+    const { stdout } = await execAsync(`${cmd} ${runtimeCmd}`);
+    const version = await getRuntimeVersion(runtimeCmd);
+    return {
+      name: "Runtime",
+      passed: true,
+      message: `${runtimeCmd}${version ? ` ${version}` : ""} (${stdout.trim()})`
+    };
+  } catch {
+    return {
+      name: "Runtime",
+      passed: false,
+      message: `${runtimeCmd} not found on PATH`,
+      fix: getInstallFix(runtimeCmd)
+    };
+  }
+}
+async function getRuntimeVersion(cmd) {
+  try {
+    const flag = cmd === "docker" ? "version --format '{{.Client.Version}}'" : "--version";
+    const { stdout } = await execAsync(`${cmd} ${flag}`);
+    const match = stdout.match(/\d+\.\d+[\.\d]*/);
+    return match ? `v${match[0]}` : "";
+  } catch {
+    return "";
+  }
+}
+function getInstallFix(cmd) {
+  const isMac = process.platform === "darwin";
+  const isWin = process.platform === "win32";
+  switch (cmd) {
+    case "node":
+      return isMac ? "brew install node" : isWin ? "winget install NodeJS" : "apt install nodejs";
+    case "python3":
+    case "python":
+      return isMac ? "brew install python" : isWin ? "winget install Python" : "apt install python3";
+    case "docker":
+      return isMac ? "brew install --cask docker" : isWin ? "winget install Docker.DockerDesktop" : "apt install docker.io";
+    default:
+      return `Install ${cmd} and ensure it's on your PATH`;
+  }
+}
+function checkEnvVars(env) {
+  if (!env || Object.keys(env).length === 0) {
+    return { name: "Env vars", passed: true, message: "none required" };
+  }
+  const missing = [];
+  const placeholder = [];
+  const PLACEHOLDER_RE = /^(your[-_]|<|TODO|PLACEHOLDER|CHANGEME|xxx)/i;
+  for (const [key, value] of Object.entries(env)) {
+    const resolved = process.env[key] ?? value;
+    if (!resolved) {
+      missing.push(key);
+    } else if (PLACEHOLDER_RE.test(resolved)) {
+      placeholder.push(key);
+    }
+  }
+  if (missing.length > 0) {
+    return {
+      name: "Env vars",
+      passed: false,
+      message: `missing: ${missing.join(", ")}`,
+      fix: `Set environment variables: ${missing.map((k) => `${k}=<value>`).join(" ")}`
+    };
+  }
+  if (placeholder.length > 0) {
+    return {
+      name: "Env vars",
+      passed: true,
+      message: `may have placeholder values: ${placeholder.join(", ")} (check config)`
+    };
+  }
+  return { name: "Env vars", passed: true, message: `${Object.keys(env).length} var(s) set` };
+}
+
+// src/core/health-checker.ts
+async function checkServerHealth(name, config) {
+  const checks = [];
+  const runtimeCheck = await checkRuntime(config.command);
+  checks.push(runtimeCheck);
+  if (!runtimeCheck.passed) {
+    checks.push({ name: "Process", passed: false, skipped: true, message: "skipped (runtime missing)" });
+    checks.push({ name: "MCP handshake", passed: false, skipped: true, message: "skipped (runtime missing)" });
+  } else {
+    const spawnCheck = await checkProcessSpawn(
+      config.command,
+      config.args ?? [],
+      config.env ?? {}
+    );
+    checks.push(spawnCheck);
+    if (!spawnCheck.passed) {
+      checks.push({ name: "MCP handshake", passed: false, skipped: true, message: "skipped (process failed)" });
+    } else {
+      const handshakeCheck = await checkMcpHandshake(
+        config.command,
+        config.args ?? [],
+        config.env ?? {}
+      );
+      checks.push(handshakeCheck);
+    }
+  }
+  checks.push(checkEnvVars(config.env));
+  const failed = checks.filter((c) => !c.skipped && !c.passed);
+  const status = failed.length === 0 ? "healthy" : "unhealthy";
+  return { serverName: name, status, checks };
+}
+async function quickHealthProbe(config, timeoutMs = 3e3) {
+  try {
+    const runtimeCheck = await checkRuntime(config.command);
+    if (!runtimeCheck.passed) return "unhealthy";
+    const handshake = await checkMcpHandshake(
+      config.command,
+      config.args ?? [],
+      config.env ?? {},
+      timeoutMs
+    );
+    return handshake.passed ? "healthy" : "unhealthy";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/commands/doctor.ts
+var CHECK_ICON = {
+  pass: import_picocolors.default.green("\u2713"),
+  fail: import_picocolors.default.red("\u2717"),
+  skip: import_picocolors.default.dim("-"),
+  warn: import_picocolors.default.yellow("\u26A0")
+};
+var doctor_default = (0, import_citty.defineCommand)({
+  meta: {
+    name: "doctor",
+    description: "Check MCP server health and configuration"
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Show fix suggestions for detected issues",
+      default: false
+    }
+  },
+  async run({ args }) {
+    console.log(import_picocolors.default.bold("\n  mcpman doctor\n"));
+    const servers = await getInstalledServers();
+    if (servers.length === 0) {
+      console.log(import_picocolors.default.dim("  No MCP servers installed. Run mcpman install <server> to get started."));
+      return;
+    }
+    const tasks = servers.map((s) => () => checkServerHealth(s.name, s.config));
+    const results = await runParallel(tasks, 5);
+    let passed = 0;
+    let failed = 0;
+    for (const result of results) {
+      printServerResult(result, args.fix);
+      if (result.status === "healthy") passed++;
+      else failed++;
+    }
+    console.log(import_picocolors.default.dim("  " + "\u2500".repeat(50)));
+    const parts = [];
+    if (passed > 0) parts.push(import_picocolors.default.green(`${passed} healthy`));
+    if (failed > 0) parts.push(import_picocolors.default.red(`${failed} unhealthy`));
+    console.log(`  Summary: ${parts.join(", ")}`);
+    if (failed > 0) {
+      if (!args.fix) {
+        console.log(import_picocolors.default.dim(`  Run ${import_picocolors.default.cyan("mcpman doctor --fix")} for fix suggestions.
+`));
+      }
+      process.exit(1);
+    }
+    console.log();
+  }
+});
+function printServerResult(result, showFix) {
+  const icon = result.status === "healthy" ? import_picocolors.default.green("\u25CF") : import_picocolors.default.red("\u25CF");
+  console.log(`  ${icon} ${import_picocolors.default.bold(result.serverName)}`);
+  for (const check of result.checks) {
+    const checkIcon = check.skipped ? CHECK_ICON.skip : check.passed ? CHECK_ICON.pass : CHECK_ICON.fail;
+    console.log(`    ${checkIcon} ${check.name}: ${check.message}`);
+    if (showFix && !check.passed && !check.skipped && check.fix) {
+      console.log(`      ${import_picocolors.default.yellow("\u2192")} Fix: ${import_picocolors.default.cyan(check.fix)}`);
+    }
+  }
+  console.log();
+}
+async function runParallel(tasks, concurrency) {
+  const results = [];
+  const executing = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    const p5 = task().then((r) => {
+      results.push(r);
+      executing.delete(p5);
+    });
+    executing.add(p5);
+    if (executing.size >= concurrency) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+
+// src/commands/init.ts
+init_cjs_shims();
+var import_citty2 = require("citty");
+var p = __toESM(require("@clack/prompts"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/core/lockfile.ts
+init_cjs_shims();
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var LOCKFILE_NAME = "mcpman.lock";
+function findLockfile() {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = import_node_path3.default.join(dir, LOCKFILE_NAME);
+    if (import_node_fs2.default.existsSync(candidate)) return candidate;
+    const parent = import_node_path3.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getGlobalLockfilePath() {
+  return import_node_path3.default.join(import_node_os2.default.homedir(), ".mcpman", LOCKFILE_NAME);
+}
+function resolveLockfilePath() {
+  return findLockfile() ?? getGlobalLockfilePath();
+}
+function readLockfile(filePath) {
+  const target = filePath ?? resolveLockfilePath();
+  if (!import_node_fs2.default.existsSync(target)) {
+    return { lockfileVersion: 1, servers: {} };
+  }
+  try {
+    const raw = import_node_fs2.default.readFileSync(target, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { lockfileVersion: 1, servers: {} };
+  }
+}
+function serialize(data) {
+  const sorted = {
+    lockfileVersion: data.lockfileVersion,
+    servers: Object.fromEntries(
+      Object.entries(data.servers).sort(([a], [b]) => a.localeCompare(b))
+    )
+  };
+  return JSON.stringify(sorted, null, 2) + "\n";
+}
+function writeLockfile(data, filePath) {
+  const target = filePath ?? resolveLockfilePath();
+  const dir = import_node_path3.default.dirname(target);
+  if (!import_node_fs2.default.existsSync(dir)) {
+    import_node_fs2.default.mkdirSync(dir, { recursive: true });
+  }
+  const tmp = `${target}.tmp`;
+  import_node_fs2.default.writeFileSync(tmp, serialize(data), "utf-8");
+  import_node_fs2.default.renameSync(tmp, target);
+}
+function addEntry(name, entry, filePath) {
+  const data = readLockfile(filePath);
+  data.servers[name] = entry;
+  writeLockfile(data, filePath);
+}
+function createEmptyLockfile(filePath) {
+  writeLockfile({ lockfileVersion: 1, servers: {} }, filePath);
+}
+
+// src/core/registry.ts
+init_cjs_shims();
+var import_node_crypto = require("crypto");
+function computeIntegrity(resolvedUrl) {
+  const hash = (0, import_node_crypto.createHash)("sha512").update(resolvedUrl).digest("base64");
+  return `sha512-${hash}`;
+}
+async function resolveFromSmithery(name) {
+  const url = `https://registry.smithery.ai/servers/${encodeURIComponent(name)}`;
+  let data;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (res.status === 404) {
+      throw new Error(`Server '${name}' not found on Smithery registry`);
+    }
+    if (!res.ok) {
+      throw new Error(`Smithery API error: ${res.status}`);
+    }
+    data = await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) throw err;
+    throw new Error(
+      `Cannot reach Smithery registry: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const version = typeof data.version === "string" ? data.version : "latest";
+  const command = typeof data.command === "string" ? data.command : "npx";
+  const args = Array.isArray(data.args) ? data.args : ["-y", `${name}@${version}`];
+  const envVars = Array.isArray(data.envVars) ? data.envVars : [];
+  const resolved = typeof data.resolved === "string" ? data.resolved : `smithery:${name}@${version}`;
+  return {
+    name,
+    version,
+    description: typeof data.description === "string" ? data.description : "",
+    runtime: "node",
+    command,
+    args,
+    envVars,
+    resolved
+  };
+}
+async function resolveFromNpm(packageName) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+  let data;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (res.status === 404) {
+      throw new Error(`Package '${packageName}' not found on npm`);
+    }
+    if (!res.ok) {
+      throw new Error(`npm registry error: ${res.status}`);
+    }
+    data = await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) throw err;
+    throw new Error(
+      `Cannot reach npm registry: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const version = typeof data.version === "string" ? data.version : "latest";
+  const resolved = `https://registry.npmjs.org/${packageName}/-/${packageName.replace(/^@[^/]+\//, "")}-${version}.tgz`;
+  const mcpField = data.mcp && typeof data.mcp === "object" ? data.mcp : null;
+  const envVars = mcpField?.envVars ? mcpField.envVars : [];
+  return {
+    name: packageName,
+    version,
+    description: typeof data.description === "string" ? data.description : "",
+    runtime: "node",
+    command: "npx",
+    args: ["-y", `${packageName}@${version}`],
+    envVars,
+    resolved
+  };
+}
+async function resolveFromGitHub(githubUrl) {
+  const match = githubUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (!match) {
+    throw new Error(`Invalid GitHub URL: ${githubUrl}`);
+  }
+  const [, owner, repo] = match;
+  const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/package.json`;
+  let pkgData = {};
+  try {
+    const res = await fetch(rawUrl, { signal: AbortSignal.timeout(8e3) });
+    if (res.ok) {
+      pkgData = await res.json();
+    }
+  } catch {
+  }
+  const version = typeof pkgData.version === "string" ? pkgData.version : "main";
+  const name = typeof pkgData.name === "string" ? pkgData.name : `${owner}/${repo}`;
+  return {
+    name,
+    version,
+    description: typeof pkgData.description === "string" ? pkgData.description : "",
+    runtime: "node",
+    command: "npx",
+    args: ["-y", githubUrl],
+    envVars: [],
+    resolved: githubUrl
+  };
+}
+
+// src/commands/init.ts
+var init_default = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "init",
+    description: "Initialize mcpman.lock in the current project"
+  },
+  args: {},
+  async run() {
+    p.intro("mcpman init");
+    const targetPath = import_node_path4.default.join(process.cwd(), LOCKFILE_NAME);
+    const existing = findLockfile();
+    if (existing) {
+      p.log.warn(`Lockfile already exists: ${existing}`);
+      const overwrite = await p.confirm({ message: "Overwrite?" });
+      if (p.isCancel(overwrite) || !overwrite) {
+        p.outro("Cancelled.");
+        return;
+      }
+    }
+    let clients = [];
+    try {
+      const mod = await Promise.resolve().then(() => (init_client_detector(), client_detector_exports));
+      clients = await mod.getInstalledClients();
+    } catch {
+      p.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
+    }
+    const clientServers = [];
+    for (const client of clients) {
+      try {
+        const config = await client.readConfig();
+        if (Object.keys(config.servers).length > 0) {
+          clientServers.push({ client, servers: config.servers });
+        }
+      } catch {
+      }
+    }
+    createEmptyLockfile(targetPath);
+    if (clientServers.length === 0) {
+      p.log.info("No existing servers found in any client config.");
+      p.outro(`Created ${LOCKFILE_NAME} \u2014 add it to version control!`);
+      return;
+    }
+    const options = clientServers.map((cs) => ({
+      value: cs.client.type,
+      label: `${cs.client.displayName} (${Object.keys(cs.servers).length} servers)`
+    }));
+    const toImport = await p.multiselect({
+      message: "Import existing servers into lockfile?",
+      options,
+      required: false
+    });
+    if (p.isCancel(toImport)) {
+      p.outro(`Created empty ${LOCKFILE_NAME}`);
+      return;
+    }
+    const selected = toImport;
+    let importCount = 0;
+    for (const cs of clientServers) {
+      if (!selected.includes(cs.client.type)) continue;
+      for (const [name, entry] of Object.entries(cs.servers)) {
+        const resolved = `npm:${name}`;
+        const lockEntry = {
+          version: "unknown",
+          source: "npm",
+          resolved,
+          integrity: computeIntegrity(resolved),
+          runtime: "node",
+          command: entry.command,
+          args: entry.args ?? [],
+          envVars: Object.keys(entry.env ?? {}),
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          clients: [cs.client.type]
+        };
+        addEntry(name, lockEntry, targetPath);
+        importCount++;
+      }
+    }
+    p.outro(
+      `Created ${LOCKFILE_NAME} with ${importCount} server(s) \u2014 commit to version control!`
+    );
+  }
+});
+
+// src/commands/install.ts
+init_cjs_shims();
+var import_citty3 = require("citty");
+
+// src/core/installer.ts
+init_cjs_shims();
+var p2 = __toESM(require("@clack/prompts"), 1);
+
+// src/core/server-resolver.ts
+init_cjs_shims();
+function detectSource(input) {
+  if (input.startsWith("smithery:")) {
+    return { type: "smithery", input: input.slice(9) };
+  }
+  if (input.startsWith("https://github.com/") || input.startsWith("github.com/")) {
+    return { type: "github", input };
+  }
+  return { type: "npm", input };
+}
+function parseEnvFlags(envFlags) {
+  if (!envFlags) return {};
+  const flags = Array.isArray(envFlags) ? envFlags : [envFlags];
+  const result = {};
+  for (const flag of flags) {
+    const idx = flag.indexOf("=");
+    if (idx > 0) {
+      result[flag.slice(0, idx)] = flag.slice(idx + 1);
+    }
+  }
+  return result;
+}
+async function resolveServer(input) {
+  const source = detectSource(input);
+  switch (source.type) {
+    case "smithery":
+      return resolveFromSmithery(source.input);
+    case "github":
+      return resolveFromGitHub(source.input);
+    case "npm":
+      return resolveFromNpm(source.input);
+  }
+}
+
+// src/core/installer.ts
+async function loadClients() {
+  try {
+    const mod = await Promise.resolve().then(() => (init_client_detector(), client_detector_exports));
+    return mod.getInstalledClients();
+  } catch {
+    return [];
+  }
+}
+async function installServer(input, options = {}) {
+  p2.intro("mcpman install");
+  const spinner2 = p2.spinner();
+  spinner2.start("Resolving server...");
+  let metadata;
+  try {
+    metadata = await resolveServer(input);
+  } catch (err) {
+    spinner2.stop("Resolution failed");
+    p2.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  spinner2.stop(`Found: ${metadata.name}@${metadata.version}`);
+  const clients = await loadClients();
+  if (clients.length === 0) {
+    p2.log.warn("No supported AI clients detected on this machine.");
+    p2.log.info("Supported: Claude Desktop, Cursor, VS Code, Windsurf");
+    process.exit(1);
+  }
+  let selectedClients;
+  if (options.client) {
+    const found = clients.find((c) => c.type === options.client || c.displayName.toLowerCase() === options.client?.toLowerCase());
+    if (!found) {
+      p2.log.error(`Client '${options.client}' not found or not installed.`);
+      p2.log.info(`Available: ${clients.map((c) => c.type).join(", ")}`);
+      process.exit(1);
+    }
+    selectedClients = [found];
+  } else if (options.yes || clients.length === 1) {
+    selectedClients = clients;
+  } else {
+    const chosen = await p2.multiselect({
+      message: "Install to which client(s)?",
+      options: clients.map((c) => ({ value: c.type, label: c.displayName })),
+      required: true
+    });
+    if (p2.isCancel(chosen)) {
+      p2.outro("Cancelled.");
+      process.exit(0);
+    }
+    selectedClients = clients.filter((c) => chosen.includes(c.type));
+  }
+  const providedEnv = parseEnvFlags(options.env);
+  const collectedEnv = { ...providedEnv };
+  const requiredVars = metadata.envVars.filter((e) => e.required && !(e.name in collectedEnv));
+  for (const envVar of requiredVars) {
+    if (options.yes && envVar.default) {
+      collectedEnv[envVar.name] = envVar.default;
+      continue;
+    }
+    const val = await p2.text({
+      message: `${envVar.name}${envVar.description ? ` \u2014 ${envVar.description}` : ""}`,
+      placeholder: envVar.default ?? "",
+      validate: (v) => envVar.required && !v ? "Required" : void 0
+    });
+    if (p2.isCancel(val)) {
+      p2.outro("Cancelled.");
+      process.exit(0);
+    }
+    collectedEnv[envVar.name] = val;
+  }
+  const entry = {
+    command: metadata.command,
+    args: metadata.args,
+    ...Object.keys(collectedEnv).length > 0 ? { env: collectedEnv } : {}
+  };
+  spinner2.start("Writing config...");
+  const clientTypes = [];
+  for (const client of selectedClients) {
+    try {
+      await client.addServer(metadata.name, entry);
+      clientTypes.push(client.type);
+    } catch (err) {
+      spinner2.stop("Partial failure");
+      p2.log.warn(`Failed to write to ${client.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  spinner2.stop("Config written");
+  const source = detectSource(input);
+  const integrity = computeIntegrity(metadata.resolved);
+  addEntry(metadata.name, {
+    version: metadata.version,
+    source: source.type,
+    resolved: metadata.resolved,
+    integrity,
+    runtime: metadata.runtime,
+    command: metadata.command,
+    args: metadata.args,
+    envVars: metadata.envVars.map((e) => e.name),
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    clients: clientTypes
+  });
+  const lockPath = findLockfile() ?? "mcpman.lock (global)";
+  p2.log.success(`Lockfile updated: ${lockPath}`);
+  p2.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
+}
+
+// src/utils/logger.ts
+init_cjs_shims();
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+var noColor = process.env.NO_COLOR !== void 0 || process.argv.includes("--no-color");
+var isVerbose = process.argv.includes("--verbose");
+var isJson = process.argv.includes("--json");
+function colorize(fn, text2) {
+  return noColor ? text2 : fn(text2);
+}
+function info(message) {
+  if (isJson) return;
+  console.log(`${colorize(import_picocolors2.default.cyan, "i")} ${message}`);
+}
+function error(message) {
+  if (isJson) return;
+  console.error(`${colorize(import_picocolors2.default.red, "\u2717")} ${message}`);
+}
+function json(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/install.ts
+var p3 = __toESM(require("@clack/prompts"), 1);
+var install_default = (0, import_citty3.defineCommand)({
+  meta: {
+    name: "install",
+    description: "Install an MCP server into one or more AI clients"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name or package (e.g. @modelcontextprotocol/server-github, smithery:github)",
+      required: false
+    },
+    client: {
+      type: "string",
+      description: "Target client (claude-desktop, cursor, vscode, windsurf)"
+    },
+    env: {
+      type: "string",
+      description: "Environment variable KEY=VAL (can repeat)"
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompts",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!args.server) {
+      await restoreFromLockfile();
+      return;
+    }
+    await installServer(args.server, {
+      client: args.client,
+      env: args.env,
+      yes: args.yes
+    });
+  }
+});
+async function restoreFromLockfile() {
+  const lockPath = findLockfile();
+  if (!lockPath) {
+    error("No mcpman.lock found. Run 'mcpman init' first or provide a server name.");
+    process.exit(1);
+  }
+  const lockfile = readLockfile(lockPath);
+  const entries = Object.entries(lockfile.servers);
+  if (entries.length === 0) {
+    info("Lockfile is empty \u2014 nothing to restore.");
+    return;
+  }
+  p3.intro(`mcpman install (restore from ${lockPath})`);
+  p3.log.info(`Restoring ${entries.length} server(s)...`);
+  for (const [name, entry] of entries) {
+    const input = entry.source === "smithery" ? `smithery:${name}` : entry.source === "github" ? entry.resolved : name;
+    await installServer(input, {
+      client: entry.clients[0],
+      yes: true
+    });
+  }
+  p3.outro("Restore complete.");
+}
+
+// src/commands/list.ts
+init_cjs_shims();
+var import_citty4 = require("citty");
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var STATUS_ICON = {
+  healthy: import_picocolors3.default.green("\u25CF"),
+  unhealthy: import_picocolors3.default.red("\u25CF"),
+  unknown: import_picocolors3.default.dim("\u25CB")
+};
+var list_default = (0, import_citty4.defineCommand)({
+  meta: {
+    name: "list",
+    description: "List installed MCP servers"
+  },
+  args: {
+    client: {
+      type: "string",
+      description: "Filter by client (claude, cursor, vscode, windsurf)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const servers = await getInstalledServers(args.client);
+    if (servers.length === 0) {
+      const filter = args.client ? ` for client "${args.client}"` : "";
+      console.log(import_picocolors3.default.dim(`No MCP servers installed${filter}. Run ${import_picocolors3.default.cyan("mcpman install <server>")} to get started.`));
+      return;
+    }
+    const withStatus = await Promise.all(
+      servers.map(async (s) => ({
+        ...s,
+        status: await quickHealthProbe(s.config, 3e3)
+      }))
+    );
+    if (args.json) {
+      json({
+        servers: withStatus.map((s) => ({
+          name: s.name,
+          clients: s.clients,
+          status: s.status,
+          config: s.config
+        })),
+        total: withStatus.length
+      });
+      return;
+    }
+    const nameWidth = Math.max(4, ...withStatus.map((s) => s.name.length));
+    const clientsWidth = Math.max(7, ...withStatus.map((s) => formatClients(s.clients).length));
+    const header = `  ${pad("NAME", nameWidth)}  ${pad("CLIENT(S)", clientsWidth)}  ${pad("COMMAND", 20)}  STATUS`;
+    console.log(import_picocolors3.default.dim(header));
+    console.log(import_picocolors3.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`));
+    for (const s of withStatus) {
+      const icon = STATUS_ICON[s.status];
+      const clientsStr = formatClients(s.clients);
+      const cmdStr = truncate(`${s.config.command}${s.config.args ? " " + s.config.args.join(" ") : ""}`, 20);
+      console.log(`  ${pad(s.name, nameWidth)}  ${pad(clientsStr, clientsWidth)}  ${pad(cmdStr, 20)}  ${icon} ${s.status}`);
+    }
+    const clientSet = new Set(withStatus.flatMap((s) => s.clients));
+    console.log(import_picocolors3.default.dim(`
+  ${withStatus.length} server${withStatus.length !== 1 ? "s" : ""} \xB7 ${clientSet.size} client${clientSet.size !== 1 ? "s" : ""}`));
+  }
+});
+function pad(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+var CLIENT_DISPLAY = {
+  "claude-desktop": "Claude",
+  cursor: "Cursor",
+  vscode: "VS Code",
+  windsurf: "Windsurf"
+};
+function formatClients(clients) {
+  return clients.map((c) => CLIENT_DISPLAY[c] ?? c).join(", ");
+}
+
+// src/commands/remove.ts
+init_cjs_shims();
+var import_citty5 = require("citty");
+var p4 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+init_client_detector();
+var CLIENT_DISPLAY2 = {
+  "claude-desktop": "Claude",
+  cursor: "Cursor",
+  vscode: "VS Code",
+  windsurf: "Windsurf"
+};
+function clientDisplayName(type) {
+  return CLIENT_DISPLAY2[type] ?? type;
+}
+var remove_default = (0, import_citty5.defineCommand)({
+  meta: {
+    name: "remove",
+    description: "Remove an MCP server from one or more AI clients"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name to remove",
+      required: true
+    },
+    client: {
+      type: "string",
+      description: "Target client (claude, cursor, vscode, windsurf)"
+    },
+    all: {
+      type: "boolean",
+      description: "Remove from all clients",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    p4.intro(import_picocolors4.default.bold("mcpman remove"));
+    const serverName = args.server;
+    const servers = await getInstalledServers();
+    const match = servers.find((s) => s.name === serverName);
+    if (!match) {
+      p4.log.warn(`Server "${serverName}" is not installed.`);
+      const similar = servers.filter((s) => s.name.includes(serverName) || serverName.includes(s.name));
+      if (similar.length > 0) {
+        p4.log.info(`Did you mean: ${similar.map((s) => import_picocolors4.default.cyan(s.name)).join(", ")}?`);
+      }
+      p4.outro("Nothing to remove.");
+      return;
+    }
+    let targetClients;
+    if (args.all) {
+      targetClients = match.clients;
+    } else if (args.client) {
+      if (!match.clients.includes(args.client)) {
+        p4.log.warn(`Server "${serverName}" is not installed in client "${args.client}".`);
+        p4.outro("Nothing to remove.");
+        return;
+      }
+      targetClients = [args.client];
+    } else if (match.clients.length === 1) {
+      targetClients = match.clients;
+    } else {
+      const selected = await p4.multiselect({
+        message: `Remove "${serverName}" from which clients?`,
+        options: match.clients.map((c) => ({
+          value: c,
+          label: clientDisplayName(c)
+        })),
+        required: true
+      });
+      if (p4.isCancel(selected)) {
+        p4.outro("Cancelled.");
+        process.exit(0);
+      }
+      targetClients = selected;
+    }
+    if (!args.yes) {
+      const clientNames = targetClients.map(clientDisplayName).join(", ");
+      const confirmed = await p4.confirm({
+        message: `Remove ${import_picocolors4.default.cyan(serverName)} from ${import_picocolors4.default.yellow(clientNames)}?`
+      });
+      if (p4.isCancel(confirmed) || !confirmed) {
+        p4.outro("Cancelled.");
+        return;
+      }
+    }
+    const installedClients = await getInstalledClients();
+    const errors = [];
+    for (const clientType of targetClients) {
+      const handler = installedClients.find((c) => c.type === clientType);
+      if (!handler) {
+        errors.push(`Client "${clientType}" not found`);
+        continue;
+      }
+      try {
+        await handler.removeServer(serverName);
+        p4.log.success(`Removed from ${clientDisplayName(clientType)}`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`${clientDisplayName(clientType)}: ${msg}`);
+      }
+    }
+    if (errors.length > 0) {
+      for (const e of errors) p4.log.error(e);
+      p4.outro(import_picocolors4.default.red("Completed with errors."));
+      process.exit(1);
+    }
+    p4.outro(import_picocolors4.default.green(`Removed "${serverName}" successfully.`));
+  }
+});
+
+// src/utils/constants.ts
+init_cjs_shims();
+var APP_NAME = "mcpman";
+var APP_VERSION = "0.1.0";
+var APP_DESCRIPTION = "The package manager for MCP servers";
+
+// src/index.ts
+process.on("SIGINT", () => {
+  console.log("\nAborted.");
+  process.exit(130);
+});
+var main = (0, import_citty6.defineCommand)({
+  meta: {
+    name: APP_NAME,
+    version: APP_VERSION,
+    description: APP_DESCRIPTION
+  },
+  subCommands: {
+    install: install_default,
+    list: list_default,
+    remove: remove_default,
+    doctor: doctor_default,
+    init: init_default
+  }
+});
+(0, import_citty6.runMain)(main);