Integration Guide

Machine ID Generation

// Example: Generate unique machine ID
function getMachineId() {
  // Combine multiple hardware identifiers
  const cpuId = os.cpus()[0].model;
  const hostname = os.hostname();
  const networkInterfaces = os.networkInterfaces();
  const macAddress = Object.values(networkInterfaces)
    .flat()
    .find(i => !i.internal && i.mac !== '00:00:00:00:00:00')?.mac;
  
  // Create a hash of the combined values
  return crypto.createHash('sha256')
    .update(cpuId + hostname + macAddress)
    .digest('hex');
}

License Validation Flow

class LicenseManager {
  constructor(apiUrl, productCode) {
    this.apiUrl = apiUrl;
    this.productCode = productCode;
    this.machineId = getMachineId();
  }

  async validateLicense(licenseKey) {
    try {
      const response = await fetch(`${this.apiUrl}/api/v1/validate`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          licenseKey,
          productCode: this.productCode,
          machineId: this.machineId,
          requireActivation: true
        })
      });

      const result = await response.json();
      
      if (result.status === 'valid') {
        // Store validation result locally
        this.storeValidation(result);
        return { success: true, features: result.features };
      } else {
        return { success: false, error: result.message };
      }
    } catch (error) {
      // Fallback to offline validation if stored
      return this.offlineValidation(licenseKey);
    }
  }

  storeValidation(result) {
    // Encrypt and store for offline use
    const encrypted = encrypt(JSON.stringify({
      ...result,
      validatedAt: new Date().toISOString(),
      machineId: this.machineId
    }));
    localStorage.setItem('license_cache', encrypted);
  }

  offlineValidation(licenseKey) {
    // Check cached validation
    const cached = localStorage.getItem('license_cache');
    if (!cached) return { success: false, error: 'No cached license' };
    
    const decrypted = JSON.parse(decrypt(cached));
    const hoursSinceValidation = 
      (new Date() - new Date(decrypted.validatedAt)) / 1000 / 60 / 60;
    
    // Allow 72 hours offline grace period
    if (hoursSinceValidation < 72 && decrypted.licenseKey === licenseKey) {
      return { success: true, features: decrypted.features };
    }
    
    return { success: false, error: 'Offline validation expired' };
  }
}

Periodic Revalidation

// Validate on startup
await licenseManager.validateLicense(userLicenseKey);

// Revalidate every 24 hours
setInterval(async () => {
  const result = await licenseManager.validateLicense(userLicenseKey);
  if (!result.success) {
    // Handle license expiration or invalidation
    showLicenseError(result.error);
  }
}, 24 * 60 * 60 * 1000);