nodejs-poolcontroller 8.1.0 → 8.1.1

package/README.md

@@ -66,8 +66,6 @@ If you don't know anything about NodeJS, these directions might be helpful.
 1. Run the app with `npm start`.
    * `npm start` will compile the Typescript code.  You should use this every time you download/clone/pull the latest code.
    * `npm run start:cached` will run the app without compiling the code which can be much faster.
-1. Running `npm start` will also create a `config.json` file for your installation.  If you need to modify any properties (e.g. the path to your serialport adapter, enabling socat, etc) then stop the app, edit the `config.json` per the [instructions](module_nodejs-poolController--config.json) below, and start the app again.
-1. Verify your pool equipment is correctly identified by inspecting the `/data/*.json` files.  
 1. Install a [webclient](module_nodejs-poolController--clients) for a browser experience and/or a [binding](module_nodejs-poolController--bindings) to have two way control with Home Automation systems.
 
 For a very thorough walk-through, see [this](https://www.troublefreepool.com/threads/pentair-intellicenter-pool-control-dashboard-instructional-guide.218514/) great thread on Trouble Free Pool.  Thanks @MyAZPool.
@@ -101,16 +99,13 @@ To do anything with this app, you need a client to connect to it.  A client can
 
 ## Web Clients
 1. [nodejs-poolController-dashPanel](https://github.com/rstrouse/nodejs-poolController-dashPanel).  Full compatibility with IntelliCenter, *Touch, REM (RelayEquipmentManager).
-1. Deprecated - ~~[nodejs-poolController-webClient](http://github.com/tagyoureit/nodejs-poolController-webClient).  Built primarily around EasyTouch/IntelliTouch but will work with other systems.~~
 
-* This app has the default to only listen to clients from localhost (127.0.0.1).  If you need to have clients connect from other machines you will need to change the [ip](#module_nodejs-poolController--config.json) in `config.json`.
 
 <a name="module_nodejs-poolController--bindings"></a>
 
 ## Home Automation Bindings (previously Integrations)
-**NOTE: Existing integrations built of 5.3 or earlier WILL NOT WORK.  They need to be upgraded to leverage 6.0.  **
 
-Available for 6.x:
+Available automations:
 * [Vera Home Automation Hub](https://github.com/rstrouse/nodejs-poolController-veraPlugin) - A plugin that integrates with nodejs-poolController.  [Bindings Directions](https://github.com/tagyoureit/nodejs-poolController/wiki/Bindings-Integrations-in-2.0#vera)
 * [Hubitat](https://github.com/bsileo/hubitat_poolcontroller) by @bsileo (prev help from @johnny2678, @donkarnag, @arrmo).  [Bindings Directions](https://github.com/tagyoureit/nodejs-poolController/wiki/Bindings-Integrations-in-2.0#smartthingshubitat)
 * [Homebridge/Siri/EVE](https://github.com/gadget-monk/homebridge-poolcontroller) by @gadget-monk, adopted from @leftyflip
@@ -118,31 +113,25 @@ Available for 6.x:
 * [MQTT](https://github.com/crsherman/nodejs-poolController-mqtt) original release by @crsherman, re-write by @kkzonie, testing by @baudfather and others.  [Bindings Directions](https://github.com/tagyoureit/nodejs-poolController/wiki/Bindings-Integrations-in-2.0#mqtt)
    * [Homeseer](https://github.com/tagyoureit/nodejs-poolController/wiki/Homeseer-Setup-Instructions) - Integration directions by @miamijerry to integrate Homeseer through MQTT
 
-Need to be updated:
+Outdated:
 * [Another SmartThings Controller](https://github.com/dhop90/pentair-pool-controller/blob/master/README.md) by @dhop90
 * [ISY](src/integrations/socketISY.js).  Original credit to @blueman2, enhancements by @mayermd
 * [ISY Polyglot NodeServer](https://github.com/brianmtreese/nodejs-pool-controller-polyglotv2) created by @brianmtreese
 
 # Support
-1. For discussions, recommendations, designs, and clarifications, we recommend you join the [Github discussions](https://github.com/tagyoureit/nodejs-poolController/discussions or [Gitter Chat room](https://gitter.im/pentair_pool/Lobby).
+1. For discussions, recommendations, designs, and clarifications, we recommend you join the [Github discussions](https://github.com/tagyoureit/nodejs-poolController/discussions.
 1. Check the [wiki](https://github.com/tagyoureit/nodejs-poolController/wiki) for tips, tricks and additional documentation.
 1. For bug reports you can open a [github issue](https://github.com/tagyoureit/nodejs-poolController/issues/new),
 
-### Virtual Controller
-v6 adds all new configuration and support for virtual pumps, chlorinators (and soon, Intellichem)
-
-* [Virtual Pump Directions](https://github.com/tagyoureit/nodejs-poolController/wiki/Virtual-Pump-Controller---v6)
-* [Virtual Chlorinator Directions](https://github.com/tagyoureit/nodejs-poolController/wiki/Virtual-Chlorinator-Controller-v6)
-* Virtual Chem Controller
 
 # Changes
 See [Changelog](https://github.com/tagyoureit/nodejs-poolController/blob/master/Changelog)
 
-
 <a name="module_nodejs-poolController--config.json"></a>
 # Config.json changes
 
 ## Controller section - changes to the communications for the app
+Most of these can be configured directly from the UI in dashPanel.
 * `rs485Port` - set to the name of you rs485 controller.  See [wiki](https://github.com/tagyoureit/nodejs-poolController/wiki/RS-485-Adapter-Details) for details and testing.
 * `portSettings` - should not need to be changed for RS485
 * `mockPort` - opens a "fake" port for this app to communicate on.  Can be used with [packet captures/replays](https://github.com/tagyoureit/nodejs-poolController/wiki/How-to-capture-all-packets-for-issue-resolution).
@@ -186,7 +175,7 @@ See [Changelog](https://github.com/tagyoureit/nodejs-poolController/blob/master/
 # License
 
 nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as

package/anslq25/MessagesMock.ts

@@ -196,7 +196,11 @@ export class MessagesMock {
             HeaterStateMessage.process(outboundMsg);
             break;*/
             case Protocol.Chlorinator:
-                mockChlor.process(msg);
+                // Only process outbound messages (commands from OCP to chlorinator)
+                // Inbound messages (responses from chlorinator to OCP) should not be processed by mock
+                if (msg.dest >= 80) {
+                    mockChlor.process(msg);
+                }
             /*
             case Protocol.Hayward:
                 PumpStateMessage.processHayward(msg);

package/anslq25/boards/MockSystemBoard.ts

@@ -50,7 +50,7 @@ export class MockSystemBoard {
     return await msg.sendAsync();
     // is the controller on a real/physical port or a mock port?
 /*     let port = conn.findPortById(sys.anslq25.portId);
-    if (port.mockPort) {
+    if (port.mock) {
       let inbound = new Inbound();
       inbound.protocol = msg.protocol;
       inbound.header = msg.header;

package/anslq25/chemistry/MockChlorinator.ts

@@ -15,13 +15,16 @@ export class MockChlorinator {
     switch (inbound.action){
       case 0: // Set control OCP->Chlorinator: [16,2,80,0][0][98,16,3]
         this.chlorSetControl(inbound, response);
+        break;
       case 17: // OCP->Chlorinator set output. [16,2,80,17][15][130,16,3]
         this.chlorSetOutput(inbound, response);
-        case 19: // iChlor keep alive(?) [16, 2, 80, 19][117, 16, 3]
-        // need response   
+        break;
+      case 19: // iChlor keep alive(?) [16, 2, 80, 19][117, 16, 3]
+        this.chlorKeepAlive(inbound, response);
         break;
       case 20: // OCP->Chlorinator Get model [16,2,80,20][0][118,16,3]
         this.chlorGetModel(inbound, response);
+        break;
       default:
         logger.info(`No mock chlorinator response for ${inbound.toShortPacket()} `);
     }
@@ -45,13 +48,34 @@ export class MockChlorinator {
     /*     
     {"port":0,"id":42639,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,17], [100],[215,16,3]],"ts":"2022-07-19T21:46:00.302-0700"}
     {"port":0,"id":42640,"valid":true,"dir":"in","proto":"chlorinator","for":[42639],"pkt":[[],[],[16,2,0,18],[78,128],[242,16,3]],"ts": "2022-07-19T21:46:00.341-0700"} */
-      response.action = 18;
-      response.appendPayloadBytes(0, 2);
-      // ideal high = 4500 = 90 * 50; ideal low = 2800 = 56 * 50
-      response.setPayloadByte(0, this.random(90-56, true)+56, 75)
-      response.setPayloadByte(1, 128); 
-      conn.queueSendMessage(response);
+    // Simulate a response from the chlorinator (inbound message)
+    const payload = [Math.floor(this.random(90-56, true))+56, 128];
+    const header = [16, 2, 0, 18];
+    const term = [242, 16, 3];
+    let responseMsg = new Inbound();
+    responseMsg.protocol = inbound.protocol;
+    responseMsg.portId = inbound.portId;
+    responseMsg.header = header;
+    responseMsg.payload = payload;
+    responseMsg.term = term;
+    // The Inbound class will parse header/payload/action/source/dest automatically
+    setTimeout(() => {
+      let port = conn.findPortById(inbound.portId);
+      if (port) {
+        port.pushIn(Buffer.from(responseMsg.toPacket()));
+      }
+    }, 50);
   }
+  public chlorKeepAlive(inbound: Inbound, response: Outbound){
+    /*  
+    {"port":0,"id":42647,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,19],[117,16,3]],"ts":"2022-07-19T21:46:00.645-0700"}   
+    {"port":0,"id":42648,"valid":true,"dir":"in","proto":"chlorinator","for":[42647],"pkt":[[],[],[16,2,0,20],[0],[118,16,3]],"ts":"2022-07-19T21:46:00.700-0700"}   */
+    response.action = 20;
+    response.appendPayloadBytes(0, 1);
+    response.setPayloadByte(0, 0);
+    conn.queueSendMessage(response);
+  }
+
   public chlorGetModel(inbound: Inbound, response: Outbound){
     /*  
     {"port":0,"id":42645,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,20], [0],[118,16,3]],"ts":"2022-07-19T21:46:00.645-0700"}   

package/app.ts

@@ -25,7 +25,7 @@ import { conn } from "./controller/comms/Comms";
 import { sys } from "./controller/Equipment";
 
 import { state } from "./controller/State";
-import { webApp } from "./web/Server";
+import { webApp, REMInterfaceServer } from "./web/Server";
 import * as readline from 'readline';
 import { sl } from './controller/comms/ScreenLogic'
 
@@ -52,6 +52,9 @@ export async function startPacketCapture(bResetLogs: boolean) {
         if (bResetLogs){
             sys.resetSystem();
         }
+        
+        // Start packet capture on the REM server
+        await REMInterfaceServer.startPacketCaptureOnRemServer();
     }
     catch (err) {
         console.error(`Error starting replay: ${ err.message }`);
@@ -61,7 +64,12 @@ export async function stopPacketCaptureAsync() {
     let log = config.getSection('log');
     log.app.captureForReplay = false;
     config.setSection('log', log);
-    return logger.stopCaptureForReplayAsync();
+    
+    // Stop packet capture on the REM server and collect its logs
+    let remLogs = await REMInterfaceServer.stopPacketCaptureOnRemServer();
+    
+    // Pass REM logs to the logger for inclusion in the backup
+    return logger.stopCaptureForReplayAsync(remLogs);
 }
 export async function stopAsync(): Promise<void> {
     try {

package/controller/State.ts

@@ -1096,7 +1096,7 @@ export class ScheduleStateCollection extends EqStateCollection<ScheduleState> {
             }
             st.calcSchedule(state.time, sys.schedules.getItemById(ssched.id));
             if (typeof st.startTime === 'undefined') continue;
-            if (ssched.isOn || st.shouldBeOn || st.startTime.getTime() > new Date().getTime()) activeScheds.push(ssched);
+            if (ssched.isOn || st.shouldBeOn || (st.startTime && st.startTime.getTime() > new Date().getTime())) activeScheds.push(ssched);
         }
         return activeScheds;
     }
@@ -1256,7 +1256,7 @@ export class ScheduleTime extends ChildEqState {
             let dtCalc = typeof this.calculatedDate !== 'undefined' && typeof this.calculatedDate.getTime === 'function' ? new Date(this.calculatedDate.getTime()).setHours(0, 0, 0, 0) : new Date(1970, 0, 1, 0, 0).getTime();
             let recalc = !this.calculated;
             if (!recalc && sod.getTime() !== dtCalc) recalc = true;
-            if (!recalc && (this.endTime.getTime() < new Date().getTime() && this.startTime.getTime() < dtCalc)) {
+            if (!recalc && (this.endTime && this.endTime.getTime() < new Date().getTime() && this.startTime && this.startTime.getTime() < dtCalc)) {
                 recalc = true;
                 logger.info(`Recalculating expired schedule ${sched.id}`);
             }

package/controller/boards/SystemBoard.ts

@@ -3656,8 +3656,12 @@ export class ScheduleCommands extends BoardCommands {
         ssched.display = sched.display = display;
         ssched.startTimeOffset = sched.startTimeOffset = startTimeOffset;
         ssched.endTimeOffset = sched.endTimeOffset = endTimeOffset;
-        if (typeof sched.startDate === 'undefined')
+        // Nixie controller managing schedules (master = 1), physical OCP (master = 0)
+        if (sys.controllerType === ControllerType.Nixie) {
             sched.master = 1;
+        } else {
+            sched.master = 0;
+        }
         await ncp.schedules.setScheduleAsync(sched, data);
         // update end time in case sched is changed while circuit is on
         let cstate = state.circuits.getInterfaceById(sched.circuit);

package/controller/comms/Comms.ts

@@ -198,7 +198,7 @@ export class Connection {
                     let c = cfg[section];
                     if (typeof c.type === 'undefined') {
                         let type = 'local';
-                        if (c.mockPort) type = 'mock';
+                        if (c.mock) type = 'mock';
                         else if (c.netConnect) type = 'network';
                         config.setSection(`controller.${section}`, c);
                         console.log(section);
@@ -260,7 +260,7 @@ export class Connection {
         if (anslq25port >= 0) {
             let ports = this.rs485Ports;
             for (let i = 0; i < ports.length; i++) {
-                // if (ports[i].mockPort) continue;
+                // if (ports[i].mock) continue;
                 if (ports[i].portId === currPort.portId) continue;
                 if (ports[i].portId === anslq25port) continue; // don't resend
                 if (!ports[i].isOpen) continue;
@@ -380,7 +380,8 @@ export class Connection {
             let msgs = [];
             // conn.queueInboundToBroadcast(msg);
             conn.queueOutboundToBroadcast(msg);
-            /* if (msgs.length > 0) {
+            /* if (msgs.le
+            ngth > 0) {
                 msgs.push(msg);
                 let promises: Promise<boolean>[] = [];
                 for (let i = 0; i < msgs.length; i++) {
@@ -511,7 +512,7 @@ export class RS485Port {
     public reconnects: number = 0;
     public emitter: EventEmitter;
     public get portId() { return typeof this._cfg !== 'undefined' && typeof this._cfg.portId !== 'undefined' ? this._cfg.portId : 0; }
-    public get type() { return typeof this._cfg.type !== 'undefined' ? this._cfg.type : this._cfg.netConnect ? 'netConnect' : this._cfg.mockPort || this._cfg.mock ? 'mock' : 'local' };
+    public get type() { return typeof this._cfg.type !== 'undefined' ? this._cfg.type : this._cfg.netConnect ? 'netConnect' : this._cfg.mock ? 'mock' : 'local' };
     public isOpen: boolean = false;
     public closing: boolean = false;
     private _cfg: any;
@@ -682,7 +683,7 @@ export class RS485Port {
                 // be open if a hardware interface is used and this method returns.
                 sp.open((err) => {
                     if (err) {
-                        this.resetConnTimer();
+                        if (!this.mock) this.resetConnTimer();
                         this.isOpen = false;
                         logger.error(`Error opening port ${this.portId}: ${err.message}. ${this._cfg.inactivityRetry > 0 && !this.mock ? `Retry in ${this._cfg.inactivityRetry} seconds` : `Never retrying; (fwiw, inactivityRetry set to ${this._cfg.inactivityRetry})`}`);
                         resolve(false);
@@ -712,7 +713,7 @@ export class RS485Port {
                         if (!this.mock && !this.isPaused) this.resetConnTimer();
                         this.pushIn(data);
                     });
-                    this.resetConnTimer();
+                    if (!this.mock) this.resetConnTimer();
                     this.emitPortStats();
                 });
                 sp.on('close', (err) => {
@@ -730,7 +731,7 @@ export class RS485Port {
                     if (typeof this.writeTimer !== 'undefined') { clearTimeout(this.writeTimer); this.writeTimer = null; }
                     this.isOpen = false;
                     if (sp.isOpen) sp.close((err) => { }); // call this with the error callback so that it doesn't emit to the error again.
-                    this.resetConnTimer();
+                    if (!this.mock) this.resetConnTimer();
                     logger.error(`Serial Port ${this.portId}: An error occurred : ${this._cfg.rs485Port}: ${JSON.stringify(err)}`);
                     this.emitPortStats();
 
@@ -823,7 +824,7 @@ export class RS485Port {
     protected resetConnTimer(...args) {
         //console.log(`resetting connection timer`);
         if (this.connTimer !== null) clearTimeout(this.connTimer);
-        if (!this._cfg.mockPort && this._cfg.inactivityRetry > 0 && !this.closing) this.connTimer = setTimeout(async () => {
+        if (!this._cfg.mock && this._cfg.inactivityRetry > 0 && !this.closing) this.connTimer = setTimeout(async () => {
             try {
                 if (this._cfg.netConnect)
                     logger.warn(`Inactivity timeout for ${this.portId} serial port ${this._cfg.netHost}:${this._cfg.netPort}/${this._cfg.rs485Port} after ${this._cfg.inactivityRetry} seconds`);

package/controller/comms/messages/Messages.ts

@@ -873,7 +873,7 @@ class OutboundCommon extends Message {
             case Protocol.Heater:
             case Protocol.Hayward:
                 this.chkHi = Math.floor(sum / 256);
-                this.chkLo = (sum - (super.chkHi * 256));
+                this.chkLo = (sum - (this.chkHi * 256));
                 break;
             case Protocol.AquaLink:
             case Protocol.Chlorinator:

package/controller/nixie/circuits/Circuit.ts

@@ -385,7 +385,7 @@ export class NixieCircuit extends NixieEquipment {
                 return new InterfaceServerResponse(200, 'Success');
             }
             if (this._sequencing) return new InterfaceServerResponse(200, 'Success');
-            let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
+        let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
                 // Set this up so we can process our egg timer.
                 if (val && val !== cstate.isOn) {

package/logger/Logger.ts

@@ -270,6 +270,10 @@ class Logger {
         // start new replay directory
 
         if (!fs.existsSync(this.captureForReplayPath)) fs.mkdirSync(this.captureForReplayBaseDir, { recursive: true });
+        
+        // Create logs subdirectory for additional log files
+        let logsSubDir = path.join(this.captureForReplayBaseDir, 'logs');
+        if (!fs.existsSync(logsSubDir)) fs.mkdirSync(logsSubDir, { recursive: true });
         if (bResetLogs){
             if (fs.existsSync(path.join(process.cwd(), 'data/poolConfig.json'))) {
                 fs.copyFileSync(path.join(process.cwd(), 'data/poolConfig.json'), path.join(process.cwd(),'data/', `poolConfig-${this.getLogTimestamp()}.json`));
@@ -360,29 +364,68 @@ class Logger {
         logger._logger.add(this.transports.file);
         this.transports.console.level = 'silly';
     }
-    public async stopCaptureForReplayAsync():Promise<string> {
+    public async stopCaptureForReplayAsync(remLogs?: any[]):Promise<string> {
         return new Promise<string>(async (resolve, reject) => {
             try {
-                fs.copyFileSync(path.join(process.cwd(), "/config.json"), path.join(this.captureForReplayBaseDir, `config.json`));
-                fs.copyFileSync(path.join(process.cwd(), 'data/poolConfig.json'), path.join(this.captureForReplayBaseDir, 'poolConfig.json'));
-                fs.copyFileSync(path.join(process.cwd(), 'data/poolState.json'), path.join(this.captureForReplayBaseDir, 'poolState.json'));
-                fs.copyFileSync(logger.pktPath, path.join(this.captureForReplayBaseDir, `packetLog${this.getLogTimestamp()}`));
+                // Get REM server configurations from config
+                let configData = config.getSection();
+                let remServers = [];
+                if (configData.web && configData.web.interfaces) {
+                    for (let interfaceName in configData.web.interfaces) {
+                        let interfaceConfig = configData.web.interfaces[interfaceName];
+                        if (interfaceConfig.type === 'rem' && interfaceConfig.enabled) {
+                            remServers.push({
+                                name: interfaceConfig.name || interfaceName,
+                                uuid: interfaceConfig.uuid,
+                                host: interfaceConfig.options?.host || '',
+                                backup: true
+                            });
+                        }
+                    }
+                }
+
+                // Use the existing backup logic to create the base backup
+                let backupOptions = {
+                    njsPC: true,
+                    servers: remServers,
+                    name: `Packet Capture ${this.currentTimestamp}`,
+                    automatic: false
+                };
+                
+                let backupFile = await webApp.backupServer(backupOptions);
+                
+                // Add packet capture logs to the existing backup zip
+                let jszip = require("jszip");
+                let zip = await jszip.loadAsync(fs.readFileSync(backupFile.filePath));
+                
+                // Add packet capture logs to the njsPC/logs directory
+                zip.file(`njsPC/logs/${this.getPacketPath()}`, fs.readFileSync(logger.pktPath));
+                zip.file(`njsPC/logs/${this.getConsoleToFilePath()}`, fs.readFileSync(this.consoleToFilePath));
+                
+                // Add REM server logs if provided
+                if (remLogs && remLogs.length > 0) {
+                    logger.info(`Adding ${remLogs.length} REM logs to backup`);
+                    for (let remLog of remLogs) {
+                        // Create logs directory for the REM server using the hardcoded name
+                        let logPath = `Relay Equipment Manager/logs/${remLog.logFileName}`;
+                        logger.info(`Adding REM log to backup: ${logPath} (size: ${remLog.logData.length} characters)`);
+                        zip.file(logPath, remLog.logData);
+                    }
+                } else {
+                    logger.info(`No REM logs provided to add to backup`);
+                }
+                
+                // Generate the updated zip
+                await zip.generateAsync({type:'nodebuffer'}).then(content => {
+                    fs.writeFileSync(backupFile.filePath, content);
+                });
+                
+                // Restore original logging configuration
                 this.cfg = config.getSection('log');
                 logger._logger.remove(this.transports.file);
                 this.transports.console.level = this.cfg.app.level;
-                let jszip = require("jszip");
-                let zipPath = path.join(this.captureForReplayBaseDir,`${this.currentTimestamp}.zip`);
-                let zip = new jszip();
-                zip.file('config.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'config.json')));
-                zip.file('poolConfig.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'poolConfig.json')));
-                zip.file('poolState.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'poolState.json')));
-                zip.file(this.getPacketPath(), fs.readFileSync(path.join(this.captureForReplayBaseDir, `packetLog${this.getLogTimestamp()}`)));
-                zip.file(this.getConsoleToFilePath(), fs.readFileSync(this.consoleToFilePath));
-                await zip.generateAsync({type:'nodebuffer'}).then(content=>
-                    {
-                        fs.writeFileSync(zipPath, content);
-                    });
-                resolve(zipPath);
+                
+                resolve(backupFile.filePath);
             }
             catch (err) {
                 reject(err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nodejs-poolcontroller",
-    "version": "8.1.0",
+    "version": "8.1.1",
     "description": "nodejs-poolController",
     "main": "app.js",
     "author": {

package/web/Server.ts

@@ -1423,18 +1423,151 @@ export class REMInterfaceServer extends ProtoServer {
         try {
             let response = await this.sendClientRequest('GET', '/config/backup/controller', undefined, 10000);
             return response;
-        } catch (err) { logger.error(`Error requesting GET /config/backup/controller: ${err.message}`); }
+        } catch (err) { 
+            logger.error(`Error requesting GET /config/backup/controller: ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting GET /config/backup/controller: ${err.message}`);
+            return errorResponse;
+        }
     }
     public async validateRestore(cfg): Promise<InterfaceServerResponse> {
         try {
             let response = await this.sendClientRequest('PUT', '/config/restore/validate', cfg, 10000);
             return response;
-        } catch (err) { logger.error(`Error requesting PUT /config/restore/validate ${err.message}`); }
+        } catch (err) { 
+            logger.error(`Error requesting PUT /config/restore/validate ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting PUT /config/restore/validate: ${err.message}`);
+            return errorResponse;
+        }
     }
     public async restoreConfig(cfg): Promise<InterfaceServerResponse> {
         try {
             return await this.sendClientRequest('PUT', '/config/restore/file', cfg, 20000);
-        } catch (err) { logger.error(`Error requesting PUT /config/restore/file ${err.message}`); }
+        } catch (err) { 
+            logger.error(`Error requesting PUT /config/restore/file ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting PUT /config/restore/file: ${err.message}`);
+            return errorResponse;
+        }
+    }
+    public async startPacketCapture(): Promise<InterfaceServerResponse> {
+        try {
+            let response = await this.sendClientRequest('PUT', '/config/packetCapture/start', undefined, 10000);
+            return response;
+        } catch (err) { 
+            logger.error(`Error requesting PUT /config/packetCapture/start: ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting PUT /config/packetCapture/start: ${err.message}`);
+            return errorResponse;
+        }
+    }
+    public async stopPacketCapture(): Promise<InterfaceServerResponse> {
+        try {
+            let response = await this.sendClientRequest('PUT', '/config/packetCapture/stop', undefined, 10000);
+            return response;
+        } catch (err) { 
+            logger.error(`Error requesting PUT /config/packetCapture/stop: ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting PUT /config/packetCapture/stop: ${err.message}`);
+            return errorResponse;
+        }
+    }
+    public async getPacketCaptureLog(): Promise<InterfaceServerResponse> {
+        try {
+            let response = await this.sendClientRequest('GET', '/config/packetCapture/log', undefined, 15000);
+            return response;
+        } catch (err) { 
+            logger.error(`Error requesting GET /config/packetCapture/log: ${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Error requesting GET /config/packetCapture/log: ${err.message}`);
+            return errorResponse;
+        }
+    }
+    
+
+    // Static methods to handle the REM server
+    public static async startPacketCaptureOnRemServer(): Promise<void> {
+        let remServers = webApp.findServersByType('rem') as REMInterfaceServer[];
+        logger.info(`Found ${remServers ? remServers.length : 0} REM servers`);
+        
+        if (remServers && remServers.length > 0) {
+            let server = remServers[0]; // Get the single REM server
+            logger.info(`Attempting to start packet capture on REM server: ${server.name} (connected: ${server.isConnected})`);
+            
+            if (server.isConnected) {
+                try {
+                    let response = await server.startPacketCapture();
+                    logger.info(`Start packet capture response: ${JSON.stringify(response)}`);
+                    
+                    if (response && response.status.code === 200) {
+                        logger.info(`Started packet capture on REM server: ${server.name}`);
+                    } else {
+                        logger.warn(`Failed to start packet capture on REM server: ${server.name}. Status: ${response?.status?.code}, Error: ${response?.error?.message}`);
+                    }
+                } catch (err) {
+                    logger.error(`Error starting packet capture on REM server ${server.name}: ${err.message}`);
+                }
+            } else {
+                logger.warn(`REM server ${server.name} is not connected, cannot start packet capture`);
+            }
+        } else {
+            logger.warn(`No REM servers found or configured`);
+        }
+    }
+    
+    public static async stopPacketCaptureOnRemServer(): Promise<any[]> {
+        let remServers = webApp.findServersByType('rem') as REMInterfaceServer[];
+        let remLogs = [];
+        
+        logger.info(`Found ${remServers ? remServers.length : 0} REM servers for stop packet capture`);
+        
+        if (remServers && remServers.length > 0) {
+            let server = remServers[0]; // Get the single REM server
+            logger.info(`Attempting to stop packet capture on REM server: ${server.name} (connected: ${server.isConnected})`);
+            
+            if (server.isConnected) {
+                try {
+                    // Stop packet capture
+                    let stopResponse = await server.stopPacketCapture();
+                    logger.info(`Stop packet capture response: ${JSON.stringify(stopResponse)}`);
+                    
+                    if (stopResponse && stopResponse.status.code === 200) {
+                        logger.info(`Stopped packet capture on REM server: ${server.name}`);
+                        
+                        // Get the log file
+                        let logResponse = await server.getPacketCaptureLog();
+                        logger.info(`Get log response: ${JSON.stringify(logResponse)}`);
+                        
+                        if (logResponse && logResponse.status.code === 200 && logResponse.data) {
+                            // Use the actual log file name from the REM response
+                            logger.info(`Log response obj: ${JSON.stringify(logResponse.obj)}`);
+                            let logFileName = logResponse.obj && logResponse.obj.logFile ? logResponse.obj.logFile : `rem_${server.name}_packetCapture.log`;
+                            logger.info(`Using log filename: ${logFileName}`);
+                            remLogs.push({
+                                serverName: server.name,
+                                logData: logResponse.data,
+                                logFileName: logFileName
+                            });
+                            logger.info(`Retrieved packet capture log from REM server: ${server.name}, log size: ${logResponse.data.length} characters, filename: ${logFileName}`);
+                        } else {
+                            logger.warn(`Failed to retrieve packet capture log from REM server: ${server.name}. Status: ${logResponse?.status?.code}, Error: ${logResponse?.error?.message}`);
+                        }
+                    } else {
+                        logger.warn(`Failed to stop packet capture on REM server: ${server.name}. Status: ${stopResponse?.status?.code}, Error: ${stopResponse?.error?.message}`);
+                    }
+                } catch (err) {
+                    logger.error(`Error stopping packet capture on REM server ${server.name}: ${err.message}`);
+                }
+            } else {
+                logger.warn(`REM server ${server.name} is not connected, cannot stop packet capture`);
+            }
+        } else {
+            logger.warn(`No REM servers found or configured for stop packet capture`);
+        }
+        
+        logger.info(`Returning ${remLogs.length} REM logs`);
+        return remLogs;
     }
     private async initConnection() {
         try {
@@ -1483,12 +1616,15 @@ export class REMInterfaceServer extends ProtoServer {
                             resolve();
                         }
                     }
-                    catch (err) { reject(new Error(`initConnection setTimeout: ${result.error.message}`)); }
+                    catch (err) { 
+                        logger.error(`initConnection setTimeout error: ${err.message}`);
+                        reject(new Error(`initConnection setTimeout: ${err.message}`)); 
+                    }
                 }, 3000);
             });
         }
         catch (err) {
-            logger.error(`Error with REM Interface Server initConnection: ${err}`)
+            logger.error(`Error with REM Interface Server initConnection: ${err.message}`);
         }
     }
     public async stopAsync() {
@@ -1556,7 +1692,10 @@ export class REMInterfaceServer extends ProtoServer {
                 });
                 req.on('abort', () => { logger.warn('Request Aborted'); reject(new Error('Request Aborted.')); });
                 req.end(sbody);
-            }).catch((err) => { logger.error(`Error Sending REM Request: ${opts.method} ${url} ${err.message}`); ret.error = err; });
+            }).catch((err) => { 
+                logger.error(`Error Sending REM Request: ${opts.method} ${url} ${err.message}`); 
+                ret.error = err; 
+            });
             logger.verbose(`REM server request returned. ${opts.method} ${opts.path} ${sbody}`);
             if (ret.status.code > 200) {
                 // We have an http error so let's parse it up.
@@ -1574,7 +1713,9 @@ export class REMInterfaceServer extends ProtoServer {
         }
         catch (err) {
             logger.error(`Error sending HTTP ${method} command to ${url}: ${err.message}`);
-            return Promise.reject(`Http ${method} Error ${url}:${err.message}`);
+            let errorResponse = new InterfaceServerResponse();
+            errorResponse.error = new Error(`Http ${method} Error ${url}:${err.message}`);
+            return errorResponse;
         }
     }
     private initSockets() {
@@ -1585,7 +1726,10 @@ export class REMInterfaceServer extends ProtoServer {
             //console.log(this.cfg);
             this.sockClient = sockClient(url, extend(true,
                 { reconnectionDelay: 2000, reconnection: true, reconnectionDelayMax: 20000, transports: ['websocket'], upgrade: true, }, this.cfg.socket));
-            if (typeof this.sockClient === 'undefined') return Promise.reject(new Error('Could not Initialize REM Server.  Invalid configuration.'));
+            if (typeof this.sockClient === 'undefined') {
+                logger.error('Could not Initialize REM Server. Invalid configuration.');
+                return;
+            }
             //this.sockClient = io.connect(url, { reconnectionDelay: 2000, reconnection: true, reconnectionDelayMax: 20000 });
             //console.log(this.sockClient);
             //console.log(typeof this.sockClient.on);
@@ -1604,7 +1748,9 @@ export class REMInterfaceServer extends ProtoServer {
             });
             this.isRunning = true;
         }
-        catch (err) { logger.error(`Error Initializing Sockets: ${err.message}`); }
+        catch (err) { 
+            logger.error(`Error Initializing Sockets: ${err.message}`); 
+        }
     }
     private isJSONString(s: string): boolean {
         if (typeof s !== 'string') return false;
@@ -1613,23 +1759,23 @@ export class REMInterfaceServer extends ProtoServer {
     }
     public async getApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
         // Calls a rest service on the REM to set the state of a connected device.
-        try { let ret = await this.sendClientRequest('GET', url, data, timeout); return ret; }
-        catch (err) { return Promise.reject(err); }
+        let ret = await this.sendClientRequest('GET', url, data, timeout); 
+        return ret; 
     }
     public async putApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
         // Calls a rest service on the REM to set the state of a connected device.
-        try { let ret = await this.sendClientRequest('PUT', url, data, timeout); return ret; }
-        catch (err) { return Promise.reject(err); }
+        let ret = await this.sendClientRequest('PUT', url, data, timeout); 
+        return ret; 
     }
     public async searchApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
         // Calls a rest service on the REM to set the state of a connected device.
-        try { let ret = await this.sendClientRequest('SEARCH', url, data, timeout); return ret; }
-        catch (err) { return Promise.reject(err); }
+        let ret = await this.sendClientRequest('SEARCH', url, data, timeout); 
+        return ret; 
     }
     public async deleteApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
         // Calls a rest service on the REM to set the state of a connected device.
-        try { let ret = await this.sendClientRequest('DELETE', url, data, timeout); return ret; }
-        catch (err) { return Promise.reject(err); }
+        let ret = await this.sendClientRequest('DELETE', url, data, timeout); 
+        return ret; 
     }
     public async getDevices() {
         try {
@@ -1640,7 +1786,10 @@ export class REMInterfaceServer extends ProtoServer {
             }
             return (response.status.code === 200) ? JSON.parse(response.data) : [];
         }
-        catch (err) { logger.error(`getDevices: ${err.message}`); }
+        catch (err) { 
+            logger.error(`getDevices: ${err.message}`); 
+            return [];
+        }
     }
 }
 export class BackupFile {

package/web/services/config/Config.ts

@@ -74,7 +74,7 @@ export class ConfigRoute {
                         let cport = extend(true, { enabled: false, netConnect: false, mock: false }, cfg[section]);
                         let port = conn.findPortById(cport.portId || 0);
                         if (typeof cport.type === 'undefined'){
-                            cport.type = cport.netConnect ? 'netConnect' : cport.mockPort || cport.mock ? 'mock' : 'local'
+                            cport.type = cport.netConnect ? 'netConnect' : cport.mock ? 'mock' : 'local'
                         }
                         if (typeof port !== 'undefined') cport.stats = port.stats;
                         if (port.portId === 0 && port.type === 'screenlogic') {
@@ -1009,7 +1009,7 @@ export class ConfigRoute {
                                     return next(new ServiceProcessError(`File already exists ${req.file.originalname}`, 'POST: app/backup/file', 'writeFile'));
                                 else {
                                     try {
-                                        fs.writeFileSync(bf.filePath, req.file.buffer);
+                                        fs.writeFileSync(bf.filePath, new Uint8Array(req.file.buffer));
                                     } catch (e) { logger.error(`Error writing backup file ${e.message}`); }
                                 }
                                 return res.status(200).send(bf);