deepdebug-local-agent 0.3.1

package/src/server-local.js

@@ -0,0 +1,576 @@
+// ============================================
+// 🆕 ADICIONAR ESTES ENDPOINTS AO server-local.js
+// Colocar ANTES da seção "START SERVER"
+// NÃO modificar endpoints existentes
+// ============================================
+
+// ============================================
+// 🆕 DRY-RUN ENDPOINT (Sprint 1.3)
+// Valida e simula patch SEM modificar arquivos
+// ============================================
+
+/**
+ * POST /workspace/patch/dry-run
+ * Validates and simulates patch application WITHOUT modifying files
+ * Useful for preview before actually applying
+ *
+ * Body: { "diff": "unified diff text" }
+ *
+ * Response:
+ * {
+ *   "ok": true,
+ *   "valid": true,
+ *   "canApply": true,
+ *   "wouldModify": ["src/Main.java"],
+ *   "hunksCount": 3,
+ *   "fileChecks": [{ "path": "...", "exists": true, "lineCount": 100 }],
+ *   "warnings": []
+ * }
+ */
+app.post("/workspace/patch/dry-run", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({
+            error: "workspace not set",
+            hint: "call POST /workspace/open first"
+        });
+    }
+
+    const { diff } = req.body || {};
+    if (!diff) return res.status(400).json({ error: "diff is required" });
+
+    console.log(`🔍 Dry-run patch validation requested`);
+
+    try {
+        // 1. Validate diff format
+        const validation = validateDiff(diff);
+        if (!validation.valid) {
+            return res.json({
+                ok: true,
+                valid: false,
+                canApply: false,
+                errors: validation.errors,
+                wouldModify: [],
+                hunksCount: 0
+            });
+        }
+
+        // 2. Extract target files
+        const targetFiles = extractTargetFiles(diff);
+
+        // 3. Check if files exist and get line counts
+        const fileChecks = await Promise.all(
+            targetFiles.map(async (relPath) => {
+                const fullPath = path.join(WORKSPACE_ROOT, relPath);
+                const fileExists = await exists(fullPath);
+                let lineCount = 0;
+                let size = 0;
+
+                if (fileExists) {
+                    try {
+                        const content = await readFile(fullPath, 'utf8');
+                        lineCount = content.split('\n').length;
+                        size = Buffer.byteLength(content, 'utf8');
+                    } catch (e) {
+                        // File exists but can't be read
+                    }
+                }
+
+                return {
+                    path: relPath,
+                    exists: fileExists,
+                    lineCount,
+                    size
+                };
+            })
+        );
+
+        // 4. Count hunks
+        const hunkMatches = diff.match(/@@ -\d+,?\d* \+\d+,?\d* @@/g) || [];
+        const hunkCount = hunkMatches.length;
+
+        // 5. Analyze changes
+        const addedLines = (diff.match(/^\+[^+]/gm) || []).length;
+        const removedLines = (diff.match(/^-[^-]/gm) || []).length;
+
+        // 6. Check if all files exist (for modification patches)
+        const isNewFile = diff.includes('--- /dev/null');
+        const allFilesExist = fileChecks.every(f => f.exists) || isNewFile;
+        const missingFiles = fileChecks.filter(f => !f.exists && !isNewFile);
+
+        console.log(`✅ Dry-run complete: ${targetFiles.length} files, ${hunkCount} hunks, +${addedLines}/-${removedLines} lines`);
+
+        res.json({
+            ok: true,
+            valid: true,
+            canApply: allFilesExist,
+            wouldModify: targetFiles,
+            hunksCount: hunkCount,
+            changes: {
+                addedLines,
+                removedLines,
+                netChange: addedLines - removedLines
+            },
+            fileChecks,
+            missingFiles: missingFiles.map(f => f.path),
+            isNewFile,
+            warnings: missingFiles.length > 0 ? [`${missingFiles.length} file(s) not found in workspace`] : []
+        });
+    } catch (err) {
+        console.error(`❌ Dry-run error: ${err.message}`);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * DELETE /workspace/backups/:backupId
+ * Deletes a specific backup
+ */
+app.delete("/workspace/backups/:backupId", (req, res) => {
+    const { backupId } = req.params;
+
+    if (!BACKUPS.has(backupId)) {
+        return res.status(404).json({
+            error: "backup not found",
+            availableBackups: Array.from(BACKUPS.keys())
+        });
+    }
+
+    const backup = BACKUPS.get(backupId);
+    BACKUPS.delete(backupId);
+
+    console.log(`🗑️ Backup deleted: ${backupId}`);
+
+    res.json({
+        ok: true,
+        deleted: backupId,
+        deletedFiles: backup.files.map(f => f.path)
+    });
+});
+
+// ============================================
+// 🆕 DETECT PORT ENDPOINT (Sprint 1.2)
+// Multi-language, multi-framework port detection
+// ============================================
+
+/**
+ * GET /workspace/detect-port
+ * Detects port from service configuration files
+ * Supports: Java (Spring Boot), Node.js, Python, .NET, Go, Ruby
+ *
+ * Query params:
+ * - servicePath: relative path to service (optional, defaults to workspace root)
+ * - language: java, node, python, dotnet, go, ruby (optional, auto-detect)
+ * - framework: spring-boot, express, flask, fastapi, etc (optional)
+ */
+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;
+
+    try {
+        const fullPath = servicePath ? path.join(WORKSPACE_ROOT, servicePath) : WORKSPACE_ROOT;
+        console.log(`🔍 Detecting port for service at: ${fullPath}`);
+
+        let port = null;
+        let detectionMethod = null;
+        let detectedLanguage = language;
+
+        // Auto-detect language if not provided
+        if (!detectedLanguage) {
+            const meta = await detectProject(fullPath);
+            detectedLanguage = meta.language;
+        }
+
+        // Detect port based on language/framework
+        if (detectedLanguage === 'java') {
+            const result = await detectSpringBootPortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (['node', 'javascript', 'typescript'].includes(detectedLanguage)) {
+            const result = await detectNodePortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'python') {
+            const result = await detectPythonPortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (['dotnet', 'csharp'].includes(detectedLanguage)) {
+            const result = await detectDotNetPortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'go') {
+            const result = await detectGoPortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else if (detectedLanguage === 'ruby') {
+            const result = await detectRubyPortLocal(fullPath);
+            port = result.port;
+            detectionMethod = result.method;
+        } else {
+            // Fallback to global detection
+            port = await detectPort(fullPath);
+            detectionMethod = 'global-detection';
+        }
+
+        console.log(`✅ Detected port: ${port || 'default'} via ${detectionMethod}`);
+
+        res.json({
+            ok: true,
+            port,
+            language: detectedLanguage,
+            framework: framework || null,
+            detectionMethod,
+            servicePath: servicePath || '/',
+            workspaceRoot: WORKSPACE_ROOT
+        });
+    } catch (err) {
+        console.error('❌ Error detecting port:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+// ============================================
+// PORT DETECTION HELPER FUNCTIONS
+// ============================================
+
+/**
+ * Detects Spring Boot port from configuration files
+ */
+async function detectSpringBootPortLocal(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, 'src/main/resources/application-local.yml'),
+        path.join(servicePath, 'src/main/resources/application-local.yaml'),
+        path.join(servicePath, 'src/main/resources/application-local.properties'),
+        path.join(servicePath, 'src/main/resources/application-dev.yml'),
+        path.join(servicePath, 'src/main/resources/application-dev.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)) {
+            try {
+                const content = await readFile(filePath, 'utf8');
+
+                // YAML format - multiple patterns
+                if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+                    // Pattern: server:\n  port: 8090
+                    const simpleMatch = content.match(/server:\s*\n\s+port:\s*(\d+)/);
+                    if (simpleMatch) {
+                        return { port: parseInt(simpleMatch[1]), method: `yaml:${path.basename(filePath)}` };
+                    }
+
+                    // Pattern: ${PORT:8080} or ${SERVER_PORT:8080}
+                    const envMatch = content.match(/port:\s*\$\{[A-Z_]+:(\d+)\}/);
+                    if (envMatch) {
+                        return { port: parseInt(envMatch[1]), method: `yaml-env-default:${path.basename(filePath)}` };
+                    }
+
+                    // Pattern: port: 8090 (simple)
+                    const directMatch = content.match(/^\s*port:\s*(\d+)/m);
+                    if (directMatch) {
+                        return { port: parseInt(directMatch[1]), method: `yaml-direct:${path.basename(filePath)}` };
+                    }
+                }
+
+                // Properties format
+                if (filePath.endsWith('.properties')) {
+                    const match = content.match(/server\.port\s*=\s*(\d+)/);
+                    if (match) {
+                        return { port: parseInt(match[1]), method: `properties:${path.basename(filePath)}` };
+                    }
+
+                    // ${PORT:8080} pattern
+                    const envMatch = content.match(/server\.port\s*=\s*\$\{[A-Z_]+:(\d+)\}/);
+                    if (envMatch) {
+                        return { port: parseInt(envMatch[1]), method: `properties-env-default:${path.basename(filePath)}` };
+                    }
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 8080, method: 'spring-boot-default' };
+}
+
+/**
+ * Detects Node.js port from configuration files
+ */
+async function detectNodePortLocal(servicePath) {
+    // Priority 1: .env files
+    const envFiles = ['.env.local', '.env.development', '.env'];
+    for (const envFile of envFiles) {
+        const envPath = path.join(servicePath, envFile);
+        if (await exists(envPath)) {
+            try {
+                const content = await readFile(envPath, 'utf8');
+                const match = content.match(/^PORT\s*=\s*(\d+)/mi);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `dotenv:${envFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    // Priority 2: package.json scripts
+    const pkgPath = path.join(servicePath, 'package.json');
+    if (await exists(pkgPath)) {
+        try {
+            const content = await readFile(pkgPath, 'utf8');
+            const pkg = JSON.parse(content);
+            const scripts = JSON.stringify(pkg.scripts || {});
+
+            // Patterns: --port 3000, --port=3000, PORT=3000, -p 3000
+            const match = scripts.match(/--port[=\s]+(\d+)|PORT[=\s]+(\d+)|-p\s+(\d+)/i);
+            if (match) {
+                const port = parseInt(match[1] || match[2] || match[3]);
+                return { port, method: 'package-json-scripts' };
+            }
+
+            // Check for port in config
+            if (pkg.config?.port) {
+                return { port: parseInt(pkg.config.port), method: 'package-json-config' };
+            }
+        } catch (e) {
+            // Continue to default
+        }
+    }
+
+    // Priority 3: Check for common config files
+    const configFiles = ['config.json', 'config/default.json', '.env.example'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(servicePath, configFile);
+        if (await exists(configPath)) {
+            try {
+                const content = await readFile(configPath, 'utf8');
+                const match = content.match(/["']?port["']?\s*[=:]\s*(\d+)/i);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `config:${configFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 3000, method: 'node-default' };
+}
+
+/**
+ * Detects Python port from configuration files
+ */
+async function detectPythonPortLocal(servicePath) {
+    // Priority 1: .env files
+    const envFiles = ['.env', '.env.local', '.env.development'];
+    for (const envFile of envFiles) {
+        const envPath = path.join(servicePath, envFile);
+        if (await exists(envPath)) {
+            try {
+                const content = await readFile(envPath, 'utf8');
+                const match = content.match(/^PORT\s*=\s*(\d+)/mi);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `dotenv:${envFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    // Priority 2: Python config files
+    const configFiles = [
+        'config.py', 'settings.py', 'app/config.py', 'src/config.py',
+        'config/settings.py', 'core/settings.py'
+    ];
+    for (const configFile of configFiles) {
+        const configPath = path.join(servicePath, configFile);
+        if (await exists(configPath)) {
+            try {
+                const content = await readFile(configPath, 'utf8');
+                const match = content.match(/PORT\s*=\s*(\d+)/i);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `python-config:${configFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    // Priority 3: Check for Dockerfile with EXPOSE
+    const dockerfilePath = path.join(servicePath, 'Dockerfile');
+    if (await exists(dockerfilePath)) {
+        try {
+            const content = await readFile(dockerfilePath, 'utf8');
+            const match = content.match(/EXPOSE\s+(\d+)/);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dockerfile-expose' };
+            }
+        } catch (e) {
+            // Continue to default
+        }
+    }
+
+    return { port: 8000, method: 'python-default' };
+}
+
+/**
+ * Detects .NET port from launchSettings.json
+ */
+async function detectDotNetPortLocal(servicePath) {
+    // Priority 1: launchSettings.json
+    const launchSettings = path.join(servicePath, 'Properties/launchSettings.json');
+    if (await exists(launchSettings)) {
+        try {
+            const content = await readFile(launchSettings, 'utf8');
+            const settings = JSON.parse(content);
+
+            const profiles = settings.profiles || {};
+            for (const [profileName, profile] of Object.entries(profiles)) {
+                if (profile.applicationUrl) {
+                    const match = profile.applicationUrl.match(/:(\d+)/);
+                    if (match) {
+                        return { port: parseInt(match[1]), method: `launchSettings:${profileName}` };
+                    }
+                }
+            }
+        } catch (e) {
+            // Continue to next method
+        }
+    }
+
+    // Priority 2: appsettings.json
+    const appSettingsFiles = ['appsettings.Development.json', 'appsettings.json'];
+    for (const settingsFile of appSettingsFiles) {
+        const appSettings = path.join(servicePath, settingsFile);
+        if (await exists(appSettings)) {
+            try {
+                const content = await readFile(appSettings, 'utf8');
+                const settings = JSON.parse(content);
+
+                if (settings.Kestrel?.Endpoints?.Http?.Url) {
+                    const match = settings.Kestrel.Endpoints.Http.Url.match(/:(\d+)/);
+                    if (match) {
+                        return { port: parseInt(match[1]), method: `appsettings:${settingsFile}` };
+                    }
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 5000, method: 'dotnet-default' };
+}
+
+/**
+ * Detects Go port from configuration
+ */
+async function detectGoPortLocal(servicePath) {
+    // Priority 1: .env files
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        try {
+            const content = await readFile(envPath, 'utf8');
+            const match = content.match(/^PORT\s*=\s*(\d+)/mi);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dotenv' };
+            }
+        } catch (e) {
+            // Continue
+        }
+    }
+
+    // Priority 2: config.yaml/config.json
+    const configFiles = ['config.yaml', 'config.yml', 'config.json', 'configs/config.yaml'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(servicePath, configFile);
+        if (await exists(configPath)) {
+            try {
+                const content = await readFile(configPath, 'utf8');
+                const match = content.match(/port['"]*\s*[=:]\s*['"]*(\d+)/i);
+                if (match) {
+                    return { port: parseInt(match[1]), method: `config:${configFile}` };
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+
+    return { port: 8080, method: 'go-default' };
+}
+
+/**
+ * Detects Ruby/Rails port from configuration
+ */
+async function detectRubyPortLocal(servicePath) {
+    // Priority 1: .env
+    const envPath = path.join(servicePath, '.env');
+    if (await exists(envPath)) {
+        try {
+            const content = await readFile(envPath, 'utf8');
+            const match = content.match(/^PORT\s*=\s*(\d+)/mi);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'dotenv' };
+            }
+        } catch (e) {
+            // Continue
+        }
+    }
+
+    // Priority 2: Puma config
+    const pumaConfig = path.join(servicePath, 'config/puma.rb');
+    if (await exists(pumaConfig)) {
+        try {
+            const content = await readFile(pumaConfig, 'utf8');
+            const match = content.match(/port\s+(\d+)/i);
+            if (match) {
+                return { port: parseInt(match[1]), method: 'puma-config' };
+            }
+        } catch (e) {
+            // Continue
+        }
+    }
+
+    return { port: 3000, method: 'ruby-default' };
+}
+
+// ============================================
+// HELPER FUNCTIONS (if not already present)
+// ============================================
+
+/**
+ * Helper: Extract target files from diff
+ * (Add only if not already present in server-local.js)
+ */
+function extractTargetFiles(diff) {
+    const files = [];
+    const lines = diff.split('\n');
+
+    for (const line of lines) {
+        if (line.startsWith('+++ ')) {
+            let filePath = line.substring(4).trim();
+            // Remove prefixes like b/ or ./
+            filePath = filePath.replace(/^[ab]\//, '').replace(/^\.\//,'');
+            if (filePath && filePath !== '/dev/null') {
+                files.push(filePath);
+            }
+        }
+    }
+
+    return files;
+}