@moonbase.sh/licensing 0.3.37

package/dist/index.cjs

@@ -0,0 +1,424 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ActivationMethod: () => ActivationMethod,
+  DefaultDeviceIdResolver: () => DefaultDeviceIdResolver,
+  ErrorType: () => ErrorType,
+  FileLicenseStore: () => FileLicenseStore,
+  InMemoryLicenseStore: () => InMemoryLicenseStore,
+  LicenseClient: () => LicenseClient,
+  LicenseValidator: () => LicenseValidator,
+  MoonbaseError: () => MoonbaseError,
+  MoonbaseLicensing: () => MoonbaseLicensing
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+var import_cross_fetch = __toESM(require("cross-fetch"), 1);
+
+// src/types.ts
+var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
+  ActivationMethod2["Online"] = "Online";
+  ActivationMethod2["Offline"] = "Offline";
+  return ActivationMethod2;
+})(ActivationMethod || {});
+
+// src/schemas.ts
+var import_zod = require("zod");
+var activationRequestResponseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  request: import_zod.z.string(),
+  browser: import_zod.z.string()
+});
+var productSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  currentReleaseVersion: import_zod.z.string().nullish()
+});
+var userSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  email: import_zod.z.string()
+});
+var licenseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  trial: import_zod.z.boolean(),
+  activationMethod: import_zod.z.nativeEnum(ActivationMethod),
+  product: productSchema,
+  issuedAt: import_zod.z.coerce.date(),
+  issuedTo: userSchema,
+  expiresAt: import_zod.z.coerce.date().nullish(),
+  validatedAt: import_zod.z.coerce.date(),
+  token: import_zod.z.string()
+});
+
+// src/client.ts
+var defaultFetchOptions = {
+  method: "GET",
+  mode: "cors",
+  headers: {
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+    "x-mb-client": `moonbase.js`
+  }
+};
+var LicenseClient = class {
+  constructor(configuration, deviceIdResolver, licenseValidator) {
+    this.configuration = configuration;
+    this.deviceIdResolver = deviceIdResolver;
+    this.licenseValidator = licenseValidator;
+  }
+  async requestActivation() {
+    const content = {
+      deviceName: await this.deviceIdResolver.resolveDeviceName(),
+      deviceSignature: await this.deviceIdResolver.resolveDeviceId()
+    };
+    const response = await (0, import_cross_fetch.default)(this.configuration.endpoint + `/api/client/activations/${this.configuration.productId}/request?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      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 */);
+    }
+    try {
+      return activationRequestResponseSchema.parse(await response.json());
+    } catch (err) {
+      const error = err;
+      throw new MoonbaseError(
+        "Could not request activation",
+        error.message,
+        "ApiError" /* ApiError */,
+        error
+      );
+    }
+  }
+  async getRequestedActivation(request) {
+    const response = await (0, import_cross_fetch.default)(request.request, defaultFetchOptions);
+    if (response.status === 204 || response.status === 404)
+      return null;
+    return await this.handleLicenseResponse(response);
+  }
+  async validateLicense(license) {
+    const response = await (0, import_cross_fetch.default)(this.configuration.endpoint + `/api/client/licenses/${this.configuration.productId}/validate?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      headers: {
+        ...defaultFetchOptions.headers,
+        "Content-Type": "text/plain"
+      },
+      body: license.token
+    });
+    return await this.handleLicenseResponse(response);
+  }
+  async validateRawLicense(rawLicense) {
+    const license = await this.licenseValidator.validateLicense(rawLicense.toString("utf8"));
+    if (license.activationMethod === "Offline" /* Offline */)
+      return license;
+    return await this.validateLicense(license);
+  }
+  async revokeLicense(license) {
+    const response = await (0, import_cross_fetch.default)(this.configuration.endpoint + `/api/client/licenses/${this.configuration.productId}/revoke?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      headers: {
+        ...defaultFetchOptions.headers,
+        "Content-Type": "text/plain"
+      },
+      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 */);
+    }
+  }
+  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 */);
+    }
+    return await this.licenseValidator.validateLicense(await response.text());
+  }
+};
+
+// src/deviceIdResolver.ts
+var import_systeminformation = __toESM(require("systeminformation"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_child_process = __toESM(require("child_process"), 1);
+var import_node_crypto = require("crypto");
+var DefaultDeviceIdResolver = class {
+  async resolveDeviceName() {
+    switch (process.platform) {
+      case "darwin":
+        try {
+          return import_node_child_process.default.execSync("scutil --get ComputerName").toString().trim();
+        } catch (e) {
+          return import_node_os.default.hostname();
+        }
+      case "win32":
+        return process.env.COMPUTERNAME || import_node_os.default.hostname();
+      case "linux":
+        const prettyname = import_node_child_process.default.execSync("hostnamectl --pretty").toString().trim();
+        return prettyname || import_node_os.default.hostname();
+      default:
+        return import_node_os.default.hostname();
+    }
+  }
+  async resolveDeviceId() {
+    const [cpu, hw] = await Promise.all([import_systeminformation.default.cpu(), import_systeminformation.default.system()]);
+    const parts = [
+      import_node_os.default.hostname(),
+      hw.manufacturer,
+      hw.model,
+      hw.serial,
+      hw.uuid,
+      hw.sku,
+      cpu.manufacturer,
+      cpu.brand,
+      cpu.vendor,
+      cpu.family,
+      cpu.model
+    ];
+    const hash = (0, import_node_crypto.createHash)("sha256").update(parts.join("")).digest();
+    return hash.toString("base64").replaceAll("=", "");
+  }
+};
+
+// src/store.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 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";
+  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;
+  }
+};
+
+// src/store.ts
+var InMemoryLicenseStore = class {
+  async loadLocalLicense() {
+    var _a;
+    return (_a = this.license) != null ? _a : null;
+  }
+  async storeLocalLicense(license) {
+    this.license = license;
+  }
+  async deleteLocalLicense() {
+    this.license = void 0;
+  }
+};
+var FileLicenseStore = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async loadLocalLicense() {
+    if (!import_node_fs.default.existsSync(this.path))
+      return null;
+    try {
+      const file = await import_promises.default.readFile(this.path, { encoding: "utf-8" });
+      const license = licenseSchema.parse(JSON.parse(file));
+      return license;
+    } catch (err) {
+      throw new MoonbaseError("File error", "Could not load local license", "LicenseInvalid" /* LicenseInvalid */, err);
+    }
+  }
+  async storeLocalLicense(license) {
+    await import_promises.default.writeFile(this.path, JSON.stringify(license), { encoding: "utf-8" });
+  }
+  async deleteLocalLicense() {
+    if (!import_node_fs.default.existsSync(this.path))
+      return;
+    await import_promises.default.rm(this.path);
+  }
+  get path() {
+    var _a, _b, _c, _d;
+    return import_node_path.default.resolve((_b = (_a = this.options) == null ? void 0 : _a.dir) != null ? _b : import_node_path.default.resolve(), (_d = (_c = this.options) == null ? void 0 : _c.licenseFileName) != null ? _d : "license.mb");
+  }
+};
+
+// src/validator.ts
+var import_zod2 = require("zod");
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
+var licenseClaimsSchema = import_zod2.z.object({
+  ["l:id" /* LicenseId */]: import_zod2.z.string(),
+  ["trial" /* Trial */]: import_zod2.z.string().or(import_zod2.z.boolean()).transform((v) => v === true || v === "true").pipe(import_zod2.z.boolean()),
+  ["method" /* ActivationMethod */]: import_zod2.z.nativeEnum(ActivationMethod),
+  ["sig" /* ComputerSignature */]: import_zod2.z.string(),
+  ["iat" /* IssuedAt */]: import_zod2.z.number().transform((v) => new Date(v * 1e3)).pipe(import_zod2.z.date()),
+  ["exp" /* ExpiresAt */]: import_zod2.z.number().nullish().transform((v) => v ? new Date(v * 1e3) : void 0).pipe(import_zod2.z.date().nullish()),
+  ["validated" /* ValidatedAt */]: import_zod2.z.number().transform((v) => new Date(v * 1e3)).pipe(import_zod2.z.date()),
+  ["p:id" /* ProductId */]: import_zod2.z.string(),
+  ["p:name" /* ProductName */]: import_zod2.z.string(),
+  ["p:rel" /* ProductReleaseVersion */]: import_zod2.z.string().nullish(),
+  ["u:id" /* UserId */]: import_zod2.z.string(),
+  ["u:name" /* UserName */]: import_zod2.z.string(),
+  ["u:email" /* UserEmail */]: import_zod2.z.string()
+});
+var LicenseValidator = class {
+  constructor(configuration, deviceIdResolver) {
+    this.configuration = configuration;
+    this.deviceIdResolver = deviceIdResolver;
+  }
+  async validateLicense(token) {
+    const [license, claims] = await this.parseLicenseToken(token);
+    if (license.expiresAt && license.expiresAt < /* @__PURE__ */ new Date()) {
+      throw new MoonbaseError(
+        "License expired",
+        "This license has expired",
+        "LicenseExpired" /* LicenseExpired */
+      );
+    }
+    const expectedSignature = await this.deviceIdResolver.resolveDeviceId();
+    if (expectedSignature !== claims["sig" /* ComputerSignature */]) {
+      throw new MoonbaseError(
+        "License invalide",
+        "This license is not for this device",
+        "LicenseExpired" /* LicenseExpired */
+      );
+    }
+    return license;
+  }
+  parseLicenseToken(token) {
+    return new Promise((resolve, reject) => {
+      import_jsonwebtoken.default.verify(token, this.configuration.publicKey, {
+        ignoreExpiration: true,
+        issuer: this.configuration.accountId,
+        audience: this.configuration.productId
+      }, (err, decoded) => {
+        var _a;
+        if (err) {
+          reject(new MoonbaseError(
+            "Could not validate license",
+            err.message,
+            "LicenseInvalid" /* LicenseInvalid */,
+            err
+          ));
+          return;
+        }
+        if (typeof decoded === "string") {
+          reject(new MoonbaseError(
+            "Could not validate license",
+            "The given license token could not be parsed",
+            "LicenseInvalid" /* LicenseInvalid */
+          ));
+          return;
+        }
+        try {
+          const claims = licenseClaimsSchema.parse(decoded);
+          resolve([{
+            id: claims["l:id" /* LicenseId */],
+            trial: claims["trial" /* Trial */],
+            activationMethod: claims["method" /* ActivationMethod */],
+            product: {
+              id: claims["p:id" /* ProductId */],
+              name: claims["p:name" /* ProductName */],
+              currentReleaseVersion: (_a = claims["p:rel" /* ProductReleaseVersion */]) != null ? _a : void 0
+            },
+            issuedTo: {
+              id: claims["u:id" /* UserId */],
+              name: claims["u:name" /* UserName */],
+              email: claims["u:email" /* UserEmail */]
+            },
+            expiresAt: claims["exp" /* ExpiresAt */] || void 0,
+            issuedAt: claims["iat" /* IssuedAt */],
+            validatedAt: claims["validated" /* ValidatedAt */],
+            token
+          }, claims]);
+        } catch (err2) {
+          const error = err2;
+          reject(new MoonbaseError(
+            "Could not validate license",
+            error.message,
+            "LicenseInvalid" /* LicenseInvalid */,
+            error
+          ));
+        }
+      });
+    });
+  }
+};
+
+// src/index.ts
+var MoonbaseLicensing = class {
+  constructor(configuration) {
+    var _a, _b;
+    this.configuration = {
+      ...configuration,
+      endpoint: configuration.endpoint.replace(/\/$/, "")
+    };
+    this.store = (_a = configuration.licenseStore) != null ? _a : new InMemoryLicenseStore();
+    this.deviceIdResolver = (_b = configuration.deivceIdResolver) != null ? _b : new DefaultDeviceIdResolver();
+    this.validator = new LicenseValidator(this.configuration, this.deviceIdResolver);
+    this.client = new LicenseClient(this.configuration, this.deviceIdResolver, this.validator);
+  }
+  async generateDeviceToken() {
+    const token = {
+      id: await this.deviceIdResolver.resolveDeviceId(),
+      name: await this.deviceIdResolver.resolveDeviceName(),
+      productId: this.configuration.productId,
+      format: "JWT"
+    };
+    const json = JSON.stringify(token);
+    return Buffer.from(Buffer.from(json).toString("base64"));
+  }
+  async readRawLicense(license) {
+    return await this.client.validateRawLicense(license);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationMethod,
+  DefaultDeviceIdResolver,
+  ErrorType,
+  FileLicenseStore,
+  InMemoryLicenseStore,
+  LicenseClient,
+  LicenseValidator,
+  MoonbaseError,
+  MoonbaseLicensing
+});

package/dist/index.d.cts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+
+interface IDeviceIdResolver {
+    resolveDeviceName(): Promise<string>;
+    resolveDeviceId(): Promise<string>;
+}
+declare class DefaultDeviceIdResolver implements IDeviceIdResolver {
+    resolveDeviceName(): Promise<string>;
+    resolveDeviceId(): Promise<string>;
+}
+
+declare const activationRequestResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    request: z.ZodString;
+    browser: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    request: string;
+    browser: string;
+}, {
+    id: string;
+    request: string;
+    browser: string;
+}>;
+declare const productSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    currentReleaseVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    currentReleaseVersion?: string | null | undefined;
+}, {
+    id: string;
+    name: string;
+    currentReleaseVersion?: string | null | undefined;
+}>;
+declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    email: string;
+}, {
+    id: string;
+    name: string;
+    email: string;
+}>;
+declare const licenseSchema: z.ZodObject<{
+    id: z.ZodString;
+    trial: z.ZodBoolean;
+    activationMethod: z.ZodNativeEnum<typeof ActivationMethod>;
+    product: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        currentReleaseVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    }, {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    }>;
+    issuedAt: z.ZodDate;
+    issuedTo: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        email: string;
+    }, {
+        id: string;
+        name: string;
+        email: string;
+    }>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    validatedAt: z.ZodDate;
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    trial: boolean;
+    activationMethod: ActivationMethod;
+    product: {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    };
+    issuedAt: Date;
+    issuedTo: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    validatedAt: Date;
+    token: string;
+    expiresAt?: Date | null | undefined;
+}, {
+    id: string;
+    trial: boolean;
+    activationMethod: ActivationMethod;
+    product: {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    };
+    issuedAt: Date;
+    issuedTo: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    validatedAt: Date;
+    token: string;
+    expiresAt?: Date | null | undefined;
+}>;
+
+declare enum ActivationMethod {
+    Online = "Online",
+    Offline = "Offline"
+}
+type License = z.infer<typeof licenseSchema>;
+type Product = z.infer<typeof productSchema>;
+type User = z.infer<typeof userSchema>;
+interface DeviceToken {
+    id: string;
+    name: string;
+    productId: string;
+    format: 'JWT';
+}
+type ActivationRequestResponse = z.infer<typeof activationRequestResponseSchema>;
+
+interface ILicenseClient {
+    /**
+     * Create a new request to have this product activated, which
+     * means the user will be able to open a browser to respond
+     * to the activation request.
+     * This can be used as an alternative way to authenticate
+     * license fulfillment without having to take in user credentials
+     * in the app. After requesting activation, open a browser with
+     * the returned browser URL, and start polling {@link getRequestedActivation}
+     * for a completed request with license.
+     *
+     * @returns Details about the requested activation with url to open in the browser
+     */
+    requestActivation(): Promise<ActivationRequestResponse>;
+    /**
+     * Takes in a activation request created through {@link requestActivation}
+     * and checks if the request has been fulfilled yet.
+     * The returned license will be either a trial or a full license
+     * depending on what the user chooses in the browser session.
+     *
+     * @param request The activation request to poll
+     * @returns A license if the request has been fulfilled, else null
+     */
+    getRequestedActivation(request: ActivationRequestResponse): Promise<License | null>;
+    /**
+     * Checks if the given license is still valid, not revoked
+     * and returns an updated license if still active.
+     * This method is a good way to ensure the user still has
+     * rights to use the product, and should be called regularly
+     * unless activated offline.
+     *
+     * @param license The license to validate
+     * @returns An updated license
+     */
+    validateLicense(license: License): Promise<License>;
+    /**
+     * Contrary to {@linkvalidateLicense }, this method takes
+     * in raw bytes of the license, which can be useful if you're
+     * reading the license from a file for offline activations.
+     *
+     * @param license The license to validate
+     * @returns An updated license
+     */
+    validateRawLicense(rawLicense: Buffer): Promise<License>;
+    /**
+     * Given a license, this method will try to revoke the license activation,
+     * freeing up a seat for other devices to activate the license.
+     * This will not work for offline-activated devices.
+     * @param license The license to revoke
+     */
+    revokeLicense(license: License): Promise<void>;
+}
+declare class LicenseClient implements ILicenseClient {
+    private readonly configuration;
+    private readonly deviceIdResolver;
+    private readonly licenseValidator;
+    constructor(configuration: MoonbaseConfiguration, deviceIdResolver: IDeviceIdResolver, licenseValidator: ILicenseValidator);
+    requestActivation(): Promise<ActivationRequestResponse>;
+    getRequestedActivation(request: ActivationRequestResponse): Promise<License | null>;
+    validateLicense(license: License): Promise<License>;
+    validateRawLicense(rawLicense: Buffer): Promise<License>;
+    revokeLicense(license: License): Promise<void>;
+    private handleLicenseResponse;
+}
+
+interface ILicenseStore {
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+}
+declare class InMemoryLicenseStore implements ILicenseStore {
+    private license?;
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+}
+declare class FileLicenseStore implements ILicenseStore {
+    private readonly options?;
+    constructor(options?: {
+        dir?: string | undefined;
+        licenseFileName?: string | undefined;
+    } | undefined);
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+    private get path();
+}
+
+interface ILicenseValidator {
+    validateLicense(token: string): Promise<License>;
+}
+declare class LicenseValidator implements ILicenseValidator {
+    private readonly configuration;
+    private readonly deviceIdResolver;
+    constructor(configuration: MoonbaseConfiguration, deviceIdResolver: IDeviceIdResolver);
+    validateLicense(token: string): Promise<License>;
+    private parseLicenseToken;
+}
+
+declare enum ErrorType {
+    None = "None",
+    ApiError = "ApiError",
+    NoEligibleLicense = "NoEligibleLicense",
+    LicenseInvalid = "LicenseInvalid",
+    LicenseRevoked = "LicenseRevoked",
+    LicenseActivationRevoked = "LicenseActivationRevoked",
+    LicenseExpired = "LicenseExpired"
+}
+declare class MoonbaseError extends Error {
+    readonly title: string;
+    readonly detail: string | undefined;
+    readonly type?: ErrorType | undefined;
+    readonly inner?: Error | undefined;
+    constructor(title: string, detail: string | undefined, type?: ErrorType | undefined, inner?: Error | undefined);
+}
+
+interface MoonbaseConfiguration {
+    endpoint: string;
+    publicKey: string;
+    productId: string;
+    accountId?: string;
+    licenseStore?: ILicenseStore;
+    deivceIdResolver?: IDeviceIdResolver;
+}
+declare class MoonbaseLicensing {
+    private readonly configuration;
+    readonly store: ILicenseStore;
+    readonly deviceIdResolver: IDeviceIdResolver;
+    readonly client: ILicenseClient;
+    readonly validator: ILicenseValidator;
+    constructor(configuration: MoonbaseConfiguration);
+    generateDeviceToken(): Promise<Buffer>;
+    readRawLicense(license: Buffer): Promise<License>;
+}
+
+export { ActivationMethod, type ActivationRequestResponse, DefaultDeviceIdResolver, type DeviceToken, ErrorType, FileLicenseStore, type IDeviceIdResolver, type ILicenseClient, type ILicenseStore, type ILicenseValidator, InMemoryLicenseStore, type License, LicenseClient, LicenseValidator, type MoonbaseConfiguration, MoonbaseError, MoonbaseLicensing, type Product, type User };

package/dist/index.d.ts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+
+interface IDeviceIdResolver {
+    resolveDeviceName(): Promise<string>;
+    resolveDeviceId(): Promise<string>;
+}
+declare class DefaultDeviceIdResolver implements IDeviceIdResolver {
+    resolveDeviceName(): Promise<string>;
+    resolveDeviceId(): Promise<string>;
+}
+
+declare const activationRequestResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    request: z.ZodString;
+    browser: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    request: string;
+    browser: string;
+}, {
+    id: string;
+    request: string;
+    browser: string;
+}>;
+declare const productSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    currentReleaseVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    currentReleaseVersion?: string | null | undefined;
+}, {
+    id: string;
+    name: string;
+    currentReleaseVersion?: string | null | undefined;
+}>;
+declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    email: string;
+}, {
+    id: string;
+    name: string;
+    email: string;
+}>;
+declare const licenseSchema: z.ZodObject<{
+    id: z.ZodString;
+    trial: z.ZodBoolean;
+    activationMethod: z.ZodNativeEnum<typeof ActivationMethod>;
+    product: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        currentReleaseVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    }, {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    }>;
+    issuedAt: z.ZodDate;
+    issuedTo: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        email: string;
+    }, {
+        id: string;
+        name: string;
+        email: string;
+    }>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    validatedAt: z.ZodDate;
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    trial: boolean;
+    activationMethod: ActivationMethod;
+    product: {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    };
+    issuedAt: Date;
+    issuedTo: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    validatedAt: Date;
+    token: string;
+    expiresAt?: Date | null | undefined;
+}, {
+    id: string;
+    trial: boolean;
+    activationMethod: ActivationMethod;
+    product: {
+        id: string;
+        name: string;
+        currentReleaseVersion?: string | null | undefined;
+    };
+    issuedAt: Date;
+    issuedTo: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    validatedAt: Date;
+    token: string;
+    expiresAt?: Date | null | undefined;
+}>;
+
+declare enum ActivationMethod {
+    Online = "Online",
+    Offline = "Offline"
+}
+type License = z.infer<typeof licenseSchema>;
+type Product = z.infer<typeof productSchema>;
+type User = z.infer<typeof userSchema>;
+interface DeviceToken {
+    id: string;
+    name: string;
+    productId: string;
+    format: 'JWT';
+}
+type ActivationRequestResponse = z.infer<typeof activationRequestResponseSchema>;
+
+interface ILicenseClient {
+    /**
+     * Create a new request to have this product activated, which
+     * means the user will be able to open a browser to respond
+     * to the activation request.
+     * This can be used as an alternative way to authenticate
+     * license fulfillment without having to take in user credentials
+     * in the app. After requesting activation, open a browser with
+     * the returned browser URL, and start polling {@link getRequestedActivation}
+     * for a completed request with license.
+     *
+     * @returns Details about the requested activation with url to open in the browser
+     */
+    requestActivation(): Promise<ActivationRequestResponse>;
+    /**
+     * Takes in a activation request created through {@link requestActivation}
+     * and checks if the request has been fulfilled yet.
+     * The returned license will be either a trial or a full license
+     * depending on what the user chooses in the browser session.
+     *
+     * @param request The activation request to poll
+     * @returns A license if the request has been fulfilled, else null
+     */
+    getRequestedActivation(request: ActivationRequestResponse): Promise<License | null>;
+    /**
+     * Checks if the given license is still valid, not revoked
+     * and returns an updated license if still active.
+     * This method is a good way to ensure the user still has
+     * rights to use the product, and should be called regularly
+     * unless activated offline.
+     *
+     * @param license The license to validate
+     * @returns An updated license
+     */
+    validateLicense(license: License): Promise<License>;
+    /**
+     * Contrary to {@linkvalidateLicense }, this method takes
+     * in raw bytes of the license, which can be useful if you're
+     * reading the license from a file for offline activations.
+     *
+     * @param license The license to validate
+     * @returns An updated license
+     */
+    validateRawLicense(rawLicense: Buffer): Promise<License>;
+    /**
+     * Given a license, this method will try to revoke the license activation,
+     * freeing up a seat for other devices to activate the license.
+     * This will not work for offline-activated devices.
+     * @param license The license to revoke
+     */
+    revokeLicense(license: License): Promise<void>;
+}
+declare class LicenseClient implements ILicenseClient {
+    private readonly configuration;
+    private readonly deviceIdResolver;
+    private readonly licenseValidator;
+    constructor(configuration: MoonbaseConfiguration, deviceIdResolver: IDeviceIdResolver, licenseValidator: ILicenseValidator);
+    requestActivation(): Promise<ActivationRequestResponse>;
+    getRequestedActivation(request: ActivationRequestResponse): Promise<License | null>;
+    validateLicense(license: License): Promise<License>;
+    validateRawLicense(rawLicense: Buffer): Promise<License>;
+    revokeLicense(license: License): Promise<void>;
+    private handleLicenseResponse;
+}
+
+interface ILicenseStore {
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+}
+declare class InMemoryLicenseStore implements ILicenseStore {
+    private license?;
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+}
+declare class FileLicenseStore implements ILicenseStore {
+    private readonly options?;
+    constructor(options?: {
+        dir?: string | undefined;
+        licenseFileName?: string | undefined;
+    } | undefined);
+    loadLocalLicense(): Promise<License | null>;
+    storeLocalLicense(license: License): Promise<void>;
+    deleteLocalLicense(): Promise<void>;
+    private get path();
+}
+
+interface ILicenseValidator {
+    validateLicense(token: string): Promise<License>;
+}
+declare class LicenseValidator implements ILicenseValidator {
+    private readonly configuration;
+    private readonly deviceIdResolver;
+    constructor(configuration: MoonbaseConfiguration, deviceIdResolver: IDeviceIdResolver);
+    validateLicense(token: string): Promise<License>;
+    private parseLicenseToken;
+}
+
+declare enum ErrorType {
+    None = "None",
+    ApiError = "ApiError",
+    NoEligibleLicense = "NoEligibleLicense",
+    LicenseInvalid = "LicenseInvalid",
+    LicenseRevoked = "LicenseRevoked",
+    LicenseActivationRevoked = "LicenseActivationRevoked",
+    LicenseExpired = "LicenseExpired"
+}
+declare class MoonbaseError extends Error {
+    readonly title: string;
+    readonly detail: string | undefined;
+    readonly type?: ErrorType | undefined;
+    readonly inner?: Error | undefined;
+    constructor(title: string, detail: string | undefined, type?: ErrorType | undefined, inner?: Error | undefined);
+}
+
+interface MoonbaseConfiguration {
+    endpoint: string;
+    publicKey: string;
+    productId: string;
+    accountId?: string;
+    licenseStore?: ILicenseStore;
+    deivceIdResolver?: IDeviceIdResolver;
+}
+declare class MoonbaseLicensing {
+    private readonly configuration;
+    readonly store: ILicenseStore;
+    readonly deviceIdResolver: IDeviceIdResolver;
+    readonly client: ILicenseClient;
+    readonly validator: ILicenseValidator;
+    constructor(configuration: MoonbaseConfiguration);
+    generateDeviceToken(): Promise<Buffer>;
+    readRawLicense(license: Buffer): Promise<License>;
+}
+
+export { ActivationMethod, type ActivationRequestResponse, DefaultDeviceIdResolver, type DeviceToken, ErrorType, FileLicenseStore, type IDeviceIdResolver, type ILicenseClient, type ILicenseStore, type ILicenseValidator, InMemoryLicenseStore, type License, LicenseClient, LicenseValidator, type MoonbaseConfiguration, MoonbaseError, MoonbaseLicensing, type Product, type User };

package/dist/index.js

@@ -0,0 +1,379 @@
+// src/client.ts
+import fetch from "cross-fetch";
+
+// src/types.ts
+var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
+  ActivationMethod2["Online"] = "Online";
+  ActivationMethod2["Offline"] = "Offline";
+  return ActivationMethod2;
+})(ActivationMethod || {});
+
+// src/schemas.ts
+import { z } from "zod";
+var activationRequestResponseSchema = z.object({
+  id: z.string(),
+  request: z.string(),
+  browser: z.string()
+});
+var productSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  currentReleaseVersion: z.string().nullish()
+});
+var userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string()
+});
+var licenseSchema = z.object({
+  id: z.string(),
+  trial: z.boolean(),
+  activationMethod: z.nativeEnum(ActivationMethod),
+  product: productSchema,
+  issuedAt: z.coerce.date(),
+  issuedTo: userSchema,
+  expiresAt: z.coerce.date().nullish(),
+  validatedAt: z.coerce.date(),
+  token: z.string()
+});
+
+// src/client.ts
+var defaultFetchOptions = {
+  method: "GET",
+  mode: "cors",
+  headers: {
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+    "x-mb-client": `moonbase.js`
+  }
+};
+var LicenseClient = class {
+  constructor(configuration, deviceIdResolver, licenseValidator) {
+    this.configuration = configuration;
+    this.deviceIdResolver = deviceIdResolver;
+    this.licenseValidator = licenseValidator;
+  }
+  async requestActivation() {
+    const content = {
+      deviceName: await this.deviceIdResolver.resolveDeviceName(),
+      deviceSignature: await this.deviceIdResolver.resolveDeviceId()
+    };
+    const response = await fetch(this.configuration.endpoint + `/api/client/activations/${this.configuration.productId}/request?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      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 */);
+    }
+    try {
+      return activationRequestResponseSchema.parse(await response.json());
+    } catch (err) {
+      const error = err;
+      throw new MoonbaseError(
+        "Could not request activation",
+        error.message,
+        "ApiError" /* ApiError */,
+        error
+      );
+    }
+  }
+  async getRequestedActivation(request) {
+    const response = await fetch(request.request, defaultFetchOptions);
+    if (response.status === 204 || response.status === 404)
+      return null;
+    return await this.handleLicenseResponse(response);
+  }
+  async validateLicense(license) {
+    const response = await fetch(this.configuration.endpoint + `/api/client/licenses/${this.configuration.productId}/validate?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      headers: {
+        ...defaultFetchOptions.headers,
+        "Content-Type": "text/plain"
+      },
+      body: license.token
+    });
+    return await this.handleLicenseResponse(response);
+  }
+  async validateRawLicense(rawLicense) {
+    const license = await this.licenseValidator.validateLicense(rawLicense.toString("utf8"));
+    if (license.activationMethod === "Offline" /* Offline */)
+      return license;
+    return await this.validateLicense(license);
+  }
+  async revokeLicense(license) {
+    const response = await fetch(this.configuration.endpoint + `/api/client/licenses/${this.configuration.productId}/revoke?format=JWT`, {
+      ...defaultFetchOptions,
+      method: "POST",
+      headers: {
+        ...defaultFetchOptions.headers,
+        "Content-Type": "text/plain"
+      },
+      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 */);
+    }
+  }
+  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 */);
+    }
+    return await this.licenseValidator.validateLicense(await response.text());
+  }
+};
+
+// src/deviceIdResolver.ts
+import si from "systeminformation";
+import os from "os";
+import cp from "child_process";
+import { createHash } from "crypto";
+var DefaultDeviceIdResolver = class {
+  async resolveDeviceName() {
+    switch (process.platform) {
+      case "darwin":
+        try {
+          return cp.execSync("scutil --get ComputerName").toString().trim();
+        } catch (e) {
+          return os.hostname();
+        }
+      case "win32":
+        return process.env.COMPUTERNAME || os.hostname();
+      case "linux":
+        const prettyname = cp.execSync("hostnamectl --pretty").toString().trim();
+        return prettyname || os.hostname();
+      default:
+        return os.hostname();
+    }
+  }
+  async resolveDeviceId() {
+    const [cpu, hw] = await Promise.all([si.cpu(), si.system()]);
+    const parts = [
+      os.hostname(),
+      hw.manufacturer,
+      hw.model,
+      hw.serial,
+      hw.uuid,
+      hw.sku,
+      cpu.manufacturer,
+      cpu.brand,
+      cpu.vendor,
+      cpu.family,
+      cpu.model
+    ];
+    const hash = createHash("sha256").update(parts.join("")).digest();
+    return hash.toString("base64").replaceAll("=", "");
+  }
+};
+
+// src/store.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import path from "path";
+
+// 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";
+  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;
+  }
+};
+
+// src/store.ts
+var InMemoryLicenseStore = class {
+  async loadLocalLicense() {
+    var _a;
+    return (_a = this.license) != null ? _a : null;
+  }
+  async storeLocalLicense(license) {
+    this.license = license;
+  }
+  async deleteLocalLicense() {
+    this.license = void 0;
+  }
+};
+var FileLicenseStore = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async loadLocalLicense() {
+    if (!fsSync.existsSync(this.path))
+      return null;
+    try {
+      const file = await fs.readFile(this.path, { encoding: "utf-8" });
+      const license = licenseSchema.parse(JSON.parse(file));
+      return license;
+    } catch (err) {
+      throw new MoonbaseError("File error", "Could not load local license", "LicenseInvalid" /* LicenseInvalid */, err);
+    }
+  }
+  async storeLocalLicense(license) {
+    await fs.writeFile(this.path, JSON.stringify(license), { encoding: "utf-8" });
+  }
+  async deleteLocalLicense() {
+    if (!fsSync.existsSync(this.path))
+      return;
+    await fs.rm(this.path);
+  }
+  get path() {
+    var _a, _b, _c, _d;
+    return path.resolve((_b = (_a = this.options) == null ? void 0 : _a.dir) != null ? _b : path.resolve(), (_d = (_c = this.options) == null ? void 0 : _c.licenseFileName) != null ? _d : "license.mb");
+  }
+};
+
+// src/validator.ts
+import { z as z2 } from "zod";
+import jwt from "jsonwebtoken";
+var licenseClaimsSchema = z2.object({
+  ["l:id" /* LicenseId */]: z2.string(),
+  ["trial" /* Trial */]: z2.string().or(z2.boolean()).transform((v) => v === true || v === "true").pipe(z2.boolean()),
+  ["method" /* ActivationMethod */]: z2.nativeEnum(ActivationMethod),
+  ["sig" /* ComputerSignature */]: z2.string(),
+  ["iat" /* IssuedAt */]: z2.number().transform((v) => new Date(v * 1e3)).pipe(z2.date()),
+  ["exp" /* ExpiresAt */]: z2.number().nullish().transform((v) => v ? new Date(v * 1e3) : void 0).pipe(z2.date().nullish()),
+  ["validated" /* ValidatedAt */]: z2.number().transform((v) => new Date(v * 1e3)).pipe(z2.date()),
+  ["p:id" /* ProductId */]: z2.string(),
+  ["p:name" /* ProductName */]: z2.string(),
+  ["p:rel" /* ProductReleaseVersion */]: z2.string().nullish(),
+  ["u:id" /* UserId */]: z2.string(),
+  ["u:name" /* UserName */]: z2.string(),
+  ["u:email" /* UserEmail */]: z2.string()
+});
+var LicenseValidator = class {
+  constructor(configuration, deviceIdResolver) {
+    this.configuration = configuration;
+    this.deviceIdResolver = deviceIdResolver;
+  }
+  async validateLicense(token) {
+    const [license, claims] = await this.parseLicenseToken(token);
+    if (license.expiresAt && license.expiresAt < /* @__PURE__ */ new Date()) {
+      throw new MoonbaseError(
+        "License expired",
+        "This license has expired",
+        "LicenseExpired" /* LicenseExpired */
+      );
+    }
+    const expectedSignature = await this.deviceIdResolver.resolveDeviceId();
+    if (expectedSignature !== claims["sig" /* ComputerSignature */]) {
+      throw new MoonbaseError(
+        "License invalide",
+        "This license is not for this device",
+        "LicenseExpired" /* LicenseExpired */
+      );
+    }
+    return license;
+  }
+  parseLicenseToken(token) {
+    return new Promise((resolve, reject) => {
+      jwt.verify(token, this.configuration.publicKey, {
+        ignoreExpiration: true,
+        issuer: this.configuration.accountId,
+        audience: this.configuration.productId
+      }, (err, decoded) => {
+        var _a;
+        if (err) {
+          reject(new MoonbaseError(
+            "Could not validate license",
+            err.message,
+            "LicenseInvalid" /* LicenseInvalid */,
+            err
+          ));
+          return;
+        }
+        if (typeof decoded === "string") {
+          reject(new MoonbaseError(
+            "Could not validate license",
+            "The given license token could not be parsed",
+            "LicenseInvalid" /* LicenseInvalid */
+          ));
+          return;
+        }
+        try {
+          const claims = licenseClaimsSchema.parse(decoded);
+          resolve([{
+            id: claims["l:id" /* LicenseId */],
+            trial: claims["trial" /* Trial */],
+            activationMethod: claims["method" /* ActivationMethod */],
+            product: {
+              id: claims["p:id" /* ProductId */],
+              name: claims["p:name" /* ProductName */],
+              currentReleaseVersion: (_a = claims["p:rel" /* ProductReleaseVersion */]) != null ? _a : void 0
+            },
+            issuedTo: {
+              id: claims["u:id" /* UserId */],
+              name: claims["u:name" /* UserName */],
+              email: claims["u:email" /* UserEmail */]
+            },
+            expiresAt: claims["exp" /* ExpiresAt */] || void 0,
+            issuedAt: claims["iat" /* IssuedAt */],
+            validatedAt: claims["validated" /* ValidatedAt */],
+            token
+          }, claims]);
+        } catch (err2) {
+          const error = err2;
+          reject(new MoonbaseError(
+            "Could not validate license",
+            error.message,
+            "LicenseInvalid" /* LicenseInvalid */,
+            error
+          ));
+        }
+      });
+    });
+  }
+};
+
+// src/index.ts
+var MoonbaseLicensing = class {
+  constructor(configuration) {
+    var _a, _b;
+    this.configuration = {
+      ...configuration,
+      endpoint: configuration.endpoint.replace(/\/$/, "")
+    };
+    this.store = (_a = configuration.licenseStore) != null ? _a : new InMemoryLicenseStore();
+    this.deviceIdResolver = (_b = configuration.deivceIdResolver) != null ? _b : new DefaultDeviceIdResolver();
+    this.validator = new LicenseValidator(this.configuration, this.deviceIdResolver);
+    this.client = new LicenseClient(this.configuration, this.deviceIdResolver, this.validator);
+  }
+  async generateDeviceToken() {
+    const token = {
+      id: await this.deviceIdResolver.resolveDeviceId(),
+      name: await this.deviceIdResolver.resolveDeviceName(),
+      productId: this.configuration.productId,
+      format: "JWT"
+    };
+    const json = JSON.stringify(token);
+    return Buffer.from(Buffer.from(json).toString("base64"));
+  }
+  async readRawLicense(license) {
+    return await this.client.validateRawLicense(license);
+  }
+};
+export {
+  ActivationMethod,
+  DefaultDeviceIdResolver,
+  ErrorType,
+  FileLicenseStore,
+  InMemoryLicenseStore,
+  LicenseClient,
+  LicenseValidator,
+  MoonbaseError,
+  MoonbaseLicensing
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@moonbase.sh/licensing",
+  "type": "module",
+  "version": "0.3.37",
+  "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",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "dependencies": {
+    "cross-fetch": "^3.1.5",
+    "jsonwebtoken": "^9.0.2",
+    "systeminformation": "^5.25.11",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/node": "^18.19.50",
+    "rimraf": "^5.0.10",
+    "tsup": "^7.1.0",
+    "typescript": "~5.1.6",
+    "vitest": "^2.1.4"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "version": "npm version",
+    "test": "vitest"
+  }
+}