mcpsmgr 0.1.0

package/src/adapters/codex-cli.ts

@@ -0,0 +1,135 @@
+import { join } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import type { AgentAdapter, DefaultConfig } from "../types.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 {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs],
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs,
+    };
+  }
+  return {
+    url: 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["url"]) {
+    return {
+      transport: "http",
+      url: raw["url"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+async function readTomlFile(
+  filePath: string,
+): Promise<{ raw: string; parsed: Record<string, unknown> }> {
+  if (!existsSync(filePath)) {
+    return { raw: "", parsed: {} };
+  }
+  const raw = await readFile(filePath, "utf-8");
+  const parsed = parseToml(raw) as Record<string, unknown>;
+  return { raw, parsed };
+}
+
+async function writeTomlFile(
+  filePath: string,
+  data: Record<string, unknown>,
+): Promise<void> {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(filePath, stringifyToml(data) + "\n", "utf-8");
+}
+
+export const codexCliAdapter: AgentAdapter = {
+  id: "codex-cli",
+  name: "Codex CLI",
+  configPath: (projectDir) => join(projectDir, ".codex", "config.toml"),
+  isGlobal: false,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read(projectDir) {
+    const filePath = join(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    return (parsed["mcp_servers"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(projectDir, serverName, config) {
+    const filePath = join(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = (parsed["mcp_servers"] as Record<string, unknown>) ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in Codex CLI config`,
+      );
+    }
+    const updated = {
+      ...parsed,
+      mcp_servers: { ...servers, [serverName]: toAgentFormat(config) },
+    };
+    await writeTomlFile(filePath, updated);
+  },
+
+  async remove(projectDir, serverName) {
+    const filePath = join(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = (parsed["mcp_servers"] as Record<string, unknown>) ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeTomlFile(filePath, { ...parsed, mcp_servers: rest });
+  },
+
+  async has(projectDir, serverName) {
+    const filePath = join(projectDir, ".codex", "config.toml");
+    const { parsed } = await readTomlFile(filePath);
+    const servers = (parsed["mcp_servers"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};

package/src/adapters/env-args.ts

@@ -0,0 +1,51 @@
+const ENV_VAR_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*=/;
+
+export function buildEnvArgs(
+  env: Readonly<Record<string, string>>,
+): string[] {
+  return Object.entries(env).map(([key, value]) => `${key}=${value}`);
+}
+
+export function parseEnvArgs(args: readonly string[]): {
+  readonly env: Record<string, string>;
+  readonly commandIndex: number;
+} {
+  const env: Record<string, string> = {};
+  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 };
+}
+
+export function resolveEnvInArgs(
+  args: readonly string[],
+  env: Readonly<Record<string, string>>,
+): {
+  readonly resolvedArgs: string[];
+  readonly remainingEnv: Record<string, string>;
+} {
+  const substitutedKeys = new Set<string>();
+  const resolvedArgs = args.map((arg) =>
+    arg.replace(/\$\{([^}]+)\}/g, (match, varName: string) => {
+      if (varName in env) {
+        substitutedKeys.add(varName);
+        return env[varName];
+      }
+      return match;
+    }),
+  );
+
+  const remainingEnv: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!substitutedKeys.has(key)) {
+      remainingEnv[key] = value;
+    }
+  }
+
+  return { resolvedArgs, remainingEnv };
+}

package/src/adapters/gemini-cli.ts

@@ -0,0 +1,110 @@
+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 {
+        command: "env",
+        args: [...envArgs, config.command, ...resolvedArgs],
+      };
+    }
+    return {
+      command: config.command,
+      args: resolvedArgs,
+    };
+  }
+  return {
+    url: 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["url"]) {
+    return {
+      transport: "http",
+      url: raw["url"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+export const geminiCliAdapter: AgentAdapter = {
+  id: "gemini-cli",
+  name: "Gemini CLI",
+  configPath: (projectDir) => join(projectDir, ".gemini", "settings.json"),
+  isGlobal: false,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read(projectDir) {
+    const filePath = join(projectDir, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    return (data["mcpServers"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(projectDir, serverName, config) {
+    const filePath = join(projectDir, ".gemini", "settings.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 Gemini CLI config`,
+      );
+    }
+    const updated = {
+      ...data,
+      mcpServers: { ...servers, [serverName]: toAgentFormat(config) },
+    };
+    await writeJsonFile(filePath, updated);
+  },
+
+  async remove(projectDir, serverName) {
+    const filePath = join(projectDir, ".gemini", "settings.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, ".gemini", "settings.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcpServers"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};

package/src/adapters/index.ts

@@ -0,0 +1,32 @@
+import { existsSync } from "node:fs";
+import type { AgentAdapter, AgentId } 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";
+import { antigravityAdapter } from "./antigravity.js";
+
+export const allAdapters: readonly AgentAdapter[] = [
+  claudeCodeAdapter,
+  codexCliAdapter,
+  geminiCliAdapter,
+  opencodeAdapter,
+  antigravityAdapter,
+];
+
+export function getAdapter(id: AgentId): AgentAdapter {
+  const adapter = allAdapters.find((a) => a.id === id);
+  if (!adapter) {
+    throw new Error(`Unknown agent: ${id}`);
+  }
+  return adapter;
+}
+
+export function detectAgents(projectDir: string): AgentAdapter[] {
+  return allAdapters.filter((adapter) => {
+    if (adapter.isGlobal) {
+      return existsSync(adapter.configPath(projectDir));
+    }
+    return existsSync(adapter.configPath(projectDir));
+  });
+}

package/src/adapters/json-file.ts

@@ -0,0 +1,24 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+
+export async function readJsonFile(
+  filePath: string,
+): Promise<Record<string, unknown>> {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  const raw = await readFile(filePath, "utf-8");
+  return JSON.parse(raw) as Record<string, unknown>;
+}
+
+export async function writeJsonFile(
+  filePath: string,
+  data: Record<string, unknown>,
+): Promise<void> {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}

package/src/adapters/opencode.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: "local",
+        command: ["env", ...envArgs, config.command, ...resolvedArgs],
+      };
+    }
+    return {
+      type: "local",
+      command: [config.command, ...resolvedArgs],
+    };
+  }
+  return {
+    type: "remote",
+    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 === "local") {
+    const commandArr = raw["command"] as string[];
+    const legacyEnv = raw["environment"] as Record<string, string> | undefined;
+
+    if (legacyEnv && Object.keys(legacyEnv).length > 0) {
+      const [command = "", ...args] = commandArr;
+      return { transport: "stdio", command, args, 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"] as string,
+      headers: (raw["headers"] as Record<string, string>) ?? {},
+    };
+  }
+  return undefined;
+}
+
+export const opencodeAdapter: AgentAdapter = {
+  id: "opencode",
+  name: "OpenCode",
+  configPath: (projectDir) => join(projectDir, "opencode.json"),
+  isGlobal: false,
+
+  toAgentFormat,
+  fromAgentFormat,
+
+  async read(projectDir) {
+    const filePath = join(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    return (data["mcp"] as Record<string, unknown>) ?? {};
+  },
+
+  async write(projectDir, serverName, config) {
+    const filePath = join(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcp"] as Record<string, unknown>) ?? {};
+    if (serverName in servers) {
+      throw new Error(
+        `Conflict: "${serverName}" already exists in OpenCode config`,
+      );
+    }
+    const updated = {
+      ...data,
+      mcp: { ...servers, [serverName]: toAgentFormat(config) },
+    };
+    await writeJsonFile(filePath, updated);
+  },
+
+  async remove(projectDir, serverName) {
+    const filePath = join(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcp"] as Record<string, unknown>) ?? {};
+    const { [serverName]: _, ...rest } = servers;
+    await writeJsonFile(filePath, { ...data, mcp: rest });
+  },
+
+  async has(projectDir, serverName) {
+    const filePath = join(projectDir, "opencode.json");
+    const data = await readJsonFile(filePath);
+    const servers = (data["mcp"] as Record<string, unknown>) ?? {};
+    return serverName in servers;
+  },
+};

package/src/commands/add.ts

@@ -0,0 +1,68 @@
+import { checkbox } from "@inquirer/prompts";
+import { detectAgents } from "../adapters/index.js";
+import { readServerDefinition, serverExists } from "../utils/server-store.js";
+import { resolveConfig } from "../utils/resolve-config.js";
+import { isUserCancellation } from "../utils/prompt.js";
+import type { AgentAdapter } from "../types.js";
+
+export async function addCommand(serverName: string): Promise<void> {
+  try {
+    await addCommandInner(serverName);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function addCommandInner(serverName: string): Promise<void> {
+  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 checkbox<AgentAdapter>({
+    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)}`,
+      );
+    }
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,136 @@
+import { checkbox, confirm } from "@inquirer/prompts";
+import { allAdapters, detectAgents } from "../adapters/index.js";
+import { listServerDefinitions } from "../utils/server-store.js";
+import { resolveConfig } from "../utils/resolve-config.js";
+import { isUserCancellation } from "../utils/prompt.js";
+import type { AgentAdapter } from "../types.js";
+
+export async function initCommand(): Promise<void> {
+  try {
+    await initCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function initCommandInner(): Promise<void> {
+  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<AgentAdapter>({
+    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 = new Map<string, Set<string>>();
+  const detectedServers = new Set<string>();
+  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 {
+      // silent fallback per design decision
+    }
+  }
+
+  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 = new Map<string, AgentAdapter[]>();
+  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 server of selectedServers) {
+      console.log(`    + ${server.name}`);
+    }
+    for (const [serverName, agents] of removals) {
+      if (agents.some((a) => a.id === agent.id)) {
+        console.log(`    - ${serverName}`);
+      }
+    }
+  }
+
+  const proceed = await confirm({ message: "Proceed?" });
+  if (!proceed) {
+    console.log("Cancelled.");
+    return;
+  }
+
+  for (const agent of selectedAgents) {
+    for (const server of selectedServers) {
+      try {
+        const config = resolveConfig(server, agent);
+        await agent.write(projectDir, server.name, config);
+        console.log(`  + ${server.name} -> ${agent.name}`);
+      } catch (error) {
+        console.warn(
+          `  ! ${server.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.");
+}