mcp-config-manager 1.0.2

package/src/cli.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { MCPConfigManager } from './config-manager.js';
+
+const manager = new MCPConfigManager();
+
+program
+  .name('mcp-manager')
+  .description('CLI to manage MCP configurations across different AI clients')
+  .version('1.0.0');
+
+program
+  .command('list')
+  .description('List all supported clients and their config status')
+  .action(async () => {
+    try {
+      const clients = await manager.listClients();
+      console.log('\nSupported MCP Clients:\n');
+
+      for (const client of clients) {
+        const status = client.exists ? `✓ ${client.serverCount || 0} server(s)` : '✗ No config';
+        console.log(`  ${client.name.padEnd(20)} ${status.padEnd(20)} ${client.configPath}`);
+      }
+    } catch (error) {
+      console.error('Error:', error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('show <client>')
+  .description('Show MCP servers for a client')
+  .action(async (client) => {
+    try {
+      const config = await manager.readConfig(client);
+      console.log(`\nMCP Servers for ${client}:\n`);
+
+      if (Object.keys(config.servers).length === 0) {
+        console.log('  No servers configured');
+      } else {
+        for (const [name, server] of Object.entries(config.servers)) {
+          console.log(`  ${name}:`);
+          console.log(`    Command: ${server.command || 'N/A'}`);
+          if (server.args) console.log(`    Args: ${server.args.join(' ')}`);
+          if (server.env) {
+            console.log(`    Environment variables:`);
+            for (const [key, value] of Object.entries(server.env)) {
+              const displayValue = value.includes('KEY') || value.includes('SECRET')
+                ? value.substring(0, 4) + '***'
+                : value;
+              console.log(`      ${key}: ${displayValue}`);
+            }
+          }
+          console.log();
+        }
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('add <client> <serverName>')
+  .description('Add a new MCP server to a client')
+  .option('-c, --command <cmd>', 'Command to run the server')
+  .option('-a, --args <args...>', 'Arguments for the command')
+  .option('-e, --env <env...>', 'Environment variables (key=value)')
+  .action(async (client, serverName, options) => {
+    try {
+      const serverConfig = {};
+
+      if (options.command) serverConfig.command = options.command;
+      if (options.args) serverConfig.args = options.args;
+      if (options.env) {
+        serverConfig.env = {};
+        for (const envVar of options.env) {
+          const [key, ...valueParts] = envVar.split('=');
+          serverConfig.env[key] = valueParts.join('=');
+        }
+      }
+
+      await manager.addServer(client, serverName, serverConfig);
+      console.log(`✓ Added server '${serverName}' to ${client}`);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('remove <client> <serverName>')
+  .description('Remove an MCP server from a client (use "all" for client to remove from all)')
+  .action(async (client, serverName) => {
+    try {
+      if (client === 'all') {
+        const clients = manager.getSupportedClients();
+        let removedCount = 0;
+
+        for (const targetClient of clients) {
+          try {
+            const config = await manager.readConfig(targetClient.id);
+            if (config.servers[serverName]) {
+              await manager.removeServer(targetClient.id, serverName);
+              console.log(`  ✓ Removed from ${targetClient.name}`);
+              removedCount++;
+            }
+          } catch (err) {
+            // Server doesn't exist in this client, skip
+          }
+        }
+
+        console.log(`\n✓ Removed '${serverName}' from ${removedCount} client(s)`);
+      } else {
+        await manager.removeServer(client, serverName);
+        console.log(`✓ Removed server '${serverName}' from ${client}`);
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('copy <fromClient> <serverName> <toClient>')
+  .description('Copy an MCP server from one client to another (use "all" for toClient to copy to all)')
+  .option('-n, --new-name <name>', 'New name for the copied server')
+  .action(async (fromClient, serverName, toClient, options) => {
+    try {
+      if (toClient === 'all') {
+        const clients = manager.getSupportedClients();
+        let copiedCount = 0;
+        for (const client of clients) {
+          if (client.id !== fromClient) {
+            try {
+              await manager.copyServer(fromClient, serverName, client.id, options.newName);
+              console.log(`  ✓ Copied to ${client.name}`);
+              copiedCount++;
+            } catch (err) {
+              console.log(`  ✗ Failed to copy to ${client.name}: ${err.message}`);
+            }
+          }
+        }
+        console.log(`\n✓ Copied '${serverName}' to ${copiedCount} client(s)`);
+      } else {
+        await manager.copyServer(fromClient, serverName, toClient, options.newName);
+        const targetName = options.newName || serverName;
+        console.log(`✓ Copied '${serverName}' from ${fromClient} to ${toClient} as '${targetName}'`);
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('env <client> <serverName> <action> [key] [value]')
+  .description('Manage environment variables (action: set|unset|list)')
+  .action(async (client, serverName, action, key, value) => {
+    try {
+      const config = await manager.readConfig(client);
+      const server = config.servers[serverName];
+
+      if (!server) {
+        console.error(`Server '${serverName}' not found in ${client}`);
+        process.exit(1);
+      }
+
+      if (action === 'list') {
+        console.log(`\nEnvironment variables for ${serverName}:\n`);
+        if (server.env) {
+          for (const [k, v] of Object.entries(server.env)) {
+            const displayValue = v.includes('KEY') || v.includes('SECRET')
+              ? v.substring(0, 4) + '***'
+              : v;
+            console.log(`  ${k}: ${displayValue}`);
+          }
+        } else {
+          console.log('  No environment variables set');
+        }
+      } else if (action === 'set') {
+        if (!key || !value) {
+          console.error('Both key and value required for set action');
+          process.exit(1);
+        }
+        await manager.updateServerEnv(client, serverName, key, value);
+        console.log(`✓ Set ${key} for server '${serverName}' in ${client}`);
+      } else if (action === 'unset') {
+        if (!key) {
+          console.error('Key required for unset action');
+          process.exit(1);
+        }
+        await manager.updateServerEnv(client, serverName, key, null);
+        console.log(`✓ Unset ${key} for server '${serverName}' in ${client}`);
+      } else {
+        console.error('Invalid action. Use: set, unset, or list');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('export <client> [output]')
+  .description('Export configuration for a client')
+  .option('-s, --server <name>', 'Export only a specific server')
+  .action(async (client, output, options) => {
+    try {
+      let result;
+      if (options.server) {
+        result = await manager.exportServer(client, options.server, output);
+      } else {
+        result = await manager.exportConfig(client, output);
+      }
+
+      if (output) {
+        console.log(`✓ Exported to ${output}`);
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('import <client> <file>')
+  .description('Import configuration to a client')
+  .action(async (client, file) => {
+    try {
+      await manager.importConfig(client, file);
+      console.log(`✓ Imported configuration to ${client}`);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('env-view')
+  .description('View all environment variables across all configs (reverse view)')
+  .option('-k, --key <key>', 'Filter by specific environment variable key')
+  .option('-v, --show-values', 'Show actual values (default: masked)')
+  .action(async (options) => {
+    try {
+      const allEnvVars = await manager.getAllEnvironmentVariables();
+
+      if (allEnvVars.length === 0) {
+        console.log('\nNo environment variables found in any configuration.\n');
+        return;
+      }
+
+      const filteredVars = options.key
+        ? allEnvVars.filter(v => v.key.toLowerCase().includes(options.key.toLowerCase()))
+        : allEnvVars;
+
+      if (filteredVars.length === 0) {
+        console.log(`\nNo environment variables found matching '${options.key}'.\n`);
+        return;
+      }
+
+      console.log('\nEnvironment Variables Across All Configs:\n');
+
+      for (const envVar of filteredVars) {
+        console.log(`  ${envVar.key}:`);
+
+        // Group by value to see which configs share the same value
+        const valueGroups = new Map();
+        for (const location of envVar.locations) {
+          const displayValue = options.showValues
+            ? location.value
+            : (location.value.includes('KEY') || location.value.includes('SECRET')
+              ? location.value.substring(0, 4) + '***'
+              : location.value);
+
+          if (!valueGroups.has(displayValue)) {
+            valueGroups.set(displayValue, []);
+          }
+          valueGroups.get(displayValue).push(location);
+        }
+
+        // Display grouped by value
+        for (const [value, locations] of valueGroups.entries()) {
+          console.log(`    Value: ${value}`);
+          for (const loc of locations) {
+            console.log(`      - ${loc.clientName} / ${loc.server}`);
+          }
+        }
+        console.log();
+      }
+
+      console.log(`Total: ${filteredVars.length} environment variable(s)\n`);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('env-update-all <key> [value]')
+  .description('Update an environment variable across all configs where it exists')
+  .option('-c, --clients <clients...>', 'Only update in specific clients')
+  .option('-s, --servers <servers...>', 'Only update in specific servers')
+  .option('-d, --dry-run', 'Show what would be updated without making changes')
+  .option('--unset', 'Remove the environment variable instead of updating')
+  .action(async (key, value, options) => {
+    try {
+      // First, get all environment variables to see where this key exists
+      const allEnvVars = await manager.getAllEnvironmentVariables();
+      const targetEnvVar = allEnvVars.find(v => v.key === key);
+
+      if (!targetEnvVar) {
+        console.log(`\nEnvironment variable '${key}' not found in any configuration.\n`);
+        return;
+      }
+
+      // Filter targets based on options
+      let targets = targetEnvVar.locations;
+
+      if (options.clients) {
+        targets = targets.filter(t => options.clients.includes(t.client));
+      }
+
+      if (options.servers) {
+        targets = targets.filter(t => options.servers.includes(t.server));
+      }
+
+      if (targets.length === 0) {
+        console.log('\nNo matching configurations found with the specified filters.\n');
+        return;
+      }
+
+      // Show what will be updated
+      console.log(`\n${options.dryRun ? '[DRY RUN] ' : ''}Updating '${key}':\n`);
+      console.log('  Affected configurations:');
+      for (const target of targets) {
+        const oldDisplay = target.value.includes('KEY') || target.value.includes('SECRET')
+          ? target.value.substring(0, 4) + '***'
+          : target.value;
+        const newDisplay = options.unset ? '(removed)' : value;
+        console.log(`    - ${target.clientName} / ${target.server}: ${oldDisplay} → ${newDisplay}`);
+      }
+
+      if (options.dryRun) {
+        console.log('\n[DRY RUN] No changes were made.\n');
+        return;
+      }
+
+      // Perform the update
+      const actualValue = options.unset ? null : value;
+      const results = await manager.updateEnvironmentVariableAcrossConfigs(key, actualValue, targets);
+
+      // Show results
+      console.log('\nUpdate Results:');
+      let successCount = 0;
+      let errorCount = 0;
+
+      for (const result of results) {
+        if (result.success) {
+          successCount++;
+          console.log(`  ✓ ${result.clientName} / ${result.server}`);
+        } else {
+          errorCount++;
+          console.log(`  ✗ ${result.clientName}: ${result.error}`);
+        }
+      }
+
+      console.log(`\n✓ Updated ${successCount} configuration(s)`);
+      if (errorCount > 0) {
+        console.log(`✗ Failed to update ${errorCount} configuration(s)`);
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('web')
+  .description('Start the web UI server')
+  .option('-p, --port <port>', 'Port to run the server on', '3456')
+  .action(async (options) => {
+    console.log(`Starting web UI server on port ${options.port}...`);
+    console.log(`Open http://localhost:${options.port} in your browser`);
+
+    const { startServer } = await import('./server.js');
+    startServer(parseInt(options.port));
+  });
+
+program.parse();

package/src/clients.js

@@ -0,0 +1,113 @@
+import path from 'path';
+import os from 'os';
+
+export const CLIENTS = {
+  claude: {
+    name: 'Claude Desktop',
+    configPaths: {
+      darwin: path.join(os.homedir(), 'Library/Application Support/Claude/claude_desktop_config.json'),
+      win32: path.join(process.env.APPDATA || '', 'Claude/claude_desktop_config.json'),
+      linux: path.join(os.homedir(), '.config/Claude/claude_desktop_config.json')
+    },
+    format: 'mcpServers'
+  },
+  'claude-code': {
+    name: 'Claude Code',
+    configPaths: {
+      darwin: '.mcp.json',
+      win32: '.mcp.json',
+      linux: '.mcp.json'
+    },
+    format: 'mcpServers'
+  },
+  vscode: {
+    name: 'VS Code',
+    configPaths: {
+      darwin: '.vscode/mcp.json',
+      win32: '.vscode/mcp.json',
+      linux: '.vscode/mcp.json'
+    },
+    format: 'mcp.servers'
+  },
+  cursor: {
+    name: 'Cursor',
+    configPaths: {
+      darwin: '.cursor/mcp.json',
+      win32: '.cursor/mcp.json',
+      linux: '.cursor/mcp.json'
+    },
+    format: 'mcpServers'
+  },
+  'cursor-global': {
+    name: 'Cursor (Global)',
+    configPaths: {
+      darwin: path.join(os.homedir(), '.cursor/mcp.json'),
+      win32: path.join(os.homedir(), '.cursor/mcp.json'),
+      linux: path.join(os.homedir(), '.cursor/mcp.json')
+    },
+    format: 'mcpServers'
+  },
+  gemini: {
+    name: 'Gemini',
+    configPaths: {
+      darwin: path.join(os.homedir(), '.gemini/settings.json'),
+      win32: path.join(os.homedir(), '.gemini/settings.json'),
+      linux: path.join(os.homedir(), '.gemini/settings.json')
+    },
+    format: 'mcpServers'
+  },
+  windsurf: {
+    name: 'Windsurf',
+    configPaths: {
+      darwin: path.join(os.homedir(), '.codeium/windsurf/mcp_config.json'),
+      win32: path.join(process.env.APPDATA || '', 'WindSurf/mcp_settings.json'),
+      linux: path.join(os.homedir(), '.codeium/windsurf/mcp_config.json')
+    },
+    format: 'mcpServers'
+  },
+  amazonq: {
+    name: 'Amazon Q Developer',
+    configPaths: {
+      darwin: path.join(os.homedir(), '.aws/amazonq/mcp.json'),
+      win32: path.join(os.homedir(), '.aws/amazonq/mcp.json'),
+      linux: path.join(os.homedir(), '.aws/amazonq/mcp.json')
+    },
+    format: 'mcpServers'
+  },
+  '5ire': {
+    name: '5ire',
+    configPaths: {
+      darwin: path.join(os.homedir(), 'Library/Application Support/5ire/mcp.json'),
+      win32: path.join(process.env.APPDATA || '', '5ire/mcp.json'),
+      linux: path.join(os.homedir(), '.config/5ire/mcp.json')
+    },
+    format: 'mcpServers'
+  },
+  'factory-bridge': {
+    name: 'Factory Bridge',
+    configPaths: {
+      darwin: path.join(os.homedir(), 'Library/Application Support/Factory Bridge/mcp.json'),
+      win32: path.join(process.env.APPDATA || '', 'Factory Bridge/mcp.json'),
+      linux: path.join(os.homedir(), '.config/Factory Bridge/mcp.json')
+    },
+    format: 'mcpServers'
+  },
+  cline: {
+    name: 'Cline',
+    configPaths: {
+      darwin: path.join(os.homedir(), 'Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'),
+      win32: path.join(process.env.APPDATA || '', 'Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'),
+      linux: path.join(os.homedir(), '.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json')
+    },
+    format: 'mcpServers'
+  },
+  'roo-code': {
+    name: 'Roo Code',
+    configPaths: {
+      darwin: path.join(os.homedir(), 'Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json'),
+      win32: path.join(process.env.APPDATA || '', 'Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json'),
+      linux: path.join(os.homedir(), '.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json')
+    },
+    format: 'mcpServers'
+  }
+};