deepdebug-local-agent 0.3.7 → 0.3.9

package/server.js

@@ -557,7 +557,6 @@ app.use(cors({
         // Cloud Run URLs (regex patterns)
         /https:\/\/.*\.run\.app$/,
         /https:\/\/.*\.web\.app$/,
-        // Production frontend
         "https://deepdebug.ai",
         "https://www.deepdebug.ai"
     ],
@@ -5083,126 +5082,10 @@ app.post("/workspace/:workspaceId/run", async (req, res) => {
     }
 });
 
-
-// ============================================
-// 🌐 CLOUDFLARE TUNNEL - Auto-expose Local Agent
-// ============================================
-import { execFile, spawn } from 'child_process';
-import { createWriteStream } from 'fs';
-import { pipeline } from 'stream/promises';
-
-async function startCloudflaredTunnel(port, gatewayUrl, apiKey, workspaceId) {
-    const platform = process.platform;
-    const arch = process.arch;
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const deepdebugDir = path.join(homeDir, '.deepdebug');
-    const binaryName = platform === 'win32' ? 'cloudflared.exe' : 'cloudflared';
-    const binaryPath = path.join(deepdebugDir, binaryName);
-
-    // Download URL based on platform
-    const downloadUrls = {
-        'win32-x64':   'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
-        'darwin-x64':  'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64',
-        'darwin-arm64':'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-arm64',
-        'linux-x64':   'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64',
-        'linux-arm64': 'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64',
-    };
-
-    const key = `${platform}-${arch}`;
-    const downloadUrl = downloadUrls[key];
-
-    if (!downloadUrl) {
-        console.warn(`⚠️ Cloudflared not available for platform: ${key}`);
-        return null;
-    }
-
-    // Download cloudflared if not present
-    if (!fs.existsSync(binaryPath)) {
-        console.log(`⬇️  Downloading cloudflared for ${key}...`);
-        try {
-            const res = await fetch(downloadUrl);
-            if (!res.ok) throw new Error(`Download failed: ${res.status}`);
-            await pipeline(res.body, createWriteStream(binaryPath));
-            // Make executable on unix
-            if (platform !== 'win32') {
-                fs.chmodSync(binaryPath, 0o755);
-            }
-            console.log(`✅ cloudflared downloaded to ${binaryPath}`);
-        } catch (err) {
-            console.warn(`⚠️ Failed to download cloudflared: ${err.message}`);
-            return null;
-        }
-    }
-
-    // Start tunnel
-    return new Promise((resolve) => {
-        console.log(`🌐 Starting Cloudflare tunnel on port ${port}...`);
-        
-        const child = spawn(binaryPath, [
-            'tunnel', '--url', `http://localhost:${port}`,
-            '--no-autoupdate'
-        ], { stdio: ['ignore', 'pipe', 'pipe'] });
-
-        let tunnelUrl = null;
-        const urlPattern = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-
-        const handleOutput = async (data) => {
-            const text = data.toString();
-            const match = text.match(urlPattern);
-            if (match && !tunnelUrl) {
-                tunnelUrl = match[0];
-                console.log(`\n🌐 ====================================`);
-                console.log(`🌐 Tunnel URL: ${tunnelUrl}`);
-                console.log(`🌐 ====================================\n`);
-
-                // Register tunnel URL with Gateway
-                if (gatewayUrl && apiKey && workspaceId) {
-                    try {
-                        const registerRes = await fetch(`${gatewayUrl}/api/v1/workspaces/${workspaceId}/agent-url`, {
-                            method: 'PUT',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'Authorization': `Bearer ${apiKey}`
-                            },
-                            body: JSON.stringify({ agentUrl: tunnelUrl })
-                        });
-                        if (registerRes.ok) {
-                            console.log(`✅ Agent URL registered with Gateway`);
-                        } else {
-                            console.warn(`⚠️ Failed to register agent URL: ${registerRes.status}`);
-                        }
-                    } catch (err) {
-                        console.warn(`⚠️ Could not register agent URL: ${err.message}`);
-                    }
-                }
-                resolve(tunnelUrl);
-            }
-        };
-
-        child.stdout.on('data', handleOutput);
-        child.stderr.on('data', handleOutput);
-
-        child.on('exit', (code) => {
-            if (!tunnelUrl) {
-                console.warn(`⚠️ cloudflared exited with code ${code} before tunnel was established`);
-                resolve(null);
-            }
-        });
-
-        // Timeout after 30 seconds
-        setTimeout(() => {
-            if (!tunnelUrl) {
-                console.warn('⚠️ Cloudflare tunnel timeout - continuing without tunnel');
-                resolve(null);
-            }
-        }, 30000);
-    });
-}
-
 // ============================================
 // START SERVER
 // ============================================
-app.listen(PORT, '0.0.0.0', async () => {
+app.listen(PORT, '0.0.0.0', () => {
     console.log(`\n🔌 DeepDebug Local Agent listening on port ${PORT}`);
     console.log(`📦 Environment: ${process.env.NODE_ENV || 'development'}`);
     console.log(`📦 Process Manager initialized`);
@@ -5213,26 +5096,6 @@ app.listen(PORT, '0.0.0.0', async () => {
         console.log(`   Max Retries: ${aiEngine.maxRetries}`);
     }
     console.log(`\n🚀 Ready to receive requests!\n`);
-
-    // 🌐 Auto-start Cloudflare Tunnel
-    const homeDir = process.env.HOME || process.env.USERPROFILE;
-    const configPath = path.join(homeDir, '.deepdebug', 'config.json');
-    let tunnelConfig = {};
-    try {
-        if (fs.existsSync(configPath)) {
-            tunnelConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-    } catch (e) {}
-
-    const gatewayUrl = tunnelConfig.gatewayUrl || process.env.GATEWAY_URL;
-    const apiKey = tunnelConfig.apiKey || process.env.DEEPDEBUG_API_KEY;
-    const workspaceId = tunnelConfig.workspaceId || process.env.WORKSPACE_ID;
-
-    if (process.env.DISABLE_TUNNEL !== 'true') {
-        startCloudflaredTunnel(PORT, gatewayUrl, apiKey, workspaceId).catch(err => {
-            console.warn(`⚠️ Tunnel error: ${err.message}`);
-        });
-    }
 });
 
 // Start MCP HTTP Bridge em paralelo (port 5056)

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