@moontra/moonui-pro 3.3.0 → 3.3.2

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.3.0",
+    "version": "3.3.2",
     "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

@@ -58,6 +58,8 @@ async function validateLicense(licenseKey) {
       source: 'postinstall'
     });
 
+    console.log('[MoonUI Pro] Sending validation request with data:', postData);
+
     const options = {
       hostname: 'moonui.dev',
       port: 443,
@@ -74,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);
     });
 
@@ -101,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);
@@ -117,24 +170,58 @@ 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;
+    }
   }
 }
 
 // Main postinstall logic
 async function main() {
+  console.log('[MoonUI Pro] === POSTINSTALL SCRIPT STARTED ===');
+  console.log('[MoonUI Pro] Environment:', {
+    NODE_ENV: process.env.NODE_ENV,
+    VERCEL: process.env.VERCEL,
+    NETLIFY: process.env.NETLIFY,
+    CI: process.env.CI,
+    MOONUI_AUTH_TOKEN: !!process.env.MOONUI_AUTH_TOKEN
+  });
+
   try {
     // Only run in production environments
     if (!isProduction()) {
@@ -164,23 +251,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,
         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) {
@@ -194,10 +297,16 @@ async function main() {
 
 // Run if called directly (not imported)
 if (require.main === module) {
+  console.log('[MoonUI Pro] PostInstall script invoked');
   main().catch(error => {
     console.error('[MoonUI Pro] Unexpected error:', error);
+    console.error('[MoonUI Pro] Stack trace:', error.stack);
     process.exit(0); // Don't fail npm install
+  }).finally(() => {
+    console.log('[MoonUI Pro] === POSTINSTALL SCRIPT FINISHED ===');
   });
+} else {
+  console.log('[MoonUI Pro] PostInstall script loaded as module');
 }
 
 module.exports = { validateLicense, saveLicenseToken, isProduction };

package/scripts/validate-license.cjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+/**
+ * MoonUI Pro License Validation Script
+ * Can be called from build scripts or directly
+ */
+
+const postinstall = require('./postinstall.cjs');
+
+// Force production mode for validation
+process.env.NODE_ENV = 'production';
+
+console.log('[MoonUI Pro] Running license validation from build script...');
+
+async function validate() {
+  try {
+    const licenseKey = process.env.MOONUI_LICENSE_KEY ||
+                       process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY ||
+                       process.env.VITE_MOONUI_LICENSE_KEY ||
+                       process.env.REACT_APP_MOONUI_LICENSE_KEY;
+
+    if (!licenseKey) {
+      console.log('[MoonUI Pro] No license key found in environment variables');
+      return;
+    }
+
+    console.log('[MoonUI Pro] Found license key, validating...');
+
+    // Use the validation function from postinstall
+    const result = await postinstall.validateLicense(licenseKey);
+
+    if (result && result.valid && result.hasProAccess) {
+      console.log('[MoonUI Pro] License validated successfully via build script');
+
+      const token = {
+        valid: true,
+        hasProAccess: result.hasProAccess,
+        plan: result.plan || 'pro',
+        expiresAt: Date.now() + (30 * 24 * 60 * 60 * 1000),
+        timestamp: Date.now()
+      };
+
+      postinstall.saveLicenseToken(token);
+    } else {
+      console.log('[MoonUI Pro] License validation failed via build script');
+    }
+  } catch (error) {
+    console.error('[MoonUI Pro] Error during build validation:', error);
+  }
+}
+
+// Run validation
+validate();