mlgym-deploy 3.3.19 → 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.17';  // Fix: Extract EXPOSE port from Dockerfile and send to backend
+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
@@ -222,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 {
@@ -564,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);
   }
@@ -716,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
@@ -766,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;
@@ -794,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
@@ -1199,11 +1334,28 @@ function validateDockerfile(content) {
   const issues = [];
   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();
     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 (upper.startsWith('EXPOSE')) {
       hasExpose = true;
       // Extract the port number
@@ -1212,22 +1364,118 @@ function validateDockerfile(content) {
         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)'
+      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'
+    });
+  }
+
+  // Elixir-specific: multi-stage builds must copy mix.lock from builder
+  if (isElixirMultiStage && builderStageHasMixDepsGet && !hasMixLockCopy) {
+    issues.push({
+      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,
-    exposedPort
+    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');
@@ -2251,32 +2499,13 @@ async function deployProject(args) {
             log.info(`    Fix: ${issue.fix}`);
           });
 
-          // Only add EXPOSE if there's truly no EXPOSE directive at all
-          // Don't override an existing EXPOSE with a different port
-          const hasAnyExpose = /^\s*EXPOSE\s+\d+/mi.test(content);
-          if (!hasAnyExpose) {
-            log.info('MCP >>> Auto-fixing Dockerfile: adding EXPOSE 80 (no existing EXPOSE found)...');
-            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');
-          } else {
-            log.info('MCP >>> Dockerfile already has EXPOSE directive, skipping auto-fix');
+            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.19",
+  "version": "3.3.24",
   "description": "MCP server for MLGym - Complete deployment management: deploy, configure, monitor, and rollback applications",
   "main": "index.js",
   "type": "module",