@dynamicu/chromedebug-mcp 2.7.1 → 2.7.4

package/chrome-extension/browser-recording-manager.js

@@ -36,6 +36,7 @@ class BrowserRecordingManager {
         title: metadata.title || 'Browser Recording',
         frameCount: 0,
         status: 'recording',
+        isVideoMode: metadata.isVideoMode || false,
         metadata
       };
 
@@ -248,6 +249,39 @@ class BrowserRecordingManager {
     }
   }
 
+  /**
+   * Delete all recordings and their frames
+   * @returns {Promise<{success: boolean, deletedCount: number}>}
+   */
+  async deleteAllRecordings() {
+    try {
+      const recordings = await this.listRecordings();
+      let deletedCount = 0;
+
+      for (const recording of recordings) {
+        const result = await this.deleteRecording(recording.sessionId);
+        if (result.success) {
+          deletedCount++;
+        }
+      }
+
+      // Clear any active recordings
+      this.activeRecordings.clear();
+
+      return {
+        success: true,
+        deletedCount
+      };
+    } catch (error) {
+      console.error('Failed to delete all recordings:', error);
+      return {
+        success: false,
+        deletedCount: 0,
+        error: error.message
+      };
+    }
+  }
+
 }
 
 // Export for use in other extension files

package/chrome-extension/content.js

@@ -476,9 +476,15 @@ if (isExtensionValid()) {
       sendResponse({ success: true });
     } else if (request.action === 'recordingStarted') {
       // Recording indicator now handled by ScreenCaptureVisualFeedback
-      // console.log('[ChromeDebug MCP] Received recordingStarted message with scheduled start time:', request.scheduledStartTime);
+      console.log('[ChromeDebug MCP] Received recordingStarted, videoMode:', request.videoMode, 'sessionId:', request.sessionId);
       // Start tracking screen interactions with scheduled timing
-      startScreenInteractionTracking(request.scheduledStartTime, request.sessionId);
+      startScreenInteractionTracking(request.scheduledStartTime, request.sessionId, request.videoMode || false);
+      sendResponse({ success: true });
+    } else if (request.action === 'setMouseTrackingSettings') {
+      // Update mouse tracking settings (PRO-only feature)
+      mouseTrackingEnabled = request.enabled || false;
+      mouseSampleInterval = request.sampleInterval || 100;
+      // console.log('[ChromeDebug MCP] Mouse tracking settings updated:', { mouseTrackingEnabled, mouseSampleInterval });
       sendResponse({ success: true });
     } else if (request.action === 'recordingStopped') {
       // Recording indicator cleanup now handled by ScreenCaptureVisualFeedback
@@ -522,6 +528,18 @@ if (isExtensionValid()) {
         sendResponse({ success: false, error: error.message });
       });
       return true; // Keep channel open for async response
+    } else if (request.action === 'startScreenshotRecording') {
+      // Start screenshot recording mode (v2.7.3)
+      // console.log('[ChromeDebug MCP] Starting screenshot recording with settings:', request.settings);
+      screenshotModeTabId = request.tabId;
+      screenshotModeSessionId = request.sessionId;
+      startScreenshotRecordingMode(request.settings);
+      sendResponse({ success: true });
+    } else if (request.action === 'getScreenshotData') {
+      // Called by background script to retrieve screenshot data
+      // console.log('[ChromeDebug MCP] Getting screenshot data');
+      const screenshots = stopScreenshotRecordingMode();
+      sendResponse({ success: true, screenshots: screenshots });
     } else if (request.action === 'createRestorePoint') {
       // Create restore point for current workflow
       createRestorePoint(request.actionIndex || workflowActions.length).then(restorePointId => {
@@ -878,23 +896,21 @@ let workflowTabId = null; // Store tabId for use when stopping recording
 let lastScreenshotTime = 0;
 let pendingScreenshots = []; // Track pending screenshot captures
 
+// Screenshot recording mode variables (v2.7.3)
+let isScreenshotMode = false;
+let screenshotModeSettings = { countdown: 3, hideCursor: true };
+let screenshotModeActions = [];
+let screenshotModeIndicator = null;
+let screenshotModeTabId = null;
+let screenshotModeSessionId = null;
+let isCountdownActive = false; // Prevent multiple countdowns
+
 // Async screenshot capture without blocking click recording
 function captureScreenshotAsync(action, actionIndex) {
   // Create the async capture promise
   const capturePromise = (async () => {
     try {
-      // Chrome API rate limit: ~1-2 screenshots per second
-      // We enforce 600ms minimum between screenshots to stay under the limit
-      const MIN_SCREENSHOT_INTERVAL = 600; // milliseconds
-      const now = Date.now();
-      const timeSinceLastScreenshot = now - lastScreenshotTime;
-
-      if (timeSinceLastScreenshot < MIN_SCREENSHOT_INTERVAL) {
-        // Wait until we can safely capture
-        const waitTime = MIN_SCREENSHOT_INTERVAL - timeSinceLastScreenshot;
-        await new Promise(resolve => setTimeout(resolve, waitTime));
-      }
-
+      // Throttling is handled centrally in background.js
       const screenshotData = await captureWorkflowScreenshot();
 
       if (screenshotData) {
@@ -1636,6 +1652,305 @@ async function stopWorkflowRecording() {
   };
 }
 
+// ============================================================
+// SCREENSHOT RECORDING MODE FUNCTIONS (v2.7.3)
+// Click-to-capture mode with configurable countdown
+// ============================================================
+
+/**
+ * Start screenshot recording mode
+ * @param {object} settings - {countdown: number, hideCursor: boolean}
+ */
+function startScreenshotRecordingMode(settings = {}) {
+  isScreenshotMode = true;
+  screenshotModeSettings = {
+    countdown: settings.countdown ?? 3,
+    hideCursor: settings.hideCursor ?? true
+  };
+  screenshotModeActions = [];
+  isCountdownActive = false;
+
+  // console.log('[Screenshot Mode] Starting with settings:', screenshotModeSettings);
+
+  // Create mode indicator
+  createScreenshotModeIndicator();
+
+  // Add click listener (capture phase to intercept before page handlers)
+  document.addEventListener('click', handleScreenshotModeClick, true);
+
+  // Note: Cursor hiding is now done per-capture in handleScreenshotModeClick()
+  // This ensures the cursor is only hidden during the countdown/capture, not the entire session
+}
+
+/**
+ * Stop screenshot recording mode and return captured screenshots
+ */
+function stopScreenshotRecordingMode() {
+  // console.log('[Screenshot Mode] Stopping, captured:', screenshotModeActions.length, 'screenshots');
+
+  isScreenshotMode = false;
+  isCountdownActive = false;
+
+  // Remove click listener
+  document.removeEventListener('click', handleScreenshotModeClick, true);
+
+  // Remove mode indicator
+  removeScreenshotModeIndicator();
+
+  // Restore cursor
+  document.body.classList.remove('chromedebug-hide-cursor');
+
+  // Reset state variables
+  screenshotModeTabId = null;
+  screenshotModeSessionId = null;
+
+  // Return captured screenshots
+  const screenshots = screenshotModeActions.map(action => ({
+    data: action.screenshot_data,
+    timestamp: action.timestamp,
+    x: action.x,
+    y: action.y
+  }));
+
+  screenshotModeActions = [];
+  return screenshots;
+}
+
+/**
+ * Wait for browser repaint to complete
+ * Uses double-requestAnimationFrame to ensure DOM changes are painted
+ */
+function waitForRepaint() {
+  return new Promise(resolve => {
+    requestAnimationFrame(() => {
+      requestAnimationFrame(resolve);
+    });
+  });
+}
+
+/**
+ * Handle click event in screenshot mode
+ */
+async function handleScreenshotModeClick(event) {
+  if (!isScreenshotMode) return;
+
+  // Prevent multiple countdowns at once
+  if (isCountdownActive) {
+    // console.log('[Screenshot Mode] Countdown already active, ignoring click');
+    return;
+  }
+
+  // CRITICAL: Capture tabId at click time (per Second Opinion review)
+  // This ensures countdown captures the correct tab even if user switches
+  const currentTabId = screenshotModeTabId;
+
+  // Get click position
+  const clickX = event.clientX;
+  const clickY = event.clientY;
+
+  // console.log('[Screenshot Mode] Click detected at:', clickX, clickY);
+
+  // Don't prevent default - let the click happen
+  // The countdown gives time for page to respond
+
+  const countdown = screenshotModeSettings.countdown;
+
+  isCountdownActive = true;
+
+  try {
+    // CRITICAL: Hide indicator BEFORE countdown/capture to prevent it appearing in screenshot
+    // Using visibility:hidden (not display:none) to avoid layout reflow
+    if (screenshotModeIndicator) {
+      screenshotModeIndicator.style.visibility = 'hidden';
+    }
+
+    // Hide cursor just before capture if setting enabled (per Second Opinion review)
+    // Cursor is only hidden during countdown/capture, not the entire session
+    if (screenshotModeSettings.hideCursor) {
+      // Ensure style tag exists (lazy injection)
+      if (!document.getElementById('chromedebug-hide-cursor-style')) {
+        const style = document.createElement('style');
+        style.id = 'chromedebug-hide-cursor-style';
+        style.textContent = '.chromedebug-hide-cursor { cursor: none !important; }';
+        document.head.appendChild(style);
+      }
+      document.body.classList.add('chromedebug-hide-cursor');
+      await waitForRepaint(); // Ensure cursor is actually hidden before proceeding
+    }
+
+    if (countdown > 0) {
+      await showCountdownOverlay(countdown);
+      // showCountdownOverlay now includes waitForRepaint after overlay removal
+    } else {
+      // No countdown - still need repaint delay for indicator to be hidden
+      await waitForRepaint();
+    }
+
+    // Capture screenshot via background script using captured tabId
+    const screenshot = await captureScreenshotForMode(currentTabId);
+
+    if (screenshot) {
+      screenshotModeActions.push({
+        type: 'screenshot',
+        timestamp: Date.now(),
+        x: clickX,
+        y: clickY,
+        screenshot_data: screenshot
+      });
+
+      // console.log('[Screenshot Mode] Screenshot captured, total:', screenshotModeActions.length);
+
+      // Update indicator count
+      updateScreenshotModeIndicatorCount();
+    }
+  } catch (error) {
+    console.error('[Screenshot Mode] Error capturing screenshot:', error);
+  } finally {
+    isCountdownActive = false;
+
+    // Restore cursor visibility after capture
+    if (screenshotModeSettings.hideCursor) {
+      document.body.classList.remove('chromedebug-hide-cursor');
+    }
+
+    // Restore indicator visibility - check element still exists in DOM
+    if (screenshotModeIndicator && document.body.contains(screenshotModeIndicator)) {
+      screenshotModeIndicator.style.visibility = 'visible';
+    }
+  }
+}
+
+/**
+ * Capture screenshot through background script
+ */
+async function captureScreenshotForMode(tabId) {
+  return new Promise((resolve, reject) => {
+    if (!isExtensionValid()) {
+      reject(new Error('Extension context invalidated'));
+      return;
+    }
+
+    chrome.runtime.sendMessage({
+      action: 'captureScreenshotForMode',
+      tabId: tabId
+    }, (response) => {
+      if (chrome.runtime.lastError) {
+        reject(chrome.runtime.lastError);
+        return;
+      }
+      if (response && response.success) {
+        resolve(response.screenshot);
+      } else {
+        reject(new Error(response?.error || 'Failed to capture screenshot'));
+      }
+    });
+  });
+}
+
+/**
+ * Show countdown overlay before capturing screenshot
+ */
+async function showCountdownOverlay(seconds) {
+  const overlay = document.createElement('div');
+  overlay.id = 'chromedebug-countdown-overlay';
+  overlay.style.cssText = `
+    position: fixed;
+    top: 0; left: 0; right: 0; bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 2147483647;
+    pointer-events: none;
+    background: rgba(0,0,0,0.3);
+  `;
+
+  const circle = document.createElement('div');
+  circle.style.cssText = `
+    width: 200px; height: 200px;
+    border-radius: 50%;
+    background: rgba(0,0,0,0.8);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: white;
+    font-size: 120px;
+    font-family: Arial, sans-serif;
+    font-weight: bold;
+  `;
+
+  overlay.appendChild(circle);
+  document.body.appendChild(overlay);
+
+  for (let i = seconds; i > 0; i--) {
+    circle.textContent = i;
+    await new Promise(r => setTimeout(r, 1000));
+  }
+
+  overlay.remove();
+
+  // Wait for browser to complete repaint after overlay removal
+  // This ensures the overlay doesn't appear in the captured screenshot
+  await waitForRepaint();
+}
+
+/**
+ * Create screenshot mode indicator
+ */
+function createScreenshotModeIndicator() {
+  // Remove any existing indicator
+  removeScreenshotModeIndicator();
+
+  const indicator = document.createElement('div');
+  indicator.id = 'chromedebug-screenshot-indicator';
+  indicator.style.cssText = `
+    position: fixed;
+    top: 10px; right: 10px;
+    padding: 8px 16px;
+    background: #FF9800;
+    color: white;
+    border-radius: 20px;
+    font-family: Arial, sans-serif;
+    font-size: 14px;
+    z-index: 2147483647;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.3);
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  `;
+  indicator.innerHTML = `
+    <span style="font-size: 16px;">📸</span>
+    <span>Click to capture</span>
+    <span id="chromedebug-screenshot-count" style="background: rgba(255,255,255,0.3); padding: 2px 8px; border-radius: 10px; font-weight: bold;">0</span>
+  `;
+  document.body.appendChild(indicator);
+  screenshotModeIndicator = indicator;
+}
+
+/**
+ * Remove screenshot mode indicator
+ */
+function removeScreenshotModeIndicator() {
+  if (screenshotModeIndicator) {
+    screenshotModeIndicator.remove();
+    screenshotModeIndicator = null;
+  }
+  // Also try to remove by ID in case reference was lost
+  const existing = document.getElementById('chromedebug-screenshot-indicator');
+  if (existing) {
+    existing.remove();
+  }
+}
+
+/**
+ * Update screenshot mode indicator count
+ */
+function updateScreenshotModeIndicatorCount() {
+  const countElement = document.getElementById('chromedebug-screenshot-count');
+  if (countElement) {
+    countElement.textContent = screenshotModeActions.length;
+  }
+}
+
 // Capture DOM snapshot with form values and states
 function captureDOMSnapshot() {
   const snapshot = {
@@ -1962,6 +2277,9 @@ async function recordScreenClick(event) {
     xpath: getXPath(element),
     x: event.clientX,
     y: event.clientY,
+    viewportWidth: window.innerWidth,   // For scaling during playback
+    viewportHeight: window.innerHeight,
+    devicePixelRatio: window.devicePixelRatio,  // Critical for Retina/HiDPI display scaling
     timestamp: Date.now() - recordingScheduledStartTime  // Relative timestamp from scheduled start
   };
   
@@ -2159,21 +2477,51 @@ function recordScreenMouseUp(event) {
   screenRecordingDragStartElement = null;
 }
 
+// Mouse movement tracking (PRO-only feature)
+function handleMouseMove(e) {
+  const now = Date.now();
+  if (!mouseTrackingEnabled || !isScreenRecording) return;
+  if (now - lastMouseTime < mouseSampleInterval) return;
+
+  lastMouseTime = now;
+  sendScreenInteraction({
+    type: 'mousemove',
+    x: e.clientX,
+    y: e.clientY,
+    pageX: e.pageX,
+    pageY: e.pageY,
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight,
+    devicePixelRatio: window.devicePixelRatio,  // Critical for Retina/HiDPI display scaling
+    timestamp: now - recordingScheduledStartTime
+  });
+}
+
+function startMouseTracking() {
+  if (!mouseTrackingEnabled) return;
+  document.addEventListener('mousemove', handleMouseMove, { passive: true });
+}
+
+function stopMouseTracking() {
+  document.removeEventListener('mousemove', handleMouseMove);
+  lastMouseTime = 0;
+}
+
 // Global variables for synchronized timing
 let recordingScheduledStartTime = null;
 let recordingSessionId = null;
 
 // Start/stop screen interaction tracking
-function startScreenInteractionTracking(scheduledStartTime, sessionId) {
+function startScreenInteractionTracking(scheduledStartTime, sessionId, videoMode = false) {
   // Store the scheduled start time and session ID for timestamp calculations
   recordingScheduledStartTime = scheduledStartTime;
   recordingSessionId = sessionId;
 
   // console.log('[ChromePilot] Screen interaction tracking scheduled to start at:', new Date(scheduledStartTime));
 
-  // Trigger visual feedback start
+  // Trigger visual feedback start (pass videoMode for hidden indicator)
   if (window.screenCaptureVisualFeedback) {
-    window.screenCaptureVisualFeedback.handleStartScreenCapture({ sessionId, scheduledStartTime });
+    window.screenCaptureVisualFeedback.handleStartScreenCapture({ sessionId, scheduledStartTime, videoMode });
   }
 
   // Wait until the scheduled start time before activating tracking
@@ -2190,6 +2538,9 @@ function startScreenInteractionTracking(scheduledStartTime, sessionId) {
     document.addEventListener('mousedown', recordScreenMouseDown, true);
     document.addEventListener('mouseup', recordScreenMouseUp, true);
 
+    // Start mouse tracking if enabled (PRO-only feature)
+    startMouseTracking();
+
     // console.log('[ChromePilot] Screen interaction tracking started at scheduled time');
   }, waitTime);
 }
@@ -2197,6 +2548,9 @@ function startScreenInteractionTracking(scheduledStartTime, sessionId) {
 function stopScreenInteractionTracking() {
   isScreenRecording = false;
 
+  // Stop mouse tracking (PRO-only feature)
+  stopMouseTracking();
+
   // Array of cleanup operations for systematic execution
   const cleanupOperations = [
     () => document.removeEventListener('click', recordScreenClick, true),
@@ -2302,6 +2656,11 @@ let screenRecordingDragStartElement = null;
 let screenRecordingDragStartX = 0;
 let screenRecordingDragStartY = 0;
 
+// Mouse movement tracking (PRO-only feature)
+let mouseTrackingEnabled = false;
+let mouseSampleInterval = 100; // User-selectable: 50, 100, or 200ms
+let lastMouseTime = 0;
+
 // Full data recording system components
 let fullDataRecording = null;
 let dataBuffer = null;
@@ -2937,11 +3296,17 @@ class ScreenCaptureVisualFeedback {
   }
 
   handleStartScreenCapture(message) {
-    // console.log('[ScreenCapture] Starting new recording, current indicator exists:', !!this.recordingIndicatorElement);
+    // If we're already in video mode recording and got a redundant start message,
+    // ignore it to prevent re-showing the indicator
+    if (this.isRecording && this.isVideoMode) {
+      console.log('[Video Mode Debug] Already in video mode recording, ignoring redundant start message');
+      return;
+    }
+
     this.isRecording = true;
     this.actionCount = 0;
-    this.showRecordingIndicator();
-    // Action counter is now part of the unified indicator, initialized to 0 in HTML
+    this.isVideoMode = message.videoMode || false;
+    this.showRecordingIndicator(this.isVideoMode);
   }
 
   handleScreenCaptureInteraction(interaction) {
@@ -3023,7 +3388,15 @@ class ScreenCaptureVisualFeedback {
     // Action counter is now part of unified indicator, handled by hideRecordingIndicator
   }
 
-  showRecordingIndicator() {
+  showRecordingIndicator(videoMode = false) {
+    // Store video mode for use in countdown sequence
+    this.isVideoMode = videoMode;
+    console.log('[Video Mode Debug] showRecordingIndicator called with videoMode:', videoMode);
+
+    // VIDEO MODE: Show countdown but hide the control menu after
+    // The countdown (3, 2, 1) will show so user knows when recording starts
+    // After countdown, the indicator is removed (handled in startCountdownSequence)
+
     // CRITICAL FIX: Clear any existing countdown interval FIRST
     if (this.countdownInterval) {
       // console.log('[ScreenCapture] Clearing existing countdown interval');
@@ -3119,22 +3492,39 @@ class ScreenCaptureVisualFeedback {
   startCountdownSequence() {
     let count = 3;
 
+    // Video mode: simpler countdown without action badge
+    const getCountdownHTML = (num) => {
+      if (this.isVideoMode) {
+        return `
+          <span style="color: #FF9800; font-size: 20px; animation: pulse 1.5s infinite;">🎥</span>
+          <span>Video recording in ${num}...</span>
+        `;
+      }
+      return `
+        <span style="color: #FF9800; font-size: 20px; animation: pulse 1.5s infinite;">●</span>
+        <span>Starting in ${num}...</span>
+        <span class="action-count-badge" style="background: rgba(255,255,255,0.2); padding: 2px 8px; border-radius: 12px; font-size: 12px;">0 actions</span>
+      `;
+    };
+
     // Initial countdown display
-    this.recordingIndicatorElement.innerHTML = `
-      <span style="color: #FF9800; font-size: 20px; animation: pulse 1.5s infinite;">●</span>
-      <span>Starting in ${count}...</span>
-      <span class="action-count-badge" style="background: rgba(255,255,255,0.2); padding: 2px 8px; border-radius: 12px; font-size: 12px;">0 actions</span>
-    `;
+    this.recordingIndicatorElement.innerHTML = getCountdownHTML(count);
 
     this.countdownInterval = setInterval(() => {
       count--;
+
+      // VIDEO MODE: Hide indicator at count=1 (before final frame) to ensure it's not captured
+      // Use visibility+opacity for immediate hiding without layout reflow
+      if (count === 1 && this.isVideoMode && this.recordingIndicatorElement) {
+        this.recordingIndicatorElement.style.visibility = 'hidden';
+        this.recordingIndicatorElement.style.opacity = '0';
+      }
+
       if (count > 0) {
-        // Update countdown
-        this.recordingIndicatorElement.innerHTML = `
-          <span style="color: #FF9800; font-size: 20px; animation: pulse 1.5s infinite;">●</span>
-          <span>Starting in ${count}...</span>
-          <span class="action-count-badge" style="background: rgba(255,255,255,0.2); padding: 2px 8px; border-radius: 12px; font-size: 12px;">0 actions</span>
-        `;
+        // Update countdown (but already hidden for video mode at count=1)
+        if (!this.isVideoMode || count > 1) {
+          this.recordingIndicatorElement.innerHTML = getCountdownHTML(count);
+        }
       } else {
         // Countdown complete! Notify background to start inactivity monitoring NOW
         if (isExtensionValid()) {
@@ -3143,6 +3533,22 @@ class ScreenCaptureVisualFeedback {
           });
         }
 
+        // VIDEO MODE: Hide indicator completely after countdown
+        // User must stop recording via popup (opens from browser extension icon)
+        console.log('[Video Mode Debug] Countdown complete. isVideoMode:', this.isVideoMode);
+        if (this.isVideoMode) {
+          console.log('[Video Mode Debug] HIDING mini controller for video mode');
+          clearInterval(this.countdownInterval);
+          this.countdownInterval = null;
+          // Remove indicator element completely
+          if (this.recordingIndicatorElement && this.recordingIndicatorElement.parentNode) {
+            this.recordingIndicatorElement.parentNode.removeChild(this.recordingIndicatorElement);
+            this.recordingIndicatorElement = null;
+            console.log('[Video Mode Debug] Mini controller REMOVED from DOM');
+          }
+          return; // Exit early, no need to show recording UI
+        }
+
         // Switch to recording display with two-row layout
         this.recordingIndicatorElement.style.pointerEvents = 'auto'; // Enable clicking
         this.recordingIndicatorElement.innerHTML = `

package/chrome-extension/firebase-config.public-sw.js

@@ -19,7 +19,7 @@ const FIREBASE_CONFIG = {
 const FUNCTIONS_URL = `https://us-central1-${FIREBASE_CONFIG.projectId}.cloudfunctions.net`;
 
 // LemonSqueezy checkout URL (Production)
-const LEMONSQUEEZY_CHECKOUT_URL = 'https://chromedebug.com/buy/996773cb-682b-430f-b9e3-9ce2130bd967';
+const LEMONSQUEEZY_CHECKOUT_URL = 'https://chromedebug.com/checkout/buy/996773cb-682b-430f-b9e3-9ce2130bd967';
 
 // Make available globally for service worker context
 if (typeof self !== 'undefined') {

package/chrome-extension/firebase-config.public.js

@@ -24,7 +24,7 @@ const FIREBASE_CONFIG = {
 const FUNCTIONS_URL = `https://us-central1-${FIREBASE_CONFIG.projectId}.cloudfunctions.net`;
 
 // LemonSqueezy checkout URL (Production)
-const LEMONSQUEEZY_CHECKOUT_URL = 'https://chromedebug.com/buy/996773cb-682b-430f-b9e3-9ce2130bd967';
+const LEMONSQUEEZY_CHECKOUT_URL = 'https://chromedebug.com/checkout/buy/996773cb-682b-430f-b9e3-9ce2130bd967';
 
 // Export for ES6 modules (popup.js, firebase-client.js)
 export { FIREBASE_CONFIG, FUNCTIONS_URL, LEMONSQUEEZY_CHECKOUT_URL };