node-red-contrib-vectorprime 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# node-red-contrib-vectorprime
+
+Official VectorPrime Decision Kernel node for Node-RED.
+
+This node sends a decision request to VectorPrime and returns a ranked result.
+
+---
+
+## ✅ What this node does
+
+- **Input:** `msg.payload` (your decision request JSON)
+- **Output:** `msg.payload` (VectorPrime response JSON)
+
+---
+
+## ✅ Quick Start
+
+### Endpoint
+
+`/v1/kernel/rank`
+
+---
+
+## ✅ How to use in Node-RED
+
+### 1) Drag these nodes into your flow:
+
+- **Inject**
+- **VectorPrime**
+- **Debug**
+
+### 2) Connect them like this:
+
+Inject → VectorPrime → Debug
+
+### 3) Configure the VectorPrime node
+
+Double-click the **VectorPrime** node, then:
+
+✅ Paste your VectorPrime API key into the node field  
+(or use the **Get Free Key** button if enabled)
+
+### 4) Run it
+
+1. Click **Deploy**
+2. Press the **Inject** button
+3. View output in the **Debug** sidebar
+
+---
+
+## ✅ Example Inject Payload
+
+### IMPORTANT:
+Your Inject node must send a JSON object inside `msg.payload`.
+
+Set your Inject node payload type to **JSON** and paste this:
+
+```json
+{
+  "decision_id": "node-red-demo-001",
+  "prompt": "Pick one.",
+  "options": [
+    { "id": "a", "label": "Option A" },
+    { "id": "b", "label": "Option B" }
+  ],
+  "engine": "classical",
+  "seed": 123
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "node-red-contrib-vectorprime",
+  "version": "0.1.0",
+  "description": "VectorPrime Decision Kernel node for Node-RED",
+  "main": "index.js",
+  "license": "MIT",
+  "keywords": [
+    "node-red",
+    "vectorprime",
+    "decision",
+    "ranking",
+    "kernel"
+  ],
+  "node-red": {
+    "nodes": {
+      "vectorprime": "vectorprime.js"
+    }
+  },
+  "dependencies": {
+    "node-fetch": "^2.6.7"
+  }
+}

package/vectorprime.html

@@ -0,0 +1,147 @@
+<script type="text/html" data-template-name="vectorprime-config">
+  <div class="form-row">
+    <label for="node-config-input-baseUrl">
+      <i class="fa fa-globe"></i> Base URL
+    </label>
+    <input type="text" id="node-config-input-baseUrl" placeholder="https://vectorprime-kernel-backend.onrender.com">
+  </div>
+
+  <div class="form-row">
+    <label for="node-config-input-apiKey">
+      <i class="fa fa-key"></i> API Key
+    </label>
+    <input type="password" id="node-config-input-apiKey" placeholder="vp_free_...">
+  </div>
+
+  <div class="form-row">
+    <button id="vp-get-free-key" class="red-ui-button">
+      Get Free Key
+    </button>
+    <span id="vp-key-status" style="margin-left:10px; font-size:12px;"></span>
+  </div>
+
+  <div class="form-row">
+    <div style="font-size:12px; color:#666;">
+      ✅ Key is stored securely in Node-RED credentials (not exported with flows).
+    </div>
+  </div>
+</script>
+
+<script type="text/javascript">
+    (function () {
+        function normalizeBaseUrl(url) {
+            url = (url || "").trim();
+            if (!url) return "";
+            // Remove trailing slash
+            if (url.endsWith("/")) url = url.slice(0, -1);
+            return url;
+        }
+
+        RED.nodes.registerType("vectorprime-config", {
+            category: "config",
+            defaults: {
+                baseUrl: { value: "https://vectorprime-kernel-backend.onrender.com", required: true }
+            },
+            credentials: {
+                apiKey: { type: "password" }
+            },
+            label: function () {
+                return "VectorPrime Config";
+            },
+            oneditprepare: function () {
+                const statusEl = document.getElementById("vp-key-status");
+                const btn = document.getElementById("vp-get-free-key");
+
+                btn.onclick = async function (e) {
+                    e.preventDefault();
+                    statusEl.textContent = "Requesting free key...";
+                    statusEl.style.color = "#444";
+
+                    try {
+                        const baseUrlInput = document.getElementById("node-config-input-baseUrl");
+                        const apiKeyInput = document.getElementById("node-config-input-apiKey");
+
+                        const baseUrl = normalizeBaseUrl(baseUrlInput.value);
+
+                        if (!baseUrl.startsWith("http")) {
+                            statusEl.textContent = "❌ Base URL missing/invalid";
+                            statusEl.style.color = "red";
+                            return;
+                        }
+
+                        // Call backend directly from the editor
+                        const resp = await fetch(`${baseUrl}/v1/keys/free`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({ source: "node-red" })
+                        });
+
+                        const text = await resp.text();
+                        let data;
+                        try { data = JSON.parse(text); } catch { data = { raw: text }; }
+
+                        if (!resp.ok) {
+                            statusEl.textContent = `❌ Failed (${resp.status}): ${data.message || data.error || "unknown"}`;
+                            statusEl.style.color = "red";
+                            return;
+                        }
+
+                        if (!data.api_key) {
+                            statusEl.textContent = "❌ Backend did not return api_key";
+                            statusEl.style.color = "red";
+                            return;
+                        }
+
+                        apiKeyInput.value = data.api_key;
+                        statusEl.textContent = "✅ Free key generated + saved";
+                        statusEl.style.color = "green";
+                    } catch (err) {
+                        statusEl.textContent = `❌ Error: ${err.message}`;
+                        statusEl.style.color = "red";
+                    }
+                };
+            }
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="vectorprime-rank">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="VectorPrime Rank">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-config"><i class="fa fa-cog"></i> Config</label>
+    <input type="text" id="node-input-config">
+  </div>
+
+  <div class="form-row">
+    <label for="node-input-endpoint"><i class="fa fa-link"></i> Endpoint</label>
+    <input type="text" id="node-input-endpoint" placeholder="/v1/kernel/rank">
+  </div>
+
+  <div class="form-row">
+    <div style="font-size:12px; color:#666;">
+      ✅ This node sends <code>msg.payload</code> to VectorPrime and returns the response in <code>msg.payload</code>.
+    </div>
+  </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("vectorprime-rank", {
+        category: "VectorPrime",
+        color: "#2563EB",   // ✅ FIX: readable (NOT black)
+        defaults: {
+            name: { value: "" },
+            config: { type: "vectorprime-config", required: true },
+            endpoint: { value: "/v1/kernel/rank", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-bolt",
+        label: function () {
+            return this.name || "VectorPrime Rank";
+        }
+    });
+</script>

package/vectorprime.js

@@ -0,0 +1,138 @@
+module.exports = function (RED) {
+    const fetch = (...args) =>
+        import("node-fetch").then(({ default: fetch }) => fetch(...args));
+
+    function normalizeBaseUrl(url) {
+        url = (url || "").trim();
+        if (!url) return "";
+        if (url.endsWith("/")) url = url.slice(0, -1);
+        return url;
+    }
+
+    function normalizeEndpoint(path) {
+        path = (path || "").trim();
+        if (!path.startsWith("/")) path = "/" + path;
+        return path;
+    }
+
+    // ✅ REQUIRED: runtime config node registration
+    function VectorPrimeConfigNode(n) {
+        RED.nodes.createNode(this, n);
+
+        // baseUrl stored in node settings (non-credential)
+        this.baseUrl = n.baseUrl || "https://vectorprime-kernel-backend.onrender.com";
+    }
+
+    // ✅ IMPORTANT: credentials must be declared here too
+    RED.nodes.registerType("vectorprime-config", VectorPrimeConfigNode, {
+        credentials: {
+            apiKey: { type: "password" },
+        },
+    });
+
+    // ✅ Main node
+    function VectorPrimeRankNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name;
+        node.endpoint = config.endpoint || "/v1/kernel/rank";
+
+        const cfg = RED.nodes.getNode(config.config);
+
+        node.on("input", async function (msg, send, done) {
+            try {
+                if (!cfg) {
+                    node.status({ fill: "red", shape: "ring", text: "missing config" });
+                    throw new Error(
+                        "VectorPrime config missing. Open node settings and set Config."
+                    );
+                }
+
+                const baseUrl = normalizeBaseUrl(cfg.baseUrl);
+                const endpoint = normalizeEndpoint(node.endpoint);
+
+                if (!baseUrl.startsWith("http")) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid base url" });
+                    throw new Error(`Base URL missing/invalid: ${baseUrl}`);
+                }
+
+                msg.headers = msg.headers || {};
+                const incomingAuth =
+                    msg.headers.authorization ||
+                    msg.headers.Authorization ||
+                    "";
+
+                const storedKey =
+                    cfg.credentials && cfg.credentials.apiKey
+                        ? String(cfg.credentials.apiKey).trim()
+                        : "";
+
+                // If user didn't provide Authorization, use stored key
+                if (!incomingAuth) {
+                    if (!storedKey) {
+                        node.status({ fill: "red", shape: "ring", text: "missing api key" });
+                        throw new Error(
+                            "No API key. Open VectorPrime Config and click 'Get Free Key'."
+                        );
+                    }
+                    msg.headers.Authorization = `Bearer ${storedKey}`;
+                }
+
+                msg.headers["Content-Type"] = "application/json";
+
+                const payload = msg.payload || {};
+
+                node.status({ fill: "blue", shape: "dot", text: "ranking..." });
+
+                const resp = await fetch(`${baseUrl}${endpoint}`, {
+                    method: "POST",
+                    headers: msg.headers,
+                    body: JSON.stringify(payload),
+                });
+
+                const text = await resp.text();
+                let data;
+                try {
+                    data = JSON.parse(text);
+                } catch {
+                    data = { raw: text };
+                }
+
+                // If free tier limit hit → return upgrade url inside Node-RED
+                if (!resp.ok) {
+                    const upgradeUrl = data.upgrade_url || data.checkout_url || null;
+
+                    if (resp.status === 402 && upgradeUrl) {
+                        node.status({
+                            fill: "yellow",
+                            shape: "ring",
+                            text: "limit reached → upgrade",
+                        });
+                        msg.payload = data;
+                        msg.vectorprime = { upgrade_url: upgradeUrl };
+                        send(msg);
+                        done();
+                        return;
+                    }
+
+                    node.status({ fill: "red", shape: "ring", text: `error ${resp.status}` });
+                    msg.payload = data;
+                    send(msg);
+                    done();
+                    return;
+                }
+
+                node.status({ fill: "green", shape: "dot", text: "ok" });
+                msg.payload = data;
+                send(msg);
+                done();
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "failed" });
+                done(err);
+            }
+        });
+    }
+
+    RED.nodes.registerType("vectorprime-rank", VectorPrimeRankNode);
+};