node-red-contrib-antenna-genius 1.0.1 → 2.0.0

package/.github/workflows/codeql-analysis.yml

@@ -38,11 +38,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -53,7 +53,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v4
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -67,4 +67,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v4

package/.github/workflows/njsscan-analysis.yml

@@ -23,13 +23,13 @@ jobs:
     name: njsscan code scanning
     steps:
     - name: Checkout the code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
     - name: nodejsscan scan
       id: njsscan
       uses: ajinabraham/njsscan-action@7237412fdd36af517e2745077cedbf9d6900d711
       with:
         args: '. --sarif --output results.sarif || true'
     - name: Upload njsscan report
-      uses: github/codeql-action/upload-sarif@v1
+      uses: github/codeql-action/upload-sarif@v4
       with:
         sarif_file: results.sarif

package/.github/workflows/node.js.yml

@@ -18,13 +18,13 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [22.x, 24.x, 26.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
+      uses: actions/setup-node@v6
       with:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'

package/.github/workflows/npm-publish.yml

@@ -11,24 +11,28 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
         with:
-          node-version: 16
+          node-version: 24
+          package-manager-cache: false 
       - run: npm ci
       - run: npm test
 
   publish-npm:
     needs: build
     runs-on: ubuntu-latest
+# Required permissions for OIDC provenance tracking and package deployment
+    permissions:
+      contents: read
+      id-token: write
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
         with:
-          node-version: 16
+          node-version: 24
           registry-url: https://registry.npmjs.org/
+          package-manager-cache: false  # never use caching in release builds
       - run: npm ci
       - run: npx auto-dist-tag --write
       - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/GeniusV4Protocol.js

@@ -0,0 +1,162 @@
+class GeniusV4Protocol {
+    constructor(socket) {
+        this.socket = socket;
+        this.seq = 0;
+        this.pending = new Map();
+        this.lineBuffer = "";
+        this.statusHandler = null;
+    }
+
+    nextSeq() {
+        this.seq = (this.seq % 255) + 1;
+        return this.seq;
+    }
+
+    handleData(chunk) {
+        this.lineBuffer += chunk.toString("utf8");
+        const lines = this.lineBuffer.split("\n");
+        this.lineBuffer = lines.pop();
+        for (const line of lines) {
+            this._handleLine(line.replace(/\r$/, ""));
+        }
+    }
+
+    _handleLine(line) {
+        if (!line) return;
+
+        if (line.startsWith("S")) {
+            const pipeIdx = line.indexOf("|");
+            const msg = pipeIdx !== -1 ? line.substring(pipeIdx + 1) : "";
+            if (this.statusHandler) {
+                this.statusHandler(msg);
+            }
+            return;
+        }
+
+        if (line.startsWith("R")) {
+            const pipeIdx1 = line.indexOf("|");
+            const pipeIdx2 = line.indexOf("|", pipeIdx1 + 1);
+            const seq = parseInt(line.substring(1, pipeIdx1));
+            const hexResult = line.substring(pipeIdx1 + 1, pipeIdx2 !== -1 ? pipeIdx2 : undefined);
+            const message = pipeIdx2 !== -1 ? line.substring(pipeIdx2 + 1) : "";
+
+            const pending = this.pending.get(seq);
+            if (!pending) return;
+
+            if (parseInt(hexResult, 16) !== 0) {
+                this.pending.delete(seq);
+                pending.reject(new Error(`Command error: 0x${hexResult} - ${message}`));
+                return;
+            }
+
+            if (pending.multi) {
+                if (message === "") {
+                    this.pending.delete(seq);
+                    pending.resolve(pending.lines);
+                } else {
+                    pending.lines.push(message);
+                }
+            } else {
+                this.pending.delete(seq);
+                pending.resolve(message);
+            }
+        }
+    }
+
+    sendCommand(cmd) {
+        const seq = this.nextSeq();
+        return new Promise((resolve, reject) => {
+            this.pending.set(seq, { resolve, reject, lines: null, multi: false });
+            this.socket.write(`C${seq}|${cmd}\r\n`);
+        });
+    }
+
+    sendCommandMulti(cmd) {
+        const seq = this.nextSeq();
+        return new Promise((resolve, reject) => {
+            this.pending.set(seq, { resolve, reject, lines: [], multi: true });
+            this.socket.write(`C${seq}|${cmd}\r\n`);
+        });
+    }
+
+    onStatus(handler) {
+        this.statusHandler = handler;
+    }
+}
+
+const parseKeyValues = (tokens, startIndex) => {
+    const kv = {};
+    for (let i = startIndex; i < tokens.length; i++) {
+        const eq = tokens[i].indexOf("=");
+        if (eq !== -1) {
+            kv[tokens[i].substring(0, eq)] = tokens[i].substring(eq + 1);
+        }
+    }
+    return kv;
+};
+
+const parseInfo = (msg) => {
+    // "info v=4.0.22 date=2023-08-22 btl=1.6 hw=2.0 serial=9A-3A-DC name=Antenna_Genius ports=2 antennas=8 mode=master uptime=3600"
+    const tokens = msg.split(" ");
+    const kv = parseKeyValues(tokens, 1);
+    return {
+        name: (kv.name || "").replace(/_/g, " "),
+        ports: parseInt(kv.ports) || 2,
+        antennas: parseInt(kv.antennas) || 8,
+        firmware: kv.v || "",
+        serial: kv.serial || "",
+    };
+};
+
+const parsePort = (msg) => {
+    // "port 1 auto=1 source=AUTO band=0 rxant=0 txant=0 tx=0 inhibit=0"
+    const tokens = msg.split(" ");
+    const portNum = parseInt(tokens[1]);
+    const kv = parseKeyValues(tokens, 2);
+    return {
+        portNum,
+        band: parseInt(kv.band) || 0,
+        rxant: parseInt(kv.rxant) || 0,
+        txant: parseInt(kv.txant) || 0,
+        tx: parseInt(kv.tx) || 0,
+        inhibit: parseInt(kv.inhibit) || 0,
+    };
+};
+
+const parseAntennaList = (lines) => {
+    // "antenna 1 name=Antenna_1 tx=0000 rx=0001 inband=0000"
+    return lines.map((line) => {
+        const tokens = line.split(" ");
+        const index = parseInt(tokens[1]);
+        const kv = parseKeyValues(tokens, 2);
+        const rxMask = parseInt(kv.rx || "0", 16);
+        const bands = [];
+        for (let i = 0; i < 16; i++) {
+            bands.push((rxMask >> i) & 1);
+        }
+        return {
+            index,
+            name: (kv.name || "").replace(/_/g, " "),
+            bands,
+        };
+    });
+};
+
+const parseBandList = (lines) => {
+    // "band 0 name=None freq_start=0.000000 freq_stop=0.000000"
+    return lines.map((line) => {
+        const tokens = line.split(" ");
+        const index = parseInt(tokens[1]);
+        const kv = parseKeyValues(tokens, 2);
+        return {
+            index,
+            name: (kv.name || "").replace(/_/g, " "),
+        };
+    });
+};
+
+exports.GeniusV4Protocol = GeniusV4Protocol;
+exports.parseInfo = parseInfo;
+exports.parsePort = parsePort;
+exports.parseAntennaList = parseAntennaList;
+exports.parseBandList = parseBandList;

package/README.md

@@ -1,6 +1,8 @@
 # node-red-contrib-antenna-genius
 Antenna Genius Control and Monitoring Nodes
 
+Supports V3 and V4 of the Antenna Genius firmware.
+
 [![Node.js CI](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/node.js.yml/badge.svg)](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/node.js.yml) [![Node.js Package](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/npm-publish.yml) [![CodeQL](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/codeql-analysis.yml) [![njsscan sarif](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/njsscan-analysis.yml/badge.svg)](https://github.com/sm6srw/node-red-contrib-antenna-genius/actions/workflows/njsscan-analysis.yml)
 
 ![image](https://user-images.githubusercontent.com/7033002/148573983-00305f15-7acf-4d4d-bb1f-9c820c4b3a79.png) ![image](https://user-images.githubusercontent.com/7033002/148489672-9e2c03e0-a968-4c2f-9dc7-923c5423fad7.png)
@@ -94,3 +96,4 @@ Antenna Genius shared connection configuration.
 `Active Background (string)`: Background color to use for an antenna that is active (e.g. can be selected).
 
 `Selected Background (string)`: Background color to use for and antenna that is selected.
+

package/SECURITY.md

@@ -0,0 +1,8 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.0.x   | :white_check_mark: |
+

package/antenna-genius-activate-antenna.js

@@ -1,5 +1,3 @@
-const Utils = require("./GeniusUtils");
-
 module.exports = (RED) => {
     class AntennaGeniusActivateAntenna {
         constructor(config) {
@@ -47,9 +45,7 @@ module.exports = (RED) => {
                         });
                     }
 
-                    let command = Utils.encode(0, 0, 415, 0, msg.topic);
-
-                    this.server.client.write(command);
+                    this.server.activate(msg.topic);
                 } else {
                     this.status({
                         fill: "red",

package/antenna-genius-server.js

@@ -2,6 +2,7 @@ const Net = require("net");
 const { PromiseSocket } = require("promise-socket");
 const EventEmitter = require("events");
 const Utils = require("./GeniusUtils");
+const { GeniusV4Protocol, parseInfo, parsePort, parseAntennaList, parseBandList } = require("./GeniusV4Protocol");
 
 class UpdatesEventEmitter extends EventEmitter {}
 
@@ -23,6 +24,9 @@ module.exports = (RED) => {
             this.interval = null;
             this.timer = null;
             this.refresh = -1;
+            this.apiVersion = null;
+            this._v4 = null;
+            this._v4DataHandler = null;
 
             this.updatesEventEmitter = new UpdatesEventEmitter();
             this.updatesEventEmitter.setMaxListeners(0);
@@ -34,6 +38,13 @@ module.exports = (RED) => {
                 this.log("TCP connection disconnected with the server.");
                 clearInterval(this.interval);
                 clearTimeout(this.timer);
+                this.connected = false;
+
+                if (this._v4DataHandler) {
+                    this.client.removeListener("data", this._v4DataHandler);
+                    this._v4DataHandler = null;
+                }
+                this._v4 = null;
 
                 if (this.updatesEventEmitter.listenerCount("closed") == 0) {
                     this.log(
@@ -58,60 +69,33 @@ module.exports = (RED) => {
                 this.log("TCP connection established with the server.");
                 this.connected = true;
 
-                const promiseClient = new PromiseSocket(this.client);
-
-                let command = Utils.encode(0, 0, 401, 0, "");
-                await promiseClient.write(command);
-                let packet = await promiseClient.read();
-                this.status = Utils.decode(packet);
-
-                command = Utils.encode(0, 0, 24, 0, "");
-                await promiseClient.write(command);
-                packet = await promiseClient.read();
-                this.info = Utils.decode(packet);
-
-                let numAntennas = 8 * this.status.stackReach;
-                for (let index = 1; index <= numAntennas; ++index) {
-                    let command = Utils.encode(0, 0, 412, 0, index.toString());
-                    await promiseClient.write(command);
-                    let packet = await promiseClient.read();
-                    let data = Utils.decode(packet);
-                    this.antennas.push(data);
-                }
-                this.updatesEventEmitter.emit("antennas");
-
-                for (let index = 0; index < 16; ++index) {
-                    let command = Utils.encode(0, 0, 82, 0, index.toString());
-                    await promiseClient.write(command);
-                    let packet = await promiseClient.read();
-                    let data = Utils.decode(packet);
-                    this.bands.push(data);
-                }
-                this.updatesEventEmitter.emit("bands");
-
-                this.client.on("data", (packet) => {
-                    let decoded = Utils.decode(packet);
-                    if (decoded.command == 401) {
-                        this.status = {
-                            ...this.status,
-                            ...Utils.decode(packet),
-                        };
-                        this.refresh = (this.refresh + 1) % 1500;
-                        this.updatesEventEmitter.emit(
-                            "status",
-                            this.refresh == 0
-                        );
-                    }
+                // Detect API version from prologue banner.
+                // V4 devices immediately send "V4.x.x AG\r\n" upon connection.
+                // V3 devices send nothing and wait for commands.
+                const banner = await new Promise((resolve) => {
+                    let timer;
+                    const handler = (data) => {
+                        clearTimeout(timer);
+                        resolve(data.toString());
+                    };
+                    timer = setTimeout(() => {
+                        this.client.removeListener("data", handler);
+                        resolve(null);
+                    }, 300);
+                    this.client.once("data", handler);
                 });
 
-                // Poll status
-                this.interval = setInterval(() => {
-                    let command = Utils.encode(0, 0, 401, 0, "");
-                    this.client.write(command);
-                }, 400);
-
-                this.forceUpdate();
-                this.updatesEventEmitter.emit("connected");
+                try {
+                    if (banner && /^V4/.test(banner)) {
+                        this.apiVersion = 4;
+                        await this._connectV4();
+                    } else {
+                        this.apiVersion = 3;
+                        await this._connectV3();
+                    }
+                } catch (err) {
+                    this.warn("Connection setup failed: " + err.message);
+                }
             });
 
             this.client.on("error", (err) => {
@@ -123,12 +107,162 @@ module.exports = (RED) => {
                 clearTimeout(this.timer);
                 this.autoConnect = false;
                 this.connected = false;
+                if (this._v4DataHandler) {
+                    this.client.removeListener("data", this._v4DataHandler);
+                    this._v4DataHandler = null;
+                }
+                this._v4 = null;
                 this.client.end();
                 this.forceUpdate();
                 done();
             });
         }
 
+        async _connectV3() {
+            const promiseClient = new PromiseSocket(this.client);
+
+            let command = Utils.encode(0, 0, 401, 0, "");
+            await promiseClient.write(command);
+            let packet = await promiseClient.read();
+            this.status = Utils.decode(packet);
+
+            command = Utils.encode(0, 0, 24, 0, "");
+            await promiseClient.write(command);
+            packet = await promiseClient.read();
+            this.info = Utils.decode(packet);
+
+            let numAntennas = 8 * this.status.stackReach;
+            for (let index = 1; index <= numAntennas; ++index) {
+                let command = Utils.encode(0, 0, 412, 0, index.toString());
+                await promiseClient.write(command);
+                let packet = await promiseClient.read();
+                let data = Utils.decode(packet);
+                this.antennas.push(data);
+            }
+            this.updatesEventEmitter.emit("antennas");
+
+            for (let index = 0; index < 16; ++index) {
+                let command = Utils.encode(0, 0, 82, 0, index.toString());
+                await promiseClient.write(command);
+                let packet = await promiseClient.read();
+                let data = Utils.decode(packet);
+                this.bands.push(data);
+            }
+            this.updatesEventEmitter.emit("bands");
+
+            this.client.on("data", (packet) => {
+                let decoded = Utils.decode(packet);
+                if (decoded.command == 401) {
+                    this.status = {
+                        ...this.status,
+                        ...Utils.decode(packet),
+                    };
+                    this.refresh = (this.refresh + 1) % 1500;
+                    this.updatesEventEmitter.emit(
+                        "status",
+                        this.refresh == 0
+                    );
+                }
+            });
+
+            this.interval = setInterval(() => {
+                let command = Utils.encode(0, 0, 401, 0, "");
+                this.client.write(command);
+            }, 400);
+
+            this.forceUpdate();
+            this.updatesEventEmitter.emit("connected");
+        }
+
+        async _connectV4() {
+            const v4 = new GeniusV4Protocol(this.client);
+            this._v4 = v4;
+
+            const dataHandler = (chunk) => v4.handleData(chunk);
+            this._v4DataHandler = dataHandler;
+            this.client.on("data", dataHandler);
+
+            const infoMsg = await v4.sendCommand("info get");
+            this.info = parseInfo(infoMsg);
+
+            const port1Msg = await v4.sendCommand("port get 1");
+            const port2Msg = await v4.sendCommand("port get 2");
+            const port1 = parsePort(port1Msg);
+            const port2 = parsePort(port2Msg);
+            this.status = {
+                portA_band: port1.band,
+                portA_antenna: port1.rxant,
+                portA_tx: port1.tx,
+                portA_inhibit: port1.inhibit,
+                portB_band: port2.band,
+                portB_antenna: port2.rxant,
+                portB_tx: port2.tx,
+                portB_inhibit: port2.inhibit,
+                stackReach: Math.ceil(this.info.antennas / 8),
+            };
+
+            const antennaLines = await v4.sendCommandMulti("antenna list");
+            this.antennas = parseAntennaList(antennaLines);
+            this.updatesEventEmitter.emit("antennas");
+
+            const bandLines = await v4.sendCommandMulti("band list");
+            this.bands = parseBandList(bandLines);
+            this.updatesEventEmitter.emit("bands");
+
+            await v4.sendCommand("sub port all");
+
+            v4.onStatus((msg) => {
+                if (msg.startsWith("port ")) {
+                    const portData = parsePort(msg);
+                    if (portData.portNum === 1) {
+                        this.status.portA_band = portData.band;
+                        this.status.portA_antenna = portData.rxant;
+                        this.status.portA_tx = portData.tx;
+                        this.status.portA_inhibit = portData.inhibit;
+                    } else if (portData.portNum === 2) {
+                        this.status.portB_band = portData.band;
+                        this.status.portB_antenna = portData.rxant;
+                        this.status.portB_tx = portData.tx;
+                        this.status.portB_inhibit = portData.inhibit;
+                    }
+                    this.refresh = (this.refresh + 1) % 1500;
+                    this.updatesEventEmitter.emit("status", this.refresh === 0);
+                } else if (msg === "antenna reload") {
+                    this._reloadV4Antennas();
+                }
+            });
+
+            this.updatesEventEmitter.emit("connected");
+            // Emit initial status so consumer nodes produce output immediately.
+            // In v3 the poll interval does this; in v4 we only get push updates
+            // when something changes, so we trigger it manually here.
+            this.refresh = 0;
+            this.updatesEventEmitter.emit("status", true);
+        }
+
+        async _reloadV4Antennas() {
+            if (!this._v4) return;
+            try {
+                const antennaLines = await this._v4.sendCommandMulti("antenna list");
+                this.antennas = parseAntennaList(antennaLines);
+                this.updatesEventEmitter.emit("antennas");
+            } catch (err) {
+                this.warn("Failed to reload antennas: " + err.message);
+            }
+        }
+
+        activate(topic) {
+            if (this.apiVersion === 4 && this._v4) {
+                const [port, antenna] = topic.split(";");
+                this._v4
+                    .sendCommand(`port set ${port} rxant=${antenna} txant=${antenna}`)
+                    .catch(() => {});
+            } else {
+                const command = Utils.encode(0, 0, 415, 0, topic);
+                this.client.write(command);
+            }
+        }
+
         connect() {
             if (this.autoConnect && !this.connected & !this.client.connecting) {
                 this.client.connect(this.port, this.host);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-antenna-genius",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Antenna Genius Control and Monitoring Nodes",
   "keywords": [
     "node-red"
@@ -35,9 +35,9 @@
   },
   "devDependencies": {
     "auto-dist-tag": "^2.1.1",
-    "jest": "^27.4.7",
-    "node-red": "^2.1.4",
-    "node-red-node-test-helper": "^0.2.7"
+    "jest": "^28.1.3",
+    "node-red": "^5.0.0",
+    "node-red-node-test-helper": "^0.3.6"
   },
   "jest": {
     "verbose": true

package/test/GeniusTestServerV4.js

@@ -0,0 +1,102 @@
+const net = require("net");
+
+var server;
+
+const bands = [
+    "band 0 name=None freq_start=0.000000 freq_stop=0.000000",
+    "band 1 name=160m freq_start=1.600000 freq_stop=2.200000",
+    "band 2 name=80m freq_start=3.300000 freq_stop=4.000000",
+    "band 3 name=40m freq_start=6.800000 freq_stop=7.400000",
+    "band 4 name=30m freq_start=9.900000 freq_stop=10.350000",
+    "band 5 name=20m freq_start=13.800000 freq_stop=14.550000",
+    "band 6 name=17m freq_start=17.868000 freq_stop=18.368000",
+    "band 7 name=15m freq_start=20.800000 freq_stop=21.650000",
+    "band 8 name=12m freq_start=24.690000 freq_stop=25.190000",
+    "band 9 name=10m freq_start=27.800000 freq_stop=29.900000",
+    "band 10 name=6m freq_start=49.800000 freq_stop=54.200000",
+    "band 11 name=60m freq_start=5.000000 freq_stop=6.000000",
+    "band 12 name=Custom_1 freq_start=0.000000 freq_stop=0.000000",
+    "band 13 name=Custom_2 freq_start=0.000000 freq_stop=0.000000",
+    "band 14 name=Custom_3 freq_start=0.000000 freq_stop=0.000000",
+    "band 15 name=Custom_4 freq_start=0.000000 freq_stop=0.000000",
+];
+
+const antennas = [
+    "antenna 1 name=Antenna_1 tx=ffff rx=ffff inband=0000",
+    "antenna 2 name=Antenna_2 tx=ffff rx=ffff inband=0000",
+    "antenna 3 name=Antenna_3 tx=ffff rx=ffff inband=0000",
+    "antenna 4 name=Antenna_4 tx=ffff rx=ffff inband=0000",
+    "antenna 5 name=Antenna_5 tx=ffff rx=ffff inband=0000",
+    "antenna 6 name=Antenna_6 tx=ffff rx=ffff inband=0000",
+    "antenna 7 name=Antenna_7 tx=ffff rx=ffff inband=0000",
+    "antenna 8 name=Antenna_8 tx=ffff rx=ffff inband=0000",
+];
+
+const start = () => {
+    server = net.createServer();
+    server.on("connection", (conn) => {
+        let lineBuffer = "";
+        let portSubscribed = false;
+
+        // Send v4 banner immediately on connect
+        conn.write("V4.0.22 AG\r\n");
+
+        const sendResponse = (seq, message) => {
+            conn.write(`R${seq}|0|${message}\r\n`);
+        };
+
+        const sendMultiResponse = (seq, lines) => {
+            for (const line of lines) {
+                conn.write(`R${seq}|0|${line}\r\n`);
+            }
+            conn.write(`R${seq}|0|\r\n`);
+        };
+
+        conn.on("data", (data) => {
+            lineBuffer += data.toString();
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop();
+
+            for (const line of lines) {
+                const trimmed = line.replace(/\r$/, "").trim();
+                if (!trimmed.startsWith("C")) continue;
+
+                const pipeIdx = trimmed.indexOf("|");
+                const seq = parseInt(trimmed.substring(1, pipeIdx));
+                const cmd = trimmed.substring(pipeIdx + 1);
+
+                if (cmd === "info get") {
+                    sendResponse(seq, "info v=4.0.22 date=2023-08-22 btl=1.6 hw=2.0 serial=9A-3A-DC name=TestGenius ports=2 antennas=8 mode=master uptime=3600");
+                } else if (cmd === "port get 1") {
+                    sendResponse(seq, "port 1 auto=1 source=AUTO band=1 rxant=2 txant=2 tx=0 inhibit=0");
+                } else if (cmd === "port get 2") {
+                    sendResponse(seq, "port 2 auto=1 source=AUTO band=2 rxant=4 txant=4 tx=0 inhibit=0");
+                } else if (cmd === "antenna list") {
+                    sendMultiResponse(seq, antennas);
+                } else if (cmd === "band list") {
+                    sendMultiResponse(seq, bands);
+                } else if (cmd === "sub port all") {
+                    portSubscribed = true;
+                    sendResponse(seq, "");
+                } else if (cmd.startsWith("port set ")) {
+                    sendResponse(seq, "");
+                } else {
+                    sendResponse(seq, "");
+                }
+            }
+        });
+    });
+
+    return new Promise((resolve) => {
+        server.listen(0, "localhost", () => {
+            return resolve(server.address().port);
+        });
+    });
+};
+
+const stop = () => {
+    server.unref();
+};
+
+exports.start = start;
+exports.stop = stop;

package/test/antenna-genius-server-v4.spec.js

@@ -0,0 +1,172 @@
+const helper = require("node-red-node-test-helper");
+const serverNode = require("../antenna-genius-server.js");
+const testServer = require("./GeniusTestServerV4.js");
+
+describe("antenna-genius-server Node (v4)", () => {
+    var port;
+
+    beforeEach(async () => {
+        port = await testServer.start();
+    });
+
+    afterEach(async () => {
+        testServer.stop();
+        helper.unload();
+    });
+
+    it("should be loaded", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            expect(n1).toBeDefined();
+            done();
+        });
+    });
+
+    it("can connect and detect v4", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            n1.updatesEventEmitter.on("connected", () => {
+                expect(n1.connected).toBeTruthy();
+                expect(n1.apiVersion).toBe(4);
+                done();
+            });
+            n1.connect();
+        });
+    });
+
+    it("parses info correctly", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            n1.updatesEventEmitter.on("connected", () => {
+                expect(n1.info.name).toBe("TestGenius");
+                expect(n1.info.ports).toBe(2);
+                expect(n1.info.antennas).toBe(8);
+                done();
+            });
+            n1.connect();
+        });
+    });
+
+    it("parses port status correctly", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            n1.updatesEventEmitter.on("connected", () => {
+                expect(n1.status.portA_band).toBe(1);
+                expect(n1.status.portA_antenna).toBe(2);
+                expect(n1.status.portB_band).toBe(2);
+                expect(n1.status.portB_antenna).toBe(4);
+                expect(n1.status.stackReach).toBe(1);
+                done();
+            });
+            n1.connect();
+        });
+    });
+
+    it("parses antenna list correctly", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            n1.updatesEventEmitter.on("connected", () => {
+                expect(n1.antennas.length).toBe(8);
+                expect(n1.antennas[0].index).toBe(1);
+                expect(n1.antennas[0].name).toBe("Antenna 1");
+                expect(n1.antennas[0].bands).toStrictEqual(
+                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+                );
+                done();
+            });
+            n1.connect();
+        });
+    });
+
+    it("parses band list correctly", (done) => {
+        let flow = [
+            {
+                id: "n1",
+                type: "antenna-genius-server",
+                name: "test name",
+                host: "localhost",
+                port: port,
+                disabledColor: "Black",
+                activeColor: "Green",
+                selectedColor: "Blue",
+                autoConnect: true,
+            },
+        ];
+        helper.load(serverNode, flow, () => {
+            let n1 = helper.getNode("n1");
+            n1.updatesEventEmitter.on("connected", () => {
+                expect(n1.bands.length).toBe(16);
+                expect(n1.bands[0].name).toBe("None");
+                expect(n1.bands[1].name).toBe("160m");
+                expect(n1.bands[5].name).toBe("20m");
+                done();
+            });
+            n1.connect();
+        });
+    });
+});