@dynamicu/chromedebug-mcp 2.2.0

package/src/port-discovery.js

@@ -0,0 +1,258 @@
+// Port discovery utilities for Chrome Debug
+// This helps Chrome extension and MCP clients find the running HTTP server
+//
+// Note: Claude Code (MCP client) may create .chromedebug-port-[UUID] files
+// to track multiple sessions. Our code only uses .chromedebug-port (no UUID).
+// We don't clean these files as we didn't create them.
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Session management for port discovery
+let currentSessionId = null;
+
+/**
+ * Get or generate a session ID for port discovery
+ */
+function getSessionId() {
+  if (!currentSessionId) {
+    currentSessionId = crypto.randomBytes(8).toString('hex');
+  }
+  return currentSessionId;
+}
+
+/**
+ * Set a custom session ID for port discovery
+ */
+export function setPortDiscoverySessionId(sessionId) {
+  if (typeof sessionId === 'string' && sessionId.match(/^[a-zA-Z0-9_-]+$/)) {
+    currentSessionId = sessionId;
+    console.log(`Port discovery session ID set to: ${sessionId}`);
+  } else {
+    throw new Error('Session ID must be alphanumeric with dashes/underscores only');
+  }
+}
+
+/**
+ * Get the session-specific port file path
+ */
+function getPortFilePath() {
+  const sessionId = getSessionId();
+  return path.join(__dirname, `../.chromedebug-port-${sessionId}`);
+}
+
+/**
+ * Get the legacy port file path (for backward compatibility)
+ */
+function getLegacyPortFilePath() {
+  return path.join(__dirname, '../.chromedebug-port');
+}
+
+/**
+ * Write the current port to a session-specific file for discovery
+ */
+export function writePortFile(port, options = {}) {
+  const { sessionId, writeLegacy = true } = options;
+
+  // Set session ID if provided
+  if (sessionId) {
+    setPortDiscoverySessionId(sessionId);
+  }
+
+  const portFilePath = getPortFilePath();
+  const legacyPortFilePath = getLegacyPortFilePath();
+
+  try {
+    // Write to session-specific file
+    fs.writeFileSync(portFilePath, port.toString());
+    console.log(`Port ${port} written to ${portFilePath} [Session: ${getSessionId()}]`);
+
+    // Optionally write to legacy file for backward compatibility
+    if (writeLegacy) {
+      try {
+        fs.writeFileSync(legacyPortFilePath, port.toString());
+      } catch (legacyError) {
+        console.warn(`Could not write legacy port file: ${legacyError.message}`);
+      }
+    }
+  } catch (error) {
+    console.error('Failed to write port file:', error);
+  }
+}
+
+/**
+ * Read the port from session-specific or legacy file
+ */
+export function readPortFile(sessionId = null) {
+  // If session ID provided, use that specific session
+  if (sessionId) {
+    try {
+      const sessionPortFile = path.join(__dirname, `../.chromedebug-port-${sessionId}`);
+      if (fs.existsSync(sessionPortFile)) {
+        const port = parseInt(fs.readFileSync(sessionPortFile, 'utf8').trim());
+        if (!isNaN(port)) {
+          return port;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to read session port file for ${sessionId}:`, error);
+    }
+  }
+
+  // Try current session file
+  const portFilePath = getPortFilePath();
+  try {
+    if (fs.existsSync(portFilePath)) {
+      const port = parseInt(fs.readFileSync(portFilePath, 'utf8').trim());
+      if (!isNaN(port)) {
+        return port;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read session port file:', error);
+  }
+
+  // Fall back to legacy file
+  const legacyPortFilePath = getLegacyPortFilePath();
+  try {
+    if (fs.existsSync(legacyPortFilePath)) {
+      const port = parseInt(fs.readFileSync(legacyPortFilePath, 'utf8').trim());
+      if (!isNaN(port)) {
+        return port;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read legacy port file:', error);
+  }
+
+  return null;
+}
+
+/**
+ * Remove the port files on shutdown
+ */
+export function removePortFile() {
+  const portFilePath = getPortFilePath();
+  const legacyPortFilePath = getLegacyPortFilePath();
+
+  try {
+    if (fs.existsSync(portFilePath)) {
+      fs.unlinkSync(portFilePath);
+      console.log(`Removed session port file: ${portFilePath}`);
+    }
+  } catch (error) {
+    console.error('Failed to remove session port file:', error);
+  }
+
+  // Only remove legacy file if no other sessions are using it
+  try {
+    if (fs.existsSync(legacyPortFilePath)) {
+      // Check if there are other session port files
+      const portFiles = fs.readdirSync(__dirname + '/..')
+        .filter(f => f.startsWith('.chromedebug-port-') && f !== `.chromedebug-port-${getSessionId()}`);
+
+      if (portFiles.length === 0) {
+        fs.unlinkSync(legacyPortFilePath);
+        console.log('Removed legacy port file (no other sessions)');
+      }
+    }
+  } catch (error) {
+    console.error('Failed to remove legacy port file:', error);
+  }
+}
+
+/**
+ * Try to discover the Chrome Debug server by checking multiple ports
+ */
+export async function discoverServer(preferredPorts = [3000, 3001, 3002, 3028], options = {}) {
+  const { sessionId, extendedRange = true } = options;
+
+  // Extend port range to reduce conflicts in multi-session environments
+  if (extendedRange) {
+    preferredPorts = [
+      ...preferredPorts,
+      // Original extended range (maintain backward compatibility)
+      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
+    ];
+  }
+
+  // First check session-specific port file
+  const filePort = readPortFile(sessionId);
+  if (filePort) {
+    preferredPorts.unshift(filePort);
+  }
+
+  // Try each port with exponential backoff
+  for (let i = 0; i < preferredPorts.length; i++) {
+    const port = preferredPorts[i];
+    try {
+      const response = await fetch(`http://localhost:${port}/chromedebug/status`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(1000) // 1 second timeout
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.status === 'online') {
+          console.log(`Discovered ChromeDebug server on port ${port}`);
+          return port;
+        }
+      }
+    } catch (error) {
+      // Port not available or wrong server, continue
+      // Add small delay for later ports to avoid overwhelming the system
+      if (i > 3) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get session information for port discovery
+ */
+export function getPortDiscoveryInfo() {
+  return {
+    sessionId: getSessionId(),
+    portFile: getPortFilePath(),
+    legacyPortFile: getLegacyPortFilePath(),
+    currentPort: readPortFile()
+  };
+}
+
+/**
+ * Find all active ChromeDebug sessions by scanning port files
+ */
+export function findActiveSessions() {
+  const sessions = [];
+
+  try {
+    const files = fs.readdirSync(__dirname + '/..');
+    const portFiles = files.filter(f => f.startsWith('.chromedebug-port-'));
+
+    for (const file of portFiles) {
+      const sessionId = file.replace('.chromedebug-port-', '');
+      try {
+        const port = parseInt(fs.readFileSync(path.join(__dirname, '..', file), 'utf8').trim());
+        if (!isNaN(port)) {
+          sessions.push({ sessionId, port, portFile: file });
+        }
+      } catch (error) {
+        console.warn(`Could not read port file ${file}: ${error.message}`);
+      }
+    }
+  } catch (error) {
+    console.error('Failed to scan for active sessions:', error);
+  }
+
+  return sessions;
+}

package/src/routes/admin.js

@@ -0,0 +1,182 @@
+import express from 'express';
+import { 
+  generateApiKey, 
+  listApiKeys, 
+  revokeApiKey,
+  activateApiKey,
+  deleteApiKey,
+  requireAdmin,
+  ROLES 
+} from '../middleware/auth.js';
+import { createValidator } from '../validation/schemas.js';
+import { createApiKeySchema, updateApiKeySchema } from '../validation/schemas.js';
+import { rateLimits } from '../middleware/security.js';
+
+const router = express.Router();
+
+// Apply admin authentication and rate limiting to all admin routes
+router.use(requireAdmin);
+router.use(rateLimits.auth);
+
+// Generate new API key
+router.post('/api-keys', createValidator(createApiKeySchema), (req, res) => {
+  try {
+    const { name, role } = req.body;
+    
+    // Validate role
+    if (!Object.values(ROLES).includes(role)) {
+      return res.status(400).json({
+        error: 'Invalid role',
+        validRoles: Object.values(ROLES)
+      });
+    }
+    
+    const result = generateApiKey(name, role);
+    
+    res.status(201).json({
+      success: true,
+      message: 'API key created successfully',
+      apiKey: result.apiKey,
+      keyInfo: result.keyData
+    });
+  } catch (error) {
+    console.error('Error creating API key:', error);
+    res.status(500).json({
+      error: 'Failed to create API key',
+      details: error.message
+    });
+  }
+});
+
+// List all API keys
+router.get('/api-keys', (req, res) => {
+  try {
+    const keys = listApiKeys();
+    res.json({
+      success: true,
+      keys,
+      total: keys.length
+    });
+  } catch (error) {
+    console.error('Error listing API keys:', error);
+    res.status(500).json({
+      error: 'Failed to list API keys',
+      details: error.message
+    });
+  }
+});
+
+// Update API key (revoke/activate)
+router.patch('/api-keys/:keyId', createValidator(updateApiKeySchema), (req, res) => {
+  try {
+    const { keyId } = req.params;
+    const { active } = req.body;
+    
+    if (typeof active === 'boolean') {
+      const success = active ? 
+        activateApiKey(keyId) :
+        revokeApiKey(keyId);
+      
+      if (success) {
+        res.json({
+          success: true,
+          message: active ? 'API key activated' : 'API key revoked'
+        });
+      } else {
+        res.status(404).json({
+          error: 'API key not found'
+        });
+      }
+    } else {
+      res.status(400).json({
+        error: 'Invalid update data'
+      });
+    }
+  } catch (error) {
+    console.error('Error updating API key:', error);
+    res.status(500).json({
+      error: 'Failed to update API key',
+      details: error.message
+    });
+  }
+});
+
+// Delete API key permanently
+router.delete('/api-keys/:keyId', (req, res) => {
+  try {
+    const { keyId } = req.params;
+    const success = deleteApiKey(keyId);
+    
+    if (success) {
+      res.json({
+        success: true,
+        message: 'API key deleted successfully'
+      });
+    } else {
+      res.status(404).json({
+        error: 'API key not found'
+      });
+    }
+  } catch (error) {
+    console.error('Error deleting API key:', error);
+    res.status(500).json({
+      error: 'Failed to delete API key',
+      details: error.message
+    });
+  }
+});
+
+// System status and security info
+router.get('/status', (req, res) => {
+  try {
+    const keys = listApiKeys();
+    const activeKeys = keys.filter(k => k.active);
+    
+    res.json({
+      success: true,
+      system: {
+        totalApiKeys: keys.length,
+        activeApiKeys: activeKeys.length,
+        roles: Object.values(ROLES),
+        securityFeatures: [
+          'API Key Authentication',
+          'JWT Bearer Tokens',
+          'Role-based Access Control',
+          'Rate Limiting',
+          'CORS Protection',
+          'Security Headers',
+          'Request Validation',
+          'Audit Logging'
+        ]
+      },
+      timestamp: new Date().toISOString()
+    });
+  } catch (error) {
+    console.error('Error getting admin status:', error);
+    res.status(500).json({
+      error: 'Failed to get status',
+      details: error.message
+    });
+  }
+});
+
+// Security audit log
+router.get('/audit-log', (req, res) => {
+  try {
+    // This would typically come from a proper audit log database
+    // For now, return a placeholder response
+    res.json({
+      success: true,
+      message: 'Audit logging not yet implemented',
+      note: 'Security events are currently logged to console'
+    });
+  } catch (error) {
+    console.error('Error getting audit log:', error);
+    res.status(500).json({
+      error: 'Failed to get audit log',
+      details: error.message
+    });
+  }
+});
+
+export default router;