@tonygeez/mcp-conf 1.0.1

package/index.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const readline = require('readline');
+
+// Color codes for terminal styling
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  
+  fg: {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    crimson: '\x1b[38m'
+  },
+  
+  bg: {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m',
+    crimson: '\x1b[48m'
+  }
+};
+
+// Logger utility with colors
+const logger = {
+  info: (msg) => console.log(`${colors.fg.blue}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.fg.green}✔${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.fg.red}✖${colors.reset} ${msg}`),
+  warning: (msg) => console.log(`${colors.fg.yellow}⚠${colors.reset} ${msg}`),
+  highlight: (msg) => console.log(`${colors.fg.cyan}${colors.bright}${msg}${colors.reset}`),
+  prompt: (msg) => `${colors.fg.magenta}?${colors.reset} ${colors.bright}${msg}${colors.reset}`,
+  enum: (options) => options.map((opt, i) => `  ${colors.fg.cyan}${i + 1}${colors.reset}) ${opt}`).join('\n'),
+  header: (msg) => console.log(`\n${colors.fg.cyan}${colors.bright}═══ ${msg} ═══${colors.reset}\n`),
+  divider: () => console.log(`${colors.dim}${'─'.repeat(50)}${colors.reset}`)
+};
+
+// Create readline interface
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Promise-based question prompt
+function ask(question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const promptText = defaultValue 
+      ? `${question} ${colors.dim}(${defaultValue})${colors.reset}: `
+      : `${question}: `;
+    
+    rl.question(promptText, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+// Enum selection prompt
+async function askEnum(question, options) {
+  console.log(logger.prompt(question));
+  console.log(logger.enum(options));
+  
+  while (true) {
+    const answer = await ask('Select', '1');
+    const index = parseInt(answer) - 1;
+    
+    if (index >= 0 && index < options.length) {
+      return options[index];
+    }
+    logger.error('Invalid selection. Please try again.');
+  }
+}
+
+// Yes/No confirmation
+async function confirm(question, defaultYes = false) {
+  const defaultText = defaultYes ? 'Y/n' : 'y/N';
+  const answer = await ask(`${question} ${colors.dim}[${defaultText}]${colors.reset}`, defaultYes ? 'yes' : 'no');
+  return answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y';
+}
+
+// Validate environment variable name
+function isValidEnvName(name) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+}
+
+// Collect environment variables recursively
+async function collectEnvVars(env = {}) {
+  const setEnv = await confirm('Set environment variables for this server?', false);
+  
+  if (!setEnv) {
+    return env;
+  }
+  
+  const envName = await ask('Environment variable name');
+  
+  if (!envName) {
+    logger.warning('Empty variable name, skipping...');
+    return await collectEnvVars(env);
+  }
+  
+  if (!isValidEnvName(envName)) {
+    logger.error('Invalid environment variable name. Use letters, numbers, and underscores only.');
+    return await collectEnvVars(env);
+  }
+  
+  if (env[envName] !== undefined) {
+    const overwrite = await confirm(`Variable "${envName}" already exists. Overwrite?`, false);
+    if (!overwrite) {
+      return await collectEnvVars(env);
+    }
+  }
+  
+  const envValue = await ask(`Value for ${envName}`);
+  env[envName] = envValue;
+  
+  logger.success(`Added: ${envName}=${envValue}`);
+  
+  const addAnother = await confirm('Add another environment variable?', false);
+  if (addAnother) {
+    return await collectEnvVars(env);
+  }
+  
+  return env;
+}
+
+// Main configuration collection
+async function collectServerConfig() {
+  logger.header('MCP Server Configuration');
+  
+  // Server name
+  const serverName = await ask('MCP Server name');
+  if (!serverName) {
+    throw new Error('Server name is required');
+  }
+  
+  // Command selection
+  const commandOptions = ['npx', 'node', 'other'];
+  const selectedCommand = await askEnum('Command', commandOptions);
+  
+  let command;
+  if (selectedCommand === 'other') {
+    command = await ask('Enter custom command');
+    if (!command) {
+      throw new Error('Command is required');
+    }
+  } else {
+    command = selectedCommand;
+  }
+  
+  // Arguments
+  const argsInput = await ask('Arguments (space-separated, e.g., -y @modelcontextprotocol/server-filesystem)');
+  const args = argsInput ? argsInput.split(/\s+/).filter(arg => arg.length > 0) : [];
+  
+  // Environment variables
+  const env = await collectEnvVars({});
+  
+  return {
+    name: serverName,
+    config: {
+      command,
+      args,
+      env
+    }
+  };
+}
+
+// Read existing .mcp.json or return default structure
+async function readExistingConfig(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(content);
+    
+    if (!parsed.mcpServers || typeof parsed.mcpServers !== 'object') {
+      logger.warning('Existing file has invalid structure. Creating backup and reinitializing...');
+      await fs.writeFile(`${filePath}.backup`, content);
+      return { mcpServers: {} };
+    }
+    
+    return parsed;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null; // File doesn't exist
+    }
+    if (error instanceof SyntaxError) {
+      logger.error('Existing .mcp.json contains invalid JSON');
+      throw new Error('Please fix or remove the existing .mcp.json file');
+    }
+    throw error;
+  }
+}
+
+// Write configuration to file
+async function writeConfig(filePath, config) {
+  const content = JSON.stringify(config, null, 2);
+  await fs.writeFile(filePath, content, 'utf8');
+}
+
+// Display server preview
+function displayPreview(serverName, config) {
+  logger.divider();
+  logger.highlight('Configuration Preview:');
+  console.log(`${colors.fg.cyan}Server Name:${colors.reset} ${serverName}`);
+  console.log(`${colors.fg.cyan}Command:${colors.reset} ${config.command}`);
+  console.log(`${colors.fg.cyan}Arguments:${colors.reset} ${config.args.length > 0 ? JSON.stringify(config.args) : colors.dim + '(none)' + colors.reset}`);
+  
+  const envKeys = Object.keys(config.env);
+  if (envKeys.length > 0) {
+    console.log(`${colors.fg.cyan}Environment Variables:${colors.reset}`);
+    envKeys.forEach(key => {
+      const maskedValue = config.env[key].length > 0 ? '••••••' : '(empty)';
+      console.log(`  ${colors.fg.yellow}${key}${colors.reset}=${maskedValue}`);
+    });
+  } else {
+    console.log(`${colors.fg.cyan}Environment Variables:${colors.reset} ${colors.dim}(none)${colors.reset}`);
+  }
+  logger.divider();
+}
+
+// Main execution
+async function main() {
+  try {
+    const cwd = process.cwd();
+    const filePath = path.join(cwd, '.mcp.json');
+    
+    logger.header('MCP Configuration Tool');
+    
+    // Check existing file
+    const existingConfig = await readExistingConfig(filePath);
+    
+    if (existingConfig === null) {
+      logger.info('No existing .mcp.json found. Will create new file.');
+    } else {
+      const serverCount = Object.keys(existingConfig.mcpServers).length;
+      logger.info(`Found existing .mcp.json with ${serverCount} server(s). Will append to it.`);
+    }
+    
+    // Collect new server configuration
+    const { name, config } = await collectServerConfig();
+    
+    // Check for duplicate names
+    if (existingConfig && existingConfig.mcpServers[name]) {
+      const overwrite = await confirm(`Server "${name}" already exists. Overwrite?`, false);
+      if (!overwrite) {
+        logger.info('Operation cancelled.');
+        rl.close();
+        return;
+      }
+      logger.warning(`Overwriting existing server: ${name}`);
+    }
+    
+    // Show preview
+    displayPreview(name, config);
+    
+    // Final confirmation
+    const proceed = await confirm('Save this configuration?', true);
+    if (!proceed) {
+      logger.info('Operation cancelled. No changes made.');
+      rl.close();
+      return;
+    }
+    
+    // Merge and write
+    const finalConfig = existingConfig || { mcpServers: {} };
+    finalConfig.mcpServers[name] = config;
+    
+    await writeConfig(filePath, finalConfig);
+    
+    // Success message
+    logger.success(`Configuration saved to: ${filePath}`);
+    console.log(`${colors.fg.green}${colors.bright}✓${colors.reset} Server "${colors.fg.cyan}${name}${colors.reset}" ${existingConfig && existingConfig.mcpServers[name] ? 'updated' : 'added'} successfully.`);
+    
+    const totalServers = Object.keys(finalConfig.mcpServers).length;
+    logger.info(`Total servers in configuration: ${totalServers}`);
+    
+  } catch (error) {
+    logger.error(`Error: ${error.message}`);
+    if (error.stack) {
+      console.error(`${colors.dim}${error.stack}${colors.reset}`);
+    }
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log(`\n${colors.fg.yellow}Operation cancelled by user.${colors.reset}`);
+  process.exit(0);
+});
+
+// Run main
+main();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@tonygeez/mcp-conf",
+  "version": "1.0.1",
+  "description": "Interactive CLI tool for managing MCP server configurations",
+  "main": "index.js",
+  "bin": {
+    "mcpconf": "./index.js",
+    "mcpc": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mcp",
+    "cli",
+    "config",
+    "interactive",
+    "model-context-protocol"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}