@dynamicu/chromedebug-mcp 2.2.0

package/chrome-extension/data-buffer.js

@@ -0,0 +1,435 @@
+// IndexedDB Circular Buffer for Chrome Debug Full Data Recording
+// Provides resilient client-side buffering with compression support
+
+class DataBuffer {
+  constructor() {
+    this.dbName = 'ChromePilotDataBuffer';
+    this.version = 1;
+    this.db = null;
+    this.maxBufferSize = 100 * 1024 * 1024; // 100MB default
+    this.currentSize = 0;
+    this.batchSize = 1000; // Events per batch
+    this.uploadQueue = [];
+    this.isUploading = false;
+  }
+
+  async init() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+      
+      request.onerror = () => {
+        console.error('[DataBuffer] Failed to open IndexedDB:', request.error);
+        reject(request.error);
+      };
+      
+      request.onsuccess = () => {
+        this.db = request.result;
+        console.log('[DataBuffer] IndexedDB initialized');
+        this.calculateCurrentSize();
+        resolve();
+      };
+      
+      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 
+          });
+          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 
+          });
+          batchesStore.createIndex('timestamp', 'timestamp', { unique: false });
+          batchesStore.createIndex('status', 'status', { unique: false });
+        }
+        
+        if (!db.objectStoreNames.contains('metadata')) {
+          db.createObjectStore('metadata', { keyPath: 'key' });
+        }
+      };
+    });
+  }
+
+  async addEvent(event) {
+    if (!this.db) await this.init();
+
+    // Add metadata
+    event.timestamp = event.timestamp || Date.now();
+    event.recording_id = event.recording_id || this.getCurrentRecordingId();
+
+    // CONTRACT B: Fallback logic for oversized logs
+    const eventSize = this.estimateSize(event);
+    if (eventSize > this.maxBufferSize * 0.5) { // If event exceeds 50% of buffer
+      console.warn('[DataBuffer] Oversized event detected, truncating message');
+      if (event.message && event.message.length > 10000) {
+        const originalLength = event.message.length;
+        event.message = event.message.substring(0, 10000) +
+                       `... [TRUNCATED: original ${originalLength} chars]`;
+      }
+    }
+
+    const transaction = this.db.transaction(['events'], 'readwrite');
+    const store = transaction.objectStore('events');
+
+    return new Promise((resolve, reject) => {
+      const request = store.add(event);
+
+      request.onsuccess = () => {
+        this.currentSize += this.estimateSize(event);
+        this.checkBufferLimits();
+        resolve(request.result);
+      };
+
+      request.onerror = () => {
+        console.error('[DataBuffer] Failed to add event:', request.error);
+        reject(request.error);
+      };
+    });
+  }
+
+  async addBatch(events) {
+    if (!this.db) await this.init();
+    
+    const transaction = this.db.transaction(['events'], 'readwrite');
+    const store = transaction.objectStore('events');
+    
+    return new Promise((resolve, reject) => {
+      let addedCount = 0;
+      
+      for (const event of events) {
+        event.timestamp = event.timestamp || Date.now();
+        event.recording_id = event.recording_id || this.getCurrentRecordingId();
+        
+        const request = store.add(event);
+        
+        request.onsuccess = () => {
+          addedCount++;
+          this.currentSize += this.estimateSize(event);
+          
+          if (addedCount === events.length) {
+            this.checkBufferLimits();
+            resolve(addedCount);
+          }
+        };
+        
+        request.onerror = () => {
+          console.error('[DataBuffer] Failed to add event in batch:', request.error);
+          reject(request.error);
+        };
+      }
+    });
+  }
+
+  async createBatch(recordingId) {
+    if (!this.db) await this.init();
+    
+    const transaction = this.db.transaction(['events', 'batches'], 'readwrite');
+    const eventsStore = transaction.objectStore('events');
+    const batchesStore = transaction.objectStore('batches');
+    
+    // Get events for this recording
+    const index = eventsStore.index('recording_id');
+    const range = IDBKeyRange.only(recordingId);
+    const events = [];
+    
+    return new Promise((resolve, reject) => {
+      const request = index.openCursor(range);
+      
+      request.onsuccess = async (event) => {
+        const cursor = event.target.result;
+        
+        if (cursor) {
+          events.push(cursor.value);
+          
+          if (events.length >= this.batchSize) {
+            // Create batch with current events
+            const batch = await this.saveBatch(events, recordingId);
+            await this.deleteEvents(events.map(e => e.id));
+            resolve(batch);
+          } else {
+            cursor.continue();
+          }
+        } else {
+          // No more events, create batch with what we have
+          if (events.length > 0) {
+            const batch = await this.saveBatch(events, recordingId);
+            await this.deleteEvents(events.map(e => e.id));
+            resolve(batch);
+          } else {
+            resolve(null);
+          }
+        }
+      };
+      
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  async saveBatch(events, recordingId) {
+    const batch = {
+      timestamp: Date.now(),
+      recording_id: recordingId,
+      events: events,
+      status: 'pending',
+      compressed: false,
+      size: this.estimateSize(events)
+    };
+    
+    // Compress if pako is available
+    if (typeof pako !== 'undefined') {
+      try {
+        const jsonString = JSON.stringify(events);
+        const compressed = pako.gzip(jsonString);
+        batch.events = Array.from(compressed); // Store as array for IndexedDB
+        batch.compressed = true;
+        batch.size = compressed.length;
+      } catch (error) {
+        console.error('[DataBuffer] Compression failed:', error);
+      }
+    }
+    
+    const transaction = this.db.transaction(['batches'], 'readwrite');
+    const store = transaction.objectStore('batches');
+    
+    return new Promise((resolve, reject) => {
+      const request = store.add(batch);
+      
+      request.onsuccess = () => {
+        batch.id = request.result;
+        resolve(batch);
+      };
+      
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  async deleteEvents(eventIds) {
+    const transaction = this.db.transaction(['events'], 'readwrite');
+    const store = transaction.objectStore('events');
+    
+    for (const id of eventIds) {
+      store.delete(id);
+    }
+    
+    return new Promise((resolve) => {
+      transaction.oncomplete = () => {
+        resolve();
+      };
+    });
+  }
+
+  async getPendingBatches() {
+    if (!this.db) await this.init();
+    
+    const transaction = this.db.transaction(['batches'], 'readonly');
+    const store = transaction.objectStore('batches');
+    const index = store.index('status');
+    const range = IDBKeyRange.only('pending');
+    
+    return new Promise((resolve, reject) => {
+      const request = index.getAll(range);
+      
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  async markBatchUploaded(batchId) {
+    const transaction = this.db.transaction(['batches'], 'readwrite');
+    const store = transaction.objectStore('batches');
+    
+    return new Promise((resolve, reject) => {
+      const getRequest = store.get(batchId);
+      
+      getRequest.onsuccess = () => {
+        const batch = getRequest.result;
+        if (batch) {
+          batch.status = 'uploaded';
+          const putRequest = store.put(batch);
+          
+          putRequest.onsuccess = () => {
+            resolve();
+          };
+          
+          putRequest.onerror = () => {
+            reject(putRequest.error);
+          };
+        } else {
+          resolve();
+        }
+      };
+      
+      getRequest.onerror = () => {
+        reject(getRequest.error);
+      };
+    });
+  }
+
+  async checkBufferLimits() {
+    // Implement FIFO circular buffer strategy
+    if (this.currentSize > this.maxBufferSize) {
+      console.log('[DataBuffer] Buffer limit exceeded, removing oldest batches');
+      await this.removeOldestBatches();
+    }
+  }
+
+  async removeOldestBatches() {
+    const transaction = this.db.transaction(['batches'], 'readwrite');
+    const store = transaction.objectStore('batches');
+    const index = store.index('timestamp');
+    
+    return new Promise((resolve, reject) => {
+      const request = index.openCursor();
+      let deletedSize = 0;
+      const targetSize = this.maxBufferSize * 0.95; // Retain 95% capacity (CONTRACT B fix)
+      
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        
+        if (cursor && this.currentSize - deletedSize > targetSize) {
+          const batch = cursor.value;
+          deletedSize += batch.size || 0;
+          store.delete(cursor.key);
+          cursor.continue();
+        } else {
+          this.currentSize -= deletedSize;
+          console.log(`[DataBuffer] Freed ${deletedSize} bytes`);
+          resolve();
+        }
+      };
+      
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+
+  async calculateCurrentSize() {
+    if (!this.db) return;
+    
+    const transaction = this.db.transaction(['events', 'batches'], 'readonly');
+    const eventsStore = transaction.objectStore('events');
+    const batchesStore = transaction.objectStore('batches');
+    
+    let totalSize = 0;
+    
+    // Calculate events size
+    const eventsRequest = eventsStore.getAll();
+    eventsRequest.onsuccess = () => {
+      const events = eventsRequest.result;
+      for (const event of events) {
+        totalSize += this.estimateSize(event);
+      }
+    };
+    
+    // Calculate batches size
+    const batchesRequest = batchesStore.getAll();
+    batchesRequest.onsuccess = () => {
+      const batches = batchesRequest.result;
+      for (const batch of batches) {
+        totalSize += batch.size || this.estimateSize(batch);
+      }
+      
+      this.currentSize = totalSize;
+      console.log(`[DataBuffer] Current buffer size: ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
+    };
+  }
+
+  estimateSize(obj) {
+    // Rough estimation of object size in bytes
+    const str = JSON.stringify(obj);
+    return str.length * 2; // Assuming 2 bytes per character (UTF-16)
+  }
+
+  getCurrentRecordingId() {
+    // Get from chrome.storage or use a default
+    return chrome.storage?.local ? 
+      new Promise((resolve) => {
+        chrome.storage.local.get(['currentRecordingId'], (result) => {
+          resolve(result.currentRecordingId || 'default');
+        });
+      }) : 'default';
+  }
+
+  async clear() {
+    if (!this.db) await this.init();
+    
+    const transaction = this.db.transaction(['events', 'batches'], 'readwrite');
+    const eventsStore = transaction.objectStore('events');
+    const batchesStore = transaction.objectStore('batches');
+    
+    eventsStore.clear();
+    batchesStore.clear();
+    
+    return new Promise((resolve) => {
+      transaction.oncomplete = () => {
+        this.currentSize = 0;
+        console.log('[DataBuffer] Buffer cleared');
+        resolve();
+      };
+    });
+  }
+
+  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,
+        batchCount: 0,
+        pendingBatches: 0,
+        uploadedBatches: 0,
+        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);
+      };
+    });
+  }
+}
+
+// Export for use in background script
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = DataBuffer;
+}