@dynamicu/chromedebug-mcp 2.2.0

package/src/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const indexPath = join(__dirname, 'index.js');
+
+const child = spawn('node', [indexPath], {
+  stdio: 'inherit',
+  env: process.env
+});
+
+child.on('exit', (code) => {
+  process.exit(code);
+});

package/src/config-loader.js

@@ -0,0 +1,303 @@
+// Configuration loader for Chrome Debug
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ProjectManager } from './services/project-manager.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  serverPorts: {
+    httpServer: {
+      preferredPorts: [
+        // Original range (maintain backward compatibility)
+        3001, 3000, 3002, 3028,
+        // Extended original range
+        3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036,
+        // Safer fallback ranges (avoid common service conflicts)
+        8080, 8081, 8082, 8083, 8084, 8085, 8086, 8087, 8088, 8089, 8090,
+        9000, 9001, 9002, 9003, 9004, 9005, 9006, 9007, 9008, 9009, 9010
+      ],
+      description: "Ports to try for HTTP server discovery, in priority order"
+    },
+    mcpServer: {
+      preferredPorts: [
+        // Original range (maintain backward compatibility)
+        3028, 3023, 3002, 3003, 3004, 3005,
+        // Extended original range
+        3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036,
+        // Safer fallback ranges (avoid common service conflicts)
+        8080, 8081, 8082, 8083, 8084, 8085, 8086, 8087, 8088, 8089, 8090,
+        9000, 9001, 9002, 9003, 9004, 9005, 9006, 9007, 9008, 9009, 9010
+      ],
+      description: "Ports to try for MCP server discovery, in priority order"
+    },
+    discoveryRange: {
+      start: 3000,
+      end: 9010,
+      description: "Port range for automatic discovery when preferred ports are not available"
+    }
+  },
+  chromeExtension: {
+    serverDiscovery: {
+      timeoutMs: 3000,
+      description: "Timeout for server discovery requests in milliseconds"
+    },
+    portScanOrder: "httpFirst",
+    description: "Order to try ports: 'httpFirst' tries HTTP ports first, 'mcpFirst' tries MCP ports first, 'sequential' tries all ports in numerical order"
+  },
+  logging: {
+    level: "info",
+    description: "Logging level: debug, info, warn, error"
+  }
+};
+
+class ConfigLoader {
+  constructor() {
+    this.config = null;
+    this.configPath = null;
+    this.projectManager = new ProjectManager();
+    this._determineConfigPath();
+  }
+
+  /**
+   * Determines the appropriate config path based on project mode
+   */
+  _determineConfigPath() {
+    try {
+      // Try project-local config first
+      const projectInfo = this.projectManager.detectProject();
+      if (projectInfo) {
+        try {
+          // Initialize project structure synchronously if possible
+          const projectConfigPath = path.join(projectInfo.projectDir, '.chromedebug', 'config', 'config.json');
+          
+          // Ensure config directory exists
+          const configDir = path.dirname(projectConfigPath);
+          if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+          }
+          
+          this.configPath = projectConfigPath;
+          console.log(`[ConfigLoader] Using project-local config: ${projectConfigPath}`);
+          return;
+        } catch (error) {
+          console.warn('[ConfigLoader] Project structure not ready, using global config:', error.message);
+        }
+      }
+    } catch (error) {
+      console.warn('[ConfigLoader] Failed project detection, using global config:', error.message);
+    }
+
+    // Fallback to global config
+    this.configPath = path.join(__dirname, '../config/chromedebug-config.json');
+    console.log(`[ConfigLoader] Using global config: ${this.configPath}`);
+  }
+
+  // Load configuration from file
+  loadConfig() {
+    if (this.config) return this.config;
+
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const configData = fs.readFileSync(this.configPath, 'utf8');
+        this.config = { ...DEFAULT_CONFIG, ...JSON.parse(configData) };
+        console.log(`Configuration loaded from: ${this.configPath}`);
+      } else {
+        console.log('No configuration file found, using defaults');
+        this.config = DEFAULT_CONFIG;
+        
+        // If we're in project mode and global config exists, copy it first
+        if (this.isProjectLocalConfig() && this.hasGlobalConfig()) {
+          this.copyGlobalConfigToProject();
+        } else {
+          this.createDefaultConfigFile();
+        }
+      }
+    } catch (error) {
+      console.warn(`Error loading configuration: ${error.message}`);
+      console.log('Using default configuration');
+      this.config = DEFAULT_CONFIG;
+    }
+
+    return this.config;
+  }
+
+  /**
+   * Checks if current config path is project-local
+   * @returns {boolean} True if using project-local config
+   */
+  isProjectLocalConfig() {
+    return this.configPath && this.configPath.includes('.chromedebug');
+  }
+
+  /**
+   * Checks if global config file exists
+   * @returns {boolean} True if global config exists
+   */
+  hasGlobalConfig() {
+    const globalConfigPath = path.join(__dirname, '../config/chromedebug-config.json');
+    return fs.existsSync(globalConfigPath);
+  }
+
+  /**
+   * Copies global config to project-local config
+   */
+  copyGlobalConfigToProject() {
+    try {
+      const globalConfigPath = path.join(__dirname, '../config/chromedebug-config.json');
+      const globalConfigData = fs.readFileSync(globalConfigPath, 'utf8');
+      const globalConfig = JSON.parse(globalConfigData);
+      
+      // Merge with defaults and write to project config
+      this.config = { ...DEFAULT_CONFIG, ...globalConfig };
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+      
+      console.log(`[ConfigLoader] Copied global config to project: ${this.configPath}`);
+    } catch (error) {
+      console.warn(`[ConfigLoader] Failed to copy global config: ${error.message}`);
+      this.createDefaultConfigFile();
+    }
+  }
+
+  // Create default configuration file
+  createDefaultConfigFile() {
+    try {
+      const configDir = path.dirname(this.configPath);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+      
+      fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+      console.log(`Default configuration file created at: ${this.configPath}`);
+    } catch (error) {
+      console.warn(`Could not create default configuration file: ${error.message}`);
+    }
+  }
+
+  // Get HTTP server ports in priority order
+  getHttpServerPorts() {
+    const config = this.loadConfig();
+    return [...config.serverPorts.httpServer.preferredPorts];
+  }
+
+  // Get MCP server ports in priority order
+  getMcpServerPorts() {
+    const config = this.loadConfig();
+    return [...config.serverPorts.mcpServer.preferredPorts];
+  }
+
+  // Get combined port list for Chrome extension based on scan order
+  getExtensionPortList() {
+    const config = this.loadConfig();
+    const httpPorts = this.getHttpServerPorts();
+    const mcpPorts = this.getMcpServerPorts();
+    
+    let combinedPorts = [];
+    
+    switch (config.chromeExtension.portScanOrder) {
+      case 'httpFirst':
+        // HTTP ports first, then MCP ports, avoiding duplicates
+        combinedPorts = [...httpPorts];
+        mcpPorts.forEach(port => {
+          if (!combinedPorts.includes(port)) {
+            combinedPorts.push(port);
+          }
+        });
+        break;
+        
+      case 'mcpFirst':
+        // MCP ports first, then HTTP ports, avoiding duplicates
+        combinedPorts = [...mcpPorts];
+        httpPorts.forEach(port => {
+          if (!combinedPorts.includes(port)) {
+            combinedPorts.push(port);
+          }
+        });
+        break;
+        
+      case 'sequential':
+        // All ports in numerical order
+        const allPorts = [...new Set([...httpPorts, ...mcpPorts])];
+        combinedPorts = allPorts.sort((a, b) => a - b);
+        break;
+        
+      default:
+        // Default to httpFirst
+        combinedPorts = [...httpPorts];
+        mcpPorts.forEach(port => {
+          if (!combinedPorts.includes(port)) {
+            combinedPorts.push(port);
+          }
+        });
+    }
+
+    // Add discovery range if enabled
+    const discoveryRange = config.serverPorts.discoveryRange;
+    if (discoveryRange.start && discoveryRange.end) {
+      for (let port = discoveryRange.start; port <= discoveryRange.end; port++) {
+        if (!combinedPorts.includes(port)) {
+          combinedPorts.push(port);
+        }
+      }
+    }
+
+    return combinedPorts;
+  }
+
+  // Get server discovery timeout
+  getDiscoveryTimeout() {
+    const config = this.loadConfig();
+    return config.chromeExtension.serverDiscovery.timeoutMs;
+  }
+
+  // Get logging level
+  getLoggingLevel() {
+    const config = this.loadConfig();
+    return config.logging.level;
+  }
+
+  // Update configuration
+  updateConfig(updates) {
+    const config = this.loadConfig();
+    const newConfig = { ...config, ...updates };
+    
+    try {
+      fs.writeFileSync(this.configPath, JSON.stringify(newConfig, null, 2));
+      this.config = newConfig;
+      console.log('Configuration updated successfully');
+      return true;
+    } catch (error) {
+      console.error(`Error updating configuration: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Gets configuration mode information
+   * @returns {object} Configuration mode info
+   */
+  getConfigInfo() {
+    return {
+      mode: this.isProjectLocalConfig() ? 'project' : 'global',
+      configPath: this.configPath,
+      isProjectLocal: this.isProjectLocalConfig(),
+      projectInfo: this.projectManager.projectInfo,
+      hasGlobalConfig: this.hasGlobalConfig(),
+      configExists: fs.existsSync(this.configPath)
+    };
+  }
+
+  /**
+   * Gets the current config file path
+   * @returns {string} Config file path
+   */
+  getConfigPath() {
+    return this.configPath;
+  }
+}
+
+// Export singleton instance
+export const configLoader = new ConfigLoader();
+export default configLoader;