nodejs-poolcontroller 8.4.0 → 8.4.1

package/logger/Logger.ts

@@ -32,7 +32,7 @@ class Logger {
         if (!fs.existsSync(path.join(process.cwd(), '/logs'))) fs.mkdirSync(path.join(process.cwd(), '/logs'));
         this.pktPath = path.join(process.cwd(), '/logs', this.getPacketPath());
         this.captureForReplayBaseDir = path.join(process.cwd(), '/logs/', this.getLogTimestamp());
-        /*         this.captureForReplayPath = path.join(this.captureForReplayBaseDir, '/packetCapture.json'); */
+        this.captureForReplayPath = this.captureForReplayBaseDir;
         this.pkts = [];
         this.slMessages = [];
     }
@@ -49,6 +49,7 @@ class Logger {
     private pktTimer: NodeJS.Timeout;
     private currentTimestamp: string;
     private _captureInProgress: boolean = false;
+    public get captureInProgress(): boolean { return this._captureInProgress; }
     private getPacketPath(): string {
         // changed this to remove spaces from the name
         return 'packetLog(' + this.getLogTimestamp() + ').log';
@@ -279,7 +280,7 @@ class Logger {
         logger.info(`Starting Replay Capture.`);
         // start new replay directory
 
-        if (!fs.existsSync(this.captureForReplayPath)) fs.mkdirSync(this.captureForReplayBaseDir, { recursive: true });
+        if (!fs.existsSync(this.captureForReplayBaseDir)) fs.mkdirSync(this.captureForReplayBaseDir, { recursive: true });
         
         // Create logs subdirectory for additional log files
         let logsSubDir = path.join(this.captureForReplayBaseDir, 'logs');
@@ -375,74 +376,84 @@ class Logger {
         this.transports.console.level = 'silly';
     }
     public async stopCaptureForReplayAsync(remLogs?: any[]):Promise<string> {
-        return new Promise<string>(async (resolve, reject) => {
-            try {
-                // 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
-                            });
-                        }
+        try {
+            if (!this._captureInProgress) {
+                logger.warn(`stopCaptureForReplayAsync called with no active capture session; creating backup without capture logs`);
+            }
+            // 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`);
+            // Use the existing backup logic to create the base backup.
+            const ts = this.currentTimestamp || this.getLogTimestamp();
+            let backupOptions = {
+                njsPC: true,
+                servers: remServers,
+                name: `Packet Capture ${ts}`,
+                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 if present.
+            if (typeof logger.pktPath === 'string' && logger.pktPath.length > 0 && fs.existsSync(logger.pktPath)) {
+                zip.file(`njsPC/logs/${path.basename(logger.pktPath)}`, fs.readFileSync(logger.pktPath));
+            } else {
+                logger.warn(`Packet capture log file unavailable during stopCaptureForReplayAsync; skipping packet log attachment`);
+            }
+            if (typeof this.consoleToFilePath === 'string' && this.consoleToFilePath.length > 0 && fs.existsSync(this.consoleToFilePath)) {
+                zip.file(`njsPC/logs/${path.basename(this.consoleToFilePath)}`, fs.readFileSync(this.consoleToFilePath));
+            } else {
+                logger.warn(`Console capture log file unavailable during stopCaptureForReplayAsync; skipping console log attachment`);
+            }
+
+            // 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);
                 }
-                
-                // 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;
-                this._captureInProgress = false;
-                
-                resolve(backupFile.filePath);
+            } else {
+                logger.info(`No REM logs provided to add to backup`);
             }
-            catch (err) {
-                this._captureInProgress = false;
-                reject(err.message);
+
+            // 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');
+            if (typeof this.transports.file !== 'undefined') {
+                logger._logger.remove(this.transports.file);
+                this.transports.file.close();
+                this.transports.file = undefined;
             }
-        });
+            this.transports.console.level = this.cfg.app.level;
+            this._captureInProgress = false;
+            return backupFile.filePath;
+        }
+        catch (err) {
+            this._captureInProgress = false;
+            return Promise.reject(err instanceof Error ? err.message : `${err}`);
+        }
     }
 }
 export var logger = new Logger();

package/package.json

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

package/tsconfig.json

@@ -13,7 +13,8 @@
         "allowJs": false,
         "allowSyntheticDefaultImports": false,
         "esModuleInterop": false,
-        "jsx": "react"
+        "jsx": "react",
+        "skipLibCheck": true
     },
     "include": [
         "web/**/*",

package/web/Server.ts

@@ -645,12 +645,14 @@ export class HttpServer extends ProtoServer {
     private replayInboundMessage(mdata: any) {
         try {
             let msg: Inbound = new Inbound();
-            msg.direction = mdata.direction;
+            if (typeof mdata.direction !== 'undefined') msg.direction = mdata.direction;
             msg.header = mdata.header;
             msg.payload = mdata.payload;
             msg.preamble = mdata.preamble;
             msg.protocol = mdata.protocol;
             msg.term = mdata.term;
+            if (typeof mdata.portId === 'number') msg.portId = mdata.portId;
+            msg.scope = 'replay';
             if (msg.isValid) msg.process();
         }
         catch (err) {

package/web/services/config/Config.ts

@@ -34,7 +34,99 @@ import { ScreenLogicComms, sl } from "../../../controller/comms/ScreenLogic";
 import { screenlogic } from "node-screenlogic";
 
 export class ConfigRoute {
+    private static securitySessions: Map<string, any> = new Map<string, any>();
+    private static isOcpWriteSecurityEnforced(): boolean {
+        // Intentionally hard-disabled until OCP security semantics are fully understood.
+        // This avoids accidentally locking users out of configuration writes.
+        return false;
+    }
+    private static getClientKey(req: express.Request): string {
+        const forwarded = (req.headers['x-forwarded-for'] || '') as string;
+        const forwardedIp = forwarded.split(',')[0].trim();
+        const connIp = ((req.connection as any) || {}).remoteAddress || '';
+        return forwardedIp || req.ip || connIp || 'unknown';
+    }
+    private static getSecuritySession(req: express.Request): any {
+        const key = ConfigRoute.getClientKey(req);
+        return ConfigRoute.securitySessions.get(key);
+    }
+    private static clearSecuritySession(req: express.Request): any {
+        const key = ConfigRoute.getClientKey(req);
+        ConfigRoute.securitySessions.delete(key);
+        return {
+            isAuthenticated: false,
+            isAdmin: false,
+            roleId: 0,
+            roleName: '',
+            ip: key
+        };
+    }
+    private static createSecuritySession(req: express.Request, role: any): any {
+        const key = ConfigRoute.getClientKey(req);
+        const session = {
+            isAuthenticated: true,
+            isAdmin: role.id === 1 || typeof role.name === 'string' && role.name.toLowerCase().indexOf('admin') >= 0,
+            roleId: role.id || 0,
+            roleName: role.name || '',
+            ip: key,
+            updatedAt: new Date().toISOString()
+        };
+        ConfigRoute.securitySessions.set(key, session);
+        return session;
+    }
+    private static getRoleForPin(pin: string): any {
+        const normalizedPin = (pin || '').toString().replace(/\D/g, '');
+        if (normalizedPin.length === 0) return undefined;
+        const roles = sys.security.roles.toArray();
+        for (let i = 0; i < roles.length; i++) {
+            const rolePin = ((roles[i] as any).pin || '').toString().replace(/\D/g, '');
+            if (rolePin.length > 0 && rolePin === normalizedPin) return roles[i];
+        }
+        return undefined;
+    }
+    private static validateWriteAccess(req: express.Request): { allowed: boolean; reason?: string; session?: any } {
+        if (!ConfigRoute.isOcpWriteSecurityEnforced()) return { allowed: true };
+        if (!sys.security.enabled) return { allowed: true };
+        const session = ConfigRoute.getSecuritySession(req);
+        if (typeof session === 'undefined' || !session.isAuthenticated) {
+            return { allowed: false, reason: 'Security is enabled; log in with an administrator PIN to change configuration.' };
+        }
+        if (!session.isAdmin) return { allowed: false, reason: 'Guest sessions are read-only.' };
+        return { allowed: true, session: session };
+    }
+    private static getSessionResponse(req: express.Request): any {
+        const session = ConfigRoute.getSecuritySession(req);
+        return {
+            enabled: sys.security.enabled,
+            session: typeof session === 'undefined' ? {
+                isAuthenticated: false,
+                isAdmin: false,
+                roleId: 0,
+                roleName: '',
+                ip: ConfigRoute.getClientKey(req)
+            } : session
+        };
+    }
     public static initRoutes(app: express.Application) {
+        app.use('/config', (req, res, next) => {
+            const method = (req.method || '').toUpperCase();
+            if (method !== 'PUT' && method !== 'POST' && method !== 'DELETE') return next();
+            const reqPath = req.path || req.url || '';
+            if (
+                reqPath.startsWith('/security/login') ||
+                reqPath.startsWith('/security/logout') ||
+                reqPath.startsWith('/security/session')
+            ) {
+                return next();
+            }
+            const access = ConfigRoute.validateWriteAccess(req);
+            if (access.allowed) return next();
+            return res.status(403).send({
+                error: 'FORBIDDEN',
+                message: access.reason,
+                security: ConfigRoute.getSessionResponse(req)
+            });
+        });
         app.get('/config/body/:body/heatModes', (req, res) => {
             return res.status(200).send(sys.bodies.getItemById(parseInt(req.params.body, 10)).getHeatModes());
         });
@@ -65,6 +157,28 @@ export class ConfigRoute {
             };
             return res.status(200).send(opts);
         });
+        app.get('/config/options/security', (req, res) => {
+            return res.status(200).send({
+                security: sys.security.get(true),
+                session: ConfigRoute.getSessionResponse(req).session
+            });
+        });
+        app.get('/config/options/alerts', (req, res) => {
+            return res.status(200).send({
+                alerts: sys.alerts.get(true),
+                // Existing app-side alert-related options still live in general options.
+                poolOptions: {
+                    cooldownDelay: sys.general.options.cooldownDelay,
+                    heaterStartDelay: sys.general.options.heaterStartDelay,
+                    valveDelayTime: sys.general.options.valveDelayTime,
+                    manualPriority: sys.general.options.manualPriority
+                },
+                runtime: {
+                    chemControllers: state.chemControllers.getExtended(),
+                    chemDosers: state.chemDosers.getExtended()
+                }
+            });
+        });
         app.get('/config/options/rs485', async (req, res, next) => {
             try {
                 let opts = { ports: [], local: [], screenlogic: {} }
@@ -245,6 +359,7 @@ export class ConfigRoute {
                     maxHeaters: sys.equipment.maxHeaters,
                     heaters: sys.heaters.get(),
                     heaterTypes: sys.board.valueMaps.heaterTypes.toArray(),
+                    equipmentMasters: sys.board.valueMaps.equipmentMaster.toArray(),
                     // Align with `/config/body/:id/heatModes` (body picklist). This ensures any board-specific
                     // filtering (e.g. IntelliCenter v3 preferred-mode suppression) is reflected consistently.
                     // Future improvement should return valid modes per body.
@@ -307,6 +422,7 @@ export class ConfigRoute {
                     // waterFlow: sys.board.valueMaps.chemControllerWaterFlow.toArray(), // remove
                     controllers: sys.chemControllers.get(),
                     maxChemControllers: sys.equipment.maxChemControllers,
+                    intellichemStandaloneSupported: sys.controllerType === ControllerType.Nixie,
                     doserTypes: sys.board.valueMaps.chemDoserTypes.toArray(),
                     chlorinators: sys.chlorinators.get(),
                 };
@@ -860,6 +976,35 @@ export class ConfigRoute {
                     sys.board.circuits.setIntelliBriteColors(new LightGroup(grp));
                     return res.status(200).send('OK');
                 }); */
+        app.get('/config/security/session', (req, res) => {
+            return res.status(200).send(ConfigRoute.getSessionResponse(req));
+        });
+        app.put('/config/security/login', (req, res) => {
+            if (!sys.security.enabled) {
+                return res.status(409).send({
+                    error: 'SECURITY_DISABLED',
+                    message: 'Panel security is disabled.',
+                    security: ConfigRoute.getSessionResponse(req)
+                });
+            }
+            const role = ConfigRoute.getRoleForPin(((req.body || {}).pin || '').toString());
+            if (typeof role === 'undefined') {
+                return res.status(401).send({
+                    error: 'INVALID_PIN',
+                    message: 'PIN does not match a configured security role.'
+                });
+            }
+            return res.status(200).send({
+                enabled: sys.security.enabled,
+                session: ConfigRoute.createSecuritySession(req, role)
+            });
+        });
+        app.put('/config/security/logout', (req, res) => {
+            return res.status(200).send({
+                enabled: sys.security.enabled,
+                session: ConfigRoute.clearSecuritySession(req)
+            });
+        });
         app.get('/config', (req, res) => {
             return res.status(200).send(sys.getSection('all'));
         });
@@ -927,7 +1072,11 @@ export class ConfigRoute {
         app.get('/app/config/stopPacketCapture', async (req, res, next) => {
             try {
                 let file = await stopPacketCaptureAsync();
-                res.download(file);
+                if (typeof file !== 'string' || file.length === 0 || !fs.existsSync(file)) {
+                    logger.warn(`stopPacketCapture did not produce a valid backup file path`);
+                    return res.status(409).send('Packet capture is not active or no capture file is available.');
+                }
+                return res.download(file);
             }
             catch (err) { next(err); }
         });

package/web/services/state/State.ts

@@ -399,6 +399,27 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/light/setBrightness', async (req, res, next) => {
+            try {
+                let cstate = await sys.board.circuits.setDimmerLevelAsync(
+                    parseInt(req.body.id, 10),
+                    parseInt(typeof req.body.level !== 'undefined' ? req.body.level : req.body.brightness, 10)
+                );
+                return res.status(200).send(cstate.get(true));
+            }
+            catch (err) { next(err); }
+        });
+        app.put('/state/light/setColor', async (req, res, next) => {
+            try {
+                let cstate = await sys.board.circuits.setLightColorAsync(parseInt(req.body.id, 10), {
+                    red: parseInt(typeof req.body.red !== 'undefined' ? req.body.red : req.body.r, 10),
+                    green: parseInt(typeof req.body.green !== 'undefined' ? req.body.green : req.body.g, 10),
+                    blue: parseInt(typeof req.body.blue !== 'undefined' ? req.body.blue : req.body.b, 10)
+                });
+                return res.status(200).send(cstate.get(true));
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/feature/setState', async (req, res, next) => {
             try {
                 let isOn = utils.makeBool(typeof req.body.isOn !== 'undefined' ? req.body.isOn : req.body.state);

package/web/services/state/StateSocket.ts

@@ -300,6 +300,13 @@ export class StateSocket {
             } 
             catch (err) { next(err); }
         }); 
+        app.put('/state/light/setTheme', async (req, res, next) => {
+            try {
+                let theme = await state.circuits.setLightThemeAsync(parseInt(req.body.id, 10), parseInt(req.body.theme, 10));
+                return res.status(200).send(theme);
+            }
+            catch (err) { next(err); }
+        });
 
         app.put('/state/circuit/setDimmerLevel', async (req, res, next) => {
             try {
@@ -308,6 +315,27 @@ export class StateSocket {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/light/setBrightness', async (req, res, next) => {
+            try {
+                let circuit = await sys.board.circuits.setDimmerLevelAsync(
+                    parseInt(req.body.id, 10),
+                    parseInt(typeof req.body.level !== 'undefined' ? req.body.level : req.body.brightness, 10)
+                );
+                return res.status(200).send(circuit);
+            }
+            catch (err) { next(err); }
+        });
+        app.put('/state/light/setColor', async (req, res, next) => {
+            try {
+                let circuit = await sys.board.circuits.setLightColorAsync(parseInt(req.body.id, 10), {
+                    red: parseInt(typeof req.body.red !== 'undefined' ? req.body.red : req.body.r, 10),
+                    green: parseInt(typeof req.body.green !== 'undefined' ? req.body.green : req.body.g, 10),
+                    blue: parseInt(typeof req.body.blue !== 'undefined' ? req.body.blue : req.body.b, 10)
+                });
+                return res.status(200).send(circuit);
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/feature/setState', async (req, res, next) => {
             try {
                 await state.features.setFeatureStateAsync(req.body.id, req.body.state);