deepdebug-local-agent 1.0.18 → 1.0.20

package/Dockerfile

@@ -2,7 +2,7 @@
 # ║          DeepDebug Local Agent - Enterprise Docker           ║
 # ║                                                              ║
 # ║  Security-hardened container for enterprise deployments      ║
-# ║  Supports: Kubernetes, OpenShift, Docker Compose             ║
+# ║  Supports: Cloud Run with NFS (GCP Filestore)                ║
 # ╚══════════════════════════════════════════════════════════════╝
 
 # ===========================================
@@ -12,14 +12,9 @@ FROM node:20-alpine AS builder
 
 WORKDIR /build
 
-# Copy package files first (better cache)
 COPY package*.json ./
-
-# Install dependencies (production only)
-# Using npm install instead of npm ci for repos without package-lock.json
 RUN npm install --omit=dev && npm cache clean --force
 
-# Copy source code
 COPY src/ ./src/
 
 # ===========================================
@@ -27,48 +22,69 @@ COPY src/ ./src/
 # ===========================================
 FROM node:20-alpine AS production
 
-# Security: Add labels for compliance
 LABEL org.opencontainers.image.title="DeepDebug Local Agent"
 LABEL org.opencontainers.image.description="Enterprise debugging agent for code analysis"
 LABEL org.opencontainers.image.vendor="InspTech AI"
-LABEL org.opencontainers.image.version="1.0.0"
+LABEL org.opencontainers.image.version="1.2.0"
 LABEL org.opencontainers.image.licenses="Proprietary"
 LABEL security.scan.required="true"
 
-# Security: Create non-root user
+# Create non-root user
 RUN addgroup -g 1001 -S deepdebug && \
     adduser -u 1001 -S deepdebug -G deepdebug
 
-# Security: Install security updates
+# Install dependencies including Java 17 for Maven wrapper support
 RUN apk update && \
     apk upgrade --no-cache && \
     apk add --no-cache \
         dumb-init \
         git \
         curl \
+        nfs-utils \
+        openjdk17-jdk \
     && rm -rf /var/cache/apk/*
 
+# Set JAVA_HOME so ./mvnw can find Java
+# Alpine stores JVM under java-17-openjdk with arch suffix - use readlink to resolve
+RUN ln -sf $(dirname $(dirname $(readlink -f $(which java)))) /usr/local/java-home
+ENV JAVA_HOME=/usr/local/java-home
+ENV PATH="$JAVA_HOME/bin:$PATH"
+
+# Create NFS mount point with correct ownership
+RUN mkdir -p /mnt/workspaces && \
+    chown deepdebug:deepdebug /mnt/workspaces
+
+# Install cloudflared for tunnel support (Vibe preview)
+RUN wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 \
+    -O /usr/local/bin/cloudflared && \
+    chmod +x /usr/local/bin/cloudflared && \
+    cloudflared --version
+
+# Install GitHub CLI (gh) for PR creation
+RUN wget -q https://github.com/cli/cli/releases/download/v2.63.2/gh_2.63.2_linux_amd64.tar.gz \
+    -O /tmp/gh.tar.gz && \
+    tar -xzf /tmp/gh.tar.gz -C /tmp && \
+    mv /tmp/gh_2.63.2_linux_amd64/bin/gh /usr/local/bin/gh && \
+    chmod +x /usr/local/bin/gh && \
+    rm -rf /tmp/gh* && \
+    gh --version
+
 WORKDIR /app
 
-# Copy from builder with correct ownership
 COPY --from=builder --chown=deepdebug:deepdebug /build/node_modules ./node_modules
 COPY --from=builder --chown=deepdebug:deepdebug /build/src ./src
 COPY --chown=deepdebug:deepdebug package*.json ./
 
-# Security: Switch to non-root user
 USER deepdebug
 
-# Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:5055/health || exit 1
 
-# Environment
 ENV NODE_ENV=production
 ENV PORT=5055
+ENV WORKSPACES_MOUNT=/mnt/workspaces
 
-# Expose port
 EXPOSE 5055
 
-# Security: Use dumb-init to handle signals properly
 ENTRYPOINT ["dumb-init", "--"]
 CMD ["node", "src/server.js"]

package/cloudbuild-agent-qa.yaml

@@ -0,0 +1,43 @@
+steps:
+  # Step 1: Build Docker image
+  - name: 'gcr.io/cloud-builders/docker'
+    args:
+      - 'build'
+      - '--platform=linux/amd64'
+      - '-t'
+      - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+      - '.'
+    timeout: '600s'
+
+  # Step 2: Push to Artifact Registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args:
+      - 'push'
+      - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+
+  # Step 3: Deploy to Cloud Run QA
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: 'gcloud'
+    args:
+      - 'run'
+      - 'deploy'
+      - 'deepdebug-local-agent-qa'
+      - '--image=us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+      - '--region=us-central1'
+      - '--platform=managed'
+      - '--allow-unauthenticated'
+      - '--memory=1Gi'
+      - '--cpu=1'
+      - '--min-instances=1'
+      - '--max-instances=3'
+      - '--port=5055'
+      - '--timeout=300'
+      - '--update-env-vars=NODE_ENV=qa'
+
+images:
+  - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+
+options:
+  logging: CLOUD_LOGGING_ONLY
+
+timeout: '1200s'

package/docker-compose.yml

@@ -52,8 +52,8 @@ services:
     # Volumes
     # ─────────────────────────────────────────
     volumes:
-      # Project source code (read-only for security)
-      - ${PROJECT_PATH:-/path/to/projects}:/workspace:ro
+      # Project source code - writable so agent can apply patches
+      - /Users/macintosh/IdeaProjects:/workspace
       # Temp directory for container writes
       - agent-tmp:/tmp
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",

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(() => {
@@ -47,20 +49,121 @@ export function run(cmd, args, cwd, timeoutMs = 10 * 60 * 1000) {
  * @returns {Promise<{code: number, stdout: string, stderr: string, duration: number}>}
  */
 export async function compileAndTest({ language, buildTool, cwd, skipTests = false }) {
-    console.log(`🔨 [COMPILE] Language: ${language}, BuildTool: ${buildTool}, SkipTests: ${skipTests}`);
+    console.log(`[BUILD] [COMPILE] Language: ${language}, BuildTool: ${buildTool}, SkipTests: ${skipTests}`);
 
     let result;
     const start = Date.now();
 
     try {
         if (language === "java" && buildTool === "maven") {
-            // Maven: clean install (skip tests if requested)
+            // Prefer ./mvnw wrapper over system mvn
+            const fs = await import("fs");
+            const path = await import("path");
+            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
+                    };
+                }
+            }
+
+            // 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);
+                }
+            }
+
             const args = skipTests
-                ? ["clean", "install", "-DskipTests", "-q"]
-                : ["clean", "install", "-q"];
+                ? ["compile", "-DskipTests", ...javaCompatFlags]
+                : ["test", ...javaCompatFlags];
 
-            console.log(`🔨 [COMPILE] Running: mvn ${args.join(" ")}`);
-            result = await run("mvn", args, cwd);
+            console.log(`[BUILD] [COMPILE] Running: ${mvnCmd} ${args.join(" ")}`);
+            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
@@ -68,12 +171,12 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
                 ? ["clean", "build", "-x", "test"]
                 : ["clean", "build"];
 
-            console.log(`🔨 [COMPILE] Running: ./gradlew ${args.join(" ")}`);
+            console.log(`[BUILD] [COMPILE] Running: ./gradlew ${args.join(" ")}`);
             result = await run("./gradlew", args, cwd);
         }
         else if (language === "node" || buildTool === "npm") {
             // Node/npm: install and optionally test
-            console.log(`🔨 [COMPILE] Running: npm install`);
+            console.log(`[BUILD] [COMPILE] Running: npm install`);
             const installResult = await run("npm", ["install", "--silent"], cwd);
 
             if (installResult.code !== 0) {
@@ -81,7 +184,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: npm test`);
+                console.log(`[BUILD] [COMPILE] Running: npm test`);
                 result = await run("npm", ["test", "--silent"], cwd);
             } else {
                 result = installResult;
@@ -89,7 +192,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === "node" || buildTool === "yarn") {
             // Yarn
-            console.log(`🔨 [COMPILE] Running: yarn install`);
+            console.log(`[BUILD] [COMPILE] Running: yarn install`);
             const installResult = await run("yarn", ["install", "--silent"], cwd);
 
             if (installResult.code !== 0) {
@@ -97,7 +200,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: yarn test`);
+                console.log(`[BUILD] [COMPILE] Running: yarn test`);
                 result = await run("yarn", ["test", "--silent"], cwd);
             } else {
                 result = installResult;
@@ -106,7 +209,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         else if (language === "python") {
             // Python: pytest
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: pytest`);
+                console.log(`[BUILD] [COMPILE] Running: pytest`);
                 result = await run("pytest", [], cwd);
             } else {
                 // Python doesn't have a compile step, just return success
@@ -115,7 +218,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === "go") {
             // Go: build and optionally test
-            console.log(`🔨 [COMPILE] Running: go build ./...`);
+            console.log(`[BUILD] [COMPILE] Running: go build ./...`);
             const buildResult = await run("go", ["build", "./..."], cwd);
 
             if (buildResult.code !== 0) {
@@ -123,7 +226,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: go test ./...`);
+                console.log(`[BUILD] [COMPILE] Running: go test ./...`);
                 result = await run("go", ["test", "./..."], cwd);
             } else {
                 result = buildResult;
@@ -131,7 +234,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === ".net" || language === "dotnet") {
             // .NET: build and optionally test
-            console.log(`🔨 [COMPILE] Running: dotnet build`);
+            console.log(`[BUILD] [COMPILE] Running: dotnet build`);
             const buildResult = await run("dotnet", ["build"], cwd);
 
             if (buildResult.code !== 0) {
@@ -139,14 +242,14 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: dotnet test`);
+                console.log(`[BUILD] [COMPILE] Running: dotnet test`);
                 result = await run("dotnet", ["test"], cwd);
             } else {
                 result = buildResult;
             }
         }
         else {
-            console.error(`❌ [COMPILE] Unsupported: ${language}/${buildTool}`);
+            console.error(`[ERR] [COMPILE] Unsupported: ${language}/${buildTool}`);
             return {
                 code: 1,
                 stdout: "",
@@ -157,18 +260,18 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
 
         // Log result
         if (result.code === 0) {
-            console.log(`✅ [COMPILE] Success in ${result.duration}ms`);
+            console.log(`[OK] [COMPILE] Success in ${result.duration}ms`);
         } else {
-            console.error(`❌ [COMPILE] Failed with code ${result.code}`);
+            console.error(`[ERR] [COMPILE] Failed with code ${result.code}`);
             if (result.stderr) {
-                console.error(`❌ [COMPILE] Error: ${result.stderr.substring(0, 500)}`);
+                console.error(`[ERR] [COMPILE] Error: ${result.stderr.substring(0, 500)}`);
             }
         }
 
         return result;
 
     } catch (err) {
-        console.error(`❌ [COMPILE] Exception: ${err.message}`);
+        console.error(`[ERR] [COMPILE] Exception: ${err.message}`);
         return {
             code: 1,
             stdout: "",