mlgym-deploy 3.3.5 → 3.3.13

package/index.js

@@ -18,7 +18,7 @@ import crypto from 'crypto';
 const execAsync = promisify(exec);
 
 // Current version of this MCP server - INCREMENT FOR WORKFLOW FIXES
-const CURRENT_VERSION = '3.3.5';  // Fixed mlgym_deploy_logs project lookup (data.projects → data) by importing fsSync for synchronous file operations
+const CURRENT_VERSION = '3.3.13';  // Fix branch detection for git push (master vs main)
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -112,14 +112,15 @@ async function saveAuth(email, token) {
   );
 }
 
-// API client helper
-async function apiRequest(method, endpoint, data = null, useAuth = true) {
+// API client helper with retry logic for 5xx errors
+async function apiRequest(method, endpoint, data = null, useAuth = true, maxRetries = 3) {
   const config = {
     method,
     url: `${CONFIG.backend_url}${endpoint}`,
     headers: {
       'Content-Type': 'application/json'
-    }
+    },
+    timeout: 120000  // 2 minute timeout for long operations
   };
 
   if (useAuth) {
@@ -133,13 +134,32 @@ async function apiRequest(method, endpoint, data = null, useAuth = true) {
     config.data = data;
   }
 
-  try {
-    const response = await axios(config);
-    return { success: true, data: response.data };
-  } catch (error) {
-    const errorData = error.response?.data || { error: error.message };
-    return { success: false, error: errorData.error || errorData.message || 'Request failed' };
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await axios(config);
+      return { success: true, data: response.data };
+    } catch (error) {
+      lastError = error;
+      const statusCode = error.response?.status;
+
+      // Retry on 5xx errors (server errors) or network errors
+      if (statusCode >= 500 || !error.response) {
+        if (attempt < maxRetries) {
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);  // Exponential backoff, max 10s
+          log.warning(`MCP >>> API request failed (attempt ${attempt}/${maxRetries}), status: ${statusCode || 'network error'}, retrying in ${delay}ms...`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+          continue;
+        }
+      }
+
+      // Don't retry on 4xx errors (client errors)
+      break;
+    }
   }
+
+  const errorData = lastError?.response?.data || { error: lastError?.message };
+  return { success: false, error: errorData.error || errorData.message || 'Request failed' };
 }
 
 // Helper to generate random password
@@ -986,8 +1006,8 @@ async function detectDeploymentStrategy(projectPath) {
 
   // Case 2: Only docker-compose
   if (!hasDockerfile && hasCompose) {
-    log.info('MCP >>> [detectDeploymentStrategy] Strategy: docker-compose (compose only)');
-    return { type: 'docker-compose', reason: 'docker-compose.yml only' };
+    log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockercompose (compose only)');
+    return { type: 'dockercompose', reason: 'docker-compose.yml only' };
   }
 
   // Case 3: Both exist - analyze docker-compose to decide
@@ -1008,11 +1028,11 @@ async function detectDeploymentStrategy(projectPath) {
 
       // COMPLEX: Multiple services (web + database, etc.)
       // → MUST use docker-compose for orchestration
-      log.info('MCP >>> [detectDeploymentStrategy] Strategy: docker-compose (multi-service)');
-      return { type: 'docker-compose', reason: 'Application requires multiple services (web + database/cache/etc)' };
+      log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockercompose (multi-service)');
+      return { type: 'dockercompose', reason: 'Application requires multiple services (web + database/cache/etc)' };
     } catch (err) {
-      log.error('MCP >>> [detectDeploymentStrategy] Analysis failed, defaulting to docker-compose:', err.message);
-      return { type: 'docker-compose', reason: 'Multiple deployment files found' };
+      log.error('MCP >>> [detectDeploymentStrategy] Analysis failed, defaulting to dockercompose:', err.message);
+      return { type: 'dockercompose', reason: 'Multiple deployment files found' };
     }
   }
 
@@ -1100,6 +1120,35 @@ function validateAndFixDockerCompose(content) {
   };
 }
 
+// Randomize volume names to prevent collisions across deployments
+function randomizeVolumeNames(content, suffix) {
+  // Common volume patterns to look for
+  const volumePatterns = [
+    'mariadb-data', 'mysql-data', 'postgres-data', 'postgresql-data',
+    'mongo-data', 'mongodb-data', 'redis-data', 'cassandra-data',
+    'elasticsearch-data', 'rabbitmq-data', 'kafka-data', 'cockroach-data',
+    'db-data', 'database-data', 'app-data', 'web-data', 'cache-data'
+  ];
+
+  let result = content;
+  let randomized = false;
+
+  for (const volumeName of volumePatterns) {
+    // Check if this volume is used
+    if (result.includes(volumeName)) {
+      // Replace in volume declarations (e.g., "mariadb-data:")
+      result = result.split(volumeName + ':').join(volumeName + '-' + suffix + ':');
+      // Replace in volume references (e.g., "mariadb-data:/var/lib/mysql")
+      result = result.split(volumeName + ':/').join(volumeName + '-' + suffix + ':/');
+      // Replace in top-level volume declarations (with newline)
+      result = result.split('  ' + volumeName + '\n').join('  ' + volumeName + '-' + suffix + '\n');
+      randomized = true;
+    }
+  }
+
+  return { content: result, randomized };
+}
+
 // Validate Dockerfile for Coolify compliance
 function validateDockerfile(content) {
   const lines = content.split('\n');
@@ -1296,8 +1345,8 @@ async function initProject(args) {
     projectData.hostname = hostname;
     projectData.local_path = local_path;
 
-    // Read docker-compose content if using docker-compose strategy (v3.2.1+)
-    if (strategy.type === 'docker-compose') {
+    // Read docker-compose content if using dockercompose strategy (v3.2.1+)
+    if (strategy.type === 'dockercompose') {
       const composeFiles = ['docker-compose.yml', 'docker-compose.yaml'];
       let composeContent = null;
 
@@ -1476,12 +1525,23 @@ async function initProject(args) {
     log.info('MCP >>> [initProject] Pushing to GitLab...');
     log.debug('MCP >>> [initProject] Git remote URL:', gitUrl);
     gitSteps.push('Pushing to GitLab to trigger deployment');
-    console.error('Executing: git push -u mlgym main');
+
+    // Detect the current branch name (could be main or master)
+    let branchName = 'main';
+    try {
+      const { stdout: branchOutput } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: absolutePath });
+      branchName = branchOutput.trim();
+      log.info(`MCP >>> [initProject] Detected branch: ${branchName}`);
+    } catch (branchError) {
+      log.warning(`MCP >>> [initProject] Could not detect branch, using default: ${branchName}`);
+    }
+
+    console.error(`Executing: git push -u mlgym ${branchName}`);
     const authInfo = await loadAuth();
     const sanitizedEmail = authInfo.email.replace('@', '_at_').replace(/[^a-zA-Z0-9_-]/g, '_');
     const sshKeyPath = path.join(os.homedir(), '.ssh', `mlgym_${sanitizedEmail}`);
     const gitSshCmd = `ssh -i "${sshKeyPath}"`;
-    await execAsync('git push -u mlgym main', { cwd: absolutePath, env: { ...process.env, GIT_SSH_COMMAND: gitSshCmd } });
+    await execAsync(`git push -u mlgym ${branchName}`, { cwd: absolutePath, env: { ...process.env, GIT_SSH_COMMAND: gitSshCmd } });
     gitSteps.push('✅ Successfully pushed to GitLab');
     pushSucceeded = true;
     log.success('MCP >>> [initProject] ✅ Git push completed successfully!');
@@ -1794,6 +1854,10 @@ class DeploymentWorkflow {
     const auth = await loadAuth();
     if (auth.token) {
       this.authToken = auth.token;
+
+      // Also ensure SSH key exists locally and in GitLab
+      await this.ensureSSHKey(auth.email);
+
       this.updateLastStep('completed', 'Using cached authentication');
       return { authenticated: true, cached: true };
     }
@@ -1820,6 +1884,43 @@ class DeploymentWorkflow {
     }
   }
 
+  // Ensure SSH key exists locally and is registered with GitLab
+  async ensureSSHKey(email) {
+    if (!email) return;
+
+    const sanitizedEmail = email.replace('@', '_at_').replace(/[^a-zA-Z0-9_-]/g, '_');
+    const sshKeyPath = path.join(os.homedir(), '.ssh', `mlgym_${sanitizedEmail}`);
+
+    // Check if SSH key exists locally
+    let keyExists = false;
+    try {
+      await fs.access(sshKeyPath);
+      keyExists = true;
+      log.info(`MCP >>> SSH key exists at ${sshKeyPath}`);
+    } catch {
+      log.info('MCP >>> SSH key does not exist locally, generating...');
+    }
+
+    if (!keyExists) {
+      // Generate SSH key pair
+      const { publicKey, privateKeyPath } = await generateSSHKeyPair(email);
+      log.success(`MCP >>> SSH key generated at ${privateKeyPath}`);
+
+      // Register key with GitLab via API
+      const keyTitle = `mlgym-${new Date().toISOString().split('T')[0]}`;
+      const keyResult = await apiRequest('POST', '/api/v1/keys', {
+        title: keyTitle,
+        key: publicKey
+      }, true);
+
+      if (keyResult.success) {
+        log.success('MCP >>> SSH key registered with GitLab');
+      } else {
+        log.warning(`MCP >>> Failed to register SSH key: ${keyResult.error}`);
+      }
+    }
+  }
+
   async analyzeProject(local_path) {
     this.currentStep = 'analysis';
     this.addStep('project_analysis', 'running');
@@ -1956,8 +2057,8 @@ async function deployProject(args) {
   const {
     email,
     password,
-    project_name,
-    project_description,
+    project_name: argProjectName,
+    project_description: argProjectDescription,
     hostname,
     local_path = '.',
     project_type,
@@ -1965,8 +2066,17 @@ async function deployProject(args) {
     package_manager = 'npm'
   } = args;
 
+  // Derive project name from local_path if not provided
+  const resolvedPath = path.resolve(local_path);
+  const derivedName = path.basename(resolvedPath);
+  const project_name = argProjectName || derivedName;
+  const project_description = argProjectDescription || `${project_name} - deployed via MLGym MCP`;
+
   log.info('MCP >>> Starting deployment workflow');
   log.debug('MCP >>> Arguments:', { project_name, hostname, local_path, project_type, framework, package_manager });
+  if (!argProjectName) {
+    log.info(`MCP >>> Derived project name from path: ${project_name}`);
+  }
 
   try {
     // Step 1: Ensure authenticated
@@ -2018,15 +2128,23 @@ async function deployProject(args) {
 
     // Step 4.5: Validate and fix deployment files for Coolify compliance
     log.info('MCP >>> STEP 4.5: Validating deployment configuration...');
-    const strategy = detectDeploymentStrategy(local_path);
+    const strategy = await detectDeploymentStrategy(local_path);
 
-    if (strategy.type === 'docker-compose') {
+    if (strategy.type === 'dockercompose') {
       const composePath = path.join(local_path, 'docker-compose.yml');
       const composePathYAML = path.join(local_path, 'docker-compose.yaml');
       const actualPath = fsSync.existsSync(composePath) ? composePath : composePathYAML;
 
       if (fsSync.existsSync(actualPath)) {
-        const content = fsSync.readFileSync(actualPath, 'utf8');
+        let content = fsSync.readFileSync(actualPath, 'utf8');
+        let fileModified = false;
+
+        // Create backup before any modifications
+        const backupPath = actualPath + '.backup';
+        fsSync.writeFileSync(backupPath, content);
+        log.info(`MCP >>> Created backup at ${backupPath}`);
+
+        // Step 1: Validate and fix port mappings
         const validation = validateAndFixDockerCompose(content);
 
         if (!validation.isValid) {
@@ -2037,18 +2155,32 @@ async function deployProject(args) {
 
           // Auto-fix the issues
           log.info('MCP >>> Auto-fixing docker-compose.yml port mappings...');
-          fsSync.writeFileSync(actualPath, validation.fixedContent);
-
-          // Create backup
-          const backupPath = actualPath + '.backup';
-          fsSync.writeFileSync(backupPath, content);
-          log.info(`MCP >>> Created backup at ${backupPath}`);
+          content = validation.fixedContent;
+          fileModified = true;
 
           log.success('MCP >>> Fixed docker-compose.yml:');
           validation.fixes.forEach(fix => log.success(`  - ${fix}`));
         } else {
           log.success('MCP >>> Docker-compose.yml is Coolify compliant');
         }
+
+        // Step 2: Randomize volume names to prevent collisions across deployments
+        // Generate unique suffix from timestamp + random chars
+        const volumeSuffix = Date.now().toString(36) + Math.random().toString(36).substr(2, 4);
+        const volumeResult = randomizeVolumeNames(content, volumeSuffix);
+
+        if (volumeResult.randomized) {
+          log.info(`MCP >>> Randomizing volume names with suffix: ${volumeSuffix}`);
+          content = volumeResult.content;
+          fileModified = true;
+          log.success('MCP >>> Volume names randomized to prevent collisions');
+        }
+
+        // Write the modified content if anything changed
+        if (fileModified) {
+          fsSync.writeFileSync(actualPath, content);
+          log.info('MCP >>> Saved modified docker-compose.yml');
+        }
       }
     } else if (strategy.type === 'dockerfile') {
       const dockerfilePath = path.join(local_path, 'Dockerfile');
@@ -2232,27 +2364,30 @@ async function getDeploymentLogs(args) {
     }
 
     log.info(`MCP >>> [getDeploymentLogs] Detected project name: ${projectName}`);
+    // Get Coolify app UUID directly from User Agent by name
+    const userAgentURL = 'http://coolify.eu.ezb.net:9000';
+    const appLookupEndpoint = `${userAgentURL}/applications/by-name/${projectName}`;
+    
+    log.info(`MCP >>> [getDeploymentLogs] Looking up application by name`);
 
-    // Get project details from backend to get Coolify app UUID
-    const projectsResult = await apiRequest('GET', '/api/v1/projects', null, true);
-    if (!projectsResult.success) {
-      throw new Error(`Failed to get projects: ${projectsResult.error}`);
-    }
-
-    const project = projectsResult.data?.find(p => p.name === projectName);
-    if (!project) {
-      throw new Error(`Project "${projectName}" not found in your account`);
-    }
-
-    if (!project.coolify_app_uuid) {
-      throw new Error(`Project "${projectName}" does not have deployment enabled`);
+    let appUUID;
+    try {
+      const appResponse = await axios.get(appLookupEndpoint, {
+        headers: {
+          'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+          'Content-Type': 'application/json'
+        }
+      });
+      appUUID = appResponse.data.uuid;
+      log.info(`MCP >>> [getDeploymentLogs] Found Coolify app UUID: ${appUUID}`);
+    } catch (appError) {
+      if (appError.response?.status === 404) {
+        throw new Error(`Project "${projectName}" not found in Coolify. Make sure deployment is enabled.`);
+      }
+      throw new Error(`Failed to lookup application: ${appError.message}`);
     }
 
-    const appUUID = project.coolify_app_uuid;
-    log.info(`MCP >>> [getDeploymentLogs] Found Coolify app UUID: ${appUUID}`);
-
     // Call User Agent API to get deployment logs
-    const userAgentURL = 'http://coolify.eu.ezb.net:9000';
     const endpoint = `${userAgentURL}/applications/${appUUID}/deployment-logs?depth=${depth}`;
 
     log.info(`MCP >>> [getDeploymentLogs] Calling User Agent: ${endpoint}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlgym-deploy",
-  "version": "3.3.5",
+  "version": "3.3.13",
   "description": "MCP server for MLGym - Complete deployment management: deploy, configure, monitor, and rollback applications",
   "main": "index.js",
   "type": "module",
@@ -52,6 +52,10 @@
         "name": "mlgym_set_env_vars",
         "description": "Set environment variables for an application (DATABASE_URL, API keys, etc.)"
       },
+      {
+        "name": "mlgym_deploy_logs",
+        "description": "View deployment history and logs for a project"
+      },
       {
         "name": "mlgym_set_health_check",
         "description": "Configure health checks to monitor application availability"