@buoy-gg/license 1.7.2

package/lib/commonjs/LicenseManager.js

@@ -0,0 +1,887 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LicenseManager = void 0;
+var _config = require("./config.js");
+var _api = require("./api.js");
+var _fingerprint = require("./fingerprint.js");
+/**
+ * LicenseManager - Singleton for managing React Buoy Pro licenses
+ *
+ * Handles license validation, machine activation, caching, and state management.
+ *
+ * New flow:
+ * 1. validateLicenseKey() - Check if license is valid, returns existing devices
+ * 2. registerDevice(deviceName) - Register new device with user-provided name
+ * 3. claimDevice(machineId) - Re-claim an existing device after storage clear
+ */
+
+// Note: We import types for the interface but use dynamic import for actual storage
+// to avoid TypeScript rootDir issues with workspace dependencies during build
+
+// Lazy load the storage module to avoid build issues
+let _persistentStorage = null;
+async function getPersistentStorage() {
+  if (_persistentStorage) return _persistentStorage;
+  try {
+    const mod = require("@buoy-gg/shared-ui/utils");
+    _persistentStorage = mod.persistentStorage;
+    return _persistentStorage;
+  } catch {
+    // Fallback to simple memory storage if shared-ui is not available
+    const memoryStore = new Map();
+    _persistentStorage = {
+      async getItem(key) {
+        return memoryStore.get(key) ?? null;
+      },
+      async setItem(key, value) {
+        memoryStore.set(key, value);
+      },
+      async removeItem(key) {
+        memoryStore.delete(key);
+      }
+    };
+    return _persistentStorage;
+  }
+}
+/**
+ * Result of license validation - indicates what action is needed
+ */
+
+/**
+ * Result of device registration
+ */
+
+class LicenseManagerImpl {
+  state = {
+    isInitialized: false,
+    isValidating: false,
+    isPro: false,
+    licenseKey: null,
+    error: null,
+    machineId: null,
+    maxMachines: null,
+    machineCount: 0,
+    expiresAt: null
+  };
+  listeners = new Set();
+  revalidationTimer = null;
+  cachedLicense = null;
+
+  // Temporary storage for license ID during registration flow
+  pendingLicenseId = null;
+
+  // Lock to prevent concurrent validation calls
+  validationInProgress = false;
+
+  // Lock to prevent concurrent registration calls
+  registrationInProgress = false;
+
+  // Promise for initialization to prevent double-init race condition
+  initPromise = null;
+
+  /**
+   * Initialize the license manager and load cached license
+   */
+  async initialize() {
+    // Return existing promise if already initializing
+    if (this.initPromise) return this.initPromise;
+    if (this.state.isInitialized) return;
+
+    // Store the promise so concurrent calls wait for the same initialization
+    this.initPromise = this._doInitialize();
+    return this.initPromise;
+  }
+
+  /**
+   * Internal initialization logic
+   */
+  async _doInitialize() {
+    if (this.state.isInitialized) return;
+    try {
+      // Load cached license from storage
+      const cached = await this.loadCachedLicense();
+      if (cached) {
+        this.cachedLicense = cached;
+        this.state.licenseKey = cached.licenseKey;
+        this.state.isPro = cached.isPro && this.isCacheValid(cached);
+        this.state.machineId = cached.machineId;
+        this.state.maxMachines = cached.maxMachines;
+        this.state.machineCount = cached.machineCount;
+        this.state.expiresAt = cached.expiresAt ? new Date(cached.expiresAt) : null;
+
+        // If we have a cached license with fingerprint, validate in background
+        if (cached.licenseKey && cached.fingerprint) {
+          this.validateInBackground(cached.licenseKey, cached.fingerprint);
+        }
+      }
+      this.state.isInitialized = true;
+      this.emit({
+        type: "initialized",
+        isPro: this.state.isPro
+      });
+
+      // Start periodic revalidation
+      this.startRevalidationTimer();
+    } catch (error) {
+      console.warn("[React Buoy] License initialization failed:", error);
+      this.state.isInitialized = true;
+      this.emit({
+        type: "initialized",
+        isPro: false
+      });
+    }
+  }
+
+  /**
+   * Validate a license key and check what action is needed
+   * Returns info about whether device registration is needed
+   */
+  async validateLicenseKey(licenseKey) {
+    // Prevent concurrent validation calls
+    if (this.validationInProgress) {
+      return {
+        valid: false,
+        needsDeviceRegistration: false,
+        existingDevices: [],
+        error: "Validation already in progress"
+      };
+    }
+    if (!licenseKey || typeof licenseKey !== "string") {
+      return {
+        valid: false,
+        needsDeviceRegistration: false,
+        existingDevices: [],
+        error: "Invalid license key"
+      };
+    }
+
+    // Normalize license key
+    const normalizedKey = licenseKey.trim().toUpperCase();
+    this.state.licenseKey = normalizedKey;
+    this.state.isValidating = true;
+    this.state.error = null;
+    this.validationInProgress = true;
+    this.emit({
+      type: "validating",
+      isPro: this.state.isPro
+    });
+    try {
+      // Validate the license without fingerprint first
+      const response = await (0, _api.validateLicense)(normalizedKey);
+      const result = (0, _api.parseValidationResult)(response);
+
+      // Check for fatal errors
+      if ((0, _api.isFatalLicenseError)(result.code)) {
+        this.state.isValidating = false;
+        this.state.error = result.detail;
+        await this.clearCachedLicense();
+        this.emit({
+          type: "error",
+          isPro: false,
+          error: result.detail
+        });
+        return {
+          valid: false,
+          needsDeviceRegistration: false,
+          existingDevices: [],
+          error: result.detail
+        };
+      }
+
+      // If response.data is null, the license is invalid
+      if (!response.data) {
+        this.state.isValidating = false;
+        this.state.error = result.detail || "License not found";
+        await this.clearCachedLicense();
+        this.emit({
+          type: "error",
+          isPro: false,
+          error: this.state.error
+        });
+        return {
+          valid: false,
+          needsDeviceRegistration: false,
+          existingDevices: [],
+          error: this.state.error
+        };
+      }
+
+      // Store license ID for registration flow
+      this.pendingLicenseId = response.data.id;
+      this.state.maxMachines = response.data.attributes.maxMachines;
+      this.state.machineCount = this.countMachines(response);
+
+      // For simulators, we don't require device registration
+      const isSimulatorDevice = (0, _fingerprint.isSimulator)();
+      if (isSimulatorDevice) {
+        // For simulators, consider Pro if license is valid OR if only issue is no machines registered
+        const isPro = result.valid || result.code === "NO_MACHINES";
+        this.state.isPro = isPro;
+        this.state.isValidating = false;
+        if (isPro) {
+          await this.saveLicenseToCache(response, normalizedKey, null, null);
+        }
+        this.emit({
+          type: "validated",
+          isPro
+        });
+        return {
+          valid: isPro,
+          needsDeviceRegistration: false,
+          existingDevices: [],
+          maxDevices: this.state.maxMachines ?? undefined,
+          currentDeviceCount: this.state.machineCount,
+          error: isPro ? undefined : result.detail
+        };
+      }
+
+      // Check if we have cached fingerprint for this license
+      if (this.cachedLicense?.fingerprint && this.cachedLicense.licenseKey === normalizedKey) {
+        // Re-validate with our stored fingerprint
+        const fingerprintResponse = await (0, _api.validateLicense)(normalizedKey, this.cachedLicense.fingerprint);
+        const fingerprintResult = (0, _api.parseValidationResult)(fingerprintResponse);
+        if (fingerprintResult.valid) {
+          // Our device is still registered
+          this.state.isPro = true;
+          this.state.isValidating = false;
+          this.state.machineId = this.cachedLicense.machineId;
+          await this.saveLicenseToCache(fingerprintResponse, normalizedKey, this.cachedLicense.fingerprint, this.cachedLicense.deviceName ?? null);
+          this.emit({
+            type: "validated",
+            isPro: true
+          });
+          return {
+            valid: true,
+            needsDeviceRegistration: false,
+            existingDevices: [],
+            maxDevices: this.state.maxMachines ?? undefined,
+            currentDeviceCount: this.state.machineCount
+          };
+        }
+      }
+
+      // Get existing devices for this license
+      let existingDevices = [];
+      try {
+        const machines = await (0, _api.getLicenseMachines)(response.data.id, normalizedKey);
+        existingDevices = machines.map(machine => ({
+          id: machine.id,
+          fingerprint: machine.attributes.fingerprint,
+          name: machine.attributes.name || "Unknown Device",
+          platform: machine.attributes.platform || "unknown",
+          model: machine.attributes.metadata?.model || null,
+          osVersion: machine.attributes.metadata?.osVersion || null,
+          appVersion: machine.attributes.metadata?.appVersion || null,
+          registeredAt: new Date(machine.attributes.created),
+          lastSeenAt: new Date(machine.attributes.updated),
+          isCurrentDevice: false // We don't have a fingerprint yet
+        }));
+      } catch {
+        // Failed to get devices, continue anyway
+      }
+
+      // Check if device registration is needed
+      // Device registration is needed if:
+      // 1. API says no machines (NO_MACHINE/NO_MACHINES code), OR
+      // 2. Too many machines (need to remove one), OR
+      // 3. This device has no cached fingerprint (meaning it's not registered yet)
+      const noMachinesOnLicense = (0, _api.needsMachineActivation)(result.code);
+      const tooManyMachines = (0, _api.hasTooManyMachines)(result.code);
+      const thisDeviceNotRegistered = !this.cachedLicense?.fingerprint;
+      const needsRegistration = noMachinesOnLicense || tooManyMachines || thisDeviceNotRegistered;
+      this.state.isValidating = false;
+      if ((0, _api.hasTooManyMachines)(result.code)) {
+        return {
+          valid: true,
+          // License is valid, just at device limit
+          needsDeviceRegistration: true,
+          existingDevices,
+          error: "Device limit reached. Remove an existing device or claim one.",
+          maxDevices: this.state.maxMachines ?? undefined,
+          currentDeviceCount: this.state.machineCount
+        };
+      }
+      return {
+        valid: true,
+        needsDeviceRegistration: needsRegistration,
+        existingDevices,
+        maxDevices: this.state.maxMachines ?? undefined,
+        currentDeviceCount: this.state.machineCount
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Validation failed";
+
+      // Check for network error and use cache
+      if (this.isNetworkError(error) && this.cachedLicense && this.isCacheValid(this.cachedLicense)) {
+        this.state.isPro = this.cachedLicense.isPro;
+        this.state.isValidating = false;
+        this.emit({
+          type: "validated",
+          isPro: this.state.isPro
+        });
+        return {
+          valid: this.state.isPro,
+          needsDeviceRegistration: false,
+          existingDevices: []
+        };
+      }
+      this.state.isValidating = false;
+      this.state.error = errorMessage;
+      this.emit({
+        type: "error",
+        isPro: false,
+        error: errorMessage
+      });
+      return {
+        valid: false,
+        needsDeviceRegistration: false,
+        existingDevices: [],
+        error: errorMessage
+      };
+    } finally {
+      this.validationInProgress = false;
+    }
+  }
+
+  /**
+   * Register a new device with a user-provided name
+   */
+  async registerDevice(deviceName) {
+    // Prevent concurrent registration calls
+    if (this.registrationInProgress) {
+      const error = "Registration already in progress";
+      this.state.error = error;
+      return {
+        success: false,
+        error
+      };
+    }
+
+    // Wait if validation is still in progress
+    if (this.validationInProgress) {
+      const error = "Please wait for license validation to complete";
+      this.state.error = error;
+      return {
+        success: false,
+        error
+      };
+    }
+    if (!this.state.licenseKey || !this.pendingLicenseId) {
+      const error = "No license key set. Call validateLicenseKey first.";
+      this.state.error = error;
+      return {
+        success: false,
+        error
+      };
+    }
+    if (!deviceName || deviceName.trim().length === 0) {
+      const error = "Device name is required";
+      this.state.error = error;
+      return {
+        success: false,
+        error
+      };
+    }
+    this.registrationInProgress = true;
+    this.state.isValidating = true;
+    this.emit({
+      type: "validating",
+      isPro: this.state.isPro
+    });
+    try {
+      // Generate a new fingerprint for this device
+      const fingerprint = (0, _fingerprint.generateUUID)();
+      const metadata = (0, _fingerprint.getDeviceMetadata)();
+
+      // Register the device with Keygen
+      const response = await (0, _api.activateMachine)(this.pendingLicenseId, this.state.licenseKey, fingerprint, deviceName.trim(), metadata);
+      this.state.machineId = response.data.id;
+
+      // Validate with the new fingerprint to get updated machine count
+      const validateResponse = await (0, _api.validateLicense)(this.state.licenseKey, fingerprint);
+
+      // If activateMachine succeeded, the device is registered - trust that over validation result
+      // (validation might fail due to API timing but activation success is authoritative)
+      this.state.isPro = true;
+      this.state.isValidating = false;
+      this.state.machineCount = this.countMachines(validateResponse);
+
+      // Save to cache with fingerprint and device name
+      await this.saveLicenseToCache(validateResponse, this.state.licenseKey, fingerprint, deviceName.trim());
+      this.emit({
+        type: "activated",
+        isPro: true
+      });
+      return {
+        success: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Registration failed";
+      let userError;
+      if (errorMessage === "MACHINE_LIMIT_EXCEEDED") {
+        userError = "Device limit reached. Remove an existing device first.";
+      } else if (errorMessage === "FINGERPRINT_TAKEN") {
+        // This shouldn't happen with UUID, but handle it anyway
+        userError = "Device ID conflict. Please try again.";
+      } else {
+        userError = errorMessage;
+      }
+      this.state.error = userError;
+      this.state.isValidating = false;
+      this.emit({
+        type: "error",
+        isPro: false,
+        error: userError
+      });
+      return {
+        success: false,
+        error: userError
+      };
+    } finally {
+      this.registrationInProgress = false;
+    }
+  }
+
+  /**
+   * Claim an existing device (use its fingerprint)
+   * This is for when the user wants to re-use a device slot after clearing storage
+   */
+  async claimDevice(machineId, existingDevices) {
+    if (!this.state.licenseKey) {
+      this.state.error = "No license key set";
+      return false;
+    }
+
+    // First try passed devices, then fetch fresh if not found (handles stale data)
+    let device = existingDevices.find(d => d.id === machineId);
+    if (!device) {
+      // Fetch fresh devices in case the list is stale
+      const freshDevices = await this.getRegisteredDevices();
+      device = freshDevices.find(d => d.id === machineId);
+    }
+    if (!device) {
+      this.state.error = "Device not found";
+      return false;
+    }
+    this.state.isValidating = true;
+    this.emit({
+      type: "validating",
+      isPro: this.state.isPro
+    });
+    try {
+      // Validate with the claimed device's fingerprint
+      const response = await (0, _api.validateLicense)(this.state.licenseKey, device.fingerprint);
+      const result = (0, _api.parseValidationResult)(response);
+      if (!result.valid) {
+        this.state.isValidating = false;
+        this.state.error = "Failed to claim device";
+        this.emit({
+          type: "error",
+          isPro: false,
+          error: this.state.error
+        });
+        return false;
+      }
+      this.state.isPro = true;
+      this.state.machineId = machineId;
+      this.state.isValidating = false;
+      this.state.machineCount = this.countMachines(response);
+
+      // Save to cache with the claimed fingerprint
+      await this.saveLicenseToCache(response, this.state.licenseKey, device.fingerprint, device.name);
+      this.emit({
+        type: "validated",
+        isPro: true
+      });
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to claim device";
+      this.state.isValidating = false;
+      this.state.error = errorMessage;
+      this.emit({
+        type: "error",
+        isPro: false,
+        error: errorMessage
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Legacy method - validates and auto-registers if needed (for backward compatibility)
+   * Note: This won't work well with the new flow - use validateLicenseKey + registerDevice instead
+   */
+  async setLicenseKey(licenseKey) {
+    const result = await this.validateLicenseKey(licenseKey);
+    if (!result.valid) {
+      return false;
+    }
+    if (!result.needsDeviceRegistration) {
+      return true;
+    }
+
+    // Auto-register with default name (legacy behavior)
+    const defaultName = `Device ${Date.now()}`;
+    const regResult = await this.registerDevice(defaultName);
+    return regResult.success;
+  }
+
+  /**
+   * Check if an error is a network error (not an API validation error)
+   */
+  isNetworkError(error) {
+    if (error instanceof TypeError) {
+      return true;
+    }
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      return message.includes("network") || message.includes("fetch") || message.includes("timeout") || message.includes("connection") || message.includes("offline") || message.includes("failed to fetch");
+    }
+    return false;
+  }
+
+  /**
+   * Clear the current license
+   */
+  async clearLicense() {
+    // If we have a machine ID and license key, try to deactivate it
+    if (this.state.machineId && this.state.licenseKey) {
+      try {
+        await (0, _api.deactivateMachine)(this.state.machineId, this.state.licenseKey);
+      } catch {
+        // Ignore deactivation errors
+      }
+    }
+    this.state.licenseKey = null;
+    this.state.isPro = false;
+    this.state.machineId = null;
+    this.state.maxMachines = null;
+    this.state.machineCount = 0;
+    this.state.expiresAt = null;
+    this.state.error = null;
+    this.cachedLicense = null;
+    this.pendingLicenseId = null;
+    await this.clearCachedLicense();
+    this.emit({
+      type: "deactivated",
+      isPro: false
+    });
+  }
+
+  /**
+   * Check if the user has Pro features
+   */
+  isPro() {
+    return this.state.isPro;
+  }
+
+  /**
+   * Check if a specific entitlement is available
+   */
+  hasEntitlement(code) {
+    if (code === "PRO") {
+      return this.state.isPro;
+    }
+    return this.state.isPro;
+  }
+
+  /**
+   * Get current license state
+   */
+  getState() {
+    return {
+      ...this.state
+    };
+  }
+
+  /**
+   * Get seat information
+   */
+  getSeatsInfo() {
+    return {
+      used: this.state.machineCount,
+      total: this.state.maxMachines
+    };
+  }
+
+  /**
+   * Subscribe to license events
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  /**
+   * Get all registered devices for the current license
+   */
+  async getRegisteredDevices() {
+    const licenseId = this.cachedLicense?.licenseId || this.pendingLicenseId;
+    if (!licenseId || !this.state.licenseKey) {
+      return [];
+    }
+    try {
+      const currentFingerprint = this.cachedLicense?.fingerprint;
+      const machines = await (0, _api.getLicenseMachines)(licenseId, this.state.licenseKey);
+      return machines.map(machine => ({
+        id: machine.id,
+        fingerprint: machine.attributes.fingerprint,
+        name: machine.attributes.name || "Unknown Device",
+        platform: machine.attributes.platform || "unknown",
+        model: machine.attributes.metadata?.model || null,
+        osVersion: machine.attributes.metadata?.osVersion || null,
+        appVersion: machine.attributes.metadata?.appVersion || null,
+        registeredAt: new Date(machine.attributes.created),
+        lastSeenAt: new Date(machine.attributes.updated),
+        isCurrentDevice: currentFingerprint ? machine.attributes.fingerprint === currentFingerprint : false
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Deactivate a specific device by machine ID
+   */
+  async deactivateDevice(machineId) {
+    if (!this.state.licenseKey) {
+      return false;
+    }
+    try {
+      await (0, _api.deactivateMachine)(machineId, this.state.licenseKey);
+
+      // Update machine count
+      this.state.machineCount = Math.max(0, this.state.machineCount - 1);
+
+      // If we deactivated the current device, clear our registration
+      if (machineId === this.state.machineId) {
+        this.state.machineId = null;
+        if (this.cachedLicense) {
+          this.cachedLicense.machineId = null;
+          this.cachedLicense.fingerprint = undefined;
+          this.cachedLicense.deviceName = undefined;
+          this.cachedLicense.machineCount = this.state.machineCount;
+          try {
+            const storage = await getPersistentStorage();
+            await storage.setItem(_config.LICENSE_STORAGE_KEY, JSON.stringify(this.cachedLicense));
+          } catch {
+            // Ignore storage errors
+          }
+        }
+        this.emit({
+          type: "deactivated",
+          isPro: this.state.isPro
+        });
+      } else {
+        // Update cache with new machine count
+        if (this.cachedLicense) {
+          this.cachedLicense.machineCount = this.state.machineCount;
+          try {
+            const storage = await getPersistentStorage();
+            await storage.setItem(_config.LICENSE_STORAGE_KEY, JSON.stringify(this.cachedLicense));
+          } catch {
+            // Ignore storage errors
+          }
+        }
+        this.emit({
+          type: "validated",
+          isPro: this.state.isPro
+        });
+      }
+      return true;
+    } catch (error) {
+      console.warn("[React Buoy] Failed to deactivate device:", error);
+      return false;
+    }
+  }
+
+  /**
+   * Register the current device for the license (legacy - use registerDevice instead)
+   */
+  async registerCurrentDevice() {
+    if (!this.state.licenseKey || !this.pendingLicenseId) {
+      return false;
+    }
+    const defaultName = `Device ${Date.now()}`;
+    const result = await this.registerDevice(defaultName);
+    return result.success;
+  }
+
+  /**
+   * Check if the current device is registered
+   */
+  isCurrentDeviceRegistered() {
+    return this.state.machineId !== null;
+  }
+
+  // Private methods
+
+  emit(event) {
+    // Iterate over a copy to prevent issues if listeners modify the Set
+    const listeners = [...this.listeners];
+    listeners.forEach(listener => {
+      try {
+        listener(event);
+      } catch (error) {
+        console.warn("[React Buoy] License listener error:", error);
+      }
+    });
+  }
+  countMachines(response) {
+    const metaCount = response.data?.relationships?.machines?.meta?.count;
+    if (typeof metaCount === "number") {
+      return metaCount;
+    }
+    const relationshipCount = response.data?.relationships?.machines?.data?.length;
+    if (relationshipCount !== undefined && relationshipCount > 0) {
+      return relationshipCount;
+    }
+    if (response.included) {
+      const machines = response.included.filter(item => item.type === "machines");
+      if (machines.length > 0) {
+        return machines.length;
+      }
+    }
+    return 0;
+  }
+  isCacheValid(cached) {
+    const now = Date.now();
+    const cacheAge = now - cached.cachedAt;
+    if (cacheAge > _config.LICENSE_CACHE_DURATION) {
+      return false;
+    }
+    if (cached.expiresAt) {
+      const expiry = new Date(cached.expiresAt).getTime();
+      if (now > expiry) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async loadCachedLicense() {
+    try {
+      const storage = await getPersistentStorage();
+      const data = await storage.getItem(_config.LICENSE_STORAGE_KEY);
+      if (!data) return null;
+      const cached = JSON.parse(data);
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+  async saveLicenseToCache(response, licenseKey, fingerprint, deviceName) {
+    if (!response.data) {
+      return;
+    }
+    const cached = {
+      licenseKey,
+      licenseId: response.data.id,
+      valid: response.meta.valid,
+      isPro: response.meta.valid || response.meta.code === "NO_MACHINES",
+      entitlements: ["PRO"],
+      machineId: this.state.machineId,
+      maxMachines: response.data.attributes.maxMachines,
+      machineCount: this.countMachines(response),
+      expiresAt: response.data.attributes.expiry,
+      cachedAt: Date.now(),
+      lastValidatedAt: Date.now(),
+      fingerprint: fingerprint ?? undefined,
+      deviceName: deviceName ?? undefined
+    };
+    this.cachedLicense = cached;
+    try {
+      const storage = await getPersistentStorage();
+      await storage.setItem(_config.LICENSE_STORAGE_KEY, JSON.stringify(cached));
+    } catch (error) {
+      console.warn("[React Buoy] Failed to cache license:", error);
+    }
+  }
+  async clearCachedLicense() {
+    this.cachedLicense = null;
+    try {
+      const storage = await getPersistentStorage();
+      await storage.removeItem(_config.LICENSE_STORAGE_KEY);
+    } catch {
+      // Ignore
+    }
+  }
+  validateInBackground(licenseKey, fingerprint) {
+    (0, _api.validateLicense)(licenseKey, fingerprint).then(async response => {
+      const result = (0, _api.parseValidationResult)(response);
+      if (result.valid) {
+        this.state.isPro = true;
+        this.state.machineCount = this.countMachines(response);
+        this.emit({
+          type: "validated",
+          isPro: true
+        });
+      } else {
+        // Device was removed by admin or license revoked
+        console.warn("[React Buoy] Background validation: device no longer valid");
+        this.state.isPro = false;
+        this.state.machineId = null;
+        await this.clearCachedLicense();
+        this.emit({
+          type: "deactivated",
+          isPro: false
+        });
+      }
+    }).catch(error => {
+      console.warn("[React Buoy] Background validation failed:", error);
+    });
+  }
+  startRevalidationTimer() {
+    if (this.revalidationTimer) {
+      clearInterval(this.revalidationTimer);
+    }
+    this.revalidationTimer = setInterval(() => {
+      if (this.state.licenseKey && this.cachedLicense?.fingerprint && !this.state.isValidating) {
+        this.validateInBackground(this.state.licenseKey, this.cachedLicense.fingerprint);
+      }
+    }, _config.LICENSE_REVALIDATION_INTERVAL);
+
+    // Store for hot reload cleanup
+    if (__DEV__) {
+      global.__LICENSE_MANAGER_TIMER__ = this.revalidationTimer;
+    }
+  }
+
+  /**
+   * Stop the revalidation timer
+   */
+  stopRevalidationTimer() {
+    if (this.revalidationTimer) {
+      clearInterval(this.revalidationTimer);
+      this.revalidationTimer = null;
+    }
+  }
+
+  /**
+   * Clear cache and revalidate
+   */
+  async clearCacheAndRevalidate() {
+    const currentKey = this.state.licenseKey;
+    await this.clearCachedLicense();
+    this.state.machineCount = 0;
+    if (currentKey) {
+      const result = await this.validateLicenseKey(currentKey);
+      return result.valid && !result.needsDeviceRegistration;
+    }
+    return false;
+  }
+}
+
+// Singleton instance
+const LicenseManager = exports.LicenseManager = new LicenseManagerImpl();
+
+// Hot reload cleanup - prevent timer leaks during development
+
+if (__DEV__) {
+  // Clear any existing timer from previous hot reload
+  if (global.__LICENSE_MANAGER_TIMER__) {
+    clearInterval(global.__LICENSE_MANAGER_TIMER__);
+  }
+}