homebridge-homiris 0.3.8 → 0.4.3

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.4.3
+
+- [CHANGE] Default `name` in the config schema is now `Homiris` instead of `SepsadSecurity`. This is the log-prefix label shown in Homebridge output (`[Homiris] INFO - …`) — display only. The platform identifier (`"platform": "SepsadSecurity"`) is unchanged for backward compatibility, so existing configs keep working untouched.
+- [DOCS] Readme config example now includes `"name": "Homiris"` and clarifies the `platform` vs `name` distinction.
+
+Existing users who want the new prefix in their logs need to add `"name": "Homiris"` to their platform block in `config.json` (or set it via the Homebridge UI). The schema default only takes effect for fresh installs.
+
+## 0.4.2
+
+- [CHANGE] Replaced `fakegato-history` runtime dependency with a vendored, single-file implementation at `lib/fakegato.js`. Trimmed to temperature-only (single `0102` signature, advertised as such instead of as a `weather` station with phantom 0% humidity / 0 hPa pressure). Plugin now has zero runtime dependencies again.
+- [FIX] Eve's `S2R1`/`S2R2`/`S2W1`/`S2W2` characteristics are now registered as optional on the history service before being added, so HAP-NodeJS no longer logs "Characteristic not in required or optional characteristic section" warnings at startup.
+- [INTERNAL] Persist file format and path are unchanged — existing v0.4.x history is preserved across the upgrade.
+- [INTERNAL] Vendored code preserves upstream MIT attribution to simont77 (full license header in `lib/fakegato.js`).
+
+## 0.4.1
+
+- [FIX] Eve history service was being removed by the platform's service cleanup at startup. The `fakegato-history` constructor itself attaches the history service to the accessory; the plugin was additionally adding the constructed instance under a custom subtype and confirming that one, leaving the library's real service unconfirmed and stripped — which silently broke history recording. The plugin now confirms the service the library actually attached.
+
+## 0.4.0
+
+- [NEW] Optional Eve app temperature history (graphs, min/max, weekly summaries) via `fakegato-history`. Disabled by default; enable with `eveHistory: true` in the plugin config
+- [NEW] When `eveHistory` is enabled, temperature is polled every 10 minutes by default — or every `refreshTimer` seconds if that is set — overriding the disabled background polling default. The existing background poll (which previously only refreshed alarm state) now also refreshes temperature when Eve history is on
+- [DEP] Adds `fakegato-history` runtime dependency
+
 ## 0.3.8
 
 - [FIX] Transparent re-authentication on `403 SESSION_EXPIREE` — the `idSession` returned by `/connect` expires before the OAuth `access_token`, so requests now detect session expiration, refresh the session, and retry once instead of failing and waiting for the 1-minute retry timer

package/config.schema.json

@@ -11,8 +11,8 @@
       "name": {
         "title": "Name",
         "type": "string",
-        "default": "SepsadSecurity",
-        "description": "The name that appears in the Homebridge log"
+        "default": "Homiris",
+        "description": "The name that appears in the Homebridge log prefix. Display only — does not affect the platform identifier."
       },
       "login": {
         "title": "Sepsad/Homiris account login",
@@ -27,9 +27,9 @@
         "type": "string",
         "default": "HOMIRIS",
         "oneOf": [
-          { "title": "Homiris", "enum": ["HOMIRIS"] },
-          { "title": "Sepsad", "enum": ["SEPSAD"] },
-          { "title": "EPS", "enum": ["EPS"] }
+          {"title": "Homiris", "enum": ["HOMIRIS"]},
+          {"title": "Sepsad", "enum": ["SEPSAD"]},
+          {"title": "EPS", "enum": ["EPS"]}
         ]
       },
       "allowActivation": {
@@ -44,6 +44,12 @@
         "maximum": 3600,
         "description": "Refresh alarm state every X seconds. Leave empty to disable. Minimum 120s to avoid rate limiting by Homiris servers."
       },
+      "eveHistory": {
+        "title": "Enable Eve app temperature history",
+        "type": "boolean",
+        "default": false,
+        "description": "Expose temperature sensors with Eve-compatible history (graphs, min/max). When enabled, temperature is polled every 10 minutes (or every 'Refresh timer' seconds if that is set), overriding the disabled background polling default."
+      },
       "maxWaitTimeForOperation": {
         "title": "Maximum wait time during operation",
         "type": "integer",

package/index.js

@@ -1,4 +1,4 @@
-var Service, Characteristic, Accessory, UUIDGen;
+var Service, Characteristic, Accessory, UUIDGen, FakeGatoHistoryService;
 
 var HomirisAPI = require('./homirisAPI.js').HomirisAPI;
 const HomirisTools = require('./homirisTools.js');
@@ -19,6 +19,14 @@ function myHomirisPlatform(log, config, api) {
     ? HomirisTools.checkParameter(config['refreshTimer'], 120, 3600, 300)
     : 0;
 
+  this.eveHistory = HomirisTools.checkBoolParameter(config['eveHistory'], false);
+
+  // Eve history needs periodic temperature samples. If the user hasn't set a
+  // refreshTimer, fall back to a 10-minute cadence — the interval Eve expects.
+  if (this.eveHistory && this.refreshTimer === 0) {
+    this.refreshTimer = 600;
+  }
+
   this.refreshTimerDuringOperation = HomirisTools.checkParameter(
     config['refreshTimerDuringOperation'],
     2,
@@ -77,6 +85,7 @@ module.exports = function (homebridge) {
   Characteristic = homebridge.hap.Characteristic;
   Accessory = homebridge.platformAccessory;
   UUIDGen = homebridge.hap.uuid;
+  FakeGatoHistoryService = require('./lib/fakegato')(homebridge);
   homebridge.registerPlatform('SepsadSecurity', myHomirisPlatform);
 };
 
@@ -113,11 +122,7 @@ myHomirisPlatform.prototype = {
     }
 
     if (accstoRemove.length > 0)
-      this.api.unregisterPlatformAccessories(
-        'homebridge-homiris',
-        'SepsadSecurity',
-        accstoRemove
-      );
+      this.api.unregisterPlatformAccessories('homebridge-homiris', 'SepsadSecurity', accstoRemove);
   },
 
   cleanServices: function () {
@@ -158,9 +163,7 @@ myHomirisPlatform.prototype = {
 
     this.homirisAPI.on('securitySystemRefreshed', () => {
       this.log.debug('INFO - securitySystemRefreshed event');
-      this.log.debug(
-        'INFO - SecuritySystem : ' + JSON.stringify(this.homirisAPI.securitySystem)
-      );
+      this.log.debug('INFO - SecuritySystem : ' + JSON.stringify(this.homirisAPI.securitySystem));
 
       if (!this.loaded) {
         this.loadSecuritySystem();
@@ -269,8 +272,7 @@ myHomirisPlatform.prototype = {
       for (let a = 0; a < smokeDetectors.length; a++) {
         let smokeSensorName = smokeDetectors[a].label;
         let smokeSensorModel = this.homirisAPI.securitySystem.model;
-        let smokeSensorSeriaNumber =
-          this.homirisAPI.securitySystem.id + '/' + smokeDetectors[a].id;
+        let smokeSensorSeriaNumber = this.homirisAPI.securitySystem.id + '/' + smokeDetectors[a].id;
 
         this.log('INFO - Discovered SmokeSensor : ' + smokeSensorName);
 
@@ -344,8 +346,7 @@ myHomirisPlatform.prototype = {
       for (let a = 0; a < tempSensors.length; a++) {
         let tempSensorName = tempSensors[a].label;
         let tempSensorModel = this.homirisAPI.securitySystem.model;
-        let tempSensorSeriaNumber =
-          this.homirisAPI.securitySystem.id + '/' + tempSensors[a].id;
+        let tempSensorSeriaNumber = this.homirisAPI.securitySystem.id + '/' + tempSensors[a].id;
 
         this.log('INFO - Discovered TemperatureSensor : ' + tempSensorName);
 
@@ -394,6 +395,25 @@ myHomirisPlatform.prototype = {
 
         this.bindCurrentTemperatureCharacteristic(HKTempSensorService);
 
+        if (this.eveHistory) {
+          if (!myTempSensorAccessory.loggingService) {
+            this.log('INFO - Creating Eve history Service ' + tempSensorName);
+            // The factory attaches its own HistoryService to the accessory and
+            // exposes it as `.service`. Don't call addService manually.
+            myTempSensorAccessory.loggingService = new FakeGatoHistoryService(
+              'temperature',
+              myTempSensorAccessory,
+              {
+                path: this.api.user.persistPath(),
+                log: this.log,
+              }
+            );
+          }
+          if (myTempSensorAccessory.loggingService.service) {
+            this._confirmedServices.push(myTempSensorAccessory.loggingService.service);
+          }
+        }
+
         this._confirmedAccessories.push(myTempSensorAccessory);
         this._confirmedServices.push(HKTempSensorService);
 
@@ -438,9 +458,7 @@ myHomirisPlatform.prototype = {
       //timer for background refresh
       this.refreshBackground();
     } else {
-      this.log(
-        'ERROR - discoverSecuritySystem - no security system found, will retry in 1 minute'
-      );
+      this.log('ERROR - discoverSecuritySystem - no security system found, will retry in 1 minute');
 
       setTimeout(() => {
         this.homirisAPI.getSecuritySystem();
@@ -490,10 +508,7 @@ myHomirisPlatform.prototype = {
 
   updateTemperature() {
     for (let a = 0; a < this.foundAccessories.length; a++) {
-      if (
-        this.foundAccessories[a].tempSensorID &&
-        this.homirisAPI.securitySystem.temperatureInfo
-      ) {
+      if (this.foundAccessories[a].tempSensorID && this.homirisAPI.securitySystem.temperatureInfo) {
         this.log.debug('INFO - refreshing temp Sensor - ' + this.foundAccessories[a].name);
 
         let tempResults = this.homirisAPI.securitySystem.temperatureInfo;
@@ -759,10 +774,12 @@ myHomirisPlatform.prototype = {
       this.log.debug(
         'INFO - Setting Timer for background refresh every  : ' + this.refreshTimer + 's'
       );
-      this.timerID = setInterval(
-        () => this.homirisAPI.getSecuritySystem(),
-        this.refreshTimer * 1000
-      );
+      this.timerID = setInterval(() => {
+        this.homirisAPI.getSecuritySystem();
+        if (this.eveHistory && this.tempLoaded) {
+          this.homirisAPI.getTemperature();
+        }
+      }, this.refreshTimer * 1000);
     }
   },
 
@@ -882,6 +899,13 @@ myHomirisPlatform.prototype = {
 
     if (newTemp != currentTemp)
       HKTempSensorService.getCharacteristic(Characteristic.CurrentTemperature).updateValue(newTemp);
+
+    if (this.eveHistory && myTempAccessory.loggingService && newTemp !== undefined) {
+      myTempAccessory.loggingService.addEntry({
+        time: Math.floor(Date.now() / 1000),
+        temp: newTemp,
+      });
+    }
   },
 
   refreshSmokeSensor: function (mySmokeAccessory, result) {
@@ -921,7 +945,8 @@ myHomirisPlatform.prototype = {
       );
       return;
     } else {
-      let currentSmokeStatus = HKSmokeSensorService.getCharacteristic(Characteristic.SmokeDetected).value;
+      let currentSmokeStatus = HKSmokeSensorService.getCharacteristic(Characteristic.SmokeDetected)
+        .value;
       if (currentSmokeStatus != newSmokeStatus)
         HKSmokeSensorService.getCharacteristic(Characteristic.SmokeDetected).updateValue(
           newSmokeStatus

package/lib/fakegato.js

@@ -0,0 +1,368 @@
+/*
+ * Trimmed Eve-history service for homebridge-homiris.
+ *
+ * Derived from fakegato-history (https://github.com/simont77/fakegato-history),
+ * MIT-licensed:
+ *
+ *   Copyright (c) 2017 simont77
+ *
+ *   Permission is hereby granted, free of charge, to any person obtaining a
+ *   copy of this software and associated documentation files (the "Software"),
+ *   to deal in the Software without restriction, including without limitation
+ *   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *   and/or sell copies of the Software, and to permit persons to whom the
+ *   Software is furnished to do so, subject to the following conditions:
+ *
+ *   The above copyright notice and this permission notice shall be included
+ *   in all copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ *   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ *   NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ *   DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ *   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ *   USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Modifications for homebridge-homiris (2026, Nicolas Roughol):
+ *   - Stripped to temperature-only (single-field 0102 signature) — no humidity,
+ *     pressure, motion, door, switch, energy, custom, googleDrive, or
+ *     averaging-timer code paths.
+ *   - Synchronous fs load and queued async writes, no retry-loop / global
+ *     storage manager.
+ *   - Eve characteristics registered as optional on the service so HAP-NodeJS
+ *     does not log "characteristic not in required or optional" warnings.
+ *   - Single file, Homebridge v2 / HAP-NodeJS v2 compatible.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {format: sprintf} = require('util');
+
+const EPOCH_OFFSET = 978307200; // Eve uses 2001-01-01 epoch
+const HISTORY_UUID = 'E863F007-079E-48FF-8F27-9C2605A29F52';
+const S2R1_UUID = 'E863F116-079E-48FF-8F27-9C2605A29F52';
+const S2R2_UUID = 'E863F117-079E-48FF-8F27-9C2605A29F52';
+const S2W1_UUID = 'E863F11C-079E-48FF-8F27-9C2605A29F52';
+const S2W2_UUID = 'E863F121-079E-48FF-8F27-9C2605A29F52';
+
+const HISTORY_SIZE = 4032; // ring-buffer capacity (matches Eve client expectation)
+const FILE_SUFFIX = '_persist.json';
+const HOSTNAME = os.hostname().split('.')[0];
+
+// Single-field "temperature only" signature.
+//   01 0102  -> 1 field, signature 0102 (CurrentTemperature, 2 bytes, factor 100)
+//   01       -> bitmap with bit 0 set
+const TYPE116_TEMP = '01 0102';
+const TYPE117_TEMP = '01';
+
+const hexToBase64 = (val) =>
+  Buffer.from(String(val).replace(/[^0-9A-F]/gi, ''), 'hex').toString('base64');
+const base64ToHex = (val) => (val ? Buffer.from(val, 'base64').toString('hex') : val);
+const swap16 = (val) => ((val & 0xff) << 8) | ((val >>> 8) & 0xff);
+const swap32 = (val) =>
+  ((val & 0xff) << 24) | ((val & 0xff00) << 8) | ((val >>> 8) & 0xff00) | ((val >>> 24) & 0xff);
+const numToHex = (val, len) => {
+  let s = Number(val >>> 0).toString(16);
+  if (s.length % 2 !== 0) s = '0' + s;
+  return len ? ('0000000000000' + s).slice(-len) : s;
+};
+
+module.exports = function (homebridge) {
+  const Service = homebridge.hap.Service;
+  const Characteristic = homebridge.hap.Characteristic;
+  const Formats = homebridge.hap.Formats;
+  const Perms = homebridge.hap.Perms;
+
+  class S2R1Characteristic extends Characteristic {
+    constructor() {
+      super('S2R1', S2R1_UUID);
+      this.setProps({
+        format: Formats.DATA,
+        perms: [Perms.PAIRED_READ, Perms.NOTIFY, Perms.HIDDEN],
+      });
+    }
+  }
+  S2R1Characteristic.UUID = S2R1_UUID;
+
+  class S2R2Characteristic extends Characteristic {
+    constructor() {
+      super('S2R2', S2R2_UUID);
+      this.setProps({
+        format: Formats.DATA,
+        perms: [Perms.PAIRED_READ, Perms.NOTIFY, Perms.HIDDEN],
+      });
+    }
+  }
+  S2R2Characteristic.UUID = S2R2_UUID;
+
+  class S2W1Characteristic extends Characteristic {
+    constructor() {
+      super('S2W1', S2W1_UUID);
+      this.setProps({
+        format: Formats.DATA,
+        perms: [Perms.PAIRED_WRITE, Perms.HIDDEN],
+      });
+    }
+  }
+  S2W1Characteristic.UUID = S2W1_UUID;
+
+  class S2W2Characteristic extends Characteristic {
+    constructor() {
+      super('S2W2', S2W2_UUID);
+      this.setProps({
+        format: Formats.DATA,
+        perms: [Perms.PAIRED_WRITE, Perms.HIDDEN],
+      });
+    }
+  }
+  S2W2Characteristic.UUID = S2W2_UUID;
+
+  class HistoryService extends Service {
+    constructor(displayName, subtype) {
+      super(displayName, HISTORY_UUID, subtype);
+      // Register before adding so HAP-NodeJS doesn't warn about the
+      // characteristics being absent from the service definition.
+      this.addOptionalCharacteristic(S2R1Characteristic);
+      this.addOptionalCharacteristic(S2R2Characteristic);
+      this.addOptionalCharacteristic(S2W1Characteristic);
+      this.addOptionalCharacteristic(S2W2Characteristic);
+      this.addCharacteristic(S2R1Characteristic);
+      this.addCharacteristic(S2R2Characteristic);
+      this.addCharacteristic(S2W1Characteristic);
+      this.addCharacteristic(S2W2Characteristic);
+    }
+  }
+  HistoryService.UUID = HISTORY_UUID;
+
+  class TemperatureHistory {
+    constructor(accessory, options) {
+      options = options || {};
+      this.accessory = accessory;
+      this.accessoryName = accessory.displayName;
+      this.log = options.log || accessory.log || {debug: () => {}};
+      if (!this.log.debug) this.log.debug = () => {};
+
+      this.size = options.size || HISTORY_SIZE;
+      this.path = options.path || path.join(os.homedir(), '.homebridge');
+      this.filename = options.filename || HOSTNAME + '_' + this.accessoryName + FILE_SUFFIX;
+
+      this.history = ['noValue'];
+      this.firstEntry = 0;
+      this.lastEntry = 0;
+      this.usedMemory = 0;
+      this.refTime = 0;
+      this.initialTime = 0;
+      this.currentEntry = 1;
+      this.transfer = false;
+      this.setTime = true;
+      this.restarted = true;
+      this.memoryAddress = 0;
+      this.dataStream = '';
+      this.extra = undefined;
+
+      this._writePending = null;
+      this._writing = false;
+
+      this._load();
+
+      // Reuse the existing service if cached, otherwise add a fresh one.
+      this.service = accessory.getService(HistoryService);
+      if (!this.service) {
+        this.service = accessory.addService(
+          HistoryService,
+          this.accessoryName + ' History',
+          'temperature'
+        );
+      }
+
+      this.service.getCharacteristic(S2R2Characteristic).on('get', this._getS2R2.bind(this));
+      this.service.getCharacteristic(S2W1Characteristic).on('set', this._setS2W1.bind(this));
+      this.service.getCharacteristic(S2W2Characteristic).on('set', this._setS2W2.bind(this));
+    }
+
+    addEntry(entry) {
+      if (entry == null || typeof entry.time !== 'number' || typeof entry.temp !== 'number') {
+        return;
+      }
+      this._addEntry({time: entry.time, temp: entry.temp});
+    }
+
+    _addEntry(entry) {
+      const entry2address = (val) => val % this.size;
+
+      if (this.usedMemory < this.size) {
+        this.usedMemory++;
+        this.firstEntry = 0;
+        this.lastEntry = this.usedMemory;
+      } else {
+        this.firstEntry++;
+        this.lastEntry = this.firstEntry + this.usedMemory;
+        if (this.restarted) {
+          this.history[entry2address(this.lastEntry)] = {
+            time: entry.time,
+            setRefTime: 1,
+          };
+          this.firstEntry++;
+          this.lastEntry = this.firstEntry + this.usedMemory;
+          this.restarted = false;
+        }
+      }
+
+      if (this.refTime === 0) {
+        this.refTime = entry.time - EPOCH_OFFSET;
+        this.history[this.lastEntry] = {time: entry.time, setRefTime: 1};
+        this.initialTime = entry.time;
+        this.lastEntry++;
+        this.usedMemory++;
+      }
+
+      this.history[entry2address(this.lastEntry)] = entry;
+
+      // S2R1 manifest: tells Eve the current ring-buffer state.
+      const usedMem = this.usedMemory < this.size ? this.usedMemory + 1 : this.usedMemory;
+      const firstIdx = this.usedMemory < this.size ? this.firstEntry : this.firstEntry + 1;
+      const val = sprintf(
+        '%s00000000%s%s%s%s%s000000000101',
+        numToHex(swap32(entry.time - this.refTime - EPOCH_OFFSET), 8),
+        numToHex(swap32(this.refTime), 8),
+        TYPE116_TEMP,
+        numToHex(swap16(usedMem), 4),
+        numToHex(swap16(this.size), 4),
+        numToHex(swap32(firstIdx), 8)
+      );
+
+      this.service.getCharacteristic(S2R1Characteristic).setValue(hexToBase64(val));
+      this.log.debug(
+        '**fakegato %s: lastEntry=%d usedMemory=%d',
+        this.accessoryName,
+        this.lastEntry,
+        this.usedMemory
+      );
+
+      this._save();
+    }
+
+    _getS2R2(callback) {
+      const entry2address = (val) => val % this.size;
+
+      if (this.currentEntry <= this.lastEntry && this.transfer) {
+        this.memoryAddress = entry2address(this.currentEntry);
+        for (let i = 0; i < 11; i++) {
+          const slot = this.history[this.memoryAddress];
+          if (
+            (slot && slot.setRefTime === 1) ||
+            this.setTime ||
+            this.currentEntry === this.firstEntry + 1
+          ) {
+            this.dataStream += sprintf(
+              ',15%s 0100 0000 81%s0000 0000 00 0000',
+              numToHex(swap32(this.currentEntry), 8),
+              numToHex(swap32(this.refTime), 8)
+            );
+            this.setTime = false;
+          } else {
+            // Temp-only entry: 0x0c (12) bytes.
+            //   1B length + 4B entry idx + 4B time delta + 1B bitmap + 2B temp = 12B
+            this.dataStream += sprintf(
+              ',0c %s%s-%s:%s',
+              numToHex(swap32(this.currentEntry), 8),
+              numToHex(swap32(slot.time - this.refTime - EPOCH_OFFSET), 8),
+              TYPE117_TEMP,
+              numToHex(swap16(Math.round(slot.temp * 100)), 4)
+            );
+          }
+          this.currentEntry++;
+          this.memoryAddress = entry2address(this.currentEntry);
+          if (this.currentEntry > this.lastEntry) break;
+        }
+        this.log.debug('**fakegato S2R2 %s: %s', this.accessoryName, this.dataStream);
+        callback(null, hexToBase64(this.dataStream));
+        this.dataStream = '';
+      } else {
+        this.transfer = false;
+        callback(null, hexToBase64('00'));
+      }
+    }
+
+    _setS2W1(val, callback) {
+      callback(null);
+      const valHex = base64ToHex(val);
+      const substring = valHex.substring(4, 12);
+      const valInt = parseInt(substring, 16);
+      const address = swap32(valInt);
+      this.log.debug('**fakegato S2W1 %s: address=%s', this.accessoryName, address.toString(16));
+      this.currentEntry = address !== 0 ? address : 1;
+      this.transfer = true;
+    }
+
+    _setS2W2(val, callback) {
+      this.log.debug('**fakegato S2W2 %s: clock adjust %s', this.accessoryName, base64ToHex(val));
+      callback(null);
+    }
+
+    _filePath() {
+      return path.join(this.path, this.filename);
+    }
+
+    _load() {
+      try {
+        const raw = fs.readFileSync(this._filePath(), 'utf8');
+        const data = JSON.parse(raw);
+        this.firstEntry = data.firstEntry || 0;
+        this.lastEntry = data.lastEntry || 0;
+        this.usedMemory = data.usedMemory || 0;
+        this.refTime = data.refTime || 0;
+        this.initialTime = data.initialTime || 0;
+        this.history = Array.isArray(data.history) ? data.history : ['noValue'];
+        this.extra = data.extra;
+        this.log.debug('**fakegato loaded %s: %d entries', this.accessoryName, this.usedMemory);
+      } catch (err) {
+        if (err.code !== 'ENOENT') {
+          this.log.debug('**fakegato load error %s: %s', this.accessoryName, err.message);
+        }
+      }
+    }
+
+    _save() {
+      const data = JSON.stringify({
+        firstEntry: this.firstEntry,
+        lastEntry: this.lastEntry,
+        usedMemory: this.usedMemory,
+        refTime: this.refTime,
+        initialTime: this.initialTime,
+        history: this.history,
+        extra: this.extra,
+      });
+
+      // Coalesce concurrent writes — keep only the latest pending payload.
+      this._writePending = data;
+      if (this._writing) return;
+      this._writing = true;
+
+      const flush = () => {
+        const payload = this._writePending;
+        this._writePending = null;
+        fs.writeFile(this._filePath(), payload, 'utf8', (err) => {
+          if (err) this.log.debug('**fakegato save error %s: %s', this.accessoryName, err.message);
+          if (this._writePending) {
+            flush();
+          } else {
+            this._writing = false;
+          }
+        });
+      };
+      flush();
+    }
+  }
+
+  // Public factory: keep the same call signature the plugin already uses.
+  function FakegatoFactory(_accessoryType, accessory, options) {
+    return new TemperatureHistory(accessory, options);
+  }
+  FakegatoFactory.UUID = HISTORY_UUID;
+  return FakegatoFactory;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-homiris",
-  "version": "0.3.8",
+  "version": "0.4.3",
   "author": "Nicolas Roughol",
   "description": "Homebridge plugin for Homiris / Sepsad / EPS alarm systems",
   "main": "index.js",

package/readme.md

@@ -6,16 +6,32 @@ Forked from [homebridge-sepsadsecurity](https://github.com/nicoduj/homebridge-se
 
 ## What's new
 
+### 0.4.3
+
+- Default `name` (the log-prefix label) is now `Homiris` instead of `SepsadSecurity`. Display only — `platform` stays `SepsadSecurity` for backward compatibility. To get the new prefix in your existing install's logs, add `"name": "Homiris"` to your `config.json` platform block.
+
+### 0.4.2
+
+- Replaced the `fakegato-history` dependency with a vendored, temperature-only implementation in `lib/fakegato.js`. Cleans up the startup `S2R2/S2W1/S2W2` characteristic warnings, advertises a temp-only signature to Eve (no more phantom 0% humidity / 0 hPa pressure), and restores zero runtime dependencies. Existing persist files are preserved across the upgrade.
+
+### 0.4.0
+
+- Optional Eve app temperature history (graphs, min/max). Disabled by default; enable with `eveHistory: true`. When enabled, temperature is polled every 10 minutes (or every `refreshTimer` seconds if set), overriding the disabled background polling default.
+
 ### 0.3.4
+
 - Reverted disarm support — Homiris API requires biometric device auth for sensitive actions
 
 ### 0.3.2
+
 - Fixed activation endpoint: was missing `smartphone/production/1.0.0/` prefix
 
 ### 0.3.1
+
 - Fixed accessory registration using the old plugin name, which caused "no loaded plugin could be found" warnings
 
 ### 0.3.0
+
 - **Fixed API compatibility** -- the Homiris/EPS API started requiring `User-Agent` and other headers on all requests; the original plugin only sent them on login
 - **Homebridge v2.0 + v1.11 support** -- replaced removed `getServiceByUUIDAndSubType()` API
 - **Zero runtime dependencies** -- replaced deprecated `request` library with native `fetch()`, removed `locks`
@@ -42,6 +58,7 @@ Or search for `homebridge-homiris` in the Homebridge UI plugins tab.
 "platforms": [
   {
     "platform": "SepsadSecurity",
+    "name": "Homiris",
     "login": "123456",
     "password": "your-password",
     "originSession": "HOMIRIS"
@@ -49,19 +66,22 @@ Or search for `homebridge-homiris` in the Homebridge UI plugins tab.
 ]
 ```
 
+`platform` must remain `"SepsadSecurity"` (the plugin's stable identifier — kept for backward compatibility with existing installs); `name` is just the log-prefix label and can be set freely.
+
 ### Fields
 
-| Field | Required | Default | Description |
-|-------|----------|---------|-------------|
-| `platform` | Yes | | Must be `"SepsadSecurity"` |
-| `login` | Yes | | Your Homiris/Sepsad account login |
-| `password` | Yes | | Your Homiris/Sepsad account password |
-| `originSession` | No | `"HOMIRIS"` | `"HOMIRIS"`, `"SEPSAD"`, or `"EPS"` depending on your system brand |
-| `allowActivation` | No | `false` | Set to `true` to allow arming the system via HomeKit |
-| `refreshTimer` | No | disabled | Refresh alarm state every X seconds (120--3600). Leave empty to disable |
-| `maxWaitTimeForOperation` | No | `30` | Max seconds to wait for an arm operation to complete (30--90) |
-| `refreshTimerDuringOperation` | No | `10` | Polling interval in seconds while an arm operation is in progress (2--15) |
-| `cleanCache` | No | `false` | Set to `true` to remove cached accessories on next restart, then remove the option |
+| Field                         | Required | Default     | Description                                                                                                                             |
+| ----------------------------- | -------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `platform`                    | Yes      |             | Must be `"SepsadSecurity"`                                                                                                              |
+| `login`                       | Yes      |             | Your Homiris/Sepsad account login                                                                                                       |
+| `password`                    | Yes      |             | Your Homiris/Sepsad account password                                                                                                    |
+| `originSession`               | No       | `"HOMIRIS"` | `"HOMIRIS"`, `"SEPSAD"`, or `"EPS"` depending on your system brand                                                                      |
+| `allowActivation`             | No       | `false`     | Set to `true` to allow arming the system via HomeKit                                                                                    |
+| `refreshTimer`                | No       | disabled    | Refresh alarm state every X seconds (120--3600). Leave empty to disable                                                                 |
+| `eveHistory`                  | No       | `false`     | Set to `true` to expose temperature sensors with Eve-compatible history. Forces a 10-minute temperature poll if `refreshTimer` is unset |
+| `maxWaitTimeForOperation`     | No       | `30`        | Max seconds to wait for an arm operation to complete (30--90)                                                                           |
+| `refreshTimerDuringOperation` | No       | `10`        | Polling interval in seconds while an arm operation is in progress (2--15)                                                               |
+| `cleanCache`                  | No       | `false`     | Set to `true` to remove cached accessories on next restart, then remove the option                                                      |
 
 ### Migrating from homebridge-sepsadsecurity
 
@@ -74,7 +94,7 @@ Or search for `homebridge-homiris` in the Homebridge UI plugins tab.
 
 - **Security System** -- arm state (Away/Home/Night/Off), mapped from Homiris TOTAL/PARTIAL/OFF modes
 - **Smoke Sensors** -- one per smoke detector reported by your system
-- **Temperature Sensors** -- one per temperature probe (if your system has any)
+- **Temperature Sensors** -- one per temperature probe (if your system has any). With `eveHistory` enabled, history is also exposed to the Eve app (graphs, min/max, weekly summaries)
 
 ## Requirements