@dynamicu/chromedebug-mcp 2.2.0

package/src/shared-storage-old.js

@@ -0,0 +1,267 @@
+// Shared storage for recordings across all server instances
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STORAGE_FILE = path.join(__dirname, '.recordings-storage.json');
+
+class SharedRecordingStorage {
+  constructor() {
+    this.recordings = new Map();
+    this.initialized = false;
+    this.initPromise = this.init();
+  }
+
+  async init() {
+    await this.loadFromDisk();
+    this.initialized = true;
+  }
+
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initPromise;
+    }
+  }
+
+  async loadFromDisk() {
+    try {
+      const data = await fs.readFile(STORAGE_FILE, 'utf8');
+      const parsed = JSON.parse(data);
+      
+      // Convert arrays back to Maps for chunked recordings
+      const recordingsArray = parsed.recordings || [];
+      this.recordings = new Map(recordingsArray.map(([key, value]) => {
+        if (value.type === 'chunked_recording' && Array.isArray(value.chunks)) {
+          return [key, {
+            ...value,
+            chunks: new Map(value.chunks)
+          }];
+        }
+        return [key, value];
+      }));
+      
+      console.log(`Loaded ${this.recordings.size} recordings from disk`);
+    } catch (error) {
+      // File doesn't exist or is invalid, start fresh
+      console.log('No existing recordings file, starting fresh');
+    }
+  }
+
+  async saveToDisk() {
+    try {
+      // Convert Maps to arrays for JSON serialization
+      const recordingsArray = Array.from(this.recordings.entries()).map(([key, value]) => {
+        if (value.type === 'chunked_recording' && value.chunks instanceof Map) {
+          return [key, {
+            ...value,
+            chunks: Array.from(value.chunks.entries())
+          }];
+        }
+        return [key, value];
+      });
+      
+      const data = {
+        recordings: recordingsArray,
+        lastSaved: new Date().toISOString()
+      };
+      await fs.writeFile(STORAGE_FILE, JSON.stringify(data, null, 2));
+    } catch (error) {
+      console.error('Error saving recordings to disk:', error);
+    }
+  }
+
+  // Removed - no longer storing single recordings
+
+  async get(id) {
+    await this.ensureInitialized();
+    
+    // Try direct lookup first
+    let recording = this.recordings.get(id);
+    if (recording) return recording;
+    
+    // Try with session_ prefix for legacy chunks
+    recording = this.recordings.get(`session_${id}`);
+    if (recording) return recording;
+    
+    // Try with frame_session_ prefix for frame captures
+    recording = this.recordings.get(`frame_session_${id}`);
+    if (recording) return recording;
+    
+    // Also check if the ID itself already has the frame_session_ prefix
+    if (id.startsWith('frame_') && !id.startsWith('frame_session_')) {
+      // This is a frame session ID, look for it with the full key
+      for (const [key, value] of this.recordings.entries()) {
+        if (key === id || key === `frame_session_${id}`) {
+          return value;
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  async delete(id) {
+    await this.ensureInitialized();
+    
+    // Try direct deletion first
+    let result = this.recordings.delete(id);
+    
+    // Try with session_ prefix
+    if (!result) {
+      result = this.recordings.delete(`session_${id}`);
+    }
+    
+    // Try with frame_session_ prefix
+    if (!result) {
+      result = this.recordings.delete(`frame_session_${id}`);
+    }
+    
+    if (result) {
+      await this.saveToDisk();
+    }
+    
+    return result;
+  }
+
+  async list() {
+    await this.ensureInitialized();
+    
+    // Only list frame sessions
+    const sessions = [];
+    for (const [key, value] of this.recordings.entries()) {
+      if (key.startsWith('frame_session_') && value.type === 'frame_capture') {
+        sessions.push({
+          id: key.replace('frame_session_', ''),
+          sessionId: value.sessionId,
+          totalFrames: value.frames.length,
+          timestamp: value.timestamp
+        });
+      }
+    }
+    
+    return sessions.sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  // Removed chunked recording methods - no longer using chunked storage
+  
+  // Store frame batch for frame capture sessions
+  async storeFrameBatch(sessionId, frames) {
+    await this.ensureInitialized();
+    
+    const sessionKey = `frame_session_${sessionId}`;
+    let session = this.recordings.get(sessionKey);
+    
+    if (!session) {
+      // Create new frame session
+      session = {
+        type: 'frame_capture',
+        sessionId: sessionId,
+        timestamp: Date.now(),
+        frames: []
+      };
+      this.recordings.set(sessionKey, session);
+    }
+    
+    // Add frames to session
+    session.frames.push(...frames);
+    console.log(`Stored ${frames.length} frames for session ${sessionId}, total: ${session.frames.length}`);
+    
+    // Save to disk
+    await this.saveToDisk();
+    
+    return session;
+  }
+  
+  // Get frame session info
+  async getFrameSessionInfo(sessionId) {
+    await this.ensureInitialized();
+    
+    // Try with frame_session_ prefix first
+    let sessionKey = `frame_session_${sessionId}`;
+    let session = this.recordings.get(sessionKey);
+    
+    // If not found, try without prefix (direct sessionId)
+    if (!session) {
+      session = this.recordings.get(sessionId);
+    }
+    
+    if (!session || session.type !== 'frame_capture') {
+      return null;
+    }
+    
+    return {
+      sessionId: session.sessionId || sessionId,
+      totalFrames: session.frames.length,
+      timestamp: session.timestamp,
+      frameTimestamps: session.frames.map(f => f.timestamp)
+    };
+  }
+  
+  // Get specific frame from session
+  async getFrame(sessionId, frameIndex) {
+    await this.ensureInitialized();
+    
+    // Try with frame_session_ prefix first
+    let sessionKey = `frame_session_${sessionId}`;
+    let session = this.recordings.get(sessionKey);
+    
+    // If not found, try without prefix (direct sessionId)
+    if (!session) {
+      session = this.recordings.get(sessionId);
+    }
+    
+    if (!session || session.type !== 'frame_capture') {
+      return null;
+    }
+    
+    if (frameIndex < 0 || frameIndex >= session.frames.length) {
+      return null;
+    }
+    
+    return session.frames[frameIndex];
+  }
+  
+  // Get entire frame session
+  async getFrameSession(sessionId) {
+    await this.ensureInitialized();
+    
+    // Try with frame_session_ prefix first
+    let sessionKey = `frame_session_${sessionId}`;
+    let session = this.recordings.get(sessionKey);
+    
+    // If not found, try without prefix (direct sessionId)
+    if (!session) {
+      session = this.recordings.get(sessionId);
+    }
+    
+    if (!session || session.type !== 'frame_capture') {
+      return null;
+    }
+    
+    return session;
+  }
+  
+  // Update frame session
+  async updateFrameSession(sessionId, updatedSession) {
+    await this.ensureInitialized();
+    
+    const sessionKey = `frame_session_${sessionId}`;
+    const existingSession = this.recordings.get(sessionKey);
+    
+    if (!existingSession || existingSession.type !== 'frame_capture') {
+      throw new Error('Frame session not found');
+    }
+    
+    // Update the session
+    this.recordings.set(sessionKey, updatedSession);
+    
+    // Save to disk
+    await this.saveToDisk();
+    
+    return updatedSession;
+  }
+}
+
+// Export singleton instance
+export const sharedStorage = new SharedRecordingStorage();

package/src/standalone-server.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// Chrome Debug HTTP Server
+// This server handles communication with the Chrome extension for frame recording
+
+import { startHttpServer, startWebSocketServer } from './http-server.js';
+import { removePortFile } from './port-discovery.js';
+
+console.log('╔════════════════════════════════════════════════════════════════╗');
+console.log('║              Chrome Debug HTTP Server                          ║');
+console.log('║                                                                ║');
+console.log('║  This server enables Chrome extension features like:           ║');
+console.log('║  - Frame recording                                             ║');
+console.log('║  - Workflow recording                                          ║');
+console.log('║  - Visual element selection                                    ║');
+console.log('║                                                                ║');
+console.log('║  Keep this running while using Chrome Debug through Claude     ║');
+console.log('╚════════════════════════════════════════════════════════════════╝');
+console.log('');
+
+async function main() {
+  try {
+    // Start HTTP server
+    const httpPort = await startHttpServer();
+    console.log(`✓ HTTP server started on port ${httpPort}`);
+    
+    // Start WebSocket server
+    await startWebSocketServer();
+    console.log('✓ WebSocket server started');
+    
+    console.log('');
+    console.log('Server is ready! Chrome extension features are now available.');
+    console.log('Press Ctrl+C to stop the server.');
+    
+  } catch (error) {
+    console.error('Failed to start server:', error.message);
+    process.exit(1);
+  }
+}
+
+// Cleanup on exit
+process.on('SIGINT', () => {
+  console.log('\nShutting down server...');
+  removePortFile();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  removePortFile();
+  process.exit(0);
+});
+
+main().catch(console.error);

package/src/utils/extension-path.js

@@ -0,0 +1,145 @@
+/**
+ * Extension Path Discovery Utility
+ *
+ * Locates the ChromeDebug extension with flexible fallback logic.
+ * Supports bundled extensions, user installations, and custom paths.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Searches for the ChromeDebug extension in multiple locations with fallback logic
+ *
+ * Search priority:
+ * 1. Environment variable: CHROMEDEBUG_EXTENSION_PATH
+ * 2. Config file (loaded by caller): config.extensionPath
+ * 3. Standard user locations (~/ChromeDebug-Extension, ~/Downloads)
+ * 4. Platform-specific app directories
+ * 5. Bundled with server (relative path)
+ *
+ * @param {Object} config - Optional config object with extensionPath property
+ * @returns {string|null} Absolute path to extension directory, or null if not found
+ */
+export function getExtensionPath(config = {}) {
+  const searchPaths = [
+    // 1. Environment variable (highest priority)
+    process.env.CHROMEDEBUG_EXTENSION_PATH,
+
+    // 2. Config file setting
+    config.extensionPath,
+
+    // 3. Standard user locations
+    path.join(os.homedir(), 'ChromeDebug-Extension'),
+    path.join(os.homedir(), 'Documents', 'ChromeDebug-Extension'),
+    path.join(os.homedir(), 'Downloads', 'ChromeDebug-Extension'),
+
+    // 4. Platform-specific app directories
+    getPlatformSpecificPath(),
+
+    // 5. Bundled with npm package (fallback)
+    path.resolve(__dirname, '../../chrome-extension')
+  ];
+
+  for (const searchPath of searchPaths) {
+    if (!searchPath) continue;
+
+    const resolvedPath = path.resolve(searchPath);
+
+    if (validateExtensionPath(resolvedPath)) {
+      console.log(`[ExtensionPath] ✓ Found ChromeDebug extension at: ${resolvedPath}`);
+      return resolvedPath;
+    }
+  }
+
+  console.warn('[ExtensionPath] ⚠ ChromeDebug extension not found in any standard location');
+  console.warn('[ExtensionPath] Searched locations:');
+  searchPaths.filter(Boolean).forEach(p => console.warn(`[ExtensionPath]   - ${p}`));
+  console.warn('[ExtensionPath]');
+  console.warn('[ExtensionPath] To specify a custom location, use:');
+  console.warn('[ExtensionPath]   • Environment variable: CHROMEDEBUG_EXTENSION_PATH=/path/to/extension');
+  console.warn('[ExtensionPath]   • Config file: Set "extensionPath" in config/chrome-pilot-config.json');
+
+  return null;
+}
+
+/**
+ * Returns the platform-specific default installation directory
+ * @returns {string|null}
+ */
+function getPlatformSpecificPath() {
+  switch (process.platform) {
+    case 'darwin':  // macOS
+      return '/Applications/ChromeDebug/extension';
+    case 'win32':   // Windows
+      return 'C:\\Program Files\\ChromeDebug\\extension';
+    case 'linux':
+      return '/opt/chromedebug/extension';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Validates that a path contains a valid ChromeDebug extension
+ *
+ * Checks:
+ * - Directory exists
+ * - manifest.json exists
+ * - manifest.json is valid JSON
+ * - Extension name matches ChromeDebug
+ *
+ * @param {string} extensionPath - Path to validate
+ * @returns {boolean} True if path contains a valid ChromeDebug extension
+ */
+export function validateExtensionPath(extensionPath) {
+  if (!extensionPath) return false;
+
+  try {
+    const manifestPath = path.join(extensionPath, 'manifest.json');
+
+    // Check if manifest exists
+    if (!fs.existsSync(manifestPath)) {
+      return false;
+    }
+
+    // Validate manifest content
+    const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+    const manifest = JSON.parse(manifestContent);
+
+    // Verify it's the ChromeDebug extension
+    if (!manifest.name?.includes('ChromeDebug')) {
+      console.warn(`[ExtensionPath] ⚠ Extension at ${extensionPath} is not ChromeDebug (found: ${manifest.name})`);
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    // Invalid JSON or filesystem error
+    return false;
+  }
+}
+
+/**
+ * Gets extension metadata from manifest.json
+ * @param {string} extensionPath - Path to extension directory
+ * @returns {Object|null} Extension manifest data or null if invalid
+ */
+export function getExtensionInfo(extensionPath) {
+  if (!validateExtensionPath(extensionPath)) {
+    return null;
+  }
+
+  try {
+    const manifestPath = path.join(extensionPath, 'manifest.json');
+    const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+    return JSON.parse(manifestContent);
+  } catch (error) {
+    return null;
+  }
+}

package/src/utils.js

@@ -0,0 +1,187 @@
+import net from 'net';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export async function findAvailablePort(startPort = 3000, maxPort = 4000) {
+  for (let port = startPort; port <= maxPort; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available ports found between ${startPort} and ${maxPort}`);
+}
+
+/**
+ * Find available port with atomic lock coordination for multi-session safety
+ * @param {number} startPort - Starting port to check
+ * @param {number} maxPort - Maximum port to check  
+ * @param {string} sessionId - Session identifier for lock ownership
+ * @returns {Promise<{port: number, lockFile: string}>} Port and lock file info
+ */
+export async function findAvailablePortWithLock(startPort = 3000, maxPort = 4000, sessionId = null) {
+  const lockDir = path.join(os.tmpdir(), 'chromedebug-ports');
+  
+  // Ensure lock directory exists
+  try {
+    await fs.promises.mkdir(lockDir, { recursive: true });
+  } catch (error) {
+    // Directory might already exist, continue
+  }
+  
+  // Clean up stale locks first
+  await cleanupStaleLocks(lockDir);
+  
+  for (let port = startPort; port <= maxPort; port++) {
+    if (await isPortAvailable(port) && await tryLockPort(port, sessionId, lockDir)) {
+      const lockFile = getLockFilePath(port, lockDir);
+      return { port, lockFile };
+    }
+  }
+  throw new Error(`No available ports with lock found between ${startPort} and ${maxPort}`);
+}
+
+/**
+ * Try to atomically lock a port
+ * @param {number} port - Port to lock
+ * @param {string} sessionId - Session ID for lock ownership
+ * @param {string} lockDir - Lock directory path
+ * @returns {Promise<boolean>} True if port was successfully locked
+ */
+async function tryLockPort(port, sessionId, lockDir) {
+  const lockFile = getLockFilePath(port, lockDir);
+  const lockData = {
+    sessionId: sessionId || process.pid.toString(),
+    port,
+    timestamp: Date.now(),
+    pid: process.pid
+  };
+  
+  try {
+    // Atomic write with exclusive flag - fails if file exists
+    await fs.promises.writeFile(lockFile, JSON.stringify(lockData), { flag: 'wx' });
+    return true;
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      // Lock file exists, check if it's stale
+      return await handleExistingLock(lockFile, port);
+    }
+    return false;
+  }
+}
+
+/**
+ * Handle existing lock file - check if stale and clean up
+ * @param {string} lockFile - Path to lock file
+ * @param {number} port - Port number
+ * @returns {Promise<boolean>} True if lock was cleaned up and port is now available
+ */
+async function handleExistingLock(lockFile, port) {
+  try {
+    const lockData = JSON.parse(await fs.promises.readFile(lockFile, 'utf8'));
+    const lockAge = Date.now() - lockData.timestamp;
+    
+    // Consider locks older than 5 minutes as stale
+    const STALE_LOCK_THRESHOLD = 5 * 60 * 1000;
+    
+    if (lockAge > STALE_LOCK_THRESHOLD) {
+      // Try to remove stale lock
+      try {
+        await fs.promises.unlink(lockFile);
+        console.log(`Cleaned up stale port lock for port ${port}`);
+        return true;
+      } catch (cleanupError) {
+        // Another process might have cleaned it up, that's fine
+        return false;
+      }
+    }
+    
+    return false; // Lock is still valid
+  } catch (error) {
+    // Corrupted lock file, try to remove it
+    try {
+      await fs.promises.unlink(lockFile);
+      return true;
+    } catch (cleanupError) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Clean up all stale lock files
+ * @param {string} lockDir - Lock directory path
+ */
+async function cleanupStaleLocks(lockDir) {
+  try {
+    const files = await fs.promises.readdir(lockDir);
+    const STALE_LOCK_THRESHOLD = 5 * 60 * 1000;
+    
+    for (const file of files) {
+      if (!file.startsWith('port-') || !file.endsWith('.lock')) continue;
+      
+      const lockFile = path.join(lockDir, file);
+      try {
+        const lockData = JSON.parse(await fs.promises.readFile(lockFile, 'utf8'));
+        const lockAge = Date.now() - lockData.timestamp;
+        
+        if (lockAge > STALE_LOCK_THRESHOLD) {
+          await fs.promises.unlink(lockFile);
+          console.log(`Cleaned up stale lock file: ${file}`);
+        }
+      } catch (error) {
+        // Corrupted lock file, remove it
+        try {
+          await fs.promises.unlink(lockFile);
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
+      }
+    }
+  } catch (error) {
+    // Directory might not exist or be accessible, continue silently
+  }
+}
+
+/**
+ * Release a port lock
+ * @param {string} lockFile - Path to lock file to release
+ */
+export async function releasePortLock(lockFile) {
+  try {
+    await fs.promises.unlink(lockFile);
+  } catch (error) {
+    // Lock might have been cleaned up by another process, that's fine
+  }
+}
+
+/**
+ * Get lock file path for a port
+ * @param {number} port - Port number
+ * @param {string} lockDir - Lock directory path
+ * @returns {string} Lock file path
+ */
+function getLockFilePath(port, lockDir) {
+  return path.join(lockDir, `port-${port}.lock`);
+}
+
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+    
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    
+    server.listen(port);
+  });
+}