@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scripts/check-syntax.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const vm = require("vm");
+
+const rootDir = path.resolve(__dirname, "..");
+const ignoredSuffixes = [".save"];
+const htmlScriptPattern = /<script\b[^>]*type=["']text\/javascript["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+function walk(dir, files) {
+    fs.readdirSync(dir, { withFileTypes: true }).forEach(function (entry) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(fullPath, files);
+            return;
+        }
+
+        if (
+            entry.isFile() &&
+            (entry.name.endsWith(".js") || entry.name.endsWith(".html")) &&
+            !ignoredSuffixes.some(function (suffix) { return entry.name.endsWith(suffix); })
+        ) {
+            files.push(fullPath);
+        }
+    });
+}
+
+const files = [];
+walk(rootDir, files);
+
+const failures = [];
+files.forEach(function (file) {
+    try {
+        const source = fs.readFileSync(file, "utf8");
+
+        if (file.endsWith(".html")) {
+            htmlScriptPattern.lastIndex = 0;
+            let match;
+            let count = 0;
+            while ((match = htmlScriptPattern.exec(source)) !== null) {
+                count += 1;
+                new vm.Script(match[1], {
+                    filename: file + "#script-" + count
+                });
+            }
+            return;
+        }
+
+        new vm.Script(source, { filename: file });
+    } catch (error) {
+        failures.push({
+            file: path.relative(rootDir, file),
+            message: error.message
+        });
+    }
+});
+
+if (failures.length) {
+    failures.forEach(function (failure) {
+        console.error(failure.file + ": " + failure.message);
+    });
+    process.exit(1);
+}
+
+console.log("OK: checked " + files.length + " JS/HTML files");

package/scripts/package-integrity.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { MANIFEST_PATH, canonicalJson, listProtectedPaths, manifestPayload, protectedPath } = require("../lib/licensing/package-integrity");
+
+function decodePrivateKey(value) {
+    const normalized = String(value || "").trim().replace(/\\n/g, "\n");
+    if (!normalized) throw new Error("PACKAGE_INTEGRITY_PRIVATE_KEY or LICENSE_PRIVATE_KEY is required");
+    if (normalized.includes("BEGIN")) return crypto.createPrivateKey(normalized);
+    const decoded = Buffer.from(normalized, "base64");
+    const text = decoded.toString("utf8");
+    return text.includes("BEGIN") ? crypto.createPrivateKey(text) : crypto.createPrivateKey({ key: decoded, format: "der", type: "pkcs8" });
+}
+
+function createIntegrityManifest(packageRoot, privateKeyValue, keyId) {
+    const root = path.resolve(packageRoot);
+    const packageJson = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8").replace(/^\uFEFF/, ""));
+    const files = listProtectedPaths(root).map(function (relative) {
+        const bytes = fs.readFileSync(path.join(root, relative.replace(/\//g, path.sep)));
+        return { path: relative, sha256: crypto.createHash("sha256").update(bytes).digest("hex"), size: bytes.length };
+    });
+    const manifest = {
+        algorithm: "sha256",
+        files,
+        keyId: keyId || "v1",
+        package: { name: String(packageJson.name || ""), version: String(packageJson.version || "") },
+        schemaVersion: 1,
+        signatureAlgorithm: "Ed25519"
+    };
+    const signature = crypto.sign(null, Buffer.from(canonicalJson(manifestPayload(manifest)), "utf8"), decodePrivateKey(privateKeyValue)).toString("base64url");
+    const complete = Object.assign({}, manifest, { signature });
+    const target = path.join(root, MANIFEST_PATH.replace(/\//g, path.sep));
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(complete, null, 2) + "\n", "utf8");
+    return complete;
+}
+
+if (require.main === module) {
+    const root = path.resolve(process.argv[2] || path.join(__dirname, ".."));
+    const manifest = createIntegrityManifest(root, process.env.PACKAGE_INTEGRITY_PRIVATE_KEY || process.env.LICENSE_PRIVATE_KEY, process.env.PACKAGE_INTEGRITY_KEY_ID || "v1");
+    console.log("OK: signed " + manifest.files.length + " protected files in " + root);
+}
+
+module.exports = { createIntegrityManifest, decodePrivateKey, protectedPath };

package/scripts/package-release.js

@@ -0,0 +1,116 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const crypto = require("crypto");
+const { createIntegrityManifest } = require("./package-integrity");
+const { signTgzIntegrity } = require("./tgz-integrity");
+
+const root = path.resolve(__dirname, "..");
+const workspace = path.resolve(root, "..", "..", "..", "..");
+const versionsRoot = path.join(workspace, "Versiuni");
+const manifest = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8").replace(/^\uFEFF/, ""));
+const version = manifest.version;
+const nodeOutput = path.join(versionsRoot, "Versiuni Noduri", version);
+const stagingRoot = path.join(root, ".release-staging", version);
+const pnpm = process.argv[2] || "pnpm.cmd";
+const integrityPrivateKey = process.env.PACKAGE_INTEGRITY_PRIVATE_KEY || process.env.LICENSE_PRIVATE_KEY;
+if (!integrityPrivateKey) throw new Error("PACKAGE_INTEGRITY_PRIVATE_KEY or LICENSE_PRIVATE_KEY is required to build signed releases");
+
+function decodePrivateKey(value) {
+    const normalized = String(value || "").trim().replace(/\\n/g, "\n");
+    if (normalized.includes("BEGIN")) return crypto.createPrivateKey(normalized);
+    const decoded = Buffer.from(normalized, "base64");
+    const text = decoded.toString("utf8");
+    return text.includes("BEGIN") ? crypto.createPrivateKey(text) : crypto.createPrivateKey({ key: decoded, format: "der", type: "pkcs8" });
+}
+
+function configureIntegrityIdentity(packageRoot, privateKeyValue) {
+    const publicKey = crypto.createPublicKey(decodePrivateKey(privateKeyValue));
+    const pem = publicKey.export({ format: "pem", type: "spki" });
+    const fingerprint = crypto.createHash("sha256").update(publicKey.export({ format: "der", type: "spki" })).digest("hex");
+    const licensingRoot = path.join(packageRoot, "lib", "licensing");
+    fs.writeFileSync(path.join(licensingRoot, "public-key.pem"), pem, "utf8");
+    const verifierPath = path.join(licensingRoot, "package-integrity.js");
+    const source = fs.readFileSync(verifierPath, "utf8");
+    const rewritten = source.replace(/(v1:\s*")[a-f0-9]{64}(")/, "$1" + fingerprint + "$2");
+    if (rewritten === source && !source.includes('v1: "' + fingerprint + '"')) throw new Error("Cannot update the package integrity key pin");
+    fs.writeFileSync(verifierPath, rewritten, "utf8");
+}
+
+function runPack(cwd, output) {
+    const lowerPnpm = pnpm.toLowerCase();
+    const isCmd = lowerPnpm.endsWith(".cmd");
+    const pnpmModule = lowerPnpm.endsWith(".mjs") ? path.resolve(pnpm) : null;
+    const executable = isCmd ? (process.env.ComSpec || "cmd.exe") : (pnpmModule ? process.execPath : pnpm);
+    const packArgs = (pnpmModule ? [pnpmModule] : []).concat(["pack", "--out", output]);
+    const args = isCmd
+        ? ["/d", "/s", "/c", '"' + '"' + pnpm + '" pack --out "' + output + '""']
+        : packArgs;
+    const result = spawnSync(executable, args, {
+        cwd,
+        stdio: "inherit",
+        shell: false,
+        env: {
+            ...process.env,
+            pnpm_config_pm_on_fail: "ignore",
+            PATH: path.dirname(process.execPath) + path.delimiter + (process.env.PATH || "")
+        }
+    });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error("pnpm pack failed with exit code " + result.status);
+}
+
+function safeRemove(target) {
+    const resolved = path.resolve(target);
+    const requiredPrefix = path.resolve(root, ".release-staging") + path.sep;
+    if (!resolved.startsWith(requiredPrefix)) {
+        throw new Error("Refuz eliminarea in afara staging-ului: " + resolved);
+    }
+    fs.rmSync(resolved, { recursive: true, force: true });
+}
+
+fs.mkdirSync(versionsRoot, { recursive: true });
+fs.mkdirSync(nodeOutput, { recursive: true });
+fs.mkdirSync(stagingRoot, { recursive: true });
+
+const fullArchive = path.join(versionsRoot, manifest.name + "-" + version + ".tgz");
+configureIntegrityIdentity(root, integrityPrivateKey);
+createIntegrityManifest(root, integrityPrivateKey, process.env.PACKAGE_INTEGRITY_KEY_ID || "v1");
+runPack(root, fullArchive);
+signTgzIntegrity(fullArchive, integrityPrivateKey, process.env.PACKAGE_INTEGRITY_KEY_ID || "v1");
+
+for (const [nodeName, entryPoint] of Object.entries(manifest["node-red"].nodes)) {
+    if (nodeName === "atelier-license") continue;
+    const nodeFolder = entryPoint.split("/")[0];
+    const stage = path.join(stagingRoot, nodeName);
+    safeRemove(stage);
+    fs.mkdirSync(stage, { recursive: true });
+    fs.cpSync(path.join(root, nodeFolder), path.join(stage, nodeFolder), { recursive: true });
+    fs.cpSync(path.join(root, "lib"), path.join(stage, "lib"), { recursive: true });
+    fs.cpSync(path.join(root, "license"), path.join(stage, "license"), { recursive: true });
+    fs.copyFileSync(path.join(root, "README.md"), path.join(stage, "README.md"));
+
+    const nodeManifest = {
+        name: manifest.name + "-" + nodeName,
+        version,
+        description: manifest.description + " - " + nodeName,
+        private: manifest.private,
+        license: manifest.license,
+        keywords: manifest.keywords,
+        engines: manifest.engines,
+        files: [nodeFolder + "/**/*", "license/**/*", "lib/**/*", "README.md", "package.json"],
+        dependencies: manifest.dependencies,
+        "node-red": { nodes: { "atelier-license": "license/atelier-license.js", [nodeName]: entryPoint } }
+    };
+    fs.writeFileSync(path.join(stage, "package.json"), JSON.stringify(nodeManifest, null, 2) + "\n", "utf8");
+    configureIntegrityIdentity(stage, integrityPrivateKey);
+    createIntegrityManifest(stage, integrityPrivateKey, process.env.PACKAGE_INTEGRITY_KEY_ID || "v1");
+    const archive = path.join(nodeOutput, nodeManifest.name + "-" + version + ".tgz");
+    runPack(stage, archive);
+    signTgzIntegrity(archive, integrityPrivateKey, process.env.PACKAGE_INTEGRITY_KEY_ID || "v1");
+}
+
+safeRemove(stagingRoot);
+console.log("OK: release " + version + " -> " + fullArchive + " + " + (Object.keys(manifest["node-red"].nodes).length - 1) + " node archives");