mcpsmgr 0.1.0

package/src/commands/list.ts

@@ -0,0 +1,77 @@
+import { allAdapters } from "../adapters/index.js";
+import type { AgentAdapter } from "../types.js";
+
+interface ServerEntry {
+  transport: string;
+}
+
+export async function listCommand(): Promise<void> {
+  const projectDir = process.cwd();
+
+  const matrix: Record<string, Record<string, ServerEntry>> = {};
+  const activeAdapters: AgentAdapter[] = [];
+
+  for (const adapter of allAdapters) {
+    let servers: Record<string, unknown>;
+    try {
+      servers = await adapter.read(projectDir);
+    } catch {
+      continue;
+    }
+
+    if (Object.keys(servers).length === 0) continue;
+
+    activeAdapters.push(adapter);
+    for (const [name, raw] of Object.entries(servers)) {
+      if (!matrix[name]) {
+        matrix[name] = {};
+      }
+      const config = adapter.fromAgentFormat(
+        name,
+        raw as Record<string, unknown>,
+      );
+      matrix[name][adapter.id] = {
+        transport: config?.transport ?? "?",
+      };
+    }
+  }
+
+  if (Object.keys(matrix).length === 0) {
+    console.log(
+      "No MCP servers found in any agent configuration. Use \"mcpsmgr init\" to get started.",
+    );
+    return;
+  }
+
+  const serverNames = Object.keys(matrix).sort();
+  const agentIds = activeAdapters.map((a) => a.id);
+  const agentNames = activeAdapters.map((a) => a.name);
+
+  const colWidths = [
+    Math.max(6, ...serverNames.map((n) => n.length)),
+    ...agentNames.map((n) => Math.max(n.length, 5)),
+  ];
+
+  const header = [
+    "Server".padEnd(colWidths.at(0) ?? 6),
+    ...agentNames.map((n, i) => n.padEnd(colWidths.at(i + 1) ?? 5)),
+  ].join("  ");
+
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+
+  console.log(`\n${header}`);
+  console.log(separator);
+
+  for (const name of serverNames) {
+    const cells = [
+      name.padEnd(colWidths.at(0) ?? 6),
+      ...agentIds.map((id, i) => {
+        const entry = matrix[name][id];
+        const val = entry ? entry.transport : "-";
+        return val.padEnd(colWidths.at(i + 1) ?? 5);
+      }),
+    ];
+    console.log(cells.join("  "));
+  }
+  console.log();
+}

package/src/commands/remove.ts

@@ -0,0 +1,61 @@
+import { checkbox } from "@inquirer/prompts";
+import { allAdapters } from "../adapters/index.js";
+import { isUserCancellation } from "../utils/prompt.js";
+import type { AgentAdapter } from "../types.js";
+
+export async function removeCommand(serverName: string): Promise<void> {
+  try {
+    await removeCommandInner(serverName);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function removeCommandInner(serverName: string): Promise<void> {
+  const projectDir = process.cwd();
+
+  const agentsWithServer: AgentAdapter[] = [];
+  for (const adapter of allAdapters) {
+    try {
+      const has = await adapter.has(projectDir, serverName);
+      if (has) {
+        agentsWithServer.push(adapter);
+      }
+    } catch {
+      // config file doesn't exist, skip
+    }
+  }
+
+  if (agentsWithServer.length === 0) {
+    console.log(
+      `Server "${serverName}" not found in any agent configuration.`,
+    );
+    return;
+  }
+
+  const selectedAgents = await checkbox<AgentAdapter>({
+    message: `Remove "${serverName}" from which agents?`,
+    choices: agentsWithServer.map((adapter) => ({
+      name: `${adapter.name}${adapter.isGlobal ? " [global]" : ""}`,
+      value: adapter,
+      checked: !adapter.isGlobal,
+    })),
+  });
+
+  if (selectedAgents.length === 0) {
+    console.log("No agents selected.");
+    return;
+  }
+
+  for (const agent of selectedAgents) {
+    try {
+      await agent.remove(projectDir, serverName);
+      console.log(`  - ${serverName} <- ${agent.name}`);
+    } catch (error) {
+      console.warn(
+        `  ! ${serverName} <- ${agent.name}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/commands/server-add.ts

@@ -0,0 +1,211 @@
+import { confirm, input, password } from "@inquirer/prompts";
+import type { DefaultConfig, ServerDefinition, StdioConfig } from "../types.js";
+import { readGlobalConfig } from "../utils/config.js";
+import {
+  serverExists,
+  writeServerDefinition,
+} from "../utils/server-store.js";
+import {
+  isValidInput,
+  buildUserMessage,
+  analyzeWithGlm,
+  type AnalysisResult,
+} from "../services/glm-client.js";
+import { isUserCancellation } from "../utils/prompt.js";
+
+export async function serverAddCommand(source?: string): Promise<void> {
+  try {
+    await serverAddCommandInner(source);
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function serverAddCommandInner(source?: string): Promise<void> {
+  const urlInput =
+    source ??
+    (await input({
+      message: "Enter MCP server URL or GitHub owner/repo (leave empty for manual):",
+    }));
+
+  if (urlInput.trim() === "") {
+    await manualAddFlow();
+    return;
+  }
+
+  const validation = isValidInput(urlInput.trim());
+  if (!validation.valid) {
+    console.error(`Error: ${validation.reason}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const config = await readGlobalConfig();
+
+  console.log("Analyzing documentation with GLM5...");
+  let analysis: AnalysisResult;
+  try {
+    const userMessage = buildUserMessage(urlInput.trim());
+    analysis = await analyzeWithGlm(config, userMessage);
+  } catch (error) {
+    console.error(
+      `GLM5 analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    const fallback = await confirm({
+      message: "Would you like to configure manually instead?",
+    });
+    if (fallback) {
+      await manualAddFlow();
+    }
+    return;
+  }
+
+  displayAnalysisResult(analysis, urlInput.trim());
+
+  const trust = await confirm({
+    message: "Trust this analysis result?",
+  });
+
+  if (!trust) {
+    const manual = await confirm({
+      message: "Configure manually instead?",
+    });
+    if (manual) {
+      await manualAddFlow();
+    }
+    return;
+  }
+
+  if (serverExists(analysis.name)) {
+    console.error(
+      `Error: Server "${analysis.name}" already exists. Run "mcpsmgr server remove ${analysis.name}" first.`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const env: Record<string, string> = {};
+  for (const varName of analysis.requiredEnvVars) {
+    const value = await password({
+      message: `Enter value for ${varName} (stored locally, never sent to servers):`,
+      mask: "*",
+    });
+    env[varName] = value;
+  }
+
+  const defaultConfig: DefaultConfig =
+    analysis.default.transport === "stdio"
+      ? {
+          transport: "stdio",
+          command: analysis.default.command ?? "",
+          args: [...(analysis.default.args ?? [])],
+          env: { ...(analysis.default.env ?? {}), ...env },
+        }
+      : {
+          transport: "http",
+          url: analysis.default.url ?? "",
+          headers: { ...(analysis.default.headers ?? {}) },
+        };
+
+  const definition: ServerDefinition = {
+    name: analysis.name,
+    source: urlInput.trim(),
+    default: defaultConfig,
+    overrides: analysis.overrides as ServerDefinition["overrides"],
+  };
+
+  await writeServerDefinition(definition);
+  console.log(`Server "${analysis.name}" saved to central repository.`);
+}
+
+function displayAnalysisResult(result: AnalysisResult, source: string): void {
+  console.log("\n--- Analysis Result ---");
+  console.log(`Name: ${result.name}`);
+  console.log(`Source: ${source}`);
+  console.log(`Transport: ${result.default.transport}`);
+  if (result.default.transport === "stdio") {
+    console.log(`Command: ${result.default.command}`);
+    console.log(`Args: ${JSON.stringify(result.default.args)}`);
+  } else {
+    console.log(`URL: ${result.default.url}`);
+  }
+  if (Object.keys(result.overrides).length > 0) {
+    console.log("Agent overrides:");
+    for (const [agent, override] of Object.entries(result.overrides)) {
+      console.log(`  ${agent}: ${JSON.stringify(override)}`);
+    }
+  }
+  if (result.requiredEnvVars.length > 0) {
+    console.log(
+      `Required env vars: ${result.requiredEnvVars.join(", ")}`,
+    );
+  }
+  console.log("---\n");
+}
+
+async function manualAddFlow(): Promise<void> {
+  const name = await input({
+    message: "Server name (kebab-case):",
+    validate: (v) =>
+      /^[a-z][a-z0-9-]*$/.test(v.trim()) ? true : "Must be kebab-case",
+  });
+
+  if (serverExists(name.trim())) {
+    console.error(
+      `Error: Server "${name.trim()}" already exists. Run "mcpsmgr server remove ${name.trim()}" first.`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const source = await input({
+    message: "Source URL (optional):",
+  });
+
+  const command = await input({
+    message: "Command (e.g., npx):",
+    validate: (v) => (v.trim().length > 0 ? true : "Command is required"),
+  });
+
+  const argsStr = await input({
+    message: "Args (comma-separated, e.g., -y,@scope/package):",
+  });
+  const args = argsStr
+    .trim()
+    .split(",")
+    .map((a) => a.trim())
+    .filter((a) => a.length > 0);
+
+  const envPairs: Record<string, string> = {};
+  let addMore = true;
+  while (addMore) {
+    const envName = await input({
+      message: "Env var name (leave empty to finish):",
+    });
+    if (envName.trim() === "") break;
+    const envValue = await password({
+      message: `Value for ${envName.trim()} (stored locally, never sent to servers):`,
+      mask: "*",
+    });
+    envPairs[envName.trim()] = envValue;
+    addMore = true;
+  }
+
+  const config: StdioConfig = {
+    transport: "stdio",
+    command: command.trim(),
+    args,
+    env: envPairs,
+  };
+
+  const definition: ServerDefinition = {
+    name: name.trim(),
+    source: source.trim(),
+    default: config,
+    overrides: {},
+  };
+
+  await writeServerDefinition(definition);
+  console.log(`Server "${name.trim()}" saved to central repository.`);
+}

package/src/commands/server-list.ts

@@ -0,0 +1,24 @@
+import { listServerDefinitions } from "../utils/server-store.js";
+
+export async function serverListCommand(): Promise<void> {
+  const servers = await listServerDefinitions();
+
+  if (servers.length === 0) {
+    console.log("No servers in central repository. Use \"mcpsmgr server add\" to add one.");
+    return;
+  }
+
+  console.log("\nCentral Repository Servers:\n");
+  for (const server of servers) {
+    const overrideCount = Object.keys(server.overrides).length;
+    const overrideInfo =
+      overrideCount > 0 ? ` (${overrideCount} overrides)` : "";
+    console.log(
+      `  ${server.name} [${server.default.transport}]${overrideInfo}`,
+    );
+    if (server.source) {
+      console.log(`    source: ${server.source}`);
+    }
+  }
+  console.log();
+}

package/src/commands/server-remove.ts

@@ -0,0 +1,12 @@
+import { removeServerDefinition, serverExists } from "../utils/server-store.js";
+
+export async function serverRemoveCommand(name: string): Promise<void> {
+  if (!serverExists(name)) {
+    console.error(`Error: Server "${name}" does not exist in central repository.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  await removeServerDefinition(name);
+  console.log(`Server "${name}" removed from central repository.`);
+}

package/src/commands/setup.ts

@@ -0,0 +1,71 @@
+import { mkdir, chmod } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { input, select, confirm } from "@inquirer/prompts";
+import type { GlobalConfig } from "../types.js";
+import { paths } from "../utils/paths.js";
+import { writeGlobalConfig, configExists } from "../utils/config.js";
+import { isUserCancellation } from "../utils/prompt.js";
+
+const GLM_ENDPOINTS = [
+  {
+    name: "Coding Plan (GLM-5)",
+    value: "https://open.bigmodel.cn/api/coding/paas/v4/chat/completions",
+  },
+  {
+    name: "General (GLM-5)",
+    value: "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+  },
+] as const;
+
+export async function setupCommand(): Promise<void> {
+  try {
+    await setupCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function setupCommandInner(): Promise<void> {
+  if (configExists()) {
+    const overwrite = await confirm({
+      message: "Configuration already exists. Overwrite?",
+    });
+    if (!overwrite) {
+      console.log("Setup cancelled.");
+      return;
+    }
+  }
+
+  if (!existsSync(paths.baseDir)) {
+    await mkdir(paths.baseDir, { recursive: true });
+    await chmod(paths.baseDir, 0o700);
+  }
+  if (!existsSync(paths.serversDir)) {
+    await mkdir(paths.serversDir, { recursive: true });
+  }
+
+  const glmApiKey = await input({
+    message: "Enter GLM5 API Key:",
+    validate: (v) => (v.trim().length > 0 ? true : "API key is required"),
+  });
+
+  const glmEndpoint = await select({
+    message: "Select GLM5 endpoint:",
+    choices: GLM_ENDPOINTS.map((e) => ({ name: e.name, value: e.value })),
+  });
+
+  const config: GlobalConfig = {
+    glm: {
+      apiKey: glmApiKey.trim(),
+      endpoint: glmEndpoint,
+    },
+    webReader: {
+      apiKey: glmApiKey.trim(),
+      url: "https://open.bigmodel.cn/api/mcp/web_reader/mcp",
+    },
+  };
+
+  await writeGlobalConfig(config);
+  console.log("Setup complete. Configuration saved to ~/.mcps-manager/config.json");
+}

package/src/commands/sync.ts

@@ -0,0 +1,98 @@
+import { confirm } from "@inquirer/prompts";
+import { allAdapters } from "../adapters/index.js";
+import { listServerDefinitions } from "../utils/server-store.js";
+import { resolveConfig } from "../utils/resolve-config.js";
+import { isUserCancellation } from "../utils/prompt.js";
+
+export async function syncCommand(): Promise<void> {
+  try {
+    await syncCommandInner();
+  } catch (error) {
+    if (isUserCancellation(error)) return;
+    throw error;
+  }
+}
+
+async function syncCommandInner(): Promise<void> {
+  const projectDir = process.cwd();
+
+  const definitions = await listServerDefinitions();
+  if (definitions.length === 0) {
+    console.log("Central repository is empty. Nothing to sync.");
+    return;
+  }
+
+  const changes: Array<{
+    agentName: string;
+    serverName: string;
+    action: "update" | "skip";
+    reason?: string;
+  }> = [];
+
+  for (const adapter of allAdapters) {
+    let servers: Record<string, unknown>;
+    try {
+      servers = await adapter.read(projectDir);
+    } catch {
+      continue;
+    }
+
+    for (const definition of definitions) {
+      if (!(definition.name in servers)) {
+        continue;
+      }
+
+      const currentRaw = servers[definition.name] as Record<string, unknown>;
+      const desired = resolveConfig(definition, adapter);
+      const desiredRaw = adapter.toAgentFormat(desired);
+
+      if (JSON.stringify(currentRaw) !== JSON.stringify(desiredRaw)) {
+        changes.push({
+          agentName: adapter.name,
+          serverName: definition.name,
+          action: "update",
+        });
+      }
+    }
+  }
+
+  if (changes.length === 0) {
+    console.log("All agent configurations are up to date.");
+    return;
+  }
+
+  console.log("\nSync preview:");
+  for (const change of changes) {
+    console.log(`  ~ ${change.serverName} -> ${change.agentName}`);
+  }
+
+  const proceed = await confirm({ message: "Apply changes?" });
+  if (!proceed) {
+    console.log("Cancelled.");
+    return;
+  }
+
+  for (const adapter of allAdapters) {
+    for (const definition of definitions) {
+      const relevant = changes.find(
+        (c) =>
+          c.agentName === adapter.name &&
+          c.serverName === definition.name,
+      );
+      if (!relevant) continue;
+
+      try {
+        await adapter.remove(projectDir, definition.name);
+        const config = resolveConfig(definition, adapter);
+        await adapter.write(projectDir, definition.name, config);
+        console.log(`  ~ ${definition.name} -> ${adapter.name} (updated)`);
+      } catch (error) {
+        console.warn(
+          `  ! ${definition.name} -> ${adapter.name}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+  }
+
+  console.log("\nSync complete.");
+}

package/src/index.ts

@@ -0,0 +1,100 @@
+import { program } from "commander";
+import { configExists } from "./utils/config.js";
+import { setupCommand } from "./commands/setup.js";
+import { serverAddCommand } from "./commands/server-add.js";
+import { serverRemoveCommand } from "./commands/server-remove.js";
+import { serverListCommand } from "./commands/server-list.js";
+import { initCommand } from "./commands/init.js";
+import { addCommand } from "./commands/add.js";
+import { removeCommand } from "./commands/remove.js";
+import { syncCommand } from "./commands/sync.js";
+import { listCommand } from "./commands/list.js";
+
+function requireSetup(): void {
+  if (!configExists()) {
+    console.error(
+      'mcpsmgr is not configured. Run "mcpsmgr setup" first.',
+    );
+    process.exit(1);
+  }
+}
+
+program
+  .name("mcpsmgr")
+  .description("Unified MCP server manager for multiple coding agents")
+  .version("0.1.0");
+
+program
+  .command("setup")
+  .description("Initialize mcpsmgr configuration")
+  .action(setupCommand);
+
+const server = program
+  .command("server")
+  .description("Manage MCP server definitions in central repository");
+
+server
+  .command("add [source]")
+  .description("Add an MCP server (URL or GitHub owner/repo)")
+  .action((source?: string) => {
+    requireSetup();
+    return serverAddCommand(source);
+  });
+
+server
+  .command("remove <name>")
+  .description("Remove an MCP server from central repository")
+  .action((name: string) => {
+    requireSetup();
+    return serverRemoveCommand(name);
+  });
+
+server
+  .command("list")
+  .description("List all servers in central repository")
+  .action(() => {
+    requireSetup();
+    return serverListCommand();
+  });
+
+program
+  .command("init")
+  .description("Initialize MCP servers for current project")
+  .action(() => {
+    requireSetup();
+    return initCommand();
+  });
+
+program
+  .command("add <server-name>")
+  .description("Add a server from central repository to current project")
+  .action((serverName: string) => {
+    requireSetup();
+    return addCommand(serverName);
+  });
+
+program
+  .command("remove <server-name>")
+  .description("Remove a server from current project agent configs")
+  .action((serverName: string) => {
+    requireSetup();
+    return removeCommand(serverName);
+  });
+
+program
+  .command("sync")
+  .description("Sync central repository changes to project agent configs")
+  .action(() => {
+    requireSetup();
+    return syncCommand();
+  });
+
+program
+  .command("list")
+  .description("List MCP servers across all agent configs in current project")
+  .action(() => {
+    requireSetup();
+    return listCommand();
+  });
+
+program.parse();