mcpman 1.0.0 → 2.0.0

package/dist/{chunk-6GGMDJQE.js → chunk-CYYW35D2.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getRollbackDir
-} from "./chunk-DSCBWQ3W.js";
+} from "./chunk-HQO4AO6B.js";
 
 // src/core/lockfile.ts
 import fs2 from "fs";

package/dist/{chunk-DSCBWQ3W.js → chunk-HQO4AO6B.js}

@@ -77,6 +77,29 @@ function resolveConfigPath(client) {
         return path.join(appData, "Code", "User", "settings.json");
       }
       return path.join(home, ".config", "Code", "User", "settings.json");
+    case "claude-code":
+      return path.join(home, ".claude", ".mcp.json");
+    case "roo-code":
+      return path.join(
+        appData,
+        "Code",
+        "User",
+        "globalStorage",
+        "rooveterinaryinc.roo-cline",
+        "settings",
+        "mcp_settings.json"
+      );
+    case "codex-cli":
+      return path.join(home, ".codex", "config.toml");
+    case "opencode":
+      return path.join(home, ".config", "opencode", "opencode.json");
+    case "continue":
+      return path.join(home, ".continue", "config.yaml");
+    case "zed":
+      if (process.platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Zed", "settings.json");
+      }
+      return path.join(home, ".config", "zed", "settings.json");
   }
 }
 

package/dist/chunk-K3NQKI34.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-NFQMBLT3.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import {
+  resolveConfigPath
+} from "./chunk-HQO4AO6B.js";
+
+// src/clients/base-client-handler.ts
+import fs from "fs";
+import path from "path";
+
+// src/clients/types.ts
+var ConfigParseError = class extends Error {
+  constructor(configPath, cause) {
+    super(`Failed to parse config: ${configPath} \u2014 ${String(cause)}`);
+    this.configPath = configPath;
+    this.name = "ConfigParseError";
+  }
+};
+var 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 fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await fs.promises.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs.promises.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function pathExists(p) {
+  try {
+    await fs.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var BaseClientHandler = class {
+  async isInstalled() {
+    const dir = path.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 fs.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/clients/claude-code.ts
+var ClaudeCodeHandler = class extends BaseClientHandler {
+  type = "claude-code";
+  displayName = "Claude Code";
+  getConfigPath() {
+    return resolveConfigPath("claude-code");
+  }
+};
+
+// src/clients/claude-desktop.ts
+var ClaudeDesktopHandler = class extends BaseClientHandler {
+  type = "claude-desktop";
+  displayName = "Claude Desktop";
+  getConfigPath() {
+    return resolveConfigPath("claude-desktop");
+  }
+};
+
+// src/clients/codex-cli.ts
+import fs2 from "fs";
+import TOML from "@iarna/toml";
+var CodexCliHandler = class extends BaseClientHandler {
+  type = "codex-cli";
+  displayName = "Codex CLI";
+  getConfigPath() {
+    return resolveConfigPath("codex-cli");
+  }
+  async readRaw() {
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await fs2.promises.readFile(configPath, "utf-8");
+      return TOML.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw new ConfigParseError(configPath, err);
+    }
+  }
+  async writeRaw(data) {
+    const configPath = this.getConfigPath();
+    try {
+      await atomicWrite(configPath, TOML.stringify(data));
+    } catch (err) {
+      throw new ConfigWriteError(configPath, err);
+    }
+  }
+  toClientConfig(raw) {
+    const mcpServers = raw.mcp_servers ?? {};
+    return { servers: mcpServers };
+  }
+  fromClientConfig(raw, config) {
+    return { ...raw, mcp_servers: config.servers };
+  }
+};
+
+// src/clients/continue-client.ts
+import fs3 from "fs";
+import YAML from "yaml";
+var ContinueHandler = class extends BaseClientHandler {
+  type = "continue";
+  displayName = "Continue";
+  getConfigPath() {
+    return resolveConfigPath("continue");
+  }
+  async readRaw() {
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await fs3.promises.readFile(configPath, "utf-8");
+      return YAML.parse(raw) ?? {};
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw new ConfigParseError(configPath, err);
+    }
+  }
+  async writeRaw(data) {
+    const configPath = this.getConfigPath();
+    try {
+      await atomicWrite(configPath, YAML.stringify(data));
+    } catch (err) {
+      throw new ConfigWriteError(configPath, err);
+    }
+  }
+  toClientConfig(raw) {
+    const mcpArray = raw.mcpServers ?? [];
+    const serverMap = /* @__PURE__ */ new Map();
+    for (const entry of mcpArray) {
+      const { name, ...rest } = entry;
+      serverMap.set(name, rest);
+    }
+    const servers = Object.fromEntries(serverMap);
+    return { servers };
+  }
+  fromClientConfig(raw, config) {
+    const mcpArray = Object.entries(config.servers).map(([name, entry]) => ({
+      name,
+      ...entry
+    }));
+    return { ...raw, mcpServers: mcpArray };
+  }
+};
+
+// src/clients/cursor.ts
+var CursorHandler = class extends BaseClientHandler {
+  type = "cursor";
+  displayName = "Cursor";
+  getConfigPath() {
+    return resolveConfigPath("cursor");
+  }
+};
+
+// src/clients/opencode.ts
+var OpenCodeHandler = class extends BaseClientHandler {
+  type = "opencode";
+  displayName = "OpenCode";
+  getConfigPath() {
+    return resolveConfigPath("opencode");
+  }
+  toClientConfig(raw) {
+    const mcp = raw.mcp ?? {};
+    const servers = {};
+    for (const [name, entry] of Object.entries(mcp)) {
+      const cmdArray = entry.command ?? [];
+      if (cmdArray.length === 0) continue;
+      servers[name] = {
+        command: cmdArray[0],
+        args: cmdArray.slice(1),
+        ...entry.environment ? { env: entry.environment } : {}
+      };
+    }
+    return { servers };
+  }
+  fromClientConfig(raw, config) {
+    const existingMcp = raw.mcp ?? {};
+    const mcp = {};
+    for (const [name, entry] of Object.entries(config.servers)) {
+      if (!entry.command) continue;
+      const existingEnabled = existingMcp[name]?.enabled;
+      const enabled = existingEnabled !== void 0 ? existingEnabled : true;
+      mcp[name] = {
+        type: "local",
+        command: [entry.command, ...entry.args ?? []],
+        enabled,
+        ...entry.env ? { environment: entry.env } : {}
+      };
+    }
+    const { mcp: _existing, ...rest } = raw;
+    return { ...rest, mcp };
+  }
+};
+
+// src/clients/roo-code.ts
+var RooCodeHandler = class extends BaseClientHandler {
+  type = "roo-code";
+  displayName = "Roo Code";
+  getConfigPath() {
+    return resolveConfigPath("roo-code");
+  }
+};
+
+// src/clients/vscode.ts
+var 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 = class extends BaseClientHandler {
+  type = "windsurf";
+  displayName = "Windsurf";
+  getConfigPath() {
+    return resolveConfigPath("windsurf");
+  }
+};
+
+// src/clients/zed.ts
+var ZedHandler = class extends BaseClientHandler {
+  type = "zed";
+  displayName = "Zed";
+  getConfigPath() {
+    return resolveConfigPath("zed");
+  }
+  toClientConfig(raw) {
+    const contextServers = raw.context_servers ?? {};
+    return { servers: contextServers };
+  }
+  fromClientConfig(raw, config) {
+    return { ...raw, context_servers: config.servers };
+  }
+};
+
+// src/clients/client-detector.ts
+function getAllClientTypes() {
+  return [
+    "claude-desktop",
+    "cursor",
+    "vscode",
+    "windsurf",
+    "claude-code",
+    "roo-code",
+    "codex-cli",
+    "opencode",
+    "continue",
+    "zed"
+  ];
+}
+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();
+    case "claude-code":
+      return new ClaudeCodeHandler();
+    case "roo-code":
+      return new RooCodeHandler();
+    case "codex-cli":
+      return new CodexCliHandler();
+    case "opencode":
+      return new OpenCodeHandler();
+    case "continue":
+      return new ContinueHandler();
+    case "zed":
+      return new ZedHandler();
+  }
+}
+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);
+}
+
+export {
+  getAllClientTypes,
+  getClient,
+  getInstalledClients
+};

package/dist/{client-detector-O2HN4MUB.js → client-detector-TSWWOALP.js}

@@ -3,8 +3,9 @@ import {
   getAllClientTypes,
   getClient,
   getInstalledClients
-} from "./chunk-CC7ICP7U.js";
-import "./chunk-DSCBWQ3W.js";
+} from "./chunk-NFQMBLT3.js";
+import "./chunk-HQO4AO6B.js";
+import "./chunk-K3NQKI34.js";
 export {
   getAllClientTypes,
   getClient,