@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/lib/adam-6000-profiles.js

@@ -0,0 +1,173 @@
+"use strict";
+
+const MODULE_NAME_ADDRESS = 40211;
+
+const PROFILES = {
+    "6015": { model: "ADAM-6015", diCount: 0, doCount: 0, aiCount: 7, aoCount: 0 },
+    "6017": { model: "ADAM-6017", diCount: 0, doCount: 2, aiCount: 8, aoCount: 0 },
+    "6018": { model: "ADAM-6018", diCount: 0, doCount: 8, aiCount: 8, aoCount: 0 },
+    "6018+": { model: "ADAM-6018+", diCount: 0, doCount: 0, aiCount: 8, aoCount: 0 },
+    "6022": { model: "ADAM-6022", diCount: 2, doCount: 2, aiCount: 6, aoCount: 2 },
+    "6024": { model: "ADAM-6024", diCount: 2, doCount: 2, aiCount: 6, aoCount: 2 },
+    "6050": { model: "ADAM-6050", diCount: 12, doCount: 6, aiCount: 0, aoCount: 0 },
+    "6051": { model: "ADAM-6051", diCount: 12, doCount: 2, aiCount: 0, aoCount: 0 },
+    "6052": { model: "ADAM-6052", diCount: 8, doCount: 8, aiCount: 0, aoCount: 0 },
+    "6060": { model: "ADAM-6060", diCount: 6, doCount: 6, aiCount: 0, aoCount: 0 },
+    "6066": { model: "ADAM-6066", diCount: 6, doCount: 6, aiCount: 0, aoCount: 0 }
+};
+
+function cloneProfile(profile) {
+    return Object.assign({}, profile || {});
+}
+
+function normalizeModel(value) {
+    const text = String(value || "").toUpperCase();
+    const match = text.match(/60\d{2}\+?/);
+    return match ? match[0] : "";
+}
+
+function profileForModel(value) {
+    const key = normalizeModel(value);
+    if (key && PROFILES[key]) return cloneProfile(PROFILES[key]);
+    return null;
+}
+
+function decodeModuleWords(words) {
+    const values = Array.isArray(words) ? words : [];
+    const candidates = [];
+
+    values.forEach(function (word) {
+        const n = Number(word);
+        if (!Number.isFinite(n)) return;
+        candidates.push(String(n));
+        candidates.push(n.toString(16).padStart(4, "0"));
+
+        const hi = (n >> 8) & 0xff;
+        const lo = n & 0xff;
+        if (hi >= 32 && hi <= 126 && lo >= 32 && lo <= 126) {
+            candidates.push(String.fromCharCode(hi) + String.fromCharCode(lo));
+        }
+    });
+
+    if (values.length >= 2) {
+        candidates.push(values.map(function (word) {
+            return Number(word).toString(16).padStart(4, "0");
+        }).join(""));
+        candidates.push(values.map(function (word) {
+            const n = Number(word) || 0;
+            return String.fromCharCode((n >> 8) & 0xff) + String.fromCharCode(n & 0xff);
+        }).join(""));
+    }
+
+    for (let i = 0; i < candidates.length; i += 1) {
+        const model = normalizeModel(candidates[i]);
+        if (model) return model;
+    }
+
+    return "";
+}
+
+async function readModuleProfile(client, resolveAddress) {
+    const start = resolveAddress(MODULE_NAME_ADDRESS, "holding");
+    const response = await client.readHoldingRegisters(start, 2);
+    const words = response && Array.isArray(response.data) ? response.data : [];
+    const modelCode = decodeModuleWords(words);
+    const profile = profileForModel(modelCode);
+
+    if (!profile) {
+        return {
+            model: modelCode ? "ADAM-" + modelCode : "",
+            modelCode: modelCode,
+            rawModuleWords: words,
+            detectedBy: "module_register"
+        };
+    }
+
+    profile.modelCode = modelCode;
+    profile.rawModuleWords = words;
+    profile.detectedBy = "module_register";
+    return profile;
+}
+
+async function canReadCoils(client, start, count) {
+    if (count <= 0) return false;
+    try {
+        await client.readCoils(start, count);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+async function canReadHolding(client, start, count) {
+    if (count <= 0) return false;
+    try {
+        await client.readHoldingRegisters(start, count);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+async function probeProfile(client, resolveAddress) {
+    const profile = {
+        model: "ADAM-6000",
+        modelCode: "",
+        diCount: 0,
+        doCount: 0,
+        aiCount: 0,
+        aoCount: 0,
+        detectedBy: "probe"
+    };
+    const candidates = [
+        { key: "diCount", area: "coil", start: 1, counts: [14, 12, 8, 6, 2] },
+        { key: "doCount", area: "coil", start: 17, counts: [8, 6, 2] },
+        { key: "aiCount", area: "holding", start: 40001, counts: [8, 7, 6] },
+        { key: "aoCount", area: "holding", start: 40011, counts: [2] }
+    ];
+
+    for (let i = 0; i < candidates.length; i += 1) {
+        const candidate = candidates[i];
+        const start = resolveAddress(candidate.start, candidate.area);
+        for (let j = 0; j < candidate.counts.length; j += 1) {
+            const count = candidate.counts[j];
+            const ok = candidate.area === "coil"
+                ? await canReadCoils(client, start, count)
+                : await canReadHolding(client, start, count);
+            if (ok) {
+                profile[candidate.key] = count;
+                break;
+            }
+        }
+    }
+
+    return profile;
+}
+
+async function detectAdamProfile(client, resolveAddress, configuredModel) {
+    const configured = profileForModel(configuredModel);
+    if (configured) {
+        configured.detectedBy = "configured";
+        configured.modelCode = normalizeModel(configuredModel);
+        return configured;
+    }
+
+    try {
+        const detected = await readModuleProfile(client, resolveAddress);
+        if (detected && (detected.diCount || detected.doCount || detected.aiCount || detected.aoCount)) {
+            return detected;
+        }
+    } catch (e) {
+        // Some modules do not expose 40211 consistently; probing is the fallback.
+    }
+
+    return probeProfile(client, resolveAddress);
+}
+
+module.exports = {
+    MODULE_NAME_ADDRESS,
+    PROFILES,
+    detectAdamProfile,
+    profileForModel,
+    normalizeModel
+};

package/lib/licensing/constants.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const LICENSE_STATES = Object.freeze({
+    UNKNOWN: "UNKNOWN",
+    NOT_ACTIVATED: "NOT_ACTIVATED",
+    ACTIVATING: "ACTIVATING",
+    ACTIVE: "ACTIVE",
+    OFFLINE: "OFFLINE",
+    GRACE_PERIOD: "GRACE_PERIOD",
+    PENDING_APPROVAL: "PENDING_APPROVAL",
+    DEVICE_LIMIT_REACHED: "DEVICE_LIMIT_REACHED",
+    EXPIRED: "EXPIRED",
+    REVOKED: "REVOKED",
+    SUSPENDED: "SUSPENDED",
+    DEVICE_BLOCKED: "DEVICE_BLOCKED",
+    DEVICE_REJECTED: "DEVICE_REJECTED",
+    DEVICE_DEACTIVATED: "DEVICE_DEACTIVATED",
+    DEVICE_REMOVED: "DEVICE_REMOVED",
+    PACKAGE_TAMPERED: "PACKAGE_TAMPERED",
+    INVALID_TOKEN: "INVALID_TOKEN",
+    INVALID_DEVICE: "INVALID_DEVICE",
+    PRODUCT_NOT_LICENSED: "PRODUCT_NOT_LICENSED",
+    VERSION_NOT_LICENSED: "VERSION_NOT_LICENSED",
+    SERVER_ERROR: "SERVER_ERROR"
+});
+
+const LICENSE_TYPES = Object.freeze({
+    SUBSCRIPTION: "SUBSCRIPTION",
+    PERMANENT: "PERMANENT"
+});
+
+const LICENSED_STATES = Object.freeze([
+    LICENSE_STATES.ACTIVE,
+    LICENSE_STATES.OFFLINE,
+    LICENSE_STATES.GRACE_PERIOD
+]);
+
+const SERVER_STATE_MAP = Object.freeze({
+    LICENSE_REVOKED: LICENSE_STATES.REVOKED,
+    LICENSE_EXPIRED: LICENSE_STATES.EXPIRED,
+    LICENSE_SUSPENDED: LICENSE_STATES.SUSPENDED,
+    COMPANY_SUSPENDED: LICENSE_STATES.SUSPENDED,
+    DEVICE_BLOCKED: LICENSE_STATES.DEVICE_BLOCKED,
+    DEVICE_REJECTED: LICENSE_STATES.DEVICE_REJECTED,
+    DEVICE_DEACTIVATED: LICENSE_STATES.DEVICE_DEACTIVATED,
+    DEVICE_REMOVED: LICENSE_STATES.DEVICE_REMOVED,
+    PRODUCT_NOT_ALLOWED: LICENSE_STATES.PRODUCT_NOT_LICENSED,
+    VERSION_NOT_ALLOWED: LICENSE_STATES.VERSION_NOT_LICENSED,
+    DEVICE_APPROVAL_REQUIRED: LICENSE_STATES.PENDING_APPROVAL,
+    COMPANY_DEVICE_LIMIT_REACHED: LICENSE_STATES.DEVICE_LIMIT_REACHED
+});
+
+const STATUS_PRESENTATION = Object.freeze({
+    UNKNOWN: { fill: "grey", shape: "ring", text: "license checking" },
+    NOT_ACTIVATED: { fill: "grey", shape: "ring", text: "not licensed" },
+    ACTIVATING: { fill: "blue", shape: "ring", text: "activating license" },
+    ACTIVE: { fill: "green", shape: "dot", text: "licensed" },
+    OFFLINE: { fill: "yellow", shape: "ring", text: "licensed offline" },
+    GRACE_PERIOD: { fill: "yellow", shape: "dot", text: "license grace period" },
+    PENDING_APPROVAL: { fill: "yellow", shape: "ring", text: "license pending" },
+    DEVICE_LIMIT_REACHED: { fill: "red", shape: "ring", text: "device limit reached" },
+    EXPIRED: { fill: "red", shape: "ring", text: "license expired" },
+    REVOKED: { fill: "red", shape: "dot", text: "license revoked" },
+    SUSPENDED: { fill: "red", shape: "dot", text: "license suspended" },
+    DEVICE_BLOCKED: { fill: "red", shape: "dot", text: "device blocked" },
+    DEVICE_REJECTED: { fill: "red", shape: "dot", text: "device rejected" },
+    DEVICE_DEACTIVATED: { fill: "red", shape: "dot", text: "device deactivated" },
+    DEVICE_REMOVED: { fill: "grey", shape: "ring", text: "device removed; deploy to activate again" },
+    PACKAGE_TAMPERED: { fill: "red", shape: "dot", text: "package tampered" },
+    INVALID_TOKEN: { fill: "red", shape: "ring", text: "invalid license token" },
+    INVALID_DEVICE: { fill: "red", shape: "ring", text: "invalid license device" },
+    PRODUCT_NOT_LICENSED: { fill: "red", shape: "ring", text: "product not licensed" },
+    VERSION_NOT_LICENSED: { fill: "red", shape: "ring", text: "version not licensed" },
+    SERVER_ERROR: { fill: "red", shape: "ring", text: "license server error" }
+});
+
+const PRODUCT_CODE = "node-red-custome-solutions";
+const PRODUCT_NAME = "Atelierul de Tehnologii - NodeRed Custome Solutions";
+const DEFAULT_SERVER_URL = "https://license.atelieruldetehnologii.ro";
+const REQUEST_TIMEOUT_MS = 10000;
+// Administrative changes (approval, blocking and company/license suspension)
+// must not wait for the policy refresh interval, which is intentionally
+// configured in minutes. This lightweight status check is authoritative.
+const CONTROL_STATUS_INTERVAL_MS = 5 * 1000;
+// Wake frequently enough to honor refresh policies configured in minutes.
+// HTTP requests are still made only when refreshAfter/nextCheck is reached.
+const SCHEDULER_INTERVAL_MS = 30 * 1000;
+const RETRY_DELAYS_MS = Object.freeze([60 * 1000, 5 * 60 * 1000, 15 * 60 * 1000, 60 * 60 * 1000]);
+
+module.exports = {
+    DEFAULT_SERVER_URL,
+    CONTROL_STATUS_INTERVAL_MS,
+    LICENSED_STATES,
+    LICENSE_STATES,
+    LICENSE_TYPES,
+    PRODUCT_CODE,
+    PRODUCT_NAME,
+    REQUEST_TIMEOUT_MS,
+    RETRY_DELAYS_MS,
+    SCHEDULER_INTERVAL_MS,
+    SERVER_STATE_MAP,
+    STATUS_PRESENTATION
+};

package/lib/licensing/device-id.js

@@ -0,0 +1,251 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { ensurePrivateDirectory } = require("./storage");
+
+function readText(filePath) {
+    try { return fs.readFileSync(filePath, "utf8").replace(/\0/g, "").trim(); } catch (error) { return ""; }
+}
+
+const VIRTUAL_INTERFACE = /^(?:lo|docker|br-|veth|virbr|vmnet|vboxnet|tun|tap|wg|tailscale|zt|podman|cni)/i;
+const IDENTITY_CACHE_FILE = "device-identity.json";
+const DEFAULT_MAC_RETRY_DELAYS_MS = [250, 750, 1500];
+
+function normalizeMac(value) {
+    const normalized = String(value || "").trim().replace(/-/g, ":").toLowerCase();
+    if (!/^[0-9a-f]{2}(?::[0-9a-f]{2}){5}$/.test(normalized)) return null;
+    if (normalized === "00:00:00:00:00:00" || normalized === "ff:ff:ff:ff:ff:ff") return null;
+    return normalized;
+}
+
+function interfacePriority(name) {
+    if (/^(?:eth|en)/i.test(name)) return 0;
+    if (/^(?:wlan|wl|wifi)/i.test(name)) return 1;
+    return 2;
+}
+
+function macCandidates(networks) {
+    const candidates = [];
+    Object.entries(networks === undefined ? os.networkInterfaces() : networks).forEach(function ([name, addresses]) {
+        if (VIRTUAL_INTERFACE.test(name)) return;
+        (addresses || []).forEach(function (address) {
+            if (!address || address.internal) return;
+            const mac = normalizeMac(address.mac);
+            if (mac) candidates.push({ mac, name, priority: interfacePriority(name) });
+        });
+    });
+    return candidates;
+}
+
+function sysfsMacCandidates(sysfsRoot) {
+    const root = sysfsRoot === undefined ? "/sys/class/net" : sysfsRoot;
+    const candidates = [];
+    let names = [];
+    try { names = fs.readdirSync(root); } catch (error) { return candidates; }
+    names.forEach(function (name) {
+        if (VIRTUAL_INTERFACE.test(name)) return;
+        const mac = normalizeMac(readText(path.join(root, name, "address")));
+        if (mac) candidates.push({ mac, name, priority: interfacePriority(name) });
+    });
+    return candidates;
+}
+
+function physicalMacCandidates(networks, sysfsRoot) {
+    const unique = new Map();
+    macCandidates(networks).concat(sysfsMacCandidates(sysfsRoot)).forEach(function (candidate) {
+        const key = candidate.name + "\0" + candidate.mac;
+        if (!unique.has(key)) unique.set(key, candidate);
+    });
+    const candidates = Array.from(unique.values());
+    candidates.sort(function (left, right) {
+        return left.priority - right.priority || left.name.localeCompare(right.name) || left.mac.localeCompare(right.mac);
+    });
+    return candidates;
+}
+
+function detectPhysicalMac(networks, sysfsRoot) {
+    return physicalMacCandidates(networks, sysfsRoot)[0] || null;
+}
+
+function macDeviceId(mac) {
+    const normalized = normalizeMac(mac);
+    return normalized ? "ATELIER-MAC-" + normalized.replace(/:/g, "").toUpperCase() : null;
+}
+
+function readMacIdentity(networks, sysfsRoot) {
+    const override = normalizeMac(process.env.ATELIER_DEVICE_MAC);
+    if (override) return { mac: override, name: "environment" };
+    return detectPhysicalMac(networks, sysfsRoot);
+}
+
+function readVictronIdentity() {
+    const environmentId = String(process.env.VRM_PORTAL_ID || process.env.VICTRON_PORTAL_ID || "").trim();
+    if (environmentId) return { value: environmentId, source: "victron-environment" };
+    const directFiles = ["/data/conf/portal-id", "/data/conf/vrm-portal-id", "/data/conf/serial-number"];
+    for (const filePath of directFiles) {
+        const value = readText(filePath);
+        if (value) return { value, source: "victron:" + filePath };
+    }
+    const settingsXml = readText("/data/conf/settings.xml");
+    const match = settingsXml.match(/<(?:PortalId|UniqueIdentifier)>([^<]+)<\/(?:PortalId|UniqueIdentifier)>/i);
+    return match ? { value: match[1].trim(), source: "victron:/data/conf/settings.xml" } : null;
+}
+
+function stableDeviceId(value) {
+    return "ATELIER-" + crypto.createHash("sha256").update(String(value), "utf8").digest("hex").slice(0, 32).toUpperCase();
+}
+
+function localStableIdentities() {
+    const identities = [];
+    const victron = readVictronIdentity();
+    if (victron) identities.push({ deviceId: stableDeviceId(victron.value), source: victron.source });
+    ["/etc/machine-id", "/var/lib/dbus/machine-id", "/sys/class/dmi/id/product_uuid", "/proc/device-tree/serial-number"].forEach(function (source) {
+        const value = readText(source);
+        if (value) identities.push({ deviceId: stableDeviceId(value), source });
+    });
+    return identities;
+}
+
+function hostFingerprint() {
+    const identities = localStableIdentities();
+    return identities.length ? stableDeviceId(identities.map(function (identity) { return identity.deviceId; }).join("|")) : null;
+}
+
+function identityCachePath(userDir) {
+    return path.join(userDir, "atelier-license", IDENTITY_CACHE_FILE);
+}
+
+function readIdentityCache(userDir) {
+    try {
+        const cached = JSON.parse(fs.readFileSync(identityCachePath(userDir), "utf8"));
+        const mac = normalizeMac(cached && cached.mac);
+        if (!mac || cached.deviceId !== macDeviceId(mac)) return null;
+        const currentFingerprint = hostFingerprint();
+        if (cached.hostFingerprint && currentFingerprint && cached.hostFingerprint !== currentFingerprint) return null;
+        return { deviceId: cached.deviceId, mac, name: String(cached.interfaceName || "unknown") };
+    } catch (error) {
+        return null;
+    }
+}
+
+async function saveIdentityCache(userDir, candidate) {
+    const directory = path.join(userDir, "atelier-license");
+    await ensurePrivateDirectory(directory);
+    const target = identityCachePath(userDir);
+    const temporary = target + ".tmp-" + process.pid;
+    const body = JSON.stringify({
+        schemaVersion: 1,
+        deviceId: macDeviceId(candidate.mac),
+        mac: candidate.mac,
+        interfaceName: candidate.name,
+        hostFingerprint: hostFingerprint(),
+        savedAt: new Date().toISOString()
+    }, null, 2) + "\n";
+    await fs.promises.writeFile(temporary, body, { encoding: "utf8", mode: 0o600 });
+    try { await fs.promises.chmod(temporary, 0o600); } catch (error) { /* Windows/limited filesystems */ }
+    await fs.promises.rename(temporary, target);
+    try { await fs.promises.chmod(target, 0o600); } catch (error) { /* Windows/limited filesystems */ }
+}
+
+function wait(delayMs) {
+    return new Promise(function (resolve) { setTimeout(resolve, delayMs); });
+}
+
+function detectModel() {
+    return readText("/proc/device-tree/model") || readText("/sys/firmware/devicetree/base/model") || os.type() + " " + os.arch();
+}
+
+function detectVenusVersion() {
+    const version = readText("/opt/victronenergy/version") || readText("/etc/venus/version");
+    if (version) return version;
+    const osRelease = readText("/etc/os-release");
+    const match = osRelease.match(/^VERSION_ID=["']?([^"'\r\n]+)["']?/m);
+    return /venus/i.test(osRelease) && match ? match[1] : null;
+}
+
+function firstReadable(paths) {
+    for (const source of paths) {
+        const value = readText(source);
+        if (value && !/^unknown|not specified|none$/i.test(value)) return value;
+    }
+    return null;
+}
+
+function detectHardwareInfo() {
+    return {
+        hardwareSerial: firstReadable(["/proc/device-tree/serial-number", "/sys/firmware/devicetree/base/serial-number", "/sys/class/dmi/id/product_serial", "/data/conf/serial-number"]),
+        systemUuid: firstReadable(["/sys/class/dmi/id/product_uuid"]),
+        manufacturer: firstReadable(["/sys/class/dmi/id/sys_vendor", "/proc/device-tree/manufacturer", "/sys/firmware/devicetree/base/manufacturer"]),
+        osPlatform: os.platform(),
+        osRelease: os.release(),
+        cpuArch: os.arch()
+    };
+}
+
+function completeIdentity(identity, candidate, model, venusOsVersion) {
+    return Object.assign({}, identity, detectHardwareInfo(), {
+        deviceModel: model,
+        venusOsVersion,
+        macAddress: candidate && candidate.mac || null,
+        networkInterface: candidate && candidate.name || null,
+        identitySource: identity.source
+    });
+}
+
+async function getDeviceIdentity(userDir, options) {
+    const settings = options || {};
+    const preferredDeviceId = String(settings.preferredDeviceId || "").trim();
+    const model = detectModel();
+    const venusOsVersion = detectVenusVersion();
+    const override = normalizeMac(process.env.ATELIER_DEVICE_MAC);
+    if (override) return completeIdentity({ deviceId: macDeviceId(override), source: "mac:environment" }, { mac: override, name: "environment" }, model, venusOsVersion);
+
+    let candidates = physicalMacCandidates(settings.networks, settings.sysfsRoot);
+    const preferredMac = candidates.find(function (candidate) { return macDeviceId(candidate.mac) === preferredDeviceId; });
+    if (preferredMac) {
+        await saveIdentityCache(userDir, preferredMac);
+        return completeIdentity({ deviceId: preferredDeviceId, source: "mac:" + preferredMac.name }, preferredMac, model, venusOsVersion);
+    }
+
+    const stableIdentities = localStableIdentities();
+    const preferredStable = stableIdentities.find(function (identity) { return identity.deviceId === preferredDeviceId; });
+    if (preferredStable) return completeIdentity({ deviceId: preferredStable.deviceId, source: preferredStable.source }, candidates[0], model, venusOsVersion);
+
+    const cached = readIdentityCache(userDir);
+    if (cached) return completeIdentity({ deviceId: cached.deviceId, source: "cached-mac:" + cached.name }, { mac: cached.mac, name: cached.name }, model, venusOsVersion);
+
+    const retryDelays = Array.isArray(settings.macRetryDelaysMs) ? settings.macRetryDelaysMs : DEFAULT_MAC_RETRY_DELAYS_MS;
+    for (const delayMs of retryDelays) {
+        if (candidates.length) break;
+        if (delayMs > 0) await wait(delayMs);
+        candidates = physicalMacCandidates(settings.networks, settings.sysfsRoot);
+    }
+    if (candidates.length) {
+        await saveIdentityCache(userDir, candidates[0]);
+        return completeIdentity({ deviceId: macDeviceId(candidates[0].mac), source: "mac:" + candidates[0].name }, candidates[0], model, venusOsVersion);
+    }
+
+    if (stableIdentities.length) return completeIdentity({ deviceId: stableIdentities[0].deviceId, source: stableIdentities[0].source }, null, model, venusOsVersion);
+
+    const directory = path.join(userDir, "atelier-license");
+    const fallbackPath = path.join(directory, "device-id");
+    const existing = readText(fallbackPath);
+    if (existing) return completeIdentity({ deviceId: existing, source: "persistent-fallback" }, null, model, venusOsVersion);
+
+    await ensurePrivateDirectory(directory);
+    const generated = stableDeviceId(crypto.randomUUID());
+    await fs.promises.writeFile(fallbackPath, generated + "\n", { encoding: "utf8", mode: 0o600, flag: "wx" }).catch(async function (error) {
+        if (error.code !== "EEXIST") throw error;
+    });
+    try { await fs.promises.chmod(fallbackPath, 0o600); } catch (error) { /* Windows/limited filesystems */ }
+    return completeIdentity({ deviceId: readText(fallbackPath) || generated, source: "persistent-fallback" }, null, model, venusOsVersion);
+}
+
+async function getDeviceId(userDir) {
+    return (await getDeviceIdentity(userDir)).deviceId;
+}
+
+module.exports = { detectHardwareInfo, detectPhysicalMac, getDeviceId, getDeviceIdentity, macDeviceId, normalizeMac, physicalMacCandidates, readIdentityCache, stableDeviceId };

package/lib/licensing/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+
+class LicenseError extends Error {
+    constructor(code, message, details) {
+        super(message || code);
+        this.name = "LicenseError";
+        this.code = code;
+        this.details = details || null;
+    }
+}
+
+class LicenseNetworkError extends LicenseError {
+    constructor(message, cause) {
+        super("NETWORK_ERROR", message || "License server unavailable");
+        this.name = "LicenseNetworkError";
+        this.cause = cause;
+        this.isNetworkError = true;
+    }
+}
+
+module.exports = { LicenseError, LicenseNetworkError };