deepdebug-local-agent 1.0.19 → 1.0.21

package/src/exec-utils.js

@@ -1,10 +1,12 @@
 import { spawn } from "child_process";
 import stripAnsi from "strip-ansi";
 
-export function run(cmd, args, cwd, timeoutMs = 10 * 60 * 1000) {
+export function run(cmd, args, cwd, timeoutMs = 10 * 60 * 1000, env = null) {
     return new Promise((resolve) => {
         const start = Date.now();
-        const child = spawn(cmd, args, { cwd, shell: true });
+        const spawnOpts = { cwd, shell: true };
+        if (env) spawnOpts.env = env;
+        const child = spawn(cmd, args, spawnOpts);
         let stdout = "";
         let stderr = "";
         const timer = setTimeout(() => {
@@ -54,31 +56,117 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
 
     try {
         if (language === "java" && buildTool === "maven") {
-            // Prefer ./mvnw wrapper over system mvn
+            // Prefer system mvn (installed in Docker), fallback to ./mvnw
             const fs = await import("fs");
             const path = await import("path");
+            const checkMvn = await run("which", ["mvn"], cwd, 5000);
             const hasMvnw = fs.existsSync(path.join(cwd, "mvnw"));
-            const mvnCmd = hasMvnw ? "./mvnw" : "mvn";
-
-            // Verify build tool is available before attempting
-            if (!hasMvnw) {
-                const check = await run("which mvn", [], cwd);
-                if (check.code !== 0) {
-                    return {
-                        code: 1,
-                        stdout: "",
-                        stderr: "Maven not found: neither ./mvnw nor mvn is available in this environment.",
-                        duration: Date.now() - start
-                    };
+            let mvnCmd;
+            if (checkMvn.code === 0) {
+                mvnCmd = "mvn"; // system Maven (always works, no permission issues)
+            } else if (hasMvnw) {
+                // Fix permission on NFS-mounted mvnw
+                await run("chmod", ["+x", path.join(cwd, "mvnw")], cwd, 5000);
+                mvnCmd = "./mvnw";
+            } else {
+                return {
+                    code: 1,
+                    stdout: "",
+                    stderr: "Maven not found: neither mvn nor ./mvnw is available.",
+                    duration: Date.now() - start
+                };
+            }
+
+            // Fix for maven-compiler-plugin 3.8.1 + Java 17:
+            // plexus-compiler-javac 2.8.4 does not support --release 17.
+            // Workaround: disable the --release flag entirely and use -source/-target instead.
+            // Also pass JAVA_HOME explicitly so mvnw uses the correct JDK.
+            // Dynamically prepare Maven environment and fix common Java version issues
+            const fs2 = await import("fs");
+            const path2 = await import("path");
+
+            // 1. Detect Java version available
+            const javaHome = process.env.JAVA_HOME || "/usr/local/java-home";
+            const javacPath = `${javaHome}/bin/javac`;
+            const hasJavac = fs2.existsSync(javacPath);
+            const mavenEnv = {
+                ...process.env,
+                JAVA_HOME: javaHome,
+                PATH: `${javaHome}/bin:${process.env.PATH}`
+            };
+            console.log(`[BUILD] JAVA_HOME=${javaHome}, javac available=${hasJavac}`);
+
+            // 2. Detect Java version from javac
+            let javaVersion = 11; // default fallback
+            try {
+                const versionResult = await run(`${javaHome}/bin/java`, ["-version"], cwd, 5000, mavenEnv);
+                const versionOutput = versionResult.stdout + versionResult.stderr;
+                const match = versionOutput.match(/version "(\d+)/);
+                if (match) javaVersion = parseInt(match[1]);
+                console.log(`[BUILD] Detected Java version: ${javaVersion}`);
+            } catch {}
+
+            // 3. Patch pom.xml dynamically based on what's in it
+            const pomPath = path2.join(cwd, "pom.xml");
+            const javaCompatFlags = [];
+            if (fs2.existsSync(pomPath)) {
+                try {
+                    let pomContent = fs2.readFileSync(pomPath, "utf8");
+                    let patched = pomContent;
+
+                    // Detect configured java version in pom
+                    const javaVersionMatch = pomContent.match(/<java\.version>(\d+)<\/java\.version>/);
+                    const pomJavaVersion = javaVersionMatch ? parseInt(javaVersionMatch[1]) : javaVersion;
+                    console.log(`[BUILD] pom.xml java.version=${pomJavaVersion}`);
+
+                    // Detect maven-compiler-plugin version
+                    const compilerVersionMatch = pomContent.match(/<artifactId>maven-compiler-plugin<\/artifactId>\s*<version>([^<]+)<\/version>/);
+                    const compilerVersion = compilerVersionMatch ? compilerVersionMatch[1] : "unknown";
+                    console.log(`[BUILD] maven-compiler-plugin version=${compilerVersion}`);
+
+                    // If compiler plugin < 3.10 and java >= 17: upgrade to 3.11.0
+                    // (3.8.x uses plexus-compiler-javac 2.8.4 which doesn't support --release 17)
+                    const [compMajor, compMinor] = compilerVersion.split(".").map(Number);
+                    if (!isNaN(compMajor) && (compMajor < 3 || (compMajor === 3 && compMinor < 10)) && pomJavaVersion >= 17) {
+                        patched = patched.replace(
+                            new RegExp("(<artifactId>maven-compiler-plugin<\/artifactId>\\s*<version>)[^<]+(<\/version>)"),
+                            "$1" + "3.11.0" + "$2"
+                        );
+                        console.log(`[BUILD] Patched: maven-compiler-plugin ${compilerVersion} -> 3.11.0`);
+                    }
+
+                    // If pom uses <release> tag that might fail, replace with <source>/<target>
+                    if (pomContent.includes("<release>") && pomJavaVersion >= 17) {
+                        patched = patched.replace(
+                            /<release>\d+<\/release>/g,
+                            `<source>${pomJavaVersion}</source>
+					<target>${pomJavaVersion}</target>`
+                        );
+                        console.log(`[BUILD] Patched: replaced <release> with <source>/<target> for Java ${pomJavaVersion}`);
+                    }
+
+                    if (patched !== pomContent) {
+                        fs2.writeFileSync(pomPath, patched, "utf8");
+                        console.log("[BUILD] pom.xml patched successfully");
+                    } else {
+                        console.log("[BUILD] pom.xml no patches needed");
+                    }
+                } catch (patchErr) {
+                    console.warn("[BUILD] Could not patch pom.xml:", patchErr.message);
                 }
             }
 
+            // -e flag shows full error stack traces from Maven
             const args = skipTests
-                ? ["compile", "-q", "-DskipTests"]
-                : ["test", "-q"];
+                ? ["compile", "-DskipTests", "-e", ...javaCompatFlags]
+                : ["test", "-e", ...javaCompatFlags];
 
             console.log(`[BUILD] [COMPILE] Running: ${mvnCmd} ${args.join(" ")}`);
-            result = await run(mvnCmd, args, cwd);
+            result = await run(mvnCmd, args, cwd, 10 * 60 * 1000, mavenEnv);
+            if (result.code !== 0) {
+                console.error("[ERR] [COMPILE] stdout:", result.stdout.substring(0, 2000));
+                console.error("[ERR] [COMPILE] stderr:", result.stderr.substring(0, 2000));
+            }
         }
         else if (language === "java" && buildTool === "gradle") {
             // Gradle: clean build

package/src/runtimes/java/maven-runtime.js

@@ -121,9 +121,10 @@ export class MavenRuntime extends BaseRuntime {
 
     async build(workspacePath, options = {}) {
         const startTime = Date.now();
-        const skipTests = options.skipTests ? '-DskipTests' : '';
-        const args = ['compile', '-q'];
-        if (skipTests) args.push(skipTests);
+        const skipTests = options.skipTests !== false;
+        // No -q flag: compilation errors must be visible to the AI agent
+        const args = ['compile', '-e'];
+        if (skipTests) args.push('-DskipTests');
 
         const result = await run('mvn', args, workspacePath);