@dynamicu/chromedebug-mcp 2.2.0

package/chrome-extension/firebase-client.js

@@ -0,0 +1,278 @@
+import { FUNCTIONS_URL } from './firebase-config.module.js';
+
+/**
+ * Firebase License Client
+ * Handles license validation, usage tracking, and caching
+ *
+ * Privacy: Only transmits userId (anonymous UUID) and usage count
+ * NO recording data, NO PII, NO browsing history
+ */
+class FirebaseLicenseClient {
+  constructor() {
+    this.functionsUrl = FUNCTIONS_URL;
+    this.cacheKey = 'chromedebug_license_cache';
+    this.instanceIdKey = 'chromedebug_instance_id';
+    console.log('[License] Initialized with FUNCTIONS_URL:', this.functionsUrl);
+  }
+
+  /**
+   * Generate unique instance ID (once per installation)
+   * Used for device-based license validation
+   * @returns {Promise<string>} Instance ID
+   */
+  async generateInstanceId() {
+    const stored = await chrome.storage.local.get(this.instanceIdKey);
+    if (stored[this.instanceIdKey]) return stored[this.instanceIdKey];
+
+    const instanceId = crypto.randomUUID();
+    await chrome.storage.local.set({[this.instanceIdKey]: instanceId});
+    return instanceId;
+  }
+
+  /**
+   * Activate license with LemonSqueezy (first-time activation)
+   * @param {string} licenseKey - License key to activate
+   * @returns {Promise<{activated: boolean, instance?: object, error?: string}>}
+   */
+  async activateLicense(licenseKey) {
+    const deviceId = await this.generateInstanceId();
+
+    try {
+      console.log(`[License] Activating license ${licenseKey} with device ${deviceId}`);
+
+      const response = await fetch(`${this.functionsUrl}/activateLicense`, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({
+          licenseKey: licenseKey.trim(),
+          instanceName: deviceId
+        })
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || `HTTP ${response.status}`);
+      }
+
+      const data = await response.json();
+      console.log('[License] Activation response:', data);
+
+      // If activation successful, save the LemonSqueezy instance ID
+      if (data.activated && data.instance) {
+        await chrome.storage.local.set({
+          'ls_instance_id': data.instance.id,
+          'ls_license_key': licenseKey.trim(),
+          'activated_at': Date.now()
+        });
+        console.log(`[License] Saved LS instance ID: ${data.instance.id}`);
+      }
+
+      return data;
+    } catch (error) {
+      console.error('[License] Activation failed:', error);
+      return {
+        activated: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Validate license with Cloud Function
+   * This should be called AFTER activateLicense() on first use
+   * @param {string} licenseKey - License key to validate
+   * @returns {Promise<{valid: boolean, tier?: string, error?: string}>}
+   */
+  async validateLicense(licenseKey) {
+    try {
+      // Get LemonSqueezy instance ID (set during activation)
+      const stored = await chrome.storage.local.get(['ls_instance_id', 'ls_license_key']);
+      const instanceId = stored.ls_instance_id;
+
+      // If no instance ID yet, this license needs activation first
+      if (!instanceId) {
+        console.log('[License] No instance ID found - activating license first');
+        const activationResult = await this.activateLicense(licenseKey);
+
+        if (!activationResult.activated) {
+          return {
+            valid: false,
+            error: activationResult.error || 'Activation failed',
+            needsActivation: true
+          };
+        }
+
+        // Activation successful, get the new instance ID
+        const newStored = await chrome.storage.local.get('ls_instance_id');
+        const newInstanceId = newStored.ls_instance_id;
+
+        // Now validate with the new instance ID
+        return await this.validateWithInstanceId(licenseKey, newInstanceId);
+      }
+
+      // Instance ID exists, just validate
+      return await this.validateWithInstanceId(licenseKey, instanceId);
+
+    } catch (error) {
+      console.error('License validation failed:', error);
+      // Check cache for offline grace period
+      return await this.getCachedLicenseStatus();
+    }
+  }
+
+  /**
+   * Validate license with LemonSqueezy API (via Firebase proxy)
+   * @param {string} licenseKey - License key
+   * @param {string} instanceId - LemonSqueezy instance ID
+   * @returns {Promise<{valid: boolean, tier?: string}>}
+   */
+  async validateWithInstanceId(licenseKey, instanceId) {
+    console.log(`[License] Validating ${licenseKey} with instance ${instanceId}`);
+
+    const response = await fetch(`${this.functionsUrl}/validateLicense`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({licenseKey, instanceId})
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const data = await response.json();
+    console.log('[License] Validation response:', data);
+
+    // Map LemonSqueezy response to our format
+    const result = {
+      valid: data.valid === true && data.status === 'active',
+      tier: data.valid ? 'pro' : 'free',
+      status: data.status,
+      activationUsage: data.activationUsage,
+      activationLimit: data.activationLimit
+    };
+
+    // Cache result for 24 hours with 30-day grace period
+    if (result.valid) {
+      await this.cacheLicenseStatus({
+        valid: true,
+        tier: result.tier,
+        licenseKey: licenseKey,
+        cachedAt: Date.now(),
+        graceUntil: Date.now() + (30 * 24 * 60 * 60 * 1000) // 30 days
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Check usage limit for user
+   * @param {string} userId - Anonymous user ID
+   * @returns {Promise<{allowed: boolean, count?: number, limit?: number, offline?: boolean}>}
+   */
+  async checkUsageLimit(userId) {
+    // First check if user has valid pro license
+    const licenseStatus = await this.getCachedLicenseStatus();
+    if (licenseStatus.valid && licenseStatus.tier === 'pro') {
+      return {allowed: true, unlimited: true, tier: 'pro'};
+    }
+
+    const url = `${this.functionsUrl}/checkUsageLimit`;
+    try {
+      console.log('[License] Calling checkUsageLimit at:', url);
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({userId})
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('[License] Full error details:');
+      console.error('  URL:', url);
+      console.error('  Error message:', error.message);
+      console.error('  Error name:', error.name);
+      console.error('  Error stack:', error.stack);
+      console.warn('[License] Cloud Functions not deployed yet - using offline mode:', error.message);
+      // Offline: allow limited usage (5 recordings/day default)
+      return {allowed: true, offline: true, count: 0, limit: 5};
+    }
+  }
+
+  /**
+   * Increment usage count (call AFTER recording completes)
+   * @param {string} userId - Anonymous user ID
+   * @returns {Promise<{success: boolean, count?: number, offline?: boolean}>}
+   */
+  async incrementUsage(userId) {
+    // Don't increment for pro users
+    const licenseStatus = await this.getCachedLicenseStatus();
+    if (licenseStatus.valid && licenseStatus.tier === 'pro') {
+      return {success: true, tier: 'pro', skipped: true};
+    }
+
+    try {
+      const response = await fetch(`${this.functionsUrl}/incrementUsage`, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({userId})
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('Failed to increment usage:', error);
+      return {success: false, offline: true};
+    }
+  }
+
+  /**
+   * Cache license status locally
+   * @param {{valid: boolean, tier: string, cachedAt: number, graceUntil: number}} status
+   */
+  async cacheLicenseStatus(status) {
+    await chrome.storage.local.set({[this.cacheKey]: status});
+  }
+
+  /**
+   * Get cached license status with grace period handling
+   * @returns {Promise<{valid: boolean, tier?: string, offline?: boolean, expired?: boolean}>}
+   */
+  async getCachedLicenseStatus() {
+    const result = await chrome.storage.local.get(this.cacheKey);
+    const cached = result[this.cacheKey];
+
+    if (!cached) return {valid: false};
+
+    // Check if cache is stale (>24 hours)
+    const cacheAge = Date.now() - cached.cachedAt;
+    const cacheExpired = cacheAge > (24 * 60 * 60 * 1000);
+
+    if (cacheExpired) {
+      // Check if within grace period
+      if (Date.now() < cached.graceUntil) {
+        return {valid: cached.valid, tier: cached.tier, offline: true, gracePeriod: true};
+      }
+
+      return {valid: false, expired: true};
+    }
+
+    return {valid: cached.valid, tier: cached.tier};
+  }
+
+  /**
+   * Clear cached license (for logout/deactivation)
+   */
+  async clearLicenseCache() {
+    await chrome.storage.local.remove(this.cacheKey);
+  }
+}
+
+export { FirebaseLicenseClient };

package/chrome-extension/firebase-config.js

@@ -0,0 +1,32 @@
+/**
+ * Firebase Cloud Functions configuration
+ * Compatible with both service workers (importScripts) and ES6 modules
+ *
+ * SECURITY: This file is gitignored and contains your API key.
+ * The API key is restricted in Google Cloud Console.
+ */
+
+// Firebase configuration
+const FIREBASE_CONFIG = {
+  projectId: 'chrome-debug-mcp',
+  apiKey: 'AIzaSyDu4r5k7J4gb76CVN9evBNg3DV6KjworCE',
+  authDomain: 'chromedebug.com'
+};
+
+// Cloud Functions base URL
+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';
+
+// Make available globally for service worker context
+if (typeof self !== 'undefined') {
+  self.FIREBASE_CONFIG = FIREBASE_CONFIG;
+  self.FUNCTIONS_URL = FUNCTIONS_URL;
+  self.LEMONSQUEEZY_CHECKOUT_URL = LEMONSQUEEZY_CHECKOUT_URL;
+}
+
+// For ES6 module imports (popup.js)
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { FIREBASE_CONFIG, FUNCTIONS_URL, LEMONSQUEEZY_CHECKOUT_URL };
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Firebase Cloud Functions configuration
+ * ES6 module version for popup.js and firebase-client.js
+ *
+ * SECURITY: This file is gitignored and contains your API key.
+ * The API key is restricted in Google Cloud Console.
+ */
+
+// Firebase configuration
+const FIREBASE_CONFIG = {
+  projectId: 'chrome-debug-mcp',
+  apiKey: 'AIzaSyDu4r5k7J4gb76CVN9evBNg3DV6KjworCE',
+  authDomain: 'chromedebug.com'
+};
+
+// Cloud Functions base URL
+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';
+
+export { FIREBASE_CONFIG, FUNCTIONS_URL, LEMONSQUEEZY_CHECKOUT_URL };

package/chrome-extension/firebase-config.module.template.js

@@ -0,0 +1,27 @@
+/**
+ * Firebase Cloud Functions configuration TEMPLATE
+ * ES6 module version for popup.js and firebase-client.js
+ *
+ * IMPORTANT: This is a template file. Do NOT commit actual API keys.
+ *
+ * Setup Instructions:
+ * 1. Copy this file to firebase-config.module.js
+ * 2. Replace placeholder values with your actual Firebase configuration
+ * 3. Ensure firebase-config.module.js is in .gitignore
+ */
+
+// Firebase configuration (populate after Firebase project creation)
+const FIREBASE_CONFIG = {
+  projectId: 'YOUR_PROJECT_ID',
+  apiKey: 'YOUR_API_KEY_HERE',
+  authDomain: 'your-domain.com'
+};
+
+// Cloud Functions base URL (update after deployment)
+const FUNCTIONS_URL = `https://us-central1-${FIREBASE_CONFIG.projectId}.cloudfunctions.net`;
+
+// LemonSqueezy checkout URL
+// Production example: https://chromedebug.com/buy/996773cb-682b-430f-b9e3-9ce2130bd967
+const LEMONSQUEEZY_CHECKOUT_URL = 'https://your-store.lemonsqueezy.com/checkout';
+
+export { FIREBASE_CONFIG, FUNCTIONS_URL, LEMONSQUEEZY_CHECKOUT_URL };

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

@@ -0,0 +1,36 @@
+/**
+ * Firebase Cloud Functions configuration TEMPLATE
+ *
+ * IMPORTANT: This is a template file. Do NOT commit actual API keys.
+ *
+ * Setup Instructions:
+ * 1. Copy this file to firebase-config.js
+ * 2. Replace placeholder values with your actual Firebase configuration
+ * 3. Ensure firebase-config.js is in .gitignore
+ */
+
+// Firebase configuration (populate after Firebase project creation)
+const FIREBASE_CONFIG = {
+  projectId: 'YOUR_PROJECT_ID',
+  apiKey: 'YOUR_API_KEY_HERE',
+  authDomain: 'your-domain.com'
+};
+
+// Cloud Functions base URL (update after deployment)
+const FUNCTIONS_URL = `https://us-central1-${FIREBASE_CONFIG.projectId}.cloudfunctions.net`;
+
+// LemonSqueezy checkout URL
+// Production example: https://chromedebug.com/buy/996773cb-682b-430f-b9e3-9ce2130bd967
+const LEMONSQUEEZY_CHECKOUT_URL = 'https://your-store.lemonsqueezy.com/checkout';
+
+// Make available globally for service worker context
+if (typeof self !== 'undefined') {
+  self.FIREBASE_CONFIG = FIREBASE_CONFIG;
+  self.FUNCTIONS_URL = FUNCTIONS_URL;
+  self.LEMONSQUEEZY_CHECKOUT_URL = LEMONSQUEEZY_CHECKOUT_URL;
+}
+
+// For ES6 module imports (popup.js)
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { FIREBASE_CONFIG, FUNCTIONS_URL, LEMONSQUEEZY_CHECKOUT_URL };
+}