@tier0/opcua-client 0.1.0

package/nodes/subscribe.js

@@ -0,0 +1,285 @@
+'use strict';
+
+const { messagePoints } = require('../lib/points');
+
+module.exports = function registerSubscribeNode(RED) {
+  function OpcUaSubscribeNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.connection = RED.nodes.getNode(config.connection);
+    node.subscriptionId = null;
+    node.desired = new Map();
+    node.monitored = new Map();
+    node.reconnectTimer = null;
+    node.reconcileChain = Promise.resolve();
+    node.reconcileAttempt = 0;
+    node.lastSessionGeneration = 0;
+    node.lastRecoveryReason = '';
+    node.closing = false;
+    node.lastDiagnostics = {};
+    node.lastDropped = 0;
+    node.lastStatusAt = 0;
+
+    const batchSize = Number(config.batchSize) || 500;
+
+    function emitBatch(batch) {
+      const diagnostics = batch.diagnostics || {};
+      const results = batch.changes || [];
+      for (const change of results) {
+        const point = node.desired.get(change.nodeId);
+        if (!point) continue;
+        for (const key in point) {
+          if (!Object.hasOwn(change, key)) change[key] = point[key];
+        }
+      }
+      node.lastDiagnostics = diagnostics;
+      const dropped = Number(diagnostics.dropped) || 0;
+      if (dropped > node.lastDropped) {
+        node.warn(`OPC UA notification queue dropped ${dropped - node.lastDropped} change(s); total ${dropped}`);
+      }
+      node.lastDropped = dropped;
+
+      if (results.length) {
+        if ((config.outputMode || 'batch') === 'batch') {
+          node.send({
+            payload: results,
+            opcua: { operation: 'change', total: results.length, queue: diagnostics },
+          });
+        } else {
+          results.forEach((result, index) => node.send({
+            topic: result.nodeId,
+            payload: result.value,
+            opcua: index === 0 ? { ...result, queue: diagnostics } : result,
+          }));
+        }
+      }
+
+      const now = Date.now();
+      if (dropped > 0 || now - node.lastStatusAt >= 1000) {
+        node.lastStatusAt = now;
+        node.status({
+          fill: dropped > 0 ? 'yellow' : 'green',
+          shape: dropped > 0 ? 'ring' : 'dot',
+          text: `${node.monitored.size} monitored q:${diagnostics.queueDepth || 0}/${diagnostics.queueCapacity || 0}`,
+        });
+      }
+    }
+
+    async function ensureSubscription() {
+      if (node.subscriptionId != null) return;
+      const result = await node.connection.client.createSubscription({
+        publishingInterval: Number(config.publishingInterval) || 1000,
+        lifetimeCount: Number(config.lifetimeCount) || 120,
+        maxKeepAliveCount: Number(config.maxKeepAliveCount) || 10,
+        maxNotificationsPerPublish: Number(config.maxNotificationsPerPublish) || 0,
+        callbackQueueSize: Number(config.callbackQueueSize) || 10000,
+        callbackBatchSize: Number(config.callbackBatchSize) || 500,
+        queueMode: config.queueMode || 'all',
+        overflowPolicy: config.overflowPolicy || 'drop-oldest',
+      }, emitBatch);
+      node.subscriptionId = result.subscriptionId;
+    }
+
+    async function createMonitoredItems(points) {
+      if (!points.length) return [];
+      const results = await node.connection.client.addMonitoredItems(
+        node.subscriptionId,
+        points,
+        {
+          samplingInterval: Number(config.samplingInterval) || 1000,
+          queueSize: Number(config.queueSize) || 10,
+          discardOldest: config.discardOldest !== false,
+          deadbandType: config.deadbandType || 'none',
+          deadbandValue: Number(config.deadbandValue) || 0,
+        },
+        batchSize
+      );
+      results.forEach((result) => {
+        if (result.statusCode === 'Good') node.monitored.set(result.nodeId, result.monitoredItemId);
+      });
+      return results;
+    }
+
+    async function reconcileSubscription(reason = 'state') {
+      if (node.closing) return;
+      if (!node.desired.size) {
+        if (node.subscriptionId != null) await clearSubscription(true);
+        return;
+      }
+
+      let rebuilt = false;
+      if (node.subscriptionId != null) {
+        const validation = await node.connection.client.validateSubscription(node.subscriptionId);
+        if (!validation.valid) {
+          try {
+            await node.connection.client.deleteSubscription(node.subscriptionId);
+          } catch {}
+          node.subscriptionId = null;
+          node.monitored.clear();
+          rebuilt = true;
+        }
+      }
+
+      await ensureSubscription();
+      const removals = [];
+      for (const [nodeId, monitoredItemId] of node.monitored) {
+        if (!node.desired.has(nodeId)) removals.push({ nodeId, monitoredItemId });
+      }
+      if (removals.length) {
+        const results = await node.connection.client.removeMonitoredItems(
+          node.subscriptionId,
+          removals.map((item) => item.monitoredItemId),
+          batchSize
+        );
+        results.forEach((result, index) => {
+          if (result.statusCode === 'Good') node.monitored.delete(removals[index].nodeId);
+        });
+      }
+
+      const additions = [...node.desired.values()].filter(
+        (point) => !node.monitored.has(point.nodeId)
+      );
+      const results = await createMonitoredItems(additions);
+      const failed = results.filter((result) => result.statusCode !== 'Good');
+      if (failed.length) throw new Error(`${failed.length} monitored item(s) failed to recover`);
+
+      node.reconcileAttempt = 0;
+      node.status({ fill: 'green', shape: 'dot', text: `${node.monitored.size} monitored` });
+      if (reason !== 'command') {
+        node.send({
+          payload: {
+            command: 'recover',
+            desired: node.desired.size,
+            monitored: node.monitored.size,
+            subscriptionId: node.subscriptionId,
+            rebuilt,
+            reason,
+          },
+          opcua: {
+            operation: 'subscription-status',
+            recovered: true,
+            rebuilt,
+            reason,
+            sessionGeneration: node.lastSessionGeneration,
+            dataGapPossible: rebuilt,
+          },
+        });
+      }
+    }
+
+    async function clearSubscription(keepDesired = false) {
+      if (!keepDesired) node.desired.clear();
+      if (node.subscriptionId != null) {
+        await node.connection.client.deleteSubscription(node.subscriptionId);
+      }
+      node.subscriptionId = null;
+      node.monitored.clear();
+    }
+
+    async function replacePoints(points) {
+      node.desired = new Map(points.map((point) => [point.nodeId, point]));
+      await clearSubscription(true);
+      await reconcileSubscription('command');
+    }
+
+    function runSerialized(task) {
+      const run = node.reconcileChain.catch(() => {}).then(task);
+      node.reconcileChain = run;
+      return run;
+    }
+
+    function scheduleReconnect(reason = 'connection-state', immediate = false) {
+      if (node.closing || node.reconnectTimer) return;
+      const base = Math.max(100, Number(config.reconnectInterval) || 5000);
+      const delay = immediate ? 0 : Math.min(30000, base * (2 ** node.reconcileAttempt));
+      node.reconcileAttempt += 1;
+      node.lastRecoveryReason = reason;
+      node.reconnectTimer = setTimeout(async () => {
+        node.reconnectTimer = null;
+        try {
+          await runSerialized(() => reconcileSubscription(reason));
+        } catch (error) {
+          node.warn(`OPC UA resubscribe failed: ${error.message}`);
+          node.status({ fill: 'yellow', shape: 'ring', text: 'waiting to recover' });
+          scheduleReconnect(reason);
+        }
+      }, delay);
+    }
+
+    const onFault = () => scheduleReconnect('service-fault');
+    const onState = (state) => {
+      if (!state || node.closing) return;
+      if (Number(state.sessionGeneration) > 0) {
+        node.lastSessionGeneration = Number(state.sessionGeneration);
+      }
+      if (state.state === 'connected') {
+        scheduleReconnect(state.reason || 'connected', true);
+      } else if (state.state === 'subscription-inactive' &&
+                 (!state.subscriptionId || state.subscriptionId === node.subscriptionId)) {
+        node.status({ fill: 'yellow', shape: 'ring', text: 'subscription inactive' });
+        scheduleReconnect('subscription-inactive');
+      } else if (['reconnecting', 'backoff', 'failed'].includes(state.state)) {
+        node.status({ fill: 'yellow', shape: 'ring', text: state.state });
+      }
+    };
+    node.connection?.client.on('fault', onFault);
+    node.connection?.client.on('state', onState);
+
+    node.on('input', async (msg, send, done) => {
+      if (!node.connection) return done(new Error('OPC UA connection not configured'));
+      try {
+        const command = msg.opcua?.command || 'replace';
+        const points = command === 'clear' ? [] : messagePoints(msg, config.nodeId, {
+          samplingInterval: Number(config.samplingInterval) || 1000,
+          queueSize: Number(config.queueSize) || 10,
+          discardOldest: config.discardOldest !== false,
+        });
+
+        node.status({ fill: 'blue', shape: 'dot', text: `${command} ${points.length}` });
+        await runSerialized(async () => {
+          if (command === 'replace') await replacePoints(points);
+          else if (command === 'add') {
+            points.forEach((point) => node.desired.set(point.nodeId, point));
+            await reconcileSubscription('command');
+          } else if (command === 'remove') {
+            points.forEach((point) => node.desired.delete(point.nodeId));
+            await reconcileSubscription('command');
+          } else if (command === 'clear') await clearSubscription();
+          else throw new Error(`Unsupported subscription command: ${command}`);
+        });
+
+        node.status({ fill: 'green', shape: 'dot', text: `${node.monitored.size} monitored` });
+        send({
+          ...msg,
+          payload: {
+            command,
+            desired: node.desired.size,
+            monitored: node.monitored.size,
+            subscriptionId: node.subscriptionId,
+          },
+          opcua: { operation: 'subscription-status' },
+        });
+        done();
+      } catch (error) {
+        node.status({ fill: 'red', shape: 'ring', text: error.message });
+        done(error);
+      }
+    });
+
+    node.on('close', async (done) => {
+      node.closing = true;
+      if (node.reconnectTimer) clearTimeout(node.reconnectTimer);
+      node.connection?.client.off('fault', onFault);
+      node.connection?.client.off('state', onState);
+      node.desired.clear();
+      try {
+        await clearSubscription();
+      } catch (error) {
+        node.warn(`OPC UA subscription cleanup failed: ${error.message}`);
+      }
+      done();
+    });
+  }
+
+  RED.nodes.registerType('tier0-opcua-subscribe', OpcUaSubscribeNode);
+};

package/nodes/write.html

@@ -0,0 +1,209 @@
+<style>
+  .opcua-advanced { margin: 8px 0 12px; }
+  .opcua-advanced summary { cursor: pointer; font-weight: 600; padding: 6px 0; }
+  .opcua-point-editor { box-sizing: border-box; display: inline-block; vertical-align: top; width: calc(100% - 110px); }
+  .opcua-point-toolbar { display: flex; gap: 6px; margin-bottom: 8px; }
+  .opcua-write-point-add { display: grid; gap: 6px; grid-template-columns: minmax(180px, 2fr) minmax(90px, 1fr) 110px auto; margin-bottom: 8px; }
+  .opcua-write-point-add input, .opcua-write-point-add select { min-width: 0; width: 100%; }
+  .opcua-point-list { border: 1px solid var(--red-ui-form-input-border-color, #ccc); border-radius: 2px; box-sizing: border-box; height: 180px; list-style: none; margin: 0 !important; overflow: auto; padding: 0 !important; width: 100%; }
+  .opcua-point-list li { align-items: center; border-bottom: 1px solid var(--red-ui-secondary-border-color, #eee); display: flex; gap: 8px; min-height: 34px; padding: 4px 8px; }
+  .opcua-point-list li:last-child { border-bottom: 0; }
+  .opcua-point-list .opcua-point-text { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .opcua-point-list .opcua-point-empty { color: var(--red-ui-form-placeholder-color, #888); justify-content: center; }
+  .opcua-point-list .opcua-point-remove { border: 0; color: var(--red-ui-text-color, #555); flex: 0 0 auto; }
+  .opcua-point-status { color: var(--red-ui-form-text-color, #666); font-size: 0.9em; margin-top: 5px; }
+</style>
+<script type="text/html" data-template-name="tier0-opcua-write">
+  <div class="form-row"><label for="node-input-connection">Connection</label><input type="text" id="node-input-connection"></div>
+  <input type="hidden" id="node-input-nodeId">
+  <input type="hidden" id="node-input-pointList">
+  <input type="hidden" id="node-input-pointListFileName">
+  <input type="file" id="node-input-pointFile" accept=".json,.csv,application/json,text/csv" style="display:none">
+  <div class="form-row">
+    <label>Points</label>
+    <div class="opcua-point-editor">
+      <div class="opcua-point-toolbar">
+        <button type="button" class="red-ui-button" id="node-input-importPointList"><i class="fa fa-upload"></i> Import</button>
+        <button type="button" class="red-ui-button" id="node-input-clearPointList"><i class="fa fa-trash"></i> Clear all</button>
+      </div>
+      <div class="opcua-write-point-add">
+        <input type="text" id="node-input-newPointNodeId" placeholder="NodeId">
+        <input type="text" id="node-input-newPointValue" placeholder="Value">
+        <select id="node-input-newPointDataType"><option>String</option><option>Boolean</option><option>SByte</option><option>Byte</option><option>Int16</option><option>UInt16</option><option>Int32</option><option>UInt32</option><option>Int64</option><option>UInt64</option><option>Float</option><option>Double</option><option>DateTime</option><option>ByteString</option></select>
+        <button type="button" class="red-ui-button" id="node-input-addPoint"><i class="fa fa-plus"></i> Add</button>
+      </div>
+      <ol class="opcua-point-list" id="node-input-pointListItems"></ol>
+      <div class="opcua-point-status" id="node-input-pointListStatus">0 points</div>
+    </div>
+  </div>
+  <details class="opcua-advanced">
+    <summary>Advanced settings</summary>
+    <div class="form-row"><label for="node-input-dataType">Default type</label><select id="node-input-dataType"><option>String</option><option>Boolean</option><option>SByte</option><option>Byte</option><option>Int16</option><option>UInt16</option><option>Int32</option><option>UInt32</option><option>Int64</option><option>UInt64</option><option>Float</option><option>Double</option><option>DateTime</option><option>ByteString</option></select></div>
+    <div class="form-row"><label for="node-input-batchSize">Batch size</label><input type="number" id="node-input-batchSize"></div>
+    <div class="form-row"><label for="node-input-outputMode">Output</label><select id="node-input-outputMode"><option value="batch">Batch</option><option value="split">One message per point</option></select></div>
+  </details>
+  <div class="form-row"><label for="node-input-name">Name</label><input type="text" id="node-input-name"></div>
+</script>
+<script type="text/html" data-help-name="tier0-opcua-write">
+  <p>Add NodeId, value, and data type rows or import JSON/CSV. Imported points are parsed and shown in the same list.</p>
+  <p>CSV requires <code>nodeId</code> and <code>value</code>; <code>dataType</code> is optional. A JSON/CSV point list may also arrive dynamically in <code>msg.payload</code>.</p>
+</script>
+<script type="text/javascript">
+  RED.nodes.registerType('tier0-opcua-write', {
+    category: 'OPC UA', color: '#c7e9f1', inputs: 1, outputs: 1, icon: 'bridge.png',
+    defaults: {
+      connection: { value: '', type: 'tier0-opcua-connection', required: true },
+      nodeId: { value: '' }, dataType: { value: 'String' },
+      pointList: { value: '' }, pointListFileName: { value: '' },
+      batchSize: { value: 500, validate: RED.validators.number() },
+      outputMode: { value: 'batch' }, name: { value: '' }
+    },
+    oneditprepare: function () {
+      const points = new Map();
+
+      const csvLine = (line) => {
+        const fields = [];
+        let value = '';
+        let quoted = false;
+        for (let index = 0; index < line.length; index += 1) {
+          const character = line[index];
+          if (character === '"') {
+            if (quoted && line[index + 1] === '"') { value += '"'; index += 1; }
+            else quoted = !quoted;
+          } else if (character === ',' && !quoted) {
+            fields.push(value.trim()); value = '';
+          } else value += character;
+        }
+        fields.push(value.trim());
+        return fields;
+      };
+
+      const parse = (content) => {
+        const text = String(content || '').replace(/^\uFEFF/, '').trim();
+        if (!text) return [];
+        if (text.startsWith('[') || text.startsWith('{')) {
+          const parsed = JSON.parse(text);
+          return Array.isArray(parsed) ? parsed : (Array.isArray(parsed.items) ? parsed.items : [parsed]);
+        }
+        const lines = text.split(/\r?\n/).filter((line) => line.trim() && !line.trimStart().startsWith('#'));
+        if (!lines.length) return [];
+        const headers = csvLine(lines.shift());
+        if (!headers.includes('nodeId')) throw new Error('CSV header must contain nodeId');
+        if (!headers.includes('value')) throw new Error('CSV header must contain value');
+        return lines.map((line) => {
+          const values = csvLine(line);
+          return Object.fromEntries(headers.map((header, index) => [header, values[index] || '']));
+        });
+      };
+
+      const normalize = (item) => {
+        const source = typeof item === 'string' ? { nodeId: item } : { ...(item || {}) };
+        source.nodeId = String(source.nodeId || source.topic || '').trim();
+        if (!source.nodeId) throw new Error('Point is missing nodeId');
+        if (!Object.prototype.hasOwnProperty.call(source, 'value')) source.useInput = true;
+        source.dataType = String(source.dataType || $('#node-input-dataType').val() || 'String');
+        return source;
+      };
+
+      const valueText = (value) => {
+        if (typeof value === 'string') return value;
+        try { return JSON.stringify(value); } catch (_) { return String(value); }
+      };
+
+      const persist = () => {
+        const items = [...points.values()];
+        $('#node-input-pointList').val(items.length ? JSON.stringify(items) : '');
+        if (items.length) $('#node-input-nodeId').val('');
+        $('#node-input-pointListStatus').text(`${items.length} point${items.length === 1 ? '' : 's'}`);
+      };
+
+      const render = () => {
+        const list = document.getElementById('node-input-pointListItems');
+        list.textContent = '';
+        if (!points.size) {
+          const empty = document.createElement('li');
+          empty.className = 'opcua-point-empty';
+          empty.textContent = 'No points. Add a write item or import a file.';
+          list.appendChild(empty);
+        } else {
+          const fragment = document.createDocumentFragment();
+          points.forEach((point, nodeId) => {
+            const row = document.createElement('li');
+            const text = document.createElement('span');
+            text.className = 'opcua-point-text';
+            const shownValue = point.useInput ? '<from msg.payload>' : valueText(point.value);
+            text.textContent = `${nodeId} = ${shownValue} (${point.dataType})`;
+            text.title = text.textContent;
+            const remove = document.createElement('button');
+            remove.type = 'button';
+            remove.className = 'red-ui-button opcua-point-remove';
+            remove.title = `Remove ${nodeId}`;
+            remove.innerHTML = '<i class="fa fa-times"></i>';
+            remove.addEventListener('click', () => { points.delete(nodeId); render(); });
+            row.append(text, remove);
+            fragment.appendChild(row);
+          });
+          list.appendChild(fragment);
+        }
+        persist();
+      };
+
+      const merge = (items) => {
+        items.forEach((item) => { const point = normalize(item); points.set(point.nodeId, point); });
+        render();
+      };
+
+      try {
+        const stored = $('#node-input-pointList').val();
+        if (stored) merge(parse(stored));
+        else if ($('#node-input-nodeId').val()) merge([{
+          nodeId: $('#node-input-nodeId').val(),
+          dataType: $('#node-input-dataType').val(),
+          useInput: true
+        }]);
+        else render();
+      } catch (error) {
+        RED.notify(`Cannot load point list: ${error.message}`, 'error');
+        render();
+      }
+
+      $('#node-input-addPoint').on('click', () => {
+        try {
+          merge([{
+            nodeId: $('#node-input-newPointNodeId').val(),
+            value: $('#node-input-newPointValue').val(),
+            dataType: $('#node-input-newPointDataType').val()
+          }]);
+          $('#node-input-newPointNodeId, #node-input-newPointValue').val('');
+          $('#node-input-newPointNodeId').focus();
+        } catch (error) { RED.notify(error.message, 'error'); }
+      });
+      $('#node-input-newPointNodeId, #node-input-newPointValue').on('keydown', function (event) {
+        if (event.key === 'Enter') { event.preventDefault(); $('#node-input-addPoint').click(); }
+      });
+      $('#node-input-importPointList').on('click', () => $('#node-input-pointFile').click());
+      $('#node-input-pointFile').on('change', function () {
+        const file = this.files && this.files[0];
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = () => {
+          try {
+            const imported = parse(reader.result);
+            merge(imported);
+            $('#node-input-pointListFileName').val(file.name);
+            RED.notify(`${imported.length} point(s) imported`, 'success');
+          } catch (error) { RED.notify(`Import failed: ${error.message}`, 'error'); }
+          $('#node-input-pointFile').val('');
+        };
+        reader.readAsText(file);
+      });
+      $('#node-input-clearPointList').on('click', () => {
+        points.clear();
+        $('#node-input-nodeId').val('');
+        $('#node-input-pointListFileName').val('');
+        render();
+      });
+    },
+    label: function () { return this.name || 'tier0-opcua-write'; }
+  });
+</script>

package/nodes/write.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { messageWritePoints } = require('../lib/points');
+
+module.exports = function registerWriteNode(RED) {
+  function OpcUaWriteNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.connection = RED.nodes.getNode(config.connection);
+
+    node.on('input', async (msg, send, done) => {
+      if (!node.connection) return done(new Error('OPC UA connection not configured'));
+
+      try {
+        const points = messageWritePoints(msg, config);
+        node.status({ fill: 'blue', shape: 'dot', text: `writing ${points.length}` });
+        const results = await node.connection.client.writeMany(
+          points,
+          Number(config.batchSize) || 500
+        );
+
+        if ((config.outputMode || 'batch') === 'split') {
+          results.forEach((result) => send({ ...msg, topic: result.nodeId, opcua: result }));
+        } else {
+          msg.payload = results;
+          msg.opcua = {
+            ...(msg.opcua || {}),
+            operation: 'write',
+            total: results.length,
+            good: results.filter((item) => item.statusCode === 'Good').length,
+            clientDiagnostics: node.connection.client.getDiagnostics(),
+          };
+          send(msg);
+        }
+
+        node.status({ fill: 'green', shape: 'dot', text: `${results.length} written` });
+        done();
+      } catch (error) {
+        node.status({ fill: 'red', shape: 'ring', text: error.message });
+        done(error);
+      }
+    });
+  }
+
+  RED.nodes.registerType('tier0-opcua-write', OpcUaWriteNode);
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@tier0/opcua-client",
+  "version": "0.1.0",
+  "description": "High-scale OPC UA client nodes for Node-RED powered by open62541",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/loliuy/opcua-client.git"
+  },
+  "main": "index.js",
+  "gypfile": true,
+  "files": [
+    "binding.gyp",
+    "index.js",
+    "lib",
+    "nodes",
+    "src",
+    "scripts",
+    "README.md",
+    "BENCHMARK.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "install": "npm run build:open62541 && node-gyp rebuild",
+    "build:open62541": "bash scripts/build-open62541.sh",
+    "build": "node-gyp rebuild",
+    "clean": "node-gyp clean",
+    "test": "node --test test/*.test.js",
+    "test:native": "node test/native.integration.js && node test/native.queue.integration.js && node test/reconnect.integration.js",
+    "test:reconnect": "node test/reconnect.integration.js",
+    "test:stress": "node test/stress.js",
+    "test:nodered": "node test/nodered.integration.js",
+    "test:nodered:reconnect": "OPCUA_NODERED_RECONNECT=1 node test/nodered.integration.js"
+  },
+  "keywords": [
+    "node-red",
+    "opcua",
+    "opc-ua",
+    "open62541",
+    "industrial-iot"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "node-red": {
+    "version": ">=3.1",
+    "nodes": {
+      "tier0-opcua-connection": "nodes/connection.js",
+      "tier0-opcua-browse": "nodes/browse.js",
+      "tier0-opcua-read": "nodes/read.js",
+      "tier0-opcua-write": "nodes/write.js",
+      "tier0-opcua-subscribe": "nodes/subscribe.js"
+    }
+  },
+  "dependencies": {
+    "node-addon-api": "^8.3.1"
+  },
+  "devDependencies": {
+    "node-gyp": "^11.4.2"
+  }
+}

package/scripts/build-open62541.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd -P)"
+VERSION="${OPEN62541_VERSION:-1.4.16}"
+BUILD_ROOT="${ROOT_DIR}/.build/open62541-src"
+INSTALL_ROOT="${OPEN62541_PREFIX:-${ROOT_DIR}/.build/open62541}"
+
+if [[ ! -d "${BUILD_ROOT}/.git" ]]; then
+  rm -rf "${BUILD_ROOT}"
+  git clone --depth 1 --branch "v${VERSION}" \
+    https://github.com/open62541/open62541.git "${BUILD_ROOT}"
+fi
+
+cmake -S "${BUILD_ROOT}" -B "${BUILD_ROOT}/build" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+  -DBUILD_SHARED_LIBS=OFF \
+  -DUA_ENABLE_ENCRYPTION=OFF \
+  -DUA_BUILD_EXAMPLES=OFF \
+  -DUA_BUILD_UNIT_TESTS=OFF \
+  -DCMAKE_INSTALL_PREFIX="${INSTALL_ROOT}"
+
+cmake --build "${BUILD_ROOT}/build" --parallel "${BUILD_JOBS:-2}"
+cmake --install "${BUILD_ROOT}/build"