mlgym-deploy 3.3.16 → 3.3.24

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.16';  // Fix: Auth status check + expose instead of ports:80
+const CURRENT_VERSION = '3.3.23';  // Scala: flexible src structure, copy all .scala files
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -95,6 +95,12 @@ const CONFIG = {
 
 // Helper to load/save authentication
 async function loadAuth() {
+  // First check environment variable
+  if (process.env.MLGYM_TOKEN) {
+    return { token: process.env.MLGYM_TOKEN, email: process.env.MLGYM_EMAIL || 'env-token-user' };
+  }
+
+  // Fall back to config file
   try {
     const data = await fs.readFile(CONFIG.config_file, 'utf8');
     return JSON.parse(data);
@@ -216,7 +222,14 @@ Host git.mlgym.io
 
   try {
     const existingConfig = await fs.readFile(configPath, 'utf8');
-    if (!existingConfig.includes('Host git.mlgym.io')) {
+    if (existingConfig.includes('Host git.mlgym.io')) {
+      // Replace existing MLGym SSH config block with new key
+      const updatedConfig = existingConfig.replace(
+        /# MLGym GitLab.*?Host git\.mlgym\.io.*?(?=\n#|\n\nHost|\n?$)/gs,
+        ''
+      ).trim();
+      await fs.writeFile(configPath, updatedConfig + configEntry, { mode: 0o600 });
+    } else {
       await fs.appendFile(configPath, configEntry);
     }
   } catch {
@@ -558,6 +571,27 @@ async function analyzeProject(local_path = '.') {
       } catch {}
     }
 
+    // Check for Scala/sbt project
+    if (analysis.project_type === 'unknown') {
+      try {
+        await fs.access(path.join(absolutePath, 'build.sbt'));
+        analysis.project_type = 'scala';
+        analysis.detected_files.push('build.sbt');
+        analysis.framework = 'sbt';
+        analysis.build_command = 'sbt assembly';
+        analysis.start_command = 'java -jar app.jar';
+
+        // Check if sbt-assembly plugin exists
+        try {
+          await fs.access(path.join(absolutePath, 'project', 'plugins.sbt'));
+          analysis.detected_files.push('project/plugins.sbt');
+          analysis.has_sbt_assembly = true;
+        } catch {
+          analysis.has_sbt_assembly = false;
+        }
+      } catch {}
+    }
+
   } catch (error) {
     console.error('Project analysis error:', error);
   }
@@ -710,6 +744,21 @@ WORKDIR /root/
 COPY --from=builder /app/app .
 EXPOSE 8080
 CMD ["./app"]`;
+  } else if (projectType === 'scala') {
+    dockerfile = `# Build stage
+FROM sbtscala/scala-sbt:eclipse-temurin-jammy-17.0.10_7_1.10.2_2.13.15 AS builder
+WORKDIR /app
+COPY project ./project
+COPY build.sbt .
+COPY src ./src
+RUN sbt assembly
+
+# Production stage
+FROM eclipse-temurin:17-jre-jammy
+WORKDIR /app
+COPY --from=builder /app/target/scala-2.13/app.jar ./app.jar
+EXPOSE 8080
+CMD ["java", "-jar", "app.jar"]`;
   } else {
     // Unknown type - basic Alpine with shell
     dockerfile = `FROM alpine:latest
@@ -760,6 +809,90 @@ async function prepareProject(args) {
       log.warning('MCP >>> [prepareProject-func] Project type is unknown, skipping Dockerfile generation');
     }
 
+    // Scala/sbt: Check for sbt-assembly plugin (required for fat JAR)
+    if (project_type === 'scala') {
+      const projectDir = path.join(absolutePath, 'project');
+      const pluginsSbtPath = path.join(projectDir, 'plugins.sbt');
+      let hasAssemblyPlugin = false;
+
+      try {
+        const pluginsContent = await fs.readFile(pluginsSbtPath, 'utf8');
+        hasAssemblyPlugin = pluginsContent.includes('sbt-assembly');
+      } catch {
+        // plugins.sbt doesn't exist
+      }
+
+      if (!hasAssemblyPlugin) {
+        log.info('MCP >>> [prepareProject-func] Scala project missing sbt-assembly plugin, adding...');
+
+        // Create project directory if it doesn't exist
+        try {
+          await fs.mkdir(projectDir, { recursive: true });
+        } catch {}
+
+        // Create plugins.sbt with sbt-assembly
+        const pluginsContent = 'addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.5")\n';
+        await fs.writeFile(pluginsSbtPath, pluginsContent);
+        actions.push('Created project/plugins.sbt with sbt-assembly plugin');
+        log.success('MCP >>> [prepareProject-func] ✅ Added sbt-assembly plugin');
+
+        // Also update build.sbt to add assembly merge strategy if not present
+        const buildSbtPath = path.join(absolutePath, 'build.sbt');
+        try {
+          let buildSbtContent = await fs.readFile(buildSbtPath, 'utf8');
+          if (!buildSbtContent.includes('assemblyMergeStrategy')) {
+            const assemblyConfig = `
+
+assembly / assemblyMergeStrategy := {
+  case PathList("META-INF", xs @ _*) => MergeStrategy.discard
+  case "reference.conf" => MergeStrategy.concat
+  case x => MergeStrategy.first
+}
+
+assembly / assemblyJarName := "app.jar"
+`;
+            buildSbtContent += assemblyConfig;
+            await fs.writeFile(buildSbtPath, buildSbtContent);
+            actions.push('Added assembly merge strategy to build.sbt');
+            log.success('MCP >>> [prepareProject-func] ✅ Added assembly config to build.sbt');
+          }
+        } catch (err) {
+          log.warning('MCP >>> [prepareProject-func] Could not update build.sbt:', err.message);
+        }
+      }
+
+      // Ensure proper Scala project structure - move root .scala files to src/main/scala/
+      try {
+        const srcDir = path.join(absolutePath, 'src', 'main', 'scala');
+        const rootFiles = await fs.readdir(absolutePath);
+        const scalaFilesInRoot = rootFiles.filter(f => f.endsWith('.scala'));
+
+        if (scalaFilesInRoot.length > 0) {
+          // Check if src/main/scala exists
+          let srcExists = false;
+          try {
+            await fs.access(srcDir);
+            srcExists = true;
+          } catch {}
+
+          if (!srcExists) {
+            // Create src/main/scala and move .scala files there
+            await fs.mkdir(srcDir, { recursive: true });
+            for (const scalaFile of scalaFilesInRoot) {
+              const srcPath = path.join(absolutePath, scalaFile);
+              const destPath = path.join(srcDir, scalaFile);
+              await fs.rename(srcPath, destPath);
+              log.info(`MCP >>> [prepareProject-func] Moved ${scalaFile} to src/main/scala/`);
+            }
+            actions.push(`Moved ${scalaFilesInRoot.length} .scala files to src/main/scala/`);
+            log.success('MCP >>> [prepareProject-func] ✅ Created proper Scala project structure');
+          }
+        }
+      } catch (err) {
+        log.warning('MCP >>> [prepareProject-func] Could not reorganize Scala files:', err.message);
+      }
+    }
+
     // Check/create .gitignore
     const gitignorePath = path.join(absolutePath, '.gitignore');
     let gitignoreExists = false;
@@ -788,6 +921,14 @@ build/
 venv/
 env/
 .venv/`;
+      } else if (project_type === 'scala') {
+        gitignoreContent = `target/
+project/target/
+.bsp/
+.idea/
+*.class
+*.log
+.env`;
       } else {
         gitignoreContent = `.env
 *.log
@@ -985,6 +1126,30 @@ async function smartDeploy(args) {
 }
 
 // Deployment Strategy Detection (matches CLI logic)
+// Extract EXPOSE port from Dockerfile
+async function extractDockerfilePort(dockerfilePath) {
+  try {
+    const content = await fs.readFile(dockerfilePath, 'utf8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('EXPOSE ')) {
+        const portMatch = trimmed.match(/EXPOSE\s+(\d+)/);
+        if (portMatch) {
+          const port = portMatch[1];
+          log.info(`MCP >>> [extractDockerfilePort] Found EXPOSE ${port}`);
+          return port;
+        }
+      }
+    }
+    log.info('MCP >>> [extractDockerfilePort] No EXPOSE directive found, defaulting to 3000');
+    return '3000'; // Default if no EXPOSE found
+  } catch (err) {
+    log.error('MCP >>> [extractDockerfilePort] Error reading Dockerfile:', err.message);
+    return '3000';
+  }
+}
+
 async function detectDeploymentStrategy(projectPath) {
   const dockerfilePath = path.join(projectPath, 'Dockerfile');
   const composePathYML = path.join(projectPath, 'docker-compose.yml');
@@ -1000,8 +1165,9 @@ async function detectDeploymentStrategy(projectPath) {
 
   // Case 1: Only Dockerfile
   if (hasDockerfile && !hasCompose) {
-    log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (Dockerfile only)');
-    return { type: 'dockerfile', reason: 'Dockerfile only' };
+    const port = await extractDockerfilePort(dockerfilePath);
+    log.info(`MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (Dockerfile only), port: ${port}`);
+    return { type: 'dockerfile', reason: 'Dockerfile only', port };
   }
 
   // Case 2: Only docker-compose
@@ -1022,8 +1188,9 @@ async function detectDeploymentStrategy(projectPath) {
       // SIMPLE: Only 1 web service, no other services, uses local Dockerfile
       // → docker-compose is just convenience wrapper
       if (totalServiceCount === 1 && webServiceCount === 1 && usesLocalDockerfile) {
-        log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (single web service)');
-        return { type: 'dockerfile', reason: 'docker-compose.yml only has web service (convenience wrapper for Dockerfile)' };
+        const port = await extractDockerfilePort(dockerfilePath);
+        log.info(`MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (single web service), port: ${port}`);
+        return { type: 'dockerfile', reason: 'docker-compose.yml only has web service (convenience wrapper for Dockerfile)', port };
       }
 
       // COMPLEX: Multiple services (web + database, etc.)
@@ -1165,32 +1332,150 @@ function randomizeVolumeNames(content, suffix) {
 function validateDockerfile(content) {
   const lines = content.split('\n');
   const issues = [];
-  let hasExpose80 = false;
+  let hasExpose = false;
+  let exposedPort = null;
+  let baseImage = null;
+  let usesCpanm = false;
+  let installsCpanm = false;
+
+  // Elixir multi-stage detection
+  let isElixirMultiStage = false;
+  let hasMixLockCopy = false;
+  let builderStageHasMixDepsGet = false;
 
   for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim().toUpperCase();
+    const trimmed = lines[i].trim();
+    const upper = trimmed.toUpperCase();
+
+    // Track base image
+    if (upper.startsWith('FROM ')) {
+      baseImage = trimmed.substring(5).split(' ')[0].toLowerCase();
+      // Check for Elixir multi-stage build
+      if (baseImage.includes('elixir') && upper.includes(' AS ')) {
+        isElixirMultiStage = true;
+      }
+    }
 
-    if (trimmed.startsWith('EXPOSE')) {
-      // Check if it exposes port 80
-      if (trimmed.includes('80') && !trimmed.includes('8080') && !trimmed.includes('8443')) {
-        hasExpose80 = true;
+    if (upper.startsWith('EXPOSE')) {
+      hasExpose = true;
+      // Extract the port number
+      const portMatch = trimmed.match(/EXPOSE\s+(\d+)/i);
+      if (portMatch) {
+        exposedPort = portMatch[1];
       }
     }
+
+    // Check for cpanm usage and installation
+    if (trimmed.includes('cpanm ') && !trimmed.includes('App::cpanminus')) {
+      usesCpanm = true;
+    }
+    if (trimmed.includes('App::cpanminus')) {
+      installsCpanm = true;
+    }
+
+    // Elixir-specific checks
+    if (trimmed.includes('mix deps.get')) {
+      builderStageHasMixDepsGet = true;
+    }
+    if (upper.includes('COPY') && trimmed.includes('mix.lock')) {
+      hasMixLockCopy = true;
+    }
+  }
+
+  if (!hasExpose) {
+    issues.push({
+      issue: 'Dockerfile does not have an EXPOSE directive',
+      fix: 'Add "EXPOSE <port>" to your Dockerfile (e.g., EXPOSE 80 for web servers, EXPOSE 3000 for Node.js)',
+      autofix: 'add_expose'
+    });
+  }
+
+  // Perl-specific: cpanm needs to be installed on slim images
+  if (baseImage && baseImage.includes('perl') && baseImage.includes('slim') && usesCpanm && !installsCpanm) {
+    issues.push({
+      issue: 'Dockerfile uses cpanm but perl:*-slim does not have it pre-installed',
+      fix: 'Add "RUN cpan -T App::cpanminus" before using cpanm, and install build deps: "RUN apt-get update && apt-get install -y --no-install-recommends make gcc && rm -rf /var/lib/apt/lists/*"',
+      autofix: 'perl_cpanm'
+    });
   }
 
-  if (!hasExpose80) {
+  // Elixir-specific: multi-stage builds must copy mix.lock from builder
+  if (isElixirMultiStage && builderStageHasMixDepsGet && !hasMixLockCopy) {
     issues.push({
-      issue: 'Dockerfile does not EXPOSE port 80',
-      fix: 'Add "EXPOSE 80" to your Dockerfile'
+      issue: 'Elixir multi-stage Dockerfile missing mix.lock copy from builder stage',
+      fix: 'Add "COPY --from=builder /app/mix.lock /app/mix.lock" to copy the generated mix.lock file',
+      autofix: 'elixir_mix_lock'
     });
   }
 
   return {
     isValid: issues.length === 0,
-    issues
+    issues,
+    exposedPort,
+    baseImage
   };
 }
 
+// Auto-fix known Dockerfile issues
+function autoFixDockerfile(content, issues) {
+  let lines = content.split('\n');
+  let modified = false;
+
+  for (const issue of issues) {
+    if (issue.autofix === 'perl_cpanm') {
+      // Find the line that uses cpanm and insert the fix before it
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim().toUpperCase();
+        if (trimmed.startsWith('RUN') && lines[i].includes('cpanm ') && !lines[i].includes('App::cpanminus')) {
+          // Insert build dependencies and cpanm installation before this line
+          const indent = lines[i].match(/^(\s*)/)[1];
+          lines.splice(i, 0,
+            `${indent}RUN apt-get update && apt-get install -y --no-install-recommends make gcc && rm -rf /var/lib/apt/lists/*`,
+            `${indent}RUN cpan -T App::cpanminus`
+          );
+          modified = true;
+          log.success('MCP >>> Auto-fixed Perl Dockerfile: added cpanm installation');
+          break;
+        }
+      }
+    }
+
+    if (issue.autofix === 'add_expose') {
+      // Find the last FROM or WORKDIR line to add EXPOSE after it
+      const hasAnyExpose = /^\s*EXPOSE\s+\d+/mi.test(content);
+      if (!hasAnyExpose) {
+        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');
+        modified = true;
+        log.success('MCP >>> Auto-fixed Dockerfile: added EXPOSE 80');
+      }
+    }
+
+    if (issue.autofix === 'elixir_mix_lock') {
+      // Find the last COPY --from=builder line and add mix.lock copy after it
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const trimmed = lines[i].trim();
+        if (trimmed.includes('COPY --from=builder') && trimmed.includes('mix.exs')) {
+          // Insert mix.lock copy right after mix.exs copy
+          const indent = lines[i].match(/^(\s*)/)[1];
+          lines.splice(i + 1, 0, `${indent}COPY --from=builder /app/mix.lock /app/mix.lock`);
+          modified = true;
+          log.success('MCP >>> Auto-fixed Elixir Dockerfile: added mix.lock copy from builder');
+          break;
+        }
+      }
+    }
+  }
+
+  return { content: lines.join('\n'), modified };
+}
+
 // Analyze docker-compose.yml to determine deployment strategy
 async function analyzeComposeFile(composePath) {
   const content = await fs.readFile(composePath, 'utf-8');
@@ -1357,6 +1642,12 @@ async function initProject(args) {
     projectData.hostname = hostname;
     projectData.local_path = local_path;
 
+    // Send ports_exposes for Dockerfile deployments (v3.3.17+)
+    if (strategy.port) {
+      projectData.ports_exposes = strategy.port;
+      log.info(`MCP >>> [initProject] Sending ports_exposes: ${strategy.port} to backend`);
+    }
+
     // Read docker-compose content if using dockercompose strategy (v3.2.1+)
     if (strategy.type === 'dockercompose') {
       const composeFiles = ['docker-compose.yml', 'docker-compose.yaml'];
@@ -2208,28 +2499,13 @@ async function deployProject(args) {
             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
+          // Use autoFixDockerfile to apply all fixes
+          const fixResult = autoFixDockerfile(content, validation.issues);
+          if (fixResult.modified) {
+            // Create backup and save fixed content
             fsSync.writeFileSync(dockerfilePath + '.backup', content);
-            fsSync.writeFileSync(dockerfilePath, fixedContent);
-
-            log.success('MCP >>> Fixed Dockerfile: added EXPOSE 80');
+            fsSync.writeFileSync(dockerfilePath, fixResult.content);
+            log.success('MCP >>> Dockerfile auto-fixes applied');
           }
         } else {
           log.success('MCP >>> Dockerfile is Coolify compliant');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlgym-deploy",
-  "version": "3.3.16",
+  "version": "3.3.24",
   "description": "MCP server for MLGym - Complete deployment management: deploy, configure, monitor, and rollback applications",
   "main": "index.js",
   "type": "module",