aios-core 2.1.0

package/.aios-core/core/mcp/config-migrator.js

@@ -0,0 +1,340 @@
+/**
+ * Config Migrator
+ *
+ * Handles migration of MCP configs from project-level to global.
+ * Provides intelligent merging without duplicates.
+ *
+ * @module core/mcp/config-migrator
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  readGlobalConfig,
+  writeGlobalConfig,
+  globalConfigExists,
+  createGlobalStructure,
+  createGlobalConfig,
+} = require('./global-config-manager');
+const { getProjectMcpPath, checkLinkStatus, LINK_STATUS, createLink } = require('./symlink-manager');
+
+/**
+ * Migration options
+ * @enum {string}
+ */
+const MIGRATION_OPTION = {
+  MIGRATE: 'migrate',
+  KEEP_PROJECT: 'keep_project',
+  MERGE: 'merge',
+};
+
+/**
+ * Detect project-level MCP configuration
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Detection result
+ */
+function detectProjectConfig(projectRoot = process.cwd()) {
+  const possiblePaths = [
+    path.join(projectRoot, '.aios-core', 'tools', 'mcp', 'global-config.json'),
+    path.join(projectRoot, '.aios-core', 'mcp.json'),
+    path.join(projectRoot, '.claude', 'mcp.json'),
+    path.join(projectRoot, 'mcp.json'),
+  ];
+
+  for (const configPath of possiblePaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const config = JSON.parse(content);
+
+        return {
+          found: true,
+          path: configPath,
+          config,
+          serverCount: config.servers ? Object.keys(config.servers).length : 0,
+        };
+      } catch (error) {
+        // Continue to next path
+      }
+    }
+  }
+
+  // Also check for legacy mcpServers format (from .claude.json style)
+  const claudeConfigPath = path.join(projectRoot, '.claude.json');
+  if (fs.existsSync(claudeConfigPath)) {
+    try {
+      const content = fs.readFileSync(claudeConfigPath, 'utf8');
+      const config = JSON.parse(content);
+
+      if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+        return {
+          found: true,
+          path: claudeConfigPath,
+          config: { servers: config.mcpServers, version: '1.0' },
+          serverCount: Object.keys(config.mcpServers).length,
+          isLegacyFormat: true,
+        };
+      }
+    } catch (error) {
+      // Continue
+    }
+  }
+
+  return {
+    found: false,
+    path: null,
+    config: null,
+    serverCount: 0,
+  };
+}
+
+/**
+ * Analyze migration scenario
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Migration scenario analysis
+ */
+function analyzeMigration(projectRoot = process.cwd()) {
+  const projectConfig = detectProjectConfig(projectRoot);
+  const hasGlobalConfig = globalConfigExists();
+  const linkStatus = checkLinkStatus(projectRoot);
+
+  // Determine scenario
+  let scenario;
+  let recommendedOption;
+  let message;
+
+  if (linkStatus.status === LINK_STATUS.LINKED) {
+    scenario = 'already_linked';
+    recommendedOption = null;
+    message = 'Project is already linked to global MCP config.';
+  } else if (!projectConfig.found && !hasGlobalConfig) {
+    scenario = 'fresh_install';
+    recommendedOption = MIGRATION_OPTION.MIGRATE;
+    message = 'No existing MCP config found. Will create fresh global config.';
+  } else if (!projectConfig.found && hasGlobalConfig) {
+    scenario = 'link_only';
+    recommendedOption = MIGRATION_OPTION.MIGRATE;
+    message = 'Global config exists. Will create link to it.';
+  } else if (projectConfig.found && !hasGlobalConfig) {
+    scenario = 'migrate_to_global';
+    recommendedOption = MIGRATION_OPTION.MIGRATE;
+    message = `Project config found with ${projectConfig.serverCount} servers. Will migrate to global.`;
+  } else {
+    // Both exist
+    scenario = 'merge_required';
+    recommendedOption = MIGRATION_OPTION.MERGE;
+    message = `Both project (${projectConfig.serverCount} servers) and global configs exist. Merge recommended.`;
+  }
+
+  return {
+    scenario,
+    recommendedOption,
+    message,
+    projectConfig,
+    hasGlobalConfig,
+    linkStatus,
+  };
+}
+
+/**
+ * Merge two server configurations
+ * @param {Object} existing - Existing servers
+ * @param {Object} incoming - Incoming servers
+ * @param {Object} options - Merge options
+ * @returns {Object} Merged servers with stats
+ */
+function mergeServers(existing = {}, incoming = {}, options = {}) {
+  const merged = { ...existing };
+  const stats = {
+    kept: Object.keys(existing).length,
+    added: 0,
+    skipped: 0,
+    conflicts: [],
+  };
+
+  for (const [name, config] of Object.entries(incoming)) {
+    if (!merged[name]) {
+      // New server, add it
+      merged[name] = config;
+      stats.added++;
+    } else if (options.overwrite) {
+      // Overwrite existing
+      merged[name] = config;
+      stats.conflicts.push({ name, action: 'overwritten' });
+    } else {
+      // Skip duplicate
+      stats.skipped++;
+      stats.conflicts.push({ name, action: 'skipped' });
+    }
+  }
+
+  return { servers: merged, stats };
+}
+
+/**
+ * Execute migration
+ * @param {string} projectRoot - Project root directory
+ * @param {string} option - Migration option (MIGRATION_OPTION)
+ * @param {Object} options - Additional options
+ * @returns {Object} Migration result
+ */
+function executeMigration(projectRoot = process.cwd(), option = MIGRATION_OPTION.MIGRATE, options = {}) {
+  const analysis = analyzeMigration(projectRoot);
+
+  // Handle already linked
+  if (analysis.scenario === 'already_linked') {
+    return {
+      success: true,
+      message: 'Already linked to global config.',
+      action: 'none',
+    };
+  }
+
+  // Handle keep project option
+  if (option === MIGRATION_OPTION.KEEP_PROJECT) {
+    return {
+      success: true,
+      message: 'Keeping project-level config. No changes made.',
+      action: 'none',
+    };
+  }
+
+  const results = {
+    structureCreated: false,
+    configCreated: false,
+    serversMigrated: 0,
+    linkCreated: false,
+    backupPath: null,
+    errors: [],
+  };
+
+  try {
+    // Step 1: Create global structure if needed
+    if (!analysis.hasGlobalConfig) {
+      const structureResult = createGlobalStructure();
+      if (!structureResult.success) {
+        results.errors.push(`Structure creation failed: ${structureResult.errors.join(', ')}`);
+      } else {
+        results.structureCreated = true;
+      }
+    }
+
+    // Step 2: Handle config based on option
+    if (option === MIGRATION_OPTION.MIGRATE) {
+      if (!analysis.hasGlobalConfig) {
+        // Create new global config with project servers
+        const initialServers = analysis.projectConfig.found
+          ? analysis.projectConfig.config.servers || {}
+          : {};
+
+        const configResult = createGlobalConfig(initialServers);
+        if (!configResult.success) {
+          results.errors.push(`Config creation failed: ${configResult.error}`);
+          return { success: false, results, errors: results.errors };
+        }
+        results.configCreated = true;
+        results.serversMigrated = Object.keys(initialServers).length;
+      }
+    } else if (option === MIGRATION_OPTION.MERGE) {
+      const globalConfig = readGlobalConfig() || { version: '1.0', servers: {} };
+      const projectServers = analysis.projectConfig.found
+        ? analysis.projectConfig.config.servers || {}
+        : {};
+
+      const mergeResult = mergeServers(
+        globalConfig.servers,
+        projectServers,
+        { overwrite: options.overwrite },
+      );
+
+      globalConfig.servers = mergeResult.servers;
+
+      const writeResult = writeGlobalConfig(globalConfig);
+      if (!writeResult.success) {
+        results.errors.push(`Config write failed: ${writeResult.error}`);
+        return { success: false, results, errors: results.errors };
+      }
+
+      results.serversMigrated = mergeResult.stats.added;
+      results.mergeStats = mergeResult.stats;
+    }
+
+    // Step 3: Backup and remove project config if it exists as directory
+    if (analysis.linkStatus.status === LINK_STATUS.DIRECTORY && analysis.projectConfig.found) {
+      const projectMcpPath = getProjectMcpPath(projectRoot);
+      const backupPath = projectMcpPath + '.backup.' + Date.now();
+
+      try {
+        fs.renameSync(projectMcpPath, backupPath);
+        results.backupPath = backupPath;
+      } catch (error) {
+        results.errors.push(`Backup failed: ${error.message}`);
+      }
+    }
+
+    // Step 4: Create link
+    const linkResult = createLink(projectRoot, { force: true });
+    if (!linkResult.success) {
+      results.errors.push(`Link creation failed: ${linkResult.error}`);
+    } else {
+      results.linkCreated = true;
+    }
+
+    return {
+      success: results.errors.length === 0,
+      results,
+      errors: results.errors,
+    };
+  } catch (error) {
+    results.errors.push(`Migration failed: ${error.message}`);
+    return {
+      success: false,
+      results,
+      errors: results.errors,
+    };
+  }
+}
+
+/**
+ * Restore from backup
+ * @param {string} backupPath - Path to backup
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Restore result
+ */
+function restoreFromBackup(backupPath, projectRoot = process.cwd()) {
+  const projectMcpPath = getProjectMcpPath(projectRoot);
+
+  if (!fs.existsSync(backupPath)) {
+    return { success: false, error: 'Backup not found' };
+  }
+
+  try {
+    // Remove current link/directory
+    if (fs.existsSync(projectMcpPath)) {
+      const stats = fs.lstatSync(projectMcpPath);
+      if (stats.isSymbolicLink()) {
+        fs.unlinkSync(projectMcpPath);
+      } else {
+        fs.rmSync(projectMcpPath, { recursive: true });
+      }
+    }
+
+    // Restore backup
+    fs.renameSync(backupPath, projectMcpPath);
+
+    return { success: true, restored: projectMcpPath };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  MIGRATION_OPTION,
+  detectProjectConfig,
+  analyzeMigration,
+  mergeServers,
+  executeMigration,
+  restoreFromBackup,
+};

package/.aios-core/core/mcp/global-config-manager.js

@@ -0,0 +1,369 @@
+/**
+ * Global Config Manager
+ *
+ * Manages the global MCP configuration at ~/.aios/mcp/
+ * Handles creation, reading, updating of global config.
+ *
+ * @module core/mcp/global-config-manager
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getGlobalAiosDir,
+  getGlobalMcpDir,
+  getGlobalConfigPath,
+  getServersDir,
+  getCacheDir,
+  getCredentialsDir,
+} = require('./os-detector');
+
+/**
+ * Default global config structure
+ */
+const DEFAULT_CONFIG = {
+  version: '1.0',
+  servers: {},
+  defaults: {
+    timeout: 30000,
+    retries: 3,
+  },
+};
+
+/**
+ * Default server templates for common MCP servers
+ */
+const SERVER_TEMPLATES = {
+  context7: {
+    type: 'sse',
+    url: 'https://mcp.context7.com/sse',
+    enabled: true,
+  },
+  exa: {
+    command: 'npx',
+    args: ['-y', 'exa-mcp-server'],
+    env: {
+      EXA_API_KEY: '${EXA_API_KEY}',
+    },
+    enabled: true,
+  },
+  github: {
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+    env: {
+      GITHUB_TOKEN: '${GITHUB_TOKEN}',
+    },
+    enabled: true,
+  },
+  puppeteer: {
+    command: 'npx',
+    args: ['-y', '@anthropic-ai/mcp-server-puppeteer'],
+    enabled: true,
+  },
+  'desktop-commander': {
+    command: 'npx',
+    args: ['-y', '@anthropic-ai/mcp-server-desktop-commander'],
+    enabled: true,
+  },
+  filesystem: {
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem'],
+    enabled: true,
+  },
+  memory: {
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-memory'],
+    enabled: true,
+  },
+};
+
+/**
+ * Check if global AIOS directory exists
+ * @returns {boolean}
+ */
+function globalDirExists() {
+  return fs.existsSync(getGlobalAiosDir());
+}
+
+/**
+ * Check if global MCP directory exists
+ * @returns {boolean}
+ */
+function globalMcpDirExists() {
+  return fs.existsSync(getGlobalMcpDir());
+}
+
+/**
+ * Check if global config file exists
+ * @returns {boolean}
+ */
+function globalConfigExists() {
+  return fs.existsSync(getGlobalConfigPath());
+}
+
+/**
+ * Create the global directory structure
+ * @returns {Object} Result with created directories
+ */
+function createGlobalStructure() {
+  const created = [];
+  const errors = [];
+
+  const directories = [
+    getGlobalAiosDir(),
+    getGlobalMcpDir(),
+    getServersDir(),
+    getCacheDir(),
+    getCredentialsDir(),
+  ];
+
+  for (const dir of directories) {
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        created.push(dir);
+      }
+    } catch (error) {
+      errors.push({ dir, error: error.message });
+    }
+  }
+
+  // Create .gitignore in credentials directory
+  const credentialsGitignore = path.join(getCredentialsDir(), '.gitignore');
+  try {
+    if (!fs.existsSync(credentialsGitignore)) {
+      fs.writeFileSync(credentialsGitignore, '*\n!.gitignore\n');
+      created.push(credentialsGitignore);
+    }
+  } catch (error) {
+    errors.push({ file: credentialsGitignore, error: error.message });
+  }
+
+  return { created, errors, success: errors.length === 0 };
+}
+
+/**
+ * Create default global config file
+ * @param {Object} initialServers - Optional initial servers to include
+ * @returns {Object} Result with config path
+ */
+function createGlobalConfig(initialServers = {}) {
+  const configPath = getGlobalConfigPath();
+
+  if (fs.existsSync(configPath)) {
+    return { success: false, error: 'Config already exists', configPath };
+  }
+
+  const config = {
+    ...DEFAULT_CONFIG,
+    servers: { ...initialServers },
+  };
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    return { success: true, configPath };
+  } catch (error) {
+    return { success: false, error: error.message, configPath };
+  }
+}
+
+/**
+ * Read global config
+ * @returns {Object|null} Config object or null if not exists
+ */
+function readGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Error reading global config: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Write global config
+ * @param {Object} config - Config object to write
+ * @returns {Object} Result with success status
+ */
+function writeGlobalConfig(config) {
+  const configPath = getGlobalConfigPath();
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    return { success: true, configPath };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Add a server to global config
+ * @param {string} serverName - Name of the server
+ * @param {Object} serverConfig - Server configuration (optional, uses template if available)
+ * @returns {Object} Result with success status
+ */
+function addServer(serverName, serverConfig = null) {
+  const config = readGlobalConfig();
+
+  if (!config) {
+    return { success: false, error: 'Global config not found. Run "aios mcp setup" first.' };
+  }
+
+  // Use template if available and no config provided
+  if (!serverConfig && SERVER_TEMPLATES[serverName]) {
+    serverConfig = { ...SERVER_TEMPLATES[serverName] };
+  } else if (!serverConfig) {
+    return { success: false, error: `No template available for "${serverName}". Provide server configuration.` };
+  }
+
+  // Check if server already exists
+  if (config.servers[serverName]) {
+    return { success: false, error: `Server "${serverName}" already exists in config.` };
+  }
+
+  config.servers[serverName] = serverConfig;
+
+  const writeResult = writeGlobalConfig(config);
+  if (!writeResult.success) {
+    return writeResult;
+  }
+
+  // Also create individual server config file
+  const serverFilePath = path.join(getServersDir(), `${serverName}.json`);
+  try {
+    fs.writeFileSync(serverFilePath, JSON.stringify(serverConfig, null, 2), 'utf8');
+  } catch (error) {
+    // Non-critical error, main config is updated
+    console.warn(`Warning: Could not create server file: ${error.message}`);
+  }
+
+  return { success: true, server: serverName };
+}
+
+/**
+ * Remove a server from global config
+ * @param {string} serverName - Name of the server to remove
+ * @returns {Object} Result with success status
+ */
+function removeServer(serverName) {
+  const config = readGlobalConfig();
+
+  if (!config) {
+    return { success: false, error: 'Global config not found.' };
+  }
+
+  if (!config.servers[serverName]) {
+    return { success: false, error: `Server "${serverName}" not found in config.` };
+  }
+
+  delete config.servers[serverName];
+
+  const writeResult = writeGlobalConfig(config);
+  if (!writeResult.success) {
+    return writeResult;
+  }
+
+  // Also remove individual server config file
+  const serverFilePath = path.join(getServersDir(), `${serverName}.json`);
+  try {
+    if (fs.existsSync(serverFilePath)) {
+      fs.unlinkSync(serverFilePath);
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not remove server file: ${error.message}`);
+  }
+
+  return { success: true, server: serverName };
+}
+
+/**
+ * Enable/disable a server
+ * @param {string} serverName - Name of the server
+ * @param {boolean} enabled - Enable or disable
+ * @returns {Object} Result with success status
+ */
+function setServerEnabled(serverName, enabled) {
+  const config = readGlobalConfig();
+
+  if (!config) {
+    return { success: false, error: 'Global config not found.' };
+  }
+
+  if (!config.servers[serverName]) {
+    return { success: false, error: `Server "${serverName}" not found in config.` };
+  }
+
+  config.servers[serverName].enabled = enabled;
+
+  return writeGlobalConfig(config);
+}
+
+/**
+ * Get list of configured servers
+ * @returns {Object} Object with server names and their enabled status
+ */
+function listServers() {
+  const config = readGlobalConfig();
+
+  if (!config) {
+    return { servers: [], total: 0, enabled: 0 };
+  }
+
+  const servers = Object.entries(config.servers).map(([name, cfg]) => ({
+    name,
+    type: cfg.type || 'command',
+    enabled: cfg.enabled !== false,
+    url: cfg.url,
+    command: cfg.command,
+  }));
+
+  return {
+    servers,
+    total: servers.length,
+    enabled: servers.filter(s => s.enabled).length,
+  };
+}
+
+/**
+ * Get available server templates
+ * @returns {string[]} List of available template names
+ */
+function getAvailableTemplates() {
+  return Object.keys(SERVER_TEMPLATES);
+}
+
+/**
+ * Get a server template
+ * @param {string} name - Template name
+ * @returns {Object|null} Template config or null
+ */
+function getServerTemplate(name) {
+  return SERVER_TEMPLATES[name] ? { ...SERVER_TEMPLATES[name] } : null;
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  SERVER_TEMPLATES,
+  globalDirExists,
+  globalMcpDirExists,
+  globalConfigExists,
+  createGlobalStructure,
+  createGlobalConfig,
+  readGlobalConfig,
+  writeGlobalConfig,
+  addServer,
+  removeServer,
+  setServerEnabled,
+  listServers,
+  getAvailableTemplates,
+  getServerTemplate,
+};