@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.3

package/src/lib/standaloneMcpService.ts

@@ -1,688 +0,0 @@
-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";
-  }
-}