iobroker.homewizard 0.6.2 → 0.6.4

package/README.md

@@ -45,8 +45,6 @@ Real-time energy monitoring from [HomeWizard](https://www.homewizard.com) Energy
 | kWh Meter 3-Phase | HWE-KWH3 / SDM630 | Yes | Yes (as controller) |
 | Plug-In Battery | HWE-BAT | Yes | Controlled via P1/kWh |
 
-> **Note:** Energy Socket (HWE-SKT) and Watermeter (HWE-WTR) only support API v1 and are not yet supported. Support will be added when HomeWizard releases API v2 for these devices.
-
 ---
 
 ## Configuration
@@ -114,6 +112,7 @@ homewizard.0.
     │   ├── cycles               — Battery charge cycles (number)
     │   ├── average_power_15m_w  — 15-min average power (number, W, Belgium)
     │   ├── monthly_power_peak_w — Monthly power peak (number, W, Belgium)
+    │   ├── monthly_power_peak_timestamp — Monthly peak timestamp (string)
     │   ├── meter_model          — Meter model identifier (string)
     │   ├── timestamp            — Measurement timestamp (string)
     │   ├── quality/             — Power quality counters
@@ -165,6 +164,15 @@ homewizard.0.
 ---
 
 ## Changelog
+### 0.6.4 (2026-04-23)
+- Separate test-build output (`build-test/`) from production `build/`, so `npm test` no longer risks leaving duplicated `build/src` + `build/test` trees in the published package.
+- Wrap async `onReady` and `onStateChange` handlers with `.catch()` to prevent unhandled promise rejections from SIGKILLing the adapter.
+- Declare `pairingIp` as an instance object (11-language name) instead of creating it dynamically in `onReady`.
+
+### 0.6.3 (2026-04-18)
+- Harden WebSocket and REST input handling against unexpected API responses
+- Stop endless reconnect when the device token is invalid (fires once after 3 failed auth attempts)
+- Avoid creating an empty `external/` channel when a device reports no external meters
 
 ### 0.6.2 (2026-04-13)
 - Fix hanging promise when response stream errors mid-transfer (`res.on("error")`)
@@ -184,23 +192,6 @@ homewizard.0.
 - Persistent REST fallback for unstable devices (30s interval instead of stopping)
 - Automatic mode switch: stabilizes after 10 min connected, detects instability after 3 short-lived connections
 
-### 0.5.1 (2026-04-08)
-- Restore standard GitHub-based tests, remove CHANGELOG.md, add FORBIDDEN_CHARS reference
-
-### 0.5.0 (2026-04-05)
-- Robust reconnect: never give up after WiFi loss, retry every 5 minutes indefinitely
-- Periodic mDNS IP recovery (~hourly), only WebSocket controls online state
-
-### 0.4.2 (2026-04-05)
-- Consistent donation labels and about text across all adapters
-
-### 0.4.1 (2026-04-05)
-- Move measurement data into `measurement/` channel for cleaner object tree
-
-Older entries have been moved to [CHANGELOG_OLD.md](CHANGELOG_OLD.md).
-
----
-
 ## Support
 
 - [ioBroker Forum](https://forum.iobroker.net/)

package/build/lib/coerce.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var coerce_exports = {};
+__export(coerce_exports, {
+  coerceBoolean: () => coerceBoolean,
+  coerceFiniteNumber: () => coerceFiniteNumber,
+  coerceString: () => coerceString,
+  isPlainObject: () => isPlainObject
+});
+module.exports = __toCommonJS(coerce_exports);
+function coerceFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function coerceString(value) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return null;
+}
+function coerceBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return null;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  coerceBoolean,
+  coerceFiniteNumber,
+  coerceString,
+  isPlainObject
+});
+//# sourceMappingURL=coerce.js.map

package/build/lib/coerce.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/coerce.ts"],
+  "sourcesContent": ["/**\n * Boundary coercion helpers for external API data (REST + WebSocket).\n * HomeWizard API v2 is well-documented but field types still drift in practice\n * (firmware bugs, future additions, null values). These helpers guard against\n * NaN/Infinity/non-string values reaching ioBroker states.\n */\n\n/**\n * Coerce to a finite number or null.\n * Accepts numbers directly; parses numeric strings; rejects NaN/Infinity/other.\n *\n * @param value Unknown external value\n */\nexport function coerceFiniteNumber(value: unknown): number | null {\n  if (typeof value === \"number\") {\n    return Number.isFinite(value) ? value : null;\n  }\n  if (typeof value === \"string\" && value.length > 0) {\n    const n = Number(value);\n    return Number.isFinite(n) ? n : null;\n  }\n  return null;\n}\n\n/**\n * Coerce to a non-empty string, or null.\n *\n * @param value Unknown external value\n */\nexport function coerceString(value: unknown): string | null {\n  if (typeof value === \"string\" && value.length > 0) {\n    return value;\n  }\n  return null;\n}\n\n/**\n * Coerce to a boolean (only `true`/`false` accepted \u2014 no truthy/falsy JS rules).\n *\n * @param value Unknown external value\n */\nexport function coerceBoolean(value: unknown): boolean | null {\n  if (typeof value === \"boolean\") {\n    return value;\n  }\n  return null;\n}\n\n/**\n * Guard for plain objects (not arrays, not null).\n *\n * @param value Unknown external value\n */\nexport function isPlainObject(\n  value: unknown,\n): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,mBAAmB,OAA+B;AAChE,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,OAAO,SAAS,KAAK,IAAI,QAAQ;AAAA,EAC1C;AACA,MAAI,OAAO,UAAU,YAAY,MAAM,SAAS,GAAG;AACjD,UAAM,IAAI,OAAO,KAAK;AACtB,WAAO,OAAO,SAAS,CAAC,IAAI,IAAI;AAAA,EAClC;AACA,SAAO;AACT;AAOO,SAAS,aAAa,OAA+B;AAC1D,MAAI,OAAO,UAAU,YAAY,MAAM,SAAS,GAAG;AACjD,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAOO,SAAS,cAAc,OAAgC;AAC5D,MAAI,OAAO,UAAU,WAAW;AAC9B,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAOO,SAAS,cACd,OACkC;AAClC,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;",
+  "names": []
+}

package/build/lib/state-manager.js

@@ -21,6 +21,7 @@ __export(state_manager_exports, {
   StateManager: () => StateManager
 });
 module.exports = __toCommonJS(state_manager_exports);
+var import_coerce = require("./coerce");
 function sanitize(str) {
   return str.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
 }
@@ -582,7 +583,9 @@ class StateManager {
    * @param data Measurement data
    */
   async updateMeasurement(config, data) {
-    var _a;
+    if (!(0, import_coerce.isPlainObject)(data)) {
+      return;
+    }
     const prefix = this.devicePrefix(config);
     const mPrefix = `${prefix}.measurement`;
     await this.adapter.setObjectNotExistsAsync(mPrefix, {
@@ -590,55 +593,83 @@ class StateManager {
       common: { name: "Measurement" },
       native: {}
     });
-    const fields = MEASUREMENT_STATE_DEFS;
-    for (const def of fields) {
-      const rawValue = data[def.key];
-      if (rawValue !== void 0 && rawValue !== null && !Array.isArray(rawValue)) {
+    const record = data;
+    for (const def of MEASUREMENT_STATE_DEFS) {
+      const raw = record[def.key];
+      let coerced = null;
+      if (def.type === "number") {
+        coerced = (0, import_coerce.coerceFiniteNumber)(raw);
+      } else if (def.type === "string") {
+        coerced = (0, import_coerce.coerceString)(raw);
+      }
+      if (coerced !== null) {
         await this.ensureAndSet(
           `${mPrefix}.${def.id}`,
           def.name,
           def.type,
           def.role,
-          rawValue,
+          coerced,
           def.unit
         );
       }
     }
-    if ((_a = data.external) == null ? void 0 : _a.length) {
-      await this.adapter.setObjectNotExistsAsync(`${mPrefix}.external`, {
-        type: "channel",
-        common: { name: "External Meters" },
-        native: {}
-      });
-      for (const ext of data.external) {
-        const extId = `${mPrefix}.external.${sanitize(ext.type)}_${sanitize(ext.unique_id)}`;
+    const external = record.external;
+    if (Array.isArray(external) && external.length > 0) {
+      let extChannelEnsured = false;
+      for (const rawExt of external) {
+        if (!(0, import_coerce.isPlainObject)(rawExt)) {
+          continue;
+        }
+        const type = (0, import_coerce.coerceString)(rawExt.type);
+        const uniqueId = (0, import_coerce.coerceString)(rawExt.unique_id);
+        if (!type || !uniqueId) {
+          continue;
+        }
+        const value = (0, import_coerce.coerceFiniteNumber)(rawExt.value);
+        const unit = (0, import_coerce.coerceString)(rawExt.unit);
+        const timestamp = (0, import_coerce.coerceString)(rawExt.timestamp);
+        if (!extChannelEnsured) {
+          await this.adapter.setObjectNotExistsAsync(`${mPrefix}.external`, {
+            type: "channel",
+            common: { name: "External Meters" },
+            native: {}
+          });
+          extChannelEnsured = true;
+        }
+        const extId = `${mPrefix}.external.${sanitize(type)}_${sanitize(uniqueId)}`;
         await this.adapter.setObjectNotExistsAsync(extId, {
           type: "channel",
-          common: { name: ext.type },
+          common: { name: type },
           native: {}
         });
-        await this.ensureAndSet(
-          `${extId}.value`,
-          "Value",
-          "number",
-          "value",
-          ext.value,
-          ext.unit
-        );
-        await this.ensureAndSet(
-          `${extId}.unit`,
-          "Unit",
-          "string",
-          "text",
-          ext.unit
-        );
-        await this.ensureAndSet(
-          `${extId}.timestamp`,
-          "Timestamp",
-          "string",
-          "date",
-          ext.timestamp
-        );
+        if (value !== null) {
+          await this.ensureAndSet(
+            `${extId}.value`,
+            "Value",
+            "number",
+            "value",
+            value,
+            unit != null ? unit : void 0
+          );
+        }
+        if (unit) {
+          await this.ensureAndSet(
+            `${extId}.unit`,
+            "Unit",
+            "string",
+            "text",
+            unit
+          );
+        }
+        if (timestamp) {
+          await this.ensureAndSet(
+            `${extId}.timestamp`,
+            "Timestamp",
+            "string",
+            "date",
+            timestamp
+          );
+        }
       }
     }
   }
@@ -649,53 +680,70 @@ class StateManager {
    * @param system System info data
    */
   async updateSystem(config, system) {
+    if (!(0, import_coerce.isPlainObject)(system)) {
+      return;
+    }
     const prefix = this.devicePrefix(config);
-    await this.ensureAndSet(
-      `${prefix}.info.wifi_rssi_db`,
-      "WiFi signal strength",
-      "number",
-      "value",
-      system.wifi_rssi_db,
-      "dB"
-    );
-    await this.ensureAndSet(
-      `${prefix}.info.uptime_s`,
-      "Uptime",
-      "number",
-      "value",
-      system.uptime_s,
-      "s"
-    );
+    const record = system;
+    const rssi = (0, import_coerce.coerceFiniteNumber)(record.wifi_rssi_db);
+    if (rssi !== null) {
+      await this.ensureAndSet(
+        `${prefix}.info.wifi_rssi_db`,
+        "WiFi signal strength",
+        "number",
+        "value",
+        rssi,
+        "dB"
+      );
+    }
+    const uptime = (0, import_coerce.coerceFiniteNumber)(record.uptime_s);
+    if (uptime !== null) {
+      await this.ensureAndSet(
+        `${prefix}.info.uptime_s`,
+        "Uptime",
+        "number",
+        "value",
+        uptime,
+        "s"
+      );
+    }
     await this.adapter.setObjectNotExistsAsync(`${prefix}.system`, {
       type: "channel",
       common: { name: "System Settings" },
       native: {}
     });
-    await this.ensureAndSet(
-      `${prefix}.system.cloud_enabled`,
-      "Cloud enabled",
-      "boolean",
-      "switch",
-      system.cloud_enabled,
-      void 0,
-      true
-    );
-    await this.ensureAndSet(
-      `${prefix}.system.status_led_brightness_pct`,
-      "LED brightness",
-      "number",
-      "level",
-      system.status_led_brightness_pct,
-      "%",
-      true
-    );
-    if (system.api_v1_enabled !== void 0) {
+    const cloudEnabled = (0, import_coerce.coerceBoolean)(record.cloud_enabled);
+    if (cloudEnabled !== null) {
+      await this.ensureAndSet(
+        `${prefix}.system.cloud_enabled`,
+        "Cloud enabled",
+        "boolean",
+        "switch",
+        cloudEnabled,
+        void 0,
+        true
+      );
+    }
+    const ledPct = (0, import_coerce.coerceFiniteNumber)(record.status_led_brightness_pct);
+    if (ledPct !== null) {
+      await this.ensureAndSet(
+        `${prefix}.system.status_led_brightness_pct`,
+        "LED brightness",
+        "number",
+        "level",
+        ledPct,
+        "%",
+        true
+      );
+    }
+    const apiV1 = (0, import_coerce.coerceBoolean)(record.api_v1_enabled);
+    if (apiV1 !== null) {
       await this.ensureAndSet(
         `${prefix}.system.api_v1_enabled`,
         "API v1 enabled",
         "boolean",
         "switch",
-        system.api_v1_enabled,
+        apiV1,
         void 0,
         true
       );
@@ -713,80 +761,87 @@ class StateManager {
    * @param battery Battery control data
    */
   async updateBattery(config, battery) {
+    if (!(0, import_coerce.isPlainObject)(battery)) {
+      return;
+    }
     const prefix = this.devicePrefix(config);
+    const record = battery;
     await this.adapter.setObjectNotExistsAsync(`${prefix}.battery`, {
       type: "channel",
       common: { name: "Battery Control" },
       native: {}
     });
-    await this.ensureAndSet(
-      `${prefix}.battery.mode`,
-      "Battery mode",
-      "string",
-      "text",
-      battery.mode,
-      void 0,
-      true
-    );
-    if (battery.permissions !== void 0) {
+    const mode = (0, import_coerce.coerceString)(record.mode);
+    if (mode) {
       await this.ensureAndSet(
-        `${prefix}.battery.permissions`,
-        "Battery permissions",
+        `${prefix}.battery.mode`,
+        "Battery mode",
         "string",
-        "json",
-        JSON.stringify(battery.permissions),
+        "text",
+        mode,
         void 0,
         true
       );
     }
-    if (battery.battery_count !== void 0) {
-      await this.ensureAndSet(
-        `${prefix}.battery.battery_count`,
-        "Connected batteries",
-        "number",
-        "value",
-        battery.battery_count
-      );
-    }
-    if (battery.power_w !== void 0) {
-      await this.ensureAndSet(
-        `${prefix}.battery.power_w`,
-        "Battery power",
-        "number",
-        "value.power",
-        battery.power_w,
-        "W"
-      );
-    }
-    if (battery.target_power_w !== void 0) {
+    if (Array.isArray(record.permissions)) {
       await this.ensureAndSet(
-        `${prefix}.battery.target_power_w`,
-        "Target power",
-        "number",
-        "value.power",
-        battery.target_power_w,
-        "W"
-      );
-    }
-    if (battery.max_consumption_w !== void 0) {
-      await this.ensureAndSet(
-        `${prefix}.battery.max_consumption_w`,
-        "Max consumption",
-        "number",
-        "value.power",
-        battery.max_consumption_w,
-        "W"
+        `${prefix}.battery.permissions`,
+        "Battery permissions",
+        "string",
+        "json",
+        JSON.stringify(record.permissions),
+        void 0,
+        true
       );
     }
-    if (battery.max_production_w !== void 0) {
-      await this.ensureAndSet(
-        `${prefix}.battery.max_production_w`,
-        "Max production",
-        "number",
-        "value.power",
-        battery.max_production_w,
-        "W"
-      );
+    const numberFields = [
+      {
+        key: "battery_count",
+        id: "battery_count",
+        name: "Connected batteries",
+        role: "value"
+      },
+      {
+        key: "power_w",
+        id: "power_w",
+        name: "Battery power",
+        role: "value.power",
+        unit: "W"
+      },
+      {
+        key: "target_power_w",
+        id: "target_power_w",
+        name: "Target power",
+        role: "value.power",
+        unit: "W"
+      },
+      {
+        key: "max_consumption_w",
+        id: "max_consumption_w",
+        name: "Max consumption",
+        role: "value.power",
+        unit: "W"
+      },
+      {
+        key: "max_production_w",
+        id: "max_production_w",
+        name: "Max production",
+        role: "value.power",
+        unit: "W"
+      }
+    ];
+    for (const field of numberFields) {
+      const coerced = (0, import_coerce.coerceFiniteNumber)(record[field.key]);
+      if (coerced !== null) {
+        await this.ensureAndSet(
+          `${prefix}.battery.${field.id}`,
+          field.name,
+          "number",
+          field.role,
+          coerced,
+          field.unit
+        );
+      }
     }
   }
   /**