homebridge-tesy-heater-api-v4 0.0.3 → 0.0.5

package/README.md

@@ -1,15 +1,29 @@
 # homebridge-tesy-heater-api-v4
-this is a clone/upgrade to https://github.com/benov84/homebridge-tesy-heater#readme for the newer tesy api
 
-# Homebridge Tesy Heater (v2)
+Homebridge plugin for Tesy smart heaters using the `ad.mytesy.com/rest/old-app-*` endpoints.
+Uses axios with a cookie jar to capture `PHPSESSID` if the API does not return `acc_session`/`acc_alt` in JSON.
 
-Homebridge plugin for Tesy smart heaters using the new v4 API.
-
-## Installation
+## Install (local dev)
 
 ```bash
-#git clone https://github.com/YOUR-USERNAME/homebridge-tesy-heater.git
-git clone https://github.com/mpopof/homebridge-tesy-heater-api-v4
-cd homebridge-tesy-heater-api-v4
 npm install
 sudo npm link
+# then configure in Homebridge UI
+```
+
+## Config fields
+
+- **name**: display name in HomeKit
+- **device_id**: device identifier as used by Tesy API
+- **username / password**: Tesy account
+- **userid**: (optional) some accounts require it
+- **pullInterval**: status refresh period in ms (default 10000)
+- **minTemp / maxTemp**: bounds for target temperature
+
+## Notes
+
+- Requires Node 16+ and Homebridge 1.6+
+- Endpoints used:
+  - `https://ad.mytesy.com/rest/old-app-login`
+  - `https://ad.mytesy.com/rest/old-app-devices`
+  - `https://ad.mytesy.com/rest/old-app-set-device-status`

package/config.schema.json

@@ -27,6 +27,11 @@
         "required": true,
         "format": "password"
       },
+      "userid": {
+        "title": "Tesy User ID (optional)",
+        "type": "string",
+        "required": false
+      },
       "pullInterval": {
         "title": "Refresh Interval (ms)",
         "type": "integer",
@@ -44,4 +49,4 @@
       }
     }
   }
-}
+}

package/index.js

@@ -1,3 +1,6 @@
+// index.js
+const { wrapper } = require("axios-cookiejar-support");
+const { CookieJar } = require("tough-cookie");
 const axios = require("axios");
 const _http_base = require("homebridge-http-base");
 const PullTimer = _http_base.PullTimer;
@@ -7,12 +10,32 @@ let Service, Characteristic;
 module.exports = function (homebridge) {
   Service = homebridge.hap.Service;
   Characteristic = homebridge.hap.Characteristic;
-  homebridge.registerAccessory("homebridge-tesy-heater-v2", "TesyHeater", TesyHeater);
+  // Keep the package name here in case you want to fully-qualify in config:
+  homebridge.registerAccessory("homebridge-tesy-heater-api-v4", "TesyHeater", TesyHeater);
 };
 
+// Shared axios instance with cookie jar and browser-like headers
+const jar = new CookieJar();
+const api = wrapper(axios.create({
+  jar,
+  withCredentials: true,
+  timeout: 15000,
+  headers: {
+    "accept": "application/json, text/plain, */*",
+    "content-type": "application/json",
+    "origin": "https://v4.mytesy.com",
+    "referer": "https://v4.mytesy.com/",
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36",
+    "dnt": "1"
+  },
+  validateStatus: (s) => s >= 200 && s < 400
+}));
+
 class TesyHeater {
   constructor(log, config) {
     this.log = log;
+
+    // ---- Config ----
     this.name = config.name;
     this.manufacturer = config.manufacturer || "Tesy";
     this.model = config.model || "Convector (Heater)";
@@ -20,118 +43,424 @@ class TesyHeater {
     this.pullInterval = config.pullInterval || 10000;
     this.maxTemp = config.maxTemp || 30;
     this.minTemp = config.minTemp || 10;
+
+    this.userid = config.userid || null;   // optional; some accounts have it
     this.username = config.username || null;
     this.password = config.password || null;
-    this.session = "";
-    this.alt = "";
 
-    if (this.username && this.password) {
-      this.authenticate();
-    }
+    // ---- Session state returned by login ----
+    this.session = ""; // PHPSESSID / acc_session
+    this.alt = "";     // ALT / acc_alt
 
+    // ---- HomeKit Service ----
     this.service = new Service.HeaterCooler(this.name);
+
+    // Default initial states
+    this.service
+      .getCharacteristic(Characteristic.CurrentHeaterCoolerState)
+      .updateValue(Characteristic.CurrentHeaterCoolerState.INACTIVE);
+
+    this.service
+      .getCharacteristic(Characteristic.Active)
+      .updateValue(Characteristic.Active.INACTIVE);
+
+    this.service
+      .getCharacteristic(Characteristic.CurrentTemperature)
+      .updateValue(this.minTemp);
+
+    this.service
+      .getCharacteristic(Characteristic.HeatingThresholdTemperature)
+      .setProps({
+        minValue: this.minTemp,
+        maxValue: this.maxTemp,
+        minStep: 0.5,
+      })
+      .updateValue(this.minTemp);
+
+    // Add CoolingThresholdTemperature so Home shows the marker on the wheel
+    this.service
+      .getCharacteristic(Characteristic.CoolingThresholdTemperature)
+      .setProps({
+        minValue: this.minTemp,
+        maxValue: this.maxTemp,
+        minStep: 0.5,
+      })
+      .updateValue(this.minTemp);
+
+    // Only support HEAT for TargetHeaterCoolerState
+    this.service
+      .getCharacteristic(Characteristic.TargetHeaterCoolerState)
+      .setProps({
+        validValues: [Characteristic.TargetHeaterCoolerState.HEAT],
+      });
+
+    // ---- Bind getters/setters ----
+    this.service
+      .getCharacteristic(Characteristic.Active)
+      .on("get", this.getActive.bind(this))
+      .on("set", this.setActive.bind(this));
+
+    this.service
+      .getCharacteristic(Characteristic.CurrentTemperature)
+      .setProps({ minStep: 0.1 })
+      .on("get", this.getCurrentTemperature.bind(this));
+
+    this.service
+      .getCharacteristic(Characteristic.HeatingThresholdTemperature)
+      .on("set", this.setHeatingThresholdTemperature.bind(this));
+
+    this.service
+      .getCharacteristic(Characteristic.TargetHeaterCoolerState)
+      .on("get", this.getTargetHeaterCoolerState.bind(this));
+
+    this.service
+      .getCharacteristic(Characteristic.Name)
+      .on("get", this.getName.bind(this));
+
+    // ---- Accessory Information ----
+    this.informationService = new Service.AccessoryInformation();
+    this.informationService
+      .setCharacteristic(Characteristic.Manufacturer, this.manufacturer)
+      .setCharacteristic(Characteristic.Model, this.model)
+      .setCharacteristic(Characteristic.SerialNumber, this.device_id);
+
+    // ---- Timer ----
     this.pullTimer = new PullTimer(
       this.log,
       this.pullInterval,
       this.refreshTesyHeaterStatus.bind(this),
       () => {}
     );
-    this.pullTimer.start();
+
+    // ---- Kick off login, then start polling ----
+    if (this.username && this.password) {
+      this.authenticate()
+        .then(() => {
+          this.pullTimer.start();
+          this.refreshTesyHeaterStatus();
+        })
+        .catch(() => {
+          this.log.error("Initial authentication failed. Will still start timer and retry on next ticks.");
+          this.pullTimer.start();
+        });
+    } else {
+      this.log.warn("Username/password not provided; device will remain INACTIVE.");
+      this.pullTimer.start();
+    }
+
+    this.log.info(this.name);
+  }
+
+  // ---- HomeKit identity ----
+  identify(callback) {
+    this.log.info("Hi, I'm", this.name);
+    callback();
+  }
+
+  getName(callback) {
+    callback(null, this.name);
+  }
+
+  getTargetHeaterCoolerState(callback) {
+    callback(null, Characteristic.TargetHeaterCoolerState.HEAT);
+  }
+
+  // ---- Helpers to map Tesy fields ----
+  getTesyHeaterActiveState(state) {
+    if (!state) return Characteristic.Active.INACTIVE;
+    return state.toLowerCase() === "on"
+      ? Characteristic.Active.ACTIVE
+      : Characteristic.Active.INACTIVE;
   }
 
+  getTesyHeaterCurrentHeaterCoolerState(state) {
+    if (!state) return Characteristic.CurrentHeaterCoolerState.INACTIVE;
+    return state.toUpperCase() === "READY"
+      ? Characteristic.CurrentHeaterCoolerState.IDLE
+      : Characteristic.CurrentHeaterCoolerState.HEATING;
+  }
+
+  // ---- API calls (axios + cookies) ----
   async authenticate() {
     try {
-      const response = await axios.post("https://v4.mytesy.com/auth/login", {
-        email: this.username,
-        password: this.password,
-      });
-      this.session = response.data.session_token;
-      this.alt = response.data.alt_key;
-      this.log.info("Successfully authenticated with Tesy API");
+      const resp = await api.post(
+        "https://ad.mytesy.com/rest/old-app-login",
+        {
+          email: this.username,
+          password: this.password,
+          userID: this.userid || "",
+          userEmail: this.username,
+          userPass: this.password,
+          lang: "en",
+        }
+      );
+
+      const data = resp.data || {};
+      this.log.debug("Login response keys:", Object.keys(data));
+
+      // Preferred (old behavior)
+      this.session = data.acc_session || data.PHPSESSID || "";
+      this.alt     = data.acc_alt || data.ALT || "";
+
+      // Fallback to cookies for PHPSESSID
+      if (!this.session) {
+        const cookies = await jar.getCookies("https://ad.mytesy.com/");
+        const phpsess = cookies.find(c => c.key.toUpperCase() === "PHPSESSID");
+        if (phpsess) this.session = phpsess.value;
+      }
+
+      if (!this.session) {
+        throw new Error("Missing session (neither JSON nor cookie contained PHPSESSID)");
+      }
+
+      if (!this.alt) {
+        this.log.warn("ALT not present in login response; will try to infer later.");
+      }
+
+      this.log.info("Authenticated (cookies + session captured).");
     } catch (error) {
-      this.log.error("Authentication failed:", error.response?.data || error.message);
+      const msg = error?.response?.data || error.message;
+      this.log.error("Authentication failed:", msg);
+      throw error;
     }
   }
 
   async refreshTesyHeaterStatus() {
-    this.log.debug("Refreshing heater status");
+    this.log.debug("Executing refreshTesyHeaterStatus");
+    this.pullTimer.stop();
+
     try {
-      const response = await axios.post("https://v4.mytesy.com/devices/status", {
-        session_token: this.session,
-        device_id: this.device_id,
-      });
+      if (!this.session) {
+        this.log.warn("No session yet; authenticating...");
+        await this.authenticate();
+      }
+
+      const payload = {
+        ALT: this.alt || undefined,
+        CURRENT_SESSION: null,
+        PHPSESSID: this.session,
+        last_login_username: this.username,
+        userID: this.userid || "",
+        userEmail: this.username,
+        userPass: this.password,
+        lang: "en"
+      };
+
+      const resp = await api.post("https://ad.mytesy.com/rest/old-app-devices", payload);
+      const data = resp.data || {};
+      this.log.debug("Devices response top-level keys:", Object.keys(data));
+
+      if (!this.alt && (data.acc_alt || data.ALT)) {
+        this.alt = data.acc_alt || data.ALT;
+        this.log.info("Captured ALT from devices response.");
+      }
+
+      if (!data.device || Object.keys(data.device).length === 0) {
+        throw new Error("No devices in response");
+      }
+
+      const firstKey = Object.keys(data.device)[0];
+      const status = data.device[firstKey]?.DeviceStatus;
+      if (!status) throw new Error("DeviceStatus missing");
 
-      const status = response.data.device_status;
       this.updateDeviceStatus(status);
     } catch (error) {
-      this.log.error("Failed to refresh heater status:", error.response?.data || error.message);
+      const msg = error?.response?.data || error.message;
+      this.log.error("Failed to refresh heater status:", msg);
+      try {
+        this.service.getCharacteristic(Characteristic.Active)
+          .updateValue(Characteristic.Active.INACTIVE);
+      } catch (_) {}
+    } finally {
+      this.pullTimer.start();
     }
   }
 
   updateDeviceStatus(status) {
-    const newCurrentTemperature = parseFloat(status.temperature);
-    this.service.getCharacteristic(Characteristic.CurrentTemperature).updateValue(newCurrentTemperature);
+    const newCurrentTemperature = parseFloat(status.gradus);
+    const oldCurrentTemperature =
+      this.service.getCharacteristic(Characteristic.CurrentTemperature).value;
+
+    if (
+      Number.isFinite(newCurrentTemperature) &&
+      newCurrentTemperature !== oldCurrentTemperature &&
+      newCurrentTemperature >= this.minTemp &&
+      newCurrentTemperature <= this.maxTemp
+    ) {
+      this.service
+        .getCharacteristic(Characteristic.CurrentTemperature)
+        .updateValue(newCurrentTemperature);
+      this.log.info(
+        "Changing CurrentTemperature from %s to %s",
+        oldCurrentTemperature,
+        newCurrentTemperature
+      );
+    }
+
+    const newHeatingThresholdTemperature = parseFloat(status.ref_gradus);
+    const oldHeatingThresholdTemperature =
+      this.service.getCharacteristic(Characteristic.HeatingThresholdTemperature).value;
+
+    if (
+      Number.isFinite(newHeatingThresholdTemperature) &&
+      newHeatingThresholdTemperature !== oldHeatingThresholdTemperature &&
+      newHeatingThresholdTemperature >= this.minTemp &&
+      newHeatingThresholdTemperature <= this.maxTemp
+    ) {
+      this.service
+        .getCharacteristic(Characteristic.HeatingThresholdTemperature)
+        .updateValue(newHeatingThresholdTemperature);
+      this.log.info(
+        "Changing HeatingThresholdTemperature from %s to %s",
+        oldHeatingThresholdTemperature,
+        newHeatingThresholdTemperature
+      );
+    }
 
-    const newHeatingThresholdTemperature = parseFloat(status.target_temperature);
-    this.service.getCharacteristic(Characteristic.HeatingThresholdTemperature).updateValue(newHeatingThresholdTemperature);
+    const newHeaterActiveStatus = this.getTesyHeaterActiveState(status.power_sw);
+    const oldHeaterActiveStatus =
+      this.service.getCharacteristic(Characteristic.Active).value;
 
-    const isActive = status.power === "on" ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
-    this.service.getCharacteristic(Characteristic.Active).updateValue(isActive);
+    if (
+      newHeaterActiveStatus !== undefined &&
+      newHeaterActiveStatus !== oldHeaterActiveStatus
+    ) {
+      this.service
+        .getCharacteristic(Characteristic.Active)
+        .updateValue(newHeaterActiveStatus);
+      this.log.info(
+        "Changing ActiveStatus from %s to %s",
+        oldHeaterActiveStatus,
+        newHeaterActiveStatus
+      );
+    }
+
+    const newCurrentHeaterCoolerState = this.getTesyHeaterCurrentHeaterCoolerState(
+      status.heater_state
+    );
+    const oldCurrentHeaterCoolerState =
+      this.service.getCharacteristic(Characteristic.CurrentHeaterCoolerState).value;
+
+    if (newCurrentHeaterCoolerState !== oldCurrentHeaterCoolerState) {
+      this.service
+        .getCharacteristic(Characteristic.CurrentHeaterCoolerState)
+        .updateValue(newCurrentHeaterCoolerState);
+      this.log.info(
+        "Changing CurrentHeaterCoolerState from %s to %s",
+        oldCurrentHeaterCoolerState,
+        newCurrentHeaterCoolerState
+      );
+    }
+  }
+
+  // ---- HomeKit characteristic handlers ----
+  getActive(callback) {
+    try {
+      const v = this.service.getCharacteristic(Characteristic.Active).value;
+      callback(null, v);
+    } catch (e) {
+      callback(e);
+    }
+    this.refreshTesyHeaterStatus().catch(() => {});
   }
 
   async setActive(value, callback) {
-    this.log.info("Setting heater state:", value);
+    this.log.info("[+] Changing Active status to value:", value);
+    this.pullTimer.stop();
+    const newValue = value === 0 ? "off" : "on";
+
     try {
-      await axios.post("https://v4.mytesy.com/devices/set", {
-        session_token: this.session,
-        device_id: this.device_id,
-        command: "power",
-        value: value === 0 ? "off" : "on",
-      });
+      if (!this.session) await this.authenticate();
+
+      await api.post(
+        "https://ad.mytesy.com/rest/old-app-set-device-status",
+        {
+          ALT: this.alt || undefined,
+          CURRENT_SESSION: null,
+          PHPSESSID: this.session,
+          last_login_username: this.username,
+          id: this.device_id,
+          apiVersion: "apiv1",
+          command: "power_sw",
+          value: newValue,
+          userID: this.userid || "",
+          userEmail: this.username,
+          userPass: this.password,
+          lang: "en",
+        }
+      );
+
+      this.service
+        .getCharacteristic(Characteristic.Active)
+        .updateValue(value);
+
       callback(null, value);
     } catch (error) {
-      this.log.error("Failed to set heater state:", error.response?.data || error.message);
+      const msg = error?.response?.data || error.message;
+      this.log.error("Failed to set Active:", msg);
       callback(error);
+    } finally {
+      this.pullTimer.start();
     }
   }
 
-  async setHeatingThresholdTemperature(value, callback) {
-    this.log.info("Setting target temperature to:", value);
+  getCurrentTemperature(callback) {
     try {
-      await axios.post("https://v4.mytesy.com/devices/set", {
-        session_token: this.session,
-        device_id: this.device_id,
-        command: "target_temperature",
-        value: value,
-      });
-      callback(null, value);
-    } catch (error) {
-      this.log.error("Failed to set target temperature:", error.response?.data || error.message);
-      callback(error);
+      const v =
+        this.service.getCharacteristic(Characteristic.CurrentTemperature).value;
+      callback(null, v);
+    } catch (e) {
+      callback(e);
     }
+    this.refreshTesyHeaterStatus().catch(() => {});
   }
 
-  getServices() {
-    this.informationService = new Service.AccessoryInformation();
-    this.informationService
-      .setCharacteristic(Characteristic.Manufacturer, this.manufacturer)
-      .setCharacteristic(Characteristic.Model, this.model)
-      .setCharacteristic(Characteristic.SerialNumber, this.device_id);
+  async setHeatingThresholdTemperature(value, callback) {
+    let v = value;
+    if (v < this.minTemp) v = this.minTemp;
+    if (v > this.maxTemp) v = this.maxTemp;
+    this.log.info("[+] Changing HeatingThresholdTemperature to:", v);
 
-    this.service.getCharacteristic(Characteristic.Active)
-      .on("set", this.setActive.bind(this));
+    this.pullTimer.stop();
 
-    this.service.getCharacteristic(Characteristic.CurrentTemperature)
-      .setProps({ minStep: 0.1 });
+    try {
+      if (!this.session) await this.authenticate();
 
-    this.service.getCharacteristic(Characteristic.HeatingThresholdTemperature)
-      .setProps({
-        minValue: this.minTemp,
-        maxValue: this.maxTemp,
-        minStep: 0.5,
-      })
-      .on("set", this.setHeatingThresholdTemperature.bind(this));
+      await api.post(
+        "https://ad.mytesy.com/rest/old-app-set-device-status",
+        {
+          ALT: this.alt || undefined,
+          CURRENT_SESSION: null,
+          PHPSESSID: this.session,
+          last_login_username: this.username,
+          id: this.device_id,
+          apiVersion: "apiv1",
+          command: "tmpT",
+          value: v,
+          userID: this.userid || "",
+          userEmail: this.username,
+          userPass: this.password,
+          lang: "en",
+        }
+      );
+
+      this.service
+        .getCharacteristic(Characteristic.HeatingThresholdTemperature)
+        .updateValue(v);
 
+      callback(null, v);
+    } catch (error) {
+      const msg = error?.response?.data || error.message;
+      this.log.error("Failed to set target temperature:", msg);
+      callback(error);
+    } finally {
+      this.pullTimer.start();
+    }
+  }
+
+  // ---- Services ----
+  getServices() {
+    this.refreshTesyHeaterStatus().catch(() => {});
     return [this.informationService, this.service];
   }
 }

package/index.js-backup

@@ -0,0 +1,137 @@
+const axios = require("axios");
+const _http_base = require("homebridge-http-base");
+const PullTimer = _http_base.PullTimer;
+
+let Service, Characteristic;
+
+module.exports = function (homebridge) {
+  Service = homebridge.hap.Service;
+  Characteristic = homebridge.hap.Characteristic;
+  homebridge.registerAccessory("homebridge-tesy-heater-v2", "TesyHeater", TesyHeater);
+};
+
+class TesyHeater {
+  constructor(log, config) {
+    this.log = log;
+    this.name = config.name;
+    this.manufacturer = config.manufacturer || "Tesy";
+    this.model = config.model || "Convector (Heater)";
+    this.device_id = config.device_id;
+    this.pullInterval = config.pullInterval || 10000;
+    this.maxTemp = config.maxTemp || 30;
+    this.minTemp = config.minTemp || 10;
+    this.username = config.username || null;
+    this.password = config.password || null;
+    this.session = "";
+    this.alt = "";
+
+    if (this.username && this.password) {
+      this.authenticate();
+    }
+
+    this.service = new Service.HeaterCooler(this.name);
+    this.pullTimer = new PullTimer(
+      this.log,
+      this.pullInterval,
+      this.refreshTesyHeaterStatus.bind(this),
+      () => {}
+    );
+    this.pullTimer.start();
+  }
+
+  async authenticate() {
+    try {
+      const response = await axios.post("https://v4.mytesy.com/auth/login", {
+        email: this.username,
+        password: this.password,
+      });
+      this.session = response.data.session_token;
+      this.alt = response.data.alt_key;
+      this.log.info("Successfully authenticated with Tesy API");
+    } catch (error) {
+      this.log.error("Authentication failed:", error.response?.data || error.message);
+    }
+  }
+
+  async refreshTesyHeaterStatus() {
+    this.log.debug("Refreshing heater status");
+    try {
+      const response = await axios.post("https://v4.mytesy.com/devices/status", {
+        session_token: this.session,
+        device_id: this.device_id,
+      });
+
+      const status = response.data.device_status;
+      this.updateDeviceStatus(status);
+    } catch (error) {
+      this.log.error("Failed to refresh heater status:", error.response?.data || error.message);
+    }
+  }
+
+  updateDeviceStatus(status) {
+    const newCurrentTemperature = parseFloat(status.temperature);
+    this.service.getCharacteristic(Characteristic.CurrentTemperature).updateValue(newCurrentTemperature);
+
+    const newHeatingThresholdTemperature = parseFloat(status.target_temperature);
+    this.service.getCharacteristic(Characteristic.HeatingThresholdTemperature).updateValue(newHeatingThresholdTemperature);
+
+    const isActive = status.power === "on" ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
+    this.service.getCharacteristic(Characteristic.Active).updateValue(isActive);
+  }
+
+  async setActive(value, callback) {
+    this.log.info("Setting heater state:", value);
+    try {
+      await axios.post("https://v4.mytesy.com/devices/set", {
+        session_token: this.session,
+        device_id: this.device_id,
+        command: "power",
+        value: value === 0 ? "off" : "on",
+      });
+      callback(null, value);
+    } catch (error) {
+      this.log.error("Failed to set heater state:", error.response?.data || error.message);
+      callback(error);
+    }
+  }
+
+  async setHeatingThresholdTemperature(value, callback) {
+    this.log.info("Setting target temperature to:", value);
+    try {
+      await axios.post("https://v4.mytesy.com/devices/set", {
+        session_token: this.session,
+        device_id: this.device_id,
+        command: "target_temperature",
+        value: value,
+      });
+      callback(null, value);
+    } catch (error) {
+      this.log.error("Failed to set target temperature:", error.response?.data || error.message);
+      callback(error);
+    }
+  }
+
+  getServices() {
+    this.informationService = new Service.AccessoryInformation();
+    this.informationService
+      .setCharacteristic(Characteristic.Manufacturer, this.manufacturer)
+      .setCharacteristic(Characteristic.Model, this.model)
+      .setCharacteristic(Characteristic.SerialNumber, this.device_id);
+
+    this.service.getCharacteristic(Characteristic.Active)
+      .on("set", this.setActive.bind(this));
+
+    this.service.getCharacteristic(Characteristic.CurrentTemperature)
+      .setProps({ minStep: 0.1 });
+
+    this.service.getCharacteristic(Characteristic.HeatingThresholdTemperature)
+      .setProps({
+        minValue: this.minTemp,
+        maxValue: this.maxTemp,
+        minStep: 0.5,
+      })
+      .on("set", this.setHeatingThresholdTemperature.bind(this));
+
+    return [this.informationService, this.service];
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-tesy-heater-api-v4",
-  "version": "0.0.3",
-  "description": "Homebridge plugin for Tesy Heater (updated APIv4)",
+  "version": "0.0.5",
+  "description": "Homebridge plugin for Tesy Heater (Tesy API old-app endpoints with cookie-based session)",
   "main": "index.js",
   "keywords": [
     "homebridge-plugin",
@@ -15,6 +15,8 @@
   },
   "dependencies": {
     "axios": "^1.7.0",
+    "axios-cookiejar-support": "^6.0.2",
+    "tough-cookie": "^4.1.3",
     "homebridge-http-base": "^1.0.0"
   }
 }