mcpsmgr 0.1.0

package/src/services/glm-client.ts

@@ -0,0 +1,190 @@
+import type { GlobalConfig } from "../types.js";
+import { fetchWebContent } from "./web-reader.js";
+import { ANALYSIS_SYSTEM_PROMPT } from "./system-prompt.js";
+
+interface GlmMessage {
+  readonly role: "system" | "user" | "assistant" | "tool";
+  readonly content: string | null;
+  readonly tool_calls?: readonly GlmToolCall[];
+  readonly tool_call_id?: string;
+}
+
+interface GlmToolCall {
+  readonly id: string;
+  readonly type: "function";
+  readonly function: {
+    readonly name: string;
+    readonly arguments: string;
+  };
+}
+
+interface GlmResponse {
+  readonly choices: readonly {
+    readonly message: GlmMessage;
+    readonly finish_reason: string;
+  }[];
+}
+
+const WEB_READER_TOOL = {
+  type: "function" as const,
+  function: {
+    name: "webReader",
+    description: "Fetch and read the content of a web page given its URL",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL of the web page to read",
+        },
+      },
+      required: ["url"],
+    },
+  },
+};
+
+export interface AnalysisResult {
+  readonly name: string;
+  readonly default: {
+    readonly transport: "stdio" | "http";
+    readonly command?: string;
+    readonly args?: readonly string[];
+    readonly env?: Readonly<Record<string, string>>;
+    readonly url?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+  };
+  readonly overrides: Readonly<Record<string, unknown>>;
+  readonly requiredEnvVars: readonly string[];
+}
+
+async function callGlm(
+  config: GlobalConfig,
+  messages: GlmMessage[],
+): Promise<GlmResponse> {
+  const response = await fetch(config.glm.endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.glm.apiKey}`,
+    },
+    body: JSON.stringify({
+      model: "glm-5",
+      messages,
+      tools: [WEB_READER_TOOL],
+      tool_choice: "auto",
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GLM5 API request failed: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  return (await response.json()) as GlmResponse;
+}
+
+export async function analyzeWithGlm(
+  config: GlobalConfig,
+  userMessage: string,
+): Promise<AnalysisResult> {
+  const messages: GlmMessage[] = [
+    { role: "system", content: ANALYSIS_SYSTEM_PROMPT },
+    { role: "user", content: userMessage },
+  ];
+
+  const MAX_ROUNDS = 10;
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    const response = await callGlm(config, messages);
+    const choice = response.choices.at(0);
+    if (!choice) {
+      throw new Error("GLM5 returned empty response");
+    }
+
+    const assistantMessage = choice.message;
+    messages.push({
+      role: "assistant",
+      content: assistantMessage.content,
+      tool_calls: assistantMessage.tool_calls,
+    });
+
+    if (
+      !assistantMessage.tool_calls ||
+      assistantMessage.tool_calls.length === 0
+    ) {
+      return parseAnalysisResult(assistantMessage.content ?? "");
+    }
+
+    for (const toolCall of assistantMessage.tool_calls) {
+      if (toolCall.function.name === "webReader") {
+        const args = JSON.parse(toolCall.function.arguments) as {
+          url: string;
+        };
+        let toolResult: string;
+        try {
+          toolResult = await fetchWebContent(config, args.url);
+        } catch (error) {
+          toolResult = `Error fetching URL: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        messages.push({
+          role: "tool",
+          content: toolResult,
+          tool_call_id: toolCall.id,
+        });
+      }
+    }
+  }
+
+  throw new Error("GLM5 analysis exceeded maximum rounds");
+}
+
+function parseAnalysisResult(content: string): AnalysisResult {
+  const cleaned = content
+    .replace(/```json\s*/g, "")
+    .replace(/```\s*/g, "")
+    .trim();
+
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error(`Cannot extract JSON from GLM5 response: ${cleaned.slice(0, 200)}`);
+  }
+
+  const result = JSON.parse(jsonMatch[0]) as AnalysisResult;
+  if (!result.name || !result.default) {
+    throw new Error("Invalid analysis result: missing name or default config");
+  }
+
+  return result;
+}
+
+export function buildUserMessage(input: string): string {
+  if (isGitHubRepo(input)) {
+    const url = `https://github.com/${input}`;
+    return `Please analyze the MCP server at ${url}. Start by reading the README at ${url}/blob/main/README.md`;
+  }
+  return `Please analyze the MCP server documentation at: ${input}`;
+}
+
+export function isGitHubRepo(input: string): boolean {
+  if (input.startsWith("http") || input.startsWith("@")) {
+    return false;
+  }
+  const parts = input.split("/");
+  return parts.length === 2 && parts.every((p) => p.length > 0);
+}
+
+export function isValidInput(
+  input: string,
+): { valid: true } | { valid: false; reason: string } {
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    return { valid: true };
+  }
+  if (isGitHubRepo(input)) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    reason:
+      'Invalid input format. Provide a URL (https://...) or GitHub owner/repo (e.g., "anthropics/mcp-brave-search")',
+  };
+}

package/src/services/system-prompt.ts

@@ -0,0 +1,61 @@
+export const ANALYSIS_SYSTEM_PROMPT = `You are an MCP (Model Context Protocol) server configuration analyst. Your task is to analyze documentation for an MCP server and extract configuration details for 5 different coding agents.
+
+The 5 agents and their configuration differences:
+
+1. **Claude Code** (.mcp.json)
+   - Format: { "type": "stdio"|"http", "command": "...", "args": [...] }
+   - HTTP: { "type": "http", "url": "...", "headers": {...} }
+   - IMPORTANT: Do NOT use "env" field. Environment variables will be handled separately.
+
+2. **Codex CLI** (.codex/config.toml)
+   - TOML format: command = "...", args = [...]
+   - Same key names as Claude Code but in TOML
+   - IMPORTANT: Do NOT use "env" field.
+
+3. **Gemini CLI** (.gemini/settings.json)
+   - Format: { "command": "...", "args": [...] }
+   - No "type" field needed
+   - IMPORTANT: Do NOT use "env" field.
+
+4. **OpenCode** (opencode.json)
+   - Format: { "type": "local"|"remote", "command": ["cmd", "arg1", ...] }
+   - command is an ARRAY including the command itself
+   - type is "local" for stdio, "remote" for http
+   - IMPORTANT: Do NOT use "environment" field.
+
+5. **Antigravity** (~/.gemini/antigravity/mcp_config.json)
+   - Format: { "command": "...", "args": [...] }
+   - HTTP: { "serverUrl": "...", "headers": {...} } (note: "serverUrl" not "url")
+   - IMPORTANT: Do NOT use "env" field.
+
+You have access to a webReader tool to fetch web page content. Use it to read the documentation URL provided.
+
+After analyzing the documentation, return a JSON object with this exact structure:
+\`\`\`json
+{
+  "name": "server-name",
+  "default": {
+    "transport": "stdio",
+    "command": "npx",
+    "args": ["-y", "@scope/package"],
+  },
+  "overrides": {
+    "opencode": {
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "@scope/package"],
+      "env": {}
+    }
+  },
+  "requiredEnvVars": ["API_KEY"]
+}
+\`\`\`
+
+Rules:
+- "name" should be a kebab-case identifier for the server
+- "default" should be the most common configuration (usually works for Claude Code, Codex CLI, Gemini CLI)
+- Only add "overrides" for agents that need DIFFERENT configuration from the default
+- OpenCode usually needs an override because its command format differs (array vs string+args)
+- "requiredEnvVars" lists environment variable names the user needs to provide values for
+- Transport is either "stdio" or "http"
+- Return ONLY the JSON object, no markdown fences, no explanation`;

package/src/services/web-reader.ts

@@ -0,0 +1,130 @@
+import type { GlobalConfig } from "../types.js";
+
+interface McpResponse {
+  readonly jsonrpc: string;
+  readonly id: number;
+  readonly result?: {
+    readonly content?: readonly { readonly type: string; readonly text: string }[];
+    readonly isError?: boolean;
+  };
+  readonly error?: { readonly code: number; readonly message: string };
+}
+
+function parseSseResponse(raw: string): McpResponse {
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data:")) {
+      return JSON.parse(line.slice(5)) as McpResponse;
+    }
+  }
+  return JSON.parse(raw) as McpResponse;
+}
+
+async function mcpInitialize(
+  endpoint: string,
+  apiKey: string,
+): Promise<string> {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "mcpsmgr", version: "0.1.0" },
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `MCP initialize failed: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const sessionId = response.headers.get("mcp-session-id");
+  if (!sessionId) {
+    throw new Error("MCP server did not return session ID");
+  }
+
+  return sessionId;
+}
+
+async function mcpToolCall(
+  endpoint: string,
+  apiKey: string,
+  sessionId: string,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<string> {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${apiKey}`,
+      "Mcp-Session-Id": sessionId,
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 2,
+      method: "tools/call",
+      params: { name: toolName, arguments: args },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `MCP tools/call failed: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const raw = await response.text();
+  const parsed = parseSseResponse(raw);
+
+  if (parsed.error) {
+    throw new Error(`MCP error: ${parsed.error.message}`);
+  }
+
+  const contents = parsed.result?.content ?? [];
+  const full = contents.map((c) => c.text).join("\n");
+  const MAX_CONTENT_LENGTH = 30000;
+  if (full.length > MAX_CONTENT_LENGTH) {
+    return full.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Content truncated]";
+  }
+  return full;
+}
+
+let cachedSessionId: string | undefined;
+
+export async function fetchWebContent(
+  config: GlobalConfig,
+  url: string,
+): Promise<string> {
+  const endpoint = config.webReader.url;
+  const apiKey = config.webReader.apiKey;
+
+  if (!cachedSessionId) {
+    cachedSessionId = await mcpInitialize(endpoint, apiKey);
+  }
+
+  try {
+    return await mcpToolCall(endpoint, apiKey, cachedSessionId, "webReader", {
+      url,
+      timeout: 20,
+    });
+  } catch {
+    cachedSessionId = await mcpInitialize(endpoint, apiKey);
+    return await mcpToolCall(endpoint, apiKey, cachedSessionId, "webReader", {
+      url,
+      timeout: 20,
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,59 @@
+export interface StdioConfig {
+  readonly transport: "stdio";
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly env: Readonly<Record<string, string>>;
+}
+
+export interface HttpConfig {
+  readonly transport: "http";
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+}
+
+export type DefaultConfig = StdioConfig | HttpConfig;
+
+export type AgentId =
+  | "claude-code"
+  | "codex-cli"
+  | "gemini-cli"
+  | "opencode"
+  | "antigravity";
+
+export interface ServerDefinition {
+  readonly name: string;
+  readonly source: string;
+  readonly default: DefaultConfig;
+  readonly overrides: Readonly<Partial<Record<AgentId, Partial<DefaultConfig>>>>;
+}
+
+export interface GlobalConfig {
+  readonly glm: {
+    readonly apiKey: string;
+    readonly endpoint: string;
+  };
+  readonly webReader: {
+    readonly apiKey: string;
+    readonly url: string;
+  };
+}
+
+export interface AgentAdapter {
+  readonly id: AgentId;
+  readonly name: string;
+  readonly configPath: (projectDir: string) => string;
+  readonly isGlobal: boolean;
+  read(projectDir: string): Promise<Record<string, unknown>>;
+  write(
+    projectDir: string,
+    serverName: string,
+    config: DefaultConfig,
+  ): Promise<void>;
+  remove(projectDir: string, serverName: string): Promise<void>;
+  has(projectDir: string, serverName: string): Promise<boolean>;
+  toAgentFormat(config: DefaultConfig): Record<string, unknown>;
+  fromAgentFormat(
+    name: string,
+    raw: Record<string, unknown>,
+  ): DefaultConfig | undefined;
+}

package/src/utils/config.ts

@@ -0,0 +1,22 @@
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import type { GlobalConfig } from "../types.js";
+import { paths } from "./paths.js";
+
+export async function readGlobalConfig(): Promise<GlobalConfig> {
+  const raw = await readFile(paths.configFile, "utf-8");
+  return JSON.parse(raw) as GlobalConfig;
+}
+
+export async function writeGlobalConfig(config: GlobalConfig): Promise<void> {
+  if (!existsSync(paths.baseDir)) {
+    await mkdir(paths.baseDir, { recursive: true });
+    await chmod(paths.baseDir, 0o700);
+  }
+  await writeFile(paths.configFile, JSON.stringify(config, null, 2), "utf-8");
+  await chmod(paths.configFile, 0o600);
+}
+
+export function configExists(): boolean {
+  return existsSync(paths.configFile);
+}

package/src/utils/paths.ts

@@ -0,0 +1,11 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const BASE_DIR = join(homedir(), ".mcps-manager");
+
+export const paths = {
+  baseDir: BASE_DIR,
+  serversDir: join(BASE_DIR, "servers"),
+  configFile: join(BASE_DIR, "config.json"),
+  serverFile: (name: string): string => join(BASE_DIR, "servers", `${name}.json`),
+} as const;

package/src/utils/prompt.ts

@@ -0,0 +1,3 @@
+export function isUserCancellation(error: unknown): boolean {
+  return error instanceof Error && error.name === "ExitPromptError";
+}

package/src/utils/resolve-config.ts

@@ -0,0 +1,13 @@
+import type { AgentAdapter, DefaultConfig, ServerDefinition } from "../types.js";
+
+export function resolveConfig(
+  definition: ServerDefinition,
+  adapter: AgentAdapter,
+): DefaultConfig {
+  const override = definition.overrides[adapter.id];
+  if (override) {
+    const base = definition.default;
+    return { ...base, ...override } as DefaultConfig;
+  }
+  return definition.default;
+}

package/src/utils/server-store.ts

@@ -0,0 +1,56 @@
+import { readFile, writeFile, readdir, unlink, mkdir, chmod } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import type { ServerDefinition } from "../types.js";
+import { paths } from "./paths.js";
+
+export async function readServerDefinition(
+  name: string,
+): Promise<ServerDefinition | undefined> {
+  const filePath = paths.serverFile(name);
+  if (!existsSync(filePath)) {
+    return undefined;
+  }
+  const raw = await readFile(filePath, "utf-8");
+  return JSON.parse(raw) as ServerDefinition;
+}
+
+export async function writeServerDefinition(
+  definition: ServerDefinition,
+): Promise<void> {
+  if (!existsSync(paths.serversDir)) {
+    await mkdir(paths.serversDir, { recursive: true });
+  }
+  const filePath = paths.serverFile(definition.name);
+  await writeFile(filePath, JSON.stringify(definition, null, 2), "utf-8");
+  await chmod(filePath, 0o600);
+}
+
+export async function removeServerDefinition(name: string): Promise<boolean> {
+  const filePath = paths.serverFile(name);
+  if (!existsSync(filePath)) {
+    return false;
+  }
+  await unlink(filePath);
+  return true;
+}
+
+export async function listServerDefinitions(): Promise<ServerDefinition[]> {
+  if (!existsSync(paths.serversDir)) {
+    return [];
+  }
+  const files = await readdir(paths.serversDir);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  const results: ServerDefinition[] = [];
+  for (const file of jsonFiles) {
+    const raw = await readFile(
+      paths.serverFile(file.replace(".json", "")),
+      "utf-8",
+    );
+    results.push(JSON.parse(raw) as ServerDefinition);
+  }
+  return results;
+}
+
+export function serverExists(name: string): boolean {
+  return existsSync(paths.serverFile(name));
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  target: "node20",
+  clean: true,
+  dts: true,
+  sourcemap: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});