mlgym-deploy 3.2.0 → 3.2.3

package/index.js

@@ -17,7 +17,7 @@ import crypto from 'crypto';
 const execAsync = promisify(exec);
 
 // Current version of this MCP server - INCREMENT FOR WORKFLOW FIXES
-const CURRENT_VERSION = '3.2.0';  // Added mlgym_deploy_logs tool for viewing deployment history
+const CURRENT_VERSION = '3.2.2';  // Added automatic validation and fixing for docker-compose and Dockerfile
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -1020,6 +1020,115 @@ async function detectDeploymentStrategy(projectPath) {
   return { type: 'none', reason: 'No Dockerfile or docker-compose.yml found' };
 }
 
+// Validate and potentially fix docker-compose.yml for Coolify compliance
+function validateAndFixDockerCompose(content) {
+  const lines = content.split('\n');
+  const issues = [];
+  const fixes = [];
+  let fixed = [...lines];
+  let inServicesSection = false;
+  let inPortsSection = false;
+  let currentService = '';
+  let currentIndent = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Detect services section
+    if (trimmed === 'services:') {
+      inServicesSection = true;
+      continue;
+    }
+
+    if (!inServicesSection) continue;
+
+    // Check for service definition
+    if (trimmed && !line.startsWith(' ') && !line.startsWith('\t')) {
+      inServicesSection = false;
+      break;
+    }
+
+    // New service
+    if ((line.startsWith('  ') || line.startsWith('\t')) &&
+        trimmed.endsWith(':') &&
+        !trimmed.startsWith('-') &&
+        !['ports:', 'expose:', 'environment:', 'volumes:', 'networks:'].includes(trimmed)) {
+      currentService = trimmed.slice(0, -1);
+      currentIndent = line.match(/^(\s*)/)[1];
+    }
+
+    // Check for ports section
+    if (trimmed === 'ports:') {
+      inPortsSection = true;
+      continue;
+    }
+
+    // Process port entries
+    if (inPortsSection && trimmed.startsWith('- ')) {
+      const portEntry = trimmed.slice(2).replace(/['"]/g, '');
+
+      if (portEntry.includes(':')) {
+        const [external, internal] = portEntry.split(':').map(p => p.trim());
+        const webPorts = ['80', '8080', '3000', '4000', '5000', '8000', '9000'];
+
+        if (webPorts.includes(internal) && external !== '80') {
+          issues.push({
+            line: i + 1,
+            service: currentService,
+            issue: `Port mapping "${external}:${internal}" not allowed`,
+            fix: `Use "80:${internal}" instead`
+          });
+
+          // Fix the line - preserve internal port
+          fixed[i] = line.replace(trimmed, `- "80:${internal}"`);
+          fixes.push(`Fixed ${currentService}: ${external}:${internal} → 80:${internal}`);
+        }
+      }
+    } else if (inPortsSection && !trimmed.startsWith('-')) {
+      inPortsSection = false;
+    }
+  }
+
+  return {
+    isValid: issues.length === 0,
+    issues,
+    fixes,
+    fixedContent: fixed.join('\n'),
+    hasChanges: fixes.length > 0
+  };
+}
+
+// Validate Dockerfile for Coolify compliance
+function validateDockerfile(content) {
+  const lines = content.split('\n');
+  const issues = [];
+  let hasExpose80 = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim().toUpperCase();
+
+    if (trimmed.startsWith('EXPOSE')) {
+      // Check if it exposes port 80
+      if (trimmed.includes('80') && !trimmed.includes('8080') && !trimmed.includes('8443')) {
+        hasExpose80 = true;
+      }
+    }
+  }
+
+  if (!hasExpose80) {
+    issues.push({
+      issue: 'Dockerfile does not EXPOSE port 80',
+      fix: 'Add "EXPOSE 80" to your Dockerfile'
+    });
+  }
+
+  return {
+    isValid: issues.length === 0,
+    issues
+  };
+}
+
 // Analyze docker-compose.yml to determine deployment strategy
 async function analyzeComposeFile(composePath) {
   const content = await fs.readFile(composePath, 'utf-8');
@@ -1186,6 +1295,32 @@ 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') {
+      const composeFiles = ['docker-compose.yml', 'docker-compose.yaml'];
+      let composeContent = null;
+
+      for (const filename of composeFiles) {
+        const composePath = path.join(local_path, filename);
+        if (fs.existsSync(composePath)) {
+          try {
+            composeContent = fs.readFileSync(composePath, 'utf8');
+            log.info(`MCP >>> [initProject] Read ${filename}: ${composeContent.length} bytes`);
+            break;
+          } catch (err) {
+            log.error(`MCP >>> [initProject] Error reading ${filename}:`, err.message);
+          }
+        }
+      }
+
+      if (composeContent) {
+        projectData.docker_compose_content = composeContent;
+        log.info(`MCP >>> [initProject] Sending docker-compose content: ${composeContent.length} bytes`);
+      } else {
+        log.warn('MCP >>> [initProject] docker-compose strategy but no compose file found!');
+      }
+    }
+
     log.info(`MCP >>> [initProject] Sending deployment_type: ${strategy.type} to backend`);
   }
 
@@ -1872,6 +2007,83 @@ async function deployProject(args) {
     log.success('MCP >>> STEP 4: Project preparation complete');
     log.debug('MCP >>> Preparation actions:', prepResult);
 
+    // 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);
+
+    if (strategy.type === 'docker-compose') {
+      const composePath = path.join(local_path, 'docker-compose.yml');
+      const composePathYAML = path.join(local_path, 'docker-compose.yaml');
+      const actualPath = fs.existsSync(composePath) ? composePath : composePathYAML;
+
+      if (fs.existsSync(actualPath)) {
+        const content = fs.readFileSync(actualPath, 'utf8');
+        const validation = validateAndFixDockerCompose(content);
+
+        if (!validation.isValid) {
+          log.warning('MCP >>> Docker-compose validation issues found:');
+          validation.issues.forEach(issue => {
+            log.warning(`  - Line ${issue.line}: ${issue.issue} (${issue.fix})`);
+          });
+
+          // Auto-fix the issues
+          log.info('MCP >>> Auto-fixing docker-compose.yml port mappings...');
+          fs.writeFileSync(actualPath, validation.fixedContent);
+
+          // Create backup
+          const backupPath = actualPath + '.backup';
+          fs.writeFileSync(backupPath, content);
+          log.info(`MCP >>> Created backup at ${backupPath}`);
+
+          log.success('MCP >>> Fixed docker-compose.yml:');
+          validation.fixes.forEach(fix => log.success(`  - ${fix}`));
+        } else {
+          log.success('MCP >>> Docker-compose.yml is Coolify compliant');
+        }
+      }
+    } else if (strategy.type === 'dockerfile') {
+      const dockerfilePath = path.join(local_path, 'Dockerfile');
+
+      if (fs.existsSync(dockerfilePath)) {
+        const content = fs.readFileSync(dockerfilePath, 'utf8');
+        const validation = validateDockerfile(content);
+
+        if (!validation.isValid) {
+          log.warning('MCP >>> Dockerfile validation issues:');
+          validation.issues.forEach(issue => {
+            log.warning(`  - ${issue.issue}`);
+            log.info(`    Fix: ${issue.fix}`);
+          });
+
+          // For Dockerfile, we'll add EXPOSE 80 if missing
+          if (!content.includes('EXPOSE 80')) {
+            log.info('MCP >>> Auto-fixing Dockerfile: adding EXPOSE 80...');
+            const lines = content.split('\n');
+
+            // Find the last FROM or WORKDIR line to add EXPOSE after it
+            let insertIndex = lines.length - 1;
+            for (let i = lines.length - 1; i >= 0; i--) {
+              if (lines[i].trim().startsWith('WORKDIR') || lines[i].trim().startsWith('FROM')) {
+                insertIndex = i + 1;
+                break;
+              }
+            }
+
+            lines.splice(insertIndex, 0, '', 'EXPOSE 80');
+            const fixedContent = lines.join('\n');
+
+            // Create backup
+            fs.writeFileSync(dockerfilePath + '.backup', content);
+            fs.writeFileSync(dockerfilePath, fixedContent);
+
+            log.success('MCP >>> Fixed Dockerfile: added EXPOSE 80');
+          }
+        } else {
+          log.success('MCP >>> Dockerfile is Coolify compliant');
+        }
+      }
+    }
+
     // Step 5: Create GitLab project and deploy
     log.info('MCP >>> STEP 5: Creating GitLab project and deploying...');
     log.debug('MCP >>> Project params:', { name: project_name, hostname: hostname || project_name, local_path });

package/mcp-docker-compose-patch.js

@@ -0,0 +1,189 @@
+// MCP Patch: Add docker-compose.yml content reading (matching CLI v2.0.14+)
+//
+// This patch ensures MCP reads docker-compose.yml content and sends it to the backend
+// just like the CLI does, so the backend can store it in Coolify's database.
+
+// Add this function after detectDeploymentStrategy function:
+function readDockerComposeContent(projectPath) {
+  const fs = require('fs');
+  const path = require('path');
+
+  // Check both .yml and .yaml extensions
+  const composeFiles = ['docker-compose.yml', 'docker-compose.yaml'];
+
+  for (const filename of composeFiles) {
+    const composePath = path.join(projectPath, filename);
+    if (fs.existsSync(composePath)) {
+      try {
+        const content = fs.readFileSync(composePath, 'utf8');
+        console.log(`[MCP] Read ${filename}: ${content.length} bytes`);
+        return content;
+      } catch (err) {
+        console.error(`[MCP] Error reading ${filename}:`, err.message);
+      }
+    }
+  }
+
+  return null;
+}
+
+// MODIFICATION NEEDED in initProject function (around line 1180-1190):
+//
+// FIND THIS BLOCK:
+//     projectData.deployment_type = strategy.type;  // ← NEW: Send detected type!
+//     log.info(`MCP >>> [initProject] Sending deployment_type: ${strategy.type} to backend`);
+//
+// ADD AFTER IT:
+//     // Read docker-compose content if using docker-compose strategy
+//     if (strategy.type === 'docker-compose') {
+//       const composeContent = readDockerComposeContent(projectPath);
+//       if (composeContent) {
+//         projectData.docker_compose_content = composeContent;
+//         log.info(`MCP >>> [initProject] Sending docker-compose content: ${composeContent.length} bytes`);
+//       } else {
+//         log.warn('MCP >>> [initProject] docker-compose strategy but no compose file found!');
+//       }
+//     }
+
+// The complete section should look like:
+/*
+    // CRITICAL: Send deployment_type so backend doesn't try to detect from empty repo
+    log.info(`MCP >>> [initProject] Using strategy: ${JSON.stringify(strategy)}`);
+    projectData.deployment_type = strategy.type;  // ← NEW: Send detected type!
+
+    // Read docker-compose content if using docker-compose strategy (v3.2.1+)
+    if (strategy.type === 'docker-compose') {
+      const composeContent = readDockerComposeContent(projectPath);
+      if (composeContent) {
+        projectData.docker_compose_content = composeContent;
+        log.info(`MCP >>> [initProject] Sending docker-compose content: ${composeContent.length} bytes`);
+      } else {
+        log.warn('MCP >>> [initProject] docker-compose strategy but no compose file found!');
+      }
+    }
+
+    log.info(`MCP >>> [initProject] Sending deployment_type: ${strategy.type} to backend`);
+*/
+
+// Also add validation function:
+function validateDockerCompose(content) {
+  const issues = [];
+
+  try {
+    // Parse YAML to check structure
+    const lines = content.split('\n');
+
+    // Check for 'ports' vs 'expose'
+    const hasPortsMapping = content.includes('ports:');
+    const hasExposeOnly = content.includes('expose:') && !hasPortsMapping;
+
+    if (!hasPortsMapping) {
+      issues.push({
+        level: 'ERROR',
+        message: 'No service exposes ports for web traffic',
+        suggestion: 'At least one service must have "ports:" configuration for Coolify/Traefik routing'
+      });
+    }
+
+    if (hasExposeOnly) {
+      issues.push({
+        level: 'WARNING',
+        message: 'Service uses "expose" instead of "ports"',
+        suggestion: 'Change "expose" to "ports" for proper Traefik routing'
+      });
+    }
+
+    // Check for hardcoded passwords
+    const passwordPatterns = [
+      /password:\s*["'](?!.*\$\{).*["']/gi,
+      /PASSWORD=(?!.*\$\{)[^$\s]+/gi,
+      /secret:\s*["'](?!.*\$\{).*["']/gi
+    ];
+
+    for (const pattern of passwordPatterns) {
+      if (pattern.test(content)) {
+        issues.push({
+          level: 'WARNING',
+          message: 'Hardcoded password detected',
+          suggestion: 'Use environment variables: PASSWORD=${PASSWORD}'
+        });
+        break;
+      }
+    }
+
+    // Check for absolute volume paths
+    if (/volumes:\s*\n\s*-\s*\//m.test(content)) {
+      issues.push({
+        level: 'WARNING',
+        message: 'Absolute host path in volume mount',
+        suggestion: 'Use named volumes instead of absolute paths'
+      });
+    }
+
+  } catch (err) {
+    issues.push({
+      level: 'ERROR',
+      message: `Invalid docker-compose format: ${err.message}`,
+      suggestion: 'Fix YAML syntax errors'
+    });
+  }
+
+  return issues;
+}
+
+function validateDockerfile(projectPath) {
+  const fs = require('fs');
+  const path = require('path');
+  const dockerfilePath = path.join(projectPath, 'Dockerfile');
+
+  if (!fs.existsSync(dockerfilePath)) {
+    return [];
+  }
+
+  const issues = [];
+
+  try {
+    const content = fs.readFileSync(dockerfilePath, 'utf8');
+
+    // Check for EXPOSE directive
+    if (!content.includes('EXPOSE ')) {
+      issues.push({
+        level: 'WARNING',
+        message: 'Dockerfile has no EXPOSE directive',
+        suggestion: 'Add EXPOSE 80 or appropriate port'
+      });
+    }
+
+    // Check for USER directive (security)
+    if (!content.includes('USER ') || content.includes('USER root')) {
+      issues.push({
+        level: 'WARNING',
+        message: 'Dockerfile runs as root user',
+        suggestion: 'Add non-root USER for better security'
+      });
+    }
+
+    // Check for WORKDIR
+    if (!content.includes('WORKDIR ')) {
+      issues.push({
+        level: 'INFO',
+        message: 'No WORKDIR set in Dockerfile',
+        suggestion: 'Consider setting WORKDIR for organization'
+      });
+    }
+
+  } catch (err) {
+    // Ignore read errors
+  }
+
+  return issues;
+}
+
+// Export for testing
+if (typeof module !== 'undefined') {
+  module.exports = {
+    readDockerComposeContent,
+    validateDockerCompose,
+    validateDockerfile
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mlgym-deploy",
-  "version": "3.2.0",
-  "description": "MCP server for MLGym - Added deployment logs viewer tool",
+  "version": "3.2.3",
+  "description": "MCP server for MLGym - Auto-validates and fixes docker-compose/Dockerfile for Coolify",
   "main": "index.js",
   "type": "module",
   "bin": {