@cyprnet/node-red-contrib-uibuilder-formgen 0.4.11

package/examples/schemas/Maintenance/maint_work_order.json

@@ -0,0 +1,134 @@
+{
+  "schemaVersion": "1.0",
+  "formId": "maint_work_order",
+  "title": "Maintenance - Work Order",
+  "description": "Create a work order for facility/equipment maintenance.",
+  "sections": [
+    {
+      "id": "request",
+      "title": "Request",
+      "fields": [
+        {
+          "id": "requestor_name",
+          "type": "text",
+          "label": "Requester Name",
+          "required": true
+        },
+        {
+          "id": "requestor_phone",
+          "type": "text",
+          "label": "Phone",
+          "validate": "phone"
+        },
+        {
+          "id": "requested_date",
+          "type": "date",
+          "label": "Requested Date",
+          "required": true
+        },
+        {
+          "id": "priority",
+          "type": "radio",
+          "label": "Priority",
+          "required": true,
+          "options": [
+            {
+              "value": "low",
+              "text": "Low"
+            },
+            {
+              "value": "normal",
+              "text": "Normal"
+            },
+            {
+              "value": "high",
+              "text": "High"
+            },
+            {
+              "value": "emergency",
+              "text": "Emergency"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "location",
+      "title": "Location",
+      "fields": [
+        {
+          "id": "site",
+          "type": "text",
+          "label": "Site/Building",
+          "required": true
+        },
+        {
+          "id": "room",
+          "type": "text",
+          "label": "Room/Area",
+          "required": true
+        },
+        {
+          "id": "asset_tag",
+          "type": "text",
+          "label": "Asset Tag (if applicable)"
+        }
+      ]
+    },
+    {
+      "id": "details",
+      "title": "Details",
+      "fields": [
+        {
+          "id": "category",
+          "type": "select",
+          "label": "Category",
+          "required": true,
+          "options": [
+            {
+              "value": "",
+              "text": "Select..."
+            },
+            {
+              "value": "plumbing",
+              "text": "Plumbing"
+            },
+            {
+              "value": "electrical",
+              "text": "Electrical"
+            },
+            {
+              "value": "hvac",
+              "text": "HVAC"
+            },
+            {
+              "value": "general",
+              "text": "General"
+            }
+          ]
+        },
+        {
+          "id": "description",
+          "type": "textarea",
+          "label": "Issue Description",
+          "rows": 4,
+          "required": true
+        },
+        {
+          "id": "estimated_cost",
+          "type": "number",
+          "label": "Estimated Cost (USD)",
+          "min": 0,
+          "step": 0.01
+        },
+        {
+          "id": "requires_shutdown",
+          "type": "checkbox",
+          "label": "Requires shutdown",
+          "defaultValue": false
+        }
+      ]
+    }
+  ],
+  "actions": []
+}

package/index.js

@@ -0,0 +1,12 @@
+/**
+ * PortalSmith FormGen - Node-RED module entry
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2026 CyprNet Solutions, LLC
+ */
+
+module.exports = function(RED) {
+  require("./nodes/portalsmith-license")(RED);
+  require("./nodes/uibuilder-formgen")(RED);
+};
+

package/lib/licensing.js

@@ -0,0 +1,254 @@
+/**
+ * PortalSmith FormGen Licensing (offline-first)
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2026 CyprNet Solutions, LLC
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const LICENSE_PREFIX = "PSLF1";
+const PRODUCT_ID = "portalsmith-formgen";
+
+// NOTE: This is a PUBLIC key (verification only). No private keys are stored in this repo.
+// Replace this PEM with your real PortalSmith FormGen license signing public key.
+// You may also override this at runtime using PORTALSMITH_LICENSE_PUBLIC_KEY_PEM (public key only).
+const DEFAULT_PUBLIC_KEY_PEM = [
+  "-----BEGIN PUBLIC KEY-----",
+  // PortalSmith FormGen Ed25519 public key (global signing key; verification only)
+  "MCowBQYDK2VwAyEAg0GNHxcE/kUWFQgcAeMJPYbI2w5JepQQmqLKJrhjAE4=",
+  "-----END PUBLIC KEY-----",
+].join("\n");
+
+function getVerifierPublicKey() {
+  const envPem = String(process.env.PORTALSMITH_LICENSE_PUBLIC_KEY_PEM || "").trim();
+  if (envPem) {
+    return { pem: envPem, source: "env" };
+  }
+  const envFile = String(process.env.PORTALSMITH_LICENSE_PUBLIC_KEY_PEM_FILE || "").trim();
+  if (envFile) {
+    try {
+      const p = path.isAbsolute(envFile) ? envFile : path.join(process.cwd(), envFile);
+      const pem = fs.readFileSync(p, "utf8");
+      if (String(pem || "").trim()) return { pem, source: "file" };
+    } catch (e) {
+      // fall through to embedded
+    }
+  }
+  return { pem: DEFAULT_PUBLIC_KEY_PEM, source: "embedded" };
+}
+
+function publicKeyFingerprint(pem) {
+  try {
+    const norm = String(pem || "").replace(/\r\n/g, "\n").trim();
+    return crypto.createHash("sha256").update(norm, "utf8").digest("hex").slice(0, 16);
+  } catch (e) {
+    return "";
+  }
+}
+
+function base64urlToBuffer(s) {
+  const str = String(s || "").trim();
+  if (!str) return Buffer.alloc(0);
+  const pad = str.length % 4 === 2 ? "==" : str.length % 4 === 3 ? "=" : "";
+  const b64 = str.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  return Buffer.from(b64, "base64");
+}
+
+function stableSortObjectKeys(obj) {
+  if (obj === null || obj === undefined) return obj;
+  if (Array.isArray(obj)) return obj.map(stableSortObjectKeys);
+  if (typeof obj !== "object") return obj;
+  const out = {};
+  Object.keys(obj)
+    .sort()
+    .forEach((k) => {
+      out[k] = stableSortObjectKeys(obj[k]);
+    });
+  return out;
+}
+
+function canonicalJson(obj) {
+  return JSON.stringify(stableSortObjectKeys(obj));
+}
+
+function parseLicenseKey(licenseString) {
+  const raw = String(licenseString || "").trim();
+  if (!raw) {
+    return { ok: false, reason: "missing" };
+  }
+
+  const parts = raw.split(".");
+  if (parts.length === 3 && parts[0] === LICENSE_PREFIX) {
+    parts.shift();
+  }
+  if (parts.length !== 2) {
+    return { ok: false, reason: "format_invalid", detail: "Expected PSLF1.<payload>.<sig> or <payload>.<sig>" };
+  }
+
+  let payload;
+  try {
+    const payloadBuf = base64urlToBuffer(parts[0]);
+    payload = JSON.parse(payloadBuf.toString("utf8"));
+  } catch (e) {
+    return { ok: false, reason: "payload_invalid" };
+  }
+
+  const signature = base64urlToBuffer(parts[1]);
+  if (!signature || signature.length < 32) {
+    return { ok: false, reason: "signature_invalid" };
+  }
+
+  return { ok: true, payload, signature };
+}
+
+function verifySignature(payload, signature, publicKeyPem) {
+  try {
+    const data = Buffer.from(canonicalJson(payload), "utf8");
+    // For Ed25519 in Node.js, algorithm is null.
+    return crypto.verify(null, data, publicKeyPem, signature);
+  } catch (e) {
+    return false;
+  }
+}
+
+function isLicenseValid(licenseObj, now = new Date()) {
+  if (!licenseObj || !licenseObj.ok) return { ok: false, reason: licenseObj?.reason || "invalid" };
+  const payload = licenseObj.payload || {};
+
+  if (payload.product !== PRODUCT_ID) return { ok: false, reason: "product_mismatch" };
+
+  if (payload.issuedAt) {
+    const issued = new Date(payload.issuedAt);
+    if (Number.isNaN(issued.getTime())) return { ok: false, reason: "issuedAt_invalid" };
+  }
+
+  if (payload.expiresAt) {
+    const exp = new Date(payload.expiresAt);
+    if (Number.isNaN(exp.getTime())) return { ok: false, reason: "expiresAt_invalid" };
+    if (now.getTime() > exp.getTime()) return { ok: false, reason: "expired" };
+  }
+
+  return { ok: true };
+}
+
+function normalizeFeatures(payloadFeatures) {
+  const f = payloadFeatures && typeof payloadFeatures === "object" ? payloadFeatures : {};
+  return {
+    removeWatermark: Boolean(f.removeWatermark),
+    customBranding: Boolean(f.customBranding),
+    emailExport: Boolean(f.emailExport),
+    multiServerProfiles: Boolean(f.multiServerProfiles),
+  };
+}
+
+function makeFreeResult(reason = "missing") {
+  return {
+    licensed: false,
+    tier: "FREE",
+    features: {
+      removeWatermark: false,
+      customBranding: false,
+      emailExport: false,
+      multiServerProfiles: false,
+    },
+    reason,
+    display: {
+      displayName: "Free (Watermarked)",
+      licensedTo: "",
+      expiresAt: "",
+    },
+    policy: {
+      watermark: true,
+      brandingLocked: true,
+    },
+  };
+}
+
+function makeLicensedResult(payload, features) {
+  const licensedTo = String(payload.licensedTo || "").trim();
+  const expiresAt = payload.expiresAt ? String(payload.expiresAt) : "";
+  const tier = String(payload.edition || "PRO").toUpperCase() === "PRO" ? "PRO" : "PRO";
+  const removeWatermark = Boolean(features.removeWatermark);
+  const customBranding = Boolean(features.customBranding);
+  return {
+    licensed: true,
+    tier,
+    features: {
+      removeWatermark,
+      customBranding,
+      emailExport: Boolean(features.emailExport),
+      multiServerProfiles: Boolean(features.multiServerProfiles),
+    },
+    reason: "ok",
+    display: {
+      displayName: licensedTo ? `Licensed: ${licensedTo}` : "Licensed",
+      licensedTo,
+      expiresAt,
+    },
+    policy: {
+      watermark: !removeWatermark,
+      brandingLocked: !customBranding,
+    },
+  };
+}
+
+// Basic cache so we don't re-verify on every msg
+let _cache = {
+  key: "",
+  result: makeFreeResult("missing"),
+  checkedAt: 0,
+};
+
+function resolveLicenseString(licenseString, now = new Date()) {
+  const key = String(licenseString || "").trim();
+  const parsed = parseLicenseKey(key);
+  if (!parsed.ok) return makeFreeResult(parsed.reason);
+
+  const publicKeyPem = getVerifierPublicKey().pem;
+  const sigOk = verifySignature(parsed.payload, parsed.signature, publicKeyPem);
+  if (!sigOk) return makeFreeResult("signature_invalid");
+
+  const valid = isLicenseValid(parsed, now);
+  if (!valid.ok) return makeFreeResult(valid.reason);
+
+  const features = normalizeFeatures(parsed.payload.features);
+  return makeLicensedResult(parsed.payload, features);
+}
+
+function resolveLicense({ node, RED, licenseConfigNode, cacheTtlMs = 5 * 60 * 1000 } = {}) {
+  const now = Date.now();
+
+  const fromNodeCred = String(node?.credentials?.licenseKey || "").trim();
+  const fromConfigCred = String(licenseConfigNode?.credentials?.licenseKey || "").trim();
+  const fromEnv = String(process.env.PORTALSMITH_LICENSE || "").trim();
+
+  const key = fromNodeCred || fromConfigCred || fromEnv || "";
+
+  if (_cache.key === key && now - _cache.checkedAt < cacheTtlMs) {
+    return _cache.result;
+  }
+
+  const result = resolveLicenseString(key, new Date(now));
+  _cache = { key, result, checkedAt: now };
+  return result;
+}
+
+module.exports = {
+  LICENSE_PREFIX,
+  PRODUCT_ID,
+  DEFAULT_PUBLIC_KEY_PEM,
+  getVerifierPublicKey,
+  publicKeyFingerprint,
+  parseLicenseKey,
+  verifySignature,
+  isLicenseValid,
+  resolveLicenseString,
+  resolveLicense,
+};
+
+

package/nodes/portalsmith-license.html

@@ -0,0 +1,40 @@
+<script type="text/javascript">
+  RED.nodes.registerType('portalsmith-license', {
+    category: 'config',
+    defaults: {
+      name: { value: "PortalSmith License" }
+    },
+    credentials: {
+      licenseKey: { type: "password" }
+    },
+    label: function () {
+      return this.name || "PortalSmith License";
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="portalsmith-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" placeholder="PortalSmith License" />
+  </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" placeholder="PSLF1.<payload>.<signature>" />
+  </div>
+
+  <div class="form-tips">
+    Paste the license string provided by PortalSmith/CyprNet. Leave blank for Free (watermarked) mode.
+    Keys are stored in the Node-RED credentials store (encrypted at rest when credentialsSecret is set).
+  </div>
+</script>
+
+<script type="text/markdown" data-help-name="portalsmith-license">
+Stores a PortalSmith FormGen license key in the Node-RED credentials store for reuse across multiple `uibuilder-formgen` nodes.
+
+- If no key is provided, nodes operate in **Free (watermarked)** mode.
+- Licensing is **offline-first**: no phone-home and no external services.
+</script>
+
+

package/nodes/portalsmith-license.js

@@ -0,0 +1,23 @@
+/**
+ * PortalSmith FormGen - License Config Node
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2026 CyprNet Solutions, LLC
+ */
+
+"use strict";
+
+module.exports = function (RED) {
+  function PortalSmithLicenseNode(config) {
+    RED.nodes.createNode(this, config);
+    this.name = config.name || "PortalSmith License";
+  }
+
+  RED.nodes.registerType("portalsmith-license", PortalSmithLicenseNode, {
+    credentials: {
+      licenseKey: { type: "password" },
+    },
+  });
+};
+
+