@moontra/moonui-pro 3.2.2 → 3.3.1

package/dist/server.mjs

@@ -3170,6 +3170,20 @@ function readLicenseTokenServer() {
     if (typeof window !== "undefined") {
       return null;
     }
+    if (process.env.MOONUI_PRO_TOKEN) {
+      try {
+        const tokenString = Buffer.from(process.env.MOONUI_PRO_TOKEN, "base64").toString("utf8");
+        const token2 = JSON.parse(tokenString);
+        if (token2.expiresAt < Date.now()) {
+          console.log("[MoonUI] License token expired, re-validation required");
+          return null;
+        }
+        console.log("[MoonUI] License token loaded successfully from environment variable");
+        return token2;
+      } catch (envError) {
+        console.error("[MoonUI] Failed to parse MOONUI_PRO_TOKEN:", envError);
+      }
+    }
     const fs = __require("fs");
     const path = __require("path");
     const possiblePaths = [
@@ -3178,6 +3192,13 @@ function readLicenseTokenServer() {
       path.join(process.cwd(), "..", "..", ".moonui-license"),
       path.join(__dirname, "..", "..", "..", "..", ".moonui-license")
     ];
+    if (process.env.VERCEL_ARTIFACTS_PATH) {
+      possiblePaths.push(path.join(process.env.VERCEL_ARTIFACTS_PATH, ".moonui-license"));
+    }
+    if (process.env.NETLIFY_BUILD_BASE) {
+      possiblePaths.push(path.join(process.env.NETLIFY_BUILD_BASE, ".moonui-license"));
+    }
+    possiblePaths.push("/tmp/.moonui-license");
     let encryptedData = null;
     let foundPath = null;
     for (const filePath of possiblePaths) {

package/package.json

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

package/scripts/postinstall.cjs

@@ -50,33 +50,16 @@ function encryptToken(token, key) {
 // Validate license with MoonUI API
 async function validateLicense(licenseKey) {
   return new Promise((resolve, reject) => {
-    // Determine the domain
-    let domain = 'unknown';
-
-    // Check for Vercel deployment
-    if (process.env.VERCEL_URL) {
-      domain = process.env.VERCEL_URL.replace(/^https?:\/\//, '');
-    } else if (process.env.VERCEL_PROJECT_PRODUCTION_URL) {
-      domain = process.env.VERCEL_PROJECT_PRODUCTION_URL.replace(/^https?:\/\//, '');
-    } else if (process.env.NEXT_PUBLIC_VERCEL_URL) {
-      domain = process.env.NEXT_PUBLIC_VERCEL_URL.replace(/^https?:\/\//, '');
-    } else if (process.env.DEPLOY_URL) {
-      domain = process.env.DEPLOY_URL.replace(/^https?:\/\//, '');
-    }
-
-    // For moonui.dev site, use special validation
-    const isMoonUISite = domain.includes('moonui.dev') ||
-                         domain.includes('moonui-git') ||
-                         domain.includes('moonui-') ||
-                         process.env.MOONUI_SITE === 'true';
-
+    // Don't send domain information to prevent bypass attacks
+    // Only validate the license key itself
     const postData = JSON.stringify({
       licenseKey,
-      domain: isMoonUISite ? 'moonui.dev' : domain,
       environment: 'production',
-      isMoonUISite
+      source: 'postinstall'
     });
 
+    console.log('[MoonUI Pro] Sending validation request with data:', postData);
+
     const options = {
       hostname: 'moonui.dev',
       port: 443,
@@ -93,25 +76,33 @@ async function validateLicense(licenseKey) {
     const req = https.request(options, (res) => {
       let data = '';
 
+      console.log('[MoonUI Pro] Response status code:', res.statusCode);
+
       res.on('data', (chunk) => {
         data += chunk;
       });
 
       res.on('end', () => {
         try {
+          console.log('[MoonUI Pro] Raw response data:', data);
           const result = JSON.parse(data);
-          if (res.statusCode === 200 && result.valid) {
+          console.log('[MoonUI Pro] Parsed response:', JSON.stringify(result, null, 2));
+
+          if (res.statusCode === 200) {
+            // Return the full result, don't check result.valid here
             resolve(result);
           } else {
             reject(new Error(result.error || 'License validation failed'));
           }
         } catch (error) {
+          console.error('[MoonUI Pro] Error parsing response:', error);
           reject(error);
         }
       });
     });
 
     req.on('error', (error) => {
+      console.error('[MoonUI Pro] Request error:', error);
       reject(error);
     });
 
@@ -120,15 +111,58 @@ async function validateLicense(licenseKey) {
   });
 }
 
-// Save license token to file
+// Save license token to file or environment
 function saveLicenseToken(token) {
   try {
+    console.log('[MoonUI Pro] Starting to save license token...');
+
+    // Check if we're in Vercel build environment
+    const isVercelBuild = process.env.VERCEL === '1';
+    const isNetlifyBuild = process.env.NETLIFY === 'true';
+
+    if (isVercelBuild || isNetlifyBuild) {
+      console.log('[MoonUI Pro] Detected build environment:', isVercelBuild ? 'Vercel' : 'Netlify');
+
+      // In Vercel/Netlify, we can't write files persistently
+      // Instead, we'll set an environment variable that the build can use
+      const tokenString = JSON.stringify(token);
+      const base64Token = Buffer.from(tokenString).toString('base64');
+
+      console.log('[MoonUI Pro] Setting MOONUI_PRO_TOKEN environment variable for build...');
+      process.env.MOONUI_PRO_TOKEN = base64Token;
+
+      // Also try to write to a temp location that might be available during build
+      try {
+        const tempPath = process.env.VERCEL_ARTIFACTS_PATH || process.env.NETLIFY_BUILD_BASE || '/tmp';
+        const tempLicenseFile = path.join(tempPath, LICENSE_FILE);
+
+        // Encrypt token with a deterministic key based on environment
+        const encryptionKey = process.env.MOONUI_LICENSE_KEY || 'default-key';
+        const encryptedData = encryptToken(token, encryptionKey);
+
+        fs.writeFileSync(tempLicenseFile, JSON.stringify(encryptedData, null, 2));
+        console.log('[MoonUI Pro] Token saved to temporary location:', tempLicenseFile);
+      } catch (tempError) {
+        console.log('[MoonUI Pro] Could not write to temp location (expected in some environments)');
+      }
+
+      console.log('[MoonUI Pro] ✓ License token stored for build environment');
+      return true;
+    }
+
+    // Standard file system approach for local development
     // Find the project root (where package.json is)
     let projectRoot = process.cwd();
+    console.log('[MoonUI Pro] Initial working directory:', projectRoot);
+
     let attempts = 0;
 
     while (attempts < 10) {
-      if (fs.existsSync(path.join(projectRoot, 'package.json'))) {
+      const packageJsonPath = path.join(projectRoot, 'package.json');
+      console.log(`[MoonUI Pro] Checking for package.json at: ${packageJsonPath}`);
+
+      if (fs.existsSync(packageJsonPath)) {
+        console.log('[MoonUI Pro] Found package.json at:', projectRoot);
         break;
       }
       projectRoot = path.dirname(projectRoot);
@@ -136,19 +170,44 @@ function saveLicenseToken(token) {
     }
 
     const licenseFilePath = path.join(projectRoot, LICENSE_FILE);
+    console.log('[MoonUI Pro] License file path:', licenseFilePath);
 
     // Encrypt token with a deterministic key based on environment
     const encryptionKey = process.env.MOONUI_LICENSE_KEY || 'default-key';
+    console.log('[MoonUI Pro] Using encryption key:', encryptionKey.substring(0, 10) + '...');
+
     const encryptedData = encryptToken(token, encryptionKey);
+    console.log('[MoonUI Pro] Token encrypted successfully');
 
     // Save to file
+    console.log('[MoonUI Pro] Writing to file:', licenseFilePath);
     fs.writeFileSync(licenseFilePath, JSON.stringify(encryptedData, null, 2));
 
-    console.log('[MoonUI Pro] ✓ License token saved successfully');
-    return true;
+    // Verify file was created
+    if (fs.existsSync(licenseFilePath)) {
+      const stats = fs.statSync(licenseFilePath);
+      console.log('[MoonUI Pro] ✓ License token saved successfully');
+      console.log('[MoonUI Pro] File size:', stats.size, 'bytes');
+      return true;
+    } else {
+      console.error('[MoonUI Pro] File was not created despite no errors');
+      return false;
+    }
   } catch (error) {
     console.error('[MoonUI Pro] Failed to save license token:', error.message);
-    return false;
+    console.error('[MoonUI Pro] Full error:', error);
+
+    // As a fallback, try to set environment variable
+    try {
+      const tokenString = JSON.stringify(token);
+      const base64Token = Buffer.from(tokenString).toString('base64');
+      process.env.MOONUI_PRO_TOKEN = base64Token;
+      console.log('[MoonUI Pro] Fallback: Set MOONUI_PRO_TOKEN environment variable');
+      return true;
+    } catch (fallbackError) {
+      console.error('[MoonUI Pro] Fallback also failed:', fallbackError);
+      return false;
+    }
   }
 }
 
@@ -183,24 +242,39 @@ async function main() {
     // Validate license with API
     const validationResult = await validateLicense(licenseKey);
 
-    if (validationResult.valid && validationResult.hasProAccess) {
+    // Debug: Log the full validation result
+    console.log('[MoonUI Pro] Validation result:', JSON.stringify(validationResult, null, 2));
+
+    if (validationResult && validationResult.valid && validationResult.hasProAccess) {
+      console.log('[MoonUI Pro] ✓ License is valid and has Pro access');
+
       // Create token with validation result and expiry
       const token = {
         valid: true,
         hasProAccess: validationResult.hasProAccess,
-        plan: validationResult.plan,
+        plan: validationResult.plan || 'pro',
         expiresAt: Date.now() + CACHE_DURATION,
-        domain: validationResult.domain,
         timestamp: Date.now()
       };
 
+      console.log('[MoonUI Pro] Creating token:', JSON.stringify(token, null, 2));
+
       // Save encrypted token
-      saveLicenseToken(token);
+      const saveResult = saveLicenseToken(token);
 
-      console.log('[MoonUI Pro] ✓ License validated successfully');
-      console.log('[MoonUI Pro] ✓ Pro features enabled');
+      if (saveResult) {
+        console.log('[MoonUI Pro] ✓ License validated successfully');
+        console.log('[MoonUI Pro] ✓ Pro features enabled');
+      } else {
+        console.log('[MoonUI Pro] ⚠ License valid but failed to save token');
+      }
     } else {
-      console.log('[MoonUI Pro] License validation failed');
+      console.log('[MoonUI Pro] License validation failed or no Pro access');
+      console.log('[MoonUI Pro] Validation result:', {
+        valid: validationResult?.valid || false,
+        hasProAccess: validationResult?.hasProAccess || false,
+        plan: validationResult?.plan || 'none'
+      });
       console.log('[MoonUI Pro] Pro features will be disabled');
     }
   } catch (error) {