node-red-contrib-modbus-modpackqt 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -4,6 +4,39 @@ All notable changes to **node-red-contrib-modbus-modpackqt** are documented
 here. This project follows [Semantic Versioning](https://semver.org/) — pin a
 major version (`^2.0.0`) in production.
 
+## [3.1.0] — 2026-05-10
+
+### Added
+
+- **Two new probe nodes** for live commissioning & analysis:
+  - `modpackqt-master-probe` — drop one per Modbus TCP device, click
+    **Open in ModPackQT Console** to launch the web tester live-attached
+    to that connection.
+  - `modpackqt-slave-probe` — drop one per fake slave (port + unit ID),
+    click the same button to open the web register editor.
+- **Hidden HTTP runtime** (`nodes/lib/probe-runtime.js`) auto-starts on
+  `127.0.0.1:8502` when the first probe deploys, auto-stops when the last
+  unregisters. Exposes `/api/probes`, `/api/probes/:id/read|write|store`
+  for the modpackqt.com web console to drive.
+- **Multi-device aggregation** — all probes from this Node-RED instance
+  appear together in the web console sidebar; switch between devices
+  with one click.
+- **Editor admin route** `/modpackqt-probe/info` returns the runtime
+  host/port so the "Open in Console" button can deep-link with the
+  correct probe ID.
+
+### Notes
+
+- Default bind is loopback-only (`127.0.0.1`) for safety. Override with
+  env vars `MODPACKQT_PROBE_HOST` and `MODPACKQT_PROBE_PORT` (e.g.
+  `MODPACKQT_PROBE_HOST=0.0.0.0` to allow remote browsers on your LAN).
+- Port `8502` falls back to `8503`–`8506` if already in use.
+- Probe nodes have **no flow inputs/outputs** — they're commissioning
+  tools, not flow nodes. Use the existing `master-read`/`-write`/
+  `slave-read`/`-write` nodes to wire Modbus into your flow logic.
+- CORS is open to `https://modpackqt.com` plus common localhost dev
+  origins.
+
 ## [3.0.0] — 2026-05-10
 
 ### ⚠️ Breaking changes (positioning, not behavior)

package/README.md

@@ -145,6 +145,53 @@ External masters connecting to `your-host:1502`, unit `1`, FC `3`, address `0`,
 | `modpackqt-slave-read` | Read from the embedded slave's register store (verify what masters see) |
 | `modpackqt-slave-write` | Push values into the embedded slave's register store |
 | `modpackqt-traffic` | Passive monitor — emits one message per Modbus op with full visibility into what's happening on the wire |
+| `modpackqt-master-probe` | **Live commissioning probe** for a single Modbus TCP device. One node per device. Click **Open in ModPackQT Console** to launch the web tester live-attached. |
+| `modpackqt-slave-probe` | **Live simulator probe** for a single fake slave. One node per port. Web console gives you a real-time register editor. |
+
+---
+
+## Live commissioning with probe nodes
+
+The two **probe** nodes (`modpackqt-master-probe`, `modpackqt-slave-probe`) are tools for the kind of work you do once per device — figuring out a register map, decoding bytes correctly, simulating a device for SCADA development. They have no flow inputs or outputs; instead, each probe registers itself with a small local HTTP runtime, and the [modpackqt.com web console](https://modpackqt.com) attaches live.
+
+### Pattern: one probe per device
+
+```
+┌─────────────────────────┐  ┌─────────────────────────┐  ┌─────────────────────────┐
+│  master-probe           │  │  master-probe           │  │  slave-probe            │
+│  Inverter A             │  │  Energy Meter           │  │  Fake Inverter          │
+│  192.168.1.10:502 #1    │  │  192.168.1.20:502 #5    │  │  Listening :1502 #1     │
+│  [ Open in Console ]    │  │  [ Open in Console ]    │  │  [ Open in Console ]    │
+└─────────────────────────┘  └─────────────────────────┘  └─────────────────────────┘
+```
+
+Click **Open in Console** on any probe → the web console opens with **all probes from this Node-RED instance in the sidebar**, the clicked one pre-selected. Switch between devices with one click.
+
+### Hidden runtime
+
+The first probe deployed starts a small HTTP server on `127.0.0.1:8502`:
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /api/health` | Runtime health + probe count |
+| `GET /api/probes` | List all registered probes |
+| `GET /api/probes/:id` | Probe details |
+| `POST /api/probes/:id/read` | Master probe: read registers `{ fc, address, quantity }` |
+| `POST /api/probes/:id/write` | Master probe: write registers `{ fc, address, values }` |
+| `GET /api/probes/:id/store?type=&address=&quantity=` | Slave probe: inspect register values |
+| `PUT /api/probes/:id/store` | Slave probe: set register values |
+
+The server **auto-stops** when the last probe is removed.
+
+### Network access
+
+Default bind is **loopback-only** (`127.0.0.1`) — only browsers on the same machine can reach it. To allow remote browsers on your LAN:
+
+```bash
+MODPACKQT_PROBE_HOST=0.0.0.0 MODPACKQT_PROBE_PORT=8502 node-red
+```
+
+Port `8502` falls back to `8503`–`8506` automatically if it's already in use.
 
 ---
 

package/nodes/lib/probe-runtime.js

@@ -0,0 +1,204 @@
+/**
+ * ModPackQT Probe Runtime — singleton HTTP server that exposes all probe
+ * nodes from this Node-RED instance to the modpackqt.com web console.
+ *
+ * Auto-starts when the first probe registers, auto-stops when the last
+ * unregisters. Default bind: 127.0.0.1:8502 (localhost-only, safe default).
+ * Override via env vars MODPACKQT_PROBE_HOST and MODPACKQT_PROBE_PORT.
+ *
+ * API:
+ *   GET  /api/health
+ *   GET  /api/probes
+ *   GET  /api/probes/:id
+ *   POST /api/probes/:id/read       { fc, address, quantity }
+ *   POST /api/probes/:id/write      { fc, address, values }
+ *   GET  /api/probes/:id/store?type=&address=&quantity=
+ *   PUT  /api/probes/:id/store      { type, address, values }
+ */
+const http = require('http');
+const { URL } = require('url');
+
+const PALETTE_VERSION = '3.1.0';
+const DEFAULT_PORT = parseInt(process.env.MODPACKQT_PROBE_PORT, 10) || 8502;
+const BIND_HOST    = process.env.MODPACKQT_PROBE_HOST || '127.0.0.1';
+const PORT_RETRY   = 5;
+
+const ALLOWED_ORIGINS = [
+  'https://modpackqt.com',
+  'https://www.modpackqt.com',
+  'http://localhost:5000',
+  'http://localhost:5173',
+  'http://127.0.0.1:5000',
+  'http://127.0.0.1:5173'
+];
+
+class ProbeRuntime {
+  constructor() {
+    this.probes = new Map();
+    this.server = null;
+    this.actualHost = BIND_HOST;
+    this.actualPort = null;
+    this._adminRoutesRegistered = false;
+  }
+
+  register(probe) {
+    this.probes.set(probe.id, probe);
+    if (!this.server) this._start();
+    return { host: this.actualHost, port: this.actualPort };
+  }
+
+  unregister(probeId) {
+    if (!this.probes.has(probeId)) return;
+    this.probes.delete(probeId);
+    if (this.probes.size === 0) this._stop();
+  }
+
+  ensureAdminRoutes(RED) {
+    if (this._adminRoutesRegistered) return;
+    this._adminRoutesRegistered = true;
+    const self = this;
+    RED.httpAdmin.get(
+      '/modpackqt-probe/info',
+      RED.auth.needsPermission('flows.read'),
+      function (_req, res) {
+        res.json({
+          host: self.actualHost,
+          port: self.actualPort,
+          probes: self.probes.size,
+          version: PALETTE_VERSION
+        });
+      }
+    );
+  }
+
+  _start() {
+    this.server = http.createServer((req, res) => this._handle(req, res));
+    const tryPort = (port, attemptsLeft) => {
+      const onError = (err) => {
+        if (err.code === 'EADDRINUSE' && attemptsLeft > 0) {
+          // eslint-disable-next-line no-console
+          console.warn(`[modpackqt] probe runtime: port ${port} in use, trying ${port + 1}`);
+          this.server.removeListener('error', onError);
+          tryPort(port + 1, attemptsLeft - 1);
+        } else {
+          // eslint-disable-next-line no-console
+          console.error(`[modpackqt] probe runtime failed to start: ${err.message}`);
+        }
+      };
+      this.server.once('error', onError);
+      this.server.listen(port, BIND_HOST, () => {
+        this.actualPort = port;
+        // eslint-disable-next-line no-console
+        console.log(`[modpackqt] probe runtime listening on http://${BIND_HOST}:${port}`);
+      });
+    };
+    tryPort(DEFAULT_PORT, PORT_RETRY);
+  }
+
+  _stop() {
+    if (this.server) {
+      try { this.server.close(); } catch (_) { /* ignore */ }
+      this.server = null;
+      this.actualPort = null;
+      // eslint-disable-next-line no-console
+      console.log('[modpackqt] probe runtime stopped (no probes registered)');
+    }
+  }
+
+  async _handle(req, res) {
+    const origin = req.headers.origin;
+    if (origin && ALLOWED_ORIGINS.includes(origin)) {
+      res.setHeader('Access-Control-Allow-Origin', origin);
+      res.setHeader('Vary', 'Origin');
+    }
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Gateway-Id, X-User-Id');
+    if (req.method === 'OPTIONS') { res.statusCode = 204; res.end(); return; }
+
+    try {
+      const u = new URL(req.url, `http://${this.actualHost}:${this.actualPort}`);
+      const parts = u.pathname.split('/').filter(Boolean);
+
+      if (parts[0] !== 'api') return this._json(res, 404, { error: 'not found' });
+
+      // GET /api/health
+      if (req.method === 'GET' && parts[1] === 'health' && !parts[2]) {
+        return this._json(res, 200, {
+          ok: true, version: PALETTE_VERSION, probes: this.probes.size
+        });
+      }
+
+      // GET /api/probes
+      if (req.method === 'GET' && parts[1] === 'probes' && !parts[2]) {
+        const list = Array.from(this.probes.values()).map((p) => p.describe());
+        return this._json(res, 200, list);
+      }
+
+      // /api/probes/:id[/...]
+      if (parts[1] === 'probes' && parts[2]) {
+        const probe = this.probes.get(parts[2]);
+        if (!probe) return this._json(res, 404, { error: `probe not found: ${parts[2]}` });
+
+        const action = parts[3] || '';
+        const body = (req.method === 'POST' || req.method === 'PUT')
+          ? await this._readBody(req) : {};
+
+        if (req.method === 'GET' && action === '') {
+          return this._json(res, 200, probe.describe(true));
+        }
+        if (req.method === 'POST' && action === 'read') {
+          const result = await probe.handleRead(body);
+          return this._json(res, 200, result);
+        }
+        if (req.method === 'POST' && action === 'write') {
+          const result = await probe.handleWrite(body);
+          return this._json(res, 200, result);
+        }
+        if (req.method === 'GET' && action === 'store') {
+          const result = await probe.handleStoreGet(u.searchParams);
+          return this._json(res, 200, result);
+        }
+        if (req.method === 'PUT' && action === 'store') {
+          const result = await probe.handleStorePut(body);
+          return this._json(res, 200, result);
+        }
+      }
+
+      this._json(res, 404, { error: 'not found' });
+    } catch (err) {
+      this._json(res, 500, { error: err && err.message ? err.message : String(err) });
+    }
+  }
+
+  _json(res, status, payload) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify(payload));
+  }
+
+  _readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let total = 0;
+      req.on('data', (c) => {
+        total += c.length;
+        if (total > 1024 * 1024) { reject(new Error('payload too large')); req.destroy(); return; }
+        chunks.push(c);
+      });
+      req.on('end', () => {
+        if (chunks.length === 0) return resolve({});
+        try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
+        catch (_) { reject(new Error('invalid JSON body')); }
+      });
+      req.on('error', reject);
+    });
+  }
+}
+
+let instance = null;
+function getRuntime() {
+  if (!instance) instance = new ProbeRuntime();
+  return instance;
+}
+
+module.exports = { getRuntime, PALETTE_VERSION };

package/nodes/modpackqt-master-probe.html

@@ -0,0 +1,103 @@
+<script type="text/javascript">
+  RED.nodes.registerType('modpackqt-master-probe', {
+    category: 'ModPackQT',
+    color: '#7c3aed',
+    defaults: {
+      name:        { value: '' },
+      targetHost:  { value: '192.168.1.10', required: true },
+      targetPort:  { value: 502, required: true, validate: RED.validators.number() },
+      unitId:      { value: 1, required: true, validate: RED.validators.number() },
+      timeoutMs:   { value: 3000, validate: RED.validators.number() }
+    },
+    inputs: 0,
+    outputs: 0,
+    icon: 'font-awesome/fa-rocket',
+    label: function () {
+      return this.name || `master probe ${this.targetHost}:${this.targetPort} #${this.unitId}`;
+    },
+    paletteLabel: 'modbus master probe',
+    oneditprepare: function () {
+      const node = this;
+      const buildLink = (info) => {
+        const host = (info && info.host) || '127.0.0.1';
+        const port = (info && info.port) || 8502;
+        const url  = 'https://modpackqt.com/console'
+          + '?gateway=local'
+          + '&host=' + encodeURIComponent(host)
+          + '&port=' + port
+          + '&probe=' + encodeURIComponent(node.id)
+          + '&kind=master';
+        $('#modpackqt-probe-link').attr('href', url);
+        $('#modpackqt-probe-runtime').text(host + ':' + port);
+      };
+      $.getJSON('modpackqt-probe/info').done(buildLink).fail(() => buildLink({}));
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="modpackqt-master-probe">
+  <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="(optional, e.g. Inverter A)">
+  </div>
+  <div class="form-row">
+    <label for="node-input-targetHost"><i class="fa fa-plug"></i> Target Host</label>
+    <input type="text" id="node-input-targetHost" placeholder="192.168.1.10">
+  </div>
+  <div class="form-row">
+    <label for="node-input-targetPort"><i class="fa fa-hashtag"></i> Target Port</label>
+    <input type="number" id="node-input-targetPort" min="1" max="65535" placeholder="502">
+  </div>
+  <div class="form-row">
+    <label for="node-input-unitId"><i class="fa fa-id-card"></i> Unit ID</label>
+    <input type="number" id="node-input-unitId" min="1" max="247" placeholder="1">
+  </div>
+  <div class="form-row">
+    <label for="node-input-timeoutMs"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
+    <input type="number" id="node-input-timeoutMs" placeholder="3000">
+  </div>
+  <div class="form-tips">
+    <b>One probe = one device.</b> Drop additional master-probe nodes for additional devices —
+    the web console aggregates them all into a unified sidebar.
+  </div>
+  <div class="form-row" style="margin-top:18px;padding-top:14px;border-top:1px solid #e5e7eb;text-align:center;">
+    <a id="modpackqt-probe-link" href="https://modpackqt.com" target="_blank" rel="noopener noreferrer"
+       style="display:inline-block;padding:10px 24px;background:#7c3aed;color:#fff;
+              text-decoration:none;border-radius:6px;font-weight:600;font-size:14px;
+              box-shadow:0 1px 2px rgba(0,0,0,0.08);">
+      Open in ModPackQT Console <i class="fa fa-external-link" style="margin-left:6px;"></i>
+    </a>
+    <div style="margin-top:6px;font-size:11px;color:#6b7280;">
+      Live register inspector, scanner, decoder &amp; AI helper · runtime <span id="modpackqt-probe-runtime">starting…</span>
+    </div>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="modpackqt-master-probe">
+  <p>Live tester / commissioning probe for a single Modbus TCP device.
+     Drop one node per device, then click <b>Open in ModPackQT Console</b>
+     to launch the web tester live-attached to this connection.</p>
+
+  <h3>How it works</h3>
+  <p>The first probe deployed in this Node-RED instance starts a small local
+     HTTP server (default <code>127.0.0.1:8502</code>). The
+     <a href="https://modpackqt.com" target="_blank">modpackqt.com web console</a>
+     calls that local server to read/write registers, scan ranges, decode bytes,
+     and save profiles.</p>
+
+  <h3>Multiple devices</h3>
+  <p>Drop one master-probe per device. The web console auto-aggregates all
+     probe nodes from this Node-RED instance into a single sidebar — switch
+     between devices with one click.</p>
+
+  <h3>Network access</h3>
+  <p>The runtime binds to <code>127.0.0.1</code> by default — only browsers on
+     the same machine can reach it. To allow remote access from another machine's
+     browser, set environment variable <code>MODPACKQT_PROBE_HOST=0.0.0.0</code>
+     before starting Node-RED (and ensure your firewall allows port 8502).</p>
+
+  <h3>No inputs / outputs</h3>
+  <p>Probe nodes are commissioning tools — they don't participate in flows.
+     Use the regular <code>modpackqt-master-read</code> / <code>-write</code>
+     nodes to wire Modbus into your flow logic.</p>
+</script>

package/nodes/modpackqt-master-probe.js

@@ -0,0 +1,116 @@
+/**
+ * ModPackQT Master Probe — live commissioning probe for a single Modbus TCP device.
+ *
+ * Drop one node per device. The hidden runtime exposes it on the local HTTP
+ * API that the modpackqt.com web console drives.
+ */
+module.exports = function (RED) {
+  const ModbusRTU = require('modbus-serial');
+  const { getRuntime } = require('./lib/probe-runtime');
+
+  function MasterProbeNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.name        = config.name || '';
+    node.targetHost  = config.targetHost || '192.168.1.10';
+    node.targetPort  = parseInt(config.targetPort, 10) || 502;
+    node.unitId      = parseInt(config.unitId, 10) || 1;
+    node.timeoutMs   = parseInt(config.timeoutMs, 10) || 3000;
+
+    let client = null;
+    let connecting = null;
+
+    async function getClient() {
+      if (client && client.isOpen) return client;
+      if (connecting) return connecting;
+      connecting = (async () => {
+        const c = new ModbusRTU();
+        c.setTimeout(node.timeoutMs);
+        await c.connectTCP(node.targetHost, { port: node.targetPort });
+        c.setID(node.unitId);
+        client = c;
+        node.status({ fill: 'green', shape: 'dot', text: `connected ${node.targetHost}:${node.targetPort}` });
+        return c;
+      })().catch((err) => {
+        node.status({ fill: 'red', shape: 'ring', text: `connect failed: ${err.message}` });
+        throw err;
+      }).finally(() => { connecting = null; });
+      return connecting;
+    }
+
+    const probe = {
+      id: node.id,
+      kind: 'master',
+      describe(_detailed = false) {
+        return {
+          id: node.id,
+          kind: 'master',
+          name: node.name || `Master @ ${node.targetHost}:${node.targetPort} #${node.unitId}`,
+          target: {
+            mode: 'tcp',
+            host: node.targetHost,
+            port: node.targetPort,
+            unitId: node.unitId,
+            timeoutMs: node.timeoutMs
+          },
+          status: client && client.isOpen ? 'connected' : 'disconnected'
+        };
+      },
+      async handleRead(body) {
+        const fc   = parseInt(body.fc, 10);
+        const addr = parseInt(body.address, 10) || 0;
+        const qty  = parseInt(body.quantity, 10) || 1;
+        const c = await getClient();
+        c.setID(node.unitId);
+        const t0 = Date.now();
+        let res;
+        switch (fc) {
+          case 1: res = await c.readCoils(addr, qty); break;
+          case 2: res = await c.readDiscreteInputs(addr, qty); break;
+          case 3: res = await c.readHoldingRegisters(addr, qty); break;
+          case 4: res = await c.readInputRegisters(addr, qty); break;
+          default: throw new Error(`unsupported read FC: ${fc}`);
+        }
+        return { values: res.data, durationMs: Date.now() - t0 };
+      },
+      async handleWrite(body) {
+        const fc     = parseInt(body.fc, 10);
+        const addr   = parseInt(body.address, 10) || 0;
+        const values = body.values;
+        if (!Array.isArray(values) && fc !== 5 && fc !== 6) {
+          throw new Error('values must be an array for FC15/FC16');
+        }
+        const c = await getClient();
+        c.setID(node.unitId);
+        const t0 = Date.now();
+        switch (fc) {
+          case 5:  await c.writeCoil(addr, !!(Array.isArray(values) ? values[0] : values)); break;
+          case 6:  await c.writeRegister(addr, Array.isArray(values) ? values[0] : values); break;
+          case 15: await c.writeCoils(addr, values.map(Boolean)); break;
+          case 16: await c.writeRegisters(addr, values); break;
+          default: throw new Error(`unsupported write FC: ${fc}`);
+        }
+        return { ok: true, durationMs: Date.now() - t0 };
+      },
+      async handleStoreGet() { throw new Error('master probe has no register store — use /read'); },
+      async handleStorePut() { throw new Error('master probe has no register store — use /write'); }
+    };
+
+    const runtime = getRuntime();
+    runtime.ensureAdminRoutes(RED);
+    const info = runtime.register(probe);
+    node.status({ fill: 'blue', shape: 'ring', text: `probe ready · ${info.host}:${info.port || '?'}` });
+
+    node.on('close', function (done) {
+      runtime.unregister(node.id);
+      if (client && client.isOpen) {
+        try { client.close(() => done()); } catch (_) { done(); }
+      } else {
+        done();
+      }
+    });
+  }
+
+  RED.nodes.registerType('modpackqt-master-probe', MasterProbeNode);
+};

package/nodes/modpackqt-slave-probe.html

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+  RED.nodes.registerType('modpackqt-slave-probe', {
+    category: 'ModPackQT',
+    color: '#7c3aed',
+    defaults: {
+      name:     { value: '' },
+      bindHost: { value: '0.0.0.0' },
+      bindPort: { value: 1502, required: true, validate: RED.validators.number() },
+      unitId:   { value: 1, required: true, validate: RED.validators.number() }
+    },
+    inputs: 0,
+    outputs: 0,
+    icon: 'font-awesome/fa-server',
+    label: function () {
+      return this.name || `slave probe :${this.bindPort} #${this.unitId}`;
+    },
+    paletteLabel: 'modbus slave probe',
+    oneditprepare: function () {
+      const node = this;
+      const buildLink = (info) => {
+        const host = (info && info.host) || '127.0.0.1';
+        const port = (info && info.port) || 8502;
+        const url  = 'https://modpackqt.com/console'
+          + '?gateway=local'
+          + '&host=' + encodeURIComponent(host)
+          + '&port=' + port
+          + '&probe=' + encodeURIComponent(node.id)
+          + '&kind=slave';
+        $('#modpackqt-slave-probe-link').attr('href', url);
+        $('#modpackqt-slave-probe-runtime').text(host + ':' + port);
+      };
+      $.getJSON('modpackqt-probe/info').done(buildLink).fail(() => buildLink({}));
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="modpackqt-slave-probe">
+  <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="(optional, e.g. Fake Inverter)">
+  </div>
+  <div class="form-row">
+    <label for="node-input-bindHost"><i class="fa fa-globe"></i> Bind Host</label>
+    <input type="text" id="node-input-bindHost" placeholder="0.0.0.0 (all interfaces)">
+  </div>
+  <div class="form-row">
+    <label for="node-input-bindPort"><i class="fa fa-hashtag"></i> Listen Port</label>
+    <input type="number" id="node-input-bindPort" min="1" max="65535" placeholder="1502">
+  </div>
+  <div class="form-row">
+    <label for="node-input-unitId"><i class="fa fa-id-card"></i> Unit ID</label>
+    <input type="number" id="node-input-unitId" min="1" max="247" placeholder="1">
+  </div>
+  <div class="form-tips">
+    <b>One probe = one fake slave.</b> For multiple slaves, drop one node per
+    port. The web console aggregates all slave probes into a unified register
+    editor — switch between them with one click.
+  </div>
+  <div class="form-row" style="margin-top:18px;padding-top:14px;border-top:1px solid #e5e7eb;text-align:center;">
+    <a id="modpackqt-slave-probe-link" href="https://modpackqt.com" target="_blank" rel="noopener noreferrer"
+       style="display:inline-block;padding:10px 24px;background:#7c3aed;color:#fff;
+              text-decoration:none;border-radius:6px;font-weight:600;font-size:14px;
+              box-shadow:0 1px 2px rgba(0,0,0,0.08);">
+      Open in ModPackQT Console <i class="fa fa-external-link" style="margin-left:6px;"></i>
+    </a>
+    <div style="margin-top:6px;font-size:11px;color:#6b7280;">
+      Live register editor, traffic monitor &amp; AI helper · runtime <span id="modpackqt-slave-probe-runtime">starting…</span>
+    </div>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="modpackqt-slave-probe">
+  <p>Live simulator probe for a single Modbus TCP slave. Drop one node per
+     fake device, configure listen port + unit ID, then click
+     <b>Open in ModPackQT Console</b> to launch the web register editor.</p>
+
+  <h3>How it works</h3>
+  <p>Each slave-probe owns a 65 536-register store per type (coils, discrete,
+     holding, input) and listens on its configured port. External Modbus
+     masters can connect and read/write — the modpackqt.com console gives
+     you a live editor for the register values.</p>
+
+  <h3>Multiple slaves</h3>
+  <p>Drop one slave-probe per port/unit combination. They appear together
+     in the web console sidebar — switch between them with one click,
+     compare register sets side-by-side.</p>
+
+  <h3>Note on ports</h3>
+  <p>Use ports above 1024 (e.g. 1502, 1503, 1504) to avoid needing root
+     privileges. Each probe must use a unique port.</p>
+</script>

package/nodes/modpackqt-slave-probe.js

@@ -0,0 +1,111 @@
+/**
+ * ModPackQT Slave Probe — live simulator probe for a single Modbus TCP slave.
+ *
+ * Drop one node per fake device. Each probe owns its own register store and
+ * binds its own port. The hidden runtime exposes it on the local HTTP API
+ * that the modpackqt.com web console drives (register editor + live traffic).
+ */
+module.exports = function (RED) {
+  const ModbusRTU = require('modbus-serial');
+  const { getRuntime } = require('./lib/probe-runtime');
+
+  function SlaveProbeNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.name     = config.name || '';
+    node.bindHost = config.bindHost || '0.0.0.0';
+    node.bindPort = parseInt(config.bindPort, 10) || 1502;
+    node.unitId   = parseInt(config.unitId, 10) || 1;
+
+    const store = {
+      coils:    new Array(65536).fill(false),
+      discrete: new Array(65536).fill(false),
+      holding:  new Array(65536).fill(0),
+      input:    new Array(65536).fill(0)
+    };
+
+    let server = null;
+    try {
+      const vector = {
+        getCoil:            (addr, _u, cb) => cb(null, store.coils[addr]),
+        getDiscreteInput:   (addr, _u, cb) => cb(null, store.discrete[addr]),
+        getHoldingRegister: (addr, _u, cb) => cb(null, store.holding[addr]),
+        getInputRegister:   (addr, _u, cb) => cb(null, store.input[addr]),
+        setCoil:            (addr, val, _u, cb) => { store.coils[addr] = !!val; cb(null); },
+        setRegister:        (addr, val, _u, cb) => { store.holding[addr] = val & 0xFFFF; cb(null); }
+      };
+      server = new ModbusRTU.ServerTCP(vector, {
+        host: node.bindHost,
+        port: node.bindPort,
+        debug: false,
+        unitID: node.unitId
+      });
+      server.on('socketError', (err) => node.warn(`[slave-probe] socket: ${err.message}`));
+      server.on('serverError', (err) => node.error(`[slave-probe] server: ${err.message}`));
+      node.log(`[modpackqt] slave probe listening on ${node.bindHost}:${node.bindPort} #${node.unitId}`);
+    } catch (err) {
+      node.error(`Failed to start slave probe: ${err.message}`);
+    }
+
+    const probe = {
+      id: node.id,
+      kind: 'slave',
+      describe(_detailed = false) {
+        return {
+          id: node.id,
+          kind: 'slave',
+          name: node.name || `Slave :${node.bindPort} #${node.unitId}`,
+          target: {
+            mode: 'tcp',
+            host: node.bindHost,
+            port: node.bindPort,
+            unitId: node.unitId
+          },
+          status: server ? 'listening' : 'error'
+        };
+      },
+      async handleRead() { throw new Error('slave probe — use GET /store to inspect registers'); },
+      async handleWrite() { throw new Error('slave probe — use PUT /store to set registers'); },
+      async handleStoreGet(searchParams) {
+        const type = searchParams.get('type') || 'holding';
+        const addr = parseInt(searchParams.get('address') || '0', 10);
+        const qty  = parseInt(searchParams.get('quantity') || '10', 10);
+        if (!store[type]) throw new Error(`unknown register type: ${type}`);
+        return { type, address: addr, values: store[type].slice(addr, addr + qty) };
+      },
+      async handleStorePut(body) {
+        const type = body.type || 'holding';
+        const addr = parseInt(body.address, 10) || 0;
+        const values = body.values || [];
+        if (!store[type]) throw new Error(`unknown register type: ${type}`);
+        if (!Array.isArray(values)) throw new Error('values must be an array');
+        const isBool = (type === 'coils' || type === 'discrete');
+        const stored = values.map((v) => isBool ? Boolean(v) : (parseInt(v, 10) & 0xFFFF));
+        stored.forEach((v, i) => { store[type][addr + i] = v; });
+        return { ok: true, type, address: addr, written: stored.length };
+      }
+    };
+
+    const runtime = getRuntime();
+    runtime.ensureAdminRoutes(RED);
+    runtime.register(probe);
+
+    if (server) {
+      node.status({ fill: 'green', shape: 'dot', text: `slave :${node.bindPort} #${node.unitId}` });
+    } else {
+      node.status({ fill: 'red', shape: 'ring', text: 'failed to start' });
+    }
+
+    node.on('close', function (done) {
+      runtime.unregister(node.id);
+      if (server) {
+        try { server.close(() => done()); } catch (_) { done(); }
+      } else {
+        done();
+      }
+    });
+  }
+
+  RED.nodes.registerType('modpackqt-slave-probe', SlaveProbeNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-modbus-modpackqt",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Modbus commissioning, testing & analysis tools for Node-RED. Embedded Modbus TCP/RTU master + slave server, FC1/FC2/FC3/FC4 reads, FC5/FC6/FC15/FC16 writes, built-in slave register store, and a passive traffic monitor for debugging. 100% free, MIT, no usage limits. By ModPackQT — open the matching web console at modpackqt.com for register decoding, simulation and AI assistance.",
   "keywords": [
     "node-red",
@@ -49,7 +49,9 @@
       "modpackqt-master-write": "nodes/modpackqt-master-write.js",
       "modpackqt-slave-read": "nodes/modpackqt-slave-read.js",
       "modpackqt-slave-write": "nodes/modpackqt-slave-write.js",
-      "modpackqt-traffic": "nodes/modpackqt-traffic.js"
+      "modpackqt-traffic": "nodes/modpackqt-traffic.js",
+      "modpackqt-master-probe": "nodes/modpackqt-master-probe.js",
+      "modpackqt-slave-probe": "nodes/modpackqt-slave-probe.js"
     }
   },
   "dependencies": {