deepdebug-local-agent 0.3.1

package/src/workspace/process-manager.js

@@ -0,0 +1,619 @@
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import stripAnsi from "strip-ansi";
+import fs from "fs";
+import path from "path";
+
+/**
+ * ProcessManager
+ *
+ * Gerencia ciclo de vida de processos (start, stop, restart)
+ * Monitora CPU, Memory, Uptime
+ * Captura logs em tempo real
+ *
+ * UNIFIED VERSION: Aceita AMBOS os formatos:
+ * 1. command/args direto (novo)
+ * 2. language/framework/buildTool (legado)
+ */
+export class ProcessManager extends EventEmitter {
+    constructor() {
+        super();
+        this.processes = new Map(); // serviceId -> { process, startTime, logs, stats }
+    }
+
+    /**
+     * Verifica se um serviço está rodando
+     */
+    isRunning(serviceId) {
+        const processData = this.processes.get(serviceId);
+        return processData && processData.process && !processData.process.killed;
+    }
+
+    /**
+     * Inicia um serviço
+     *
+     * ACEITA DOIS FORMATOS:
+     * 1. { command, args, cwd, port, env } - Novo formato direto
+     * 2. { language, framework, buildTool, cwd, port, profile } - Formato legado
+     */
+    async start(serviceId, config) {
+        const {
+            // Novo formato
+            command,
+            args,
+            // Formato legado
+            language,
+            framework,
+            buildTool,
+            // Comum
+            cwd,
+            port,
+            profile,
+            env,
+            envVars = {}
+        } = config;
+
+        // Se já estiver rodando, parar primeiro
+        if (this.processes.has(serviceId)) {
+            console.log(`⚠️ Service ${serviceId} already running, stopping first...`);
+            await this.stop(serviceId);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        // Determinar comando a usar
+        let cmd, cmdArgs;
+
+        if (command && args) {
+            // NOVO FORMATO: command/args passados diretamente
+            cmd = command;
+            cmdArgs = args;
+            console.log(`🚀 Starting ${serviceId} (direct): ${cmd} ${cmdArgs.join(' ')}`);
+        } else if (language) {
+            // FORMATO LEGADO: derivar de language/framework/buildTool
+            const startCommand = await this.getStartCommand(language, framework, buildTool, cwd, profile || 'dev');
+            cmd = startCommand.cmd;
+            cmdArgs = startCommand.args;
+            console.log(`🚀 Starting ${serviceId} (derived): ${cmd} ${cmdArgs.join(' ')}`);
+        } else {
+            throw new Error(`Either 'command/args' or 'language' must be provided to start ${serviceId}`);
+        }
+
+        console.log(`⚙️ Config: port=${port}, profile=${profile || 'none'}`);
+        console.log(`📁 Working directory: ${cwd}`);
+
+        // ============================================
+        // BUILD ENVIRONMENT
+        // ============================================
+        // Two strategies:
+        //   DIRECT MODE (command/args provided): env is used AS-IS if provided.
+        //     The caller (test-local/start) already builds a clean env without
+        //     SPRING_* variables so the app uses only application.yml defaults.
+        //   LEGACY MODE (language/framework): merge process.env with overrides.
+        // ============================================
+        let processEnv;
+
+        if (command && args && env) {
+            // ✅ DIRECT MODE: Use the caller's env as the base (it's already clean)
+            processEnv = {
+                ...env,
+                ...envVars
+            };
+            // Only set port vars if not already present
+            if (!processEnv.SERVER_PORT) processEnv.SERVER_PORT = String(port || 8080);
+            if (!processEnv.PORT) processEnv.PORT = String(port || 8080);
+            // DO NOT set SPRING_PROFILES_ACTIVE — let application.yml decide
+            console.log(`   📦 Using caller-provided env (clean, ${Object.keys(processEnv).length} vars)`);
+        } else {
+            // 🔄 LEGACY MODE: Merge with process.env and apply profile
+            processEnv = {
+                ...process.env,
+                ...(env || {}),
+                ...envVars,
+                SERVER_PORT: String(port || 8080),
+                PORT: String(port || 8080),
+                NODE_ENV: profile === 'prod' ? 'production' : 'development',
+                FLASK_ENV: profile === 'prod' ? 'production' : 'development',
+            };
+            // Only set profile if explicitly provided
+            if (profile) {
+                processEnv.SPRING_PROFILES_ACTIVE = profile;
+            }
+            console.log(`   📦 Using merged env (legacy, profile=${profile || 'default'})`);
+        }
+
+        const child = spawn(cmd, cmdArgs, {
+            cwd,
+            shell: true,
+            env: processEnv,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        if (!child.pid) {
+            throw new Error(`Failed to spawn process for ${serviceId}`);
+        }
+
+        console.log(`✅ Process spawned with PID: ${child.pid}`);
+
+        const processData = {
+            process: child,
+            pid: child.pid,
+            command: cmd,
+            args: cmdArgs,
+            cwd,
+            startTime: Date.now(),
+            logs: [],
+            port,
+            status: "starting",
+            cpu: 0,
+            memory: 0
+        };
+
+        this.processes.set(serviceId, processData);
+
+        // Capturar stdout
+        child.stdout.on("data", (data) => {
+            const text = data.toString();
+            const lines = text.split('\n').filter(l => l.trim());
+
+            for (const line of lines) {
+                const log = stripAnsi(line).trim();
+                if (!log) continue;
+
+                processData.logs.push({
+                    timestamp: Date.now(),
+                    type: "stdout",
+                    message: log
+                });
+
+                this.emit("log", { serviceId, message: log, type: "stdout" });
+
+                // Detectar quando serviço está pronto
+                if (this.isServiceReady(log, language || 'java')) {
+                    if (processData.status !== "running") {
+                        processData.status = "running";
+                        console.log(`✅ Service ${serviceId} is READY!`);
+                        this.emit("started", { serviceId, port });
+                    }
+                }
+            }
+        });
+
+        // Capturar stderr (Spring Boot também loga aqui)
+        child.stderr.on("data", (data) => {
+            const text = data.toString();
+            const lines = text.split('\n').filter(l => l.trim());
+
+            for (const line of lines) {
+                const log = stripAnsi(line).trim();
+                if (!log) continue;
+
+                processData.logs.push({
+                    timestamp: Date.now(),
+                    type: "stderr",
+                    message: log
+                });
+
+                this.emit("log", { serviceId, message: log, type: "stderr" });
+
+                // Spring Boot pode logar "Started" no stderr também
+                if (this.isServiceReady(log, language || 'java')) {
+                    if (processData.status !== "running") {
+                        processData.status = "running";
+                        console.log(`✅ Service ${serviceId} is READY!`);
+                        this.emit("started", { serviceId, port });
+                    }
+                }
+            }
+        });
+
+        // Capturar erro de inicialização
+        child.on("error", (err) => {
+            console.error(`❌ Failed to start ${serviceId}:`, err.message);
+            processData.status = "failed";
+            this.emit("error", { serviceId, error: err.message });
+        });
+
+        // Capturar encerramento
+        child.on("close", (code, signal) => {
+            console.log(`⏹️ Service ${serviceId} exited with code ${code}, signal ${signal}`);
+            this.processes.delete(serviceId);
+            this.emit("stopped", { serviceId, code, signal });
+        });
+
+        // Iniciar monitoramento de recursos
+        this.startResourceMonitoring(serviceId);
+
+        return {
+            serviceId,
+            pid: child.pid,
+            status: "starting",
+            port,
+            command: `${cmd} ${cmdArgs.join(' ')}`,
+            startedAt: new Date().toISOString()
+        };
+    }
+
+    /**
+     * Para um serviço
+     */
+    async stop(serviceId) {
+        const processData = this.processes.get(serviceId);
+        if (!processData) {
+            console.log(`⚠️ Service ${serviceId} is not running (already stopped)`);
+            return {
+                serviceId,
+                status: 'stopped',
+                stoppedAt: new Date().toISOString(),
+                alreadyStopped: true
+            };
+        }
+
+        console.log(`⏹️ Stopping ${serviceId} (PID: ${processData.pid})...`);
+
+        return new Promise((resolve) => {
+            const child = processData.process;
+            let resolved = false;
+
+            const onExit = (code) => {
+                if (!resolved) {
+                    resolved = true;
+                    this.processes.delete(serviceId);
+                    console.log(`✅ Service ${serviceId} stopped (exit code: ${code})`);
+                    this.emit("log", { serviceId, message: `Service stopped (exit code: ${code})`, type: "info" });
+                    resolve({
+                        serviceId,
+                        status: 'stopped',
+                        exitCode: code,
+                        stoppedAt: new Date().toISOString()
+                    });
+                }
+            };
+
+            child.once('exit', onExit);
+            child.once('close', onExit);
+
+            // Tentar graceful shutdown
+            try {
+                child.kill('SIGTERM');
+            } catch (err) {
+                console.log(`⚠️ SIGTERM failed for ${serviceId}: ${err.message}`);
+            }
+
+            // Force kill após 5 segundos
+            setTimeout(() => {
+                if (!resolved && this.processes.has(serviceId)) {
+                    console.log(`🔨 Force killing ${serviceId} (SIGKILL)`);
+                    try {
+                        child.kill('SIGKILL');
+                    } catch (err) {
+                        console.log(`⚠️ SIGKILL failed: ${err.message}`);
+                    }
+                }
+            }, 5000);
+
+            // Timeout geral após 10 segundos
+            setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    this.processes.delete(serviceId);
+                    console.log(`⏰ Stop timeout for ${serviceId}, assuming stopped`);
+                    resolve({
+                        serviceId,
+                        status: 'stopped',
+                        timeout: true,
+                        stoppedAt: new Date().toISOString()
+                    });
+                }
+            }, 10000);
+        });
+    }
+
+    /**
+     * Retorna status de um serviço
+     */
+    getStatus(serviceId) {
+        const processData = this.processes.get(serviceId);
+        if (!processData) {
+            return { serviceId, status: "stopped" };
+        }
+
+        const uptime = Math.floor((Date.now() - processData.startTime) / 1000);
+
+        return {
+            serviceId,
+            status: processData.status,
+            pid: processData.pid,
+            port: processData.port,
+            cpu: processData.cpu,
+            memory: processData.memory,
+            uptime,
+            logsCount: processData.logs.length,
+            startedAt: new Date(processData.startTime).toISOString()
+        };
+    }
+
+    /**
+     * Retorna logs de um serviço
+     */
+    getLogs(serviceId, limit = 100) {
+        const processData = this.processes.get(serviceId);
+        if (!processData) {
+            return [];
+        }
+        return processData.logs.slice(-limit);
+    }
+
+    /**
+     * Lista todos os serviços
+     */
+    listServices() {
+        const services = [];
+        for (const [serviceId] of this.processes.entries()) {
+            services.push(this.getStatus(serviceId));
+        }
+        return services;
+    }
+
+    /**
+     * Alias para compatibilidade
+     */
+    listAll() {
+        return this.listServices();
+    }
+
+    /**
+     * Determina comando de start baseado no framework (FORMATO LEGADO)
+     * Usado quando server.js não passa command/args diretamente
+     */
+    async getStartCommand(language, framework, buildTool, cwd, profile = 'dev') {
+        console.log(`🔧 getStartCommand: language=${language}, framework=${framework}, buildTool=${buildTool}`);
+
+        // Java (qualquer framework ou sem framework)
+        if (language === "java") {
+            return await this.getJavaCommand(buildTool, cwd, profile);
+        }
+
+        // Node.js
+        if (language === "node") {
+            return await this.getNodeCommand(framework, cwd);
+        }
+
+        // Python
+        if (language === "python") {
+            return await this.getPythonCommand(framework, cwd);
+        }
+
+        // .NET
+        if (language === "dotnet" || language === ".net") {
+            return await this.getDotNetCommand(cwd);
+        }
+
+        // Go
+        if (language === "go") {
+            return await this.getGoCommand(cwd);
+        }
+
+        // Fallback genérico - tenta npm start
+        console.warn(`⚠️ Unknown language: ${language}, trying npm start`);
+        return { cmd: "npm", args: ["start"] };
+    }
+
+    /**
+     * Comando Java/Spring Boot
+     */
+    async getJavaCommand(buildTool, cwd, profile = null) {
+        const targetDir = path.join(cwd, "target");
+        const buildDir = path.join(cwd, "build", "libs");
+
+        console.log(`🔍 Checking for compiled JARs in: ${cwd}`);
+
+        // ✅ Helper: Build args with optional profile
+        const buildJavaArgs = (jarPath) => {
+            const javaArgs = [];
+            // Only add profile if explicitly provided (not null/undefined/'default')
+            if (profile && profile !== 'default') {
+                javaArgs.push(`-Dspring.profiles.active=${profile}`);
+                console.log(`   📋 Using Spring profile: ${profile}`);
+            } else {
+                // ✅ Check if there's a local/dev profile available
+                const resourcesDir = path.join(cwd, 'src/main/resources');
+                const localProfile = ['local', 'dev'].find(p => {
+                    return fs.existsSync(path.join(resourcesDir, `application-${p}.yml`)) ||
+                        fs.existsSync(path.join(resourcesDir, `application-${p}.yaml`)) ||
+                        fs.existsSync(path.join(resourcesDir, `application-${p}.properties`));
+                });
+                if (localProfile) {
+                    javaArgs.push(`-Dspring.profiles.active=${localProfile}`);
+                    console.log(`   📋 Auto-detected profile: ${localProfile}`);
+                } else {
+                    console.log(`   📋 No profile set — using application.yml defaults`);
+                }
+            }
+            javaArgs.push("-jar", jarPath);
+            return javaArgs;
+        };
+
+        // Maven: Procurar JAR em target/
+        if (buildTool === "maven") {
+            console.log(`📁 Target directory: ${targetDir} (exists: ${fs.existsSync(targetDir)})`);
+
+            if (fs.existsSync(targetDir)) {
+                try {
+                    const allFiles = fs.readdirSync(targetDir);
+                    console.log(`📦 Files in target/: ${allFiles.join(", ")}`);
+
+                    const jars = allFiles
+                        .filter(f => {
+                            return f.endsWith(".jar") &&
+                                !f.includes("original") &&
+                                !f.includes("sources") &&
+                                !f.includes("javadoc");
+                        })
+                        .sort((a, b) => {
+                            const statsA = fs.statSync(path.join(targetDir, a));
+                            const statsB = fs.statSync(path.join(targetDir, b));
+                            return statsB.mtimeMs - statsA.mtimeMs;
+                        });
+
+                    console.log(`🎯 Filtered JARs: ${jars.join(", ")}`);
+
+                    if (jars.length > 0) {
+                        const jarPath = path.join(targetDir, jars[0]);
+                        console.log(`✅ Found compiled JAR: ${jars[0]}`);
+                        return {
+                            cmd: "java",
+                            args: buildJavaArgs(jarPath)
+                        };
+                    }
+                } catch (err) {
+                    console.error(`❌ Error reading target: ${err.message}`);
+                }
+            }
+
+            // Sem JAR - pedir para compilar
+            throw new Error(`No JAR found. Please compile first: mvn clean install -DskipTests`);
+        }
+
+        // Gradle: Procurar JAR em build/libs/
+        if (buildTool === "gradle") {
+            console.log(`📁 Build directory: ${buildDir} (exists: ${fs.existsSync(buildDir)})`);
+
+            if (fs.existsSync(buildDir)) {
+                try {
+                    const allFiles = fs.readdirSync(buildDir);
+                    const jars = allFiles
+                        .filter(f => f.endsWith(".jar") && !f.includes("plain") && !f.includes("sources"))
+                        .sort((a, b) => {
+                            const statsA = fs.statSync(path.join(buildDir, a));
+                            const statsB = fs.statSync(path.join(buildDir, b));
+                            return statsB.mtimeMs - statsA.mtimeMs;
+                        });
+
+                    if (jars.length > 0) {
+                        const jarPath = path.join(buildDir, jars[0]);
+                        console.log(`✅ Found compiled JAR: ${jars[0]}`);
+                        return {
+                            cmd: "java",
+                            args: buildJavaArgs(jarPath)
+                        };
+                    }
+                } catch (err) {
+                    console.error(`❌ Error reading build/libs: ${err.message}`);
+                }
+            }
+
+            throw new Error(`No JAR found. Please compile first: ./gradlew clean build -x test`);
+        }
+
+        throw new Error(`Unknown Java build tool: ${buildTool}`);
+    }
+
+    /**
+     * Comando Node.js
+     */
+    async getNodeCommand(framework, cwd) {
+        const nodeModules = path.join(cwd, "node_modules");
+        const hasNodeModules = fs.existsSync(nodeModules);
+
+        if (!hasNodeModules) {
+            console.log("⚠️ node_modules not found, will install first");
+            if (framework === "next") {
+                return { cmd: "sh", args: ["-c", "npm install && npm run dev"] };
+            }
+            return { cmd: "sh", args: ["-c", "npm install && npm start"] };
+        }
+
+        if (framework === "next") {
+            return { cmd: "npm", args: ["run", "dev"] };
+        }
+        return { cmd: "npm", args: ["start"] };
+    }
+
+    /**
+     * Comando Python
+     */
+    async getPythonCommand(framework, cwd) {
+        if (framework === "django") {
+            return { cmd: "python", args: ["manage.py", "runserver"] };
+        }
+        if (framework === "flask") {
+            return { cmd: "flask", args: ["run"] };
+        }
+        if (framework === "fastapi") {
+            return { cmd: "uvicorn", args: ["main:app", "--reload"] };
+        }
+        return { cmd: "python", args: ["main.py"] };
+    }
+
+    /**
+     * Comando .NET
+     */
+    async getDotNetCommand(cwd) {
+        return { cmd: "dotnet", args: ["run"] };
+    }
+
+    /**
+     * Comando Go
+     */
+    async getGoCommand(cwd) {
+        return { cmd: "go", args: ["run", "."] };
+    }
+
+    /**
+     * Detecta quando serviço está pronto
+     */
+    isServiceReady(log, language) {
+        if (!log) return false;
+
+        const patterns = [
+            // Spring Boot
+            /started.*in \d+(\.\d+)? seconds/i,
+            /tomcat started on port/i,
+            /started \w+application/i,
+            /jvm running for/i,
+            // Node.js
+            /listening on port/i,
+            /server running/i,
+            /ready on/i,
+            /started on/i,
+            // Python
+            /running on http/i,
+            /uvicorn running/i,
+            /development server/i,
+            // .NET
+            /now listening on/i,
+            // Generic
+            /server started/i,
+            /application started/i
+        ];
+
+        return patterns.some(pattern => pattern.test(log));
+    }
+
+    /**
+     * Monitora recursos (CPU e Memory)
+     */
+    startResourceMonitoring(serviceId) {
+        const interval = setInterval(async () => {
+            const processData = this.processes.get(serviceId);
+            if (!processData) {
+                clearInterval(interval);
+                return;
+            }
+
+            try {
+                const pidusage = await import('pidusage').then(m => m.default).catch(() => null);
+                if (pidusage && processData.pid) {
+                    const stats = await pidusage(processData.pid);
+                    processData.cpu = parseFloat(stats.cpu.toFixed(1));
+                    processData.memory = Math.floor(stats.memory / 1024 / 1024);
+                }
+            } catch {
+                processData.cpu = 0;
+                processData.memory = 0;
+            }
+        }, 5000);
+    }
+}
+
+export default ProcessManager;

package/src/workspace/scanner.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export class WorkspaceScanner {
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+        this.ignorePatterns = [
+            'node_modules', 'target', 'build', 'dist',
+            '.git', '.idea', '.vscode', '__pycache__',
+            '.next', 'out', 'coverage', '.gradle'
+        ];
+    }
+
+    async scan() {
+        const structure = {
+            root: this.rootPath,
+            files: [],
+            directories: [],
+            metadata: {
+                totalFiles: 0,
+                totalSize: 0,
+                languages: new Set(),
+                frameworks: new Set()
+            }
+        };
+
+        await this.walkDirectory(this.rootPath, structure);
+
+        // Convert Set to Array for JSON serialization
+        structure.metadata.languages = Array.from(structure.metadata.languages);
+        structure.metadata.frameworks = Array.from(structure.metadata.frameworks);
+
+        return structure;
+    }
+
+    async walkDirectory(dir, structure, depth = 0) {
+        if (depth > 10) return; // Limite de profundidade
+
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (this.shouldIgnore(entry.name)) continue;
+
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(this.rootPath, fullPath);
+
+                if (entry.isDirectory()) {
+                    structure.directories.push(relativePath);
+                    await this.walkDirectory(fullPath, structure, depth + 1);
+                } else {
+                    const stat = await fs.stat(fullPath);
+                    structure.files.push({
+                        path: relativePath,
+                        name: entry.name,
+                        extension: path.extname(entry.name),
+                        size: stat.size,
+                        modified: stat.mtime
+                    });
+                    structure.metadata.totalFiles++;
+                    structure.metadata.totalSize += stat.size;
+                }
+            }
+        } catch (err) {
+            console.error(`Error reading directory ${dir}:`, err.message);
+        }
+    }
+
+    shouldIgnore(name) {
+        return this.ignorePatterns.some(pattern => name.includes(pattern));
+    }
+}