@moonbase.sh/licensing 3.1.0 → 3.2.0

package/README.md

@@ -59,19 +59,68 @@ console.log('License stored locally')
 
 ## Validate on startup
 
-```ts
-const localLicense = await licensing.store.loadLocalLicense()
-
-if (localLicense) {
-  // Validate token signature + device binding locally
-  const locallyValidated = await licensing.validator.validateLicense(localLicense.token)
+Only delete the stored license when Moonbase says the license is gone. Deleting it on any error makes
+the user re-activate every time a check fails for a reason that has nothing to do with the license,
+such as opening the app offline.
 
-  // Re-validate against Moonbase (recommended for online activations)
-  const refreshed = await licensing.client.validateLicense(locallyValidated)
-  await licensing.store.storeLocalLicense(refreshed)
+```ts
+import type { License } from '@moonbase.sh/licensing'
+import { ActivationMethod, ErrorType, MoonbaseError } from '@moonbase.sh/licensing'
+
+// Moonbase says the license can no longer be used on this device. Anything
+// else, an ErrorType.ApiError or a network failure (which is not a
+// MoonbaseError), only means Moonbase could not be reached right now.
+const licenseGone = new Set<ErrorType | undefined>([
+  ErrorType.LicenseRevoked,
+  ErrorType.LicenseActivationRevoked,
+  ErrorType.LicenseExpired,
+  ErrorType.LicenseInvalid,
+  ErrorType.LicenseDeviceMismatch,
+  ErrorType.StoreClosed,
+])
+
+async function licenseOnStartup(): Promise<License | null> {
+  const localLicense = await licensing.store.loadLocalLicense()
+  if (!localLicense)
+    return null
+
+  if (localLicense.activationMethod === ActivationMethod.Online) {
+    try {
+      // Ask Moonbase first: it is how a revocation reaches the app, and how a
+      // token whose expiry has passed is refreshed after a renewal
+      const refreshed = await licensing.client.validateLicense(localLicense)
+      await licensing.store.storeLocalLicense(refreshed)
+      return refreshed
+    }
+    catch (err) {
+      if (err instanceof MoonbaseError && licenseGone.has(err.type)) {
+        await licensing.store.deleteLocalLicense()
+        return null // show your activation flow
+      }
+      // Moonbase could not be reached, so check the license locally instead
+    }
+  }
+
+  try {
+    // Signature, device binding and expiry, which needs no network
+    return await licensing.validator.validateLicense(localLicense.token)
+  }
+  catch (err) {
+    // Keep the stored token: only Moonbase can say the license is gone, and the
+    // next launch that reaches it can still refresh a token that has expired
+    if (err instanceof MoonbaseError)
+      return null // show your activation flow
+    throw err
+  }
 }
 ```
 
+A revoked license reports `ErrorType.LicenseRevoked`; a revoked device, whose license may still be
+active, reports `ErrorType.LicenseActivationRevoked`. To limit how long an app keeps running without
+reaching Moonbase, compare `license.validatedAt` with a limit of your choosing before returning the
+locally validated license. For `ErrorType.LicenseDeviceMismatch`, see [Device fingerprint](#device-fingerprint)
+first: after an SDK update, it can mean the same machine under an older fingerprint.
+
 ## Metadata, platform, and app version
 
 The SDK can report analytics with every activation, trial request, and validation. These are configured once on the `MoonbaseLicensing` config and sent automatically; there's no per-call parameter.

package/dist/index.cjs

@@ -68,6 +68,43 @@ var import_node_process3 = __toESM(require("process"), 1);
 // src/client.ts
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
+// src/errors.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["None"] = "None";
+  ErrorType2["ApiError"] = "ApiError";
+  ErrorType2["NoEligibleLicense"] = "NoEligibleLicense";
+  ErrorType2["LicenseInvalid"] = "LicenseInvalid";
+  ErrorType2["LicenseRevoked"] = "LicenseRevoked";
+  ErrorType2["LicenseActivationRevoked"] = "LicenseActivationRevoked";
+  ErrorType2["LicenseExpired"] = "LicenseExpired";
+  ErrorType2["LicenseDeviceMismatch"] = "LicenseDeviceMismatch";
+  ErrorType2["DeviceIdentityUnavailable"] = "DeviceIdentityUnavailable";
+  ErrorType2["StoreClosed"] = "StoreClosed";
+  return ErrorType2;
+})(ErrorType || {});
+var MoonbaseError = class extends Error {
+  constructor(title, detail, type, inner) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.type = type;
+    this.inner = inner;
+    this.name = "MoonbaseError";
+    this.message = detail != null ? detail : title;
+  }
+};
+var InsufficientDeviceIdentityError = class extends MoonbaseError {
+  constructor(platform, reason = "no identity parameter could be read") {
+    super(
+      "No device identity",
+      `Could not identify this device (platform: ${platform}): ${reason}`,
+      "DeviceIdentityUnavailable" /* DeviceIdentityUnavailable */
+    );
+    this.platform = platform;
+    this.name = "InsufficientDeviceIdentityError";
+  }
+};
+
 // src/schemas.ts
 var import_zod = require("zod");
 
@@ -84,6 +121,11 @@ var activationRequestResponseSchema = import_zod.z.object({
   request: import_zod.z.string(),
   browser: import_zod.z.string()
 });
+var problemDetailsSchema = import_zod.z.object({
+  title: import_zod.z.string().nullish(),
+  detail: import_zod.z.string().nullish(),
+  errorType: import_zod.z.string().nullish()
+});
 var productSchema = import_zod.z.object({
   id: import_zod.z.string(),
   name: import_zod.z.string(),
@@ -138,7 +180,7 @@ var LicenseClient = class {
       body: JSON.stringify(content)
     });
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
     try {
       return activationRequestResponseSchema.parse(await response.json());
@@ -203,12 +245,12 @@ var LicenseClient = class {
       body: license.token
     });
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
   }
   async handleLicenseResponse(response) {
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
     return await this.licenseValidator.validateLicense(await response.text());
   }
@@ -229,6 +271,36 @@ var LicenseClient = class {
     return `?${parts.join("&")}`;
   }
 };
+var licenseErrorTypes = /* @__PURE__ */ new Set([
+  "NoEligibleLicense" /* NoEligibleLicense */,
+  "LicenseInvalid" /* LicenseInvalid */,
+  "LicenseRevoked" /* LicenseRevoked */,
+  "LicenseActivationRevoked" /* LicenseActivationRevoked */,
+  "LicenseExpired" /* LicenseExpired */,
+  "StoreClosed" /* StoreClosed */
+]);
+async function errorFromResponse(response) {
+  const fallback = new MoonbaseError(
+    "Request not successful",
+    `The API responded with a ${response.status} ${response.statusText} response`,
+    "ApiError" /* ApiError */
+  );
+  let body;
+  try {
+    body = JSON.parse(await response.text());
+  } catch (e) {
+    return fallback;
+  }
+  const problem = problemDetailsSchema.safeParse(body);
+  if (!problem.success)
+    return fallback;
+  const { title, detail, errorType } = problem.data;
+  return new MoonbaseError(
+    title != null ? title : fallback.title,
+    detail != null ? detail : fallback.detail,
+    errorType && licenseErrorTypes.has(errorType) ? errorType : "ApiError" /* ApiError */
+  );
+}
 
 // src/deviceIdResolver.ts
 var import_node_child_process2 = __toESM(require("child_process"), 1);
@@ -237,42 +309,6 @@ var import_node_os2 = __toESM(require("os"), 1);
 var import_node_process2 = __toESM(require("process"), 1);
 var import_systeminformation = __toESM(require("systeminformation"), 1);
 
-// src/errors.ts
-var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
-  ErrorType2["None"] = "None";
-  ErrorType2["ApiError"] = "ApiError";
-  ErrorType2["NoEligibleLicense"] = "NoEligibleLicense";
-  ErrorType2["LicenseInvalid"] = "LicenseInvalid";
-  ErrorType2["LicenseRevoked"] = "LicenseRevoked";
-  ErrorType2["LicenseActivationRevoked"] = "LicenseActivationRevoked";
-  ErrorType2["LicenseExpired"] = "LicenseExpired";
-  ErrorType2["LicenseDeviceMismatch"] = "LicenseDeviceMismatch";
-  ErrorType2["DeviceIdentityUnavailable"] = "DeviceIdentityUnavailable";
-  return ErrorType2;
-})(ErrorType || {});
-var MoonbaseError = class extends Error {
-  constructor(title, detail, type, inner) {
-    super();
-    this.title = title;
-    this.detail = detail;
-    this.type = type;
-    this.inner = inner;
-    this.name = "MoonbaseError";
-    this.message = detail != null ? detail : title;
-  }
-};
-var InsufficientDeviceIdentityError = class extends MoonbaseError {
-  constructor(platform, reason = "no identity parameter could be read") {
-    super(
-      "No device identity",
-      `Could not identify this device (platform: ${platform}): ${reason}`,
-      "DeviceIdentityUnavailable" /* DeviceIdentityUnavailable */
-    );
-    this.platform = platform;
-    this.name = "InsufficientDeviceIdentityError";
-  }
-};
-
 // src/fingerprint.ts
 var import_node_buffer = require("buffer");
 var import_node_child_process = __toESM(require("child_process"), 1);

package/dist/index.d.cts

@@ -597,18 +597,39 @@ declare class LicenseValidator implements ILicenseValidator {
     private parseLicenseToken;
 }
 
+/**
+ * What went wrong, on a {@link MoonbaseError}. The license types say the license
+ * is no longer usable, so a stored copy can be deleted. `ApiError` only says no
+ * answer was had: keep the stored license and try again later.
+ */
 declare enum ErrorType {
     None = "None",
+    /**
+     * The request failed without saying anything about the license: an outage, a
+     * rate limit, a proxy error page. Transient, so keep any stored license. A
+     * network failure is not a `MoonbaseError` at all, and is transient too.
+     */
     ApiError = "ApiError",
+    /** The customer has no license for this product to activate. */
     NoEligibleLicense = "NoEligibleLicense",
+    /** The license token failed verification (signature, issuer or product), or the stored license could not be read. */
     LicenseInvalid = "LicenseInvalid",
+    /** The merchant revoked the license, for example after a refund. */
     LicenseRevoked = "LicenseRevoked",
+    /** This device's activation was revoked, freeing its seat. The license itself may still be active. */
     LicenseActivationRevoked = "LicenseActivationRevoked",
+    /** The license, or trial, has expired. */
     LicenseExpired = "LicenseExpired",
     /** The license is valid but bound to a different device, or to an older fingerprint version. */
     LicenseDeviceMismatch = "LicenseDeviceMismatch",
     /** No stable hardware identifier could be read, so no device id can be computed. */
-    DeviceIdentityUnavailable = "DeviceIdentityUnavailable"
+    DeviceIdentityUnavailable = "DeviceIdentityUnavailable",
+    /**
+     * The store this product is sold through has closed its Moonbase account. Not transient:
+     * nothing about the license can be validated, activated or renewed online again. An offline
+     * license keeps validating, since that never asks the server.
+     */
+    StoreClosed = "StoreClosed"
 }
 declare class MoonbaseError extends Error {
     readonly title: string;

package/dist/index.d.ts

@@ -597,18 +597,39 @@ declare class LicenseValidator implements ILicenseValidator {
     private parseLicenseToken;
 }
 
+/**
+ * What went wrong, on a {@link MoonbaseError}. The license types say the license
+ * is no longer usable, so a stored copy can be deleted. `ApiError` only says no
+ * answer was had: keep the stored license and try again later.
+ */
 declare enum ErrorType {
     None = "None",
+    /**
+     * The request failed without saying anything about the license: an outage, a
+     * rate limit, a proxy error page. Transient, so keep any stored license. A
+     * network failure is not a `MoonbaseError` at all, and is transient too.
+     */
     ApiError = "ApiError",
+    /** The customer has no license for this product to activate. */
     NoEligibleLicense = "NoEligibleLicense",
+    /** The license token failed verification (signature, issuer or product), or the stored license could not be read. */
     LicenseInvalid = "LicenseInvalid",
+    /** The merchant revoked the license, for example after a refund. */
     LicenseRevoked = "LicenseRevoked",
+    /** This device's activation was revoked, freeing its seat. The license itself may still be active. */
     LicenseActivationRevoked = "LicenseActivationRevoked",
+    /** The license, or trial, has expired. */
     LicenseExpired = "LicenseExpired",
     /** The license is valid but bound to a different device, or to an older fingerprint version. */
     LicenseDeviceMismatch = "LicenseDeviceMismatch",
     /** No stable hardware identifier could be read, so no device id can be computed. */
-    DeviceIdentityUnavailable = "DeviceIdentityUnavailable"
+    DeviceIdentityUnavailable = "DeviceIdentityUnavailable",
+    /**
+     * The store this product is sold through has closed its Moonbase account. Not transient:
+     * nothing about the license can be validated, activated or renewed online again. An offline
+     * license keeps validating, since that never asks the server.
+     */
+    StoreClosed = "StoreClosed"
 }
 declare class MoonbaseError extends Error {
     readonly title: string;

package/dist/index.js

@@ -5,6 +5,43 @@ import process3 from "process";
 // src/client.ts
 import fetch from "cross-fetch";
 
+// src/errors.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["None"] = "None";
+  ErrorType2["ApiError"] = "ApiError";
+  ErrorType2["NoEligibleLicense"] = "NoEligibleLicense";
+  ErrorType2["LicenseInvalid"] = "LicenseInvalid";
+  ErrorType2["LicenseRevoked"] = "LicenseRevoked";
+  ErrorType2["LicenseActivationRevoked"] = "LicenseActivationRevoked";
+  ErrorType2["LicenseExpired"] = "LicenseExpired";
+  ErrorType2["LicenseDeviceMismatch"] = "LicenseDeviceMismatch";
+  ErrorType2["DeviceIdentityUnavailable"] = "DeviceIdentityUnavailable";
+  ErrorType2["StoreClosed"] = "StoreClosed";
+  return ErrorType2;
+})(ErrorType || {});
+var MoonbaseError = class extends Error {
+  constructor(title, detail, type, inner) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.type = type;
+    this.inner = inner;
+    this.name = "MoonbaseError";
+    this.message = detail != null ? detail : title;
+  }
+};
+var InsufficientDeviceIdentityError = class extends MoonbaseError {
+  constructor(platform, reason = "no identity parameter could be read") {
+    super(
+      "No device identity",
+      `Could not identify this device (platform: ${platform}): ${reason}`,
+      "DeviceIdentityUnavailable" /* DeviceIdentityUnavailable */
+    );
+    this.platform = platform;
+    this.name = "InsufficientDeviceIdentityError";
+  }
+};
+
 // src/schemas.ts
 import { z } from "zod";
 
@@ -21,6 +58,11 @@ var activationRequestResponseSchema = z.object({
   request: z.string(),
   browser: z.string()
 });
+var problemDetailsSchema = z.object({
+  title: z.string().nullish(),
+  detail: z.string().nullish(),
+  errorType: z.string().nullish()
+});
 var productSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -75,7 +117,7 @@ var LicenseClient = class {
       body: JSON.stringify(content)
     });
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
     try {
       return activationRequestResponseSchema.parse(await response.json());
@@ -140,12 +182,12 @@ var LicenseClient = class {
       body: license.token
     });
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
   }
   async handleLicenseResponse(response) {
     if (response.status >= 400) {
-      throw new MoonbaseError("Request not successful", `The API responded with a ${response.status} ${response.statusText} response`, "ApiError" /* ApiError */);
+      throw await errorFromResponse(response);
     }
     return await this.licenseValidator.validateLicense(await response.text());
   }
@@ -166,6 +208,36 @@ var LicenseClient = class {
     return `?${parts.join("&")}`;
   }
 };
+var licenseErrorTypes = /* @__PURE__ */ new Set([
+  "NoEligibleLicense" /* NoEligibleLicense */,
+  "LicenseInvalid" /* LicenseInvalid */,
+  "LicenseRevoked" /* LicenseRevoked */,
+  "LicenseActivationRevoked" /* LicenseActivationRevoked */,
+  "LicenseExpired" /* LicenseExpired */,
+  "StoreClosed" /* StoreClosed */
+]);
+async function errorFromResponse(response) {
+  const fallback = new MoonbaseError(
+    "Request not successful",
+    `The API responded with a ${response.status} ${response.statusText} response`,
+    "ApiError" /* ApiError */
+  );
+  let body;
+  try {
+    body = JSON.parse(await response.text());
+  } catch (e) {
+    return fallback;
+  }
+  const problem = problemDetailsSchema.safeParse(body);
+  if (!problem.success)
+    return fallback;
+  const { title, detail, errorType } = problem.data;
+  return new MoonbaseError(
+    title != null ? title : fallback.title,
+    detail != null ? detail : fallback.detail,
+    errorType && licenseErrorTypes.has(errorType) ? errorType : "ApiError" /* ApiError */
+  );
+}
 
 // src/deviceIdResolver.ts
 import cp2 from "child_process";
@@ -174,42 +246,6 @@ import os2 from "os";
 import process2 from "process";
 import si from "systeminformation";
 
-// src/errors.ts
-var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
-  ErrorType2["None"] = "None";
-  ErrorType2["ApiError"] = "ApiError";
-  ErrorType2["NoEligibleLicense"] = "NoEligibleLicense";
-  ErrorType2["LicenseInvalid"] = "LicenseInvalid";
-  ErrorType2["LicenseRevoked"] = "LicenseRevoked";
-  ErrorType2["LicenseActivationRevoked"] = "LicenseActivationRevoked";
-  ErrorType2["LicenseExpired"] = "LicenseExpired";
-  ErrorType2["LicenseDeviceMismatch"] = "LicenseDeviceMismatch";
-  ErrorType2["DeviceIdentityUnavailable"] = "DeviceIdentityUnavailable";
-  return ErrorType2;
-})(ErrorType || {});
-var MoonbaseError = class extends Error {
-  constructor(title, detail, type, inner) {
-    super();
-    this.title = title;
-    this.detail = detail;
-    this.type = type;
-    this.inner = inner;
-    this.name = "MoonbaseError";
-    this.message = detail != null ? detail : title;
-  }
-};
-var InsufficientDeviceIdentityError = class extends MoonbaseError {
-  constructor(platform, reason = "no identity parameter could be read") {
-    super(
-      "No device identity",
-      `Could not identify this device (platform: ${platform}): ${reason}`,
-      "DeviceIdentityUnavailable" /* DeviceIdentityUnavailable */
-    );
-    this.platform = platform;
-    this.name = "InsufficientDeviceIdentityError";
-  }
-};
-
 // src/fingerprint.ts
 import { Buffer } from "buffer";
 import cp from "child_process";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonbase.sh/licensing",
   "type": "module",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Package to add sotftware licensing using Moonbase.sh to your node.js apps",
   "author": "Tobias Lønnerød Madsen <m@dsen.tv>",
   "license": "MIT",
@@ -33,6 +33,8 @@
     "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
     "version": "npm version",
     "type-check": "tsc --noEmit -p tsconfig.typecheck.json",
+    "lint": "eslint . --cache --cache-location node_modules/.cache/eslint/ --cache-strategy content",
+    "lint:fix": "eslint . --cache --cache-location node_modules/.cache/eslint/ --cache-strategy content --fix",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:integration": "TEST_INTEGRATION=true vitest run"