@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/lib/standaloneMcpService.ts

@@ -0,0 +1,688 @@
+import { product } from "@codellm/product";
+import fs, { promises as fsPromises } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import type { IMcpServerInfo, IMcpManagementService, IMcpServerConfig } from "./types.js";
+
+import { helpText } from "./mcpCommandHandler.js";
+
+interface McpConfigFile {
+  inputs?: unknown[];
+  servers?: Record<string, IMcpServerConfig>;
+}
+
+interface CursorGlobalConfig {
+  mcpServers?: Record<
+    string,
+    {
+      command?: string;
+      args?: string[];
+      env?: Record<string, string>;
+      url?: string;
+    }
+  >;
+}
+
+interface VSCodeSettings {
+  mcp?: McpConfigFile;
+  [key: string]: any;
+}
+
+interface ConfigSource {
+  path: string;
+  type:
+    | "cursor-global"
+    | "cursor-workspace"
+    | "vscode-user"
+    | "vscode-workspace"
+    | "claude-desktop"
+    | "windsurf"
+    | "abacusai-user";
+  label: string;
+  exists: boolean;
+}
+
+/**
+ * Standalone MCP service that reads configurations directly from files
+ * without requiring any workbench dependencies.
+ */
+export class StandaloneMcpService implements IMcpManagementService {
+  constructor() {}
+
+  async listServers(): Promise<IMcpServerInfo[]> {
+    const configSources = await this.findConfigSources();
+    const servers: IMcpServerInfo[] = [];
+
+    for (const source of configSources) {
+      if (!source.exists) {
+        continue;
+      }
+
+      try {
+        const sourceServers = await this.loadServersFromSource(source);
+        servers.push(...sourceServers);
+      } catch {
+        // Failed to load from this source, skip
+      }
+    }
+
+    return servers;
+  }
+
+  async addServer(name: string, config: IMcpServerConfig): Promise<void> {
+    // Validate the server configuration before saving
+    this.validateServerConfig(config);
+    // Prefer product-specific User settings over other formats
+    const configSources = await this.findConfigSources();
+
+    // Priority order: Product User > VSCode User > existing files > Cursor global
+    const abacusaiUser = configSources.find((s) => s.type === "abacusai-user" && s.exists);
+    const vscodeUser = configSources.find((s) => s.type === "vscode-user" && s.exists);
+    const existingFiles = configSources.filter((s) => s.exists);
+    const cursorGlobal = configSources.find((s) => s.type === "cursor-global");
+    const vscodeUserNonExisting = configSources.find((s) => s.type === "vscode-user");
+
+    // Try existing files first, then fall back to creating new ones
+    const targetSource =
+      abacusaiUser || vscodeUser || existingFiles[0] || vscodeUserNonExisting || cursorGlobal;
+    if (!targetSource) {
+      throw new Error("No suitable configuration location found.");
+    }
+
+    await this.addServerToSource(targetSource, name, config);
+  }
+
+  async removeServer(name: string): Promise<void> {
+    const configSources = await this.findConfigSources();
+    let removed = false;
+
+    for (const source of configSources) {
+      if (!source.exists) {
+        continue;
+      }
+
+      try {
+        const wasRemoved = await this.removeServerFromSource(source.path, name);
+        if (wasRemoved) {
+          removed = true;
+        }
+      } catch {
+        // Failed to remove from this source, continue
+      }
+    }
+
+    if (!removed) {
+      throw new Error(`Server '${name}' not found in any configuration file`);
+    }
+  }
+
+  async getServer(name: string): Promise<IMcpServerInfo | undefined> {
+    const servers = await this.listServers();
+    return servers.find((server) => server.name === name || server.id === name);
+  }
+
+  async addServerFromJson(name: string, jsonConfig: string): Promise<void> {
+    let config: IMcpServerConfig;
+
+    try {
+      config = this.parseJsonWithFallback(jsonConfig) as IMcpServerConfig;
+    } catch (error) {
+      throw new Error(
+        `Invalid JSON syntax: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    try {
+      this.validateServerConfig(config);
+    } catch (error) {
+      throw new Error(
+        `Invalid server configuration: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    await this.addServer(name, config);
+  }
+
+  async addServerFromUrl(name: string, url: string, args?: string[]): Promise<void> {
+    let config: IMcpServerConfig;
+
+    // Check if it's an HTTP URL
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      config = {
+        url,
+      };
+    } else {
+      // Treat as command
+      config = {
+        command: url,
+        args: args || [],
+      };
+    }
+
+    await this.addServer(name, config);
+  }
+
+  formatServerInfo(server: IMcpServerInfo): string {
+    const lines = [
+      `Name: ${server.name}`,
+      `ID: ${server.id}`,
+      `Source: ${server.description || "Unknown"}`,
+      `Status: ${server.status || "unknown"}`,
+    ];
+
+    if ("url" in server.config) {
+      lines.push(`Type: HTTP`);
+      lines.push(`URL: ${server.config.url}`);
+      if (server.config.headers && Object.keys(server.config.headers).length > 0) {
+        lines.push(`Headers: ${JSON.stringify(server.config.headers, null, 2)}`);
+      }
+    } else if ("command" in server.config) {
+      lines.push(`Type: Command`);
+      lines.push(`Command: ${server.config.command}`);
+      if (server.config.args && server.config.args.length > 0) {
+        lines.push(`Arguments: ${server.config.args.join(" ")}`);
+      }
+      if (server.config.env && Object.keys(server.config.env).length > 0) {
+        lines.push(`Environment: ${JSON.stringify(server.config.env, null, 2)}`);
+      }
+      if (server.config.cwd) {
+        lines.push(`Working Directory: ${server.config.cwd}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  formatServerList(servers: IMcpServerInfo[]): string {
+    const lines: string[] = [];
+
+    if (servers.length === 0) {
+      lines.push("No MCP servers found.");
+      lines.push("");
+      lines.push("Use the following commands to manage MCP servers:");
+      lines.push("");
+      // Add the MCP help content
+      lines.push(helpText);
+    } else {
+      lines.push("📡 MCP Servers:");
+      lines.push("");
+
+      // Group servers by source
+      const serversBySource: Record<string, IMcpServerInfo[]> = {};
+      for (const server of servers) {
+        const source = this.getServerSourceLabel(server);
+        if (!serversBySource[source]) {
+          serversBySource[source] = [];
+        }
+        serversBySource[source].push(server);
+      }
+
+      for (const [source, sourceServers] of Object.entries(serversBySource)) {
+        lines.push(`  ${source}:`);
+        for (const server of sourceServers) {
+          const typeLabel = "url" in server.config ? "🌐" : "💻";
+          lines.push(`    ${typeLabel} ${server.name}`);
+        }
+        lines.push("");
+      }
+
+      lines.push("📝 Example - Add GitHub MCP Server:");
+      lines.push(
+        '  /mcp add-json github \'{"command":"npx","args":["-y","@modelcontextprotocol/server-github"],"env":{"GITHUB_PERSONAL_ACCESS_TOKEN":"your_token"}}\'',
+      );
+      lines.push("");
+    }
+
+    return lines.join("\n");
+  }
+
+  async findConfigSources(): Promise<ConfigSource[]> {
+    const sources: ConfigSource[] = [];
+
+    // Claude Desktop
+    const claudePath =
+      process.platform === "win32"
+        ? path.join(os.homedir(), "AppData", "Roaming", "Claude", "claude_desktop_config.json")
+        : process.platform === "darwin"
+          ? path.join(
+              os.homedir(),
+              "Library",
+              "Application Support",
+              "Claude",
+              "claude_desktop_config.json",
+            )
+          : path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
+    sources.push({
+      path: claudePath,
+      type: "claude-desktop",
+      label: "Claude Desktop",
+      exists: fs.existsSync(claudePath),
+    });
+
+    // Windsurf
+    const windsurfPath = path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+    sources.push({
+      path: windsurfPath,
+      type: "windsurf",
+      label: "Windsurf",
+      exists: fs.existsSync(windsurfPath),
+    });
+
+    // Cursor Global: ~/.cursor/mcp.json
+    const cursorGlobal = path.join(os.homedir(), ".cursor", "mcp.json");
+    sources.push({
+      path: cursorGlobal,
+      type: "cursor-global",
+      label: "Cursor (Global)",
+      exists: fs.existsSync(cursorGlobal),
+    });
+
+    // Cursor Workspace: .cursor/mcp.json
+    const cursorWorkspace = path.join(process.cwd(), ".cursor", "mcp.json");
+    sources.push({
+      path: cursorWorkspace,
+      type: "cursor-workspace",
+      label: "Cursor (Workspace)",
+      exists: fs.existsSync(cursorWorkspace),
+    });
+
+    const possibleProductNames = [product.fullName, "AbacusAI", "CodeLLM"];
+    for (const productName of possibleProductNames) {
+      const userDataDir = this.getUserDataDir(productName);
+      if (userDataDir) {
+        const mcpJsonPath = path.join(userDataDir, "User", "mcp.json");
+        if (fs.existsSync(mcpJsonPath)) {
+          sources.push({
+            path: mcpJsonPath,
+            type: "abacusai-user",
+            label: `${productName} (User)`,
+            exists: true,
+          });
+        }
+      }
+    }
+
+    // Standard VSCode User Settings (fallback)
+    const vscodeUserDir =
+      process.platform === "win32"
+        ? path.join(os.homedir(), "AppData", "Roaming", "Code", "User")
+        : process.platform === "darwin"
+          ? path.join(os.homedir(), "Library", "Application Support", "Code", "User")
+          : path.join(os.homedir(), ".config", "Code", "User");
+    const vscodeMcpJson = path.join(vscodeUserDir, "mcp.json");
+    sources.push({
+      path: vscodeMcpJson,
+      type: "vscode-user",
+      label: "VSCode (User)",
+      exists: fs.existsSync(vscodeMcpJson),
+    });
+
+    return sources;
+  }
+
+  private getUserDataDir(productName: string): string | null {
+    try {
+      switch (process.platform) {
+        case "win32": {
+          const appData = process.env["APPDATA"];
+          if (!appData) {
+            return null;
+          }
+          return path.join(appData, productName);
+        }
+
+        case "darwin": {
+          return path.join(os.homedir(), "Library", "Application Support", productName);
+        }
+
+        case "linux": {
+          const configHome = process.env["XDG_CONFIG_HOME"] || path.join(os.homedir(), ".config");
+          return path.join(configHome, productName);
+        }
+
+        default:
+          return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  private async loadServersFromSource(source: ConfigSource): Promise<IMcpServerInfo[]> {
+    const content = await fsPromises.readFile(source.path, "utf8");
+    const servers: IMcpServerInfo[] = [];
+
+    // Parse JSON with better error handling and trailing comma support
+    let parsedContent: any;
+    try {
+      parsedContent = this.parseJsonWithFallback(content);
+    } catch (error) {
+      throw new Error(
+        `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    if (source.type.startsWith("vscode") || source.type === "abacusai-user") {
+      let serversConfig: Record<string, IMcpServerConfig> | undefined;
+
+      if (parsedContent.servers && !parsedContent.mcp) {
+        serversConfig = parsedContent.servers;
+      } else if (parsedContent.mcp?.servers) {
+        serversConfig = parsedContent.mcp.servers;
+      }
+
+      if (serversConfig) {
+        for (const [name, serverConfig] of Object.entries(serversConfig)) {
+          servers.push({
+            id: `${source.type}.${name}`,
+            name,
+            config: serverConfig,
+            status: "stopped",
+            description: `${source.label} - ${this.getServerTypeDescription(serverConfig)}`,
+          });
+        }
+      }
+    } else if (
+      ["cursor-global", "cursor-workspace", "claude-desktop", "windsurf"].includes(source.type)
+    ) {
+      const cursorConfig: CursorGlobalConfig = parsedContent;
+
+      if (cursorConfig.mcpServers) {
+        for (const [name, serverConfig] of Object.entries(cursorConfig.mcpServers)) {
+          // Convert format to our internal format
+          const config: IMcpServerConfig = serverConfig.url
+            ? {
+                type: "http",
+                url: serverConfig.url,
+                headers: {},
+              }
+            : {
+                type: "stdio",
+                command: serverConfig.command || "",
+                args: serverConfig.args || [],
+                env: serverConfig.env || {},
+              };
+
+          servers.push({
+            id: `${source.type}.${name}`,
+            name,
+            config,
+            status: "stopped",
+            description: `${source.label} - ${this.getServerTypeDescription(config)}`,
+          });
+        }
+      }
+    }
+
+    return servers;
+  }
+
+  private parseJsonWithFallback(content: string): any {
+    // First try standard JSON parsing
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      // If that fails, try to fix common JSON issues like trailing commas
+      try {
+        // Remove trailing commas before closing braces/brackets
+        const fixedContent = content
+          .replace(/,(\s*[}\]])/g, "$1") // Remove trailing commas
+          .replace(/([}\]]),(\s*[}\]])/g, "$1$2"); // Remove commas before closing braces
+
+        return JSON.parse(fixedContent);
+      } catch (fallbackError) {
+        // If still failing, provide more detailed error info
+        const originalError = error instanceof Error ? error.message : String(error);
+        const fallbackErrorMsg =
+          fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        throw new Error(
+          `JSON parsing failed. Original error: ${originalError}. After fixing trailing commas: ${fallbackErrorMsg}`,
+        );
+      }
+    }
+  }
+
+  private async addServerToSource(
+    source: ConfigSource,
+    name: string,
+    config: IMcpServerConfig,
+  ): Promise<void> {
+    const configPath = source.path;
+    // Ensure directory exists
+    const dir = path.dirname(configPath);
+    await fsPromises.mkdir(dir, { recursive: true });
+
+    // Determine config type based on source type
+    const isVSCodeLikeSettings = ["vscode-user", "vscode-workspace", "abacusai-user"].includes(
+      source.type,
+    );
+
+    if (isVSCodeLikeSettings) {
+      if (configPath.endsWith("mcp.json")) {
+        let mcpConfig: McpConfigFile = { servers: {} };
+        if (fs.existsSync(configPath)) {
+          try {
+            const content = await fsPromises.readFile(configPath, "utf8");
+            mcpConfig = this.parseJsonWithFallback(content);
+          } catch {}
+        }
+
+        mcpConfig.servers = mcpConfig.servers || {};
+        mcpConfig.servers[name] = config;
+
+        const newContent = JSON.stringify(mcpConfig, null, 2);
+        await fsPromises.writeFile(configPath, newContent, "utf8");
+      } else {
+        let vscodeSettings: VSCodeSettings = {};
+        if (fs.existsSync(configPath)) {
+          try {
+            const content = await fsPromises.readFile(configPath, "utf8");
+            vscodeSettings = this.parseJsonWithFallback(content);
+          } catch {}
+        }
+
+        vscodeSettings.mcp = vscodeSettings.mcp || { servers: {} };
+        vscodeSettings.mcp.servers = vscodeSettings.mcp.servers || {};
+        vscodeSettings.mcp.servers[name] = config;
+
+        const newContent = JSON.stringify(vscodeSettings, null, 2);
+        await fsPromises.writeFile(configPath, newContent, "utf8");
+      }
+    } else if (source.type === "cursor-global") {
+      // Cursor Global format: { "mcpServers": { ... } }
+      let cursorConfig: CursorGlobalConfig = { mcpServers: {} };
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = await fsPromises.readFile(configPath, "utf8");
+          cursorConfig = this.parseJsonWithFallback(content);
+        } catch {
+          // Invalid JSON, start fresh
+        }
+      }
+
+      cursorConfig.mcpServers = cursorConfig.mcpServers || {};
+
+      // Convert our internal format to Cursor format
+      const cursorServerConfig =
+        "url" in config
+          ? {
+              url: config.url,
+            }
+          : {
+              command: config.command,
+              args: config.args ? [...config.args] : undefined,
+              env: config.env
+                ? Object.fromEntries(Object.entries(config.env).map(([k, v]) => [k, String(v)]))
+                : undefined,
+            };
+
+      cursorConfig.mcpServers[name] = cursorServerConfig;
+
+      const newContent = JSON.stringify(cursorConfig, null, 2);
+      await fsPromises.writeFile(configPath, newContent, "utf8");
+    } else if (source.type === "cursor-workspace") {
+      let cursorWorkspaceConfig: CursorGlobalConfig = { mcpServers: {} };
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = await fsPromises.readFile(configPath, "utf8");
+          cursorWorkspaceConfig = this.parseJsonWithFallback(content);
+        } catch {
+          // Invalid JSON, start fresh
+        }
+      }
+
+      cursorWorkspaceConfig.mcpServers = cursorWorkspaceConfig.mcpServers || {};
+
+      const cursorServerConfig =
+        "url" in config
+          ? {
+              url: config.url,
+            }
+          : {
+              command: config.command,
+              args: config.args ? [...config.args] : undefined,
+              env: config.env
+                ? Object.fromEntries(Object.entries(config.env).map(([k, v]) => [k, String(v)]))
+                : undefined,
+            };
+
+      cursorWorkspaceConfig.mcpServers[name] = cursorServerConfig;
+      const newContent = JSON.stringify(cursorWorkspaceConfig, null, 2);
+      await fsPromises.writeFile(configPath, newContent, "utf8");
+    } else {
+      throw new Error(`Unsupported config source type: ${source.type}`);
+    }
+  }
+
+  private async removeServerFromSource(configPath: string, name: string): Promise<boolean> {
+    if (!fs.existsSync(configPath)) {
+      return false;
+    }
+
+    const content = await fsPromises.readFile(configPath, "utf8");
+    const isCursorOrClaudeFormat =
+      configPath.includes(".cursor") ||
+      configPath.includes("claude_desktop_config.json") ||
+      configPath.includes("mcp_config.json"); // Windsurf
+
+    if (configPath.endsWith("mcp.json")) {
+      const mcpConfig: McpConfigFile = this.parseJsonWithFallback(content);
+
+      if (!mcpConfig.servers || !mcpConfig.servers[name]) {
+        return false;
+      }
+
+      delete mcpConfig.servers[name];
+
+      const newContent = JSON.stringify(mcpConfig, null, 2);
+      await fsPromises.writeFile(configPath, newContent, "utf8");
+      return true;
+    } else if (configPath.endsWith("settings.json")) {
+      const vscodeSettings: VSCodeSettings = this.parseJsonWithFallback(content);
+      const config = vscodeSettings?.mcp || { servers: {} };
+
+      if (!config.servers || !config.servers[name]) {
+        return false;
+      }
+
+      delete config.servers[name];
+      vscodeSettings.mcp = config;
+
+      const newContent = JSON.stringify(vscodeSettings, null, 2);
+      await fsPromises.writeFile(configPath, newContent, "utf8");
+      return true;
+    } else if (isCursorOrClaudeFormat) {
+      // Claude/Cursor/Windsurf format - matches GUI's claudeConfigToServerDefinition
+      const cursorConfig: CursorGlobalConfig = this.parseJsonWithFallback(content);
+
+      if (!cursorConfig.mcpServers || !cursorConfig.mcpServers[name]) {
+        return false;
+      }
+
+      delete cursorConfig.mcpServers[name];
+
+      const newContent = JSON.stringify(cursorConfig, null, 2);
+      await fsPromises.writeFile(configPath, newContent, "utf8");
+      return true;
+    } else {
+      throw new Error(`Unsupported config file format: ${configPath}`);
+    }
+  }
+
+  private validateServerConfig(config: IMcpServerConfig): void {
+    // Check if config is null, undefined, or not an object
+    if (!config || typeof config !== "object") {
+      throw new Error("Server configuration must be a valid object");
+    }
+
+    // Check for invalid top-level properties that suggest wrong format
+    if ("mcpServers" in config || "servers" in config) {
+      throw new Error(
+        'Invalid configuration format. Server configuration should not contain "mcpServers" or "servers" properties. Each server should be configured individually.',
+      );
+    }
+
+    if ("url" in config) {
+      // HTTP server validation
+      if (!config.url) {
+        throw new Error("URL is required for HTTP servers");
+      }
+      if (typeof config.url !== "string") {
+        throw new Error("URL must be a string");
+      }
+      if (!config.url.startsWith("http://") && !config.url.startsWith("https://")) {
+        throw new Error("URL must start with http:// or https://");
+      }
+    } else if ("command" in config) {
+      // Stdio server validation
+      if (!config.command) {
+        throw new Error("Command is required for stdio servers");
+      }
+      if (typeof config.command !== "string") {
+        throw new Error("Command must be a string");
+      }
+      // Validate args if present
+      if (config.args && !Array.isArray(config.args)) {
+        throw new Error("Arguments must be an array");
+      }
+      if (config.args && config.args.some((arg) => typeof arg !== "string")) {
+        throw new Error("All arguments must be strings");
+      }
+    } else {
+      throw new Error('Server configuration must have either "url" or "command" property');
+    }
+  }
+
+  private getServerTypeDescription(config: IMcpServerConfig): string {
+    if ("url" in config) {
+      return `HTTP server at ${config.url}`;
+    } else if ("command" in config) {
+      const argsStr = config.args && config.args.length > 0 ? ` ${config.args.join(" ")}` : "";
+      return `Command: ${config.command}${argsStr}`;
+    }
+    return "Unknown server type";
+  }
+
+  private getServerSourceLabel(server: IMcpServerInfo): string {
+    if (server.id.startsWith("claude-desktop")) {
+      return "Claude Desktop";
+    } else if (server.id.startsWith("windsurf")) {
+      return "Windsurf";
+    } else if (server.id.startsWith("cursor-global")) {
+      return "Cursor (Global)";
+    } else if (server.id.startsWith("cursor-workspace")) {
+      return "Cursor (Workspace)";
+    } else if (server.id.startsWith("abacusai-user")) {
+      const isDev =
+        server.description?.includes(`${product.fullName}-dev`) ||
+        server.description?.includes("CodeLLM-dev");
+      return isDev ? `${product.fullName}-dev (User)` : `${product.fullName} (User)`;
+    } else if (server.id.startsWith("vscode-user")) {
+      return "VSCode (User)";
+    } else if (server.id.startsWith("vscode-workspace")) {
+      return "VSCode (Workspace)";
+    }
+    return "Other";
+  }
+}