deepdebug-local-agent 0.3.11 → 0.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Insptech AI — DeepDebug Local Agent. Autonomous code debugging agent for production environments.",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -557,6 +557,7 @@ app.use(cors({
         // Cloud Run URLs (regex patterns)
         /https:\/\/.*\.run\.app$/,
         /https:\/\/.*\.web\.app$/,
+        // Production frontend
         "https://deepdebug.ai",
         "https://www.deepdebug.ai"
     ],
@@ -5082,10 +5083,138 @@ app.post("/workspace/:workspaceId/run", async (req, res) => {
     }
 });
 
+
+// ============================================
+// 🔌 WEBSOCKET REVERSE TUNNEL
+// Connects Local Agent to Gateway — no public URL needed
+// ============================================
+async function startWebSocketTunnel(port, gatewayUrl, apiKey, tenantId) {
+    if (!gatewayUrl || !apiKey || !tenantId) {
+        console.log('⚠️  WebSocket tunnel skipped: missing gatewayUrl, apiKey or tenantId in ~/.deepdebug/config.json');
+        return;
+    }
+
+    const wsUrl = gatewayUrl.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
+    const fullUrl = `${wsUrl}/api/v1/agent/ws?tenantId=${encodeURIComponent(tenantId)}&apiKey=${encodeURIComponent(apiKey)}`;
+
+    let reconnectDelay = 2000;
+    let isShuttingDown = false;
+    let ws = null;
+
+    async function connect() {
+        if (isShuttingDown) return;
+        try {
+            const { default: WebSocket } = await import('ws');
+            ws = new WebSocket(fullUrl);
+
+            ws.on('open', () => {
+                console.log(`✅ WebSocket tunnel connected to Gateway`);
+                reconnectDelay = 2000;
+                ws.send(JSON.stringify({ type: 'register', tenantId, port, workspacePath: WORKSPACE_ROOT || null }));
+                const hb = setInterval(() => {
+                    if (ws.readyState === WebSocket.OPEN) ws.send('ping');
+                    else clearInterval(hb);
+                }, 30000);
+            });
+
+            ws.on('message', async (data) => {
+                const text = data.toString();
+                if (text === 'pong') return;
+                let request;
+                try { request = JSON.parse(text); } catch { return; }
+                const { requestId, command, params } = request;
+                if (!requestId || !command) return;
+                console.log(`📨 WS command: ${command}`);
+                let result;
+                try { result = await handleWsCommand(command, params || {}); }
+                catch (err) { result = { error: err.message }; }
+                ws.send(JSON.stringify({ requestId, command, ...result }));
+            });
+
+            ws.on('close', () => {
+                if (!isShuttingDown) {
+                    console.log(`🔌 WS disconnected. Reconnecting in ${reconnectDelay/1000}s...`);
+                    setTimeout(connect, reconnectDelay);
+                    reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+                }
+            });
+
+            ws.on('error', (err) => console.warn(`⚠️ WS error: ${err.message}`));
+
+        } catch (err) {
+            if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                console.warn('⚠️ WebSocket tunnel requires "ws" package. Run: npm install ws');
+            } else {
+                console.warn(`⚠️ WS tunnel error: ${err.message}`);
+                setTimeout(connect, reconnectDelay);
+                reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+            }
+        }
+    }
+
+    async function handleWsCommand(command, params) {
+        const localBase = `http://localhost:${port}`;
+        switch (command) {
+            case 'health':
+                return { status: 'ok', workspace: WORKSPACE_ROOT, openWorkspaces: wsManager ? wsManager.list().length : 0 };
+
+            case 'workspace.open': {
+                const { root } = params;
+                if (!root) return { error: 'root is required' };
+                await wsManager.open('default', root);
+                WORKSPACE_ROOT = root;
+                return { ok: true, root };
+            }
+
+            case 'workspace.file-content': {
+                const { path: filePath } = params;
+                if (!filePath) return { error: 'path is required' };
+                if (!WORKSPACE_ROOT) return { error: 'No workspace open' };
+                const absPath = path.isAbsolute(filePath) ? filePath : path.join(WORKSPACE_ROOT, filePath);
+                try {
+                    const content = await fsPromises.readFile(absPath, 'utf-8');
+                    return { content, path: filePath, found: true };
+                } catch (err) {
+                    return { content: null, found: false, error: err.message };
+                }
+            }
+
+            case 'workspace.safe-patch':
+            case 'workspace.compile':
+            case 'workspace.rollback':
+            case 'workspace.validate-diff':
+            case 'workspace.backups': {
+                const endpointMap = {
+                    'workspace.safe-patch': '/workspace/safe-patch',
+                    'workspace.compile': '/workspace/compile',
+                    'workspace.rollback': '/workspace/rollback',
+                    'workspace.validate-diff': '/workspace/validate-diff',
+                    'workspace.backups': '/workspace/backups'
+                };
+                const endpoint = endpointMap[command];
+                const method = command === 'workspace.backups' ? 'GET' : 'POST';
+                const res = await fetch(`${localBase}${endpoint}`, {
+                    method,
+                    headers: { 'Content-Type': 'application/json' },
+                    ...(method === 'POST' ? { body: JSON.stringify(params) } : {})
+                });
+                return await res.json();
+            }
+
+            default:
+                return { error: `Unknown command: ${command}` };
+        }
+    }
+
+    process.on('SIGINT', () => { isShuttingDown = true; if (ws) ws.close(); });
+    process.on('SIGTERM', () => { isShuttingDown = true; if (ws) ws.close(); });
+    connect();
+}
+
 // ============================================
 // START SERVER
 // ============================================
-app.listen(PORT, '0.0.0.0', () => {
+app.listen(PORT, '0.0.0.0', async () => {
     console.log(`\n🔌 DeepDebug Local Agent listening on port ${PORT}`);
     console.log(`📦 Environment: ${process.env.NODE_ENV || 'development'}`);
     console.log(`📦 Process Manager initialized`);
@@ -5096,6 +5225,26 @@ app.listen(PORT, '0.0.0.0', () => {
         console.log(`   Max Retries: ${aiEngine.maxRetries}`);
     }
     console.log(`\n🚀 Ready to receive requests!\n`);
+
+    // 🔌 Start WebSocket reverse tunnel
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const configPath = path.join(homeDir, '.deepdebug', 'config.json');
+    let cfg = {};
+    try { cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8')); } catch {}
+
+    const gwUrl = cfg.gatewayUrl || process.env.GATEWAY_URL;
+    const apiKey = cfg.apiKey || process.env.DEEPDEBUG_API_KEY;
+    let tenantId = cfg.tenantId;
+    if (!tenantId && apiKey) {
+        try {
+            const payload = JSON.parse(Buffer.from(apiKey.split('.')[1], 'base64').toString());
+            tenantId = payload.tenantId;
+        } catch {}
+    }
+
+    if (process.env.DISABLE_WS_TUNNEL !== 'true') {
+        startWebSocketTunnel(PORT, gwUrl, apiKey, tenantId).then(() => console.log("WS tunnel started")).catch(err => console.error("WS tunnel failed:", err));
+    }
 });
 
 // Start MCP HTTP Bridge em paralelo (port 5056)