@licenseseat/js 0.3.1 → 0.4.1

package/dist/index.js

@@ -300,12 +300,12 @@ function generateDeviceId() {
     return `node-${hashCode(os + "|" + arch)}`;
   }
   const nav = window.navigator;
-  const screen = window.screen;
+  const screen2 = window.screen;
   const data = [
     nav.userAgent,
     nav.language,
-    screen.colorDepth,
-    screen.width + "x" + screen.height,
+    screen2.colorDepth,
+    screen2.width + "x" + screen2.height,
     (/* @__PURE__ */ new Date()).getTimezoneOffset(),
     nav.hardwareConcurrency,
     getCanvasFingerprint()
@@ -320,7 +320,366 @@ function getCsrfToken() {
   return token ? token.content : "";
 }
 
+// src/telemetry.js
+function detectOSName() {
+  if (typeof process !== "undefined" && process.platform) {
+    const map = {
+      darwin: "macOS",
+      win32: "Windows",
+      linux: "Linux",
+      freebsd: "FreeBSD",
+      sunos: "SunOS"
+    };
+    return map[process.platform] || process.platform;
+  }
+  if (typeof navigator !== "undefined") {
+    if (navigator.userAgentData && navigator.userAgentData.platform) {
+      return navigator.userAgentData.platform;
+    }
+    const ua = navigator.userAgent || "";
+    if (/Android/i.test(ua))
+      return "Android";
+    if (/iPhone|iPad|iPod/i.test(ua))
+      return "iOS";
+    if (/Mac/i.test(ua))
+      return "macOS";
+    if (/Win/i.test(ua))
+      return "Windows";
+    if (/Linux/i.test(ua))
+      return "Linux";
+  }
+  return "Unknown";
+}
+function detectOSVersion() {
+  if (typeof process !== "undefined" && process.version) {
+    try {
+      const os = await_free_os_release();
+      if (os)
+        return os;
+    } catch (_) {
+    }
+    return process.version;
+  }
+  if (typeof navigator !== "undefined") {
+    const ua = navigator.userAgent || "";
+    const macMatch = ua.match(/Mac OS X\s+([\d._]+)/);
+    if (macMatch)
+      return macMatch[1].replace(/_/g, ".");
+    const winMatch = ua.match(/Windows NT\s+([\d.]+)/);
+    if (winMatch)
+      return winMatch[1];
+    const androidMatch = ua.match(/Android\s+([\d.]+)/);
+    if (androidMatch)
+      return androidMatch[1];
+    const iosMatch = ua.match(/OS\s+([\d._]+)/);
+    if (iosMatch)
+      return iosMatch[1].replace(/_/g, ".");
+  }
+  return null;
+}
+function await_free_os_release() {
+  try {
+    const os = new Function("try { return require('os') } catch(e) { return null }")();
+    if (os && os.release)
+      return os.release();
+  } catch (_) {
+  }
+  return null;
+}
+function dynamicRequire(moduleName) {
+  try {
+    return new Function("m", "try { return require(m) } catch(e) { return null }")(moduleName);
+  } catch (_) {
+    return null;
+  }
+}
+function detectPlatform() {
+  if (typeof process !== "undefined") {
+    if (process.versions && process.versions.electron)
+      return "electron";
+    if (process.versions && process.versions.bun)
+      return "bun";
+    if (process.versions && process.versions.node)
+      return "node";
+  }
+  if (typeof Deno !== "undefined")
+    return "deno";
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative")
+    return "react-native";
+  if (typeof window !== "undefined")
+    return "browser";
+  return "unknown";
+}
+function detectDeviceModel() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgentData) {
+      return navigator.userAgentData.model || null;
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  if (typeof Intl !== "undefined") {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().locale || null;
+    } catch (_) {
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.LANG || process.env.LC_ALL || null;
+  }
+  return null;
+}
+function detectTimezone() {
+  if (typeof Intl !== "undefined") {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone || null;
+    } catch (_) {
+    }
+  }
+  return null;
+}
+function detectDeviceType() {
+  try {
+    const platform = detectPlatform();
+    if (platform === "node" || platform === "bun" || platform === "deno")
+      return "server";
+    if (platform === "electron")
+      return "desktop";
+    if (platform === "react-native") {
+      if (typeof screen !== "undefined" && screen.width) {
+        return screen.width < 768 ? "phone" : "tablet";
+      }
+      return "phone";
+    }
+    if (typeof navigator !== "undefined") {
+      if (navigator.userAgentData && typeof navigator.userAgentData.mobile === "boolean") {
+        if (navigator.userAgentData.mobile) {
+          if (typeof screen !== "undefined" && screen.width >= 768)
+            return "tablet";
+          return "phone";
+        }
+        return "desktop";
+      }
+      if (navigator.maxTouchPoints > 0) {
+        if (typeof screen !== "undefined" && screen.width >= 768)
+          return "tablet";
+        return "phone";
+      }
+      return "desktop";
+    }
+  } catch (_) {
+  }
+  return "unknown";
+}
+function detectArchitecture() {
+  try {
+    if (typeof process !== "undefined" && process.arch) {
+      const map = { ia32: "x86", x64: "x64", arm: "arm", arm64: "arm64" };
+      return map[process.arch] || process.arch;
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgentData) {
+      if (navigator.userAgentData.architecture) {
+        return navigator.userAgentData.architecture;
+      }
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectCpuCores() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
+      return navigator.hardwareConcurrency;
+    }
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const os = dynamicRequire("os");
+      if (os && os.cpus) {
+        const cpus = os.cpus();
+        if (cpus && cpus.length)
+          return cpus.length;
+      }
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectMemoryGb() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.deviceMemory) {
+      return navigator.deviceMemory;
+    }
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const os = dynamicRequire("os");
+      if (os && os.totalmem) {
+        return Math.round(os.totalmem() / (1024 * 1024 * 1024));
+      }
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectLanguage() {
+  try {
+    const locale = detectLocale();
+    if (locale) {
+      const lang = locale.split(/[-_]/)[0];
+      if (lang && lang.length >= 2)
+        return lang.toLowerCase();
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectScreenResolution() {
+  try {
+    if (typeof screen !== "undefined" && screen.width && screen.height) {
+      return `${screen.width}x${screen.height}`;
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectDisplayScale() {
+  try {
+    if (typeof window !== "undefined" && window.devicePixelRatio) {
+      return window.devicePixelRatio;
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectBrowserName() {
+  try {
+    if (typeof navigator === "undefined")
+      return null;
+    if (navigator.userAgentData && navigator.userAgentData.brands) {
+      const brands = navigator.userAgentData.brands;
+      for (const b of brands) {
+        const name = b.brand || "";
+        if (/^(Google Chrome|Microsoft Edge|Opera|Brave|Vivaldi|Samsung Internet)$/i.test(name)) {
+          return name;
+        }
+      }
+      for (const b of brands) {
+        if ((b.brand || "").toLowerCase() === "chromium")
+          return "Chrome";
+      }
+    }
+    const ua = navigator.userAgent || "";
+    if (/Edg\//i.test(ua))
+      return "Edge";
+    if (/OPR\//i.test(ua) || /Opera/i.test(ua))
+      return "Opera";
+    if (/Brave/i.test(ua))
+      return "Brave";
+    if (/Vivaldi/i.test(ua))
+      return "Vivaldi";
+    if (/Firefox/i.test(ua))
+      return "Firefox";
+    if (/SamsungBrowser/i.test(ua))
+      return "Samsung Internet";
+    if (/CriOS/i.test(ua))
+      return "Chrome";
+    if (/Chrome/i.test(ua))
+      return "Chrome";
+    if (/Safari/i.test(ua))
+      return "Safari";
+  } catch (_) {
+  }
+  return null;
+}
+function detectBrowserVersion() {
+  try {
+    if (typeof navigator === "undefined")
+      return null;
+    if (navigator.userAgentData && navigator.userAgentData.brands) {
+      const brands = navigator.userAgentData.brands;
+      for (const b of brands) {
+        const name = b.brand || "";
+        if (/^(Google Chrome|Microsoft Edge|Opera|Brave|Vivaldi|Samsung Internet)$/i.test(name)) {
+          return b.version || null;
+        }
+      }
+      for (const b of brands) {
+        if ((b.brand || "").toLowerCase() === "chromium")
+          return b.version || null;
+      }
+    }
+    const ua = navigator.userAgent || "";
+    const patterns = [
+      /Edg\/([\d.]+)/,
+      /OPR\/([\d.]+)/,
+      /Firefox\/([\d.]+)/,
+      /SamsungBrowser\/([\d.]+)/,
+      /CriOS\/([\d.]+)/,
+      /Chrome\/([\d.]+)/,
+      /Version\/([\d.]+).*Safari/
+    ];
+    for (const re of patterns) {
+      const m = ua.match(re);
+      if (m)
+        return m[1];
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function detectRuntimeVersion() {
+  try {
+    if (typeof process !== "undefined" && process.versions) {
+      if (process.versions.bun)
+        return process.versions.bun;
+      if (process.versions.electron)
+        return process.versions.electron;
+      if (process.versions.node)
+        return process.versions.node;
+    }
+    if (typeof Deno !== "undefined" && Deno.version)
+      return Deno.version.deno;
+  } catch (_) {
+  }
+  return null;
+}
+function collectTelemetry(sdkVersion, options) {
+  const locale = detectLocale();
+  const raw = {
+    sdk_version: sdkVersion,
+    sdk_name: "js",
+    os_name: detectOSName(),
+    os_version: detectOSVersion(),
+    platform: detectPlatform(),
+    device_model: detectDeviceModel(),
+    device_type: detectDeviceType(),
+    locale,
+    timezone: detectTimezone(),
+    language: detectLanguage(),
+    architecture: detectArchitecture(),
+    cpu_cores: detectCpuCores(),
+    memory_gb: detectMemoryGb(),
+    screen_resolution: detectScreenResolution(),
+    display_scale: detectDisplayScale(),
+    browser_name: detectBrowserName(),
+    browser_version: detectBrowserVersion(),
+    runtime_version: detectRuntimeVersion(),
+    app_version: options && options.appVersion || null,
+    app_build: options && options.appBuild || null
+  };
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (value != null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 // src/LicenseSeat.js
+var SDK_VERSION = "0.4.1";
 var DEFAULT_CONFIG = {
   apiBaseUrl: "https://licenseseat.com/api/v1",
   productSlug: null,
@@ -328,6 +687,8 @@ var DEFAULT_CONFIG = {
   storagePrefix: "licenseseat_",
   autoValidateInterval: 36e5,
   // 1 hour
+  heartbeatInterval: 3e5,
+  // 5 minutes
   networkRecheckInterval: 3e4,
   // 30 seconds
   maxRetries: 3,
@@ -342,7 +703,13 @@ var DEFAULT_CONFIG = {
   // 0 = disabled
   maxClockSkewMs: 5 * 60 * 1e3,
   // 5 minutes
-  autoInitialize: true
+  autoInitialize: true,
+  telemetryEnabled: true,
+  // Set false to disable telemetry (e.g. for GDPR compliance)
+  appVersion: null,
+  // User-provided app version, sent as app_version in telemetry
+  appBuild: null
+  // User-provided app build, sent as app_build in telemetry
 };
 var LicenseSeatSDK = class {
   /**
@@ -356,6 +723,7 @@ var LicenseSeatSDK = class {
     };
     this.eventListeners = {};
     this.validationTimer = null;
+    this.heartbeatTimer = null;
     this.cache = new LicenseCache(this.config.storagePrefix);
     this.online = true;
     this.currentAutoLicenseKey = null;
@@ -402,6 +770,7 @@ var LicenseSeatSDK = class {
       }
       if (this.config.apiKey) {
         this.startAutoValidation(cachedLicense.license_key);
+        this.startHeartbeat();
         this.validateLicense(cachedLicense.license_key).catch((err) => {
           this.log("Background validation failed:", err);
           if (err instanceof APIError && (err.status === 401 || err.status === 501)) {
@@ -457,6 +826,7 @@ var LicenseSeatSDK = class {
       this.cache.setLicense(licenseData);
       this.cache.updateValidation({ valid: true, optimistic: true });
       this.startAutoValidation(licenseKey);
+      this.startHeartbeat();
       this.syncOfflineAssets();
       this.scheduleOfflineRefresh();
       this.emit("activation:success", licenseData);
@@ -495,6 +865,7 @@ var LicenseSeatSDK = class {
       this.cache.clearLicense();
       this.cache.clearOfflineToken();
       this.stopAutoValidation();
+      this.stopHeartbeat();
       this.emit("deactivation:success", response);
       return response;
     } catch (error) {
@@ -825,12 +1196,41 @@ var LicenseSeatSDK = class {
       throw error;
     }
   }
+  /**
+   * Send a heartbeat for the current license.
+   * Heartbeats let the server know the device is still active.
+   * @returns {Promise<Object|undefined>} Heartbeat response, or undefined if no active license
+   * @throws {ConfigurationError} When productSlug is not configured
+   * @throws {APIError} When the API request fails
+   */
+  async heartbeat() {
+    if (!this.config.productSlug) {
+      throw new ConfigurationError("productSlug is required for heartbeat");
+    }
+    const cached = this.cache.getLicense();
+    if (!cached) {
+      this.log("No active license for heartbeat");
+      return;
+    }
+    const body = { device_id: cached.device_id };
+    const response = await this.apiCall(
+      `/products/${this.config.productSlug}/licenses/${encodeURIComponent(cached.license_key)}/heartbeat`,
+      {
+        method: "POST",
+        body
+      }
+    );
+    this.emit("heartbeat:success", response);
+    this.log("Heartbeat sent successfully");
+    return response;
+  }
   /**
    * Clear all data and reset SDK state
    * @returns {void}
    */
   reset() {
     this.stopAutoValidation();
+    this.stopHeartbeat();
     this.stopConnectivityPolling();
     if (this.offlineRefreshTimer) {
       clearInterval(this.offlineRefreshTimer);
@@ -850,6 +1250,7 @@ var LicenseSeatSDK = class {
   destroy() {
     this.destroyed = true;
     this.stopAutoValidation();
+    this.stopHeartbeat();
     this.stopConnectivityPolling();
     if (this.offlineRefreshTimer) {
       clearInterval(this.offlineRefreshTimer);
@@ -922,8 +1323,14 @@ var LicenseSeatSDK = class {
     this.stopAutoValidation();
     this.currentAutoLicenseKey = licenseKey;
     const validationInterval = this.config.autoValidateInterval;
+    if (!validationInterval || validationInterval <= 0) {
+      this.log("Auto-validation disabled (interval:", validationInterval, ")");
+      return;
+    }
     const performAndReschedule = () => {
-      this.validateLicense(licenseKey).catch((err) => {
+      this.validateLicense(licenseKey).then(() => {
+        this.heartbeat().catch((err) => this.log("Heartbeat failed:", err));
+      }).catch((err) => {
         this.log("Auto-validation failed:", err);
         this.emit("validation:auto-failed", { licenseKey, error: err });
       });
@@ -948,6 +1355,35 @@ var LicenseSeatSDK = class {
       this.emit("autovalidation:stopped");
     }
   }
+  /**
+   * Start separate heartbeat timer
+   * Sends periodic heartbeats between auto-validation cycles.
+   * @returns {void}
+   * @private
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    const interval = this.config.heartbeatInterval;
+    if (!interval || interval <= 0) {
+      this.log("Heartbeat timer disabled (interval:", interval, ")");
+      return;
+    }
+    this.heartbeatTimer = setInterval(() => {
+      this.heartbeat().then(() => this.emit("heartbeat:cycle", { nextRunAt: new Date(Date.now() + interval) })).catch((err) => this.log("Heartbeat timer failed:", err));
+    }, interval);
+    this.log("Heartbeat timer started (interval:", interval, "ms)");
+  }
+  /**
+   * Stop the separate heartbeat timer
+   * @returns {void}
+   * @private
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
   /**
    * Start connectivity polling (when offline)
    * @returns {void}
@@ -958,10 +1394,12 @@ var LicenseSeatSDK = class {
       return;
     const healthCheck = async () => {
       try {
-        await fetch(`${this.config.apiBaseUrl}/health`, {
+        const res = await fetch(`${this.config.apiBaseUrl}/health`, {
           method: "GET",
           credentials: "omit"
         });
+        await res.text().catch(() => {
+        });
         if (!this.online) {
           this.online = true;
           this.emit("network:online");
@@ -994,10 +1432,10 @@ var LicenseSeatSDK = class {
   // Offline License Management
   // ============================================================
   /**
-   * Fetch and cache offline token and signing key
-   * Uses a lock to prevent concurrent calls from causing race conditions
+   * Download and cache the offline token and its corresponding public signing key.
+   * Emits `offlineToken:ready` on success. Safe to call multiple times — concurrent
+   * calls are deduplicated automatically.
    * @returns {Promise<void>}
-   * @private
    */
   async syncOfflineAssets() {
     if (this.syncingOfflineAssets || this.destroyed) {
@@ -1048,9 +1486,10 @@ var LicenseSeatSDK = class {
     );
   }
   /**
-   * Verify cached offline token
+   * Verify the cached offline token and return a validation result.
+   * Use this to validate the license when the device is offline.
+   * The offline token must have been previously downloaded via {@link syncOfflineAssets}.
    * @returns {Promise<import('./types.js').ValidationResult>}
-   * @private
    */
   async verifyCachedOffline() {
     const signed = this.cache.getOfflineToken();
@@ -1183,12 +1622,20 @@ var LicenseSeatSDK = class {
         "[Warning] No API key configured for LicenseSeat SDK. Authenticated endpoints will fail."
       );
     }
+    const method = options.method || "GET";
+    let body = options.body;
+    if (method === "POST" && body && this.config.telemetryEnabled !== false) {
+      body = { ...body, telemetry: collectTelemetry(SDK_VERSION, {
+        appVersion: this.config.appVersion,
+        appBuild: this.config.appBuild
+      }) };
+    }
     for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
       try {
         const response = await fetch(url, {
-          method: options.method || "GET",
+          method,
           headers,
-          body: options.body ? JSON.stringify(options.body) : void 0,
+          body: body ? JSON.stringify(body) : void 0,
           credentials: "omit"
         });
         const data = await response.json();
@@ -1312,8 +1759,10 @@ export {
   LicenseCache,
   LicenseError,
   LicenseSeatSDK,
+  SDK_VERSION,
   base64UrlDecode,
   canonicalJsonStringify,
+  collectTelemetry,
   configure,
   constantTimeEqual,
   src_default as default,

package/dist/types/LicenseSeat.d.ts

@@ -16,6 +16,11 @@ export function configure(config: import("./types.js").LicenseSeatConfig, force?
  * @returns {void}
  */
 export function resetSharedInstance(): void;
+/**
+ * SDK version constant
+ * @type {string}
+ */
+export const SDK_VERSION: string;
 /**
  * LicenseSeat SDK Main Class
  *
@@ -61,6 +66,12 @@ export class LicenseSeatSDK {
      * @private
      */
     private validationTimer;
+    /**
+     * Heartbeat timer ID (separate from auto-validation)
+     * @type {ReturnType<typeof setInterval>|null}
+     * @private
+     */
+    private heartbeatTimer;
     /**
      * License cache manager
      * @type {LicenseCache}
@@ -204,6 +215,14 @@ export class LicenseSeatSDK {
         healthy: boolean;
         api_version: string;
     }>;
+    /**
+     * Send a heartbeat for the current license.
+     * Heartbeats let the server know the device is still active.
+     * @returns {Promise<Object|undefined>} Heartbeat response, or undefined if no active license
+     * @throws {ConfigurationError} When productSlug is not configured
+     * @throws {APIError} When the API request fails
+     */
+    heartbeat(): Promise<any | undefined>;
     /**
      * Clear all data and reset SDK state
      * @returns {void}
@@ -251,6 +270,19 @@ export class LicenseSeatSDK {
      * @private
      */
     private stopAutoValidation;
+    /**
+     * Start separate heartbeat timer
+     * Sends periodic heartbeats between auto-validation cycles.
+     * @returns {void}
+     * @private
+     */
+    private startHeartbeat;
+    /**
+     * Stop the separate heartbeat timer
+     * @returns {void}
+     * @private
+     */
+    private stopHeartbeat;
     /**
      * Start connectivity polling (when offline)
      * @returns {void}
@@ -264,12 +296,12 @@ export class LicenseSeatSDK {
      */
     private stopConnectivityPolling;
     /**
-     * Fetch and cache offline token and signing key
-     * Uses a lock to prevent concurrent calls from causing race conditions
+     * Download and cache the offline token and its corresponding public signing key.
+     * Emits `offlineToken:ready` on success. Safe to call multiple times — concurrent
+     * calls are deduplicated automatically.
      * @returns {Promise<void>}
-     * @private
      */
-    private syncOfflineAssets;
+    syncOfflineAssets(): Promise<void>;
     /**
      * Schedule periodic offline license refresh
      * @returns {void}
@@ -277,11 +309,12 @@ export class LicenseSeatSDK {
      */
     private scheduleOfflineRefresh;
     /**
-     * Verify cached offline token
+     * Verify the cached offline token and return a validation result.
+     * Use this to validate the license when the device is offline.
+     * The offline token must have been previously downloaded via {@link syncOfflineAssets}.
      * @returns {Promise<import('./types.js').ValidationResult>}
-     * @private
      */
-    private verifyCachedOffline;
+    verifyCachedOffline(): Promise<import("./types.js").ValidationResult>;
     /**
      * Quick offline verification using only local data (no network)
      * Performs signature verification plus basic validity checks (expiry, license key match)