homebridge-nest-accfactory 0.2.11 → 0.3.1

package/dist/{thermostat.js → plugins/thermostat.js}

@@ -1,26 +1,33 @@
 // Nest Thermostat
 // Part of homebridge-nest-accfactory
 //
-// Code version 15/10/2024
 // Mark Hulskamp
 'use strict';
 
-// Define our modules
-import HomeKitDevice from './HomeKitDevice.js';
-
 // Define nodejs module requirements
 import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+// Define our modules
+import HomeKitDevice from '../HomeKitDevice.js';
 
-const LOWBATTERYLEVEL = 10; // Low battery level percentage
+// Define constants
+const LOW_BATTERY_LEVEL = 10; // Low battery level percentage
 const MIN_TEMPERATURE = 9; // Minimum temperature for Nest Thermostat
 const MAX_TEMPERATURE = 32; // Maximum temperature for Nest Thermostat
+const __dirname = path.dirname(fileURLToPath(import.meta.url)); // Make a defined for JS __dirname
 
 export default class NestThermostat extends HomeKitDevice {
+  static TYPE = 'Thermostat';
+  static VERSION = '2025.06.15';
+
   batteryService = undefined;
   occupancyService = undefined;
   humidityService = undefined;
-  fanService = undefined;
-  dehumidifierService = undefined;
+  switchService = undefined; // Hotwater heating boost control
+  fanService = undefined; // Fan control
+  dehumidifierService = undefined; // dehumidifier (only) control
   externalCool = undefined; // External module function
   externalHeat = undefined; // External module function
   externalFan = undefined; // External module function
@@ -31,247 +38,192 @@ export default class NestThermostat extends HomeKitDevice {
   }
 
   // Class functions
-  async addServices() {
+  async setupDevice() {
     // Setup the thermostat service if not already present on the accessory
-    this.thermostatService = this.accessory.getService(this.hap.Service.Thermostat);
-    if (this.thermostatService === undefined) {
-      this.thermostatService = this.accessory.addService(this.hap.Service.Thermostat, '', 1);
-    }
+    this.thermostatService = this.addHKService(this.hap.Service.Thermostat, '', 1);
     this.thermostatService.setPrimaryService();
 
-    if (this.thermostatService.testCharacteristic(this.hap.Characteristic.StatusActive) === false) {
-      // Used to indicate active temperature if the thermostat is using its temperature sensor data
-      // or an external temperature sensor ie: Nest Temperature Sensor
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.StatusActive);
-    }
-    if (this.thermostatService.testCharacteristic(this.hap.Characteristic.StatusFault) === false) {
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.StatusFault);
-    }
-    if (this.thermostatService.testCharacteristic(this.hap.Characteristic.LockPhysicalControls) === false) {
-      // Setting can only be accessed via Eve App (or other 3rd party).
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.LockPhysicalControls);
-    }
-    if (
-      this.deviceData?.has_air_filter === true &&
-      this.thermostatService.testCharacteristic(this.hap.Characteristic.FilterChangeIndication) === false
-    ) {
-      // Setup air filter change characteristic
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.FilterChangeIndication);
-    }
-    if (
-      this.deviceData?.has_air_filter === false &&
-      this.thermostatService.testCharacteristic(this.hap.Characteristic.FilterChangeIndication) === true
-    ) {
-      // No longer configured to have an air filter, so remove characteristic from the accessory
-      this.thermostatService.removeCharacteristic(this.hap.Characteristic.FilterChangeIndication);
-    }
+    // Setup set characteristics
 
-    if (
-      this.deviceData?.has_humidifier === true &&
-      this.thermostatService.testCharacteristic(this.hap.Characteristic.TargetRelativeHumidity) === false
-    ) {
-      // We have the capability for a humidifier, so setup target humidity characterisitc
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.TargetRelativeHumidity);
-    }
+    // Used to indicate active temperature if the thermostat is using its temperature sensor data
+    // or an external temperature sensor ie: Nest Temperature Sensor
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.StatusActive);
 
-    if (
-      this.deviceData?.has_humidifier === false &&
-      this.thermostatService.testCharacteristic(this.hap.Characteristic.TargetRelativeHumidity) === true
-    ) {
-      // No longer configured to use a humdifier, so remove characteristic from the accessory
-      this.thermostatService.removeCharacteristic(this.hap.Characteristic.TargetRelativeHumidity);
-    }
-
-    if (this.thermostatService.testCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity) === false) {
-      this.thermostatService.addCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity);
-    }
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.StatusFault);
 
-    // Limit prop ranges
-    if (this.deviceData?.can_cool === false && this.deviceData?.can_heat === true) {
-      // Can heat only, so set values allowed for mode off/heat
-      this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).setProps({
-        validValues: [this.hap.Characteristic.TargetHeatingCoolingState.OFF, this.hap.Characteristic.TargetHeatingCoolingState.HEAT],
-      });
-    }
-    if (this.deviceData?.can_cool === true && this.deviceData?.can_heat === false) {
-      // Can cool only
-      this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).setProps({
-        validValues: [this.hap.Characteristic.TargetHeatingCoolingState.OFF, this.hap.Characteristic.TargetHeatingCoolingState.COOL],
-      });
-    }
-    if (this.deviceData?.can_cool === true && this.deviceData?.can_heat === true) {
-      // heat and cool
-      this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).setProps({
-        validValues: [
-          this.hap.Characteristic.TargetHeatingCoolingState.OFF,
-          this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
-          this.hap.Characteristic.TargetHeatingCoolingState.COOL,
-          this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
-        ],
-      });
-    }
-    if (this.deviceData?.can_cool === false && this.deviceData?.can_heat === false) {
-      // only off mode
-      this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).setProps({
-        validValues: [this.hap.Characteristic.TargetHeatingCoolingState.OFF],
-      });
-    }
-
-    // Set default ranges - based on celsuis ranges to which the Nest Thermostat operates
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.CurrentTemperature).setProps({
-      minStep: 0.5,
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetTemperature).setProps({
-      minStep: 0.5,
-      minValue: MIN_TEMPERATURE,
-      maxValue: MAX_TEMPERATURE,
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature).setProps({
-      minStep: 0.5,
-      minValue: MIN_TEMPERATURE,
-      maxValue: MAX_TEMPERATURE,
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature).setProps({
-      minStep: 0.5,
-      minValue: MIN_TEMPERATURE,
-      maxValue: MAX_TEMPERATURE,
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.LockPhysicalControls, {
+      onSet: (value) => {
+        this.setChildlock('', value);
+      },
+      onGet: () => {
+        return this.deviceData.temperature_lock === true
+          ? this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED
+          : this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED;
+      },
     });
 
-    // Setup callbacks for characteristics
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TemperatureDisplayUnits).onSet((value) => {
-      this.setDisplayUnit(value);
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).onSet((value) => {
-      this.setMode(value);
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetTemperature).onSet((value) => {
-      this.setTemperature(this.hap.Characteristic.TargetTemperature, value);
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature).onSet((value) => {
-      this.setTemperature(this.hap.Characteristic.CoolingThresholdTemperature, value);
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature).onSet((value) => {
-      this.setTemperature(this.hap.Characteristic.HeatingThresholdTemperature, value);
-    });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.LockPhysicalControls).onSet((value) => {
-      this.setChildlock('', value);
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.CurrentRelativeHumidity, {
+      onGet: () => {
+        return this.deviceData.current_humidity;
+      },
     });
 
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TemperatureDisplayUnits).onGet(() => {
-      return this.deviceData.temperature_scale === 'C'
-        ? this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS
-        : this.hap.Characteristic.TemperatureDisplayUnits.FAHRENHEIT;
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.TemperatureDisplayUnits, {
+      onSet: (value) => {
+        this.setDisplayUnit(value);
+      },
+      onGet: () => {
+        return this.deviceData.temperature_scale === 'C'
+          ? this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS
+          : this.hap.Characteristic.TemperatureDisplayUnits.FAHRENHEIT;
+      },
     });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetTemperature).onGet(() => {
-      return this.getTemperature(this.hap.Characteristic.TargetTemperature);
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.CurrentTemperature, {
+      props: { minStep: 0.5 },
+      onGet: () => {
+        return this.deviceData.current_temperature;
+      },
     });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature).onGet(() => {
-      return this.getTemperature(this.hap.Characteristic.CoolingThresholdTemperature);
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.TargetTemperature, {
+      onSet: (value) => {
+        this.setTemperature(this.hap.Characteristic.TargetTemperature, value);
+      },
+      onGet: () => {
+        return this.getTemperature(this.hap.Characteristic.TargetTemperature);
+      },
     });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature).onGet(() => {
-      return this.getTemperature(this.hap.Characteristic.HeatingThresholdTemperature);
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.CoolingThresholdTemperature, {
+      props: {
+        minStep: 0.5,
+        minValue: MIN_TEMPERATURE,
+        maxValue: MAX_TEMPERATURE,
+      },
+      onSet: (value) => {
+        this.setTemperature(this.hap.Characteristic.CoolingThresholdTemperature, value);
+      },
+      onGet: () => {
+        return this.getTemperature(this.hap.Characteristic.CoolingThresholdTemperature);
+      },
     });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).onGet(() => {
-      return this.getMode();
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.HeatingThresholdTemperature, {
+      props: {
+        minStep: 0.5,
+        minValue: MIN_TEMPERATURE,
+        maxValue: MAX_TEMPERATURE,
+      },
+      onSet: (value) => {
+        this.setTemperature(this.hap.Characteristic.HeatingThresholdTemperature, value);
+      },
+      onGet: () => {
+        return this.getTemperature(this.hap.Characteristic.HeatingThresholdTemperature);
+      },
     });
-    this.thermostatService.getCharacteristic(this.hap.Characteristic.LockPhysicalControls).onGet(() => {
-      return this.deviceData.temperature_lock === true
-        ? this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED
-        : this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_DISABLED;
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.TargetHeatingCoolingState, {
+      props: {
+        validValues:
+          this.deviceData?.can_cool === true && this.deviceData?.can_heat === true
+            ? [
+              this.hap.Characteristic.TargetHeatingCoolingState.OFF,
+              this.hap.Characteristic.TargetHeatingCoolingState.HEAT,
+              this.hap.Characteristic.TargetHeatingCoolingState.COOL,
+              this.hap.Characteristic.TargetHeatingCoolingState.AUTO,
+            ]
+            : this.deviceData?.can_heat === true
+              ? [this.hap.Characteristic.TargetHeatingCoolingState.OFF, this.hap.Characteristic.TargetHeatingCoolingState.HEAT]
+              : this.deviceData?.can_cool === true
+                ? [this.hap.Characteristic.TargetHeatingCoolingState.OFF, this.hap.Characteristic.TargetHeatingCoolingState.COOL]
+                : [this.hap.Characteristic.TargetHeatingCoolingState.OFF],
+      },
+      onSet: (value) => {
+        this.setMode(value);
+      },
+      onGet: () => {
+        return this.getMode();
+      },
     });
 
-    // Setup occupancy service if not already present on the accessory
-    this.occupancyService = this.accessory.getService(this.hap.Service.OccupancySensor);
-    if (this.occupancyService === undefined) {
-      this.occupancyService = this.accessory.addService(this.hap.Service.OccupancySensor, '', 1);
+    if (this.deviceData?.has_air_filter === true) {
+      // We have the capability for an air filter, so setup filter change characterisitc
+      this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.FilterChangeIndication);
+    }
+    if (this.deviceData?.has_air_filter === false) {
+      // No longer configured to have an air filter, so remove characteristic from the accessory
+      this.thermostatService.removeCharacteristic(this.hap.Characteristic.FilterChangeIndication);
     }
+
+    // Setup occupancy service if not already present on the accessory
+    this.occupancyService = this.addHKService(this.hap.Service.OccupancySensor, '', 1);
     this.thermostatService.addLinkedService(this.occupancyService);
 
     // Setup battery service if not already present on the accessory
-    this.batteryService = this.accessory.getService(this.hap.Service.Battery);
-    if (this.batteryService === undefined) {
-      this.batteryService = this.accessory.addService(this.hap.Service.Battery, '', 1);
-    }
+    this.batteryService = this.addHKService(this.hap.Service.Battery, '', 1);
     this.batteryService.setHiddenService(true);
     this.thermostatService.addLinkedService(this.batteryService);
 
     // Setup fan service if supported by the thermostat and not already present on the accessory
-    this.fanService = this.accessory.getService(this.hap.Service.Fanv2);
     if (this.deviceData?.has_fan === true) {
-      if (this.fanService === undefined) {
-        this.fanService = this.accessory.addService(this.hap.Service.Fanv2, '', 1);
-      }
-      if (this.fanService.testCharacteristic(this.hap.Characteristic.RotationSpeed) === false) {
-        this.fanService.addCharacteristic(this.hap.Characteristic.RotationSpeed);
-      }
-      this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).setProps({
-        minStep: 100 / this.deviceData.fan_max_speed,
-      });
-
-      this.thermostatService.addLinkedService(this.fanService);
-
-      this.fanService.getCharacteristic(this.hap.Characteristic.Active).onSet((value) => {
-        this.setFan(
-          value,
-          value === this.hap.Characteristic.Active.ACTIVE ? (this.deviceData.fan_timer_speed / this.deviceData.fan_max_speed) * 100 : 0,
-        );
-      });
-      this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).onSet((value) => {
-        this.setFan(value !== 0 ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE, value);
-      });
-      this.fanService.getCharacteristic(this.hap.Characteristic.Active).onGet(() => {
-        return this.deviceData.fan_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
-      });
-      this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).onGet(() => {
-        return (this.deviceData.fan_timer_speed / this.deviceData.fan_max_speed) * 100;
-      });
+      this.#setupFan();
     }
-    if (this.deviceData?.has_fan === false && this.fanService !== undefined) {
+    if (this.deviceData?.has_fan === false) {
       // No longer have a Fan configured and service present, so removed it
-      this.accessory.removeService(this.fanService);
+      this.fanService = this.accessory.getService(this.hap.Service.Fanv2);
+      if (this.fanService !== undefined) {
+        this.accessory.removeService(this.fanService);
+      }
       this.fanService = undefined;
     }
 
     // Setup dehumifider service if supported by the thermostat and not already present on the accessory
-    this.dehumidifierService = this.accessory.getService(this.hap.Service.HumidifierDehumidifier);
     if (this.deviceData?.has_dehumidifier === true) {
-      if (this.dehumidifierService === undefined) {
-        this.dehumidifierService = this.accessory.addService(this.hap.Service.HumidifierDehumidifier, '', 1);
-      }
-      this.thermostatService.addLinkedService(this.dehumidifierService);
-
-      this.dehumidifierService.getCharacteristic(this.hap.Characteristic.TargetHumidifierDehumidifierState).setProps({
-        validValues: [this.hap.Characteristic.TargetHumidifierDehumidifierState.DEHUMIDIFIER],
-      });
-      this.dehumidifierService.getCharacteristic(this.hap.Characteristic.Active).onSet((value) => {
-        this.setDehumidifier(value);
-      });
-      this.dehumidifierService.getCharacteristic(this.hap.Characteristic.Active).onGet(() => {
-        return this.deviceData.dehumidifier_state === true
-          ? this.hap.Characteristic.Active.ACTIVE
-          : this.hap.Characteristic.Active.INACTIVE;
-      });
+      this.#setupDehumidifier();
     }
-    if (this.deviceData?.has_dehumidifier === false && this.dehumidifierService !== undefined) {
+    if (this.deviceData?.has_dehumidifier === false) {
       // No longer have a dehumidifier configured and service present, so removed it
-      this.accessory.removeService(this.dehumidifierService);
+      this.dehumidifierService = this.accessory.getService(this.hap.Service.HumidifierDehumidifier);
+      if (this.dehumidifierService !== undefined) {
+        this.accessory.removeService(this.dehumidifierService);
+      }
       this.dehumidifierService = undefined;
     }
 
     // Setup humdity service if configured to be seperate and not already present on the accessory
-    this.humidityService = this.accessory.getService(this.hap.Service.HumiditySensor);
     if (this.deviceData?.humiditySensor === true) {
-      if (this.humidityService === undefined) {
-        this.humidityService = this.accessory.addService(this.hap.Service.HumiditySensor, '', 1);
-      }
+      this.humidityService = this.addHKService(this.hap.Service.HumiditySensor, '', 1);
       this.thermostatService.addLinkedService(this.humidityService);
+
+      this.addHKCharacteristic(this.humidityService, this.hap.Characteristic.CurrentRelativeHumidity, {
+        onGet: () => {
+          return this.deviceData.current_humidity;
+        },
+      });
     }
-    if (this.deviceData?.humiditySensor === false && this.humidityService !== undefined) {
+    if (this.deviceData?.humiditySensor === false) {
       // No longer have a seperate humidity sensor configure and service present, so removed it
-      this.accessory.removeService(this.humidityService);
+      this.humidityService = this.accessory.getService(this.hap.Service.HumiditySensor);
+      if (this.humidityService !== undefined) {
+        this.accessory.removeService(this.humidityService);
+      }
       this.humidityService = undefined;
     }
 
+    // Setup hotwater heating boost service if supported by the thermostat and not already present on the accessory
+    if (this.deviceData?.has_hot_water_control === true) {
+      this.#setupHotwaterBoost();
+    }
+    if (this.deviceData?.has_hot_water_control === false) {
+      // No longer have hotwater heating boost configured and service present, so removed it
+      this.switchService = this.accessory.getService(this.hap.Service.Switch);
+      if (this.switchService !== undefined) {
+        this.accessory.removeService(this.switchService);
+      }
+      this.switchService = undefined;
+    }
+
     // Setup linkage to EveHome app if configured todo so
     if (
       this.deviceData?.eveHistory === true &&
@@ -288,42 +240,17 @@ export default class NestThermostat extends HomeKitDevice {
     // Attempt to load any external modules for this thermostat
     // We support external cool/heat/fan/dehumidifier module functions
     // This is all undocumented on how to use, as its for my specific use case :-)
-    const loadExternalModule = async (module) => {
-      if (typeof module !== 'string' || module === '') {
-        return;
-      }
-
-      let loadedModule = undefined;
-      try {
-        let values = module.match(/('.*?'|[^' ]+)(?=\s* |\s*$)/g);
-        let script = path.resolve(values[0]); // external library name
-        let options = values.slice(1); // options to be passed into the external library
-        let externalModule = await import(script);
-        if (typeof externalModule?.default === 'function') {
-          loadedModule = externalModule.default(this.log, options);
-        }
-        // eslint-disable-next-line no-unused-vars
-      } catch (error) {
-        this?.log?.warn && this.log.warn('Failed to load specified external module for thermostat "%s"', module);
-      }
-
-      return loadedModule;
-    };
-
-    this.externalCool = await loadExternalModule(this.deviceData?.externalCool);
-    this.externalHeat = await loadExternalModule(this.deviceData?.externalHeat);
-    this.externalFan = await loadExternalModule(this.deviceData?.externalFan);
-    this.externalDehumidifier = await loadExternalModule(this.deviceData?.externalDehumidifier);
-
-    // Create extra details for output
-    let postSetupDetails = [];
-    this.humidityService !== undefined && postSetupDetails.push('Seperate humidity sensor');
-    this.externalCool !== undefined && postSetupDetails.push('Using external cooling module');
-    this.externalHeat !== undefined && postSetupDetails.push('Using external heating module');
-    this.externalFan !== undefined && postSetupDetails.push('Using external fan module');
-    this.externalDehumidifier !== undefined && postSetupDetails.push('Using external dehumidification module');
-
-    return postSetupDetails;
+    this.externalCool = await this.#loadExternalModule(this.deviceData?.externalCool, ['cool', 'off']);
+    this.externalHeat = await this.#loadExternalModule(this.deviceData?.externalHeat, ['heat', 'off']);
+    this.externalFan = await this.#loadExternalModule(this.deviceData?.externalFan, ['fan', 'off']);
+    this.externalDehumidifier = await this.#loadExternalModule(this.deviceData?.externalDehumidifier, ['dehumidifier', 'off']);
+
+    // Extra setup details for output
+    this.humidityService !== undefined && this.postSetupDetail('Seperate humidity sensor');
+    this.externalCool !== undefined && this.postSetupDetail('Using external cooling module');
+    this.externalHeat !== undefined && this.postSetupDetail('Using external heating module');
+    this.externalFan !== undefined && this.postSetupDetail('Using external fan module');
+    this.externalDehumidifier !== undefined && this.postSetupDetail('Using external dehumidification module');
   }
 
   setFan(fanState, speed) {
@@ -339,30 +266,42 @@ export default class NestThermostat extends HomeKitDevice {
       this.fanService.updateCharacteristic(this.hap.Characteristic.Active, fanState);
       this.fanService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, speed);
 
-      this?.log?.info &&
-        this.log.info(
-          'Set fan on thermostat "%s" to "%s"',
-          this.deviceData.description,
-          fanState === this.hap.Characteristic.Active.ACTIVE ? 'On with fan speed of ' + speed + '%' : 'Off',
-        );
+      this?.log?.info?.(
+        'Set fan on thermostat "%s" to "%s"',
+        this.deviceData.description,
+        fanState === this.hap.Characteristic.Active.ACTIVE ? 'On with fan speed of ' + speed + '%' : 'Off',
+      );
     }
   }
 
   setDehumidifier(dehumidiferState) {
     this.set({
       uuid: this.deviceData.nest_google_uuid,
-      dehumidifer_State: dehumidiferState === this.hap.Characteristic.Active.ACTIVE ? true : false,
+      dehumidifier_state: dehumidiferState === this.hap.Characteristic.Active.ACTIVE ? true : false,
     });
     this.dehumidifierService.updateCharacteristic(this.hap.Characteristic.Active, dehumidiferState);
 
-    this?.log?.info &&
-      this.log.info(
-        'Set dehumidifer on thermostat "%s" to "%s"',
-        this.deviceData.description,
-        dehumidiferState === this.hap.Characteristic.Active.ACTIVE
-          ? 'On with target humidity level of ' + this.deviceData.target_humidity + '%'
-          : 'Off',
-      );
+    this?.log?.info?.(
+      'Set dehumidifer on thermostat "%s" to "%s"',
+      this.deviceData.description,
+      dehumidiferState === this.hap.Characteristic.Active.ACTIVE
+        ? 'On with target humidity level of ' + this.deviceData.target_humidity + '%'
+        : 'Off',
+    );
+  }
+
+  setHotwaterBoost(hotwaterState) {
+    this.set({
+      uuid: this.deviceData.nest_google_uuid,
+      hot_water_boost_active: { state: hotwaterState === true, time: this.deviceData.hotWaterBoostTime },
+    });
+    this.switchService.updateCharacteristic(this.hap.Characteristic.On, hotwaterState);
+
+    this?.log?.info?.(
+      'Set hotwater boost heating on thermostat "%s" to "%s"',
+      this.deviceData.description,
+      hotwaterState === true ? 'On for ' + formatDuration(this.deviceData.hotWaterBoostTime) : 'Off',
+    );
   }
 
   setDisplayUnit(temperatureUnit) {
@@ -372,12 +311,11 @@ export default class NestThermostat extends HomeKitDevice {
     });
     this.thermostatService.updateCharacteristic(this.hap.Characteristic.TemperatureDisplayUnits, temperatureUnit);
 
-    this?.log?.info &&
-      this.log.info(
-        'Set temperature units on thermostat "%s" to "%s"',
-        this.deviceData.description,
-        temperatureUnit === this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS ? '°C' : '°F',
-      );
+    this?.log?.info?.(
+      'Set temperature units on thermostat "%s" to "%s"',
+      this.deviceData.description,
+      temperatureUnit === this.hap.Characteristic.TemperatureDisplayUnits.CELSIUS ? '°C' : '°F',
+    );
   }
 
   setMode(thermostatMode) {
@@ -443,7 +381,7 @@ export default class NestThermostat extends HomeKitDevice {
 
       this.set({ uuid: this.deviceData.nest_google_uuid, hvac_mode: mode });
 
-      this?.log?.info && this.log.info('Set mode on "%s" to "%s"', this.deviceData.description, mode);
+      this?.log?.info?.('Set mode on "%s" to "%s"', this.deviceData.description, mode);
     }
   }
 
@@ -479,17 +417,16 @@ export default class NestThermostat extends HomeKitDevice {
       ) {
         this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature: temperature });
 
-        this?.log?.info &&
-          this.log.info(
-            'Set %s%s temperature on "%s" to "%s °C"',
-            this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-            this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value ===
-              this.hap.Characteristic.TargetHeatingCoolingState.HEAT
-              ? 'heating'
-              : 'cooling',
-            this.deviceData.description,
-            temperature,
-          );
+        this?.log?.info?.(
+          'Set %s%s temperature on "%s" to "%s °C"',
+          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
+          this.thermostatService.getCharacteristic(this.hap.Characteristic.TargetHeatingCoolingState).value ===
+            this.hap.Characteristic.TargetHeatingCoolingState.HEAT
+            ? 'heating'
+            : 'cooling',
+          this.deviceData.description,
+          temperature,
+        );
       }
       if (
         characteristic.UUID === this.hap.Characteristic.HeatingThresholdTemperature.UUID &&
@@ -498,13 +435,12 @@ export default class NestThermostat extends HomeKitDevice {
       ) {
         this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature_low: temperature });
 
-        this?.log?.info &&
-          this.log.info(
-            'Set %sheating temperature on "%s" to "%s °C"',
-            this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-            this.deviceData.description,
-            temperature,
-          );
+        this?.log?.info?.(
+          'Set %sheating temperature on "%s" to "%s °C"',
+          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
+          this.deviceData.description,
+          temperature,
+        );
       }
       if (
         characteristic.UUID === this.hap.Characteristic.CoolingThresholdTemperature.UUID &&
@@ -513,13 +449,12 @@ export default class NestThermostat extends HomeKitDevice {
       ) {
         this.set({ uuid: this.deviceData.nest_google_uuid, target_temperature_high: temperature });
 
-        this?.log?.info &&
-          this.log.info(
-            'Set %scooling temperature on "%s" to "%s °C"',
-            this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
-            this.deviceData.description,
-            temperature,
-          );
+        this?.log?.info?.(
+          'Set %scooling temperature on "%s" to "%s °C"',
+          this.deviceData.hvac_mode.toUpperCase().includes('ECO') ? 'eco mode ' : '',
+          this.deviceData.description,
+          temperature,
+        );
       }
 
       this.thermostatService.updateCharacteristic(characteristic, temperature); // Update HomeKit with value
@@ -567,15 +502,14 @@ export default class NestThermostat extends HomeKitDevice {
       temperature_lock: value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? true : false,
     });
 
-    this?.log?.info &&
-      this.log.info(
-        'Setting Childlock on "%s" to "%s"',
-        this.deviceData.description,
-        value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? 'Enabled' : 'Disabled',
-      );
+    this?.log?.info?.(
+      'Setting Childlock on "%s" to "%s"',
+      this.deviceData.description,
+      value === this.hap.Characteristic.LockPhysicalControls.CONTROL_LOCK_ENABLED ? 'Enabled' : 'Disabled',
+    );
   }
 
-  updateServices(deviceData) {
+  updateDevice(deviceData) {
     if (
       typeof deviceData !== 'object' ||
       this.thermostatService === undefined ||
@@ -630,7 +564,7 @@ export default class NestThermostat extends HomeKitDevice {
     this.batteryService.updateCharacteristic(this.hap.Characteristic.BatteryLevel, deviceData.battery_level);
     this.batteryService.updateCharacteristic(
       this.hap.Characteristic.StatusLowBattery,
-      deviceData.battery_level > LOWBATTERYLEVEL
+      deviceData.battery_level > LOW_BATTERY_LEVEL
         ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
         : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW,
     );
@@ -661,23 +595,7 @@ export default class NestThermostat extends HomeKitDevice {
     if (deviceData.has_fan !== this.deviceData.has_fan) {
       if (deviceData.has_fan === true && this.deviceData.has_fan === false && this.fanService === undefined) {
         // Fan has been added
-        this.fanService = this.accessory.addService(this.hap.Service.Fanv2, '', 1);
-
-        if (this.fanService.testCharacteristic(this.hap.Characteristic.RotationSpeed) === false) {
-          this.fanService.addCharacteristic(this.hap.Characteristic.RotationSpeed);
-        }
-        this.fanService.getCharacteristic(this.hap.Characteristic.RotationSpeed).setProps({
-          minStep: 100 / this.deviceData.fan_max_speed,
-        });
-        this.thermostatService.addLinkedService(this.fanService);
-
-        this.fanService.getCharacteristic(this.hap.Characteristic.Active).onSet((value) => {
-          this.setFan(value);
-        });
-
-        this.fanService.getCharacteristic(this.hap.Characteristic.Active).onGet(() => {
-          return this.deviceData.fan_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
-        });
+        this.#setupFan();
       }
       if (deviceData.has_fan === false && this.deviceData.has_fan === true && this.fanService !== undefined) {
         // Fan has been removed
@@ -685,34 +603,18 @@ export default class NestThermostat extends HomeKitDevice {
         this.fanService = undefined;
       }
 
-      this?.log?.info &&
-        this.log.info(
-          'Fan setup on thermostat "%s" has changed. Fan was',
-          deviceData.description,
-          this.fanService === undefined ? 'removed' : 'added',
-        );
+      this?.log?.info?.(
+        'Fan setup on thermostat "%s" has changed. Fan was',
+        deviceData.description,
+        this.fanService === undefined ? 'removed' : 'added',
+      );
     }
 
     // Check for dehumidifer setup change on thermostat
     if (deviceData.has_dehumidifier !== this.deviceData.has_dehumidifier) {
       if (deviceData.has_dehumidifier === true && this.deviceData.has_dehumidifier === false && this.dehumidifierService === undefined) {
         // Dehumidifier has been added
-        this.dehumidifierService = this.accessory.addService(this.hap.Service.HumidifierDehumidifier, '', 1);
-        this.thermostatService.addLinkedService(this.dehumidifierService);
-
-        this.dehumidifierService.getCharacteristic(this.hap.Characteristic.TargetHumidifierDehumidifierState).setProps({
-          validValues: [this.hap.Characteristic.TargetHumidifierDehumidifierState.DEHUMIDIFIER],
-        });
-
-        this.dehumidifierService.getCharacteristic(this.hap.Characteristic.Active).onSet((value) => {
-          this.setDehumidifier(value);
-        });
-
-        this.dehumidifierService.getCharacteristic(this.hap.Characteristic.Active).onGet(() => {
-          return this.deviceData.dehumidifier_state === true
-            ? this.hap.Characteristic.Active.ACTIVE
-            : this.hap.Characteristic.Active.INACTIVE;
-        });
+        this.#setupDehumidifier();
       }
       if (deviceData.has_dehumidifier === false && this.deviceData.has_dehumidifier === true && this.dehumidifierService !== undefined) {
         // Dehumidifer has been removed
@@ -720,12 +622,41 @@ export default class NestThermostat extends HomeKitDevice {
         this.dehumidifierService = undefined;
       }
 
-      this?.log?.info &&
-        this.log.info(
-          'Dehumidifier setup on thermostat "%s" has changed. Dehumidifier was',
-          deviceData.description,
-          this.dehumidifierService === undefined ? 'removed' : 'added',
-        );
+      this?.log?.info?.(
+        'Dehumidifier setup on thermostat "%s" has changed. Dehumidifier was',
+        deviceData.description,
+        this.dehumidifierService === undefined ? 'removed' : 'added',
+      );
+    }
+
+    // Check for hotwater heating boost setup change on thermostat
+    if (deviceData.has_hot_water_control !== this.deviceData.has_hot_water_control) {
+      if (
+        deviceData.has_hot_water_control === true &&
+        this.deviceData.has_hot_water_control === false &&
+        this.switchService === undefined
+      ) {
+        // hotwater heating boost has been added
+        this.switchService = this.accessory.getService(this.hap.Service.Switch);
+        if (this.deviceData.has_hot_water_control === true) {
+          this.#setupHotwaterBoost();
+        }
+        if (
+          deviceData.has_hot_water_control === false &&
+          this.deviceData.has_hot_water_control === true &&
+          this.switchService !== undefined
+        ) {
+          // hotwater heating boost has been removed
+          this.accessory.removeService(this.switchService);
+          this.switchService = undefined;
+        }
+      }
+
+      this?.log?.info?.(
+        'hotwater heating boost setup on thermostat "%s" has changed. Hotwater heating boost was',
+        deviceData.description,
+        this.switchService === undefined ? 'removed' : 'added',
+      );
     }
 
     if (deviceData.can_cool !== this.deviceData.can_cool || deviceData.can_heat !== this.deviceData.can_heat) {
@@ -762,7 +693,7 @@ export default class NestThermostat extends HomeKitDevice {
         });
       }
 
-      this?.log?.info && this.log.info('Heating/cooling setup on thermostat on "%s" has changed', deviceData.description);
+      this?.log?.info?.('Heating/cooling setup on thermostat on "%s" has changed', deviceData.description);
     }
 
     // Update current mode temperatures
@@ -808,7 +739,7 @@ export default class NestThermostat extends HomeKitDevice {
       historyEntry.target = { low: deviceData.target_temperature_low, high: deviceData.target_temperature_high };
     }
     if (deviceData.can_cool === false && deviceData.can_heat === false && deviceData.hvac_mode.toUpperCase() === 'OFF') {
-      // off mode.
+      // off mode
       this.thermostatService.updateCharacteristic(this.hap.Characteristic.TargetTemperature, deviceData.target_temperature);
       this.thermostatService.updateCharacteristic(
         this.hap.Characteristic.TargetHeatingCoolingState,
@@ -819,22 +750,18 @@ export default class NestThermostat extends HomeKitDevice {
 
     // Update current state
     if (deviceData.hvac_state.toUpperCase() === 'HEATING') {
-      if (this.deviceData.hvac_state.toUpperCase() === 'COOLING' && this.externalCool !== undefined) {
+      if (this.deviceData.hvac_state.toUpperCase() === 'COOLING' && typeof this.externalCool?.off === 'function') {
         // Switched to heating mode and external cooling external code was being used, so stop cooling via cooling external code
-        if (typeof this.externalCool.off === 'function') {
-          this.externalCool.off();
-        }
+        this.externalCool.off();
       }
       if (
         (this.deviceData.hvac_state.toUpperCase() !== 'HEATING' ||
           deviceData.target_temperature_low !== this.deviceData.target_temperature_low) &&
-        this.externalHeat !== undefined
+        typeof this.externalHeat?.heat === 'function'
       ) {
         // Switched to heating mode and external heating external code is being used
         // Start heating via heating external code OR adjust heating target temperature due to change
-        if (typeof this.externalHeat.heat === 'function') {
-          this.externalHeat.heat(deviceData.deviceData.target_temperature_low);
-        }
+        this.externalHeat.heat(deviceData.target_temperature_low);
       }
       this.thermostatService.updateCharacteristic(
         this.hap.Characteristic.CurrentHeatingCoolingState,
@@ -843,22 +770,18 @@ export default class NestThermostat extends HomeKitDevice {
       historyEntry.status = 2; // heating
     }
     if (deviceData.hvac_state.toUpperCase() === 'COOLING') {
-      if (this.deviceData.hvac_state.toUpperCase() === 'HEATING' && this.externalHeat !== undefined) {
+      if (this.deviceData.hvac_state.toUpperCase() === 'HEATING' && typeof this.externalHeat?.off === 'function') {
         // Switched to cooling mode and external heating external code was being used, so stop heating via heating external code
-        if (typeof this.externalHeat.off === 'function') {
-          this.externalHeat.off();
-        }
+        this.externalHeat.off();
       }
       if (
         (this.deviceData.hvac_state.toUpperCase() !== 'COOLING' ||
           deviceData.target_temperature_high !== this.deviceData.target_temperature_high) &&
-        this.externalCool !== undefined
+        typeof this.externalCool?.cool === 'function'
       ) {
         // Switched to cooling mode and external cooling external code is being used
         // Start cooling via cooling external code OR adjust cooling target temperature due to change
-        if (typeof this.externalCool.cool === 'function') {
-          this.externalCool.cool(deviceData.target_temperature_high);
-        }
+        this.externalCool.cool(deviceData.target_temperature_high);
       }
       this.thermostatService.updateCharacteristic(
         this.hap.Characteristic.CurrentHeatingCoolingState,
@@ -867,17 +790,13 @@ export default class NestThermostat extends HomeKitDevice {
       historyEntry.status = 3; // cooling
     }
     if (deviceData.hvac_state.toUpperCase() === 'OFF') {
-      if (this.deviceData.hvac_state.toUpperCase() === 'COOLING' && this.externalCool !== undefined) {
-        // Switched to off mode and external cooling external code was being used, so stop cooling via cooling external code
-        if (typeof this.externalCool.off === 'function') {
-          this.externalCool.off();
-        }
+      if (this.deviceData.hvac_state.toUpperCase() === 'COOLING' && typeof this.externalCool?.off === 'function') {
+        // Switched to off mode and external cooling external code was being used, so stop cooling via cooling external code{
+        this.externalCool.off();
       }
-      if (this.deviceData.hvac_state.toUpperCase() === 'HEATING' && this.externalHeat !== undefined) {
+      if (this.deviceData.hvac_state.toUpperCase() === 'HEATING' && typeof this.externalHeat?.off === 'function') {
         // Switched to off mode and external heating external code was being used, so stop heating via heating external code
-        if (typeof this.externalHeat.heat === 'function') {
-          this.externalHeat.off();
-        }
+        this.externalHeat.off();
       }
       this.thermostatService.updateCharacteristic(
         this.hap.Characteristic.CurrentHeatingCoolingState,
@@ -885,18 +804,16 @@ export default class NestThermostat extends HomeKitDevice {
       );
       historyEntry.status = 0; // off
     }
+
     if (this.fanService !== undefined) {
-      if (this.deviceData.fan_state === false && deviceData.fan_state === true && this.externalFan !== undefined) {
+      // fan status on or off
+      if (this.deviceData.fan_state === false && deviceData.fan_state === true && typeof this.externalFan?.fan === 'function') {
         // Fan mode was switched on and external fan external code is being used, so start fan via fan external code
-        if (typeof this.externalFan.fan === 'function') {
-          this.externalFan.fan(0); // Fan speed will be auto
-        }
+        this.externalFan.fan(0); // Fan speed will be auto
       }
-      if (this.deviceData.fan_state === true && deviceData.fan_state === false && this.externalFan !== undefined) {
+      if (this.deviceData.fan_state === true && deviceData.fan_state === false && typeof this.externalFan?.off === 'function') {
         // Fan mode was switched off and external fan external code was being used, so stop fan via fan external code
-        if (typeof this.externalFan.off === 'function') {
-          this.externalFan.off();
-        }
+        this.externalFan.off();
       }
 
       this.fanService.updateCharacteristic(
@@ -907,40 +824,43 @@ export default class NestThermostat extends HomeKitDevice {
       this.fanService.updateCharacteristic(
         this.hap.Characteristic.Active,
         deviceData.fan_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE,
-      ); // fan status on or off
+      );
       historyEntry.status = 1; // fan
     }
+
     if (this.dehumidifierService !== undefined) {
+      // dehumidifier status on or off
       if (
         this.deviceData.dehumidifier_state === false &&
         deviceData.dehumidifier_state === true &&
-        this.externalDehumidifier !== undefined
+        typeof this.externalDehumidifier?.dehumidifier === 'function'
       ) {
         // Dehumidifier mode was switched on and external dehumidifier external code is being used
         // Start dehumidifier via dehumidifier external code
-        if (typeof this.externalDehumidifier.dehumififier === 'function') {
-          this.externalDehumidifier.dehumififier(0);
-        }
+        this.externalDehumidifier.dehumidifier(0);
       }
       if (
         this.deviceData.dehumidifier_state === true &&
         deviceData.dehumidifier_state === false &&
-        this.externalDehumidifier !== undefined
+        typeof this.externalDehumidifier?.off === 'function'
       ) {
         // Dehumidifier mode was switched off and external dehumidifier external code was being used
         // Stop dehumidifier via dehumidifier external code
-        if (typeof this.externalDehumidifier.off === 'function') {
-          this.externalDehumidifier.off();
-        }
+        this.externalDehumidifier.off();
       }
 
       this.dehumidifierService.updateCharacteristic(
         this.hap.Characteristic.Active,
         deviceData.dehumidifier_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE,
-      ); // dehumidifier status on or off
+      );
       historyEntry.status = 4; // dehumidifier
     }
 
+    if (this.switchService !== undefined) {
+      // Hotwater boost status on or off
+      this.switchService.updateCharacteristic(this.hap.Characteristic.On, deviceData.hot_water_boost_active === true);
+    }
+
     // Log thermostat metrics to history only if changed to previous recording
     if (this.thermostatService !== undefined && typeof this.historyService?.addHistory === 'function') {
       let tempEntry = this.historyService.lastHistory(this.thermostatService);
@@ -1056,4 +976,127 @@ export default class NestThermostat extends HomeKitDevice {
       //});
     }
   }
+
+  #setupFan() {
+    this.fanService = this.addHKService(this.hap.Service.Fanv2, '', 1);
+    this.addHKCharacteristic(this.hap.Service.Fanv2, this.hap.Characteristic.RotationSpeed);
+    this.thermostatService.addLinkedService(this.fanService);
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.Active, {
+      onSet: (value) =>
+        this.setFan(
+          value,
+          value === this.hap.Characteristic.Active.ACTIVE ? (this.deviceData.fan_timer_speed / this.deviceData.fan_max_speed) * 100 : 0,
+        ),
+      onGet: () => {
+        return this.deviceData.fan_state === true ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE;
+      },
+    });
+
+    this.addHKCharacteristic(this.thermostatService, this.hap.Characteristic.RotationSpeed, {
+      props: { minStep: 100 / this.deviceData.fan_max_speed },
+      onSet: (value) => this.setFan(value !== 0 ? this.hap.Characteristic.Active.ACTIVE : this.hap.Characteristic.Active.INACTIVE, value),
+      onGet: () => {
+        return (this.deviceData.fan_timer_speed / this.deviceData.fan_max_speed) * 100;
+      },
+    });
+  }
+
+  #setupDehumidifier() {
+    this.dehumidifierService = this.addHKService(this.hap.Service.HumidifierDehumidifier, '', 1);
+    this.thermostatService.addLinkedService(this.dehumidifierService);
+
+    this.addHKCharacteristic(this.dehumidifierService, this.hap.Characteristic.TargetHumidifierDehumidifierState, {
+      props: { validValues: [this.hap.Characteristic.TargetHumidifierDehumidifierState.DEHUMIDIFIER] },
+    });
+
+    this.addHKCharacteristic(this.dehumidifierService, this.hap.Characteristic.Active, {
+      onSet: (value) => this.setDehumidifier(value),
+      onGet: () => {
+        return this.deviceData.dehumidifier_state === true
+          ? this.hap.Characteristic.Active.ACTIVE
+          : this.hap.Characteristic.Active.INACTIVE;
+      },
+    });
+  }
+
+  #setupHotwaterBoost() {
+    this.switchService = this.addHKService(this.hap.Service.Switch, '', 1);
+    this.thermostatService.addLinkedService(this.switchService);
+
+    this.addHKCharacteristic(this.switchService, this.hap.Characteristic.On, {
+      onSet: (value) => this.setHotwaterBoost(value),
+      onGet: () => {
+        return this.deviceData?.hot_water_boost_active === true;
+      },
+    });
+  }
+
+  async #loadExternalModule(module, expectedFunctions = []) {
+    if (typeof module !== 'string' || module === '' || Array.isArray(expectedFunctions) === false) {
+      return undefined;
+    }
+
+    // Helper to resolve a module path, defaulting to plugin dir and falling back from .mjs to .js
+    const resolveModulePath = async (basePath) => {
+      let hasExtension = path.extname(basePath) !== '';
+      let isRelative = basePath.startsWith('./') || basePath.startsWith('../');
+      let isAbsolute = path.isAbsolute(basePath);
+      let resolvedBase = isAbsolute ? basePath : isRelative ? path.resolve(basePath) : path.resolve(__dirname, basePath);
+      let finalPath = resolvedBase;
+
+      if (hasExtension === false) {
+        let mjsPath = `${resolvedBase}.mjs`;
+        let jsPath = `${resolvedBase}.js`;
+
+        try {
+          await fs.access(mjsPath);
+          finalPath = mjsPath;
+        } catch {
+          try {
+            await fs.access(jsPath);
+            finalPath = jsPath;
+          } catch {
+            finalPath = mjsPath; // fallback to mjs even if not found
+          }
+        }
+      }
+      return finalPath;
+    };
+
+    let loadedModule = undefined;
+
+    try {
+      let values = module.match(/'[^']*'|[^\s]+/g)?.map((v) => v.replace(/^'(.*)'$/, '$1')) || [];
+      let script = await resolveModulePath(values[0]);
+      let options = values.slice(1);
+      let externalModule = await import(script);
+
+      if (typeof externalModule?.default === 'function') {
+        let moduleExports = externalModule.default(this.log, options);
+        let valid = Object.fromEntries(
+          expectedFunctions.filter((fn) => typeof moduleExports[fn] === 'function').map((fn) => [fn, moduleExports[fn]]),
+        );
+        loadedModule = Object.keys(valid).length > 0 ? valid : undefined;
+      }
+      // eslint-disable-next-line no-unused-vars
+    } catch (error) {
+      let shortName =
+        typeof module === 'string'
+          ? module
+            .trim()
+            .match(/'[^']*'|[^\s]+/)?.[0]
+            ?.replace(/^'(.*)'$/, '$1')
+          : '';
+      this?.log?.warn?.('Failed to load external module "%s" for thermostat "%s"', shortName, this.deviceData.description);
+    }
+
+    return loadedModule;
+  }
+}
+
+function formatDuration(seconds) {
+  return `${
+    seconds >= 3600 ? `${Math.floor(seconds / 3600)} hr${Math.floor(seconds / 3600) > 1 ? 's' : ''} ` : ''
+  }${Math.floor((seconds % 3600) / 60)} min${Math.floor((seconds % 3600) / 60) !== 1 ? 's' : ''}`;
 }