deepdebug-local-agent 1.0.23 → 1.1.0

package/src/workspace/process-manager.js

@@ -7,13 +7,13 @@ import path from "path";
 /**
  * ProcessManager
  *
- * Gerencia ciclo de vida de processos (start, stop, restart)
- * Monitora CPU, Memory, Uptime
- * Captura logs em tempo real
+ * Manages the process lifecycle (start, stop, restart)
+ * Monitors CPU, Memory, Uptime
+ * Captures logs in real time
  *
- * UNIFIED VERSION: Aceita AMBOS os formatos:
- * 1. command/args direto (novo)
- * 2. language/framework/buildTool (legado)
+ * UNIFIED VERSION: Accepts BOTH formats:
+ * 1. command/args directly (new)
+ * 2. language/framework/buildTool (legacy)
  */
 export class ProcessManager extends EventEmitter {
     constructor() {
@@ -22,7 +22,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Verifica se um serviço está rodando
+     * Checks whether a service is running
      */
     isRunning(serviceId) {
         const processData = this.processes.get(serviceId);
@@ -30,11 +30,11 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Inicia um serviço
+     * Starts a service
      *
-     * ACEITA DOIS FORMATOS:
-     * 1. { command, args, cwd, port, env } - Novo formato direto
-     * 2. { language, framework, buildTool, cwd, port, profile } - Formato legado
+     * ACCEPTS TWO FORMATS:
+     * 1. { command, args, cwd, port, env } - New direct format
+     * 2. { language, framework, buildTool, cwd, port, profile } - Legacy format
      */
     async start(serviceId, config) {
         const {
@@ -45,7 +45,7 @@ export class ProcessManager extends EventEmitter {
             language,
             framework,
             buildTool,
-            // Comum
+            // Common
             cwd,
             port,
             profile,
@@ -53,23 +53,23 @@ export class ProcessManager extends EventEmitter {
             envVars = {}
         } = config;
 
-        // Se já estiver rodando, parar primeiro
+        // If it is already running, stop it first
         if (this.processes.has(serviceId)) {
             console.log(`⚠️ Service ${serviceId} already running, stopping first...`);
             await this.stop(serviceId);
             await new Promise(resolve => setTimeout(resolve, 1000));
         }
 
-        // Determinar comando a usar
+        // Determine which command to use
         let cmd, cmdArgs;
 
         if (command && args) {
-            // NOVO FORMATO: command/args passados diretamente
+            // NEW FORMAT: command/args passed directly
             cmd = command;
             cmdArgs = args;
             console.log(`🚀 Starting ${serviceId} (direct): ${cmd} ${cmdArgs.join(' ')}`);
         } else if (language) {
-            // FORMATO LEGADO: derivar de language/framework/buildTool
+            // LEGACY FORMAT: derive from language/framework/buildTool
             const startCommand = await this.getStartCommand(language, framework, buildTool, cwd, profile || 'dev');
             cmd = startCommand.cmd;
             cmdArgs = startCommand.args;
@@ -167,7 +167,7 @@ export class ProcessManager extends EventEmitter {
 
                 this.emit("log", { serviceId, message: log, type: "stdout" });
 
-                // Detectar quando serviço está pronto
+                // Detect when the service is ready
                 if (this.isServiceReady(log, language || 'java')) {
                     if (processData.status !== "running") {
                         processData.status = "running";
@@ -178,7 +178,7 @@ export class ProcessManager extends EventEmitter {
             }
         });
 
-        // Capturar stderr (Spring Boot também loga aqui)
+        // Capture stderr (Spring Boot also logs here)
         child.stderr.on("data", (data) => {
             const text = data.toString();
             const lines = text.split('\n').filter(l => l.trim());
@@ -195,7 +195,7 @@ export class ProcessManager extends EventEmitter {
 
                 this.emit("log", { serviceId, message: log, type: "stderr" });
 
-                // Spring Boot pode logar "Started" no stderr também
+                // Spring Boot may log "Started" on stderr too
                 if (this.isServiceReady(log, language || 'java')) {
                     if (processData.status !== "running") {
                         processData.status = "running";
@@ -206,21 +206,21 @@ export class ProcessManager extends EventEmitter {
             }
         });
 
-        // Capturar erro de inicialização
+        // Capture startup errors
         child.on("error", (err) => {
             console.error(`❌ Failed to start ${serviceId}:`, err.message);
             processData.status = "failed";
             this.emit("error", { serviceId, error: err.message });
         });
 
-        // Capturar encerramento
+        // Capture termination
         child.on("close", (code, signal) => {
             console.log(`⏹️ Service ${serviceId} exited with code ${code}, signal ${signal}`);
             this.processes.delete(serviceId);
             this.emit("stopped", { serviceId, code, signal });
         });
 
-        // Iniciar monitoramento de recursos
+        // Start resource monitoring
         this.startResourceMonitoring(serviceId);
 
         return {
@@ -234,7 +234,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Para um serviço
+     * Stops a service
      */
     async stop(serviceId) {
         const processData = this.processes.get(serviceId);
@@ -272,14 +272,14 @@ export class ProcessManager extends EventEmitter {
             child.once('exit', onExit);
             child.once('close', onExit);
 
-            // Tentar graceful shutdown
+            // Try a graceful shutdown
             try {
                 child.kill('SIGTERM');
             } catch (err) {
                 console.log(`⚠️ SIGTERM failed for ${serviceId}: ${err.message}`);
             }
 
-            // Force kill após 5 segundos
+            // Force kill after 5 seconds
             setTimeout(() => {
                 if (!resolved && this.processes.has(serviceId)) {
                     console.log(`🔨 Force killing ${serviceId} (SIGKILL)`);
@@ -291,7 +291,7 @@ export class ProcessManager extends EventEmitter {
                 }
             }, 5000);
 
-            // Timeout geral após 10 segundos
+            // Overall timeout after 10 seconds
             setTimeout(() => {
                 if (!resolved) {
                     resolved = true;
@@ -309,7 +309,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Retorna status de um serviço
+     * Returns the status of a service
      */
     getStatus(serviceId) {
         const processData = this.processes.get(serviceId);
@@ -333,7 +333,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Retorna logs de um serviço
+     * Returns the logs of a service
      */
     getLogs(serviceId, limit = 100) {
         const processData = this.processes.get(serviceId);
@@ -344,7 +344,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Lista todos os serviços
+     * Lists all services
      */
     listServices() {
         const services = [];
@@ -355,20 +355,20 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Alias para compatibilidade
+     * Alias for compatibility
      */
     listAll() {
         return this.listServices();
     }
 
     /**
-     * Determina comando de start baseado no framework (FORMATO LEGADO)
-     * Usado quando server.js não passa command/args diretamente
+     * Determines the start command based on the framework (LEGACY FORMAT)
+     * Used when server.js does not pass command/args directly
      */
     async getStartCommand(language, framework, buildTool, cwd, profile = 'dev') {
         console.log(`🔧 getStartCommand: language=${language}, framework=${framework}, buildTool=${buildTool}`);
 
-        // Java (qualquer framework ou sem framework)
+        // Java (any framework or no framework)
         if (language === "java") {
             return await this.getJavaCommand(buildTool, cwd, profile);
         }
@@ -393,14 +393,14 @@ export class ProcessManager extends EventEmitter {
             return await this.getGoCommand(cwd);
         }
 
-        // Fallback genérico - tenta npm start
+        // Generic fallback - try npm start
         console.warn(`⚠️ Unknown language: ${language}, trying npm start`);
         return { cmd: "npm", args: ["start"] };
     }
 
     /**
-     * Comando Java/Spring Boot
-     */
+     * Java/Spring Boot command
+    async getJavaCommand(buildTool, cwd, profile = null) {
     async getJavaCommand(buildTool, cwd, profile = null) {
         const targetDir = path.join(cwd, "target");
         const buildDir = path.join(cwd, "build", "libs");
@@ -433,7 +433,7 @@ export class ProcessManager extends EventEmitter {
             return javaArgs;
         };
 
-        // Maven: Procurar JAR em target/
+        // Maven: Look for a JAR in target/
         if (buildTool === "maven") {
             console.log(`📁 Target directory: ${targetDir} (exists: ${fs.existsSync(targetDir)})`);
 
@@ -470,11 +470,11 @@ export class ProcessManager extends EventEmitter {
                 }
             }
 
-            // Sem JAR - pedir para compilar
+            // No JAR - ask to compile
             throw new Error(`No JAR found. Please compile first: mvn clean install -DskipTests`);
         }
 
-        // Gradle: Procurar JAR em build/libs/
+        // Gradle: Look for a JAR in build/libs/
         if (buildTool === "gradle") {
             console.log(`📁 Build directory: ${buildDir} (exists: ${fs.existsSync(buildDir)})`);
 
@@ -509,8 +509,8 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Comando Node.js
-     */
+     * Node.js command
+    async getNodeCommand(framework, cwd) {
     async getNodeCommand(framework, cwd) {
         const nodeModules = path.join(cwd, "node_modules");
         const hasNodeModules = fs.existsSync(nodeModules);
@@ -530,7 +530,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Comando Python
+     * Python command
      */
     async getPythonCommand(framework, cwd) {
         if (framework === "django") {
@@ -546,21 +546,21 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Comando .NET
+     * .NET command
      */
     async getDotNetCommand(cwd) {
         return { cmd: "dotnet", args: ["run"] };
     }
 
     /**
-     * Comando Go
+     * Go command
      */
     async getGoCommand(cwd) {
         return { cmd: "go", args: ["run", "."] };
     }
 
     /**
-     * Detecta quando serviço está pronto
+     * Detects when the service is ready
      */
     isServiceReady(log, language) {
         if (!log) return false;
@@ -591,7 +591,7 @@ export class ProcessManager extends EventEmitter {
     }
 
     /**
-     * Monitora recursos (CPU e Memory)
+     * Monitors resources (CPU and Memory)
      */
     startResourceMonitoring(serviceId) {
         const interval = setInterval(async () => {

package/src/workspace-manager.js

@@ -1,30 +1,36 @@
 import path from "path";
+import fs from "fs";
 import { exists, listRecursive, readFile, stat } from "./fs-utils.js";
+import { WORKSPACE_SIDECAR, readWorkspaceSidecar } from "./utils/open-gate.js";
 import { detectProject } from "./detectors.js";
 import { detectPort } from "./ports.js";
 
 /**
- * WorkspaceManager — Gere múltiplos workspaces simultâneos.
+ * WorkspaceManager — Manages multiple simultaneous workspaces.
  *
- * Substitui a variável global WORKSPACE_ROOT.
- * Cada workspace é identificado por um ID e tem o seu próprio root path.
+ * Replaces the global WORKSPACE_ROOT variable.
+ * Each workspace is identified by an ID and has its own root path.
  */
 export class WorkspaceManager {
     constructor() {
         /** @type {Map<string, WorkspaceState>} */
         this.workspaces = new Map();
 
-        /** Backward compat: workspace "default" para REST legacy */
+        /** Backward compat: "default" workspace for legacy REST */
         this.defaultWorkspaceId = null;
     }
 
     /**
-     * Abre um workspace. Se já existe com mesmo ID, actualiza o root.
-     * @param {string} workspaceId - Identificador único
-     * @param {string} rootPath - Caminho absoluto
+     * Opens a workspace. If one already exists with the same ID, updates the root.
+     * @param {string} workspaceId - Unique identifier
+     * @param {string} rootPath - Absolute path
+     * @param {{tenantId?: string|null}} [meta] - Optional. tenantId = tenant this
+     *        clone was hydrated for (TENANT GATE for ROOT-RECOVERY). When absent,
+     *        a previously registered tenantId for the same workspaceId is kept;
+     *        otherwise stays null (= unknown, recovery fails closed).
      * @returns {Promise<WorkspaceState>}
      */
-    async open(workspaceId, rootPath) {
+    async open(workspaceId, rootPath, meta = {}) {
         const abs = path.resolve(rootPath);
         if (!(await exists(abs))) {
             throw new Error(`Workspace path not found: ${abs}`);
@@ -33,9 +39,24 @@ export class WorkspaceManager {
         const projectInfo = await detectProject(abs);
         const port = await detectPort(abs);
 
+        // A previous registration under the same id only lends its tenant when
+        // it is for the SAME directory: ids like "default" are reused by
+        // different clones, and carrying tenant A over to tenant B's dir would
+        // mislabel it (registry AND sidecar, which ROOT-RECOVERY trusts).
+        const prevAny = this.workspaces.get(workspaceId);
+        const prev = prevAny && prevAny.root === abs ? prevAny : null;
+        // SIDECAR (QA 2026-09-22): after a restart the Map is empty, but the
+        // dir may still carry its registration on disk - keep that tenant
+        // instead of downgrading it to "unknown" (fail-closed elsewhere).
+        const sidecar = (!(meta && meta.tenantId) && !(prev && prev.tenantId))
+            ? readWorkspaceSidecar(abs) : null;
+        const tenantId = (meta && meta.tenantId) || (prev && prev.tenantId)
+            || (sidecar && sidecar.id === workspaceId ? sidecar.tenantId : null) || null;
+
         const state = {
             id: workspaceId,
             root: abs,
+            tenantId,
             projectInfo,
             port,
             openedAt: new Date().toISOString(),
@@ -44,8 +65,9 @@ export class WorkspaceManager {
         };
 
         this.workspaces.set(workspaceId, state);
+        this.writeSidecar(state);
 
-        // Se é o primeiro workspace, torna-se o default
+        // If it is the first workspace, it becomes the default
         if (!this.defaultWorkspaceId) {
             this.defaultWorkspaceId = workspaceId;
         }
@@ -55,16 +77,55 @@ export class WorkspaceManager {
     }
 
     /**
-     * Fecha um workspace.
+     * Persist the registration next to the clone so the OPEN GATE can still
+     * recognise this dir after the in-memory Map is gone (cold start / new
+     * revision / second instance). Best-effort: a write failure is logged and
+     * never breaks open(). NEVER stores tokens.
+     */
+    writeSidecar(state) {
+        const file = path.join(state.root, WORKSPACE_SIDECAR);
+        try {
+            // Atomic (temp + rename) and owner-only: the sidecar's tenantId is
+            // read by ROOT-RECOVERY, so it must never be observed half-written.
+            const tmp = `${file}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify({
+                id: state.id,
+                tenantId: state.tenantId || null,
+                root: state.root,
+                openedAt: state.openedAt
+            }, null, 2) + "\n", { mode: 0o600 });
+            fs.renameSync(tmp, file);
+            // Single-repo clones ARE git repos and the PR path runs `git add -A`:
+            // keep the sidecar out of git via .git/info/exclude (never touches
+            // the repo's own .gitignore). Multi-repo parents have no .git.
+            const infoDir = path.join(state.root, ".git", "info");
+            if (fs.existsSync(infoDir)) {
+                const excludeFile = path.join(infoDir, "exclude");
+                let current = "";
+                try { current = fs.readFileSync(excludeFile, "utf8"); } catch { current = ""; }
+                if (!current.split(/\r?\n/).includes(WORKSPACE_SIDECAR)) {
+                    fs.appendFileSync(excludeFile, (current && !current.endsWith("\n") ? "\n" : "") + WORKSPACE_SIDECAR + "\n");
+                }
+            }
+        } catch (err) {
+            console.warn(`[workspace] sidecar write failed (non-fatal) at ${file}: ${err.message}`);
+        }
+    }
+
+    /**
+     * Closes a workspace.
      */
     close(workspaceId) {
         const ws = this.workspaces.get(workspaceId);
         if (!ws) return false;
 
         this.workspaces.delete(workspaceId);
+        // A closed workspace is no longer registered anywhere: drop the sidecar
+        // so the OPEN GATE treats the dir exactly as before (orphan rules).
+        try { fs.rmSync(path.join(ws.root, WORKSPACE_SIDECAR), { force: true }); } catch { /* best-effort */ }
 
         if (this.defaultWorkspaceId === workspaceId) {
-            // Eleger novo default
+            // Elect a new default
             const first = this.workspaces.keys().next().value;
             this.defaultWorkspaceId = first || null;
         }
@@ -74,7 +135,7 @@ export class WorkspaceManager {
     }
 
     /**
-     * Obtém estado de um workspace. Actualiza lastAccessedAt.
+     * Gets the state of a workspace. Updates lastAccessedAt.
      * @param {string} workspaceId
      * @returns {WorkspaceState|null}
      */
@@ -87,7 +148,7 @@ export class WorkspaceManager {
     }
 
     /**
-     * Obtém o root path de um workspace. Throw se não existe.
+     * Gets the root path of a workspace. Throws if it does not exist.
      * @param {string} workspaceId
      * @returns {string}
      */
@@ -98,8 +159,8 @@ export class WorkspaceManager {
     }
 
     /**
-     * Resolve workspace ID — se null, usa o default.
-     * Backward compat para REST endpoints que não enviam workspaceId.
+     * Resolves a workspace ID — if null, uses the default.
+     * Backward compat for REST endpoints that do not send a workspaceId.
      */
     resolveId(workspaceId) {
         if (workspaceId) return workspaceId;
@@ -108,7 +169,7 @@ export class WorkspaceManager {
     }
 
     /**
-     * Resolve root path — aceita workspaceId ou usa default.
+     * Resolves the root path — accepts a workspaceId or uses the default.
      */
     resolveRoot(workspaceId) {
         const id = this.resolveId(workspaceId);
@@ -116,29 +177,29 @@ export class WorkspaceManager {
     }
 
     /**
-     * Lista todos os workspaces abertos.
+     * Lists all open workspaces.
      */
     list() {
         return Array.from(this.workspaces.values());
     }
 
     /**
-     * Verifica se workspace está aberto.
+     * Checks whether a workspace is open.
      */
     isOpen(workspaceId) {
         return this.workspaces.has(workspaceId);
     }
 
     /**
-     * Total de workspaces abertos.
+     * Total number of open workspaces.
      */
     get count() {
         return this.workspaces.size;
     }
 
     /**
-     * Backward compat: obtém WORKSPACE_ROOT (default workspace).
-     * Usado pelos endpoints REST legacy.
+     * Backward compat: gets WORKSPACE_ROOT (default workspace).
+     * Used by the legacy REST endpoints.
      */
     get defaultRoot() {
         if (!this.defaultWorkspaceId) return null;
@@ -147,12 +208,12 @@ export class WorkspaceManager {
     }
 
     /**
-     * Backward compat: define WORKSPACE_ROOT (default workspace).
-     * Chamado pelo POST /workspace/open legacy.
+     * Backward compat: sets WORKSPACE_ROOT (default workspace).
+     * Called by the legacy POST /workspace/open.
      */
     async setDefault(rootPath) {
         const id = `default-${Date.now()}`;
-        // Se já tem default, reutiliza o ID
+        // If a default already exists, reuse its ID
         const existingId = this.defaultWorkspaceId || id;
         await this.open(existingId, rootPath);
         this.defaultWorkspaceId = existingId;
@@ -164,6 +225,7 @@ export class WorkspaceManager {
  * @typedef {Object} WorkspaceState
  * @property {string} id
  * @property {string} root
+ * @property {string|null} tenantId
  * @property {Object} projectInfo
  * @property {number|null} port
  * @property {string} openedAt

package/test/adapters/registry.test.js

@@ -77,11 +77,18 @@ describe('adapter registry', () => {
   });
 
   test('stopAll respects timeout — slow stop does not block forever', async () => {
-    const slow = { stop: () => new Promise(() => { /* never resolve */ }) };
+    // stop() resolves AFTER stopAll's timeout (via a real timer), proving stopAll
+    // returns early — then we drain the outstanding promise before the test
+    // settles. A never-resolving promise leaves "resolution still pending" at test
+    // end (node:test failure) which cancelled the sibling subtests.
+    let slowPromise;
+    const slow = { stop: () => (slowPromise = new Promise((resolve) => setTimeout(resolve, 400))) };
     const before = Date.now();
-    await stopAll([slow], 200);
+    await stopAll([slow], 100);
     const elapsed = Date.now() - before;
     assert.ok(elapsed < 1000, `stopAll should return within timeout; took ${elapsed}ms`);
+    assert.ok(elapsed < 400, `stopAll should return on its timeout, not wait for slow stop; took ${elapsed}ms`);
+    await slowPromise; // drain: nothing left pending when the test settles
   });
 
   test('stopAll swallows per-adapter stop() errors (never throws)', async () => {