deepdebug-local-agent 0.3.8 → 0.3.9

package/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/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);
+    }
+}