mcpsmgr 0.1.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { ServerDefinition, StdioConfig } from "../types.js";
+import { claudeCodeAdapter } from "../adapters/claude-code.js";
+import { codexCliAdapter } from "../adapters/codex-cli.js";
+import { geminiCliAdapter } from "../adapters/gemini-cli.js";
+import { opencodeAdapter } from "../adapters/opencode.js";
+import { resolveConfig } from "../utils/resolve-config.js";
+import {
+  isGitHubRepo,
+  isValidInput,
+  buildUserMessage,
+} from "../services/glm-client.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "mcpsmgr-e2e-"));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true });
+});
+
+const sampleDefinition: ServerDefinition = {
+  name: "brave-search",
+  source: "https://github.com/anthropics/mcp-brave-search",
+  default: {
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "@anthropic/mcp-brave-search"],
+    env: { BRAVE_API_KEY: "test-key-123" },
+  },
+  overrides: {},
+};
+
+const definitionWithOverrides: ServerDefinition = {
+  name: "custom-mcp",
+  source: "https://example.com",
+  default: {
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "custom-mcp"],
+    env: { API_KEY: "default-key" },
+  },
+  overrides: {
+    "claude-code": {
+      transport: "http",
+      url: "https://example.com/mcp",
+      headers: { Authorization: "Bearer token" },
+    },
+  },
+};
+
+describe("E2E: server add -> deploy to agents -> list -> sync -> remove", () => {
+  it("deploys a server definition to all project-level adapters", async () => {
+    const adapters = [
+      claudeCodeAdapter,
+      codexCliAdapter,
+      geminiCliAdapter,
+      opencodeAdapter,
+    ];
+
+    for (const adapter of adapters) {
+      const config = resolveConfig(sampleDefinition, adapter);
+      await adapter.write(tmpDir, sampleDefinition.name, config);
+    }
+
+    const ccServers = await claudeCodeAdapter.read(tmpDir);
+    expect(ccServers["brave-search"]).toBeTruthy();
+
+    const codexServers = await codexCliAdapter.read(tmpDir);
+    expect(codexServers["brave-search"]).toBeTruthy();
+
+    const geminiServers = await geminiCliAdapter.read(tmpDir);
+    expect(geminiServers["brave-search"]).toBeTruthy();
+
+    const ocServers = await opencodeAdapter.read(tmpDir);
+    expect(ocServers["brave-search"]).toBeTruthy();
+
+    const ocConfig = ocServers["brave-search"] as Record<string, unknown>;
+    expect(ocConfig["type"]).toBe("local");
+    expect(ocConfig["command"]).toEqual([
+      "env",
+      "BRAVE_API_KEY=test-key-123",
+      "npx",
+      "-y",
+      "@anthropic/mcp-brave-search",
+    ]);
+  });
+
+  it("respects overrides per agent", async () => {
+    const ccConfig = resolveConfig(definitionWithOverrides, claudeCodeAdapter);
+    expect(ccConfig.transport).toBe("http");
+
+    const codexConfig = resolveConfig(definitionWithOverrides, codexCliAdapter);
+    expect(codexConfig.transport).toBe("stdio");
+  });
+
+  it("detects conflicts and prevents double-write", async () => {
+    await claudeCodeAdapter.write(tmpDir, "brave-search", sampleDefinition.default);
+    await expect(
+      claudeCodeAdapter.write(tmpDir, "brave-search", sampleDefinition.default),
+    ).rejects.toThrow("Conflict");
+  });
+
+  it("removes server from all adapters", async () => {
+    const adapters = [
+      claudeCodeAdapter,
+      codexCliAdapter,
+      geminiCliAdapter,
+      opencodeAdapter,
+    ];
+
+    for (const adapter of adapters) {
+      await adapter.write(tmpDir, "brave-search", sampleDefinition.default);
+    }
+
+    for (const adapter of adapters) {
+      await adapter.remove(tmpDir, "brave-search");
+      const has = await adapter.has(tmpDir, "brave-search");
+      expect(has).toBe(false);
+    }
+  });
+
+  it("sync: updates config after central repo change", async () => {
+    await claudeCodeAdapter.write(tmpDir, "brave-search", sampleDefinition.default);
+
+    const updatedConfig: StdioConfig = {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@anthropic/mcp-brave-search@2.0"],
+      env: { BRAVE_API_KEY: "new-key-456" },
+    };
+
+    await claudeCodeAdapter.remove(tmpDir, "brave-search");
+    await claudeCodeAdapter.write(tmpDir, "brave-search", updatedConfig);
+
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    const config = servers["brave-search"] as Record<string, unknown>;
+    expect(config["command"]).toBe("env");
+    expect(config["args"]).toEqual([
+      "BRAVE_API_KEY=new-key-456",
+      "npx",
+      "-y",
+      "@anthropic/mcp-brave-search@2.0",
+    ]);
+  });
+
+  it("preserves other content in config files", async () => {
+    const geminiPath = join(tmpDir, ".gemini", "settings.json");
+    await mkdir(join(tmpDir, ".gemini"), { recursive: true });
+    await writeFile(
+      geminiPath,
+      JSON.stringify({ theme: "dark", language: "en" }),
+    );
+
+    await geminiCliAdapter.write(tmpDir, "brave-search", sampleDefinition.default);
+
+    const raw = JSON.parse(await readFile(geminiPath, "utf-8"));
+    expect(raw["theme"]).toBe("dark");
+    expect(raw["language"]).toBe("en");
+    expect(raw["mcpServers"]["brave-search"]).toBeTruthy();
+  });
+});
+
+describe("Input validation", () => {
+  it("recognizes GitHub owner/repo format", () => {
+    expect(isGitHubRepo("anthropics/mcp-brave-search")).toBe(true);
+    expect(isGitHubRepo("https://github.com/foo/bar")).toBe(false);
+    expect(isGitHubRepo("@scope/package")).toBe(false);
+    expect(isGitHubRepo("bare-name")).toBe(false);
+  });
+
+  it("validates input formats", () => {
+    expect(isValidInput("https://example.com")).toEqual({ valid: true });
+    expect(isValidInput("anthropics/mcp")).toEqual({ valid: true });
+    expect(isValidInput("@scope/pkg")).toEqual({
+      valid: false,
+      reason: expect.any(String),
+    });
+    expect(isValidInput("bare-name")).toEqual({
+      valid: false,
+      reason: expect.any(String),
+    });
+  });
+
+  it("builds correct user message for GitHub repos", () => {
+    const msg = buildUserMessage("anthropics/mcp-brave-search");
+    expect(msg).toContain("https://github.com/anthropics/mcp-brave-search");
+    expect(msg).toContain("README");
+  });
+
+  it("builds correct user message for URLs", () => {
+    const msg = buildUserMessage("https://docs.example.com/mcp");
+    expect(msg).toContain("https://docs.example.com/mcp");
+  });
+});

package/src/adapters/__tests__/adapters.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { StdioConfig, HttpConfig } from "../../types.js";
+import { claudeCodeAdapter } from "../claude-code.js";
+import { codexCliAdapter } from "../codex-cli.js";
+import { geminiCliAdapter } from "../gemini-cli.js";
+import { opencodeAdapter } from "../opencode.js";
+
+const stdioConfig: StdioConfig = {
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@anthropic/mcp-brave-search"],
+  env: { BRAVE_API_KEY: "test-key" },
+};
+
+const stdioConfigWithRef: StdioConfig = {
+  transport: "stdio",
+  command: "npx",
+  args: [
+    "-y",
+    "mcp-remote",
+    "https://mcp.example.com/v1",
+    "--header",
+    "Authorization: Bearer ${API_KEY}",
+  ],
+  env: { API_KEY: "sk-test-123" },
+};
+
+const stdioConfigMixed: StdioConfig = {
+  transport: "stdio",
+  command: "npx",
+  args: [
+    "-y",
+    "mcp-remote",
+    "--header",
+    "Authorization: Bearer ${API_KEY}",
+  ],
+  env: { API_KEY: "sk-test-123", DEBUG: "true" },
+};
+
+const httpConfig: HttpConfig = {
+  transport: "http",
+  url: "https://example.com/mcp",
+  headers: { Authorization: "Bearer test-token" },
+};
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "mcpsmgr-test-"));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true });
+});
+
+describe("Claude Code Adapter", () => {
+  it("writes and reads stdio config", async () => {
+    await claudeCodeAdapter.write(tmpDir, "brave-search", stdioConfig);
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    expect(servers["brave-search"]).toEqual({
+      type: "stdio",
+      command: "env",
+      args: ["BRAVE_API_KEY=test-key", "npx", "-y", "@anthropic/mcp-brave-search"],
+    });
+  });
+
+  it("writes and reads http config", async () => {
+    await claudeCodeAdapter.write(tmpDir, "my-mcp", httpConfig);
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    expect(servers["my-mcp"]).toEqual({
+      type: "http",
+      url: "https://example.com/mcp",
+      headers: { Authorization: "Bearer test-token" },
+    });
+  });
+
+  it("throws on conflict", async () => {
+    await claudeCodeAdapter.write(tmpDir, "brave-search", stdioConfig);
+    await expect(
+      claudeCodeAdapter.write(tmpDir, "brave-search", stdioConfig),
+    ).rejects.toThrow("Conflict");
+  });
+
+  it("removes a server", async () => {
+    await claudeCodeAdapter.write(tmpDir, "brave-search", stdioConfig);
+    await claudeCodeAdapter.remove(tmpDir, "brave-search");
+    const has = await claudeCodeAdapter.has(tmpDir, "brave-search");
+    expect(has).toBe(false);
+  });
+
+  it("preserves other servers on write", async () => {
+    await claudeCodeAdapter.write(tmpDir, "first", stdioConfig);
+    await claudeCodeAdapter.write(tmpDir, "second", httpConfig);
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    expect(Object.keys(servers)).toEqual(["first", "second"]);
+  });
+
+  it("converts from new agent format (env command)", () => {
+    const result = claudeCodeAdapter.fromAgentFormat("test", {
+      type: "stdio",
+      command: "env",
+      args: ["KEY=val", "npx", "-y", "pkg"],
+    });
+    expect(result).toEqual({
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "pkg"],
+      env: { KEY: "val" },
+    });
+  });
+
+  it("converts from legacy agent format (env field)", () => {
+    const result = claudeCodeAdapter.fromAgentFormat("test", {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "pkg"],
+      env: { KEY: "val" },
+    });
+    expect(result).toEqual({
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "pkg"],
+      env: { KEY: "val" },
+    });
+  });
+
+  it("substitutes ${VAR} references in args and removes env", async () => {
+    await claudeCodeAdapter.write(tmpDir, "jina", stdioConfigWithRef);
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    expect(servers["jina"]).toEqual({
+      type: "stdio",
+      command: "npx",
+      args: [
+        "-y",
+        "mcp-remote",
+        "https://mcp.example.com/v1",
+        "--header",
+        "Authorization: Bearer sk-test-123",
+      ],
+    });
+  });
+
+  it("substitutes ${VAR} in args and wraps remaining env vars", async () => {
+    await claudeCodeAdapter.write(tmpDir, "mixed", stdioConfigMixed);
+    const servers = await claudeCodeAdapter.read(tmpDir);
+    expect(servers["mixed"]).toEqual({
+      type: "stdio",
+      command: "env",
+      args: [
+        "DEBUG=true",
+        "npx",
+        "-y",
+        "mcp-remote",
+        "--header",
+        "Authorization: Bearer sk-test-123",
+      ],
+    });
+  });
+});
+
+describe("Codex CLI Adapter", () => {
+  it("writes and reads stdio config as TOML", async () => {
+    await codexCliAdapter.write(tmpDir, "brave-search", stdioConfig);
+    const servers = await codexCliAdapter.read(tmpDir);
+    expect(servers["brave-search"]).toBeTruthy();
+
+    const raw = await readFile(
+      join(tmpDir, ".codex", "config.toml"),
+      "utf-8",
+    );
+    expect(raw).toContain("[mcp_servers.brave-search]");
+  });
+
+  it("throws on conflict", async () => {
+    await codexCliAdapter.write(tmpDir, "brave-search", stdioConfig);
+    await expect(
+      codexCliAdapter.write(tmpDir, "brave-search", stdioConfig),
+    ).rejects.toThrow("Conflict");
+  });
+
+  it("removes a server", async () => {
+    await codexCliAdapter.write(tmpDir, "brave-search", stdioConfig);
+    await codexCliAdapter.remove(tmpDir, "brave-search");
+    const has = await codexCliAdapter.has(tmpDir, "brave-search");
+    expect(has).toBe(false);
+  });
+});
+
+describe("Gemini CLI Adapter", () => {
+  it("writes and reads stdio config", async () => {
+    await geminiCliAdapter.write(tmpDir, "brave-search", stdioConfig);
+    const servers = await geminiCliAdapter.read(tmpDir);
+    expect(servers["brave-search"]).toEqual({
+      command: "env",
+      args: ["BRAVE_API_KEY=test-key", "npx", "-y", "@anthropic/mcp-brave-search"],
+    });
+  });
+
+  it("preserves non-MCP fields", async () => {
+    const { writeJsonFile } = await import("../json-file.js");
+    const filePath = join(tmpDir, ".gemini", "settings.json");
+    await writeJsonFile(filePath, { theme: "dark", mcpServers: {} });
+
+    await geminiCliAdapter.write(tmpDir, "brave-search", stdioConfig);
+
+    const raw = JSON.parse(await readFile(filePath, "utf-8"));
+    expect(raw["theme"]).toBe("dark");
+    expect(raw["mcpServers"]["brave-search"]).toBeTruthy();
+  });
+});
+
+describe("OpenCode Adapter", () => {
+  it("writes stdio config with array command", async () => {
+    await opencodeAdapter.write(tmpDir, "brave-search", stdioConfig);
+    const servers = await opencodeAdapter.read(tmpDir);
+    expect(servers["brave-search"]).toEqual({
+      type: "local",
+      command: ["env", "BRAVE_API_KEY=test-key", "npx", "-y", "@anthropic/mcp-brave-search"],
+    });
+  });
+
+  it("writes http config with remote type", async () => {
+    await opencodeAdapter.write(tmpDir, "my-mcp", httpConfig);
+    const servers = await opencodeAdapter.read(tmpDir);
+    expect(servers["my-mcp"]).toEqual({
+      type: "remote",
+      url: "https://example.com/mcp",
+      headers: { Authorization: "Bearer test-token" },
+    });
+  });
+
+  it("converts from new agent format (env command)", () => {
+    const result = opencodeAdapter.fromAgentFormat("test", {
+      type: "local",
+      command: ["env", "KEY=val", "npx", "-y", "pkg"],
+    });
+    expect(result).toEqual({
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "pkg"],
+      env: { KEY: "val" },
+    });
+  });
+
+  it("converts from legacy agent format (environment field)", () => {
+    const result = opencodeAdapter.fromAgentFormat("test", {
+      type: "local",
+      command: ["npx", "-y", "pkg"],
+      environment: { KEY: "val" },
+    });
+    expect(result).toEqual({
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "pkg"],
+      env: { KEY: "val" },
+    });
+  });
+
+  it("converts from agent format (remote)", () => {
+    const result = opencodeAdapter.fromAgentFormat("test", {
+      type: "remote",
+      url: "https://example.com",
+      headers: {},
+    });
+    expect(result).toEqual({
+      transport: "http",
+      url: "https://example.com",
+      headers: {},
+    });
+  });
+});

package/src/adapters/antigravity.ts

@@ -0,0 +1,114 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentAdapter, DefaultConfig } from "../types.js";
+import { readJsonFile, writeJsonFile } from "./json-file.js";
+import { buildEnvArgs, parseEnvArgs, resolveEnvInArgs } from "./env-args.js";
+
+const GLOBAL_CONFIG_PATH = join(
+  homedir(),
+  ".gemini",
+  "antigravity",
+  "mcp_config.json",
+);
+
+function toAgentFormat(config: DefaultConfig): Record<string, unknown> {
+  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 fromAgentFormat(
+  _name: string,
+  raw: Record<string, unknown>,
+): DefaultConfig | undefined {
+  if (raw["command"]) {
+    const command = raw["command"] as string;
+    const rawArgs = (raw["args"] as string[]) ?? [];
+    const legacyEnv = raw["env"] as Record<string, string> | undefined;
+
+    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"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+export const antigravityAdapter: AgentAdapter = {
+  id: "antigravity",
+  name: "Antigravity",
+  configPath: () => GLOBAL_CONFIG_PATH,
+  isGlobal: true,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read() {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    return (data["mcpServers"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(_projectDir, serverName, config) {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Antigravity config`,
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat(config) },
+    };
+    await writeJsonFile(GLOBAL_CONFIG_PATH, updated);
+  },
+
+  async remove(_projectDir, serverName) {
+    const data = await readJsonFile(GLOBAL_CONFIG_PATH);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    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"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};

package/src/adapters/claude-code.ts

@@ -0,0 +1,114 @@
+import { join } from "node:path";
+import type { AgentAdapter, DefaultConfig } from "../types.js";
+import { readJsonFile, writeJsonFile } from "./json-file.js";
+import { buildEnvArgs, parseEnvArgs, resolveEnvInArgs } from "./env-args.js";
+
+function toAgentFormat(config: DefaultConfig): Record<string, unknown> {
+  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: string,
+  raw: Record<string, unknown>,
+): DefaultConfig | undefined {
+  const type = raw["type"] as string | undefined;
+  if (type === "stdio") {
+    const command = raw["command"] as string;
+    const rawArgs = (raw["args"] as string[]) ?? [];
+    const legacyEnv = raw["env"] as Record<string, string> | undefined;
+
+    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"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+export const claudeCodeAdapter: AgentAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  configPath: (projectDir) => join(projectDir, ".mcp.json"),
+  isGlobal: false,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read(projectDir) {
+    const filePath = join(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    return (data["mcpServers"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(projectDir, serverName, config) {
+    const filePath = join(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    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 = join(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(filePath, { ...data, mcpServers: rest });
+  },
+
+  async has(projectDir, serverName) {
+    const filePath = join(projectDir, ".mcp.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};