@dynamicu/chromedebug-mcp 2.2.0

package/chrome-extension/upload-manager.js

@@ -0,0 +1,323 @@
+// Upload Manager for Chrome Debug Full Data Recording
+// Handles reliable batch uploads with retry logic and compression
+
+// Version will be provided by background.js which imports this file
+console.log('[UploadManager] Loaded version: 2.0.4-BUILD-20250119');
+
+// Cleanup any existing stale intervals to prevent multiple instances
+if (typeof window !== 'undefined' && window._chromePilotUploadIntervals) {
+  window._chromePilotUploadIntervals.forEach(intervalId => clearInterval(intervalId));
+  window._chromePilotUploadIntervals = [];
+} else if (typeof window !== 'undefined') {
+  window._chromePilotUploadIntervals = [];
+}
+
+class UploadManager {
+  constructor(dataBuffer) {
+    // Validate dataBuffer parameter
+    if (!dataBuffer || typeof dataBuffer !== 'object') {
+      throw new Error('[UploadManager] Invalid dataBuffer provided to constructor');
+    }
+    
+    this.dataBuffer = dataBuffer;
+    this.uploadQueue = [];
+    this.isUploading = false;
+    this.retryAttempts = 3;
+    this.retryDelay = 1000; // Start with 1 second
+    this.maxRetryDelay = 30000; // Max 30 seconds
+    this.serverUrl = null;
+    this.uploadInterval = null;
+    this.uploadIntervalTime = 5000; // Check for uploads every 5 seconds
+  }
+
+  async init() {
+    // Get server URL from available ports
+    this.serverUrl = await this.findAvailableServer();
+    
+    if (!this.serverUrl) {
+      console.warn('[UploadManager] No server available, will retry later');
+      // Don't start periodic upload if no server is available
+      return false;
+    }
+    
+    // Only start periodic upload check if server is available
+    this.startPeriodicUpload();
+    
+    console.log('[UploadManager] Initialized with server:', this.serverUrl);
+    return true;
+  }
+
+  async findAvailableServer() {
+    const ports = [3001, 3000, 3002, 3028]; // From config
+    
+    for (const port of ports) {
+      try {
+        const response = await fetch(`http://localhost:${port}/chromedebug/status`, {
+          method: 'GET',
+          mode: 'cors'
+        });
+        
+        if (response.ok) {
+          return `http://localhost:${port}`;
+        }
+      } catch (error) {
+        // Try next port
+        continue;
+      }
+    }
+    
+    return null;
+  }
+
+  startPeriodicUpload() {
+    if (this.uploadInterval) {
+      clearInterval(this.uploadInterval);
+      // Remove from global tracking if it exists
+      if (typeof window !== 'undefined' && window._chromePilotUploadIntervals) {
+        const index = window._chromePilotUploadIntervals.indexOf(this.uploadInterval);
+        if (index > -1) {
+          window._chromePilotUploadIntervals.splice(index, 1);
+        }
+      }
+    }
+    
+    this.uploadInterval = setInterval(async () => {
+      if (!this.isUploading) {
+        await this.processUploadQueue();
+      }
+    }, this.uploadIntervalTime);
+    
+    // Track interval globally for cleanup
+    if (typeof window !== 'undefined') {
+      if (!window._chromePilotUploadIntervals) window._chromePilotUploadIntervals = [];
+      window._chromePilotUploadIntervals.push(this.uploadInterval);
+    }
+  }
+
+  stopPeriodicUpload() {
+    if (this.uploadInterval) {
+      clearInterval(this.uploadInterval);
+      // Remove from global tracking if it exists
+      if (typeof window !== 'undefined' && window._chromePilotUploadIntervals) {
+        const index = window._chromePilotUploadIntervals.indexOf(this.uploadInterval);
+        if (index > -1) {
+          window._chromePilotUploadIntervals.splice(index, 1);
+        }
+      }
+      this.uploadInterval = null;
+    }
+  }
+
+  async processUploadQueue() {
+    // IMMEDIATE defensive check - MUST be first line (v2.0 fix)
+    if (!this.dataBuffer || typeof this.dataBuffer.getPendingBatches !== 'function') {
+      console.warn('[UploadManager v2.0.3] DataBuffer not ready, skipping');
+      return;
+    }
+    
+    if (this.isUploading) return;
+    
+    this.isUploading = true;
+    
+    try {
+      // Check server availability
+      if (!this.serverUrl) {
+        this.serverUrl = await this.findAvailableServer();
+        if (!this.serverUrl) {
+          console.log('[UploadManager] No server available, skipping upload');
+          return;
+        }
+      }
+      
+      // Get pending batches from buffer
+      const batches = await this.dataBuffer.getPendingBatches();
+      
+      if (batches.length === 0) {
+        return;
+      }
+      
+      console.log(`[UploadManager] Processing ${batches.length} pending batches`);
+      
+      for (const batch of batches) {
+        const success = await this.uploadBatch(batch);
+        
+        if (success) {
+          await this.dataBuffer.markBatchUploaded(batch.id);
+          console.log(`[UploadManager] Batch ${batch.id} uploaded successfully`);
+        } else {
+          console.warn(`[UploadManager] Failed to upload batch ${batch.id}`);
+        }
+      }
+    } catch (error) {
+      console.error('[UploadManager] Error processing upload queue:', error);
+    } finally {
+      this.isUploading = false;
+    }
+  }
+
+  async uploadBatch(batch, attemptNumber = 1) {
+    try {
+      // Prepare the data
+      let data = batch.events;
+      let contentType = 'application/json';
+      let body;
+      
+      if (batch.compressed) {
+        // Data is compressed, send as binary
+        const uint8Array = new Uint8Array(data);
+        body = uint8Array.buffer;
+        contentType = 'application/octet-stream';
+      } else {
+        // Data is not compressed, send as JSON
+        body = JSON.stringify({
+          recording_id: batch.recording_id,
+          timestamp: batch.timestamp,
+          events: data
+        });
+      }
+      
+      // Determine endpoint based on data type
+      const endpoint = this.getEndpointForBatch(batch);
+      
+      const response = await fetch(`${this.serverUrl}${endpoint}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': contentType,
+          'X-Recording-ID': batch.recording_id,
+          'X-Batch-ID': batch.id.toString(),
+          'X-Compressed': batch.compressed ? 'true' : 'false'
+        },
+        body: body
+      });
+      
+      if (response.ok) {
+        return true;
+      }
+      
+      // Handle specific error codes
+      if (response.status === 413) {
+        // Payload too large, need to split the batch
+        console.warn('[UploadManager] Batch too large, splitting...');
+        return await this.splitAndUploadBatch(batch);
+      }
+      
+      if (response.status >= 500 && attemptNumber < this.retryAttempts) {
+        // Server error, retry with exponential backoff
+        const delay = Math.min(this.retryDelay * Math.pow(2, attemptNumber - 1), this.maxRetryDelay);
+        console.log(`[UploadManager] Server error, retrying in ${delay}ms...`);
+        await this.sleep(delay);
+        return await this.uploadBatch(batch, attemptNumber + 1);
+      }
+      
+      return false;
+    } catch (error) {
+      console.error('[UploadManager] Upload error:', error);
+      
+      if (attemptNumber < this.retryAttempts) {
+        const delay = Math.min(this.retryDelay * Math.pow(2, attemptNumber - 1), this.maxRetryDelay);
+        console.log(`[UploadManager] Network error, retrying in ${delay}ms...`);
+        await this.sleep(delay);
+        return await this.uploadBatch(batch, attemptNumber + 1);
+      }
+      
+      return false;
+    }
+  }
+
+  async splitAndUploadBatch(batch) {
+    // Split large batch into smaller chunks
+    const events = batch.compressed ? 
+      JSON.parse(pako.ungzip(new Uint8Array(batch.events), { to: 'string' })) : 
+      batch.events;
+    
+    const chunkSize = Math.ceil(events.length / 2);
+    const chunks = [];
+    
+    for (let i = 0; i < events.length; i += chunkSize) {
+      chunks.push(events.slice(i, i + chunkSize));
+    }
+    
+    let allSuccess = true;
+    
+    for (const chunk of chunks) {
+      const subBatch = {
+        ...batch,
+        events: chunk,
+        compressed: false // Send chunks uncompressed for simplicity
+      };
+      
+      // Compress the chunk if pako is available
+      if (typeof pako !== 'undefined') {
+        try {
+          const jsonString = JSON.stringify(chunk);
+          const compressed = pako.gzip(jsonString);
+          subBatch.events = Array.from(compressed);
+          subBatch.compressed = true;
+        } catch (error) {
+          console.error('[UploadManager] Compression failed for chunk:', error);
+        }
+      }
+      
+      const success = await this.uploadBatch(subBatch);
+      if (!success) {
+        allSuccess = false;
+      }
+    }
+    
+    return allSuccess;
+  }
+
+  getEndpointForBatch(batch) {
+    // All batch uploads go to the same endpoint
+    // The server will handle different event types internally
+    return '/chromedebug/upload/batch';
+  }
+
+  async queueForUpload(recordingId, events) {
+    // Add events to buffer and trigger upload if threshold reached
+    await this.dataBuffer.addBatch(events);
+    
+    // Check if we should create a batch
+    const stats = await this.dataBuffer.getStats();
+    if (stats.eventCount >= this.dataBuffer.batchSize) {
+      const batch = await this.dataBuffer.createBatch(recordingId);
+      if (batch && !this.isUploading) {
+        // Trigger immediate upload for important batches
+        this.processUploadQueue();
+      }
+    }
+  }
+
+  async forceUpload(recordingId) {
+    // Force creation and upload of all pending data for a recording
+    const batch = await this.dataBuffer.createBatch(recordingId);
+    if (batch) {
+      await this.processUploadQueue();
+    }
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async getStats() {
+    const bufferStats = await this.dataBuffer.getStats();
+    return {
+      ...bufferStats,
+      serverUrl: this.serverUrl,
+      isUploading: this.isUploading,
+      uploadQueueLength: this.uploadQueue.length
+    };
+  }
+
+  destroy() {
+    this.stopPeriodicUpload();
+    this.uploadQueue = [];
+    this.isUploading = false;
+  }
+}
+
+// Export for use in background script
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = UploadManager;
+}

package/chrome-extension/web-vitals.iife.js

@@ -0,0 +1 @@
+var webVitals=function(e){"use strict";let t=-1;const n=e=>{addEventListener("pageshow",(n=>{n.persisted&&(t=n.timeStamp,e(n))}),!0)},i=(e,t,n,i)=>{let s,r;return o=>{t.value>=0&&(o||i)&&(r=t.value-(s??0),(r||void 0===s)&&(s=t.value,t.delta=r,t.rating=((e,t)=>e>t[1]?"poor":e>t[0]?"needs-improvement":"good")(t.value,n),e(t)))}},s=e=>{requestAnimationFrame((()=>requestAnimationFrame((()=>e()))))},r=()=>{const e=performance.getEntriesByType("navigation")[0];if(e&&e.responseStart>0&&e.responseStart<performance.now())return e},o=()=>{const e=r();return e?.activationStart??0},c=(e,n=-1)=>{const i=r();let s="navigate";t>=0?s="back-forward-cache":i&&(document.prerendering||o()>0?s="prerender":document.wasDiscarded?s="restore":i.type&&(s=i.type.replace(/_/g,"-")));return{name:e,value:n,rating:"good",delta:0,entries:[],id:`v5-${Date.now()}-${Math.floor(8999999999999*Math.random())+1e12}`,navigationType:s}},a=new WeakMap;function d(e,t){return a.get(e)||a.set(e,new t),a.get(e)}class h{t;i=0;o=[];h(e){if(e.hadRecentInput)return;const t=this.o[0],n=this.o.at(-1);this.i&&t&&n&&e.startTime-n.startTime<1e3&&e.startTime-t.startTime<5e3?(this.i+=e.value,this.o.push(e)):(this.i=e.value,this.o=[e]),this.t?.(e)}}const f=(e,t,n={})=>{try{if(PerformanceObserver.supportedEntryTypes.includes(e)){const i=new PerformanceObserver((e=>{Promise.resolve().then((()=>{t(e.getEntries())}))}));return i.observe({type:e,buffered:!0,...n}),i}}catch{}},u=e=>{let t=!1;return()=>{t||(e(),t=!0)}};let l=-1;const m=new Set,v=()=>"hidden"!==document.visibilityState||document.prerendering?1/0:0,p=e=>{if("hidden"===document.visibilityState){if("visibilitychange"===e.type)for(const e of m)e();isFinite(l)||(l="visibilitychange"===e.type?e.timeStamp:0,removeEventListener("prerenderingchange",p,!0))}},g=()=>{if(l<0){const e=o(),t=document.prerendering?void 0:globalThis.performance.getEntriesByType("visibility-state").filter((t=>"hidden"===t.name&&t.startTime>e))[0]?.startTime;l=t??v(),addEventListener("visibilitychange",p,!0),addEventListener("prerenderingchange",p,!0),n((()=>{setTimeout((()=>{l=v()}))}))}return{get firstHiddenTime(){return l},onHidden(e){m.add(e)}}},y=e=>{document.prerendering?addEventListener("prerenderingchange",(()=>e()),!0):e()},b=[1800,3e3],E=(e,t={})=>{y((()=>{const r=g();let a,d=c("FCP");const h=f("paint",(e=>{for(const t of e)"first-contentful-paint"===t.name&&(h.disconnect(),t.startTime<r.firstHiddenTime&&(d.value=Math.max(t.startTime-o(),0),d.entries.push(t),a(!0)))}));h&&(a=i(e,d,b,t.reportAllChanges),n((n=>{d=c("FCP"),a=i(e,d,b,t.reportAllChanges),s((()=>{d.value=performance.now()-n.timeStamp,a(!0)}))})))}))},L=[.1,.25];let P=0,T=1/0,_=0;const M=e=>{for(const t of e)t.interactionId&&(T=Math.min(T,t.interactionId),_=Math.max(_,t.interactionId),P=_?(_-T)/7+1:0)};let w;const C=()=>w?P:performance.interactionCount??0,I=()=>{"interactionCount"in performance||w||(w=f("event",M,{type:"event",buffered:!0,durationThreshold:0}))};let F=0;class k{u=[];l=new Map;m;v;p(){F=C(),this.u.length=0,this.l.clear()}L(){const e=Math.min(this.u.length-1,Math.floor((C()-F)/50));return this.u[e]}h(e){if(this.m?.(e),!e.interactionId&&"first-input"!==e.entryType)return;const t=this.u.at(-1);let n=this.l.get(e.interactionId);if(n||this.u.length<10||e.duration>t.P){if(n?e.duration>n.P?(n.entries=[e],n.P=e.duration):e.duration===n.P&&e.startTime===n.entries[0].startTime&&n.entries.push(e):(n={id:e.interactionId,entries:[e],P:e.duration},this.l.set(n.id,n),this.u.push(n)),this.u.sort(((e,t)=>t.P-e.P)),this.u.length>10){const e=this.u.splice(10);for(const t of e)this.l.delete(t.id)}this.v?.(n)}}}const A=e=>{const t=globalThis.requestIdleCallback||setTimeout;"hidden"===document.visibilityState?e():(e=u(e),addEventListener("visibilitychange",e,{once:!0,capture:!0}),t((()=>{e(),removeEventListener("visibilitychange",e,{capture:!0})})))},B=[200,500];class S{m;h(e){this.m?.(e)}}const N=[2500,4e3],q=[800,1800],H=e=>{document.prerendering?y((()=>H(e))):"complete"!==document.readyState?addEventListener("load",(()=>H(e)),!0):setTimeout(e)};return e.CLSThresholds=L,e.FCPThresholds=b,e.INPThresholds=B,e.LCPThresholds=N,e.TTFBThresholds=q,e.onCLS=(e,t={})=>{const r=g();E(u((()=>{let o,a=c("CLS",0);const u=d(t,h),l=e=>{for(const t of e)u.h(t);u.i>a.value&&(a.value=u.i,a.entries=u.o,o())},m=f("layout-shift",l);m&&(o=i(e,a,L,t.reportAllChanges),r.onHidden((()=>{l(m.takeRecords()),o(!0)})),n((()=>{u.i=0,a=c("CLS",0),o=i(e,a,L,t.reportAllChanges),s((()=>o()))})),setTimeout(o))})))},e.onFCP=E,e.onINP=(e,t={})=>{if(!globalThis.PerformanceEventTiming||!("interactionId"in PerformanceEventTiming.prototype))return;const s=g();y((()=>{I();let r,o=c("INP");const a=d(t,k),h=e=>{A((()=>{for(const t of e)a.h(t);const t=a.L();t&&t.P!==o.value&&(o.value=t.P,o.entries=t.entries,r())}))},u=f("event",h,{durationThreshold:t.durationThreshold??40});r=i(e,o,B,t.reportAllChanges),u&&(u.observe({type:"first-input",buffered:!0}),s.onHidden((()=>{h(u.takeRecords()),r(!0)})),n((()=>{a.p(),o=c("INP"),r=i(e,o,B,t.reportAllChanges)})))}))},e.onLCP=(e,t={})=>{y((()=>{const r=g();let a,h=c("LCP");const l=d(t,S),m=e=>{t.reportAllChanges||(e=e.slice(-1));for(const t of e)l.h(t),t.startTime<r.firstHiddenTime&&(h.value=Math.max(t.startTime-o(),0),h.entries=[t],a())},v=f("largest-contentful-paint",m);if(v){a=i(e,h,N,t.reportAllChanges);const r=u((()=>{m(v.takeRecords()),v.disconnect(),a(!0)})),o=e=>{e.isTrusted&&(A(r),removeEventListener(e.type,o,{capture:!0}))};for(const e of["keydown","click","visibilitychange"])addEventListener(e,o,{capture:!0});n((n=>{h=c("LCP"),a=i(e,h,N,t.reportAllChanges),s((()=>{h.value=performance.now()-n.timeStamp,a(!0)}))}))}}))},e.onTTFB=(e,t={})=>{let s=c("TTFB"),a=i(e,s,q,t.reportAllChanges);H((()=>{const d=r();d&&(s.value=Math.max(d.responseStart-o(),0),s.entries=[d],a(!0),n((()=>{s=c("TTFB",0),a=i(e,s,q,t.reportAllChanges),a(!0)})))}))},e}({});

package/config/api-keys.json

@@ -0,0 +1,11 @@
+[
+  {
+    "id": "c8d93006-6483-494f-865f-f8bb8fba6e02",
+    "name": "Default Admin",
+    "role": "admin",
+    "hashedKey": "$2b$12$MNv6YBqYw1JumuiPr.1VxefkIgbzlEDJOm6T3BPlgWySGR820TqYy",
+    "createdAt": "2025-10-14T20:38:14.583Z",
+    "lastUsed": null,
+    "active": true
+  }
+]

package/config/chrome-pilot-config.json

@@ -0,0 +1,45 @@
+{
+  "serverPorts": {
+    "httpServer": {
+      "preferredPorts": [
+        3000,
+        3001,
+        3002,
+        3028,
+        3029,
+        3030
+      ],
+      "description": "Ports to try for HTTP server discovery, in priority order"
+    },
+    "mcpServer": {
+      "preferredPorts": [
+        3028,
+        3029,
+        3030,
+        3031,
+        3032,
+        3033
+      ],
+      "description": "Ports to try for MCP server discovery, in priority order"
+    },
+    "discoveryRange": {
+      "start": 3000,
+      "end": 3033,
+      "description": "Port range for automatic discovery when preferred ports are not available"
+    }
+  },
+  "chromeExtension": {
+    "extensionPath": null,
+    "extensionPathDescription": "Optional: Custom path to ChromeDebug extension. If null, will search standard locations. Can also be set via CHROMEDEBUG_EXTENSION_PATH environment variable.",
+    "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"
+  }
+}

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@dynamicu/chromedebug-mcp",
+  "version": "2.2.0",
+  "description": "ChromeDebug MCP - MCP server that provides full control over a Chrome browser instance for debugging and automation with AI assistants like Claude Code",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "chromedebug-mcp": "./src/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dynamicupgrade/ChromePilot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dynamicupgrade/ChromePilot/issues"
+  },
+  "homepage": "https://github.com/dynamicupgrade/ChromePilot#readme",
+  "scripts": {
+    "cleanup": "node scripts/cleanup-processes.js",
+    "cleanup-force": "node scripts/cleanup-processes.js --force",
+    "start": "npm run cleanup && node src/index.js",
+    "go": "NODE_ENV=development npm start",
+    "single-server": "npm run cleanup && node src/index.js --single-server",
+    "dev": "npm run cleanup && node --watch src/index.js",
+    "start-http": "npm run cleanup && node src/http-server.js",
+    "server": "npm run cleanup && node src/standalone-server.js",
+    "server-only": "npm run cleanup && node src/standalone-server.js",
+    "start-legacy": "node scripts/start.js",
+    "update-extension-config": "node scripts/generate-extension-config.js",
+    "setup-security": "node scripts/setup-security.js",
+    "config": "node scripts/config-manager.js",
+    "config-show": "node scripts/config-manager.js show",
+    "config-ports": "node scripts/config-manager.js list-ports",
+    "postinstall": "npm run update-extension-config",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest",
+    "test:watch": "NODE_OPTIONS='--experimental-vm-modules' jest --watch",
+    "test:coverage": "NODE_OPTIONS='--experimental-vm-modules' jest --coverage",
+    "test:unit": "NODE_OPTIONS='--experimental-vm-modules' jest --testPathPattern='(?<!integration)\\.test\\.js$'",
+    "test:integration": "NODE_OPTIONS='--experimental-vm-modules' jest --testPathPattern='integration\\.test\\.js$'",
+    "test:chrome": "NODE_OPTIONS='--experimental-vm-modules' jest tests/chrome-controller.test.js",
+    "test:http": "NODE_OPTIONS='--experimental-vm-modules' jest tests/http-server.test.js",
+    "test:db": "NODE_OPTIONS='--experimental-vm-modules' jest tests/database.test.js",
+    "test:dual-id-fix": "NODE_OPTIONS='--experimental-vm-modules' jest tests/dual-recording-id.test.js --testNamePattern='Dual Recording ID Fix Verification'",
+    "test:recording": "NODE_OPTIONS='--experimental-vm-modules' jest tests/recording-system-comprehensive.test.js",
+    "test:extension": "NODE_OPTIONS='--experimental-vm-modules' jest tests/chrome-extension-recording.test.js",
+    "test:migration": "NODE_OPTIONS='--experimental-vm-modules' jest tests/dual-id-migration.test.js",
+    "test:regression": "NODE_OPTIONS='--experimental-vm-modules' jest tests/recording-regression.test.js",
+    "test:recording-all": "NODE_OPTIONS='--experimental-vm-modules' jest tests/recording-system-comprehensive.test.js tests/chrome-extension-recording.test.js tests/dual-id-migration.test.js tests/recording-regression.test.js tests/dual-recording-id.test.js",
+    "run-migration": "node migrate-dual-ids.js",
+    "test:mcp": "NODE_OPTIONS='--experimental-vm-modules' jest tests/mcp-server.test.js",
+    "tbv:microtest": "cd chrome-extension && npm run tbv:microtest",
+    "build:free": "webpack --config webpack.config.free.cjs",
+    "build:pro": "webpack --config webpack.config.pro.cjs",
+    "build:both": "npm run build:free && npm run build:pro"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "chrome",
+    "debugger",
+    "puppeteer",
+    "automation",
+    "browser-automation",
+    "ai-assistant",
+    "claude-code",
+    "debugging",
+    "testing",
+    "screen-recording",
+    "developer-tools"
+  ],
+  "author": "dynamicupgrade",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "files": [
+    "src/",
+    "chrome-extension/*.js",
+    "!chrome-extension/test-*.js",
+    "!chrome-extension/jest.config.js",
+    "chrome-extension/*.css",
+    "chrome-extension/*.html",
+    "chrome-extension/*.png",
+    "chrome-extension/manifest.json",
+    "chrome-extension/README.md",
+    "config/",
+    "scripts/",
+    "README.md",
+    "LICENSE",
+    "CLAUDE.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "bcrypt": "^6.0.0",
+    "better-sqlite3": "^12.2.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "express-rate-limit": "^8.0.1",
+    "express-validator": "^7.2.1",
+    "firebase-admin": "^12.7.0",
+    "glob": "^11.0.0",
+    "helmet": "^8.1.0",
+    "joi": "^18.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.0.2",
+    "puppeteer": "^23.10.0",
+    "uuid": "^11.1.0",
+    "web-vitals": "^5.1.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.5",
+    "copy-webpack-plugin": "^13.0.1",
+    "jest": "^30.0.5",
+    "jsdom": "^27.0.0",
+    "puppeteer-core": "^24.16.0",
+    "sqlite3": "^5.1.7",
+    "supertest": "^7.1.4",
+    "webpack": "^5.102.1",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/scripts/cleanup-processes.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * Cleanup ChromeDebug MCP processes safely
+ * Only kills processes that were explicitly registered by our application
+ */
+
+import {
+  killAllRegisteredProcesses,
+  cleanupDeadProcesses,
+  getRegisteredProcesses,
+  findUntrackedChromePilotProcesses,
+  killUntrackedChromePilotProcesses
+} from '../src/services/process-tracker.js';
+
+async function main() {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const forceCleanup = args.includes('--force') || args.includes('-f');
+
+  console.log('ChromeDebug MCP Process Cleanup');
+  console.log('================================');
+  if (forceCleanup) {
+    console.log('⚠️  FORCE MODE: Will also clean up untracked ChromeDebug processes');
+  }
+
+  // First clean up any dead processes from tracking
+  const removedCount = cleanupDeadProcesses();
+  if (removedCount > 0) {
+    console.log(`Removed ${removedCount} dead processes from tracking`);
+  }
+
+  // Get current registered processes
+  const processes = getRegisteredProcesses();
+  let totalKilled = 0;
+  let totalFailed = 0;
+  let allKilledPids = [];
+
+  // Kill registered processes
+  if (processes.length > 0) {
+    console.log(`\nFound ${processes.length} registered ChromeDebug processes:`);
+    processes.forEach(proc => {
+      console.log(`  - PID ${proc.pid} (${proc.type}) started ${proc.startTime}`);
+    });
+
+    const results = await killAllRegisteredProcesses();
+    totalKilled += results.killed.length;
+    totalFailed += results.failed.length;
+    allKilledPids.push(...results.killed);
+
+    console.log('\nRegistered Process Cleanup:');
+    console.log(`Successfully killed: ${results.killed.length}`);
+    if (results.failed.length > 0) {
+      console.log(`Failed to kill: ${results.failed.length} - PIDs: ${results.failed.join(', ')}`);
+    }
+  } else {
+    console.log('\nNo registered ChromeDebug processes found');
+  }
+
+  // Handle untracked processes if --force flag is used
+  if (forceCleanup) {
+    console.log('\n🔍 Searching for untracked ChromeDebug processes...');
+    const untrackedResults = await killUntrackedChromePilotProcesses();
+
+    if (untrackedResults.total > 0) {
+      totalKilled += untrackedResults.killed.length;
+      totalFailed += untrackedResults.failed.length;
+      allKilledPids.push(...untrackedResults.killed);
+
+      console.log('\nUntracked Process Cleanup:');
+      console.log(`Successfully killed: ${untrackedResults.killed.length}`);
+      if (untrackedResults.failed.length > 0) {
+        console.log(`Failed to kill: ${untrackedResults.failed.length} - PIDs: ${untrackedResults.failed.join(', ')}`);
+      }
+    }
+  } else {
+    // Just show what untracked processes would be found
+    const untrackedProcesses = await findUntrackedChromePilotProcesses();
+    if (untrackedProcesses.length > 0) {
+      console.log(`\n💡 Found ${untrackedProcesses.length} untracked ChromeDebug processes:`);
+      untrackedProcesses.forEach(proc => {
+        console.log(`  - ${proc.description}`);
+      });
+      console.log('\n   Use --force flag to clean up untracked processes too');
+    }
+  }
+
+  // Final summary
+  console.log('\n' + '='.repeat(50));
+  console.log('Final Cleanup Results:');
+  console.log(`Total processes killed: ${totalKilled}`);
+  console.log(`Total failures: ${totalFailed}`);
+
+  if (allKilledPids.length > 0) {
+    console.log(`All killed PIDs: ${allKilledPids.join(', ')}`);
+  }
+
+  if (totalFailed > 0) {
+    console.log('\n⚠️  Some processes could not be killed. Check permissions or process status.');
+    process.exit(1);
+  }
+
+  console.log('\n✅ Cleanup completed successfully');
+}
+
+main().catch(error => {
+  console.error('Cleanup failed:', error);
+  process.exit(1);
+});