nodejs-poolcontroller 8.1.2 → 8.4.0

package/anslq25/pumps/MockPump.ts

@@ -1,84 +1,84 @@
-import { sys } from "../../controller/Equipment";
-import { PumpState, state } from "../../controller/State";
-import { Outbound } from "../../controller/comms/messages/Messages";
-import { conn } from "controller/comms/Comms";
-
-export class MockPump {
-  constructor(){}
-
-  public process(outboundMsg: Outbound){
-    let response: Outbound = Outbound.create({
-      portId: outboundMsg.portId,
-      protocol: outboundMsg.protocol
-    });
-
-    switch (outboundMsg.action){
-      case 7:
-        this.pumpStatus(outboundMsg, response);
-      default:
-        this.pumpAck(outboundMsg, response);
-    }
-  }
-
-  public pumpStatus(outboundMsg: Outbound, response: Outbound){
-    let pState:PumpState = state.pumps.getItemById(outboundMsg.dest - 96);
-    let pt = sys.board.valueMaps.pumpTypes.get(pState.type);
-    response.action = 7;
-    response.source = outboundMsg.dest;
-    response.dest = outboundMsg.source;
-    response.appendPayloadBytes(0, 15);
-    response.setPayloadByte(0, pState.command, 2);
-    response.setPayloadByte(1, pState.mode, 0);
-    response.setPayloadByte(2, pState.driveState, 2);
-    let watts = 0;
-    if (Math.max(pState.rpm, pState.flow) > 0){
-      if (pState.rpm > 0) watts = pState.rpm/pt.maxSpeed * 2000 + this.random(100);
-      else if (pState.flow > 0) watts = pState.flow/pt.maxFlow * 2000 + this.random(100);
-      else //ss, ds, etc
-      watts = 2000 + this.random(250);
-    }
-    response.setPayloadByte(3, Math.floor(watts / 256), 0);
-    response.setPayloadByte(4, watts % 256, 0);
-    response.setPayloadByte(5, Math.floor(pState.rpm / 256), 0);
-    response.setPayloadByte(6, pState.rpm % 256, 0);
-    response.setPayloadByte(7, pState.flow, 0);
-    response.setPayloadByte(8, pState.ppc, 0);
-    // 9, 10 = unknown
-    // 11, 12 = Status code; 
-    response.setPayloadByte(11, Math.floor(pState.status / 256), 0);
-    response.setPayloadByte(12, pState.status % 256, 1);
-    let time = new Date();
-    response.setPayloadByte(13, time.getHours() * 60);
-    response.setPayloadByte(14, time.getMinutes());
-    
-    conn.queueSendMessage(response);
-  }
-
-  public pumpAck(outboundMsg: Outbound, response: Outbound){
-    response.action = outboundMsg.action;
-    response.source = outboundMsg.dest;
-    response.dest = outboundMsg.source;
-    switch (outboundMsg.action){
-      case 1:
-      case 10: {
-        response.appendPayloadByte(outboundMsg.payload[2]);
-        response.appendPayloadByte(outboundMsg.payload[3]);
-        break;
-      }
-      default:    
-        response.appendPayloadByte(outboundMsg.payload[0]);
-      }
-    conn.queueSendMessage(response);
-  }
-
-  private random(bounds: number, onlyPositive: boolean = false){
-    let rand = Math.random() * bounds;
-    if (!onlyPositive) {
-      if (Math.random()<=.5) rand = rand * -1;
-    }
-    return rand;
-  }
-
-}
-
+import { sys } from "../../controller/Equipment";
+import { PumpState, state } from "../../controller/State";
+import { Outbound } from "../../controller/comms/messages/Messages";
+import { conn } from "controller/comms/Comms";
+
+export class MockPump {
+  constructor(){}
+
+  public process(outboundMsg: Outbound){
+    let response: Outbound = Outbound.create({
+      portId: outboundMsg.portId,
+      protocol: outboundMsg.protocol
+    });
+
+    switch (outboundMsg.action){
+      case 7:
+        this.pumpStatus(outboundMsg, response);
+      default:
+        this.pumpAck(outboundMsg, response);
+    }
+  }
+
+  public pumpStatus(outboundMsg: Outbound, response: Outbound){
+    let pState:PumpState = state.pumps.getItemById(outboundMsg.dest - 96);
+    let pt = sys.board.valueMaps.pumpTypes.get(pState.type);
+    response.action = 7;
+    response.source = outboundMsg.dest;
+    response.dest = outboundMsg.source;
+    response.appendPayloadBytes(0, 15);
+    response.setPayloadByte(0, pState.command, 2);
+    response.setPayloadByte(1, pState.mode, 0);
+    response.setPayloadByte(2, pState.driveState, 2);
+    let watts = 0;
+    if (Math.max(pState.rpm, pState.flow) > 0){
+      if (pState.rpm > 0) watts = pState.rpm/pt.maxSpeed * 2000 + this.random(100);
+      else if (pState.flow > 0) watts = pState.flow/pt.maxFlow * 2000 + this.random(100);
+      else //ss, ds, etc
+      watts = 2000 + this.random(250);
+    }
+    response.setPayloadByte(3, Math.floor(watts / 256), 0);
+    response.setPayloadByte(4, watts % 256, 0);
+    response.setPayloadByte(5, Math.floor(pState.rpm / 256), 0);
+    response.setPayloadByte(6, pState.rpm % 256, 0);
+    response.setPayloadByte(7, pState.flow, 0);
+    response.setPayloadByte(8, pState.ppc, 0);
+    // 9, 10 = unknown
+    // 11, 12 = Status code; 
+    response.setPayloadByte(11, Math.floor(pState.status / 256), 0);
+    response.setPayloadByte(12, pState.status % 256, 1);
+    let time = new Date();
+    response.setPayloadByte(13, time.getHours() * 60);
+    response.setPayloadByte(14, time.getMinutes());
+    
+    conn.queueSendMessage(response);
+  }
+
+  public pumpAck(outboundMsg: Outbound, response: Outbound){
+    response.action = outboundMsg.action;
+    response.source = outboundMsg.dest;
+    response.dest = outboundMsg.source;
+    switch (outboundMsg.action){
+      case 1:
+      case 10: {
+        response.appendPayloadByte(outboundMsg.payload[2]);
+        response.appendPayloadByte(outboundMsg.payload[3]);
+        break;
+      }
+      default:    
+        response.appendPayloadByte(outboundMsg.payload[0]);
+      }
+    conn.queueSendMessage(response);
+  }
+
+  private random(bounds: number, onlyPositive: boolean = false){
+    let rand = Math.random() * bounds;
+    if (!onlyPositive) {
+      if (Math.random()<=.5) rand = rand * -1;
+    }
+    return rand;
+  }
+
+}
+
 export var mockPump: MockPump = new MockPump();

package/app.ts

@@ -1,116 +1,116 @@
-/*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
-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
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// add source map support for .js to .ts files
-//require('source-map-support').install();
-import 'source-map-support/register';
-
-import { logger } from "./logger/Logger";
-import { config } from "./config/Config";
-import { conn } from "./controller/comms/Comms";
-import { sys } from "./controller/Equipment";
-
-import { state } from "./controller/State";
-import { webApp, REMInterfaceServer } from "./web/Server";
-import * as readline from 'readline';
-import { sl } from './controller/comms/ScreenLogic'
-
-export async function initAsync() {
-    try {
-        await config.init();
-        await logger.init();
-        await sys.init();
-        await state.init();
-        await webApp.init();
-        await conn.initAsync();
-        await sys.start();
-        await webApp.initAutoBackup();
-        await sl.openAsync();
-    } catch (err) { console.log(`Error Initializing nodejs-PoolController ${err.message}`);  }
-}
-
-export async function startPacketCapture(bResetLogs: boolean) {
-    try {
-        let log = config.getSection('log');
-        log.app.captureForReplay = true;
-        config.setSection('log', log);
-        logger.startCaptureForReplay(bResetLogs);
-        if (bResetLogs){
-            sys.resetSystem();
-        }
-        
-        // Start packet capture on the REM server
-        await REMInterfaceServer.startPacketCaptureOnRemServer();
-    }
-    catch (err) {
-        console.error(`Error starting replay: ${ err.message }`);
-    }
-}
-export async function stopPacketCaptureAsync() {
-    let log = config.getSection('log');
-    log.app.captureForReplay = false;
-    config.setSection('log', log);
-    
-    // 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 {
-        console.log('Shutting down open processes');
-        await webApp.stopAutoBackup();
-        await sys.stopAsync();
-        await state.stopAsync();
-        await conn.stopAsync();
-        await sl.closeAsync();
-        await webApp.stopAsync();
-        await config.updateAsync();
-        await logger.stopAsync();
-        // RKS: Uncomment below to see the shutdown process
-        //await new Promise<void>((resolve, reject) => { setTimeout(() => { resolve(); }, 20000); });
-    }
-    catch (err) {
-        console.error(`Error stopping processes: ${ err.message }`);
-    }
-    finally {
-        process.exit();
-    }
-}
-if (process.platform === 'win32') {
-    let rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.on('SIGINT', async function () {
-        try { await stopAsync(); } catch (err) { console.log(`Error shutting down processes ${err.message}`); }
-    });
-}
-else {
-    process.stdin.resume();
-    process.on('SIGINT', async function () {
-        try { return await stopAsync(); } catch (err) { console.log(`Error shutting down processes ${err.message}`); }
-    });
-}
-if (typeof process === 'object') {
-    process.on('unhandledRejection', (error: Error, promise) => {
-        console.group('unhandled rejection');
-        console.error("== Node detected an unhandled rejection! ==");
-        console.error(error.message);
-        console.error(error.stack);
-        console.groupEnd();
-    });
-}
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+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
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// add source map support for .js to .ts files
+//require('source-map-support').install();
+import 'source-map-support/register';
+
+import { logger } from "./logger/Logger";
+import { config } from "./config/Config";
+import { conn } from "./controller/comms/Comms";
+import { sys } from "./controller/Equipment";
+
+import { state } from "./controller/State";
+import { webApp, REMInterfaceServer } from "./web/Server";
+import * as readline from 'readline';
+import { sl } from './controller/comms/ScreenLogic'
+
+export async function initAsync() {
+    try {
+        await config.init();
+        await logger.init();
+        await sys.init();
+        await state.init();
+        await webApp.init();
+        await conn.initAsync();
+        await sys.start();
+        await webApp.initAutoBackup();
+        await sl.openAsync();
+    } catch (err) { console.log(`Error Initializing nodejs-PoolController ${err.message}`);  }
+}
+
+export async function startPacketCapture(bResetLogs: boolean) {
+    try {
+        let log = config.getSection('log');
+        log.app.captureForReplay = true;
+        config.setSection('log', log);
+        logger.startCaptureForReplay(bResetLogs);
+        if (bResetLogs){
+            await sys.resetSystemAsync();
+        }
+        
+        // Start packet capture on the REM server
+        await REMInterfaceServer.startPacketCaptureOnRemServer();
+    }
+    catch (err) {
+        console.error(`Error starting replay: ${ err.message }`);
+    }
+}
+export async function stopPacketCaptureAsync() {
+    let log = config.getSection('log');
+    log.app.captureForReplay = false;
+    config.setSection('log', log);
+    
+    // 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 {
+        console.log('Shutting down open processes');
+        await webApp.stopAutoBackup();
+        await sys.stopAsync();
+        await state.stopAsync();
+        await conn.stopAsync();
+        await sl.closeAsync();
+        await webApp.stopAsync();
+        await config.updateAsync();
+        await logger.stopAsync();
+        // RKS: Uncomment below to see the shutdown process
+        //await new Promise<void>((resolve, reject) => { setTimeout(() => { resolve(); }, 20000); });
+    }
+    catch (err) {
+        console.error(`Error stopping processes: ${ err.message }`);
+    }
+    finally {
+        process.exit();
+    }
+}
+if (process.platform === 'win32') {
+    let rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.on('SIGINT', async function () {
+        try { await stopAsync(); } catch (err) { console.log(`Error shutting down processes ${err.message}`); }
+    });
+}
+else {
+    process.stdin.resume();
+    process.on('SIGINT', async function () {
+        try { return await stopAsync(); } catch (err) { console.log(`Error shutting down processes ${err.message}`); }
+    });
+}
+if (typeof process === 'object') {
+    process.on('unhandledRejection', (error: Error, promise) => {
+        console.group('unhandled rejection');
+        console.error("== Node detected an unhandled rejection! ==");
+        console.error(error.message);
+        console.error(error.stack);
+        console.groupEnd();
+    });
+}
 ( async () => { await initAsync() })();

package/config/Config.ts

@@ -36,21 +36,52 @@ class Config {
         // RKS 05-18-20: This originally had multiple points of failure where it was not in the try/catch.
         try {
             this._isLoading = true;
-            this._cfg = fs.existsSync(this.cfgPath) ? JSON.parse(fs.readFileSync(this.cfgPath, "utf8").trim()) : {};
+            // Read user config (if present) with graceful handling of empty or invalid JSON.
+            let userCfg: any = {};
+            if (fs.existsSync(this.cfgPath)) {
+                try {
+                    const raw = fs.readFileSync(this.cfgPath, "utf8");
+                    const trimmed = raw.trim();
+                    if (trimmed.length > 0) userCfg = JSON.parse(trimmed);
+                    else {
+                        console.log(`Config file '${ this.cfgPath }' is empty. Populating with defaults.`);
+                    }
+                } catch (parseErr: any) {
+                    // Backup corrupt file then continue with defaults.
+                    try {
+                        const backupName = this.cfgPath.replace(/\.json$/i, `.corrupt-${ Date.now() }.json`);
+                        fs.copyFileSync(this.cfgPath, backupName);
+                        console.log(`Config file '${ this.cfgPath }' contained invalid JSON and was backed up to '${ backupName }'. Using defaults.`);
+                    } catch (backupErr: any) {
+                        console.log(`Failed to backup corrupt config file '${ this.cfgPath }': ${ backupErr.message }`);
+                    }
+                    userCfg = {};
+                }
+            }
             const def = JSON.parse(fs.readFileSync(path.join(process.cwd(), "/defaultConfig.json"), "utf8").trim());
             const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), "/package.json"), "utf8").trim());
-            this._cfg = extend(true, {}, def, this._cfg, { appVersion: packageJson.version });
+            this._cfg = extend(true, {}, def, userCfg, { appVersion: packageJson.version });
             this._isInitialized = true;
             this.updateAsync((err) => {
                 if (typeof err === 'undefined') {
                     fs.watch(this.cfgPath, (event, fileName) => {
                         if (fileName && event === 'change') {
-                            if (self._isLoading) return; // Need a debounce here.  We will use a semaphore to cause it not to load more than once.
+                            if (self._isLoading) return; // Debounce via semaphore.
                             console.log('Updating config file');
                             const stats = fs.statSync(self.cfgPath);
                             if (stats.mtime.valueOf() === self._fileTime.valueOf()) return;
-                            this._cfg = fs.existsSync(this.cfgPath) ? JSON.parse(fs.readFileSync(this.cfgPath, "utf8")) : {};
-                            this._cfg = extend(true, {}, def, this._cfg, { appVersion: packageJson.version });
+                            let changedCfg: any = {};
+                            if (fs.existsSync(self.cfgPath)) {
+                                try {
+                                    const raw2 = fs.readFileSync(self.cfgPath, "utf8");
+                                    const trimmed2 = raw2.trim();
+                                    if (trimmed2.length > 0) changedCfg = JSON.parse(trimmed2);
+                                    else console.log(`Watched config file is empty; continuing with defaults + existing overrides.`);
+                                } catch (e: any) {
+                                    console.log(`Error parsing updated config file. Retaining existing configuration. Error: ${ e.message }`);
+                                }
+                            }
+                            this._cfg = extend(true, {}, def, changedCfg, { appVersion: packageJson.version });
                             logger.init(); // only reload logger for now; possibly expand to other areas of app
                             logger.info(`Reloading app config: ${fileName}`);
                             this.emitter.emit('reloaded', this._cfg);
@@ -63,8 +94,7 @@ class Config {
             this.getEnvVariables();
         } catch (err) {
             console.log(`Error reading configuration information.  Aborting startup: ${ err }`);
-            // Rethrow this error so we exit the app with the appropriate pause in the console.
-            throw err;
+            throw err; // Only throw if defaults/package.json could not be read.
         }
     }
     public async updateAsync(callback?: (err?) => void) {
@@ -189,6 +219,26 @@ class Config {
             this._cfg.controller.comms.netPort = env.POOL_NET_PORT;
             bUpdate = true;
         }
+        // Allow overriding location coordinates for heliotrope calculations
+        if (typeof env.POOL_LATITUDE !== 'undefined') {
+            const lat = parseFloat(env.POOL_LATITUDE as any);
+            if (!isNaN(lat) && (!this._cfg.controller?.general?.location || this._cfg.controller.general.location.latitude !== lat)) {
+                // Ensure nested objects exist
+                this._cfg.controller.general = this._cfg.controller.general || {};
+                this._cfg.controller.general.location = this._cfg.controller.general.location || {};
+                this._cfg.controller.general.location.latitude = lat;
+                bUpdate = true;
+            }
+        }
+        if (typeof env.POOL_LONGITUDE !== 'undefined') {
+            const lon = parseFloat(env.POOL_LONGITUDE as any);
+            if (!isNaN(lon) && (!this._cfg.controller?.general?.location || this._cfg.controller.general.location.longitude !== lon)) {
+                this._cfg.controller.general = this._cfg.controller.general || {};
+                this._cfg.controller.general.location = this._cfg.controller.general.location || {};
+                this._cfg.controller.general.location.longitude = lon;
+                bUpdate = true;
+            }
+        }
         if (bUpdate) this.updateAsync();
     }
 }

package/config/VersionCheck.ts

@@ -28,10 +28,24 @@ class VersionCheck {
     private gitApiHost: string;
     private gitLatestReleaseJSONPath: string;
     private redirects: number;
+    private gitAvailable: boolean;
+    private warnedBranch: boolean = false;
+    private warnedCommit: boolean = false;
     constructor() {
         this.userAgent = 'tagyoureit-nodejs-poolController-app';
         this.gitApiHost = 'api.github.com';
         this.gitLatestReleaseJSONPath = '/repos/tagyoureit/nodejs-poolController/releases/latest';
+        this.gitAvailable = this.detectGit();
+        // NOTE:
+        //  * SOURCE_BRANCH / SOURCE_COMMIT env vars (if present) override git commands. These are expected in container builds where .git may be absent.
+        //  * If git is not available (no binary or not a repo) we suppress repeated warnings after the first occurrence.
+        //  * Version comparison is rate-limited via nextCheckTime (every 2 days) to avoid Github API throttling.
+    }
+    private detectGit(): boolean {
+        try {
+            execSync('git --version', { stdio: 'ignore' });
+            return true;
+        } catch { return false; }
     }
 
     public checkGitRemote() {
@@ -40,43 +54,46 @@ class VersionCheck {
         if (typeof state.appVersion.nextCheckTime === 'undefined' || new Date() > new Date(state.appVersion.nextCheckTime)) setTimeout(() => { this.checkAll(); }, 100);
     }
     public checkGitLocal() {
-        let env = process.env;
-        // check local git version
+        const env = process.env;
+        // Branch
         try {
             let out: string;
-            if (typeof env.SOURCE_BRANCH !== 'undefined') 
-            {
-                out = env.SOURCE_BRANCH // check for docker variable
-            }
-            else {
-                let res = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' });
+            if (typeof env.SOURCE_BRANCH !== 'undefined') {
+                out = env.SOURCE_BRANCH;
+            } else if (this.gitAvailable) {
+                const res = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' });
                 out = res.toString().trim();
+            } else {
+                out = '--';
             }
-            logger.info(`The current git branch output is ${out}`);
+            if (out !== '--') logger.info(`The current git branch output is ${out}`);
             switch (out) {
-            case 'fatal':
-            case 'command':
-                state.appVersion.gitLocalBranch = '--';
-                break;
-            default:
-                state.appVersion.gitLocalBranch = out;
-        }
-        }
-        catch (err) {
+                case 'fatal':
+                case 'command':
+                    state.appVersion.gitLocalBranch = '--';
+                    break;
+                default:
+                    state.appVersion.gitLocalBranch = out;
+            }
+        } catch (err) {
             state.appVersion.gitLocalBranch = '--';
-            logger.warn(`Unable to retrieve local git branch.  ${err}`);
+            if (!this.warnedBranch) {
+                logger.warn(`Unable to retrieve local git branch (git missing or not a repo). Further branch warnings suppressed.`);
+                this.warnedBranch = true;
+            }
         }
+        // Commit
         try {
             let out: string;
-            if (typeof env.SOURCE_COMMIT !== 'undefined') 
-            {
-                out = env.SOURCE_COMMIT; // check for docker variable
-            }
-            else {
-                let res = execSync('git rev-parse HEAD', { stdio: 'pipe' });
+            if (typeof env.SOURCE_COMMIT !== 'undefined') {
+                out = env.SOURCE_COMMIT;
+            } else if (this.gitAvailable) {
+                const res = execSync('git rev-parse HEAD', { stdio: 'pipe' });
                 out = res.toString().trim();
+            } else {
+                out = '--';
             }
-            logger.info(`The current git commit output is ${out}`);
+            if (out !== '--') logger.info(`The current git commit output is ${out}`);
             switch (out) {
                 case 'fatal':
                 case 'command':
@@ -85,10 +102,12 @@ class VersionCheck {
                 default:
                     state.appVersion.gitLocalCommit = out;
             }
-        }
-        catch (err) { 
+        } catch (err) {
             state.appVersion.gitLocalCommit = '--';
-            logger.warn(`Unable to retrieve local git commit.  ${err}`); 
+            if (!this.warnedCommit) {
+                logger.warn(`Unable to retrieve local git commit (git missing or not a repo). Further commit warnings suppressed.`);
+                this.warnedCommit = true;
+            }
         }
     }
     private checkAll() {
@@ -126,15 +145,24 @@ class VersionCheck {
         return new Promise<string>((resolve, reject) => {
             try {
                 let req = https.request(url, options, async res => {
-                    if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) await this.getLatestRelease(res.headers.location);
+                    if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) {
+                        try {
+                            const redirected = await this.getLatestRelease(res.headers.location);
+                            return resolve(redirected);
+                        } catch (e) { return reject(e); }
+                    }
                     let data = '';
                     res.on('data', d => { data += d; });
                     res.on('end', () => {
-                        let jdata = JSON.parse(data);
-                        if (typeof jdata.tag_name !== 'undefined')
-                            resolve(jdata.tag_name.replace('v', ''));
-                        else
-                            reject(`No data returned.`)
+                        try {
+                            let jdata = JSON.parse(data);
+                            if (typeof jdata.tag_name !== 'undefined')
+                                resolve(jdata.tag_name.replace('v', ''));
+                            else
+                                reject(`No data returned.`)
+                        } catch(parseErr: any){
+                            reject(`Error parsing Github response: ${ parseErr.message }`);
+                        }
                     })
                 })
                     .end();