@homebridge-plugins/homebridge-tado 8.6.0-beta.2 → 8.6.0-beta.3

package/CHANGELOG.md

@@ -1,11 +1,16 @@
 # Changelog
 
-## v8.6.0 - 2025-10-30
-- BREAKING CHANGE: If you use tadoApiUrl or skipAuth, you must now define them under each corresponding home in your configuration (#176)
-- Refactor configuration: moved tadoApiUrl and skipAuth into individual home configs to support multiple API URLs (#176)
-- Persist tado zone states after every zone states update
+## v8.6.0 - 2025-10-31
+- BREAKING CHANGE: If you use tadoApiUrl or skipAuth, they must now be defined under each corresponding home in your configuration (#176)
+- Refactor configuration: Moved tadoApiUrl and skipAuth into individual home configs to support multiple API URLs (#176)
+- Persist Tado zone states after zone state updates
 - Improved zone update logic: when setting a state, all zones are now updated immediately if the next scheduled update is more than 10 seconds away
+- Advanced queue handling for update and persistence tasks
+- Tado API counter now tracks and persists for each authenticated user
+- Fix: Polling and tasks for multiple homes (#178)
 - Fix: Corrected zone update handling that could previously cause unintended heating changes (#178)
+- Added additional debug log messages for zone updates
+- Note: This update will reset your tado api counter for the current day to zero.
 
 ## v8.5.0 - 2025-10-27
 - Change minimum polling interval to 30s due to improvements made in v8.2.0

package/homebridge-ui/server.js

@@ -21,7 +21,7 @@ class UiServer extends HomebridgePluginUiServer {
       username: config.username,
       tadoApiUrl: config.tadoApiUrl,
       skipAuth: config.skipAuth
-    }, this.homebridgeStoragePath);
+    }, this.homebridgeStoragePath, false);
 
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebridge-plugins/homebridge-tado",
-  "version": "8.6.0-beta.2",
+  "version": "8.6.0-beta.3",
   "description": "Homebridge plugin for controlling tado° devices.",
   "main": "index.js",
   "scripts": {

package/src/helper/handler.js

@@ -1,42 +1,35 @@
 import Logger from '../helper/logger.js';
 import moment from 'moment';
-import { writeFile, access, readFile } from 'fs/promises';
+import { writeFile } from 'fs/promises';
 import { join } from "path";
 
-let settingState = false;
-let tasksInitialized = false;
-let lastGetStates = 0;
-const delayTimer = {};
-
 const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
-const aRefreshHistoryHandlers = [];
-
-export async function getPersistedStates(storagePath) {
-  try {
-    const sFilePath = join(storagePath, "tado-states.json");
-    await access(sFilePath);
-    const sData = (await readFile(sFilePath, "utf-8"));
-    if (sData) return JSON.parse(sData);
-  } catch (error) {
-    //no states data => ignore
-    Logger.debug(`Failed to read tado states file: ${error.message || error}`);
-  }
-}
+const helpers = {};
 
 export default (api, accessories, config, tado, telegram) => {
-  const statesIntervalTime = Math.max(config.polling, 30) * 1000;
-  const storagePath = api.user.storagePath();
+  //init helper variables for current home scope
+  if (!helpers[config.homeId]) {
+    helpers[config.homeId] = {
+      settingState: false,
+      tasksInitialized: false,
+      lastGetStates: 0,
+      lastPersistZoneStates: 0,
+      persistPromise: Promise.resolve(),
+      updateZonesRunning: false,
+      updateZonesNextQueued: false,
+      delayTimer: {},
+      refreshHistoryHandlers: [],
+      statesIntervalTime: Math.max(config.polling, 30) * 1000,
+      storagePath: api.user.storagePath(),
+    }
+  }
 
   async function setStates(accessory, accs, target, value) {
     let zoneUpdated = false;
-
     accessories = accs.filter((acc) => acc && acc.context.config.homeName === config.homeName);
-
     try {
-      settingState = true;
-
+      helpers[config.homeId].settingState = true;
       value = typeof value === 'number' ? parseFloat(value.toFixed(2)) : value;
-
       Logger.info(target + ': ' + value, accessory.displayName);
 
       switch (accessory.context.config.subtype) {
@@ -63,10 +56,10 @@ export default (api, accessories, config, tado, telegram) => {
             value < 5
           ) {
             if (value === 0) {
-              if (delayTimer[accessory.displayName]) {
+              if (helpers[config.homeId].delayTimer[accessory.displayName]) {
                 Logger.info('Resetting delay timer', accessory.displayName);
-                clearTimeout(delayTimer[accessory.displayName]);
-                delayTimer[accessory.displayName] = null;
+                clearTimeout(helpers[config.homeId].delayTimer[accessory.displayName]);
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }
 
               power = 'OFF';
@@ -111,14 +104,14 @@ export default (api, accessories, config, tado, telegram) => {
               let timer = accessory.context.delayTimer;
               let tarState = value === 1 ? 'HEAT' : 'AUTO';
 
-              if (delayTimer[accessory.displayName]) {
-                clearTimeout(delayTimer[accessory.displayName]);
-                delayTimer[accessory.displayName] = null;
+              if (helpers[config.homeId].delayTimer[accessory.displayName]) {
+                clearTimeout(helpers[config.homeId].delayTimer[accessory.displayName]);
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }
 
               Logger.info('Wait ' + timer + ' seconds before switching state', accessory.displayName);
 
-              delayTimer[accessory.displayName] = setTimeout(async () => {
+              helpers[config.homeId].delayTimer[accessory.displayName] = setTimeout(async () => {
                 Logger.info('Delay timer finished, switching state to ' + tarState, accessory.displayName);
 
                 //targetState
@@ -172,7 +165,7 @@ export default (api, accessories, config, tado, telegram) => {
                   );
                 }
 
-                delayTimer[accessory.displayName] = null;
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }, timer * 1000);
             }
           } else {
@@ -567,11 +560,11 @@ export default (api, accessories, config, tado, telegram) => {
     } catch (err) {
       errorHandler(err);
     } finally {
-      settingState = false;
+      helpers[config.homeId].settingState = false;
       //update zones to ensure correct state in Apple Home
-      const timeSinceLastGetStates = Date.now() - lastGetStates;
-      const statesIntervalTimeLeft = statesIntervalTime - timeSinceLastGetStates;
-      if (zoneUpdated && statesIntervalTimeLeft > 10_000) await updateZones();
+      const timeSinceLastGetStates = helpers[config.homeId].lastGetStates === 0 ? 0 : (Date.now() - helpers[config.homeId].lastGetStates);
+      const statesIntervalTimeLeft = helpers[config.homeId].statesIntervalTime - timeSinceLastGetStates;
+      if (zoneUpdated && statesIntervalTimeLeft > (10 * 1000)) await updateZones();
     }
   }
 
@@ -729,61 +722,49 @@ export default (api, accessories, config, tado, telegram) => {
     }
   }
 
-  async function persistZoneStates(homeId, zoneStates) {
+  function persistZoneStates(homeId, zoneStates) {
+    helpers[config.homeId].persistPromise = helpers[config.homeId].persistPromise.then(() => _persistZoneStates(homeId, zoneStates));
+  }
+
+  async function _persistZoneStates(homeId, zoneStates) {
+    if ((Date.now() - helpers[config.homeId].lastPersistZoneStates) < (10 * 1000)) return;
     try {
       if (zoneStates && Object.keys(zoneStates).length) {
         const homeData = {};
         homeData.zoneStates = zoneStates;
-        await writeFile(join(storagePath, `tado-states-${homeId}.json`), JSON.stringify(homeData, null, 2), "utf-8");
+        await writeFile(join(helpers[config.homeId].storagePath, `tado-states-${homeId}.json`), JSON.stringify(homeData, null, 2), "utf-8");
+        helpers[config.homeId].lastPersistZoneStates = Date.now();
       } else {
-        Logger.info(`Skipping persistence of tado states for home ${homeId}: zone states are empty.`);
+        Logger.warn(`Skipping persistence of tado states file for home ${homeId}: zone states are empty.`);
       }
     } catch (error) {
       Logger.error(`Error while updating the tado states file for home ${homeId}: ${error.message || error}`);
     }
   }
 
-  async function persistStates() {
-    try {
-      const data = {};
-      data.counterData = await tado.getCounterData();
-      await writeFile(join(storagePath, "tado-states.json"), JSON.stringify(data, null, 2), "utf-8");
-    } catch (error) {
-      Logger.error(`Error while updating the tado states file: ${error.message || error}`);
-    }
+  async function refreshHistoryServices() {
+    if (!helpers[config.homeId].refreshHistoryHandlers.length) return;
     try {
       //wait for fakegato history services to be loaded
       await timeout(4000);
-      for (const refreshHistory of aRefreshHistoryHandlers) {
+      for (const refreshHistory of helpers[config.homeId].refreshHistoryHandlers) {
         refreshHistory();
       }
     } catch (error) {
-      Logger.error(`Error while refreshing history: ${error.message || error}`);
-    }
-  }
-
-  async function logCounter() {
-    try {
-      const iCounter = (await tado.getCounterData()).counter;
-      Logger.info(`Tado API counter: ${iCounter.toLocaleString('en-US')}`);
-    } catch (error) {
-      Logger.warn(`Failed to get Tado API counter: ${error.message || error}`);
+      Logger.error(`Error while refreshing history services: ${error.message || error}`);
     }
   }
 
   function initTasks() {
-    if (tasksInitialized) return;
-    tasksInitialized = true;
+    if (helpers[config.homeId].tasksInitialized) return;
+    helpers[config.homeId].tasksInitialized = true;
 
     void getStates();
-    setInterval(() => getStates(), statesIntervalTime);
-
-    void logCounter();
-    setInterval(() => logCounter(), 60 * 60 * 1000);
+    setInterval(() => void getStates(), helpers[config.homeId].statesIntervalTime);
   }
 
   async function getStates() {
-    lastGetStates = Date.now();
+    helpers[config.homeId].lastGetStates = Date.now();
     try {
       //ME
       if (!config.homeId) await updateMe();
@@ -811,12 +792,12 @@ export default (api, accessories, config, tado, telegram) => {
     } catch (err) {
       errorHandler(err);
     } finally {
-      void persistStates();
+      void refreshHistoryServices();
     }
   }
 
   async function updateMe() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     Logger.debug('Polling User Info...', config.homeName);
 
@@ -828,7 +809,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateHome() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     Logger.debug('Polling Home Info...', config.homeName);
 
@@ -853,7 +834,32 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateZones() {
-    if (settingState) return;
+    if (helpers[config.homeId].updateZonesRunning) {
+      helpers[config.homeId].updateZonesNextQueued = true;
+      return;
+    }
+    helpers[config.homeId].updateZonesRunning = true;
+    try {
+      while (true) {
+        try {
+          await _updateZones();
+        } catch (error) {
+          Logger.error(`Failed to update zones: ${error.message || error}`);
+        }
+        if (helpers[config.homeId].updateZonesNextQueued) {
+          helpers[config.homeId].updateZonesNextQueued = false;
+          //continue with loop
+        } else {
+          break;
+        }
+      }
+    } finally {
+      helpers[config.homeId].updateZonesRunning = false;
+    }
+  }
+
+  async function _updateZones() {
+    if (helpers[config.homeId].settingState) return;
 
     Logger.debug('Polling Zones...', config.homeName);
 
@@ -1316,7 +1322,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateMobileDevices() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     Logger.debug('Polling MobileDevices...', config.homeName);
 
@@ -1370,7 +1376,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateWeather() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     const weatherTemperatureAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Weather'
@@ -1425,7 +1431,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updatePresence() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     const presenceLockAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Presence Lock'
@@ -1470,7 +1476,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateRunningTime() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     const centralSwitchAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Central Switch'
@@ -1515,7 +1521,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateDevices() {
-    if (settingState) return;
+    if (helpers[config.homeId].settingState) return;
 
     Logger.debug('Polling Devices...', config.homeName);
 
@@ -1586,6 +1592,6 @@ export default (api, accessories, config, tado, telegram) => {
     getStates: getStates,
     setStates: setStates,
     changedStates: changedStates,
-    refreshHistoryHandlers: aRefreshHistoryHandlers
+    refreshHistoryHandlers: helpers[config.homeId].refreshHistoryHandlers
   };
-};
+};

package/src/tado/tado-api.js

@@ -1,5 +1,4 @@
 import Logger from '../helper/logger.js';
-import { getPersistedStates } from '../helper/handler.js';
 import got from 'got';
 import { join } from 'path';
 import { access, readFile, writeFile } from 'fs/promises';
@@ -8,8 +7,17 @@ const tado_url = "https://my.tado.com";
 const tado_auth_url = "https://login.tado.com/oauth2";
 const tado_client_id = "1bb50063-6b0c-4d11-bd99-387f4a91cc46";
 
+function _getSimpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+  }
+  return (hash >>> 0).toString(36).padStart(7, '0');
+}
+
 export default class Tado {
-  constructor(name, auth, storagePath) {
+  constructor(name, auth, storagePath, counterActivated) {
     this.tadoApiUrl = auth.tadoApiUrl || tado_url;
     this.customTadoApiUrlActive = !!auth.tadoApiUrl;
     this.skipAuth = auth.skipAuth?.toString() === "true";
@@ -17,28 +25,42 @@ export default class Tado {
     this.name = name;
     const usesExternalTokenFile = auth.username?.toLowerCase().endsWith(".json");
     this._tadoExternalTokenFilePath = usesExternalTokenFile ? auth.username : undefined;
-    const fnSimpleHash = (str) => {
-      let hash = 0;
-      for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-      }
-      return (hash >>> 0).toString(36).padStart(7, '0');
-    };
+    this.hashedUsername = _getSimpleHash(auth.username);
     this.username = usesExternalTokenFile ? undefined : auth.username;
-    this._tadoInternalTokenFilePath = usesExternalTokenFile ? undefined : join(this.storagePath, `.tado-token-${fnSimpleHash(auth.username)}.json`);
+    this._tadoInternalTokenFilePath = usesExternalTokenFile ? undefined : join(this.storagePath, `.tado-token-${this.hashedUsername}.json`);
     this._tadoApiClientId = tado_client_id;
     this._tadoTokenPromise = undefined;
     this._tadoAuthenticationCallback = undefined;
+    this._counterActivated = counterActivated?.toString() === "true";
     this._counterInitPromise = this._initCounter();
     Logger.debug("API successfull initialized", this.name);
   }
 
   async _initCounter() {
-    const persistedCounterData = (await getPersistedStates(this.storagePath))?.counterData;
+    if (!this._counterActivated) return;
+    const persistedCounterData = (await this._getPersistedCounter())?.counterData;
     this._counter = persistedCounterData?.counter ?? 0;
     this._counterTimestamp = persistedCounterData?.counterTimestamp ?? new Date().toISOString();
     this._checkCounterMidnightReset();
+    //wait some seconds to catch recent api calls
+    setTimeout(() => {
+      void this._logCounter();
+      setInterval(() => void this._logCounter(), 60 * 60 * 1000);
+      void this._persistCounterData();
+      setInterval(() => void this._persistCounterData(), 5 * 60 * 1000);
+    }, 4 * 1000);
+  }
+
+  async _getPersistedCounter() {
+    try {
+      const filePath = join(this.storagePath, `tado-api-${this.hashedUsername}.json`);
+      await access(filePath);
+      const data = (await readFile(filePath, "utf-8"));
+      if (data) return JSON.parse(data);
+    } catch (error) {
+      //no persisted counter data => ignore
+      Logger.debug(`Failed to read tado api file for user ${this.hashedUsername}: ${error.message || error}`);
+    }
   }
 
   _checkCounterMidnightReset() {
@@ -53,6 +75,7 @@ export default class Tado {
   }
 
   async _increaseCounter() {
+    if (!this._counterActivated) return;
     try {
       await this._counterInitPromise;
       this._checkCounterMidnightReset();
@@ -63,7 +86,7 @@ export default class Tado {
     }
   }
 
-  async getCounterData() {
+  async _getCounterData() {
     await this._counterInitPromise;
     return {
       counter: this._counter,
@@ -71,6 +94,25 @@ export default class Tado {
     };
   }
 
+  async _persistCounterData() {
+    try {
+      const data = {};
+      data.counterData = await this._getCounterData();
+      await writeFile(join(this.storagePath, `tado-api-${this.hashedUsername}.json`), JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      Logger.error(`Error while updating the tado api file for user ${this.hashedUsername}: ${error.message || error}`);
+    }
+  }
+
+  async _logCounter() {
+    try {
+      const counter = (await this._getCounterData()).counter;
+      Logger.info(`Tado API counter: ${counter.toLocaleString('en-US')}`);
+    } catch (error) {
+      Logger.warn(`Failed to get Tado API counter: ${error.message || error}`);
+    }
+  }
+
   async getToken() {
     Logger.debug('Get access token...', this.name);
     if (!this._tadoTokenPromise) {

package/src/tado/tado-config.js

@@ -23,7 +23,7 @@ export default {
 
     for (const auth of auths) {
 
-      const tado = new TadoApi('Configuration', auth, storagePath);
+      const tado = new TadoApi('Configuration', auth, storagePath, false);
 
       const me = await tado.getMe();
 
@@ -160,7 +160,7 @@ export default {
         username: auth.username,
         tadoApiUrl: auth.tadoApiUrl,
         skipAuth: auth.skipAuth
-      }, storagePath);
+      }, storagePath, false);
 
       const me = await tado.getMe();
 
@@ -208,7 +208,7 @@ export default {
 
   refresh: async function (currentHome, config, auth, storagePath) {
 
-    const tado = new TadoApi('Configuration', auth, storagePath);
+    const tado = new TadoApi('Configuration', auth, storagePath, false);
 
     //Home Informations
     let home = config.homes.find((home) => home && home.name === currentHome);
@@ -505,7 +505,7 @@ export default {
             username: home.username,
             tadoApiUrl: home.tadoApiUrl,
             skipAuth: home.skipAuth
-          }, storagePath);
+          }, storagePath, true);
 
           const accessoryConfig = {
             homeId: home.id,