@moontra/moonui-pro 2.32.32 → 2.32.33

package/dist/index.mjs

@@ -100,20 +100,19 @@ var init_cli_token_reader = __esm({
         return this.instance;
       }
       /**
-       * Generate device fingerprint compatible with CLI format
-       * Format: platform-hostname-username_hash (8 chars)
+       * Generate device fingerprint compatible with CLI format but enhanced for browser security
+       * Format: platform-hostname-username_hash-machine_hash (enhanced browser version)
        */
       async getDeviceFingerprint() {
         try {
           let platform2 = "unknown";
           if (typeof window !== "undefined") {
             const userAgent = navigator.userAgent.toLowerCase();
-            const navigatorPlatform = navigator.platform.toLowerCase();
-            if (navigatorPlatform.includes("mac") || userAgent.includes("mac")) {
+            if (userAgent.includes("mac") || userAgent.includes("darwin")) {
               platform2 = "darwin";
-            } else if (navigatorPlatform.includes("win") || userAgent.includes("windows")) {
+            } else if (userAgent.includes("win") || userAgent.includes("windows")) {
               platform2 = "win32";
-            } else if (navigatorPlatform.includes("linux") || userAgent.includes("linux")) {
+            } else if (userAgent.includes("linux") || userAgent.includes("x11")) {
               platform2 = "linux";
             }
           }
@@ -125,14 +124,18 @@ var init_cli_token_reader = __esm({
           }
           const username = process.env.NEXT_PUBLIC_MOONUI_USERNAME || "dev-user";
           const usernameHash = await this.sha256Hash(username);
-          const fingerprint = `${platform2}-${hostname}-${usernameHash}`;
-          console.log("[MoonUI Pro] Browser device fingerprint generated:", {
+          const machineId = await this.generateBrowserMachineId();
+          const fingerprint = `${platform2}-${hostname}-${usernameHash}-${machineId}`;
+          console.log("[MoonUI Pro] Enhanced browser device fingerprint generated:", {
             platform: platform2,
             hostname,
             username: username.substring(0, 3) + "***",
             // Partial logging for privacy
             usernameHash,
-            fingerprint
+            machineId: machineId.substring(0, 4) + "***",
+            // Partial logging for privacy
+            fingerprint: fingerprint.substring(0, 20) + "***"
+            // Partial logging for privacy
           });
           return fingerprint;
         } catch (error) {
@@ -140,6 +143,113 @@ var init_cli_token_reader = __esm({
           return "browser-fallback-device";
         }
       }
+      /**
+       * Generate browser-specific machine ID using multiple browser characteristics
+       * This prevents token sharing between different browsers/machines
+       */
+      async generateBrowserMachineId() {
+        if (typeof window === "undefined") {
+          return "ssr-fallback";
+        }
+        try {
+          const characteristics = [];
+          characteristics.push(`${screen.width}x${screen.height}`);
+          characteristics.push(`${screen.colorDepth}`);
+          characteristics.push(`${window.devicePixelRatio || 1}`);
+          characteristics.push(navigator.userAgent);
+          characteristics.push(navigator.language);
+          characteristics.push(`${navigator.hardwareConcurrency || 0}`);
+          characteristics.push(`${navigator.maxTouchPoints || 0}`);
+          characteristics.push(Intl.DateTimeFormat().resolvedOptions().timeZone);
+          const canvasFingerprint = await this.generateCanvasFingerprint();
+          characteristics.push(canvasFingerprint);
+          const webglFingerprint = this.generateWebGLFingerprint();
+          characteristics.push(webglFingerprint);
+          const audioFingerprint = await this.generateAudioFingerprint();
+          characteristics.push(audioFingerprint);
+          const combined = characteristics.join("|");
+          const machineHash = await this.sha256Hash(combined);
+          return machineHash.substring(0, 6);
+        } catch (error) {
+          console.warn("[MoonUI Pro] Machine ID generation fallback:", error);
+          const fallback = `${screen.width}-${navigator.userAgent.length}-${navigator.language}`;
+          const fallbackHash = await this.sha256Hash(fallback);
+          return fallbackHash.substring(0, 6);
+        }
+      }
+      /**
+       * Generate canvas fingerprint
+       */
+      async generateCanvasFingerprint() {
+        try {
+          const canvas = document.createElement("canvas");
+          const ctx = canvas.getContext("2d");
+          if (!ctx)
+            return "no-canvas";
+          ctx.textBaseline = "top";
+          ctx.font = "14px Arial";
+          ctx.fillStyle = "#f60";
+          ctx.fillRect(125, 1, 62, 20);
+          ctx.fillStyle = "#069";
+          ctx.fillText("MoonUI Browser Fingerprint \u{1F510}", 2, 15);
+          ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+          ctx.fillRect(45, 25, 80, 15);
+          const dataURL = canvas.toDataURL();
+          const hash = await this.sha256Hash(dataURL);
+          return hash.substring(0, 8);
+        } catch (error) {
+          return "canvas-error";
+        }
+      }
+      /**
+       * Generate WebGL fingerprint
+       */
+      generateWebGLFingerprint() {
+        try {
+          const canvas = document.createElement("canvas");
+          const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+          if (!gl)
+            return "no-webgl";
+          const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+          const vendor = debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : "unknown";
+          const renderer = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : "unknown";
+          return `${vendor}-${renderer}`.replace(/\s+/g, "-").substring(0, 16);
+        } catch (error) {
+          return "webgl-error";
+        }
+      }
+      /**
+       * Generate audio context fingerprint
+       */
+      async generateAudioFingerprint() {
+        try {
+          const AudioContext = window.AudioContext || window.webkitAudioContext;
+          if (!AudioContext)
+            return "no-audio";
+          const context = new AudioContext();
+          const oscillator = context.createOscillator();
+          const gain = context.createGain();
+          oscillator.type = "triangle";
+          oscillator.frequency.setValueAtTime(1e3, context.currentTime);
+          gain.gain.setValueAtTime(0.01, context.currentTime);
+          oscillator.connect(gain);
+          gain.connect(context.destination);
+          const audioFingerprint = [
+            context.sampleRate.toString(),
+            context.destination.maxChannelCount.toString(),
+            context.destination.channelCount.toString(),
+            context.baseLatency ? context.baseLatency.toString() : "0",
+            context.outputLatency ? context.outputLatency.toString() : "0"
+          ].join("-");
+          try {
+            context.close();
+          } catch {
+          }
+          return audioFingerprint.substring(0, 8);
+        } catch (error) {
+          return "audio-error";
+        }
+      }
       /**
        * SHA256 hash function for consistency with CLI
        * Returns first 8 characters of SHA256 hex digest

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.32.32",
+    "version": "2.32.33",
     "description": "Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components",
     "type": "module",
     "main": "dist/index.mjs",