@moontra/moonui-pro 2.33.18 → 2.33.20

package/dist/index.mjs

@@ -102,17 +102,17 @@ var init_cli_token_reader = __esm({
       /**
        * Generate TRULY secure browser-specific device fingerprint
        * COMPLETELY INDEPENDENT from environment variables
-       * Format: platform-hostname-browser_user_hash-machine_hash
+       * Format: browser-hostname-browser_user_hash-machine_hash
        *
        * SECURITY: Environment copying CANNOT bypass this!
        */
       async getDeviceFingerprint() {
         try {
           const platform2 = this.detectBrowserPlatform();
-          const hostname = process.env.NEXT_PUBLIC_MOONUI_HOSTNAME || (typeof window !== "undefined" ? window.location.hostname : "unknown");
+          const hostname = typeof window !== "undefined" ? window.location.hostname : "unknown";
           const browserUserHash = await this.generateBrowserSpecificUserHash();
           const browserMachineId = await this.generateBrowserMachineId();
-          const fingerprint = `${platform2}-${hostname}-${browserUserHash}-${browserMachineId}`;
+          const fingerprint = `browser-${hostname}-${browserUserHash}-${browserMachineId}`;
           console.log("[MoonUI Pro] Environment-independent browser fingerprint generated:", {
             platform: platform2,
             hostname,
@@ -124,11 +124,7 @@ var init_cli_token_reader = __esm({
           return fingerprint;
         } catch (error) {
           console.error("[MoonUI Pro] Device fingerprint generation failed:", error);
-          const fallbackPlatform = this.detectBrowserPlatform() || "darwin";
-          const fallbackHostname = typeof window !== "undefined" ? window.location.hostname : "localhost";
-          const fallbackUserHash = "fallback";
-          const fallbackMachineHash = "000000";
-          return `${fallbackPlatform}-${fallbackHostname}-${fallbackUserHash}-${fallbackMachineHash}`;
+          return "browser-fallback-device";
         }
       }
       /**
@@ -161,7 +157,7 @@ var init_cli_token_reader = __esm({
           return hash.substring(0, 8);
         } catch (error) {
           console.warn("[MoonUI Pro] Browser user hash generation failed, using fallback");
-          const fallback = `${navigator.userAgent.length}-${screen.width}-${navigator.language}`;
+          const fallback = `${navigator.userAgent.length}-${screen.width}-${Date.now() % 1e4}`;
           return this.fallbackHash(fallback);
         }
       }
@@ -289,47 +285,30 @@ var init_cli_token_reader = __esm({
         }
       }
       /**
-       * Validate device compatibility (CLI vs Browser) with hybrid security model
+       * Validate device compatibility (CLI vs Browser)
        * CLI: platform-hostname-userHash-macHash
        * Browser: platform-hostname-userHash-browserHash
-       * Security levels:
-       * - STRICT: All parts must match (prevent .env.local copying)
-       * - HYBRID: First 3 parts match, API validation required for hash differences
+       * 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, requiresAPIValidation: false, reason: "Invalid device ID format" };
+          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];
-        console.log("[MoonUI Pro] Device ID comparison:", {
-          platform: { token: tokenParts[0], current: currentParts[0], match: platformMatch },
-          hostname: { token: tokenParts[1], current: currentParts[1], match: hostnameMatch },
-          userHash: { token: tokenParts[2], current: currentParts[2], match: userHashMatch },
-          machineHash: { token: tokenParts[3], current: currentParts[3], match: tokenParts[3] === currentParts[3] }
-        });
         if (!platformMatch) {
-          return { compatible: false, requiresAPIValidation: false, reason: `Platform mismatch: token=${tokenParts[0]}, current=${currentParts[0]}` };
+          return { compatible: false, reason: "Platform mismatch (different OS)" };
         }
         if (!hostnameMatch) {
-          return { compatible: false, requiresAPIValidation: false, reason: `Hostname mismatch: token=${tokenParts[1]}, current=${currentParts[1]}` };
+          return { compatible: false, reason: "Hostname mismatch (different machine)" };
         }
         if (!userHashMatch) {
-          console.log("[MoonUI Pro] User hash mismatch detected (CLI vs Browser) - this is normal");
-          console.log("[MoonUI Pro] Requiring API validation for security");
-          return { compatible: true, requiresAPIValidation: true, reason: `User hash difference expected: CLI=${tokenParts[2]}, Browser=${currentParts[2]}` };
-        }
-        const cliMachineHash = tokenParts[3] || "";
-        const browserMachineHash = currentParts[3] || "";
-        const machineHashMatch = cliMachineHash === browserMachineHash;
-        if (machineHashMatch) {
-          return { compatible: true, requiresAPIValidation: false };
-        } else {
-          return { compatible: true, requiresAPIValidation: true };
+          return { compatible: false, reason: "User account mismatch" };
         }
+        return { compatible: true };
       }
       /**
        * SHA256 hash function for consistency with CLI
@@ -448,12 +427,7 @@ var init_cli_token_reader = __esm({
             console.log("  \u2022 Contact support for multi-device licensing options");
             return null;
           }
-          if (compatibility.requiresAPIValidation) {
-            console.log("[MoonUI Pro] Device hash mismatch detected - performing API validation");
-            console.log("[MoonUI Pro] This is normal for CLI-Browser authentication");
-          } else {
-            console.log("[MoonUI Pro] Perfect device match - skipping API validation");
-          }
+          console.log("[MoonUI Pro] Device compatibility validated successfully");
         }
         const isValid2 = await this.validateWithAPI(tokenData.token, tokenDeviceId, currentDeviceId);
         if (!isValid2) {
@@ -2861,6 +2835,64 @@ function createAIProvider(provider, config) {
 
 // src/index.ts
 init_use_subscription();
+async function sha256(message) {
+  const msgBuffer = new TextEncoder().encode(message);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+async function generateStableBrowserFingerprint() {
+  const components = [];
+  try {
+    const canvas = document.createElement("canvas");
+    canvas.width = 200;
+    canvas.height = 50;
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      ctx.textBaseline = "top";
+      ctx.font = "14px Arial";
+      ctx.textAlign = "center";
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(125, 1, 62, 20);
+      ctx.fillStyle = "#069";
+      ctx.fillText("\u{1F510}MoonUI", 50, 25);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("\u{1F510}MoonUI", 100, 25);
+      const canvasData = canvas.toDataURL();
+      const canvasHash = await sha256(canvasData);
+      components.push(canvasHash.slice(0, 8));
+    }
+    const canvas2 = document.createElement("canvas");
+    const gl = canvas2.getContext("webgl") || canvas2.getContext("experimental-webgl");
+    if (gl) {
+      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+      if (debugInfo) {
+        const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+        const glHash = await sha256(`${vendor}|${renderer}`);
+        components.push(glHash.slice(0, 8));
+      } else {
+        const vendor = gl.getParameter(gl.VENDOR);
+        const renderer = gl.getParameter(gl.RENDERER);
+        const glHash = await sha256(`${vendor}|${renderer}`);
+        components.push(glHash.slice(0, 8));
+      }
+    }
+    const screenData = `${window.screen.width}x${window.screen.height}x${window.screen.colorDepth}`;
+    const screenHash = await sha256(screenData);
+    components.push(screenHash.slice(0, 8));
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const language = navigator.language;
+    const localeHash = await sha256(`${timezone}|${language}`);
+    components.push(localeHash.slice(0, 6));
+  } catch (error) {
+    console.error("[MoonUI Pro] Error generating browser fingerprint:", error);
+    const fallbackHash = await sha256(`${Date.now()}-${Math.random()}`);
+    components.push(fallbackHash.slice(0, 8));
+  }
+  return `browser-${components.join("-")}`;
+}
 var CACHE_KEY2 = "moonui_license_cache";
 var CLI_AUTH_CACHE_KEY2 = "moonui_cli_auth_cache";
 var CACHE_DURATION = !process.env.VERCEL ? 1 * 60 * 1e3 : 24 * 60 * 60 * 1e3;
@@ -2905,14 +2937,13 @@ function SubscriptionProvider({ children }) {
           try {
             const decoded = JSON.parse(atob(devToken));
             const jwtToken = decoded.token;
-            const hostname = window.location.hostname.replace(/\./g, "");
-            const userHash = deviceId.split("-")[2];
-            const browserHash = Math.random().toString(36).substring(2, 8);
+            const browserFingerprint = await generateStableBrowserFingerprint();
             const requestBody = {
               deviceId,
-              browserDeviceId: `browser-${hostname}-${userHash}-${browserHash}`,
+              browserDeviceId: browserFingerprint,
               timestamp: Date.now(),
-              validationType: "hybrid-strict"
+              validationType: "hybrid-browser-register",
+              action: "registerBrowserIfNeeded"
             };
             console.log("[MoonUI Pro] Sending request to moonui.dev/api/cli/validate-session");
             console.log("[MoonUI Pro] DeviceId:", deviceId);

package/package.json

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