centaurus-cli 3.0.0 → 3.1.0

package/dist/config/mcp-config-manager.js

@@ -1,402 +1,449 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { logWarning } from '../utils/logger.js';
-export class MCPConfigManager {
-    configPath;
-    config;
-    constructor(configDir) {
-        const baseDir = configDir || path.join(os.homedir(), '.centaurus');
-        this.configPath = path.join(baseDir, 'mcp-config.json');
-        this.config = this.load();
-    }
-    getConfigPath() {
-        return this.configPath;
-    }
-    load() {
-        try {
-            if (fs.existsSync(this.configPath)) {
-                const content = fs.readFileSync(this.configPath, 'utf-8');
-                // Handle empty file
-                if (!content.trim()) {
-                    logWarning('[MCP Config] Config file is empty');
-                    return this.getDefaultConfig();
-                }
-                let rawConfig;
-                try {
-                    rawConfig = JSON.parse(content);
-                }
-                catch (parseError) {
-                    logWarning(`[MCP Config] Invalid JSON: ${parseError.message}`);
-                    return this.getDefaultConfig();
-                }
-                // Normalize the config to standard format
-                const normalizedConfig = this.normalizeConfig(rawConfig);
-                if (normalizedConfig.servers.length === 0) {
-                    logWarning('[MCP Config] No servers found in config file');
-                }
-                return normalizedConfig;
-            }
-            else {
-                // Config file doesn't exist - create directory and return default
-                const configDir = path.dirname(this.configPath);
-                if (!fs.existsSync(configDir)) {
-                    fs.mkdirSync(configDir, { recursive: true });
-                }
-            }
-        }
-        catch (error) {
-            logWarning(`[MCP Config] Failed to load config: ${error.message}`);
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logWarning } from "../utils/logger.js";
+class MCPConfigManager {
+  configPath;
+  config;
+  constructor(configDir) {
+    const baseDir = configDir || path.join(os.homedir(), ".centaurus");
+    this.configPath = path.join(baseDir, "mcp-config.json");
+    this.config = this.load();
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const content = fs.readFileSync(this.configPath, "utf-8");
+        if (!content.trim()) {
+          logWarning("[MCP Config] Config file is empty");
+          return this.getDefaultConfig();
         }
-        return this.getDefaultConfig();
-    }
-    /**
-     * Normalize config from different formats to standard format
-     * Supports:
-     * 1. mcp_servers format (preferred): { "mcp_servers": { "serverName": { "command": "...", ... } } }
-     * 2. Array format: { "servers": [{ "name": "x", "command": "y", ... }] }
-     * 3. Object format: { "serverName": { "command": "y", ... } } - keys become server names
-     * 4. mcpServers format (VSCode/Claude style): { "mcpServers": { ... } }
-     */
-    normalizeConfig(rawConfig) {
-        // If it's null or not an object, return default
-        if (!rawConfig || typeof rawConfig !== 'object') {
-            return this.getDefaultConfig();
-        }
-        // Format 1 (PREFERRED): Check for "mcp_servers" key (snake_case) - object format
-        if (rawConfig.mcp_servers && typeof rawConfig.mcp_servers === 'object' && !Array.isArray(rawConfig.mcp_servers)) {
-            return this.convertObjectToArrayFormat(rawConfig.mcp_servers);
-        }
-        // Format 2: Standard array format with "servers" key
-        if (Array.isArray(rawConfig.servers)) {
-            const validServers = rawConfig.servers
-                .filter((s) => this.validateServerConfig(s))
-                .map((s) => this.sanitizeServerConfig(s));
-            return { servers: validServers };
-        }
-        // Format 3: Check for "mcpServers" key (VSCode/Claude Desktop style - camelCase)
-        if (rawConfig.mcpServers && typeof rawConfig.mcpServers === 'object') {
-            return this.convertObjectToArrayFormat(rawConfig.mcpServers);
+        let rawConfig;
+        try {
+          rawConfig = JSON.parse(content);
+        } catch (parseError) {
+          logWarning(`[MCP Config] Invalid JSON: ${parseError.message}`);
+          return this.getDefaultConfig();
         }
-        // Format 4: Object format where keys are server names (legacy)
-        // Check if any top-level key looks like a server config (has 'command' property)
-        const potentialServers = Object.entries(rawConfig).filter(([key, value]) => key !== 'servers' &&
-            key !== 'mcpServers' &&
-            key !== 'mcp_servers' &&
-            value &&
-            typeof value === 'object' &&
-            'command' in value);
-        if (potentialServers.length > 0) {
-            return this.convertObjectToArrayFormat(rawConfig);
+        const normalizedConfig = this.normalizeConfig(rawConfig);
+        if (normalizedConfig.servers.length === 0) {
+          logWarning("[MCP Config] No servers found in config file");
         }
-        // If we have a 'servers' key but it's not an array, try to handle it
-        if (rawConfig.servers && typeof rawConfig.servers === 'object' && !Array.isArray(rawConfig.servers)) {
-            return this.convertObjectToArrayFormat(rawConfig.servers);
+        return normalizedConfig;
+      } else {
+        const configDir = path.dirname(this.configPath);
+        if (!fs.existsSync(configDir)) {
+          fs.mkdirSync(configDir, { recursive: true });
         }
-        logWarning('[MCP Config] Unrecognized config format');
-        return this.getDefaultConfig();
+      }
+    } catch (error) {
+      logWarning(`[MCP Config] Failed to load config: ${error.message}`);
     }
-    /**
-     * Convert object-based format to array format
-     * { "serverName": { "command": "x", ... } } => { "servers": [{ "name": "serverName", "command": "x", ... }] }
-     */
-    convertObjectToArrayFormat(configObject) {
-        const servers = [];
-        for (const [name, serverConfig] of Object.entries(configObject)) {
-            if (!serverConfig || typeof serverConfig !== 'object') {
-                logWarning(`[MCP Config] Skipping invalid server entry: ${name}`);
-                continue;
-            }
-            // Build server config with name from key
-            const server = {
-                name,
-                command: serverConfig.command,
-                args: serverConfig.args,
-                env: serverConfig.env,
-                enabled: serverConfig.enabled,
-                auth: serverConfig.auth
-            };
-            if (this.validateServerConfig(server)) {
-                servers.push(this.sanitizeServerConfig(server));
-            }
-        }
-        return { servers };
+    return this.getDefaultConfig();
+  }
+  /**
+   * Normalize config from different formats to standard format
+   * Supports:
+   * 1. mcp_servers format (preferred): { "mcp_servers": { "serverName": { "command": "...", ... } } }
+   * 2. Array format: { "servers": [{ "name": "x", "command": "y", ... }] }
+   * 3. Object format: { "serverName": { "command": "y", ... } } - keys become server names
+   * 4. mcpServers format (VSCode/Claude style): { "mcpServers": { ... } }
+   */
+  normalizeConfig(rawConfig) {
+    if (!rawConfig || typeof rawConfig !== "object") {
+      return this.getDefaultConfig();
     }
-    /**
-     * Validate a server config has required fields
-     */
-    validateServerConfig(config) {
-        if (!config || typeof config !== 'object') {
-            return false;
-        }
-        if (!config.name || typeof config.name !== 'string') {
-            logWarning('[MCP Config] Server missing required "name" field');
-            return false;
-        }
-        if (!config.command || typeof config.command !== 'string') {
-            logWarning(`[MCP Config] Server "${config.name}" missing required "command" field`);
-            return false;
-        }
-        return true;
+    if (rawConfig.mcp_servers && typeof rawConfig.mcp_servers === "object" && !Array.isArray(rawConfig.mcp_servers)) {
+      return this.convertObjectToArrayFormat(rawConfig.mcp_servers);
     }
-    /**
-     * Sanitize and set defaults for server config
-     */
-    sanitizeServerConfig(config) {
-        return {
-            name: config.name,
-            command: config.command,
-            args: Array.isArray(config.args) ? config.args : undefined,
-            env: config.env && typeof config.env === 'object' ? config.env : undefined,
-            enabled: config.enabled !== false, // Default to enabled
-            auth: config.auth
-        };
+    if (Array.isArray(rawConfig.servers)) {
+      const validServers = rawConfig.servers.filter((s) => this.validateServerConfig(s)).map((s) => this.sanitizeServerConfig(s));
+      return { servers: validServers };
     }
-    save(config) {
-        try {
-            const configDir = path.dirname(this.configPath);
-            // Ensure config directory exists
-            if (!fs.existsSync(configDir)) {
-                fs.mkdirSync(configDir, { recursive: true });
-            }
-            // Convert to mcp_servers object format (preferred format)
-            const mcpServersFormat = {};
-            for (const server of config.servers) {
-                const serverConfig = {
-                    command: server.command
-                };
-                if (server.args && server.args.length > 0) {
-                    serverConfig.args = server.args;
-                }
-                if (server.env && Object.keys(server.env).length > 0) {
-                    serverConfig.env = server.env;
-                }
-                if (server.enabled === false) {
-                    serverConfig.enabled = false;
-                }
-                if (server.auth) {
-                    serverConfig.auth = server.auth;
-                }
-                mcpServersFormat[server.name] = serverConfig;
-            }
-            const outputConfig = { mcp_servers: mcpServersFormat };
-            fs.writeFileSync(this.configPath, JSON.stringify(outputConfig, null, 2), 'utf-8');
-            this.config = config;
-        }
-        catch (error) {
-            throw new Error(`Failed to save MCP config: ${error}`);
-        }
+    if (rawConfig.mcpServers && typeof rawConfig.mcpServers === "object") {
+      return this.convertObjectToArrayFormat(rawConfig.mcpServers);
     }
-    getServers() {
-        return this.config.servers.filter(s => s.enabled !== false);
+    const potentialServers = Object.entries(rawConfig).filter(
+      ([key, value]) => key !== "servers" && key !== "mcpServers" && key !== "mcp_servers" && value && typeof value === "object" && "command" in value
+    );
+    if (potentialServers.length > 0) {
+      return this.convertObjectToArrayFormat(rawConfig);
     }
-    getAllServers() {
-        return this.config.servers;
+    if (rawConfig.servers && typeof rawConfig.servers === "object" && !Array.isArray(rawConfig.servers)) {
+      return this.convertObjectToArrayFormat(rawConfig.servers);
     }
-    /**
-     * Reload config from disk into cache
-     * Call this when user runs /mcp refresh
-     */
-    reload() {
-        this.config = this.load();
-        return this.config;
+    logWarning("[MCP Config] Unrecognized config format");
+    return this.getDefaultConfig();
+  }
+  /**
+   * Convert object-based format to array format
+   * { "serverName": { "command": "x", ... } } => { "servers": [{ "name": "serverName", "command": "x", ... }] }
+   */
+  convertObjectToArrayFormat(configObject) {
+    const servers = [];
+    for (const [name, serverConfig] of Object.entries(configObject)) {
+      if (!serverConfig || typeof serverConfig !== "object") {
+        logWarning(`[MCP Config] Skipping invalid server entry: ${name}`);
+        continue;
+      }
+      const server = {
+        name,
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env,
+        enabled: serverConfig.enabled,
+        auth: serverConfig.auth
+      };
+      if (this.validateServerConfig(server)) {
+        servers.push(this.sanitizeServerConfig(server));
+      }
     }
-    addServer(server) {
-        this.config.servers.push(server);
-        this.save(this.config);
+    return { servers };
+  }
+  /**
+   * Validate a server config has required fields
+   */
+  validateServerConfig(config) {
+    if (!config || typeof config !== "object") {
+      return false;
     }
-    removeServer(name) {
-        this.config.servers = this.config.servers.filter(s => s.name !== name);
-        this.save(this.config);
+    if (!config.name || typeof config.name !== "string") {
+      logWarning('[MCP Config] Server missing required "name" field');
+      return false;
     }
-    enableServer(name) {
-        const index = this.config.servers.findIndex(s => s.name === name);
-        if (index !== -1) {
-            this.config.servers[index].enabled = true;
-            this.save(this.config);
-        }
+    if (!config.command || typeof config.command !== "string") {
+      logWarning(`[MCP Config] Server "${config.name}" missing required "command" field`);
+      return false;
     }
-    disableServer(name) {
-        const index = this.config.servers.findIndex(s => s.name === name);
-        if (index !== -1) {
-            this.config.servers[index].enabled = false;
-            this.save(this.config);
+    return true;
+  }
+  /**
+   * Sanitize and set defaults for server config
+   */
+  sanitizeServerConfig(config) {
+    return {
+      name: config.name,
+      command: config.command,
+      args: Array.isArray(config.args) ? config.args : void 0,
+      env: config.env && typeof config.env === "object" ? config.env : void 0,
+      enabled: config.enabled !== false,
+      // Default to enabled
+      auth: config.auth
+    };
+  }
+  save(config) {
+    try {
+      const configDir = path.dirname(this.configPath);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+      const mcpServersFormat = {};
+      for (const server of config.servers) {
+        const serverConfig = {
+          command: server.command
+        };
+        if (server.args && server.args.length > 0) {
+          serverConfig.args = server.args;
         }
-    }
-    updateServer(name, updates) {
-        const index = this.config.servers.findIndex(s => s.name === name);
-        if (index !== -1) {
-            this.config.servers[index] = { ...this.config.servers[index], ...updates };
-            this.save(this.config);
+        if (server.env && Object.keys(server.env).length > 0) {
+          serverConfig.env = server.env;
+        }
+        if (server.enabled === false) {
+          serverConfig.enabled = false;
         }
+        if (server.auth) {
+          serverConfig.auth = server.auth;
+        }
+        mcpServersFormat[server.name] = serverConfig;
+      }
+      const outputConfig = { mcp_servers: mcpServersFormat };
+      fs.writeFileSync(this.configPath, JSON.stringify(outputConfig, null, 2), "utf-8");
+      this.config = config;
+    } catch (error) {
+      throw new Error(`Failed to save MCP config: ${error}`);
+    }
+  }
+  getServers() {
+    return this.config.servers.filter((s) => s.enabled !== false);
+  }
+  getAllServers() {
+    return this.config.servers;
+  }
+  /**
+   * Reload config from disk into cache
+   * Call this when user runs /mcp refresh
+   */
+  reload() {
+    this.config = this.load();
+    return this.config;
+  }
+  addServer(server) {
+    this.config.servers.push(server);
+    this.save(this.config);
+  }
+  removeServer(name) {
+    this.config.servers = this.config.servers.filter((s) => s.name !== name);
+    this.save(this.config);
+  }
+  enableServer(name) {
+    const index = this.config.servers.findIndex((s) => s.name === name);
+    if (index !== -1) {
+      this.config.servers[index].enabled = true;
+      this.save(this.config);
     }
-    /**
-     * Validate a server config JSON string and return parsed config or error
-     * Supports multiple formats:
-     * 1. "server-name": {"command": "...", "args": [...]}
-     * 2. {"server-name": {"command": "...", "args": [...]}}
-     * 3. {"mcpServers": {"server-name": {"command": "...", "args": [...]}}}
-     * 4. {"name": "server-name", "command": "...", "args": [...]}
-     */
-    validateServerConfigJSON(jsonString) {
+  }
+  disableServer(name) {
+    const index = this.config.servers.findIndex((s) => s.name === name);
+    if (index !== -1) {
+      this.config.servers[index].enabled = false;
+      this.save(this.config);
+    }
+  }
+  updateServer(name, updates) {
+    const index = this.config.servers.findIndex((s) => s.name === name);
+    if (index !== -1) {
+      this.config.servers[index] = { ...this.config.servers[index], ...updates };
+      this.save(this.config);
+    }
+  }
+  /**
+   * Validate a server config JSON string and return parsed config or error
+   * Supports multiple formats:
+   * 1. "server-name": {"command": "...", "args": [...]}
+   * 2. {"server-name": {"command": "...", "args": [...]}}
+   * 3. {"mcpServers": {"server-name": {"command": "...", "args": [...]}}}
+   * 4. {"name": "server-name", "command": "...", "args": [...]}
+   */
+  validateServerConfigJSON(jsonString) {
+    try {
+      let parsed;
+      let parseErrorMsg = "";
+      const cleanJson = this.sanitizeJsonString(jsonString);
+      try {
+        parsed = JSON.parse(cleanJson);
+      } catch (e1) {
+        parseErrorMsg = e1.message;
         try {
-            let parsed;
-            let parseErrorMsg = '';
-            // Sanitize input (remove comments, trailing commas)
-            const cleanJson = this.sanitizeJsonString(jsonString);
-            // 1. Try direct parse
+          parsed = JSON.parse(`{${cleanJson}}`);
+        } catch (e2) {
+          try {
+            parsed = JSON.parse(`${cleanJson}}`);
+          } catch (e3) {
             try {
-                parsed = JSON.parse(cleanJson);
-            }
-            catch (e1) {
-                parseErrorMsg = e1.message;
-                // 2. Try wrapping in braces (for pasted properties like "key": { ... })
-                try {
-                    parsed = JSON.parse(`{${cleanJson}}`);
-                }
-                catch (e2) {
-                    // 3. Try appending closing brace (common copy-paste error)
-                    try {
-                        parsed = JSON.parse(`${cleanJson}}`);
-                    }
-                    catch (e3) {
-                        // 4. Try both
-                        try {
-                            parsed = JSON.parse(`{${cleanJson}}`);
-                        }
-                        catch (e4) {
-                            return { valid: false, error: `Invalid JSON: ${parseErrorMsg}` };
-                        }
-                    }
-                }
+              parsed = JSON.parse(`{${cleanJson}}`);
+            } catch (e4) {
+              return { valid: false, error: `Invalid JSON: ${parseErrorMsg}` };
             }
-            // Strategy: Extract server name and config from various formats
-            // Check 1: Is the root itself a server config with "name" field?
-            // Format: {"name": "server-name", "command": "...", "args": [...]}
-            if (this.isValidServerShape(parsed) && parsed.name) {
-                return this.finalizeValidation(parsed);
-            }
-            // Check 2: Is it wrapped in "mcpServers" or "mcp_servers"?
-            // Format: {"mcpServers": {"server-name": {"command": "...", "args": [...]}}}
-            const inner = parsed.mcpServers || parsed.mcp_servers || parsed.servers;
-            if (inner && typeof inner === 'object') {
-                // If array, take first
-                if (Array.isArray(inner) && inner.length > 0 && this.isValidServerShape(inner[0])) {
-                    return this.finalizeValidation(inner[0]);
-                }
-                // If object, extract first server entry
-                if (!Array.isArray(inner)) {
-                    const entries = Object.entries(inner);
-                    if (entries.length > 0) {
-                        const [serverName, serverConfig] = entries[0];
-                        if (this.isValidServerShape(serverConfig)) {
-                            // Inject key as name if missing
-                            const configWithName = { ...serverConfig, name: serverName };
-                            return this.finalizeValidation(configWithName);
-                        }
-                    }
-                }
-            }
-            // Check 3: Is it a single server entry without wrapper?
-            // Format: {"server-name": {"command": "...", "args": [...]}}
-            // or Format: "server-name": {"command": "...", "args": [...]}
-            const entries = Object.entries(parsed);
-            if (entries.length === 1) {
-                const [serverName, serverConfig] = entries[0];
-                // Skip known wrapper keys
-                if (serverName !== 'mcpServers' && serverName !== 'servers' && serverName !== 'mcp_servers') {
-                    if (this.isValidServerShape(serverConfig)) {
-                        // Inject key as name
-                        const configWithName = { ...serverConfig, name: serverName };
-                        return this.finalizeValidation(configWithName);
-                    }
-                }
-            }
-            // Check 4: Multiple server entries - take the first one
-            for (const [key, val] of entries) {
-                if (key !== 'mcpServers' && key !== 'servers' && key !== 'mcp_servers' && this.isValidServerShape(val)) {
-                    // Inject key as name
-                    const configWithName = { ...val, name: key };
-                    return this.finalizeValidation(configWithName);
-                }
+          }
+        }
+      }
+      if (this.isValidServerShape(parsed) && parsed.name) {
+        return this.finalizeValidation(parsed);
+      }
+      const inner = parsed.mcpServers || parsed.mcp_servers || parsed.servers;
+      if (inner && typeof inner === "object") {
+        if (Array.isArray(inner) && inner.length > 0 && this.isValidServerShape(inner[0])) {
+          return this.finalizeValidation(inner[0]);
+        }
+        if (!Array.isArray(inner)) {
+          const entries2 = Object.entries(inner);
+          if (entries2.length > 0) {
+            const [serverName, serverConfig] = entries2[0];
+            if (this.isValidServerShape(serverConfig)) {
+              const configWithName = { ...serverConfig, name: serverName };
+              return this.finalizeValidation(configWithName);
             }
-            return { valid: false, error: 'Could not find a valid MCP server configuration (must have "command" field)' };
+          }
+        }
+      }
+      const entries = Object.entries(parsed);
+      if (entries.length === 1) {
+        const [serverName, serverConfig] = entries[0];
+        if (serverName !== "mcpServers" && serverName !== "servers" && serverName !== "mcp_servers") {
+          if (this.isValidServerShape(serverConfig)) {
+            const configWithName = { ...serverConfig, name: serverName };
+            return this.finalizeValidation(configWithName);
+          }
         }
-        catch (parseError) {
-            return { valid: false, error: `Unexpected error: ${parseError.message}` };
+      }
+      for (const [key, val] of entries) {
+        if (key !== "mcpServers" && key !== "servers" && key !== "mcp_servers" && this.isValidServerShape(val)) {
+          const configWithName = { ...val, name: key };
+          return this.finalizeValidation(configWithName);
         }
+      }
+      return { valid: false, error: 'Could not find a valid MCP server configuration (must have "command" field)' };
+    } catch (parseError) {
+      return { valid: false, error: `Unexpected error: ${parseError.message}` };
     }
-    isValidServerShape(obj) {
-        return obj && typeof obj === 'object' && typeof obj.command === 'string';
+  }
+  isValidServerShape(obj) {
+    return obj && typeof obj === "object" && typeof obj.command === "string";
+  }
+  finalizeValidation(parsed) {
+    if (!parsed.name || typeof parsed.name !== "string") {
+      return { valid: false, error: 'Missing or invalid "name" field' };
     }
-    finalizeValidation(parsed) {
-        // Ensure name exists
-        if (!parsed.name || typeof parsed.name !== 'string') {
-            return { valid: false, error: 'Missing or invalid "name" field' };
-        }
-        // Trim and validate name
-        const serverName = parsed.name.trim();
-        if (!serverName) {
-            return { valid: false, error: 'Server name cannot be empty' };
+    const serverName = parsed.name.trim();
+    if (!serverName) {
+      return { valid: false, error: "Server name cannot be empty" };
+    }
+    const existingNames = this.config.servers.map((s) => s.name.toLowerCase());
+    if (existingNames.includes(serverName.toLowerCase())) {
+      return { valid: false, error: `Server with name "${serverName}" already exists` };
+    }
+    if (parsed.args !== void 0 && !Array.isArray(parsed.args)) {
+      return { valid: false, error: '"args" must be an array of strings' };
+    }
+    if (parsed.env !== void 0 && (typeof parsed.env !== "object" || Array.isArray(parsed.env))) {
+      return { valid: false, error: '"env" must be an object with string values' };
+    }
+    const config = {
+      name: serverName,
+      command: parsed.command,
+      args: Array.isArray(parsed.args) ? parsed.args : void 0,
+      env: parsed.env && typeof parsed.env === "object" ? parsed.env : void 0,
+      enabled: parsed.enabled !== false,
+      auth: parsed.auth
+    };
+    return { valid: true, config };
+  }
+  getDefaultConfig() {
+    return {
+      servers: []
+    };
+  }
+  /**
+   * Helper to clean up JSON string (remove comments, trailing commas)
+   */
+  sanitizeJsonString(str) {
+    try {
+      const withoutComments = this.stripCommentsOutsideStrings(str);
+      return this.removeTrailingCommasOutsideStrings(withoutComments);
+    } catch (e) {
+      return str;
+    }
+  }
+  /**
+   * Remove JS-style comments from JSON-like input, but only when they appear
+   * outside of quoted JSON strings (so values like "https://..." remain intact).
+   */
+  stripCommentsOutsideStrings(input) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+      const next = input[i + 1];
+      if (inLineComment) {
+        if (char === "\n" || char === "\r") {
+          inLineComment = false;
+          result += char;
         }
-        // Check for duplicate name
-        const existingNames = this.config.servers.map(s => s.name.toLowerCase());
-        if (existingNames.includes(serverName.toLowerCase())) {
-            return { valid: false, error: `Server with name "${serverName}" already exists` };
+        continue;
+      }
+      if (inBlockComment) {
+        if (char === "*" && next === "/") {
+          inBlockComment = false;
+          i++;
+          continue;
         }
-        // Validate optional fields
-        if (parsed.args !== undefined && !Array.isArray(parsed.args)) {
-            return { valid: false, error: '"args" must be an array of strings' };
+        if (char === "\n" || char === "\r") {
+          result += char;
         }
-        if (parsed.env !== undefined && (typeof parsed.env !== 'object' || Array.isArray(parsed.env))) {
-            return { valid: false, error: '"env" must be an object with string values' };
+        continue;
+      }
+      if (inString) {
+        result += char;
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
         }
-        const config = {
-            name: serverName,
-            command: parsed.command,
-            args: Array.isArray(parsed.args) ? parsed.args : undefined,
-            env: parsed.env && typeof parsed.env === 'object' ? parsed.env : undefined,
-            enabled: parsed.enabled !== false,
-            auth: parsed.auth
-        };
-        return { valid: true, config };
-    }
-    getDefaultConfig() {
-        return {
-            servers: []
-        };
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        result += char;
+        continue;
+      }
+      if (char === "/" && next === "/") {
+        inLineComment = true;
+        i++;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        inBlockComment = true;
+        i++;
+        continue;
+      }
+      result += char;
     }
-    /**
-     * Helper to clean up JSON string (remove comments, trailing commas)
-     */
-    sanitizeJsonString(str) {
-        try {
-            // Remove single line comments // ...
-            let clean = str.replace(/\/\/.*$/gm, '');
-            // Remove multi-line comments /* ... */
-            clean = clean.replace(/\/\*[\s\S]*?\*\//g, '');
-            // Remove trailing commas before } or ]
-            clean = clean.replace(/,(\s*[}\]])/g, '$1');
-            return clean;
+    return result;
+  }
+  /**
+   * Remove trailing commas before closing } or ], while respecting strings.
+   */
+  removeTrailingCommasOutsideStrings(input) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+      if (inString) {
+        result += char;
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        result += char;
+        continue;
+      }
+      if (char === ",") {
+        let j = i + 1;
+        while (j < input.length && /\s/.test(input[j])) {
+          j++;
         }
-        catch (e) {
-            return str;
+        const nextNonWhitespace = input[j];
+        if (nextNonWhitespace === "}" || nextNonWhitespace === "]") {
+          continue;
         }
+      }
+      result += char;
     }
-    createExampleConfig() {
-        const exampleConfig = {
-            servers: [
-                {
-                    name: 'example-filesystem',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-filesystem', os.homedir()],
-                    enabled: false
-                }
-            ]
-        };
-        if (!fs.existsSync(this.configPath)) {
-            this.save(exampleConfig);
+    return result;
+  }
+  createExampleConfig() {
+    const exampleConfig = {
+      servers: [
+        {
+          name: "example-filesystem",
+          command: "npx",
+          args: ["-y", "@modelcontextprotocol/server-filesystem", os.homedir()],
+          enabled: false
         }
+      ]
+    };
+    if (!fs.existsSync(this.configPath)) {
+      this.save(exampleConfig);
     }
+  }
 }
+export {
+  MCPConfigManager
+};
 //# sourceMappingURL=mcp-config-manager.js.map