@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/lib/licensing/public-keys.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function loadPublicKeys() {
+    const keys = {};
+    const pemPath = path.join(__dirname, "public-key.pem");
+    try {
+        const pem = fs.readFileSync(pemPath, "utf8").trim();
+        if (pem.includes("BEGIN PUBLIC KEY")) keys.v1 = pem;
+    } catch (error) {
+        // A release without a vendor key fails closed in token-verifier.
+    }
+    return Object.freeze(keys);
+}
+
+module.exports = { PUBLIC_KEYS: loadPublicKeys(), loadPublicKeys };

package/lib/licensing/storage.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+async function ensurePrivateDirectory(directory) {
+    await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+    try { await fs.promises.chmod(directory, 0o700); } catch (error) { /* Windows/limited filesystems */ }
+}
+
+function tokenFileName(configId, product) {
+    const digest = crypto.createHash("sha256").update(String(configId) + "\0" + String(product)).digest("hex");
+    return "license-" + digest.slice(0, 32) + ".json";
+}
+
+function licenseKeyFingerprint(value) {
+    const key = String(value || "").trim();
+    return key ? crypto.createHash("sha256").update(key, "utf8").digest("hex") : null;
+}
+
+class LicenseStorage {
+    constructor(userDir, configId, product) {
+        this.directory = path.join(userDir, "atelier-license");
+        this.filePath = path.join(this.directory, tokenFileName(configId, product));
+    }
+
+    async load() {
+        try {
+            const raw = await fs.promises.readFile(this.filePath, "utf8");
+            const stored = JSON.parse(raw);
+            return stored && (typeof stored.token === "string" || typeof stored.serverState === "string") ? stored : null;
+        } catch (error) {
+            if (error.code === "ENOENT") return null;
+            throw error;
+        }
+    }
+
+    async save(token, deviceId, product, keyFingerprint) {
+        return this.saveState(null, token, deviceId, product, keyFingerprint);
+    }
+
+    async saveState(serverState, token, deviceId, product, keyFingerprint) {
+        let fingerprint = keyFingerprint;
+        if (fingerprint === undefined) {
+            const current = await this.load();
+            fingerprint = current && current.licenseKeyFingerprint || null;
+        }
+        await ensurePrivateDirectory(this.directory);
+        const temporary = this.filePath + ".tmp-" + process.pid;
+        const body = JSON.stringify({ token: token || null, serverState: serverState || null, deviceId, product, licenseKeyFingerprint: fingerprint || null, 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, this.filePath);
+        try { await fs.promises.chmod(this.filePath, 0o600); } catch (error) { /* Windows/limited filesystems */ }
+    }
+
+    async clear() {
+        try { await fs.promises.unlink(this.filePath); } catch (error) { if (error.code !== "ENOENT") throw error; }
+    }
+}
+
+module.exports = { LicenseStorage, ensurePrivateDirectory, licenseKeyFingerprint, tokenFileName };

package/lib/licensing/token-verifier.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const crypto = require("crypto");
+const { LICENSE_TYPES } = require("./constants");
+const { LicenseError } = require("./errors");
+
+function decodeJsonPart(value, label) {
+    try {
+        return JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    } catch (error) {
+        throw new LicenseError("INVALID_TOKEN", "Invalid " + label + " in license token");
+    }
+}
+
+function requireText(payload, field) {
+    if (typeof payload[field] !== "string" || !payload[field].trim()) {
+        throw new LicenseError("INVALID_TOKEN", "License token is missing " + field);
+    }
+}
+
+function requireTime(payload, field, nullable) {
+    const value = payload[field];
+    if (nullable && value === null) return;
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new LicenseError("INVALID_TOKEN", "License token has invalid " + field);
+    }
+}
+
+function validateClaims(payload) {
+    if (!Number.isInteger(payload.tokenVersion) || payload.tokenVersion < 1) {
+        throw new LicenseError("INVALID_TOKEN", "Unsupported license token version");
+    }
+    ["deviceId", "companyId", "licenseId", "product", "licenseType", "status"].forEach(function (field) {
+        requireText(payload, field);
+    });
+    ["issuedAt", "refreshAfter"].forEach(function (field) { requireTime(payload, field, false); });
+    const licenseType = payload.licenseType.toUpperCase();
+    if (!Object.prototype.hasOwnProperty.call(LICENSE_TYPES, licenseType)) {
+        throw new LicenseError("INVALID_TOKEN", "Unsupported license type");
+    }
+    requireTime(payload, "expiresAt", licenseType === LICENSE_TYPES.PERMANENT);
+    requireTime(payload, "offlineGraceUntil", licenseType === LICENSE_TYPES.PERMANENT);
+    if (payload.features === undefined) payload.features = {};
+    if (!payload.features || typeof payload.features !== "object" || Array.isArray(payload.features)) {
+        throw new LicenseError("INVALID_TOKEN", "License token has invalid features");
+    }
+    return payload;
+}
+
+function verifyLicenseToken(token, options) {
+    const settings = options || {};
+    if (typeof token !== "string" || token.length > 65536) {
+        throw new LicenseError("INVALID_TOKEN", "Invalid license token format");
+    }
+    const parts = token.split(".");
+    if (parts.length !== 3 || parts.some(function (part) { return !part; })) {
+        throw new LicenseError("INVALID_TOKEN", "License token must be compact JWS");
+    }
+    const header = decodeJsonPart(parts[0], "header");
+    const payload = decodeJsonPart(parts[1], "payload");
+    if (header.alg !== "EdDSA") throw new LicenseError("INVALID_TOKEN", "License token algorithm must be EdDSA");
+    const keyId = String(header.kid || payload.keyId || "");
+    if (!keyId) throw new LicenseError("INVALID_TOKEN", "License token is missing keyId");
+    const publicKeys = settings.publicKeys || {};
+    const publicKey = publicKeys[keyId];
+    if (!publicKey) throw new LicenseError("INVALID_TOKEN", "Unknown license signing key: " + keyId);
+    let valid = false;
+    try {
+        valid = crypto.verify(null, Buffer.from(parts[0] + "." + parts[1], "ascii"), publicKey, Buffer.from(parts[2], "base64url"));
+    } catch (error) {
+        throw new LicenseError("INVALID_TOKEN", "Invalid license signing key");
+    }
+    if (!valid) throw new LicenseError("INVALID_TOKEN", "Invalid license token signature");
+    validateClaims(payload);
+    if (settings.deviceId && payload.deviceId !== settings.deviceId) {
+        throw new LicenseError("INVALID_DEVICE", "License token belongs to another device");
+    }
+    if (settings.product && payload.product !== settings.product) {
+        throw new LicenseError("PRODUCT_NOT_LICENSED", "License token belongs to another product");
+    }
+    return { header, payload, keyId };
+}
+
+module.exports = { validateClaims, verifyLicenseToken };

package/lib/numbers.js

@@ -0,0 +1,26 @@
+"use strict";
+
+function toFiniteNumber(value, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function atLeast(value, min, fallback) {
+    return Math.max(min, toFiniteNumber(value, fallback));
+}
+
+function clampNumber(value, min, max, fallback) {
+    const numeric = toFiniteNumber(value, fallback);
+    return Math.min(Math.max(numeric, min), max);
+}
+
+function roundedAtLeast(value, min, fallback) {
+    return Math.max(min, Math.round(toFiniteNumber(value, fallback)));
+}
+
+module.exports = {
+    toFiniteNumber,
+    atLeast,
+    clampNumber,
+    roundedAtLeast
+};

package/license/atelier-license.html

@@ -0,0 +1,88 @@
+<script type="text/javascript">
+(function () {
+    "use strict";
+
+    // Multiple individually installed Atelier packages ship the same config node.
+    // Reuse the first editor definition instead of registering the type twice.
+    const marker = "__atelierLicenseEditorRegistered";
+    const alreadyRegistered = window[marker] || (RED.nodes && typeof RED.nodes.getType === "function" && RED.nodes.getType("atelier-license"));
+    window[marker] = true;
+    if (alreadyRegistered) return;
+
+    const LABELS = {
+        UNKNOWN: "Checking", NOT_ACTIVATED: "Not Activated", ACTIVATING: "Activating", ACTIVE: "Active",
+        OFFLINE: "Licensed 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", INVALID_TOKEN: "Invalid Token", INVALID_DEVICE: "Invalid Device",
+        PRODUCT_NOT_LICENSED: "Product Not Licensed", SERVER_ERROR: "Server Error"
+    };
+
+    function text(value) { return value === null || value === undefined || value === "" ? "—" : String(value); }
+    function render(status) {
+        const enabledFeatures = Object.keys(status.features || {}).filter(function (key) { return status.features[key]; });
+        const genericFeatures = enabledFeatures.filter(function (key) { return !key.startsWith("node:"); });
+        const selectedNodes = enabledFeatures.filter(function (key) { return key.startsWith("node:") && key !== "node:*"; }).map(function (key) { return key.slice(5); });
+        const displayedFeatures = genericFeatures.concat(status.allNodes ? ["Toate nodurile"] : selectedNodes);
+        const fields = {
+            status: LABELS[status.state] || status.state, company: status.company, device: status.deviceId,
+            source: status.deviceSource, type: status.licenseType, plan: status.plan, valid: status.expiresAt,
+            offline: status.offlineGraceUntil, last: status.lastCheck, next: status.nextCheck,
+            product: status.productName || status.product, features: displayedFeatures.join(", ")
+        };
+        Object.keys(fields).forEach(function (key) { $("#atelier-license-" + key).text(text(fields[key])); });
+        let message = status.message || "";
+        if (status.state === "PENDING_APPROVAL") message = "This device is waiting for approval from Atelierul de Tehnologii.";
+        if (status.state === "DEVICE_LIMIT_REACHED") message = "The maximum number of licensed devices for this company has been reached.";
+        if (status.state === "DEVICE_REMOVED") message = "This device was removed. Deploy the license configuration again to request a new activation.";
+        $("#atelier-license-message").text(message);
+    }
+
+    function request(node, operation) {
+        if (!node.id || node.id.startsWith("_") || !RED.nodes.node(node.id)) {
+            RED.notify("Deploy the license configuration before using this action.", "warning");
+            return;
+        }
+        $(".atelier-license-action").prop("disabled", true);
+        $.ajax({ url: "atelier-license/" + encodeURIComponent(node.id) + "/" + operation, method: operation === "status" ? "GET" : "POST", contentType: "application/json" })
+            .done(function (response) { render(response.status || {}); if (operation !== "status") RED.notify("License operation completed.", "success"); })
+            .fail(function (xhr) { const result = xhr.responseJSON || {}; RED.notify(result.message || "License operation failed.", "error"); })
+            .always(function () { $(".atelier-license-action").prop("disabled", false); });
+    }
+
+    RED.nodes.registerType("atelier-license", {
+        category: "config",
+        defaults: {
+            name: { value: "Atelierul de Tehnologii License" },
+            product: { value: "node-red-custome-solutions", required: true }
+        },
+        credentials: { licenseKey: { type: "password" } },
+        label: function () { return this.name || "Atelierul de Tehnologii License"; },
+        oneditprepare: function () {
+            const node = this;
+            $("#node-config-input-product").val("node-red-custome-solutions");
+            $("#atelier-license-refresh").on("click", function () { request(node, "refresh"); });
+            request(node, "status");
+        }
+    });
+}());
+</script>
+
+<script type="text/html" data-template-name="atelier-license">
+    <div class="form-row"><label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label><input type="text" id="node-config-input-name"></div>
+    <div class="form-row"><label for="node-config-input-licenseKey"><i class="fa fa-key"></i> License Key</label><input type="password" id="node-config-input-licenseKey" autocomplete="new-password"></div>
+    <input type="hidden" id="node-config-input-product">
+    <div class="form-row"><button type="button" id="atelier-license-refresh" class="red-ui-button atelier-license-action"><i class="fa fa-refresh"></i> Refresh License</button></div>
+    <div class="form-tips">License activation is automatic after Deploy. To change the license, enter the new key and Deploy again.</div>
+    <div class="form-row" style="border:1px solid #ddd;border-radius:4px;padding:10px;line-height:1.7">
+        <strong>Status: <span id="atelier-license-status">Checking</span></strong><br>
+        Company: <span id="atelier-license-company">—</span><br>Device ID: <span id="atelier-license-device">—</span><br>Device source: <span id="atelier-license-source">—</span><br>
+        License Type: <span id="atelier-license-type">—</span><br>Plan: <span id="atelier-license-plan">—</span><br>Valid Until: <span id="atelier-license-valid">—</span><br>
+        Offline Until: <span id="atelier-license-offline">—</span><br>Last Check: <span id="atelier-license-last">—</span><br>Next Check: <span id="atelier-license-next">—</span><br>
+        Product: <span id="atelier-license-product">—</span><br>Features: <span id="atelier-license-features">—</span><br><em id="atelier-license-message"></em>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="atelier-license">
+    <p>Central commercial license configuration for Atelierul de Tehnologii nodes. The License Key is stored as a Node-RED credential; signed tokens are stored under the Node-RED user directory.</p>
+</script>

package/license/atelier-license.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { LicenseClient } = require("../lib/licensing/license-client");
+const { PRODUCT_CODE, PRODUCT_NAME, STATUS_PRESENTATION } = require("../lib/licensing/constants");
+const { getDeviceIdentity } = require("../lib/licensing/device-id");
+const { PUBLIC_KEYS } = require("../lib/licensing/public-keys");
+const { LicenseStorage, licenseKeyFingerprint } = require("../lib/licensing/storage");
+const { getPackageIntegrity } = require("../lib/licensing/package-integrity");
+
+module.exports = function (RED) {
+    // Every selectively delivered package contains this shared config node. Node-RED
+    // loads installed packages sequentially, so only the first copy must register it.
+    // The remaining packages reuse the existing type and its runtime/admin routes.
+    if (RED.nodes && typeof RED.nodes.getType === "function" && RED.nodes.getType("atelier-license")) return;
+
+    const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8").replace(/^\uFEFF/, ""));
+    const commercialNodeTypes = new Set(Object.keys(packageJson["node-red"].nodes || {}).filter(function (type) { return type !== "atelier-license"; }));
+    const packageContainsAllNodes = !packageJson.atelierDelivery || packageJson.atelierDelivery.allNodes === true;
+    const runtimeNodes = new Map();
+    const integrity = getPackageIntegrity();
+
+    function publicError(error) {
+        return { ok: false, code: error.code || "SERVER_ERROR", message: error.message || "License operation failed" };
+    }
+
+    function AtelierLicenseNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.name = String(config.name || "Atelierul de Tehnologii License").trim();
+        node.product = PRODUCT_CODE;
+        node.client = null;
+        node.initialization = null;
+        node.approvalRetry = null;
+
+        function clientMethod(name, fallback) {
+            return function () {
+                if (!node.client || typeof node.client[name] !== "function") return fallback;
+                return node.client[name].apply(node.client, arguments);
+            };
+        }
+
+        const clientIsLicensed = clientMethod("isLicensed", false);
+        const clientGetState = clientMethod("getState", "UNKNOWN");
+        node.isLicensed = function () { return integrity.isValid() && clientIsLicensed(); };
+        node.getState = function () { return integrity.isValid() ? clientGetState() : "PACKAGE_TAMPERED"; };
+        node.getCompany = clientMethod("getCompany", null);
+        node.getPlan = clientMethod("getPlan", null);
+        node.getFeatures = clientMethod("getFeatures", {});
+        node.hasFeature = clientMethod("hasFeature", false);
+        node.getDeviceId = clientMethod("getDeviceId", null);
+        node.getLicenseType = clientMethod("getLicenseType", null);
+        node.getExpiresAt = clientMethod("getExpiresAt", null);
+        node.getOfflineGraceUntil = clientMethod("getOfflineGraceUntil", null);
+        node.getLastCheck = clientMethod("getLastCheck", null);
+        node.getNextCheck = clientMethod("getNextCheck", null);
+        node.getLicenseStatus = clientMethod("getStatus", { state: "UNKNOWN" });
+        node.getDisplayLicenseStatus = function () {
+            const status = node.getLicenseStatus();
+            const features = status && status.features || {};
+            const everyInstalledNodeLicensed = commercialNodeTypes.size > 0 && [...commercialNodeTypes].every(function (type) { return features["node:" + type] === true; });
+            return Object.assign({}, status, { state: integrity.isValid() ? status.state : "PACKAGE_TAMPERED", integrity: integrity.getStatus(), allNodes: features["node:*"] === true || packageContainsAllNodes && everyInstalledNodeLicensed });
+        };
+        node.refresh = function () { return node.initialization.then(function () { return node.client.refresh(); }).then(function () { return node.getDisplayLicenseStatus(); }); };
+
+        function updateStatus(status) {
+            const effective = integrity.isValid() ? status : Object.assign({}, status, { state: "PACKAGE_TAMPERED", integrity: integrity.getStatus() });
+            const presentation = STATUS_PRESENTATION[effective.state] || STATUS_PRESENTATION.UNKNOWN;
+            node.status(presentation);
+            node.emit("state-changed", effective);
+        }
+
+        function integrityChanged() { updateStatus(node.getLicenseStatus()); }
+        integrity.on("state-changed", integrityChanged);
+
+        const storage = new LicenseStorage(RED.settings.userDir, node.id, node.product);
+        node.initialization = storage.load().catch(function () { return null; }).then(async function (stored) {
+            const identity = await getDeviceIdentity(RED.settings.userDir, { preferredDeviceId: stored && stored.deviceId });
+            node.client = new LicenseClient({
+                identity,
+                nodeRedVersion: (typeof RED.version === "function" ? RED.version() : RED.version) || (RED.settings && RED.settings.version) || "unknown",
+                product: node.product,
+                productName: PRODUCT_NAME,
+                publicKeys: PUBLIC_KEYS,
+                nodeUsageProvider: function () {
+                    let count = 0;
+                    if (RED.nodes && typeof RED.nodes.eachNode === "function") {
+                        RED.nodes.eachNode(function (flowNode) {
+                            if (flowNode && flowNode.license === node.id && commercialNodeTypes.has(flowNode.type)) count += 1;
+                        });
+                    }
+                    return count;
+                },
+                serverUrl: process.env.ATELIER_LICENSE_SERVER_URL,
+                storage,
+                version: packageJson.version
+            });
+            node.client.on("state-changed", updateStatus);
+            node.client.on("background-error", function (event) {
+                node.warn("License " + event.operation + " failed [" + event.code + "]: " + event.message + " at " + event.at);
+            });
+            let status = await node.client.initialize();
+            const configuredKey = String(node.credentials && node.credentials.licenseKey || "").trim();
+            const configuredFingerprint = licenseKeyFingerprint(configuredKey);
+            const keyChanged = Boolean(configuredFingerprint && (!stored || stored.licenseKeyFingerprint !== configuredFingerprint));
+            const needsActivation = ["NOT_ACTIVATED", "INVALID_TOKEN", "INVALID_DEVICE", "PRODUCT_NOT_LICENSED", "PENDING_APPROVAL", "DEVICE_LIMIT_REACHED", "DEVICE_REMOVED"].includes(status.state);
+            if (configuredKey && (keyChanged || needsActivation)) {
+                try {
+                    status = await node.client.activate(configuredKey);
+                } catch (error) {
+                    status = node.client.getStatus();
+                    node.warn("Automatic license activation failed: " + error.message);
+                }
+            }
+            if (configuredKey) {
+                node.approvalRetry = setInterval(function () {
+                    if (!node.client || !["PENDING_APPROVAL", "DEVICE_LIMIT_REACHED"].includes(node.client.getState())) return;
+                    node.client.runBackground("approval-retry", node.client.activate(configuredKey));
+                }, 5000);
+                if (typeof node.approvalRetry.unref === "function") node.approvalRetry.unref();
+            }
+            updateStatus(status);
+            return status;
+        }).catch(function (error) {
+            node.status(STATUS_PRESENTATION.SERVER_ERROR);
+            node.error("License initialization failed: " + error.message);
+            throw error;
+        });
+
+        runtimeNodes.set(node.id, node);
+        node.on("close", function (removed, done) {
+            if (typeof removed === "function" && done === undefined) done = removed;
+            runtimeNodes.delete(node.id);
+            integrity.removeListener("state-changed", integrityChanged);
+            if (node.approvalRetry) clearInterval(node.approvalRetry);
+            node.approvalRetry = null;
+            if (node.client) node.client.close();
+            if (typeof done === "function") done();
+        });
+    }
+
+    RED.nodes.registerType("atelier-license", AtelierLicenseNode, {
+        credentials: { licenseKey: { type: "password" } }
+    });
+
+    function permission(name) {
+        return RED.auth && typeof RED.auth.needsPermission === "function" ? RED.auth.needsPermission(name) : function (req, res, next) { next(); };
+    }
+
+    function withNode(req, res, action) {
+        const node = runtimeNodes.get(req.params.id);
+        if (!node) { res.status(404).json({ ok: false, code: "NOT_FOUND", message: "License configuration is not deployed." }); return; }
+        Promise.resolve().then(() => action(node)).then(function (status) {
+            res.json({ ok: true, status });
+        }).catch(function (error) {
+            const response = publicError(error);
+            res.status(error.isNetworkError ? 503 : 400).json(response);
+        });
+    }
+
+    if (RED.httpAdmin) {
+        RED.httpAdmin.get("/atelier-license/:id/status", permission("atelier-license.read"), function (req, res) {
+            withNode(req, res, async function (node) { await node.initialization; return node.getDisplayLicenseStatus(); });
+        });
+        RED.httpAdmin.post("/atelier-license/:id/refresh", permission("atelier-license.write"), function (req, res) {
+            withNode(req, res, function (node) { return node.refresh(); });
+        });
+    }
+};