deepdebug-local-agent 0.3.13 → 0.3.14

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "Insptech AI — DeepDebug Local Agent. Autonomous code debugging agent for production environments.",
   "type": "module",
-  "main": "server.js",
+  "main": "src/server.js",
   "bin": {
-    "deepdebug-local-agent": "./bin/install.js"
+    "deepdebug-local-agent": "index.js"
   },
   "scripts": {
-    "start": "node server.js",
-    "dev": "NODE_ENV=development node server.js",
-    "mcp": "node mcp-server.js"
+    "start": "node src/server.js",
+    "dev": "NODE_ENV=development node src/server.js",
+    "mcp": "node src/mcp-server.js"
   },
   "keywords": [
     "deepdebug",
@@ -36,6 +36,6 @@
     "properties-reader": "^2.3.0",
     "strip-ansi": "^7.1.0",
     "unidiff": "^1.0.2",
-    "ws": "^8.19.0"
+    "ws": "^8.18.0"
   }
 }

package/src/server.js

@@ -557,7 +557,10 @@ app.use(cors({
         // Cloud Run URLs (regex patterns)
         /https:\/\/.*\.run\.app$/,
         /https:\/\/.*\.web\.app$/,
+<<<<<<< HEAD
         // Production frontend
+=======
+>>>>>>> dd7d3ab (fix: add deepdebug.ai to CORS origins)
         "https://deepdebug.ai",
         "https://www.deepdebug.ai"
     ],
@@ -5201,6 +5204,121 @@ async function startWebSocketTunnel(port, gatewayUrl, apiKey, tenantId) {
                 return await res.json();
             }
 
+            // ============================================
+            // MCP TOOLS — routed via MCP HTTP Bridge (port 5056)
+            // ============================================
+            case 'mcp.read-file': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/read-file`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        path: params.path
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.read-files': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/read-files`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        paths: params.paths
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.list-directory': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/list-directory`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        path: params.path || '.',
+                        maxFiles: params.maxFiles || 500
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.search-code': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/search-code`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        query: params.query,
+                        filePattern: params.filePattern || '*',
+                        maxResults: params.maxResults || 50
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.execute-command': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/execute-command`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        command: params.command,
+                        timeoutMs: params.timeoutMs || 120000
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.project-info': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/project-info`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default'
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.apply-patch': {
+                const mcpBase = `http://localhost:5056`;
+                const res = await fetch(`${mcpBase}/mcp/apply-patch`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        diff: params.diff
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'mcp.open': {
+                const mcpBase = `http://localhost:5056`;
+                // Also open in wsManager for backward compat
+                if (params.root) {
+                    await wsManager.open(params.workspaceId || 'default', params.root);
+                    WORKSPACE_ROOT = params.root;
+                }
+                const res = await fetch(`${mcpBase}/mcp/open`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: params.workspaceId || 'default',
+                        root: params.root
+                    })
+                });
+                return await res.json();
+            }
+
             default:
                 return { error: `Unknown command: ${command}` };
         }

package/analyzers/config-analyzer.js

@@ -1,446 +0,0 @@
-import path from "path";
-import { readFile, exists } from "../fs-utils.js";
-import yaml from "js-yaml";
-
-/**
- * ConfigAnalyzer
- *
- * Analyzes application configuration to extract:
- * - Server port
- * - Environment variables
- * - Database connections
- * - API keys and secrets (obfuscated)
- * - Spring profiles
- */
-export class ConfigAnalyzer {
-    constructor(workspaceRoot) {
-        this.workspaceRoot = workspaceRoot;
-    }
-
-    /**
-     * Find all configuration files
-     */
-    async findConfigFiles() {
-        const configPatterns = [
-            "application.yml",
-            "application.yaml",
-            "application.properties",
-            "application-dev.yml",
-            "application-dev.yaml",
-            "application-dev.properties",
-            "application-local.yml",
-            "application-local.yaml",
-            "application-local.properties",
-            "application-prod.yml",
-            "application-prod.yaml",
-            "application-prod.properties",
-            "bootstrap.yml",
-            "bootstrap.yaml",
-            ".env",
-            ".env.local",
-            ".env.development",
-            "config/application.yml",
-            "config/application.yaml"
-        ];
-
-        const srcPaths = [
-            "src/main/resources/",
-            "src/main/java/resources/",
-            ""
-        ];
-
-        const foundConfigs = [];
-
-        for (const srcPath of srcPaths) {
-            for (const configPattern of configPatterns) {
-                const fullPath = path.join(this.workspaceRoot, srcPath, configPattern);
-                if (await exists(fullPath)) {
-                    foundConfigs.push(path.join(srcPath, configPattern));
-                }
-            }
-        }
-
-        return foundConfigs;
-    }
-
-    /**
-     * Analyze main configuration
-     */
-    async analyze() {
-        const configFiles = await this.findConfigFiles();
-        const configs = [];
-
-        for (const configFile of configFiles) {
-            const config = await this.analyzeConfigFile(configFile);
-            if (config) {
-                configs.push(config);
-            }
-        }
-
-        // Merge all configs into a unified view
-        const merged = this.mergeConfigs(configs);
-
-        // Extract server config and add available profiles
-        const serverConfig = this.extractServerConfig(merged);
-        serverConfig.availableProfiles = this.detectProfiles(configFiles);
-
-        return {
-            files: configFiles,
-            configs: configs,
-            merged: merged,
-            server: serverConfig,
-            database: this.extractDatabaseConfig(merged),
-            security: this.extractSecurityConfig(merged),
-            envVars: this.extractEnvVars(configs)
-        };
-    }
-
-    /**
-     * Analyze a single config file
-     */
-    async analyzeConfigFile(configPath) {
-        try {
-            const fullPath = path.join(this.workspaceRoot, configPath);
-            const content = await readFile(fullPath, "utf8");
-            const fileName = path.basename(configPath);
-
-            if (fileName.endsWith(".yml") || fileName.endsWith(".yaml")) {
-                return {
-                    file: configPath,
-                    type: "yaml",
-                    content: yaml.load(content) || {}
-                };
-            } else if (fileName.endsWith(".properties")) {
-                return {
-                    file: configPath,
-                    type: "properties",
-                    content: this.parseProperties(content)
-                };
-            } else if (fileName.startsWith(".env")) {
-                return {
-                    file: configPath,
-                    type: "env",
-                    content: this.parseEnvFile(content)
-                };
-            }
-
-            return null;
-        } catch (err) {
-            console.error(`Failed to analyze config ${configPath}:`, err.message);
-            return null;
-        }
-    }
-
-    /**
-     * Parse .properties file
-     */
-    parseProperties(content) {
-        const result = {};
-        const lines = content.split("\n");
-
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith("#")) continue;
-
-            const eqIndex = trimmed.indexOf("=");
-            if (eqIndex > 0) {
-                const key = trimmed.substring(0, eqIndex).trim();
-                const value = trimmed.substring(eqIndex + 1).trim();
-                this.setNestedValue(result, key, value);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Parse .env file
-     */
-    parseEnvFile(content) {
-        const result = {};
-        const lines = content.split("\n");
-
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith("#")) continue;
-
-            const eqIndex = trimmed.indexOf("=");
-            if (eqIndex > 0) {
-                const key = trimmed.substring(0, eqIndex).trim();
-                let value = trimmed.substring(eqIndex + 1).trim();
-                // Remove quotes
-                value = value.replace(/^["']|["']$/g, "");
-                result[key] = this.obfuscateSensitive(key, value);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Set nested value from dot notation key
-     */
-    setNestedValue(obj, key, value) {
-        const parts = key.split(".");
-        let current = obj;
-
-        for (let i = 0; i < parts.length - 1; i++) {
-            const part = parts[i];
-            if (!current[part]) {
-                current[part] = {};
-            }
-            current = current[part];
-        }
-
-        current[parts[parts.length - 1]] = value;
-    }
-
-    /**
-     * Merge multiple config files
-     */
-    mergeConfigs(configs) {
-        const merged = {};
-
-        for (const config of configs) {
-            if (config && config.content) {
-                this.deepMerge(merged, config.content);
-            }
-        }
-
-        return merged;
-    }
-
-    /**
-     * Deep merge two objects
-     */
-    deepMerge(target, source) {
-        for (const key in source) {
-            if (source[key] instanceof Object && key in target) {
-                this.deepMerge(target[key], source[key]);
-            } else {
-                target[key] = source[key];
-            }
-        }
-        return target;
-    }
-
-    /**
-     * Extract server configuration
-     */
-    extractServerConfig(config) {
-        const server = {
-            port: 8080, // default
-            contextPath: "/",
-            ssl: false,
-            activeProfile: "dev" // default profile
-        };
-
-        // Spring Boot server config
-        if (config.server) {
-            server.port = config.server.port || server.port;
-            server.contextPath = config.server.servlet?.["context-path"] ||
-                                 config.server["servlet.context-path"] ||
-                                 config.server.contextPath ||
-                                 server.contextPath;
-            server.ssl = !!config.server.ssl;
-        }
-
-        // Also check for PORT env var placeholder
-        if (typeof server.port === "string" && server.port.includes("${")) {
-            const match = server.port.match(/\$\{([^:}]+)(?::(\d+))?\}/);
-            if (match) {
-                server.portEnvVar = match[1];
-                server.port = parseInt(match[2]) || 8080;
-            }
-        }
-
-        // Extract active profile from spring.profiles.active
-        if (config.spring?.profiles?.active) {
-            server.activeProfile = config.spring.profiles.active;
-        }
-
-        return server;
-    }
-
-    /**
-     * Extract database configuration
-     */
-    extractDatabaseConfig(config) {
-        const database = {
-            type: null,
-            host: null,
-            port: null,
-            name: null,
-            configured: false
-        };
-
-        // Spring Boot data source
-        const datasource = config.spring?.datasource;
-        if (datasource) {
-            database.configured = true;
-            database.url = this.obfuscateSensitive("url", datasource.url);
-
-            // Parse URL to extract type
-            if (datasource.url) {
-                if (datasource.url.includes("mysql")) database.type = "mysql";
-                else if (datasource.url.includes("postgresql") || datasource.url.includes("postgres")) database.type = "postgresql";
-                else if (datasource.url.includes("mongodb")) database.type = "mongodb";
-                else if (datasource.url.includes("h2")) database.type = "h2";
-                else if (datasource.url.includes("oracle")) database.type = "oracle";
-                else if (datasource.url.includes("sqlserver")) database.type = "sqlserver";
-            }
-        }
-
-        // MongoDB
-        const mongodb = config.spring?.data?.mongodb;
-        if (mongodb) {
-            database.configured = true;
-            database.type = "mongodb";
-            database.uri = this.obfuscateSensitive("uri", mongodb.uri);
-            database.database = mongodb.database;
-        }
-
-        // Redis
-        const redis = config.spring?.data?.redis || config.spring?.redis;
-        if (redis) {
-            database.redis = {
-                configured: true,
-                host: redis.host || "localhost",
-                port: redis.port || 6379
-            };
-        }
-
-        return database;
-    }
-
-    /**
-     * Extract security configuration
-     */
-    extractSecurityConfig(config) {
-        const security = {
-            hasAuth: false,
-            type: null,
-            cors: null
-        };
-
-        // Check for Spring Security
-        if (config.spring?.security) {
-            security.hasAuth = true;
-
-            if (config.spring.security.oauth2) {
-                security.type = "oauth2";
-            } else if (config.spring.security.jwt) {
-                security.type = "jwt";
-            } else {
-                security.type = "basic";
-            }
-        }
-
-        // Check for JWT config
-        if (config.jwt || config.security?.jwt) {
-            security.hasAuth = true;
-            security.type = "jwt";
-        }
-
-        return security;
-    }
-
-    /**
-     * Extract environment variables referenced in configs
-     */
-    extractEnvVars(configs) {
-        const envVars = new Set();
-
-        const extractFromObject = (obj) => {
-            if (typeof obj === "string") {
-                const matches = obj.matchAll(/\$\{([^:}]+)(?::[^}]*)?\}/g);
-                for (const match of matches) {
-                    envVars.add(match[1]);
-                }
-            } else if (obj && typeof obj === "object") {
-                for (const value of Object.values(obj)) {
-                    extractFromObject(value);
-                }
-            }
-        };
-
-        for (const config of configs) {
-            if (config && config.content) {
-                extractFromObject(config.content);
-            }
-        }
-
-        return Array.from(envVars);
-    }
-
-    /**
-     * Obfuscate sensitive values
-     */
-    obfuscateSensitive(key, value) {
-        if (!value || typeof value !== "string") return value;
-
-        const sensitivePatterns = [
-            "password", "secret", "key", "token", "credential",
-            "api_key", "apikey", "auth", "jwt"
-        ];
-
-        const keyLower = key.toLowerCase();
-        for (const pattern of sensitivePatterns) {
-            if (keyLower.includes(pattern)) {
-                if (value.length > 4) {
-                    return value.substring(0, 2) + "****" + value.substring(value.length - 2);
-                }
-                return "****";
-            }
-        }
-
-        return value;
-    }
-
-    /**
-     * Get runtime configuration for starting the server
-     */
-    async getRuntimeConfig() {
-        const analysis = await this.analyze();
-
-        return {
-            port: analysis.server.port,
-            contextPath: analysis.server.contextPath,
-            envVars: analysis.envVars,
-            profiles: this.detectProfiles(analysis.files),
-            jvmArgs: this.buildJvmArgs(analysis)
-        };
-    }
-
-    /**
-     * Detect available Spring profiles
-     */
-    detectProfiles(configFiles) {
-        const profiles = ["default"];
-
-        for (const file of configFiles) {
-            const match = file.match(/application-(\w+)\./);
-            if (match && match[1] !== "test") {
-                profiles.push(match[1]);
-            }
-        }
-
-        return [...new Set(profiles)];
-    }
-
-    /**
-     * Build JVM arguments for running the application
-     */
-    buildJvmArgs(analysis) {
-        const args = [];
-
-        // Add profile if dev or local exists
-        if (analysis.files.some(f => f.includes("-dev") || f.includes("-local"))) {
-            args.push("-Dspring.profiles.active=dev,local");
-        }
-
-        return args;
-    }
-}
-
-export default ConfigAnalyzer;