@meldocio/mcp-stdio-proxy 1.0.22 → 1.0.24

package/lib/install/installers.js

@@ -0,0 +1,328 @@
+/**
+ * MCP Installation Orchestrator
+ *
+ * Unified installer for all MCP clients (Claude Desktop, Cursor, Claude Code, Local).
+ * Consolidates installation logic to eliminate code duplication.
+ */
+
+const logger = require('../core/logger');
+const { getConfigPath, getClientDisplayName } = require('./config-paths');
+const { getConfigTemplate, configsEqual, mergeClaudeDesktopConfig, mergeCursorConfig, mergeClaudeCodeConfig, removeMeldocConfig, removeMeldocClaudeCodeConfig } = require('./templates');
+const { readConfigSafe, writeConfig, fileExists } = require('./config-manager');
+const path = require('path');
+
+/**
+ * Installation result codes
+ */
+const INSTALL_RESULTS = {
+  SUCCESS: 'success',
+  ALREADY_CONFIGURED: 'already_configured',
+  UPDATED: 'updated',
+  ERROR: 'error'
+};
+
+/**
+ * Unified MCP Installer
+ * Handles installation for all supported clients
+ */
+class Installer {
+  /**
+   * Create an installer for a specific client
+   * @param {string} client - Client type: 'claude-desktop', 'cursor', 'claude-code', 'local'
+   * @param {string} [scope='project'] - Installation scope: 'global', 'project', 'user', 'local'
+   */
+  constructor(client, scope = 'project') {
+    this.client = client;
+    this.scope = scope;
+    this.clientName = getClientDisplayName(client);
+    this.configPath = getConfigPath(client, scope);
+    this.expectedConfig = getConfigTemplate(client);
+  }
+
+  /**
+   * Get the server key name based on client type
+   * @returns {string} Server key ('meldoc' or 'meldoc-mcp')
+   */
+  getServerKey() {
+    return this.client === 'claude-code' ? 'meldoc-mcp' : 'meldoc';
+  }
+
+  /**
+   * Check if Meldoc is already configured
+   * @returns {Object} { configured: boolean, isEqual: boolean, existingConfig: Object|null }
+   */
+  checkExistingConfig() {
+    const config = readConfigSafe(this.configPath);
+    const serverKey = this.getServerKey();
+
+    if (!config.mcpServers || !config.mcpServers[serverKey]) {
+      return {
+        configured: false,
+        isEqual: false,
+        existingConfig: null
+      };
+    }
+
+    const existingConfig = config.mcpServers[serverKey];
+    const isEqual = configsEqual(existingConfig, this.expectedConfig);
+
+    return {
+      configured: true,
+      isEqual,
+      existingConfig
+    };
+  }
+
+  /**
+   * Install Meldoc MCP configuration
+   * @returns {Object} { result: string, message: string, configPath: string }
+   */
+  install() {
+    try {
+      logger.section(`🚀 Installing Meldoc MCP for ${this.clientName}`);
+      console.log();
+
+      logger.info(`Config file location: ${logger.highlight(this.configPath)}`);
+      console.log();
+
+      // Check existing configuration
+      const { configured, isEqual, existingConfig } = this.checkExistingConfig();
+
+      if (configured && isEqual) {
+        logger.success('Meldoc MCP is already configured correctly!');
+        console.log();
+        logger.info('Current configuration:');
+        console.log('  ' + logger.highlight(JSON.stringify(existingConfig, null, 2)));
+        console.log();
+        this.printNextSteps();
+
+        return {
+          result: INSTALL_RESULTS.ALREADY_CONFIGURED,
+          message: 'Configuration already exists and is correct',
+          configPath: this.configPath
+        };
+      }
+
+      if (configured && !isEqual) {
+        logger.warn('Meldoc MCP is already configured, but with different settings');
+        console.log();
+        logger.info('Current configuration:');
+        console.log('  ' + logger.highlight(JSON.stringify(existingConfig, null, 2)));
+        console.log();
+        logger.info('Expected configuration:');
+        console.log('  ' + logger.highlight(JSON.stringify(this.expectedConfig, null, 2)));
+        console.log();
+        logger.info('To update the configuration, run:');
+        console.log('  ' + logger.highlight('npx @meldocio/mcp-stdio-proxy uninstall'));
+        console.log('  ' + logger.highlight('npx @meldocio/mcp-stdio-proxy install'));
+        console.log();
+
+        return {
+          result: INSTALL_RESULTS.ALREADY_CONFIGURED,
+          message: 'Configuration exists but differs from expected',
+          configPath: this.configPath
+        };
+      }
+
+      // Read existing config or create new
+      const config = readConfigSafe(this.configPath);
+      const configExists = fileExists(this.configPath);
+
+      if (configExists) {
+        logger.info('Found existing configuration file');
+      } else {
+        logger.info('Configuration file does not exist, will create it');
+      }
+
+      // Merge Meldoc configuration
+      const { merged } = this.mergeConfig(config, this.expectedConfig);
+
+      // Create directory if needed
+      const configDir = path.dirname(this.configPath);
+      if (!fileExists(configDir)) {
+        logger.info(`Creating directory: ${configDir}`);
+      }
+
+      // Write config
+      writeConfig(this.configPath, merged);
+
+      logger.success('Configuration added successfully!');
+      console.log();
+
+      // Show what was added
+      logger.info('Added configuration:');
+      console.log('  ' + logger.highlight(JSON.stringify(this.expectedConfig, null, 2)));
+      console.log();
+
+      this.printNextSteps();
+
+      return {
+        result: INSTALL_RESULTS.SUCCESS,
+        message: 'Configuration installed successfully',
+        configPath: this.configPath
+      };
+
+    } catch (error) {
+      logger.error(`Installation failed: ${error.message}`);
+      return {
+        result: INSTALL_RESULTS.ERROR,
+        message: error.message,
+        configPath: this.configPath
+      };
+    }
+  }
+
+  /**
+   * Merge Meldoc config into existing config based on client type
+   * @param {Object} config - Existing configuration
+   * @param {Object} newServer - New Meldoc server configuration
+   * @returns {Object} { merged: Object, changed: boolean }
+   */
+  mergeConfig(config, newServer) {
+    switch (this.client) {
+      case 'claude-desktop':
+        return mergeClaudeDesktopConfig(config, newServer);
+      case 'cursor':
+        return mergeCursorConfig(config, newServer);
+      case 'claude-code':
+        return mergeClaudeCodeConfig(config, newServer);
+      case 'local':
+        return mergeCursorConfig(config, newServer); // Uses same format as Cursor
+      default:
+        throw new Error(`Unknown client type: ${this.client}`);
+    }
+  }
+
+  /**
+   * Uninstall Meldoc MCP configuration
+   * @returns {Object} { result: string, message: string, configPath: string }
+   */
+  uninstall() {
+    try {
+      logger.section(`🗑️  Uninstalling Meldoc MCP from ${this.clientName}`);
+      console.log();
+
+      logger.info(`Config file location: ${logger.highlight(this.configPath)}`);
+      console.log();
+
+      // Check if config exists
+      if (!fileExists(this.configPath)) {
+        logger.info('Configuration file does not exist');
+        logger.success('Nothing to uninstall');
+        console.log();
+        return {
+          result: INSTALL_RESULTS.SUCCESS,
+          message: 'No configuration found',
+          configPath: this.configPath
+        };
+      }
+
+      // Read config
+      const config = readConfigSafe(this.configPath);
+      const serverKey = this.getServerKey();
+
+      // Check if Meldoc is configured
+      if (!config.mcpServers || !config.mcpServers[serverKey]) {
+        logger.info('Meldoc MCP is not configured');
+        logger.success('Nothing to uninstall');
+        console.log();
+        return {
+          result: INSTALL_RESULTS.SUCCESS,
+          message: 'Meldoc not configured',
+          configPath: this.configPath
+        };
+      }
+
+      // Remove Meldoc configuration
+      const { merged } = this.client === 'claude-code'
+        ? removeMeldocClaudeCodeConfig(config)
+        : removeMeldocConfig(config);
+
+      // Write updated config
+      writeConfig(this.configPath, merged);
+
+      logger.success('Configuration removed successfully!');
+      console.log();
+      logger.info(`Remember to restart ${this.clientName} to apply changes`);
+      console.log();
+
+      return {
+        result: INSTALL_RESULTS.SUCCESS,
+        message: 'Configuration uninstalled successfully',
+        configPath: this.configPath
+      };
+
+    } catch (error) {
+      logger.error(`Uninstallation failed: ${error.message}`);
+      return {
+        result: INSTALL_RESULTS.ERROR,
+        message: error.message,
+        configPath: this.configPath
+      };
+    }
+  }
+
+  /**
+   * Print next steps after installation
+   */
+  printNextSteps() {
+    logger.info('✅ Next steps:');
+    console.log();
+
+    if (this.client === 'claude-desktop') {
+      console.log('  1. Restart Claude Desktop (if you haven\'t already)');
+      console.log('  2. Run: ' + logger.highlight('npx @meldocio/mcp-stdio-proxy auth login'));
+    } else if (this.client === 'cursor') {
+      console.log(`  1. Restart Cursor (if you haven't already)`);
+      console.log('  2. Run: ' + logger.highlight('npx @meldocio/mcp-stdio-proxy auth login'));
+    } else if (this.client === 'claude-code') {
+      console.log('  1. Restart Claude Code (if you haven\'t already)');
+      console.log('  2. Run: ' + logger.highlight('npx @meldocio/mcp-stdio-proxy auth login'));
+    } else {
+      console.log('  1. Restart your MCP client');
+      console.log('  2. Run: ' + logger.highlight('npx @meldocio/mcp-stdio-proxy auth login'));
+    }
+
+    console.log();
+  }
+}
+
+/**
+ * Factory function to create installer
+ * @param {string} client - Client type
+ * @param {string} [scope='project'] - Installation scope
+ * @returns {Installer} Installer instance
+ */
+function createInstaller(client, scope = 'project') {
+  return new Installer(client, scope);
+}
+
+/**
+ * Quick install function
+ * @param {string} client - Client type
+ * @param {string} [scope='project'] - Installation scope
+ * @returns {Object} Installation result
+ */
+function install(client, scope = 'project') {
+  const installer = createInstaller(client, scope);
+  return installer.install();
+}
+
+/**
+ * Quick uninstall function
+ * @param {string} client - Client type
+ * @param {string} [scope='project'] - Installation scope
+ * @returns {Object} Uninstallation result
+ */
+function uninstall(client, scope = 'project') {
+  const installer = createInstaller(client, scope);
+  return installer.uninstall();
+}
+
+module.exports = {
+  Installer,
+  createInstaller,
+  install,
+  uninstall,
+  INSTALL_RESULTS
+};

package/lib/install/templates.js

@@ -0,0 +1,266 @@
+/**
+ * MCP Configuration Templates
+ *
+ * Standard configuration templates for different MCP clients.
+ * Includes comparison and merging utilities.
+ */
+
+/**
+ * Get expected Meldoc MCP configuration for Claude Desktop
+ * @returns {Object} Claude Desktop MCP configuration
+ */
+function getClaudeDesktopConfig() {
+  return {
+    command: 'npx',
+    args: ['-y', '@meldocio/mcp-stdio-proxy@latest']
+  };
+}
+
+/**
+ * Get expected Meldoc MCP configuration for Cursor
+ * @returns {Object} Cursor MCP configuration
+ */
+function getCursorConfig() {
+  return {
+    command: 'npx',
+    args: ['-y', '@meldocio/mcp-stdio-proxy@latest']
+  };
+}
+
+/**
+ * Get expected Meldoc MCP configuration for Claude Code
+ * @returns {Object} Claude Code MCP configuration
+ */
+function getClaudeCodeConfig() {
+  return {
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@meldocio/mcp-stdio-proxy@latest']
+  };
+}
+
+/**
+ * Get expected Meldoc MCP configuration for local (generic) installation
+ * @returns {Object} Local MCP configuration
+ */
+function getLocalConfig() {
+  return {
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@meldocio/mcp-stdio-proxy@latest']
+  };
+}
+
+/**
+ * Get configuration template by client type
+ * @param {string} client - Client type: 'claude-desktop', 'cursor', 'claude-code', 'local'
+ * @returns {Object} Configuration template
+ * @throws {Error} If client type is unknown
+ */
+function getConfigTemplate(client) {
+  switch (client) {
+    case 'claude-desktop':
+      return getClaudeDesktopConfig();
+    case 'cursor':
+      return getCursorConfig();
+    case 'claude-code':
+      return getClaudeCodeConfig();
+    case 'local':
+      return getLocalConfig();
+    default:
+      throw new Error(`Unknown client type: ${client}`);
+  }
+}
+
+/**
+ * Deep equality comparison for configuration objects
+ * @param {any} a - First value
+ * @param {any} b - Second value
+ * @returns {boolean} True if values are deeply equal
+ */
+function deepEqual(a, b) {
+  // Handle null/undefined
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+
+  // Handle non-objects
+  if (typeof a !== 'object') return a === b;
+
+  // Handle arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, idx) => deepEqual(val, b[idx]));
+  }
+
+  // Handle objects
+  if (Array.isArray(a) || Array.isArray(b)) return false;
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) return false;
+
+  return keysA.every(key => {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    return deepEqual(a[key], b[key]);
+  });
+}
+
+/**
+ * Check if two configurations are equal
+ * @param {Object} config1 - First configuration
+ * @param {Object} config2 - Second configuration
+ * @returns {boolean} True if configurations are equal
+ */
+function configsEqual(config1, config2) {
+  return deepEqual(config1, config2);
+}
+
+/**
+ * Merge Meldoc server configuration into existing config
+ * For Claude Desktop format (mcpServers.meldoc)
+ * @param {Object} existingConfig - Existing configuration object
+ * @param {Object} newServer - New Meldoc server configuration
+ * @returns {Object} { merged: Object, changed: boolean }
+ */
+function mergeClaudeDesktopConfig(existingConfig, newServer) {
+  const merged = { ...existingConfig };
+
+  // Ensure mcpServers exists
+  if (!merged.mcpServers) {
+    merged.mcpServers = {};
+  }
+
+  // Check if meldoc server exists
+  if (!merged.mcpServers.meldoc) {
+    merged.mcpServers.meldoc = newServer;
+    return { merged, changed: true };
+  }
+
+  // Check if configs are equal
+  if (configsEqual(merged.mcpServers.meldoc, newServer)) {
+    return { merged, changed: false };
+  }
+
+  // Update if different
+  merged.mcpServers.meldoc = newServer;
+  return { merged, changed: true };
+}
+
+/**
+ * Merge Meldoc server configuration into existing config
+ * For Cursor/Local format (mcpServers.meldoc)
+ * @param {Object} existingConfig - Existing configuration object
+ * @param {Object} newServer - New Meldoc server configuration
+ * @returns {Object} { merged: Object, changed: boolean }
+ */
+function mergeCursorConfig(existingConfig, newServer) {
+  const merged = { ...existingConfig };
+
+  // Ensure mcpServers exists
+  if (!merged.mcpServers) {
+    merged.mcpServers = {};
+  }
+
+  // Check if meldoc server exists
+  if (!merged.mcpServers.meldoc) {
+    merged.mcpServers.meldoc = newServer;
+    return { merged, changed: true };
+  }
+
+  // Check if configs are equal
+  if (configsEqual(merged.mcpServers.meldoc, newServer)) {
+    return { merged, changed: false };
+  }
+
+  // Update if different
+  merged.mcpServers.meldoc = newServer;
+  return { merged, changed: true };
+}
+
+/**
+ * Merge Meldoc server configuration into existing config
+ * For Claude Code format (mcpServers.meldoc-mcp)
+ * @param {Object} existingConfig - Existing configuration object
+ * @param {Object} newServer - New Meldoc server configuration
+ * @returns {Object} { merged: Object, changed: boolean }
+ */
+function mergeClaudeCodeConfig(existingConfig, newServer) {
+  const merged = { ...existingConfig };
+
+  // Ensure mcpServers exists
+  if (!merged.mcpServers) {
+    merged.mcpServers = {};
+  }
+
+  // Check if meldoc-mcp server exists (Claude Code uses different key)
+  if (!merged.mcpServers['meldoc-mcp']) {
+    merged.mcpServers['meldoc-mcp'] = newServer;
+    return { merged, changed: true };
+  }
+
+  // Check if configs are equal
+  if (configsEqual(merged.mcpServers['meldoc-mcp'], newServer)) {
+    return { merged, changed: false };
+  }
+
+  // Update if different
+  merged.mcpServers['meldoc-mcp'] = newServer;
+  return { merged, changed: true };
+}
+
+/**
+ * Remove Meldoc server from configuration
+ * For Claude Desktop/Cursor format
+ * @param {Object} config - Configuration object
+ * @returns {Object} { merged: Object, changed: boolean }
+ */
+function removeMeldocConfig(config) {
+  const merged = { ...config };
+
+  if (!merged.mcpServers || !merged.mcpServers.meldoc) {
+    return { merged, changed: false };
+  }
+
+  delete merged.mcpServers.meldoc;
+  return { merged, changed: true };
+}
+
+/**
+ * Remove Meldoc server from Claude Code configuration
+ * @param {Object} config - Configuration object
+ * @returns {Object} { merged: Object, changed: boolean }
+ */
+function removeMeldocClaudeCodeConfig(config) {
+  const merged = { ...config };
+
+  if (!merged.mcpServers || !merged.mcpServers['meldoc-mcp']) {
+    return { merged, changed: false };
+  }
+
+  delete merged.mcpServers['meldoc-mcp'];
+  return { merged, changed: true };
+}
+
+module.exports = {
+  // Template getters
+  getClaudeDesktopConfig,
+  getCursorConfig,
+  getClaudeCodeConfig,
+  getLocalConfig,
+  getConfigTemplate,
+
+  // Comparison utilities
+  deepEqual,
+  configsEqual,
+
+  // Merge utilities
+  mergeClaudeDesktopConfig,
+  mergeCursorConfig,
+  mergeClaudeCodeConfig,
+
+  // Remove utilities
+  removeMeldocConfig,
+  removeMeldocClaudeCodeConfig
+};