@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/lib/licensing/license-client.js

@@ -0,0 +1,377 @@
+"use strict";
+
+const EventEmitter = require("events");
+const http = require("http");
+const https = require("https");
+const os = require("os");
+const {
+    CONTROL_STATUS_INTERVAL_MS,
+    DEFAULT_SERVER_URL,
+    LICENSE_STATES,
+    PRODUCT_CODE,
+    REQUEST_TIMEOUT_MS,
+    RETRY_DELAYS_MS,
+    SCHEDULER_INTERVAL_MS,
+    SERVER_STATE_MAP
+} = require("./constants");
+const { LicenseError, LicenseNetworkError } = require("./errors");
+const { evaluateLicenseState, isLicensedState } = require("./license-state");
+const { PUBLIC_KEYS } = require("./public-keys");
+const { verifyLicenseToken } = require("./token-verifier");
+const { licenseKeyFingerprint } = require("./storage");
+
+const NETWORK_CODES = new Set(["ETIMEDOUT", "ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "ECONNRESET", "EPIPE", "ERR_TLS_HANDSHAKE_TIMEOUT"]);
+const AUTHORITATIVE_DENIAL_STATES = new Set([
+    LICENSE_STATES.REVOKED,
+    LICENSE_STATES.SUSPENDED,
+    LICENSE_STATES.DEVICE_BLOCKED,
+    LICENSE_STATES.DEVICE_REJECTED,
+    LICENSE_STATES.DEVICE_DEACTIVATED,
+    LICENSE_STATES.DEVICE_REMOVED
+]);
+
+function sanitizeServerUrl(value) {
+    const candidate = String(value || DEFAULT_SERVER_URL).trim().replace(/\/+$/, "");
+    const parsed = new URL(candidate);
+    if (!/^https?:$/.test(parsed.protocol)) throw new LicenseError("SERVER_ERROR", "License server URL must use HTTP or HTTPS");
+    return parsed.toString().replace(/\/$/, "");
+}
+
+function requestJson(baseUrl, endpoint, body, timeoutMs) {
+    return new Promise(function (resolve, reject) {
+        const target = new URL(endpoint, baseUrl + "/");
+        const payload = Buffer.from(JSON.stringify(body || {}), "utf8");
+        const transport = target.protocol === "https:" ? https : http;
+        const request = transport.request(target, {
+            method: "POST",
+            headers: { "content-type": "application/json", "content-length": payload.length, accept: "application/json" },
+            timeout: timeoutMs || REQUEST_TIMEOUT_MS
+        }, function (response) {
+            const chunks = [];
+            let size = 0;
+            response.on("data", function (chunk) {
+                size += chunk.length;
+                if (size > 1024 * 1024) {
+                    request.destroy(new Error("License response too large"));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            response.on("end", function () {
+                const statusCode = Number(response.statusCode || 0);
+                const serverUnavailable = statusCode >= 500 && statusCode <= 599;
+                let data = {};
+                try { data = chunks.length ? JSON.parse(Buffer.concat(chunks).toString("utf8")) : {}; } catch (error) {
+                    if (serverUnavailable) {
+                        reject(new LicenseNetworkError(`License server unavailable (HTTP ${statusCode})`, error));
+                        return;
+                    }
+                    reject(new LicenseError("SERVER_ERROR", "License server returned invalid JSON"));
+                    return;
+                }
+                const errorData = data && typeof data.error === "object" ? data.error : data;
+                if (serverUnavailable) {
+                    reject(new LicenseNetworkError(errorData.message || `License server unavailable (HTTP ${statusCode})`));
+                    return;
+                }
+                if (statusCode < 200 || statusCode >= 300 || data.success === false) {
+                    const code = String(errorData.code || "SERVER_ERROR").toUpperCase();
+                    reject(new LicenseError(code, errorData.message || "License server rejected the request", { statusCode }));
+                    return;
+                }
+                resolve(data && data.success === true && data.data && typeof data.data === "object" ? data.data : data);
+            });
+        });
+        request.on("timeout", function () { request.destroy(Object.assign(new Error("License request timed out"), { code: "ETIMEDOUT" })); });
+        request.on("error", function (error) {
+            if (NETWORK_CODES.has(error.code) || /network|socket|connect|timed out/i.test(error.message || "")) {
+                reject(new LicenseNetworkError(error.message, error));
+                return;
+            }
+            reject(new LicenseError("SERVER_ERROR", error.message));
+        });
+        request.end(payload);
+    });
+}
+
+class LicenseClient extends EventEmitter {
+    constructor(options) {
+        super();
+        const settings = options || {};
+        this.storage = settings.storage;
+        this.identity = settings.identity;
+        this.product = settings.product || PRODUCT_CODE;
+        this.productName = settings.productName || this.product;
+        this.version = settings.version || "unknown";
+        this.nodeRedVersion = settings.nodeRedVersion || "unknown";
+        this.serverUrl = sanitizeServerUrl(settings.serverUrl || process.env.ATELIER_LICENSE_SERVER_URL || DEFAULT_SERVER_URL);
+        this.publicKeys = settings.publicKeys || PUBLIC_KEYS;
+        this.timeoutMs = settings.timeoutMs || REQUEST_TIMEOUT_MS;
+        this.request = settings.request || requestJson;
+        this.nodeUsageProvider = typeof settings.nodeUsageProvider === "function" ? settings.nodeUsageProvider : function () { return 0; };
+        this.state = LICENSE_STATES.UNKNOWN;
+        this.token = null;
+        this.claims = null;
+        this.lastCheck = null;
+        this.nextCheck = null;
+        this.lastMessage = "";
+        this.retryIndex = 0;
+        this.scheduler = null;
+        this.controlScheduler = null;
+        this.startupRefresh = null;
+        this.busy = null;
+        this.lastBackgroundError = null;
+    }
+
+    runBackground(operation, promise) {
+        Promise.resolve(promise).catch((error) => {
+            const code = String(error && error.code || "SERVER_ERROR");
+            const message = String(error && error.message || error || "Unknown licensing error");
+            const fingerprint = operation + ":" + code + ":" + message;
+            const now = Date.now();
+            if (!this.lastBackgroundError || this.lastBackgroundError.fingerprint !== fingerprint || now - this.lastBackgroundError.at >= 60000) {
+                this.lastBackgroundError = { fingerprint, at: now };
+                this.emit("background-error", { operation, code, message, at: new Date(now).toISOString() });
+            }
+        });
+    }
+
+    setState(state, message) {
+        const previous = this.state;
+        this.state = state;
+        this.lastMessage = message || "";
+        if (previous !== state) this.emit("state-changed", this.getStatus());
+    }
+
+    verifyAndApply(token, options) {
+        try {
+            const previousState = this.state;
+            const previousFeatures = JSON.stringify(this.claims && this.claims.features || {});
+            const verified = verifyLicenseToken(token, { publicKeys: this.publicKeys, deviceId: this.identity.deviceId, product: this.product });
+            this.token = token;
+            this.claims = verified.payload;
+            const state = evaluateLicenseState(this.claims, options);
+            this.setState(state);
+            if (previousState === state && previousFeatures !== JSON.stringify(this.claims.features || {})) {
+                this.emit("state-changed", this.getStatus());
+            }
+            this.nextCheck = this.claims.refreshAfter || null;
+            return verified.payload;
+        } catch (error) {
+            this.token = null;
+            this.claims = null;
+            this.setState(error.code === "INVALID_DEVICE" ? LICENSE_STATES.INVALID_DEVICE : error.code === "PRODUCT_NOT_LICENSED" ? LICENSE_STATES.PRODUCT_NOT_LICENSED : LICENSE_STATES.INVALID_TOKEN, error.message);
+            throw error;
+        }
+    }
+
+    async initialize() {
+        const stored = await this.storage.load();
+        if (!stored || (!stored.token && !stored.serverState)) {
+            this.setState(LICENSE_STATES.NOT_ACTIVATED);
+        } else if (!stored.token && stored.serverState) {
+            this.setState(stored.serverState);
+        } else {
+            try {
+                this.verifyAndApply(stored.token);
+                if (stored.serverState) this.setState(stored.serverState);
+                if (this.shouldRefresh()) setImmediate(() => this.runBackground("startup-refresh", this.refresh()));
+            } catch (error) {
+                // verifyAndApply already selected a fail-closed state.
+            }
+        }
+        this.scheduler = setInterval(() => {
+            if (this.shouldRefresh()) this.runBackground("scheduled-refresh", this.refresh());
+        }, SCHEDULER_INTERVAL_MS);
+        if (typeof this.scheduler.unref === "function") this.scheduler.unref();
+        this.controlScheduler = setInterval(() => {
+            if (this.token && !this.busy) this.runBackground("control-status", this.checkStatus());
+        }, CONTROL_STATUS_INTERVAL_MS);
+        if (typeof this.controlScheduler.unref === "function") this.controlScheduler.unref();
+        if (this.token) {
+            this.startupRefresh = setTimeout(() => {
+                this.startupRefresh = null;
+                this.runBackground("startup-refresh", this.refresh());
+            }, 1000);
+            if (typeof this.startupRefresh.unref === "function") this.startupRefresh.unref();
+        }
+        return this.getStatus();
+    }
+
+    shouldRefresh(now) {
+        if (!this.token || !this.claims || this.busy) return false;
+        const refreshAt = Date.parse(this.claims.refreshAfter);
+        const retryAt = this.nextCheck ? Date.parse(this.nextCheck) : NaN;
+        return Number(now || Date.now()) >= (Number.isFinite(retryAt) ? retryAt : refreshAt);
+    }
+
+    metadata() {
+        let activeNodeCount = 0;
+        try { activeNodeCount = Math.max(0, Number(this.nodeUsageProvider()) || 0); } catch (error) { activeNodeCount = 0; }
+        return {
+            activeNodeCount: Math.floor(activeNodeCount),
+            deviceId: this.identity.deviceId,
+            product: this.product,
+            version: this.version,
+            deviceName: os.hostname(),
+            deviceModel: this.identity.deviceModel || null,
+            nodeRedVersion: this.nodeRedVersion,
+            venusOsVersion: this.identity.venusOsVersion || null,
+            macAddress: this.identity.macAddress || null,
+            hardwareSerial: this.identity.hardwareSerial || null,
+            systemUuid: this.identity.systemUuid || null,
+            manufacturer: this.identity.manufacturer || null,
+            osPlatform: this.identity.osPlatform || null,
+            osRelease: this.identity.osRelease || null,
+            cpuArch: this.identity.cpuArch || null,
+            networkInterface: this.identity.networkInterface || null,
+            identitySource: this.identity.identitySource || this.identity.source || null
+        };
+    }
+
+    async acceptResponse(response, options) {
+        const settings = options || {};
+        const code = String(response.code || response.status || "").toUpperCase();
+        if (SERVER_STATE_MAP[code]) {
+            this.setState(SERVER_STATE_MAP[code], response.message);
+            await this.storage.saveState(SERVER_STATE_MAP[code], this.token, this.identity.deviceId, this.product, settings.licenseKeyFingerprint);
+            return this.getStatus();
+        }
+        if (!response.token) throw new LicenseError("SERVER_ERROR", "License server did not return a token");
+        this.verifyAndApply(response.token);
+        await this.storage.save(response.token, this.identity.deviceId, this.product, settings.licenseKeyFingerprint);
+        this.lastCheck = new Date().toISOString();
+        this.retryIndex = 0;
+        return this.getStatus();
+    }
+
+    runExclusive(operation) {
+        if (this.busy) return this.busy;
+        this.busy = Promise.resolve().then(operation).finally(() => { this.busy = null; });
+        return this.busy;
+    }
+
+    activate(licenseKey) {
+        const key = String(licenseKey || "").trim();
+        if (!key) return Promise.reject(new LicenseError("NOT_ACTIVATED", "License Key is required"));
+        return this.runExclusive(async () => {
+            this.setState(LICENSE_STATES.ACTIVATING);
+            this.lastCheck = new Date().toISOString();
+            try {
+                return await this.acceptResponse(await this.request(this.serverUrl, "/api/v1/license/activate", Object.assign({ licenseKey: key }, this.metadata()), this.timeoutMs), { licenseKeyFingerprint: licenseKeyFingerprint(key) });
+            } catch (error) {
+                this.applyRequestError(error, false);
+                throw error;
+            }
+        });
+    }
+
+    refresh() {
+        if (!this.token) return Promise.reject(new LicenseError("NOT_ACTIVATED", "No stored license token"));
+        return this.runExclusive(async () => {
+            this.lastCheck = new Date().toISOString();
+            try {
+                const body = this.metadata();
+                delete body.product;
+                body.token = this.token;
+                return await this.acceptResponse(await this.request(this.serverUrl, "/api/v1/license/refresh", body, this.timeoutMs));
+            } catch (error) {
+                this.applyRequestError(error, true);
+                throw error;
+            }
+        });
+    }
+
+    checkStatus() {
+        if (!this.token) return Promise.reject(new LicenseError("NOT_ACTIVATED", "No stored license token"));
+        return this.runExclusive(async () => {
+            this.lastCheck = new Date().toISOString();
+            try {
+                const response = await this.request(this.serverUrl, "/api/v1/license/status", { token: this.token, deviceId: this.identity.deviceId, activeNodeCount: this.metadata().activeNodeCount }, this.timeoutMs);
+                if (response.token) return await this.acceptResponse(response);
+                this.verifyAndApply(this.token, { remoteState: response.status || "ACTIVE" });
+                await this.storage.save(this.token, this.identity.deviceId, this.product);
+                this.retryIndex = 0;
+                return this.getStatus();
+            } catch (error) {
+                this.applyRequestError(error, true);
+                throw error;
+            }
+        });
+    }
+
+    applyRequestError(error, hadToken) {
+        if (["INVALID_TOKEN", "INVALID_DEVICE", "PRODUCT_NOT_LICENSED"].includes(error.code)) {
+            this.setState(LICENSE_STATES[error.code], error.message);
+            return;
+        }
+        const mapped = SERVER_STATE_MAP[String(error.code || "").toUpperCase()];
+        if (mapped) {
+            this.setState(mapped, error.message);
+            this.nextCheck = null;
+            if (this.storage && typeof this.storage.saveState === "function") {
+                this.runBackground("persist-server-state", this.storage.saveState(mapped, this.token, this.identity.deviceId, this.product));
+            }
+            return;
+        }
+        if (error.isNetworkError && hadToken && this.token) {
+            // A server-side block/suspension remains authoritative until the
+            // server explicitly reports ACTIVE again. Never fall back to an
+            // older locally valid token after such a denial.
+            if (AUTHORITATIVE_DENIAL_STATES.has(this.state)) {
+                this.lastMessage = "License server unavailable; the last administrative restriction remains active.";
+                return;
+            }
+            try { this.verifyAndApply(this.token, { networkUnavailable: true }); } catch (verificationError) { return; }
+            const delay = RETRY_DELAYS_MS[Math.min(this.retryIndex, RETRY_DELAYS_MS.length - 1)];
+            this.retryIndex += 1;
+            this.nextCheck = new Date(Date.now() + delay).toISOString();
+            this.lastMessage = "License server unavailable; using locally verified license policy.";
+            return;
+        }
+        this.setState(LICENSE_STATES.SERVER_ERROR, error.message);
+    }
+
+    async clear() {
+        await this.storage.clear();
+        this.token = null;
+        this.claims = null;
+        this.lastCheck = new Date().toISOString();
+        this.nextCheck = null;
+        this.setState(LICENSE_STATES.NOT_ACTIVATED);
+        return this.getStatus();
+    }
+
+    close() {
+        if (this.scheduler) clearInterval(this.scheduler);
+        if (this.controlScheduler) clearInterval(this.controlScheduler);
+        if (this.startupRefresh) clearTimeout(this.startupRefresh);
+        this.scheduler = null;
+        this.controlScheduler = null;
+        this.startupRefresh = null;
+    }
+
+    isLicensed() { return isLicensedState(this.state); }
+    getState() { return this.state; }
+    getCompany() { return this.claims ? (this.claims.company || this.claims.companyName || this.claims.companyId) : null; }
+    getPlan() { return this.claims ? (this.claims.plan || null) : null; }
+    getFeatures() { return Object.assign({}, this.claims && this.claims.features || {}); }
+    hasFeature(name) { return !!(this.claims && this.claims.features && this.claims.features[name] === true); }
+    getDeviceId() { return this.identity.deviceId; }
+    getLicenseType() { return this.claims ? this.claims.licenseType : null; }
+    getExpiresAt() { return this.claims ? this.claims.expiresAt : null; }
+    getOfflineGraceUntil() { return this.claims ? this.claims.offlineGraceUntil : null; }
+    getLastCheck() { return this.lastCheck; }
+    getNextCheck() { return this.nextCheck || (this.claims && this.claims.refreshAfter) || null; }
+    getStatus() {
+        return {
+            company: this.getCompany(), deviceId: this.getDeviceId(), deviceSource: this.identity.source,
+            expiresAt: this.getExpiresAt(), features: this.getFeatures(), lastCheck: this.getLastCheck(),
+            licenseType: this.getLicenseType(), message: this.lastMessage, nextCheck: this.getNextCheck(),
+            offlineGraceUntil: this.getOfflineGraceUntil(), plan: this.getPlan(), product: this.product,
+            productName: this.productName, state: this.getState()
+        };
+    }
+}
+
+module.exports = { AUTHORITATIVE_DENIAL_STATES, LicenseClient, NETWORK_CODES, requestJson, sanitizeServerUrl };

package/lib/licensing/license-state.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const { LICENSED_STATES, LICENSE_STATES, LICENSE_TYPES } = require("./constants");
+
+function timeValue(value) {
+    if (value === null || value === undefined || value === "") return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : NaN;
+}
+
+function evaluateLicenseState(payload, options) {
+    const settings = options || {};
+    const now = settings.now instanceof Date ? settings.now.getTime() : Number(settings.now || Date.now());
+    const networkUnavailable = !!settings.networkUnavailable;
+    const remoteState = String(settings.remoteState || payload.status || "").toUpperCase();
+
+    if (["REVOKED", "LICENSE_REVOKED"].includes(remoteState)) return LICENSE_STATES.REVOKED;
+    if (["SUSPENDED", "LICENSE_SUSPENDED", "COMPANY_SUSPENDED"].includes(remoteState)) return LICENSE_STATES.SUSPENDED;
+    if (remoteState === "DEVICE_BLOCKED") return LICENSE_STATES.DEVICE_BLOCKED;
+    if (remoteState === "DEVICE_REJECTED") return LICENSE_STATES.DEVICE_REJECTED;
+    if (remoteState === "DEVICE_DEACTIVATED") return LICENSE_STATES.DEVICE_DEACTIVATED;
+    if (remoteState === "PENDING_APPROVAL" || remoteState === "DEVICE_APPROVAL_REQUIRED") return LICENSE_STATES.PENDING_APPROVAL;
+
+    const licenseType = String(payload.licenseType || "").toUpperCase();
+    const expiresAt = timeValue(payload.expiresAt);
+    const offlineUntil = timeValue(payload.offlineGraceUntil);
+
+    if (licenseType === LICENSE_TYPES.SUBSCRIPTION && (!Number.isFinite(expiresAt) || now > expiresAt)) {
+        return LICENSE_STATES.EXPIRED;
+    }
+
+    if (!networkUnavailable) return LICENSE_STATES.ACTIVE;
+
+    // A null offlineGraceUntil represents an unlimited offline policy for
+    // both permanent and subscription licenses. Subscriptions are still
+    // bounded by expiresAt, which is checked above.
+    if (payload.offlineGraceUntil === null) {
+        return LICENSE_STATES.OFFLINE;
+    }
+    if (Number.isFinite(offlineUntil) && now <= offlineUntil) {
+        return LICENSE_STATES.GRACE_PERIOD;
+    }
+    return LICENSE_STATES.EXPIRED;
+}
+
+function isLicensedState(state) {
+    return LICENSED_STATES.includes(state);
+}
+
+module.exports = { evaluateLicenseState, isLicensedState, timeValue };

package/lib/licensing/node-guard.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const { STATUS_PRESENTATION } = require("./constants");
+const { getPackageIntegrity } = require("./package-integrity");
+
+function statusForLicense(license) {
+    if (!license) return { fill: "red", shape: "ring", text: "license missing" };
+    const state = typeof license.getState === "function" ? license.getState() : "UNKNOWN";
+    return STATUS_PRESENTATION[state] || STATUS_PRESENTATION.UNKNOWN;
+}
+
+function nodeFeatureKey(node) {
+    return "node:" + String(node && node.type || "").trim();
+}
+
+function isNodeLicensed(license, node) {
+    if (!license || typeof license.hasFeature !== "function") return false;
+    return license.hasFeature("node:*") || license.hasFeature(nodeFeatureKey(node));
+}
+
+function runCloseHandler(handler) {
+    return new Promise(function (resolve) {
+        let complete = false;
+        let timeout = null;
+        function done() {
+            if (!complete) {
+                complete = true;
+                if (timeout) clearTimeout(timeout);
+                resolve();
+            }
+        }
+        try {
+            const result = handler.length >= 2 ? handler(false, done) : handler(done);
+            if (result && typeof result.then === "function") result.then(done, done);
+            else if (handler.length === 0) done();
+        } catch (error) { done(); }
+        if (!complete) timeout = setTimeout(done, 5000);
+    });
+}
+
+function runLicensedNode(node, RED, config, startRuntime) {
+    const license = RED.nodes.getNode(config.license);
+    const integrity = getPackageIntegrity();
+    const originalOn = node.on.bind(node);
+    const originalRemoveListener = node.removeListener ? node.removeListener.bind(node) : null;
+    let running = false;
+    let closed = false;
+    let transition = Promise.resolve();
+    let runtimeListeners = [];
+    let closeHandlers = [];
+    let entitlementRefreshRequested = false;
+
+    function presentLicenseStatus() {
+        if (!integrity.isValid()) {
+            node.status(STATUS_PRESENTATION.PACKAGE_TAMPERED);
+            return;
+        }
+        if (license && license.isLicensed() && !isNodeLicensed(license, node)) {
+            node.status({ fill: "red", shape: "ring", text: "node not licensed" });
+            return;
+        }
+        node.status(statusForLicense(license));
+    }
+
+    function start() {
+        if (closed || running || !integrity.isValid() || !license || !license.isLicensed() || !isNodeLicensed(license, node)) {
+            presentLicenseStatus();
+            return;
+        }
+        running = true;
+        const publicOn = node.on;
+        node.on = function (eventName, handler) {
+            if (eventName === "close") {
+                closeHandlers.push(handler);
+                return node;
+            }
+            const guarded = eventName === "input" ? function () {
+                if (!integrity.isValid() || !license.isLicensed() || !isNodeLicensed(license, node)) {
+                    presentLicenseStatus();
+                    const done = arguments.length > 2 && arguments[2];
+                    if (typeof done === "function") done();
+                    return;
+                }
+                return handler.apply(node, arguments);
+            } : handler;
+            runtimeListeners.push({ eventName, handler: guarded });
+            originalOn(eventName, guarded);
+            return node;
+        };
+        try {
+            startRuntime();
+        } catch (error) {
+            running = false;
+            node.error("Licensed runtime startup failed: " + (error.message || error));
+        } finally {
+            node.on = publicOn;
+        }
+    }
+
+    async function stop() {
+        if (!running) return;
+        running = false;
+        if (originalRemoveListener) runtimeListeners.forEach(function (listener) {
+            originalRemoveListener(listener.eventName, listener.handler);
+        });
+        runtimeListeners = [];
+        const handlers = closeHandlers.splice(0);
+        for (const handler of handlers.reverse()) await runCloseHandler(handler);
+    }
+
+    function reconcile() {
+        transition = transition.then(async function () {
+            if (closed) return;
+            if (integrity.isValid() && license && license.isLicensed() && isNodeLicensed(license, node)) start();
+            else { await stop(); presentLicenseStatus(); }
+        }).catch(function (error) { node.error(error); });
+    }
+
+    function stateChanged() { reconcile(); refreshMissingEntitlementOnce(); }
+    if (license && typeof license.on === "function") license.on("state-changed", stateChanged);
+    integrity.on("state-changed", stateChanged);
+
+    function refreshMissingEntitlementOnce() {
+        if (entitlementRefreshRequested || !integrity.isValid() || !license || typeof license.refresh !== "function" || !license.isLicensed() || isNodeLicensed(license, node)) return;
+        entitlementRefreshRequested = true;
+        Promise.resolve(license.refresh()).then(reconcile).catch(function () { presentLicenseStatus(); });
+    }
+
+    originalOn("close", function (removed, done) {
+        if (typeof removed === "function" && done === undefined) {
+            done = removed;
+            removed = false;
+        }
+        closed = true;
+        if (license && typeof license.removeListener === "function") license.removeListener("state-changed", stateChanged);
+        integrity.removeListener("state-changed", stateChanged);
+        transition.then(stop).finally(function () { if (typeof done === "function") done(); });
+    });
+
+    if (integrity.isValid() && license && license.isLicensed() && isNodeLicensed(license, node)) start();
+    else {
+        presentLicenseStatus();
+        // A newly delivered node may not exist in the previously issued token.
+        // Refresh once at deployment so its new entitlement becomes effective
+        // without opening the license configuration node manually.
+        refreshMissingEntitlementOnce();
+    }
+}
+
+module.exports = { runLicensedNode, statusForLicense, isNodeLicensed };