deepdebug-local-agent 0.3.1

package/src/utils/exec-utils.js

@@ -0,0 +1,264 @@
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import stripAnsi from 'strip-ansi';
+
+const execAsync = promisify(exec);
+
+/**
+ * Executa um comando e retorna o resultado
+ *
+ * @param {string} cmd - Comando a executar
+ * @param {string[]} args - Argumentos
+ * @param {string} cwd - Diretório de trabalho
+ * @param {number} timeoutMs - Timeout em ms (default: 10 min)
+ * @returns {Promise<CommandResult>}
+ */
+export function run(cmd, args = [], cwd = process.cwd(), timeoutMs = 10 * 60 * 1000) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+
+        const child = spawn(cmd, args, {
+            cwd,
+            shell: true,
+            env: { ...process.env }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            } catch (e) {
+                // Process already terminated
+            }
+        }, timeoutMs);
+
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                code: 1,
+                stdout: stripAnsi(stdout),
+                stderr: stripAnsi(err.message),
+                duration: Date.now() - startTime
+            });
+        });
+
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                code: code || 0,
+                stdout: stripAnsi(stdout),
+                stderr: stripAnsi(stderr),
+                duration: Date.now() - startTime
+            });
+        });
+    });
+}
+
+/**
+ * Executa comando com streaming de output
+ *
+ * @param {string} cmd - Comando
+ * @param {string[]} args - Argumentos
+ * @param {string} cwd - Diretório de trabalho
+ * @param {object} callbacks - { onStdout, onStderr, onClose }
+ * @returns {ChildProcess}
+ */
+export function runStreaming(cmd, args = [], cwd = process.cwd(), callbacks = {}) {
+    const { onStdout, onStderr, onClose, onError } = callbacks;
+
+    const child = spawn(cmd, args, {
+        cwd,
+        shell: true,
+        env: { ...process.env }
+    });
+
+    if (onStdout) {
+        child.stdout.on('data', (data) => {
+            onStdout(stripAnsi(data.toString()));
+        });
+    }
+
+    if (onStderr) {
+        child.stderr.on('data', (data) => {
+            onStderr(stripAnsi(data.toString()));
+        });
+    }
+
+    if (onError) {
+        child.on('error', onError);
+    }
+
+    if (onClose) {
+        child.on('close', onClose);
+    }
+
+    return child;
+}
+
+/**
+ * Executa comando simples e retorna output
+ *
+ * @param {string} command - Comando completo
+ * @param {string} cwd - Diretório de trabalho
+ * @returns {Promise<string>}
+ */
+export async function execSimple(command, cwd = process.cwd()) {
+    try {
+        const { stdout } = await execAsync(command, { cwd });
+        return stripAnsi(stdout.trim());
+    } catch (e) {
+        throw new Error(e.stderr || e.message);
+    }
+}
+
+/**
+ * Verifica se um comando está disponível no sistema
+ *
+ * @param {string} cmd - Nome do comando
+ * @returns {Promise<boolean>}
+ */
+export async function commandExists(cmd) {
+    try {
+        const checkCmd = process.platform === 'win32'
+            ? `where ${cmd}`
+            : `which ${cmd}`;
+        await execAsync(checkCmd);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Executa compile e test para um projeto
+ *
+ * @param {object} options - { language, buildTool, cwd }
+ * @returns {Promise<CompileTestResult>}
+ */
+export async function compileAndTest({ language, buildTool, cwd }) {
+    const steps = [];
+
+    // Java + Maven
+    if (language === 'java' && buildTool === 'maven') {
+        const clean = await run('mvn', ['clean', '-q'], cwd);
+        steps.push({ name: 'clean', ...clean });
+
+        const test = await run('mvn', ['test', '-q'], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // Java + Gradle
+    if (language === 'java' && buildTool === 'gradle') {
+        const cmd = await commandExists('./gradlew') ? './gradlew' : 'gradle';
+
+        const clean = await run(cmd, ['clean'], cwd);
+        steps.push({ name: 'clean', ...clean });
+
+        const test = await run(cmd, ['test'], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // Node.js
+    if (language === 'node') {
+        const install = await run('npm', ['install', '--silent'], cwd);
+        steps.push({ name: 'install', ...install });
+
+        const test = await run('npm', ['test', '--', '--passWithNoTests'], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // Python
+    if (language === 'python') {
+        const test = await run('pytest', [], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // Go
+    if (language === 'go') {
+        const test = await run('go', ['test', './...'], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // .NET
+    if (language === 'dotnet' || language === '.net') {
+        const build = await run('dotnet', ['build'], cwd);
+        steps.push({ name: 'build', ...build });
+
+        const test = await run('dotnet', ['test'], cwd);
+        steps.push({ name: 'test', ...test });
+
+        return {
+            success: test.code === 0,
+            steps
+        };
+    }
+
+    // Unsupported
+    return {
+        success: false,
+        steps: [{
+            name: 'error',
+            code: 1,
+            stdout: '',
+            stderr: `Unsupported language/build tool: ${language}/${buildTool}`,
+            duration: 0
+        }]
+    };
+}
+
+/**
+ * @typedef {object} CommandResult
+ * @property {number} code - Exit code
+ * @property {string} stdout - Standard output
+ * @property {string} stderr - Standard error
+ * @property {number} duration - Duration in ms
+ */
+
+/**
+ * @typedef {object} CompileTestResult
+ * @property {boolean} success - Whether all steps passed
+ * @property {CommandResult[]} steps - Results of each step
+ */
+
+export default {
+    run,
+    runStreaming,
+    execSimple,
+    commandExists,
+    compileAndTest
+};

package/src/utils/fs-utils.js

@@ -0,0 +1,218 @@
+import fs from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+
+// Promisified functions
+export const stat = promisify(fs.stat);
+export const readdir = promisify(fs.readdir);
+export const readFile = promisify(fs.readFile);
+export const writeFile = promisify(fs.writeFile);
+export const mkdir = promisify(fs.mkdir);
+export const unlink = promisify(fs.unlink);
+export const rmdir = promisify(fs.rmdir);
+export const copyFile = promisify(fs.copyFile);
+export const access = promisify(fs.access);
+export const rename = promisify(fs.rename);
+
+/**
+ * Verifica se um arquivo/diretório existe
+ */
+export async function exists(p) {
+    try {
+        await access(p, fs.constants.F_OK);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Cria diretório recursivamente se não existir
+ */
+export async function ensureDir(dir) {
+    if (!(await exists(dir))) {
+        await mkdir(dir, { recursive: true });
+    }
+}
+
+/**
+ * Lista arquivos recursivamente
+ */
+export async function listRecursive(root, options = {}) {
+    const {
+        maxFiles = 5000,
+        includeHidden = false,
+        extensions = null,
+        ignore = ['node_modules', '.git', 'target', 'build', 'dist', '__pycache__', '.idea', '.vscode']
+    } = options;
+
+    const results = [];
+
+    async function walk(dir) {
+        if (results.length >= maxFiles) return;
+
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (results.length >= maxFiles) break;
+
+                // Skip hidden files
+                if (!includeHidden && entry.name.startsWith('.')) continue;
+
+                // Skip ignored directories
+                if (ignore.includes(entry.name)) continue;
+
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(root, fullPath);
+
+                if (entry.isDirectory()) {
+                    results.push({ type: 'dir', path: relativePath });
+                    await walk(fullPath);
+                } else if (entry.isFile()) {
+                    // Filter by extension if specified
+                    if (extensions) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!extensions.includes(ext)) continue;
+                    }
+
+                    results.push({ type: 'file', path: relativePath });
+                }
+            }
+        } catch (e) {
+            // Permission denied or other error
+        }
+    }
+
+    await walk(root);
+    return results;
+}
+
+/**
+ * Copia diretório recursivamente
+ */
+export async function copyDir(src, dest) {
+    await ensureDir(dest);
+    const entries = await readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        } else {
+            await copyFile(srcPath, destPath);
+        }
+    }
+}
+
+/**
+ * Remove diretório recursivamente
+ */
+export async function removeDir(dir) {
+    if (!(await exists(dir))) return;
+
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+            await removeDir(fullPath);
+        } else {
+            await unlink(fullPath);
+        }
+    }
+
+    await rmdir(dir);
+}
+
+/**
+ * Calcula tamanho total de um diretório
+ */
+export async function dirSize(dir) {
+    let totalSize = 0;
+
+    async function walk(d) {
+        try {
+            const entries = await readdir(d, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = path.join(d, entry.name);
+
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                } else {
+                    const stats = await stat(fullPath);
+                    totalSize += stats.size;
+                }
+            }
+        } catch (e) {
+            // Skip inaccessible directories
+        }
+    }
+
+    await walk(dir);
+    return totalSize;
+}
+
+/**
+ * Lê arquivo JSON
+ */
+export async function readJson(filePath) {
+    const content = await readFile(filePath, 'utf8');
+    return JSON.parse(content);
+}
+
+/**
+ * Escreve arquivo JSON
+ */
+export async function writeJson(filePath, data, pretty = true) {
+    const content = pretty
+        ? JSON.stringify(data, null, 2)
+        : JSON.stringify(data);
+    await writeFile(filePath, content, 'utf8');
+}
+
+/**
+ * Obtém extensão do arquivo normalizada
+ */
+export function getExtension(filePath) {
+    return path.extname(filePath).toLowerCase();
+}
+
+/**
+ * Verifica se é arquivo de código
+ */
+export function isCodeFile(filePath) {
+    const codeExtensions = [
+        '.java', '.js', '.ts', '.jsx', '.tsx', '.py', '.cs', '.go',
+        '.rb', '.php', '.swift', '.kt', '.scala', '.rs', '.cpp', '.c',
+        '.h', '.hpp', '.vue', '.svelte'
+    ];
+    return codeExtensions.includes(getExtension(filePath));
+}
+
+export default {
+    stat,
+    readdir,
+    readFile,
+    writeFile,
+    mkdir,
+    unlink,
+    rmdir,
+    copyFile,
+    access,
+    rename,
+    exists,
+    ensureDir,
+    listRecursive,
+    copyDir,
+    removeDir,
+    dirSize,
+    readJson,
+    writeJson,
+    getExtension,
+    isCodeFile
+};

package/src/workspace/detect-port.js

@@ -0,0 +1,176 @@
+// Adicionar no server.js do Local Agent
+
+/**
+ * GET /workspace/detect-port
+ *
+ * Detecta porta de um serviço específico lendo arquivos de configuração
+ *
+ * Query params:
+ * - servicePath: caminho relativo do serviço
+ * - language: linguagem do serviço
+ * - framework: framework do serviço
+ */
+app.get("/workspace/detect-port", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { servicePath, language, framework } = req.query;
+
+    if (!servicePath) {
+        return res.status(400).json({ error: "servicePath is required" });
+    }
+
+    try {
+        const fullPath = path.join(WORKSPACE_ROOT, servicePath);
+
+        console.log(`🔍 Detecting port for service at: ${fullPath}`);
+
+        let port = null;
+
+        // Detectar porta baseado na linguagem/framework
+        if (language === 'java' && framework === 'spring-boot') {
+            port = await detectSpringBootPort(fullPath);
+        } else if (language === 'node') {
+            port = await detectNodePort(fullPath);
+        } else if (language === 'python') {
+            port = await detectPythonPort(fullPath);
+        } else if (language === 'dotnet') {
+            port = await detectDotNetPort(fullPath);
+        }
+
+        console.log(`✅ Detected port: ${port || 'default'}`);
+
+        res.json({ port });
+    } catch (err) {
+        console.error('❌ Error detecting port:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+/**
+ * Detecta porta do Spring Boot
+ */
+async function detectSpringBootPort(servicePath) {
+    const candidates = [
+        path.join(servicePath, 'src/main/resources/application.yml'),
+        path.join(servicePath, 'src/main/resources/application.yaml'),
+        path.join(servicePath, 'src/main/resources/application.properties'),
+        path.join(servicePath, 'application.yml'),
+        path.join(servicePath, 'application.yaml'),
+        path.join(servicePath, 'application.properties')
+    ];
+
+    for (const filePath of candidates) {
+        if (await exists(filePath)) {
+            console.log(`📄 Reading config: ${filePath}`);
+            const content = await readFile(filePath, 'utf8');
+
+            // YAML
+            if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+                const match = content.match(/server:\s+port:\s*(\d+)/);
+                if (match) {
+                    console.log(`✓ Found port in YAML: ${match[1]}`);
+                    return parseInt(match[1]);
+                }
+            }
+
+            // Properties
+            if (filePath.endsWith('.properties')) {
+                const match = content.match(/server\.port\s*=\s*(\d+)/);
+                if (match) {
+                    console.log(`✓ Found port in Properties: ${match[1]}`);
+                    return parseInt(match[1]);
+                }
+            }
+        }
+    }
+
+    console.log('⚠️ No port config found, using default: 8080');
+    return 8080; // Default Spring Boot
+}
+
+/**
+ * Detecta porta do Node.js
+ */
+async function detectNodePort(servicePath) {
+    // Tentar .env
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        const content = await readFile(envPath, 'utf8');
+        const match = content.match(/PORT\s*=\s*(\d+)/i);
+        if (match) {
+            console.log(`✓ Found port in .env: ${match[1]}`);
+            return parseInt(match[1]);
+        }
+    }
+
+    // Tentar package.json scripts
+    const pkgPath = path.join(servicePath, 'package.json');
+    if (await exists(pkgPath)) {
+        const content = await readFile(pkgPath, 'utf8');
+        const pkg = JSON.parse(content);
+
+        // Procurar por --port ou PORT= nos scripts
+        const scripts = JSON.stringify(pkg.scripts || {});
+        const match = scripts.match(/--port[=\s]+(\d+)|PORT[=\s]+(\d+)/i);
+        if (match) {
+            const port = parseInt(match[1] || match[2]);
+            console.log(`✓ Found port in package.json: ${port}`);
+            return port;
+        }
+    }
+
+    console.log('⚠️ No port config found, using default: 3000');
+    return 3000; // Default Node
+}
+
+/**
+ * Detecta porta do Python
+ */
+async function detectPythonPort(servicePath) {
+    // Tentar .env
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        const content = await readFile(envPath, 'utf8');
+        const match = content.match(/PORT\s*=\s*(\d+)/i);
+        if (match) {
+            console.log(`✓ Found port in .env: ${match[1]}`);
+            return parseInt(match[1]);
+        }
+    }
+
+    // Defaults por framework
+    console.log('⚠️ No port config found, using framework default');
+    return 8000; // Default Django/FastAPI
+}
+
+/**
+ * Detecta porta do .NET
+ */
+async function detectDotNetPort(servicePath) {
+    const launchSettings = path.join(servicePath, 'Properties/launchSettings.json');
+
+    if (await exists(launchSettings)) {
+        const content = await readFile(launchSettings, 'utf8');
+        const settings = JSON.parse(content);
+
+        // Procurar em profiles
+        const profiles = settings.profiles || {};
+        for (const profile of Object.values(profiles)) {
+            if (profile.applicationUrl) {
+                const match = profile.applicationUrl.match(/:(\d+)/);
+                if (match) {
+                    console.log(`✓ Found port in launchSettings: ${match[1]}`);
+                    return parseInt(match[1]);
+                }
+            }
+        }
+    }
+
+    console.log('⚠️ No port config found, using default: 5000');
+    return 5000; // Default .NET
+}

package/src/workspace/file-reader.js

@@ -0,0 +1,54 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export class FileReader {
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+        this.ignorePatterns = ['node_modules', 'target', '.git', 'build', 'dist'];
+    }
+
+    async read(relativePath) {
+        const fullPath = path.join(this.rootPath, relativePath);
+
+        // Validação de segurança - previne path traversal
+        if (!fullPath.startsWith(this.rootPath)) {
+            throw new Error('Path traversal detected');
+        }
+
+        const content = await fs.readFile(fullPath, 'utf8');
+        return {
+            path: relativePath,
+            content,
+            lines: content.split('\n').length,
+            size: Buffer.byteLength(content, 'utf8')
+        };
+    }
+
+    async readMultiple(paths) {
+        return Promise.all(paths.map(p => this.read(p)));
+    }
+
+    async findByPattern(pattern) {
+        const allFiles = await this.getAllFiles();
+        return allFiles.filter(f => pattern.test(f));
+    }
+
+    async getAllFiles(dir = this.rootPath) {
+        const files = [];
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !this.shouldIgnore(entry.name)) {
+                files.push(...await this.getAllFiles(fullPath));
+            } else if (entry.isFile()) {
+                files.push(path.relative(this.rootPath, fullPath));
+            }
+        }
+        return files;
+    }
+
+    shouldIgnore(name) {
+        return this.ignorePatterns.includes(name);
+    }
+}