deepdebug-local-agent 1.0.23 → 1.2.0

package/src/ports.js

@@ -18,10 +18,10 @@ export async function detectPort(root) {
                 const content = await readFile(full, "utf8");
                 const doc = yaml.load(content);
 
-                // Tentar pegar do objeto parseado
+                // Try to read it from the parsed object
                 let port = doc?.server?.port ?? doc?.SERVER?.PORT;
 
-                // Se for string com ${PORT:8090}, extrair o valor padrão
+                // If it is a string like ${PORT:8090}, extract the default value
                 if (typeof port === 'string') {
                     const match = port.match(/\$\{PORT:(\d+)\}/);
                     if (match) port = match[1];
@@ -43,7 +43,7 @@ export async function detectPort(root) {
                 const props = PropertiesReader(full);
                 let port = props.get("server.port");
 
-                // Se for string com ${PORT:8090}, extrair o valor padrão
+                // If it is a string like ${PORT:8090}, extract the default value
                 if (typeof port === 'string') {
                     const match = port.match(/\$\{PORT:(\d+)\}/);
                     if (match) port = match[1];
@@ -54,7 +54,7 @@ export async function detectPort(root) {
         }
     }
 
-    // Node (com .env padrão)
+    // Node (with default .env)
     const envCandidates = [".env", "src/.env"];
     for (const rel of envCandidates) {
         const full = path.join(root, rel);

package/src/routes/workspace.route.js

@@ -5,7 +5,7 @@ import os from "os";
 
 const router = express.Router();
 
-// 🔹 Caminho global do workspace (inicializado com fallback padrão)
+// 🔹 Global workspace path (initialized with a default fallback)
 // ✅ FIX: Read WORKSPACE_ROOT (set by install.js Docker) OR WORKSPACE_BASE (legacy)
 let workspacePath =
     process.env.WORKSPACE_ROOT ||
@@ -89,7 +89,7 @@ function translateToDockerPath(hostPath) {
 
 // --------------------------------------------------
 // 🧩 1️⃣ GET /workspace/info
-// Retorna informações sobre o workspace atual
+// Returns information about the current workspace
 // --------------------------------------------------
 router.get("/info", async (req, res) => {
     try {
@@ -199,11 +199,22 @@ async function ensureRepoCloned(repoUrl, token, branch = 'main') {
         // Fresh clone
         console.log(`📂 [git] Cloning ${repoUrl} (branch: ${branch})...`);
 
-        const result = execAsync(
+        let result = execAsync(
             `git clone --branch ${branch} --single-branch --depth 50 "${authUrl}" "${clonePath}"`,
             { timeout: 180000 }  // 3 minutes for large repos
         );
 
+        if (result.exitCode !== 0 && /could not find remote branch/i.test(result.stderr || '')) {
+            // Requested branch may not exist (repo uses master, caller assumed main):
+            // fall back to the repo's default branch instead of failing the session.
+            console.warn(`⚠️ [git] Branch '${branch}' not found — falling back to the repo default branch`);
+            execAsync(`rm -rf "${clonePath}"`);
+            result = execAsync(
+                `git clone --single-branch --depth 50 "${authUrl}" "${clonePath}"`,
+                { timeout: 180000 }
+            );
+        }
+
         if (result.exitCode !== 0) {
             throw new Error(`Git clone failed: ${result.stderr}`);
         }
@@ -225,6 +236,18 @@ async function ensureRepoCloned(repoUrl, token, branch = 'main') {
 
 router.post("/open", async (req, res) => {
     try {
+        // ==========================================
+        // Input validation and sanitization
+        // ==========================================
+        if (!req.body || typeof req.body !== 'object') {
+            console.error(`❌ [/workspace/open] Invalid request body:`, req.body);
+            return res.status(400).json({ 
+                ok: false,
+                error: "Invalid request body - expected JSON object" 
+            });
+        }
+
+        // Now safe to destructure
         const { root, workspacePath: wpPath, repoUrl, token, branch = 'main' } = req.body;
 
         // ==========================================
@@ -272,7 +295,10 @@ router.post("/open", async (req, res) => {
         const requestedPath = root || wpPath;
 
         if (!requestedPath) {
-            return res.status(400).json({ error: "Missing 'root', 'workspacePath', or 'repoUrl' in body" });
+            return res.status(400).json({ 
+                ok: false,
+                error: "Missing 'root', 'workspacePath', or 'repoUrl' in body" 
+            });
         }
 
         // Translate host path to docker path if needed
@@ -301,6 +327,7 @@ router.post("/open", async (req, res) => {
 
                 console.error(`❌ [/workspace/open] Directory not found: ${resolvedPath}`);
                 return res.status(400).json({
+                    ok: false,
                     error: `Directory not found: ${resolvedPath}`,
                     requestedPath, resolvedPath,
                     availableProjects: availableDirs,
@@ -329,14 +356,18 @@ router.post("/open", async (req, res) => {
             port: null
         });
     } catch (err) {
-        console.error("❌ [/workspace/open] Error:", err);
-        return res.status(500).json({ error: err.message });
+        console.error("❌ [/workspace/open] Unexpected error:", err);
+        return res.status(500).json({ 
+            ok: false,
+            error: err.message || "Internal server error",
+            stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
+        });
     }
 });
 
 // --------------------------------------------------
 // 🧩 2️⃣ POST /workspace
-// Atualiza o diretório de workspace selecionado pelo usuário
+// Updates the workspace directory selected by the user
 // (legacy endpoint - kept for backward compatibility)
 // --------------------------------------------------
 router.post("/", async (req, res) => {
@@ -370,7 +401,7 @@ router.post("/", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 3️⃣ GET /workspace/files
-// Lista arquivos .java (até 3 níveis de profundidade)
+// Lists .java files (up to 3 levels deep)
 // --------------------------------------------------
 router.get("/files", async (req, res) => {
     try {
@@ -421,7 +452,7 @@ router.get("/files", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 4️⃣ GET /workspace/file
-// Lê o conteúdo de um arquivo específico dentro do workspace
+// Reads the content of a specific file inside the workspace
 // --------------------------------------------------
 router.get("/file", async (req, res) => {
     try {
@@ -431,7 +462,7 @@ router.get("/file", async (req, res) => {
             return res.status(400).json({ error: "Missing 'path' query parameter" });
         }
 
-        // 🔹 Corrige o caminho caso venha relativo (ex: "src/...") ou com prefixo incorreto
+        // 🔹 Fix the path if it comes in relative (e.g. "src/...") or with an incorrect prefix
         let fullPath = requestedPath;
 
         if (!path.isAbsolute(requestedPath) || !requestedPath.startsWith(workspacePath)) {
@@ -470,7 +501,7 @@ router.get("/file", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 5️⃣ POST /workspace/resolve
-// Resolve caminho relativo a absoluto (para exibição no frontend)
+// Resolves a relative path to an absolute one (for display in the frontend)
 // --------------------------------------------------
 router.post("/resolve", async (req, res) => {
     try {
@@ -498,7 +529,7 @@ router.post("/resolve", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 6️⃣ GET /workspace/detect
-// Detecta tipo de projeto (Maven / Gradle / Outro)
+// Detects the project type (Maven / Gradle / Other)
 // --------------------------------------------------
 router.get("/detect", async (req, res) => {
     try {
@@ -526,7 +557,7 @@ router.get("/detect", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 7️⃣ GET /workspace/search-file
-// Busca um arquivo pelo nome dentro do workspace
+// Searches for a file by name inside the workspace
 // --------------------------------------------------
 router.get("/search-file", async (req, res) => {
     try {
@@ -590,7 +621,7 @@ router.get("/search-file", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 8️⃣ POST /workspace/search
-// Busca por conteúdo dentro dos arquivos do workspace
+// Searches for content inside the workspace files
 // --------------------------------------------------
 router.post("/search", async (req, res) => {
     try {
@@ -654,7 +685,7 @@ router.post("/search", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 9️⃣ GET /workspace/scan
-// Lista TODOS os arquivos do workspace (para list_files tool)
+// Lists ALL workspace files (for the list_files tool)
 // --------------------------------------------------
 router.get("/scan", async (req, res) => {
     try {
@@ -718,7 +749,7 @@ router.get("/scan", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 🔟 GET /workspace/file-content
-// Alias para /workspace/file (compatibilidade com código Java)
+// Alias for /workspace/file (compatibility with Java code)
 // --------------------------------------------------
 router.get("/file-content", async (req, res) => {
     try {

package/src/runtimes/base-runtime.js

@@ -1,8 +1,8 @@
 /**
  * BaseRuntime
  *
- * Interface abstrata para todos os runtimes de linguagem.
- * Cada linguagem (Java, Node, Python, etc.) deve implementar esta interface.
+ * Abstract interface for all language runtimes.
+ * Each language (Java, Node, Python, etc.) must implement this interface.
  *
  * @abstract
  */
@@ -19,32 +19,32 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Identificador único do runtime
-     * @returns {string} Ex: 'java-maven', 'node-npm', 'python-pip'
+     * Unique identifier of the runtime
+     * @returns {string} e.g.: 'java-maven', 'node-npm', 'python-pip'
      */
     getId() {
         throw new Error('Method getId() must be implemented');
     }
 
     /**
-     * Nome amigável do runtime
-     * @returns {string} Ex: 'Java (Maven)', 'Node.js (npm)'
+     * Friendly name of the runtime
+     * @returns {string} e.g.: 'Java (Maven)', 'Node.js (npm)'
      */
     getName() {
         throw new Error('Method getName() must be implemented');
     }
 
     /**
-     * Linguagem do runtime
-     * @returns {string} Ex: 'java', 'node', 'python', 'dotnet', 'go'
+     * Language of the runtime
+     * @returns {string} e.g.: 'java', 'node', 'python', 'dotnet', 'go'
      */
     getLanguage() {
         throw new Error('Method getLanguage() must be implemented');
     }
 
     /**
-     * Build tool usado
-     * @returns {string} Ex: 'maven', 'gradle', 'npm', 'yarn', 'pip'
+     * Build tool used
+     * @returns {string} e.g.: 'maven', 'gradle', 'npm', 'yarn', 'pip'
      */
     getBuildTool() {
         throw new Error('Method getBuildTool() must be implemented');
@@ -55,16 +55,16 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Arquivos marcadores que indicam este runtime
-     * @returns {string[]} Ex: ['pom.xml'], ['package.json']
+     * Marker files that indicate this runtime
+     * @returns {string[]} e.g.: ['pom.xml'], ['package.json']
      */
     getMarkerFiles() {
         throw new Error('Method getMarkerFiles() must be implemented');
     }
 
     /**
-     * Verifica se este runtime é compatível com o workspace
-     * @param {string} workspacePath - Caminho do workspace
+     * Checks whether this runtime is compatible with the workspace
+     * @param {string} workspacePath - Workspace path
      * @returns {Promise<boolean>}
      */
     async isCompatible(workspacePath) {
@@ -72,8 +72,8 @@ export class BaseRuntime {
     }
 
     /**
-     * Detecta informações do projeto
-     * @param {string} workspacePath - Caminho do workspace
+     * Detects project information
+     * @param {string} workspacePath - Workspace path
      * @returns {Promise<ProjectInfo>}
      */
     async detectProject(workspacePath) {
@@ -85,9 +85,9 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Instala dependências do projeto
-     * @param {string} workspacePath - Caminho do workspace
-     * @param {object} options - Opções adicionais
+     * Installs the project dependencies
+     * @param {string} workspacePath - Workspace path
+     * @param {object} options - Additional options
      * @returns {Promise<CommandResult>}
      */
     async install(workspacePath, options = {}) {
@@ -95,9 +95,9 @@ export class BaseRuntime {
     }
 
     /**
-     * Compila o projeto
-     * @param {string} workspacePath - Caminho do workspace
-     * @param {object} options - Opções adicionais
+     * Compiles the project
+     * @param {string} workspacePath - Workspace path
+     * @param {object} options - Additional options
      * @returns {Promise<CommandResult>}
      */
     async build(workspacePath, options = {}) {
@@ -105,8 +105,8 @@ export class BaseRuntime {
     }
 
     /**
-     * Retorna o comando para iniciar o serviço
-     * @param {object} options - Opções (port, profile, etc.)
+     * Returns the command to start the service
+     * @param {object} options - Options (port, profile, etc.)
      * @returns {StartCommand} { cmd: string, args: string[], env?: object }
      */
     getStartCommand(options = {}) {
@@ -114,7 +114,7 @@ export class BaseRuntime {
     }
 
     /**
-     * Padrão regex para detectar quando o serviço está pronto
+     * Regex pattern to detect when the service is ready
      * @returns {RegExp}
      */
     getReadyPattern() {
@@ -122,7 +122,7 @@ export class BaseRuntime {
     }
 
     /**
-     * Porta padrão do framework
+     * Default port of the framework
      * @returns {number}
      */
     getDefaultPort() {
@@ -130,8 +130,8 @@ export class BaseRuntime {
     }
 
     /**
-     * Detecta a porta configurada no projeto
-     * @param {string} workspacePath - Caminho do workspace
+     * Detects the port configured in the project
+     * @param {string} workspacePath - Workspace path
      * @returns {Promise<number|null>}
      */
     async detectPort(workspacePath) {
@@ -143,9 +143,9 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Executa testes do projeto
-     * @param {string} workspacePath - Caminho do workspace
-     * @param {object} options - Opções (testFile, coverage, etc.)
+     * Runs the project tests
+     * @param {string} workspacePath - Workspace path
+     * @param {object} options - Options (testFile, coverage, etc.)
      * @returns {Promise<TestResult>}
      */
     async test(workspacePath, options = {}) {
@@ -153,9 +153,9 @@ export class BaseRuntime {
     }
 
     /**
-     * Executa um teste específico
-     * @param {string} workspacePath - Caminho do workspace
-     * @param {string} testFile - Arquivo de teste
+     * Runs a specific test
+     * @param {string} workspacePath - Workspace path
+     * @param {string} testFile - Test file
      * @returns {Promise<TestResult>}
      */
     async testSingle(workspacePath, testFile) {
@@ -167,16 +167,16 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Extensões de arquivo suportadas
-     * @returns {string[]} Ex: ['.java'], ['.js', '.ts']
+     * Supported file extensions
+     * @returns {string[]} e.g.: ['.java'], ['.js', '.ts']
      */
     getFileExtensions() {
         throw new Error('Method getFileExtensions() must be implemented');
     }
 
     /**
-     * Encontra integrações HTTP no código
-     * @param {string} workspacePath - Caminho do workspace
+     * Finds HTTP integrations in the code
+     * @param {string} workspacePath - Workspace path
      * @returns {Promise<Integration[]>}
      */
     async findIntegrations(workspacePath) {
@@ -184,9 +184,9 @@ export class BaseRuntime {
     }
 
     /**
-     * Analisa imports/dependências de um arquivo
-     * @param {string} filePath - Caminho do arquivo
-     * @param {string} content - Conteúdo do arquivo
+     * Analyzes the imports/dependencies of a file
+     * @param {string} filePath - File path
+     * @param {string} content - File content
      * @returns {Promise<Dependency[]>}
      */
     async analyzeImports(filePath, content) {
@@ -198,8 +198,8 @@ export class BaseRuntime {
     // ==========================================
 
     /**
-     * Valida se um diff é aplicável
-     * @param {string} workspacePath - Caminho do workspace
+     * Validates whether a diff is applicable
+     * @param {string} workspacePath - Workspace path
      * @param {string} diff - Unified diff
      * @returns {Promise<ValidationResult>}
      */
@@ -208,13 +208,13 @@ export class BaseRuntime {
     }
 
     /**
-     * Ações pós-patch (ex: reformatar código)
-     * @param {string} workspacePath - Caminho do workspace
-     * @param {string[]} modifiedFiles - Arquivos modificados
+     * Post-patch actions (e.g.: reformat code)
+     * @param {string} workspacePath - Workspace path
+     * @param {string[]} modifiedFiles - Modified files
      * @returns {Promise<void>}
      */
     async postPatchActions(workspacePath, modifiedFiles) {
-        // Override nas implementações específicas
+        // Override in the specific implementations
     }
 }
 
@@ -224,12 +224,12 @@ export class BaseRuntime {
 
 /**
  * @typedef {object} ProjectInfo
- * @property {string} name - Nome do projeto
- * @property {string} version - Versão
- * @property {string} language - Linguagem
- * @property {string} framework - Framework detectado
+ * @property {string} name - Project name
+ * @property {string} version - Version
+ * @property {string} language - Language
+ * @property {string} framework - Detected framework
  * @property {string} buildTool - Build tool
- * @property {number} port - Porta configurada
+ * @property {number} port - Configured port
  */
 
 /**
@@ -237,54 +237,54 @@ export class BaseRuntime {
  * @property {number} code - Exit code
  * @property {string} stdout - Standard output
  * @property {string} stderr - Standard error
- * @property {number} duration - Duração em ms
+ * @property {number} duration - Duration in ms
  */
 
 /**
  * @typedef {object} StartCommand
- * @property {string} cmd - Comando
- * @property {string[]} args - Argumentos
- * @property {object} [env] - Variáveis de ambiente adicionais
+ * @property {string} cmd - Command
+ * @property {string[]} args - Arguments
+ * @property {object} [env] - Additional environment variables
  */
 
 /**
  * @typedef {object} TestResult
- * @property {boolean} success - Se todos os testes passaram
- * @property {number} passed - Número de testes que passaram
- * @property {number} failed - Número de testes que falharam
- * @property {number} skipped - Número de testes ignorados
- * @property {number} duration - Duração em ms
- * @property {string} output - Output completo
- * @property {TestFailure[]} failures - Lista de falhas
+ * @property {boolean} success - Whether all tests passed
+ * @property {number} passed - Number of tests that passed
+ * @property {number} failed - Number of tests that failed
+ * @property {number} skipped - Number of skipped tests
+ * @property {number} duration - Duration in ms
+ * @property {string} output - Full output
+ * @property {TestFailure[]} failures - List of failures
  */
 
 /**
  * @typedef {object} TestFailure
- * @property {string} testName - Nome do teste
- * @property {string} message - Mensagem de erro
+ * @property {string} testName - Test name
+ * @property {string} message - Error message
  * @property {string} stackTrace - Stack trace
  */
 
 /**
  * @typedef {object} Integration
- * @property {string} type - Tipo (rest-templates, feign, axios, etc.)
- * @property {string} file - Arquivo onde foi encontrado
- * @property {number} line - Linha
- * @property {string} targetUrl - URL alvo (se detectável)
- * @property {string} method - Método HTTP (se detectável)
+ * @property {string} type - Type (rest-templates, feign, axios, etc.)
+ * @property {string} file - File where it was found
+ * @property {number} line - Line
+ * @property {string} targetUrl - Target URL (if detectable)
+ * @property {string} method - HTTP method (if detectable)
  */
 
 /**
  * @typedef {object} Dependency
- * @property {string} name - Nome da dependência
- * @property {string} type - Tipo (import, require, using)
- * @property {boolean} isExternal - Se é externa ao projeto
+ * @property {string} name - Dependency name
+ * @property {string} type - Type (import, require, using)
+ * @property {boolean} isExternal - Whether it is external to the project
  */
 
 /**
  * @typedef {object} ValidationResult
- * @property {boolean} valid - Se o patch é válido
- * @property {string[]} errors - Lista de erros
+ * @property {boolean} valid - Whether the patch is valid
+ * @property {string[]} errors - List of errors
  */
 
 export default BaseRuntime;

package/src/runtimes/java/gradle-runtime.js

@@ -6,15 +6,15 @@ import { run } from '../../utils/exec-utils.js';
 /**
  * GradleRuntime
  *
- * Runtime para projetos Java com Gradle.
- * Suporta Spring Boot, Quarkus, e projetos Gradle genéricos.
+ * Runtime for Java projects using Gradle.
+ * Supports Spring Boot, Quarkus, and generic Gradle projects.
  */
 export class GradleRuntime extends BaseRuntime {
 
     constructor() {
         super();
         this.framework = null;
-        this.useWrapper = true; // Usar ./gradlew por padrão
+        this.useWrapper = true; // Use ./gradlew by default
     }
 
     // ==========================================
@@ -64,11 +64,11 @@ export class GradleRuntime extends BaseRuntime {
             buildContent = await readFile(kotlinPath, 'utf8');
         }
 
-        // Verificar se existe wrapper
+        // Check whether a wrapper exists
         const wrapperPath = path.join(workspacePath, 'gradlew');
         this.useWrapper = await exists(wrapperPath);
 
-        // Detectar nome do projeto
+        // Detect the project name
         const settingsPath = path.join(workspacePath, 'settings.gradle');
         const settingsKtsPath = path.join(workspacePath, 'settings.gradle.kts');
         let name = path.basename(workspacePath);
@@ -83,15 +83,15 @@ export class GradleRuntime extends BaseRuntime {
             if (match) name = match[1];
         }
 
-        // Detectar versão
+        // Detect the version
         const versionMatch = buildContent.match(/version\s*=?\s*['"]([^'"]+)['"]/);
         const version = versionMatch ? versionMatch[1] : '0.0.1';
 
-        // Detectar framework
+        // Detect the framework
         const framework = this.detectFramework(buildContent);
         this.framework = framework;
 
-        // Detectar porta
+        // Detect the port
         const port = await this.detectPort(workspacePath);
 
         return {
@@ -207,7 +207,7 @@ export class GradleRuntime extends BaseRuntime {
     }
 
     async detectPort(workspacePath) {
-        // Mesma lógica do Maven - configs são iguais
+        // Same logic as Maven - the configs are identical
         const propsPath = path.join(workspacePath, 'src/main/resources/application.properties');
         if (await exists(propsPath)) {
             const content = await readFile(propsPath, 'utf8');
@@ -233,10 +233,10 @@ export class GradleRuntime extends BaseRuntime {
         const startTime = Date.now();
         const cmd = this.getGradleCommand();
 
-        // Clean primeiro
+        // Clean first
         await run(cmd, ['clean', '--quiet'], workspacePath);
 
-        // Rodar testes
+        // Run the tests
         const result = await run(cmd, ['test', '--quiet'], workspacePath);
 
         const testResult = this.parseTestOutput(result, workspacePath);
@@ -249,7 +249,7 @@ export class GradleRuntime extends BaseRuntime {
         const startTime = Date.now();
         const cmd = this.getGradleCommand();
 
-        // Extrair nome da classe
+        // Extract the class name
         const className = path.basename(testFile, '.java');
 
         const result = await run(cmd, [
@@ -268,10 +268,10 @@ export class GradleRuntime extends BaseRuntime {
     async parseTestOutput(result, workspacePath) {
         const output = result.stdout + result.stderr;
 
-        // Tentar ler relatório XML do Gradle se disponível
+        // Try to read the Gradle XML report if available
         const reportDir = path.join(workspacePath, 'build/test-results/test');
 
-        // Parse básico do output
+        // Basic parsing of the output
         let passed = 0;
         let failed = 0;
         let skipped = 0;
@@ -303,7 +303,7 @@ export class GradleRuntime extends BaseRuntime {
     extractFailures(output) {
         const failures = [];
 
-        // Gradle mostra falhas com formato específico
+        // Gradle shows failures in a specific format
         const failureRegex = /(\w+Test)\s+>\s+(\w+).*FAILED/g;
         let match;
 
@@ -323,7 +323,7 @@ export class GradleRuntime extends BaseRuntime {
     // ==========================================
 
     getFileExtensions() {
-        return ['.java', '.kt']; // Suporte a Kotlin também
+        return ['.java', '.kt']; // Kotlin support as well
     }
 
     async findIntegrations(workspacePath) {
@@ -333,7 +333,7 @@ export class GradleRuntime extends BaseRuntime {
     }
 
     async analyzeImports(filePath, content) {
-        // Mesma lógica do Maven
+        // Same logic as Maven
         const imports = [];
         const importRegex = /import\s+(static\s+)?([a-zA-Z0-9_.]+)(?:\.\*)?;/g;