appiq-solution 1.2.0 → 1.3.1

package/appiq-mcp installer/index.js

@@ -0,0 +1,672 @@
+#!/usr/bin/env node
+
+// Try to load inquirer with fallback
+let inquirer;
+try {
+  inquirer = require('inquirer');
+  // Test if prompt function exists
+  if (typeof inquirer.prompt !== 'function') {
+    // Try default export for newer versions
+    if (inquirer.default && typeof inquirer.default.prompt === 'function') {
+      inquirer = inquirer.default;
+    } else {
+      // Set to null to use fallback
+      inquirer = null;
+    }
+  }
+} catch (error) {
+  console.warn('Warning: inquirer not available, using fallback methods');
+  inquirer = null;
+}
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+// Safe prompt function with robust fallback
+async function safePrompt(questions) {
+  // Always use readline fallback for better compatibility
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const results = {};
+  
+  for (const question of questions) {
+    if (question.type === 'input' || question.type === 'confirm') {
+      const answer = await new Promise((resolve) => {
+        const prompt = question.message + (question.type === 'confirm' ? ' (y/N): ' : ': ');
+        rl.question(prompt, (input) => {
+          if (question.type === 'confirm') {
+            resolve(input.toLowerCase().startsWith('y'));
+          } else {
+            resolve(input || question.default || '');
+          }
+        });
+      });
+      results[question.name] = answer;
+    } else if (question.type === 'checkbox') {
+      // For checkbox, show options and let user select by numbers
+      console.log(chalk.cyan(`\n${question.message}`));
+      question.choices?.forEach((choice, index) => {
+        const checked = choice.checked ? '✓' : ' ';
+        console.log(chalk.white(`  [${index + 1}] ${checked} ${choice.name}`));
+      });
+      
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk.yellow('Enter numbers separated by commas (e.g., 1,3,5) or press Enter for defaults: '), (input) => {
+          if (!input.trim()) {
+            // Use defaults (checked items)
+            resolve(question.choices?.filter(c => c.checked).map(c => c.value) || []);
+          } else {
+            // Parse user input
+            const selected = input.split(',').map(n => parseInt(n.trim()) - 1).filter(i => i >= 0 && i < question.choices.length);
+            resolve(selected.map(i => question.choices[i].value));
+          }
+        });
+      });
+      results[question.name] = answer;
+    } else if (question.type === 'list') {
+      // For list, show options and let user select by number
+      console.log(chalk.cyan(`\n${question.message}`));
+      question.choices?.forEach((choice, index) => {
+        console.log(chalk.white(`  [${index + 1}] ${choice.name}`));
+      });
+      
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk.yellow('Enter number (1-' + question.choices.length + ') or press Enter for default: '), (input) => {
+          const num = parseInt(input.trim());
+          if (!input.trim() || isNaN(num) || num < 1 || num > question.choices.length) {
+            // Use default (first option)
+            resolve(question.choices?.[0]?.value || question.default);
+          } else {
+            resolve(question.choices[num - 1].value);
+          }
+        });
+      });
+      results[question.name] = answer;
+    }
+  }
+  
+  rl.close();
+  return results;
+}
+
+console.log(chalk.blue.bold(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                        🚀 AppIQ MCP Installer 🚀                             ║
+║                                                                              ║
+║            One-Click Installer for all MCP Servers                          ║
+║          Automatic Installation & Configuration for:                        ║
+║        Claude Desktop • Cursor • Windsurf • VS Code • Trae AI               ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+`));
+
+// Setup local configuration file
+async function setupLocalConfig() {
+  const localConfigPath = path.join(process.cwd(), 'my_mcps.md');
+  const templatePath = path.join(__dirname, 'my_mcps.md');
+  
+  if (!fs.existsSync(localConfigPath)) {
+    console.log(chalk.yellow('\n📁 Creating local configuration file...'));
+    if (fs.existsSync(templatePath)) {
+      fs.copyFileSync(templatePath, localConfigPath);
+      console.log(chalk.green(`✅ Copied my_mcps.md to ${localConfigPath}`));
+    } else {
+      // Fallback: create basic template if package template not found
+      const basicTemplate = `# MCP Servers Configuration
+
+Edit this file to customize your MCP servers
+
+\`\`\`javascript
+const MCP_SERVERS = {
+  // 🌍 GLOBAL SERVERS
+  'git': {
+    name: 'Git MCP Server',
+    description: 'Git repository interaction - commits, branches, status',
+    config: {
+      command: 'uvx',
+      args: ['mcp-server-git', '--repository', '.']
+    }
+  },
+  
+  // 📁 LOCAL SERVERS
+  'extended-memory': {
+    name: 'Extended Memory MCP',
+    description: 'Enhanced memory capabilities for AI assistants',
+    config: {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-memory']
+    }
+  }
+};
+\`\`\`
+
+✏️ Edit the servers above and run \`npx appiq-mcp-installer\` to install them!
+`;
+      fs.writeFileSync(localConfigPath, basicTemplate);
+      console.log(chalk.green(`✅ Created basic my_mcps.md at ${localConfigPath}`));
+    }
+  }
+  return localConfigPath;
+}
+
+// Prompt user to edit configuration
+async function promptUserToEdit(configPath) {
+  console.log(chalk.blue.bold('\n🛠️  Configuration Setup'));
+  console.log(chalk.white(`📝 Please edit the configuration file: ${chalk.cyan(configPath)}`));
+  console.log(chalk.white('   Add, remove, or modify MCP servers as needed'));
+  console.log(chalk.white('   Save the file when you\'re done'));
+  
+  const response = await safePrompt([{
+    type: 'input',
+    name: 'continue',
+    message: 'Press Enter when you have finished editing the file...',
+  }]);
+  return response;
+}
+
+// Validate MCP configuration syntax
+function validateMCPConfig(mcpContent) {
+  try {
+    // Extract JavaScript code block from markdown
+    const codeBlockRegex = /```javascript\n(const MCP_SERVERS = \{[\s\S]*?\});?\n```/;
+    const match = mcpContent.match(codeBlockRegex);
+    
+    if (!match) {
+      return { valid: false, error: 'Could not find MCP_SERVERS configuration block.\nMake sure you have:\n```javascript\nconst MCP_SERVERS = {\n  // your servers here\n};\n```' };
+    }
+    
+    // Try to evaluate the JavaScript code
+    const mcpCode = match[1];
+    const cleanCode = mcpCode.replace('const MCP_SERVERS = ', '');
+    const MCP_SERVERS = eval(`(${cleanCode})`);
+    
+    // Basic validation
+    if (typeof MCP_SERVERS !== 'object' || MCP_SERVERS === null) {
+      return { valid: false, error: 'MCP_SERVERS must be an object' };
+    }
+    
+    // Check if servers have required properties (Claude Desktop format)
+    for (const [key, server] of Object.entries(MCP_SERVERS)) {
+      if (!server.command) {
+        return { valid: false, error: `Server '${key}' is missing required 'command' property` };
+      }
+      if (!Array.isArray(server.args)) {
+        return { valid: false, error: `Server '${key}' must have 'args' as an array` };
+      }
+    }
+    
+    return { valid: true, servers: MCP_SERVERS };
+  } catch (error) {
+    return { valid: false, error: `Syntax error: ${error.message}` };
+  }
+}
+
+// Load MCP Server Definitions with retry loop
+async function loadMCPServersWithRetry() {
+  while (true) {
+    try {
+      const localConfigPath = path.join(process.cwd(), 'my_mcps.md');
+      
+      if (!fs.existsSync(localConfigPath)) {
+        throw new Error('my_mcps.md not found in current directory');
+      }
+      
+      const mcpContent = fs.readFileSync(localConfigPath, 'utf8');
+      const validation = validateMCPConfig(mcpContent);
+      
+      if (validation.valid) {
+        console.log(chalk.green(`✅ Configuration loaded successfully! Found ${Object.keys(validation.servers).length} MCP servers`));
+        return validation.servers;
+      } else {
+        console.log(chalk.red('\n❌ Configuration Error:'));
+        console.log(chalk.white(validation.error));
+        console.log(chalk.yellow('\n💡 Please fix the error in my_mcps.md and try again.'));
+        
+        const retry = await safePrompt([{
+          type: 'confirm',
+          name: 'retry',
+          message: 'Do you want to edit the file again?',
+          default: true
+        }]);
+        
+        if (!retry.retry) {
+          console.log(chalk.red('❌ Installation cancelled'));
+          process.exit(1);
+        }
+        
+        await promptUserToEdit(localConfigPath);
+      }
+    } catch (error) {
+      console.error(chalk.red(`❌ Error reading configuration: ${error.message}`));
+      process.exit(1);
+    }
+  }
+}
+
+// IDE Configuration Paths
+const IDE_CONFIGS = {
+  'claude-desktop': {
+    name: 'Claude Desktop',
+    paths: {
+      'darwin': path.join(os.homedir(), 'Library/Application Support/Claude/claude_desktop_config.json'),
+      'win32': path.join(os.homedir(), 'AppData/Roaming/Claude/claude_desktop_config.json'),
+      'linux': path.join(os.homedir(), '.config/Claude/claude_desktop_config.json')
+    },
+    configKey: 'mcpServers',
+    globalOnly: true
+  },
+  'cursor': {
+    name: 'Cursor AI',
+    paths: {
+      'global': path.join(os.homedir(), '.cursor/mcp.json'),
+      'project': '.cursor/mcp.json'
+    },
+    configKey: 'mcpServers',
+    globalOnly: false
+  },
+  'windsurf': {
+    name: 'Windsurf',
+    paths: {
+      'global': path.join(os.homedir(), '.windsurf/mcp.json'),
+      'project': '.windsurf/mcp.json'
+    },
+    configKey: 'mcpServers',
+    globalOnly: false
+  },
+  'vscode': {
+    name: 'VS Code',
+    paths: {
+      'global': path.join(os.homedir(), '.vscode/settings.json'),
+      'project': '.vscode/mcp.json'
+    },
+    configKey: 'mcp.servers',
+    globalOnly: false
+  },
+  'trae-ai': {
+    name: 'Trae AI',
+    paths: {
+      'global': path.join(os.homedir(), '.trae/mcp.json'),
+      'project': '.trae/mcp.json'
+    },
+    configKey: 'mcpServers',
+    globalOnly: false
+  }
+};
+
+// Helper Functions
+async function detectInstalledIDEs() {
+  const spinner = ora('Searching for installed IDEs...').start();
+  const installedIDEs = [];
+  
+  for (const [key, ide] of Object.entries(IDE_CONFIGS)) {
+    try {
+      if (ide.globalOnly) {
+        const globalPath = ide.paths[os.platform()];
+        if (globalPath && await fs.pathExists(path.dirname(globalPath))) {
+          installedIDEs.push(key);
+        }
+      } else {
+        const globalPath = ide.paths.global;
+        if (await fs.pathExists(path.dirname(globalPath))) {
+          installedIDEs.push(key);
+        }
+      }
+    } catch (error) {
+      // IDE not installed
+    }
+  }
+  
+  spinner.succeed(`${installedIDEs.length} IDEs found: ${installedIDEs.map(id => IDE_CONFIGS[id].name).join(', ')}`);
+  return installedIDEs;
+}
+
+async function getExistingGlobalServers() {
+  const globalServers = {};
+  
+  for (const [ideKey, ide] of Object.entries(IDE_CONFIGS)) {
+    try {
+      let configPath;
+      if (ide.globalOnly) {
+        configPath = ide.paths[os.platform()];
+      } else {
+        configPath = ide.paths.global;
+      }
+      
+      if (configPath && await fs.pathExists(configPath)) {
+        const config = await fs.readJson(configPath);
+        const servers = ide.configKey.split('.').reduce((obj, key) => obj?.[key], config) || {};
+        globalServers[ideKey] = Object.keys(servers);
+      }
+    } catch (error) {
+      globalServers[ideKey] = [];
+    }
+  }
+  
+  return globalServers;
+}
+
+async function installMCPServer(ide, serverKey, serverConfig, isGlobal, projectPath = null) {
+  const spinner = ora(`Installing ${serverKey} for ${IDE_CONFIGS[ide].name}...`).start();
+  
+  try {
+    let configPath;
+    if (isGlobal || IDE_CONFIGS[ide].globalOnly) {
+      if (IDE_CONFIGS[ide].globalOnly) {
+        configPath = IDE_CONFIGS[ide].paths[os.platform()];
+      } else {
+        configPath = IDE_CONFIGS[ide].paths.global;
+      }
+    } else {
+      configPath = path.join(projectPath || process.cwd(), IDE_CONFIGS[ide].paths.project);
+    }
+    
+    // Create directory if needed
+    await fs.ensureDir(path.dirname(configPath));
+    
+    // Load existing configuration
+    let config = {};
+    if (await fs.pathExists(configPath)) {
+      config = await fs.readJson(configPath);
+    }
+    
+    // Navigate to correct location in configuration
+    const configKeys = IDE_CONFIGS[ide].configKey.split('.');
+    let currentConfig = config;
+    for (let i = 0; i < configKeys.length - 1; i++) {
+      if (!currentConfig[configKeys[i]]) {
+        currentConfig[configKeys[i]] = {};
+      }
+      currentConfig = currentConfig[configKeys[i]];
+    }
+    
+    const finalKey = configKeys[configKeys.length - 1];
+    if (!currentConfig[finalKey]) {
+      currentConfig[finalKey] = {};
+    }
+    
+    // Check for duplicates
+    if (currentConfig[finalKey][serverKey]) {
+      spinner.warn(`${serverKey} is already installed - skipping`);
+      return false;
+    }
+    
+    // Add server (Claude Desktop format)
+    currentConfig[finalKey][serverKey] = {
+      command: serverConfig.command,
+      args: serverConfig.args
+    };
+    
+    // Add env if it exists
+    if (serverConfig.env) {
+      currentConfig[finalKey][serverKey].env = serverConfig.env;
+    }
+    
+    // Save configuration
+    await fs.writeJson(configPath, config, { spaces: 2 });
+    
+    spinner.succeed(`${serverKey} successfully installed`);
+    return true;
+  } catch (error) {
+    spinner.fail(`Error installing ${serverKey}: ${error.message}`);
+    return false;
+  }
+}
+
+async function main() {
+  try {
+    // Step 1: Setup local configuration
+    const configPath = await setupLocalConfig();
+    
+    // Step 2: Prompt user to edit configuration
+    await promptUserToEdit(configPath);
+    
+    // Step 3: Load and validate configuration with retry loop
+    const MCP_SERVERS = await loadMCPServersWithRetry();
+    
+    console.log(chalk.blue('\n🔍 Analyzing your system...'));
+    
+    // Detect installed IDEs
+    const installedIDEs = await detectInstalledIDEs();
+    
+    if (installedIDEs.length === 0) {
+      console.log(chalk.red('❌ No supported IDEs found!'));
+      console.log(chalk.yellow('Supported IDEs: Claude Desktop, Cursor, Windsurf, VS Code, Trae AI'));
+      process.exit(1);
+    }
+    
+    // Get already installed global servers
+    const existingGlobalServers = await getExistingGlobalServers();
+    
+    // Show already installed global servers
+    console.log(chalk.green('\n📊 Already installed global MCP servers:'));
+    for (const [ideKey, servers] of Object.entries(existingGlobalServers)) {
+      if (servers.length > 0) {
+        console.log(chalk.cyan(`  ${IDE_CONFIGS[ideKey].name}: ${servers.join(', ')}`));
+      }
+    }
+    
+    // IDE selection
+    const { selectedIDEs } = await safePrompt([{
+      type: 'checkbox',
+      name: 'selectedIDEs',
+      message: 'Which IDEs would you like to install MCP servers for?',
+      choices: installedIDEs.map(ide => ({
+        name: IDE_CONFIGS[ide].name,
+        value: ide,
+        checked: true
+      }))
+    }]);
+    
+    if (selectedIDEs.length === 0) {
+      console.log(chalk.yellow('No IDEs selected. Installation cancelled.'));
+      process.exit(0);
+    }
+    
+    // Global vs. Project-specific
+    const { installationType } = await safePrompt([{
+      type: 'list',
+      name: 'installationType',
+      message: 'How would you like to install the MCP servers?',
+      choices: [
+        { name: '🌍 Global (available in all projects)', value: 'global' },
+        { name: '📁 Project-specific (only in this project)', value: 'project' }
+      ]
+    }]);
+    
+    // Define global and local server keys based on their position in the object
+    const globalServerKeys = ['sequential-thinking', 'puppeteer', 'claude-continuity'];
+    
+    // Server descriptions for display (since the new format doesn't include them)
+    const serverDescriptions = {
+      'sequential-thinking': 'Structured thinking for complex problem solving',
+      'puppeteer': 'Browser automation and web scraping',
+      'claude-continuity': 'Enhanced thread continuity for Claude',
+      'extended-memory': 'Enhanced memory capabilities for AI assistants',
+      '@21st-dev/magic': 'UI builder for MCP - like v0 but in your IDE',
+      'dart': 'Dart SDK integration for Flutter/Dart projects',
+      'firebase': 'Firebase services - Auth, Firestore, Functions',
+      'supabase': 'Supabase integration - database, auth, storage',
+      'context7': 'Up-to-date code documentation for any library',
+      'stripe': 'Stripe payment integration'
+    };
+    
+    // MCP Server selection
+    const serverChoices = Object.entries(MCP_SERVERS).map(([key, server]) => {
+      // Check if already globally installed
+      let alreadyInstalled = false;
+      if (installationType !== 'project') {
+        for (const servers of Object.values(existingGlobalServers)) {
+          if (servers.includes(key)) {
+            alreadyInstalled = true;
+            break;
+          }
+        }
+      }
+      
+      const description = serverDescriptions[key] || 'MCP Server';
+      
+      return {
+        name: `${key} - ${description}${alreadyInstalled ? ' ✅ (already globally installed)' : ''}`,
+        value: key,
+        checked: !alreadyInstalled
+      };
+    });
+    
+    const { selectedServers } = await safePrompt([{
+      type: 'checkbox',
+      name: 'selectedServers',
+      message: 'Which MCP servers would you like to install?',
+      choices: serverChoices,
+      pageSize: 15
+    }]);
+    
+    if (selectedServers.length === 0) {
+      console.log(chalk.yellow('No MCP servers selected. Installation cancelled.'));
+      process.exit(0);
+    }
+    
+    // Start installation
+    console.log(chalk.blue('\n🚀 Starting installation...'));
+    
+    let successCount = 0;
+    const totalInstallations = selectedIDEs.length * selectedServers.length;
+    
+    for (const ideKey of selectedIDEs) {
+      console.log(chalk.magenta(`\n📱 Installing for ${IDE_CONFIGS[ideKey].name}:`));
+      
+      for (const serverKey of selectedServers) {
+        const server = MCP_SERVERS[serverKey];
+        
+        // Determine installation type
+        let installGlobally = installationType === 'global';
+        
+        // For IDEs that only support global
+        if (IDE_CONFIGS[ideKey].globalOnly) {
+          installGlobally = true;
+        }
+        
+        const success = await installMCPServer(ideKey, serverKey, server, installGlobally);
+        if (success) successCount++;
+      }
+    }
+    
+    // Summary
+    console.log(chalk.green.bold(`\n✅ Installation completed!`));
+    console.log(chalk.green(`📊 ${successCount}/${totalInstallations} servers successfully installed`));
+    
+    if (successCount > 0) {
+      console.log(chalk.yellow('\n⚠️  Important notes:'));
+      console.log(chalk.yellow('• Restart your IDEs for changes to take effect'));
+      console.log(chalk.yellow('• Check environment variables for servers that require API keys'));
+      console.log(chalk.yellow('• Some servers require additional configuration (see documentation)'));
+      
+      // Show specific configuration hints
+      const serversNeedingConfig = selectedServers.filter(key => 
+        MCP_SERVERS[key].env && Object.keys(MCP_SERVERS[key].env).length > 0
+      );
+      
+      if (serversNeedingConfig.length > 0) {
+        console.log(chalk.cyan('\n🔧 Servers requiring configuration:'));
+        for (const serverKey of serversNeedingConfig) {
+          const server = MCP_SERVERS[serverKey];
+          console.log(chalk.cyan(`  • ${serverKey}:`));
+          for (const [envKey, envValue] of Object.entries(server.env)) {
+            console.log(chalk.gray(`    ${envKey}: ${envValue}`));
+          }
+        }
+      }
+    }
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// List command function with dynamic loading
+async function listServers() {
+  try {
+    // Check if config exists, if not, create it
+    await setupLocalConfig();
+    
+    // Load servers (without edit prompt for list command)
+    const localConfigPath = path.join(process.cwd(), 'my_mcps.md');
+    if (!fs.existsSync(localConfigPath)) {
+      console.log(chalk.red('❌ my_mcps.md not found in current directory'));
+      console.log(chalk.yellow('💡 Run without arguments to create and configure it first'));
+      process.exit(1);
+    }
+    
+    const mcpContent = fs.readFileSync(localConfigPath, 'utf8');
+    const validation = validateMCPConfig(mcpContent);
+    
+    if (!validation.valid) {
+      console.log(chalk.red('❌ Configuration Error:'));
+      console.log(chalk.white(validation.error));
+      console.log(chalk.yellow('💡 Fix the error in my_mcps.md and try again'));
+      process.exit(1);
+    }
+    
+    const MCP_SERVERS = validation.servers;
+    
+    // List available servers
+    console.log(chalk.blue.bold('\n📋 Available MCP Servers:\n'));
+    
+    // Server descriptions for display
+    const serverDescriptions = {
+      'sequential-thinking': 'Structured thinking for complex problem solving',
+      'puppeteer': 'Browser automation and web scraping',
+      'claude-continuity': 'Enhanced thread continuity for Claude',
+      'extended-memory': 'Enhanced memory capabilities for AI assistants',
+      '@21st-dev/magic': 'UI builder for MCP - like v0 but in your IDE',
+      'dart': 'Dart SDK integration for Flutter/Dart projects',
+      'firebase': 'Firebase services - Auth, Firestore, Functions',
+      'supabase': 'Supabase integration - database, auth, storage',
+      'context7': 'Up-to-date code documentation for any library',
+      'stripe': 'Stripe payment integration'
+    };
+    
+    console.log(chalk.green.bold('🌍 GLOBAL SERVERS:'));
+    const globalServerKeys = ['sequential-thinking', 'puppeteer', 'claude-continuity'];
+    for (const key of globalServerKeys) {
+      const server = MCP_SERVERS[key];
+      if (server) {
+        const description = serverDescriptions[key] || 'MCP Server';
+        console.log(chalk.cyan(`  ${key}: ${description}`));
+      }
+    }
+    
+    console.log(chalk.yellow.bold('\n📁 LOCAL SERVERS:'));
+    for (const [key, server] of Object.entries(MCP_SERVERS)) {
+      if (!globalServerKeys.includes(key)) {
+        const description = serverDescriptions[key] || 'MCP Server';
+        console.log(chalk.cyan(`  ${key}: ${description}`));
+      }
+    }
+    console.log();
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// Process command line arguments
+const args = process.argv.slice(2);
+if (args.includes('list')) {
+  listServers();
+} else if (args.includes('uninstall')) {
+  console.log(chalk.red('🚧 Uninstall feature coming in a future version'));
+} else {
+  // Main installation
+  main();
+}