@moontra/moonui-pro 2.32.32 → 2.32.34

package/dist/index.mjs

@@ -100,39 +100,27 @@ var init_cli_token_reader = __esm({
         return this.instance;
       }
       /**
-       * Generate device fingerprint compatible with CLI format
-       * Format: platform-hostname-username_hash (8 chars)
+       * Generate secure device fingerprint using hybrid approach
+       * Format: platform-hostname-username_hash-browser_machine_id
+       *
+       * SECURITY: Even if .env.local is copied, browser machine ID will be different
        */
       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")) {
-              platform2 = "darwin";
-            } else if (navigatorPlatform.includes("win") || userAgent.includes("windows")) {
-              platform2 = "win32";
-            } else if (navigatorPlatform.includes("linux") || userAgent.includes("linux")) {
-              platform2 = "linux";
-            }
-          }
-          let hostname = process.env.NEXT_PUBLIC_MOONUI_HOSTNAME || "localhost";
-          if (typeof window !== "undefined" && !process.env.NEXT_PUBLIC_MOONUI_HOSTNAME) {
-            if (window.location.hostname !== "localhost" && window.location.hostname !== "127.0.0.1") {
-              hostname = window.location.hostname;
-            }
-          }
+          const platform2 = this.detectBrowserPlatform();
+          const hostname = process.env.NEXT_PUBLIC_MOONUI_HOSTNAME || "localhost";
           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 browserMachineId = await this.generateBrowserMachineId();
+          const fingerprint = `${platform2}-${hostname}-${usernameHash}-${browserMachineId}`;
+          console.log("[MoonUI Pro] Secure browser device fingerprint generated:", {
             platform: platform2,
             hostname,
             username: username.substring(0, 3) + "***",
-            // Partial logging for privacy
             usernameHash,
-            fingerprint
+            browserMachineId: browserMachineId.substring(0, 4) + "***",
+            fingerprint: fingerprint.substring(0, 25) + "***",
+            security: "browser-machine-locked"
           });
           return fingerprint;
         } catch (error) {
@@ -140,6 +128,155 @@ var init_cli_token_reader = __esm({
           return "browser-fallback-device";
         }
       }
+      /**
+       * Detect platform in browser environment (CLI compatible)
+       */
+      detectBrowserPlatform() {
+        if (typeof window === "undefined")
+          return "unknown";
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (userAgent.includes("mac") || userAgent.includes("darwin")) {
+          return "darwin";
+        } else if (userAgent.includes("win") || userAgent.includes("windows")) {
+          return "win32";
+        } else if (userAgent.includes("linux") || userAgent.includes("x11")) {
+          return "linux";
+        }
+        return "unknown";
+      }
+      /**
+       * 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";
+        }
+      }
+      /**
+       * Validate device compatibility (CLI vs Browser)
+       * CLI: platform-hostname-userHash-macHash
+       * Browser: platform-hostname-userHash-browserHash
+       * Compatible if first 3 parts match
+       */
+      validateDeviceCompatibility(tokenDeviceId, currentDeviceId) {
+        const tokenParts = tokenDeviceId.split("-");
+        const currentParts = currentDeviceId.split("-");
+        if (tokenParts.length < 3 || currentParts.length < 3) {
+          return { compatible: false, reason: "Invalid device ID format" };
+        }
+        const platformMatch = tokenParts[0] === currentParts[0];
+        const hostnameMatch = tokenParts[1] === currentParts[1];
+        const userHashMatch = tokenParts[2] === currentParts[2];
+        if (!platformMatch) {
+          return { compatible: false, reason: "Platform mismatch (different OS)" };
+        }
+        if (!hostnameMatch) {
+          return { compatible: false, reason: "Hostname mismatch (different machine)" };
+        }
+        if (!userHashMatch) {
+          return { compatible: false, reason: "User account mismatch" };
+        }
+        return { compatible: true };
+      }
       /**
        * SHA256 hash function for consistency with CLI
        * Returns first 8 characters of SHA256 hex digest
@@ -232,21 +369,27 @@ var init_cli_token_reader = __esm({
         }
         const currentDeviceId = await this.getDeviceFingerprint();
         const tokenDeviceId = tokenData.deviceId;
-        console.log("[MoonUI Pro] Device validation check:", {
-          currentDevice: currentDeviceId,
-          tokenDevice: tokenDeviceId,
-          matches: currentDeviceId === tokenDeviceId
+        console.log("[MoonUI Pro] Hybrid device compatibility check:", {
+          currentDevice: currentDeviceId.substring(0, 25) + "***",
+          tokenDevice: tokenDeviceId.substring(0, 25) + "***"
         });
-        if (tokenDeviceId && currentDeviceId !== tokenDeviceId) {
-          console.error("[MoonUI Pro] Device mismatch detected!");
-          console.error("[MoonUI Pro] This token was created for a different device");
-          console.log("[MoonUI Pro] Token device:", tokenDeviceId);
-          console.log("[MoonUI Pro] Current device:", currentDeviceId);
-          console.log("[MoonUI Pro] Solutions:");
-          console.log('  \u2022 Run "moonui login" on this device to create a new session');
-          console.log("  \u2022 Use the correct device where this token was generated");
-          console.log("  \u2022 Contact support for multi-device licensing options");
-          return null;
+        if (tokenDeviceId) {
+          const compatibility = this.validateDeviceCompatibility(tokenDeviceId, currentDeviceId);
+          if (!compatibility.compatible) {
+            console.error("[MoonUI Pro] Device compatibility check failed!");
+            console.error("[MoonUI Pro] Reason:", compatibility.reason);
+            console.error("[MoonUI Pro] This indicates:");
+            console.log("  \u2022 Token was created on a different machine or user account");
+            console.log("  \u2022 .env.local file may have been copied from another device");
+            console.log("  \u2022 Different hostname or user profile detected");
+            console.log("[MoonUI Pro] Solutions:");
+            console.log('  \u2022 Run "moonui login" on this device to create a new session');
+            console.log("  \u2022 Ensure you are using the correct user account");
+            console.log("  \u2022 Verify hostname matches the original login device");
+            console.log("  \u2022 Contact support for multi-device licensing options");
+            return null;
+          }
+          console.log("[MoonUI Pro] Device compatibility validated successfully");
         }
         const isValid2 = await this.validateWithAPI(tokenData.token, tokenDeviceId || currentDeviceId);
         if (!isValid2) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.32.32",
+    "version": "2.32.34",
     "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",