@dynamicu/chromedebug-mcp 2.6.6 → 2.7.0

package/chrome-extension/data-buffer.js

@@ -4,7 +4,7 @@
 class DataBuffer {
   constructor() {
     this.dbName = 'ChromePilotDataBuffer';
-    this.version = 1;
+    this.version = 2; // Incremented for new object stores
     this.db = null;
     this.maxBufferSize = 100 * 1024 * 1024; // 100MB default
     this.currentSize = 0;
@@ -31,30 +31,48 @@ class DataBuffer {
       
       request.onupgradeneeded = (event) => {
         const db = event.target.result;
-        
+
         // Create object stores if they don't exist
         if (!db.objectStoreNames.contains('events')) {
-          const eventsStore = db.createObjectStore('events', { 
-            keyPath: 'id', 
-            autoIncrement: true 
+          const eventsStore = db.createObjectStore('events', {
+            keyPath: 'id',
+            autoIncrement: true
           });
           eventsStore.createIndex('timestamp', 'timestamp', { unique: false });
           eventsStore.createIndex('type', 'type', { unique: false });
           eventsStore.createIndex('recording_id', 'recording_id', { unique: false });
         }
-        
+
         if (!db.objectStoreNames.contains('batches')) {
-          const batchesStore = db.createObjectStore('batches', { 
-            keyPath: 'id', 
-            autoIncrement: true 
+          const batchesStore = db.createObjectStore('batches', {
+            keyPath: 'id',
+            autoIncrement: true
           });
           batchesStore.createIndex('timestamp', 'timestamp', { unique: false });
           batchesStore.createIndex('status', 'status', { unique: false });
         }
-        
+
         if (!db.objectStoreNames.contains('metadata')) {
           db.createObjectStore('metadata', { keyPath: 'key' });
         }
+
+        // New object stores for browser-only recording mode
+        if (!db.objectStoreNames.contains('browser_recordings')) {
+          const recordingsStore = db.createObjectStore('browser_recordings', {
+            keyPath: 'sessionId'
+          });
+          recordingsStore.createIndex('timestamp', 'startTime', { unique: false });
+          recordingsStore.createIndex('status', 'status', { unique: false });
+        }
+
+        if (!db.objectStoreNames.contains('browser_frames')) {
+          const framesStore = db.createObjectStore('browser_frames', {
+            keyPath: 'id',
+            autoIncrement: true
+          });
+          framesStore.createIndex('sessionId', 'sessionId', { unique: false });
+          framesStore.createIndex('frameIndex', 'frameIndex', { unique: false });
+        }
       };
     });
   }
@@ -390,11 +408,11 @@ class DataBuffer {
 
   async getStats() {
     if (!this.db) await this.init();
-    
+
     const transaction = this.db.transaction(['events', 'batches'], 'readonly');
     const eventsStore = transaction.objectStore('events');
     const batchesStore = transaction.objectStore('batches');
-    
+
     return new Promise((resolve) => {
       let stats = {
         eventCount: 0,
@@ -404,29 +422,200 @@ class DataBuffer {
         totalSize: this.currentSize,
         maxSize: this.maxBufferSize
       };
-      
+
       eventsStore.count().onsuccess = (e) => {
         stats.eventCount = e.target.result;
       };
-      
+
       batchesStore.count().onsuccess = (e) => {
         stats.batchCount = e.target.result;
       };
-      
+
       const pendingIndex = batchesStore.index('status');
       pendingIndex.count(IDBKeyRange.only('pending')).onsuccess = (e) => {
         stats.pendingBatches = e.target.result;
       };
-      
+
       pendingIndex.count(IDBKeyRange.only('uploaded')).onsuccess = (e) => {
         stats.uploadedBatches = e.target.result;
       };
-      
+
       transaction.oncomplete = () => {
         resolve(stats);
       };
     });
   }
+
+  // Browser-only recording methods
+  async addBrowserRecording(recording) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_recordings'], 'readwrite');
+    const store = transaction.objectStore('browser_recordings');
+
+    return new Promise((resolve, reject) => {
+      const request = store.add(recording);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async updateBrowserRecording(sessionId, updates) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_recordings'], 'readwrite');
+    const store = transaction.objectStore('browser_recordings');
+
+    return new Promise((resolve, reject) => {
+      const getRequest = store.get(sessionId);
+      getRequest.onsuccess = () => {
+        const recording = getRequest.result;
+        if (recording) {
+          Object.assign(recording, updates);
+          const putRequest = store.put(recording);
+          putRequest.onsuccess = () => resolve();
+          putRequest.onerror = () => reject(putRequest.error);
+        } else {
+          reject(new Error('Recording not found'));
+        }
+      };
+      getRequest.onerror = () => reject(getRequest.error);
+    });
+  }
+
+  async getBrowserRecording(sessionId) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_recordings'], 'readonly');
+    const store = transaction.objectStore('browser_recordings');
+
+    return new Promise((resolve, reject) => {
+      const request = store.get(sessionId);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getAllBrowserRecordings() {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_recordings'], 'readonly');
+    const store = transaction.objectStore('browser_recordings');
+
+    return new Promise((resolve, reject) => {
+      const request = store.getAll();
+      request.onsuccess = () => resolve(request.result || []);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async deleteBrowserRecording(sessionId) {
+    if (!this.db) await this.init();
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction(['browser_recordings'], 'readwrite');
+      const store = transaction.objectStore('browser_recordings');
+
+      // Delete the recording
+      const deleteRequest = store.delete(sessionId);
+      deleteRequest.onerror = () => reject(deleteRequest.error);
+
+      // Wait for transaction to COMPLETE (commit to disk), not just request success
+      // This prevents race condition where add() happens before delete() commits
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+
+  async addBrowserFrame(frame) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_frames'], 'readwrite');
+    const store = transaction.objectStore('browser_frames');
+
+    return new Promise((resolve, reject) => {
+      const request = store.add(frame);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getBrowserFrames(sessionId) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_frames'], 'readonly');
+    const store = transaction.objectStore('browser_frames');
+    const index = store.index('sessionId');
+
+    return new Promise((resolve, reject) => {
+      const request = index.getAll(IDBKeyRange.only(sessionId));
+      request.onsuccess = () => resolve(request.result || []);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getBrowserFrameCount(sessionId) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_frames'], 'readonly');
+    const store = transaction.objectStore('browser_frames');
+    const index = store.index('sessionId');
+
+    return new Promise((resolve, reject) => {
+      const request = index.count(IDBKeyRange.only(sessionId));
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async updateBrowserFrame(frameId, updates) {
+    if (!this.db) await this.init();
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction(['browser_frames'], 'readwrite');
+      const store = transaction.objectStore('browser_frames');
+
+      // Get the existing frame
+      const getRequest = store.get(frameId);
+      getRequest.onsuccess = () => {
+        const frame = getRequest.result;
+        if (!frame) {
+          reject(new Error(`Frame ${frameId} not found`));
+          return;
+        }
+
+        // Apply updates
+        Object.assign(frame, updates);
+
+        // Put the updated frame back
+        const putRequest = store.put(frame);
+        putRequest.onerror = () => reject(putRequest.error);
+      };
+      getRequest.onerror = () => reject(getRequest.error);
+
+      // Wait for transaction to complete
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+
+  async deleteBrowserFrames(sessionId) {
+    if (!this.db) await this.init();
+    const transaction = this.db.transaction(['browser_frames'], 'readwrite');
+    const store = transaction.objectStore('browser_frames');
+    const index = store.index('sessionId');
+
+    return new Promise((resolve, reject) => {
+      let deletedCount = 0;
+      const request = index.openCursor(IDBKeyRange.only(sessionId));
+
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          store.delete(cursor.primaryKey);
+          deletedCount++;
+          cursor.continue();
+        } else {
+          resolve(deletedCount);
+        }
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  }
 }
 
 // Export for use in background script

package/chrome-extension/extension-config.js

@@ -64,7 +64,7 @@ const CHROMEDEBUG_CONFIG = {
   3027
 ],
   discoveryTimeout: 3000,
-  lastGenerated: '2025-10-17T23:32:00.030Z'
+  lastGenerated: '2025-11-19T23:54:34.802Z'
 };
 
 // Export for use in extension scripts

package/chrome-extension/frame-capture.js

@@ -10,6 +10,7 @@ class FrameCapture {
     this.sessionId = null;
     this.startTime = null;
     this.totalFramesCaptured = 0;
+    this.mode = 'server'; // 'server' or 'browser-only'
     this.settings = {
       frameRate: 1,      // seconds between frames
       imageQuality: 30,  // JPEG quality (1-100)
@@ -23,6 +24,16 @@ class FrameCapture {
 
   }
 
+  setMode(mode) {
+    if (mode !== 'server' && mode !== 'browser-only') {
+      console.warn('[FrameCapture] Invalid mode:', mode, '- defaulting to server');
+      this.mode = 'server';
+    } else {
+      this.mode = mode;
+      console.log('[FrameCapture] Mode set to:', this.mode);
+    }
+  }
+
   async startCapture(streamId, tabId, sessionId, scheduledStartTime, settings = {}, ownerId = null) {
     if (this.isCapturing) return;
 
@@ -38,12 +49,22 @@ class FrameCapture {
     // Initialize lease tracking - null forces immediate first check
     this.lastLeaseCheck = null;
 
-    // Update settings with passed values
-    this.settings = {
-      frameRate: settings.frameRate || 1,
-      imageQuality: settings.imageQuality || 30,
-      frameFlash: settings.frameFlash !== false
-    };
+    // Update settings with passed values or apply mode-specific defaults
+    if (this.mode === 'browser-only') {
+      // Browser-only mode: ultra-low resolution and quality for storage efficiency
+      this.settings = {
+        frameRate: settings.frameRate || 1,
+        imageQuality: settings.imageQuality || 15,  // Lower quality for browser storage
+        frameFlash: settings.frameFlash !== false
+      };
+    } else {
+      // Server mode: standard settings
+      this.settings = {
+        frameRate: settings.frameRate || 1,
+        imageQuality: settings.imageQuality || 30,
+        frameFlash: settings.frameFlash !== false
+      };
+    }
 
     console.log('Starting frame capture session:', this.sessionId);
     console.log('Frame capture scheduled to start at:', new Date(scheduledStartTime));
@@ -68,16 +89,27 @@ class FrameCapture {
     this.totalFramesCaptured++;
     console.log('Created synthetic first frame at scheduled start time');
 
-    // Get the media stream with very low resolution optimized for Claude reading
-    const media = await navigator.mediaDevices.getUserMedia({
-      video: {
-        mandatory: {
-          chromeMediaSource: 'tab',
-          chromeMediaSourceId: streamId,
-          maxWidth: 640,  // Reduced from 960 for smaller files
-          maxHeight: 360  // Reduced from 540 for smaller files
+    // Get the media stream with resolution based on mode
+    const videoConstraints = this.mode === 'browser-only'
+      ? {
+          mandatory: {
+            chromeMediaSource: 'tab',
+            chromeMediaSourceId: streamId,
+            maxWidth: 480,   // Ultra-low resolution for browser storage
+            maxHeight: 270   // Ultra-low resolution for browser storage
+          }
         }
-      },
+      : {
+          mandatory: {
+            chromeMediaSource: 'tab',
+            chromeMediaSourceId: streamId,
+            maxWidth: 640,   // Standard resolution for server storage
+            maxHeight: 360   // Standard resolution for server storage
+          }
+        };
+
+    const media = await navigator.mediaDevices.getUserMedia({
+      video: videoConstraints,
       audio: false
     });
 
@@ -382,6 +414,11 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
   if (message.target !== 'offscreen') return;
 
   if (message.type === 'start-frame-capture') {
+    // Set mode before starting capture
+    if (message.mode) {
+      frameCapture.setMode(message.mode);
+    }
+
     frameCapture.startCapture(message.streamId, message.tabId, message.sessionId, message.scheduledStartTime, message.settings, message.ownerId)
       .then(() => sendResponse({ success: true }))
       .catch(error => {

package/chrome-extension/license-helper.js

@@ -12,12 +12,27 @@ const LicenseHelper = {
   instanceIdKey: 'chromedebug_instance_id',
   userIdKey: 'chromedebug_user_id',
 
+  /**
+   * Check if this is the PRO version by checking the manifest
+   * @returns {boolean} True if PRO version
+   */
+  isProVersion() {
+    const manifest = chrome.runtime.getManifest();
+    return manifest.name.includes('PRO');
+  },
+
   /**
    * Check if user can start a recording (license + usage limit check)
    * @returns {Promise<{allowed: boolean, message?: string, tier?: string}>}
    */
   async checkLicenseBeforeRecording() {
     try {
+      // PRO version: always allow, no restrictions
+      if (this.isProVersion()) {
+        console.log('[License] PRO version - bypassing all license checks');
+        return {allowed: true, tier: 'pro', proVersion: true};
+      }
+
       // Get userId
       const stored = await chrome.storage.local.get(this.userIdKey);
       let userId = stored[this.userIdKey];
@@ -70,6 +85,12 @@ const LicenseHelper = {
    */
   async trackUsageAfterRecording(userId) {
     try {
+      // PRO version: skip all usage tracking
+      if (this.isProVersion()) {
+        console.log('[License] PRO version - skipping usage tracking');
+        return {success: true, tier: 'pro', proVersion: true, skipped: true};
+      }
+
       if (!userId) {
         const stored = await chrome.storage.local.get(this.userIdKey);
         userId = stored[this.userIdKey];
@@ -155,6 +176,11 @@ const LicenseHelper = {
    * @returns {Promise<{valid: boolean, tier?: string}>}
    */
   async getCachedLicenseStatus() {
+    // PRO version: always return pro tier
+    if (this.isProVersion()) {
+      return {valid: true, tier: 'pro', proVersion: true};
+    }
+
     const result = await chrome.storage.local.get(this.cacheKey);
     const cached = result[this.cacheKey];
 

package/chrome-extension/manifest.free.json

@@ -1,8 +1,8 @@
 {
   "manifest_version": 3,
-  "name": "ChromeDebug MCP Assistant FREE v2.6.1",
-  "version": "2.6.1",
-  "description": "ChromeDebug MCP visual element selector [FREE Edition] [Build: 2025-10-28-v2.6.1]",
+  "name": "ChromeDebug MCP Assistant FREE v2.6.7",
+  "version": "2.6.7",
+  "description": "ChromeDebug MCP visual element selector [FREE Edition] [Build: 2025-11-10-v2.6.7]",
   "permissions": [
     "activeTab",
     "scripting",
@@ -12,9 +12,6 @@
     "notifications",
     "offscreen"
   ],
-  "host_permissions": [
-    "https://*.cloudfunctions.net/*"
-  ],
   "action": {
     "default_popup": "popup.html",
     "default_icon": {

package/chrome-extension/options.js

@@ -217,7 +217,7 @@ document.addEventListener('DOMContentLoaded', () => {
     
     const a = document.createElement('a');
     a.href = url;
-    a.download = 'chrome-pilot-site-settings.json';
+    a.download = 'chrome-debug-site-settings.json';
     a.click();
     
     URL.revokeObjectURL(url);