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

package/CHANGELOG.md

@@ -4,6 +4,65 @@ 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)
+
+- **Removed the 1,000 ops/day rate limit.** All nodes are now 100% free with
+  no usage limits. The `RATE_LIMIT` error code is no longer thrown. If your
+  flows previously caught it, you can remove that handler.
+- **Removed the `modpackqt · ` brand prefix from node status text.** Status
+  text is now clean by default.
+- **Repositioned palette as "Modbus commissioning, testing & analysis tools."**
+  README, package description and node help text updated. No code changes
+  beyond the rate-limit removal.
+
+### Changed
+
+- `modpackqt-config.js` — `checkLimit()` is now a no-op counter. The API key
+  field is retained but is reserved for future optional cloud features
+  (profile sync, remote console). All Modbus functionality works without a key.
+- README — pricing table, "free tier" sections and trial-key call-outs removed.
+- DISCLAIMER.md — rate-limit references removed.
+
+### Added
+
+- New keywords: `modbus-tester`, `modbus-commissioning`, `modbus-analyzer`
+  for better discoverability.
+
 ## [2.1.1] — 2026-05-09
 
 ### Changed

package/DISCLAIMER.md

@@ -53,8 +53,6 @@ and a wrong write can damage equipment, ruin a batch, or cause a safety incident
 - It does **not** guarantee delivery, ordering, or completeness of writes
   beyond what the underlying `modbus-serial` library and the network/serial
   link provide.
-- The free tier is rate-limited; if you exceed 1,000 ops/day, master read/write
-  nodes will return errors. **Do not rely on the free tier for production.**
 
 ## Reporting issues
 
@@ -79,10 +77,9 @@ We strongly recommend subscribing to release notifications:
 
 ## Licence
 
-This software is provided under the MIT License — see `LICENSE`. Paid plans
-provide commercial support and remove the daily op cap. **Paid plans do not
-add a warranty** — the limitation of liability in the LICENSE applies to all
-users. See <https://modpackqt.com/nodered/terms> for the full terms.
+This software is provided under the MIT License — see `LICENSE`. The
+limitation of liability in the LICENSE applies to all users. See
+<https://modpackqt.com/nodered/terms> for the full terms.
 
 ---
 

package/README.md

@@ -1,19 +1,21 @@
 # node-red-contrib-modbus-modpackqt
 
-**Embedded Modbus TCP / RTU master + slave server for Node-RED — no extra apps required.**
+**Modbus commissioning, testing & analysis tools for Node-RED.**
 By [ModPackQT](https://modpackqt.com).
 
 [![npm version](https://img.shields.io/npm/v/node-red-contrib-modbus-modpackqt.svg)](https://www.npmjs.com/package/node-red-contrib-modbus-modpackqt)
 [![Node-RED](https://img.shields.io/badge/Node--RED-%E2%89%A52.0.0-red)](https://nodered.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 
+> **100% free, MIT-licensed, no usage limits.** Open the [ModPackQT web console](https://modpackqt.com) for register decoding, device simulation and AI assistance.
+
 ---
 
 ## What you get
 
 - **Modbus master** — read (FC1–FC4) and write (FC5/FC6/FC15/FC16) over **TCP** or **RTU (serial)**
 - **Embedded Modbus TCP slave server** — push values from any flow, let PLCs / SCADA / HMIs read them
-- **Free passive traffic monitor** — see every Modbus op (timing, values, errors) in real time
+- **Passive traffic monitor** — see every Modbus op (timing, values, errors) in real time
 - **Outputs raw register values** — pair with [`node-red-contrib-bytes-modpackqt`](https://www.npmjs.com/package/node-red-contrib-bytes-modpackqt) to decode int / float / string / bitmask
 - **Zero external dependencies** — Modbus runs inside the Node-RED process
 
@@ -82,7 +84,7 @@ Drop a **modbus traffic** node anywhere on the canvas, point it at the same runt
 }
 ```
 
-Filter by direction, function code, or target if you only want a slice. **Free, doesn't count toward your daily op cap.**
+Filter by direction, function code, or target if you only want a slice.
 
 ### 4. Be a Modbus slave (let SCADA read your values)
 
@@ -137,30 +139,65 @@ External masters connecting to `your-host:1502`, unit `1`, FC `3`, address `0`,
 
 | Node | Purpose |
 |---|---|
-| `modpackqt-config` | Shared runtime — master mode (TCP/RTU), serial settings, optional slave server, API key |
+| `modpackqt-config` | Shared runtime — master mode (TCP/RTU), serial settings, optional slave server |
 | `modpackqt-master-read` | Read FC1/FC2/FC3/FC4 from a remote Modbus device |
 | `modpackqt-master-write` | Write FC5/FC6/FC15/FC16 to a remote Modbus device |
 | `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. Free, with filters, full visibility into what's happening on the wire. |
+| `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. |
 
 ---
 
-## Pricing
+## 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
 
-| | Free | Paid |
-|---|---|---|
-| Master read / write | ✓ | ✓ |
-| Embedded slave server | ✓ | ✓ |
-| **Traffic monitor** | ✓ | ✓ |
-| Daily ops cap | **1,000 / day** per Node-RED instance | **Unlimited** |
-| Branding in node status | Visible | Hidden |
-| API key required | No | Yes |
-| Trial | — | **30 days free, no credit card** |
+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.
+
+---
 
-[Get a free trial key →](https://modpackqt.com/nodered)
+## Why this palette?
 
-When the daily cap is hit, master read/write nodes return a clear error pointing at the upgrade link. **Traffic events, slave register reads/writes, and decode/encode operations don't count.**
+These nodes are built for **commissioning, testing, and analysis** — the kind of work where you need to quickly probe a device, verify register layouts, decode bytes correctly, simulate a slave for SCADA development, or watch traffic to debug a flaky link. Pair them with the [ModPackQT web console](https://modpackqt.com) for AI-assisted register decoding, profile management, and a full visual tester.
 
 ---
 
@@ -178,7 +215,6 @@ Make sure `node-red-contrib-bytes-modpackqt` is also installed before importing
 
 | Issue | Solution |
 |---|---|
-| `ModPackQT free tier limit reached` | Either wait until midnight or [get a free trial key](https://modpackqt.com/nodered) |
 | Decoded float looks like garbage | Try a different word order (`BE` ↔ `LE_SWAP`) — common conventions are ABCD and CDAB |
 | `Serial port not configured for RTU mode` | Open runtime config → set Serial Port (e.g. `/dev/ttyUSB0` or `COM3`) |
 | `EADDRINUSE` on slave port | Another process already uses that port. Pick a different one (e.g. `1502`). |
@@ -194,10 +230,9 @@ Make sure `node-red-contrib-bytes-modpackqt` is also installed before importing
 - **Security issues:** report privately via the [security page](https://modpackqt.com/security).
 - **Updates are never automatic.** Node-RED's palette manager will show
   "update available" when we publish a new version — you choose when to
-  upgrade. Pin a major version (`^2.0.0`) in production.
+  upgrade. Pin a major version (`^3.0.0`) for stability.
 - **Changelog:** the `CHANGELOG.md` file is shipped inside this package. We
   follow [semver](https://semver.org/) — patch releases for bug fixes only.
-- **Paid customers** get notice for security and breaking-change releases.
 
 ---
 
@@ -212,4 +247,4 @@ Make sure `node-red-contrib-bytes-modpackqt` is also installed before importing
 
 ## License & disclaimer
 
-MIT — © ModPackQT. Provided **"as is" without warranty of any kind**. You are responsible for validating this software in your environment before any production use.
+MIT — © ModPackQT. Provided **"as is" without warranty of any kind**. You are responsible for validating this software in your environment before any use with real equipment.

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-config.html

@@ -102,15 +102,14 @@
     <input type="number" id="node-config-input-slavePort" placeholder="1502">
   </div>
 
-  <h4 style="margin-top:18px">API Key (optional — for unlimited usage)</h4>
+  <h4 style="margin-top:18px">API Key (optional — reserved for future cloud features)</h4>
   <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="Free trial — get one at modpackqt.com/nodered">
+    <input type="password" id="node-config-input-apiKey" placeholder="Optional — leave blank for local-only use">
   </div>
 
   <div class="form-tips">
-    <b>No extra app needed.</b> Modbus runs inside Node-RED.<br>
-    <b>Free tier:</b> 1,000 ops/day. <a href="https://modpackqt.com/nodered" target="_blank">Get unlimited →</a>
+    <b>No extra app needed.</b> Modbus runs inside Node-RED. 100% free, no usage limits.
   </div>
   <div class="form-row" style="margin-top:18px;padding-top:14px;border-top:1px solid #e5e7eb;text-align:center;">
       <a href="https://modpackqt.com" target="_blank" rel="noopener noreferrer"
@@ -146,9 +145,7 @@
 
   <h3>API key (optional)</h3>
   <p>
-    Leave blank for the free anonymous tier (1,000 ops/day per Node-RED instance,
-    branding visible in node status).
-    Add a key for unlimited use and clean status text — <a href="https://modpackqt.com/nodered" target="_blank">get a free 30-day trial key →</a>.
-    No credit card required.
+    Reserved for future cloud features (profile sync, remote console). Leave blank
+    for local-only use — all Modbus functionality works without a key.
   </p>
 </script>

package/nodes/modpackqt-config.js

@@ -4,19 +4,11 @@
  * Owns:
  *   - A connection pool of Modbus TCP/RTU master clients (one per target).
  *   - An optional embedded Modbus TCP slave server with a local register store.
- *   - A local rate-limit counter (anonymous tier: 1,000 ops/day per Node-RED instance).
- *
- * Phase 1: limits are enforced locally only. Phase 2 will validate the API key
- * against the ModPackQT cloud lease endpoint for unlimited usage.
  */
 module.exports = function (RED) {
   const ModbusRTU = require('modbus-serial');
   const { EventEmitter } = require('events');
 
-  const FREE_DAILY_LIMIT = 1000;
-  const UPGRADE_URL = 'https://modpackqt.com/nodered';
-  const DEBUG_LOG_INTERVAL = 100; // log "powered by ModPackQT" every N ops
-
   function ModPackQTConfigNode(config) {
     RED.nodes.createNode(this, config);
     const node = this;
@@ -42,46 +34,24 @@ module.exports = function (RED) {
     node.slavePort    = parseInt(config.slavePort, 10) || 1502;
     node.slaveHost    = config.slaveHost || '0.0.0.0';
 
-    // ---- Auth (Phase 2) ----
+    // ---- Optional API key (reserved for future cloud features) ----
     node.apiKey = (node.credentials && node.credentials.apiKey) || '';
 
     // ====================================================================
-    // RATE LIMITING (local, in-memory)
+    // OPS COUNTER (informational only — no limit enforced)
     // ====================================================================
     const today = () => new Date().toISOString().slice(0, 10);
     node._opsDay   = today();
     node._opsCount = 0;
 
     node.checkLimit = function () {
-      // Reset counter at midnight
       const d = today();
       if (d !== node._opsDay) { node._opsDay = d; node._opsCount = 0; }
-
-      // Phase 1: anonymous tier only — API key currently ignored for billing
-      if (node._opsCount >= FREE_DAILY_LIMIT) {
-        const err = new Error(
-          `ModPackQT free tier limit reached (${FREE_DAILY_LIMIT} ops/day). ` +
-          `Get a free trial API key at ${UPGRADE_URL}`
-        );
-        err.code = 'RATE_LIMIT';
-        throw err;
-      }
       node._opsCount += 1;
-
-      if (node._opsCount % DEBUG_LOG_INTERVAL === 0) {
-        node.log(
-          `[modpackqt] ${node._opsCount} ops served today — ` +
-          `unlock unlimited at ${UPGRADE_URL}`
-        );
-      }
       return node._opsCount;
     };
 
-    node.brandStatus = function (text) {
-      // Phase 1: branding always visible (anonymous tier).
-      // Phase 2: paid users get clean text without the "modpackqt ·" prefix.
-      return `modpackqt · ${text}`;
-    };
+    node.brandStatus = function (text) { return text; };
 
     node.opsToday = function () { return node._opsCount; };
 
@@ -323,8 +293,7 @@ module.exports = function (RED) {
         node._slaveServer.on('socketError', (err) => node.warn(`[slave] socket error: ${err.message}`));
         node._slaveServer.on('serverError', (err) => node.error(`[slave] server error: ${err.message}`));
         node.log(
-          `[modpackqt] embedded Modbus slave listening on ${node.slaveHost}:${node.slavePort} — ` +
-          `powered by ModPackQT (${UPGRADE_URL})`
+          `[modpackqt] embedded Modbus slave listening on ${node.slaveHost}:${node.slavePort}`
         );
       } catch (err) {
         node.error(`Failed to start embedded slave server: ${err.message}`);

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-master-read.html

@@ -90,6 +90,4 @@
     <dt>topic <span class="property-type">string</span></dt>
     <dd><code>modpackqt/read/{host}:{port}/fc{N}/{address}</code></dd>
   </dl>
-  <h3>Free tier</h3>
-  <p>1,000 ops/day per Node-RED instance. Add an API key in the runtime config for unlimited use.</p>
 </script>

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/nodes/modpackqt-traffic.html

@@ -123,5 +123,5 @@
   </ul>
 
   <h3>Pricing</h3>
-  <p><b>Free</b> — visibility costs nothing. Traffic events themselves don't count toward your daily op limit.</p>
+  <p><b>Free</b> — full visibility into every Modbus operation, no usage limits.</p>
 </script>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-modbus-modpackqt",
-  "version": "2.1.1",
-  "description": "Node-RED Modbus nodes — embedded Modbus TCP/RTU master + slave server, no extra apps required. By ModPackQT. FC1/FC2/FC3/FC4 reads, FC5/FC6/FC15/FC16 writes, a built-in slave register store, and a free passive traffic monitor for debugging.",
+  "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",
     "modbus",
@@ -11,6 +11,9 @@
     "modbus-master",
     "modbus-slave",
     "modbus-server",
+    "modbus-tester",
+    "modbus-commissioning",
+    "modbus-analyzer",
     "industrial",
     "automation",
     "holding-register",
@@ -46,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": {