deepdebug-local-agent 0.3.8 → 0.3.10

package/analyzers/config-analyzer.js

@@ -0,0 +1,446 @@
+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;