homebridge-biocat 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AliM
+
+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.

package/README.md

@@ -0,0 +1,228 @@
+# homebridge-biocat
+
+Ein Homebridge-Plugin fuer WATERCryst BIOCAT-Anlagen auf Basis der offiziellen myBIOCAT REST-API.
+
+Das Plugin liest den Geraetestatus ueber `GET /state`, kann den Abwesenheitsmodus schalten, die Wasserzufuhr schliessen und optional auch wieder oeffnen. Zusaetzlich werden Tagesstatistiken als JSONL protokolliert.
+
+## Funktionsumfang
+
+- Dynamisches Homebridge-Platform-Plugin
+- Native HomeKit-Services fuer BIOCAT-Funktionen
+- `LeakSensor` fuer Leckage- und Stoerungsanzeige
+- `Valve` fuer die Wasserzufuhr
+- `Switch` fuer `Absence Mode`
+- `FilterMaintenance` fuer Wartungs- und Wechselhinweise
+- Offizielle WATERCryst API mit `X-API-KEY`
+- JSONL-Statistiklogging mit Duplikatschutz
+- Persistenz des zuletzt geloggten Statistikdatums ueber Neustarts
+
+## Voraussetzungen
+
+- Node.js `>= 20.0.0`
+- Homebridge `^1.8.0`
+- Eine aktive myBIOCAT REST-API fuer dein Geraet
+- Ein API-Key aus `app.watercryst.com`
+
+## Installation
+
+Ueber die Homebridge UI nach `homebridge-biocat` suchen und das Plugin installieren.
+
+Alternativ per npm:
+
+```bash
+sudo npm install -g homebridge-biocat
+```
+
+Danach das Plugin in der Homebridge UI konfigurieren oder den folgenden Eintrag in `config.json` ergaenzen.
+
+## Entwicklung
+
+```bash
+npm install
+npm run build
+```
+
+## Homebridge-Konfiguration
+
+Beispiel fuer `config.json`:
+
+```json
+{
+  "platforms": [
+    {
+      "platform": "BiocatPlatform",
+      "name": "BIOCAT",
+      "apiBaseUrl": "https://appapi.watercryst.com/v1",
+      "apiKey": "YOUR_API_KEY",
+      "pollIntervalSeconds": 60,
+      "requestTimeoutMs": 15000,
+      "allowWaterSupplyOpen": false,
+      "statistics": {
+        "enabled": true,
+        "directory": "biocat",
+        "fileName": "statistics.jsonl",
+        "stateFileName": ".statistics-state.json"
+      }
+    }
+  ]
+}
+```
+
+## Konfigurationsoptionen
+
+| Feld | Typ | Standard | Beschreibung |
+| --- | --- | --- | --- |
+| `platform` | `string` | - | Muss `BiocatPlatform` sein |
+| `name` | `string` | `BIOCAT` | Anzeigename in Homebridge und HomeKit |
+| `apiBaseUrl` | `string` | `https://appapi.watercryst.com/v1` | Basis-URL der WATERCryst REST-API |
+| `apiKey` | `string` | - | API-Key fuer den Header `X-API-KEY` |
+| `headers` | `object` | `{}` | Optionale zusaetzliche HTTP-Header |
+| `pollIntervalSeconds` | `number` | `60` | Polling-Intervall, intern auf `15` bis `86400` begrenzt |
+| `requestTimeoutMs` | `number` | `15000` | Timeout pro API-Aufruf, intern auf `1000` bis `120000` begrenzt |
+| `allowWaterSupplyOpen` | `boolean` | `false` | Erlaubt das Oeffnen der Wasserzufuhr aus HomeKit heraus |
+| `statistics.enabled` | `boolean` | `true` | Aktiviert das Tagesstatistik-Logging |
+| `statistics.directory` | `string` | `biocat` | Relativer Ordner unterhalb des Homebridge-Storage-Pfads |
+| `statistics.fileName` | `string` | `statistics.jsonl` | Dateiname fuer JSONL-Statistiken |
+| `statistics.stateFileName` | `string` | `.statistics-state.json` | Dateiname fuer den letzten Log-Zustand |
+
+Hinweis:
+
+- `statusUrl` wird weiterhin als Legacy-Eingabe akzeptiert. Wenn sie auf `/state` endet, wird automatisch die API-Basis-URL daraus abgeleitet.
+- `authToken` wird als Fallback ebenfalls als API-Key akzeptiert.
+
+## HomeKit-Abbildung
+
+Das Plugin legt ein dynamisches Accessory mit diesen nativen HomeKit-Services an:
+
+- `LeakSensor`: zeigt Leckage oder relevante Stoerungen an
+- `Valve`: zeigt den Zustand der Wasserzufuhr und kann sie schliessen
+- `Switch`: `Absence Mode` ein- oder ausschalten
+- `FilterMaintenance`: Wartungs- bzw. Granulatwechsel-Hinweise
+- `AccessoryInformation`: Hersteller, Modell, Seriennummer, Firmware
+
+## Schaltfunktionen in HomeKit
+
+### Absence Mode
+
+Der BIOCAT-Abwesenheitsmodus wird als nativer `Switch` exponiert. Dadurch kannst du in der Home-App ganz normale Automationen verwenden, zum Beispiel:
+
+- Wenn die letzte Person das Haus verlaesst, `Absence Mode` einschalten
+- Wenn die erste Person nach Hause kommt, `Absence Mode` ausschalten
+
+Intern nutzt das Plugin:
+
+- `GET /absence/enable`
+- `GET /absence/disable`
+
+### Water Supply Valve
+
+Die Wasserzufuhr wird als HomeKit-`Valve` exponiert.
+
+Damit sind Automationen moeglich wie:
+
+- Wenn ein HomeKit-Wassersensor ein Leck erkennt, `Water Supply` ausschalten
+
+Intern nutzt das Plugin:
+
+- `GET /watersupply/close`
+- `GET /watersupply/open`
+
+Sicherheitsverhalten:
+
+- Schliessen ist immer erlaubt
+- Oeffnen ist standardmaessig gesperrt
+- Wenn du das Oeffnen aus HomeKit erlauben willst, setze `allowWaterSupplyOpen` auf `true`
+
+## Verwendete BIOCAT-Endpunkte
+
+- `GET /state`
+- `GET /statistics/daily/direct`
+- Fallback: `GET /statistics/cumulative/daily`
+- `GET /absence/enable`
+- `GET /absence/disable`
+- `GET /watersupply/close`
+- Optional: `GET /watersupply/open`
+
+## Erwartete State-Antwort
+
+Das Plugin ist auf die offizielle API-Struktur ausgelegt. Wichtige Felder sind:
+
+- `online`
+- `mode.id`
+- `mode.name`
+- `event`
+- `waterProtection.absenceModeEnabled`
+- `waterProtection.pauseLeakageProtectionUntilUTC`
+- `mlState`
+
+Beispiel:
+
+```json
+{
+  "online": true,
+  "mode": {
+    "id": "WT",
+    "name": "Water Treatment"
+  },
+  "event": {},
+  "waterProtection": {
+    "absenceModeEnabled": false,
+    "pauseLeakageProtectionUntilUTC": "2026-03-15T10:00:00Z"
+  },
+  "mlState": "idle"
+}
+```
+
+## Statistiklogging
+
+Wenn `statistics.enabled` aktiv ist, schreibt das Plugin Tagesstatistiken als JSONL.
+
+Speicherorte:
+
+- JSONL-Datei: `<homebridge-storage>/<statistics.directory>/<statistics.fileName>`
+- State-Datei: `<homebridge-storage>/<statistics.directory>/<statistics.stateFileName>`
+
+Eigenschaften:
+
+- Verzeichnisse werden automatisch angelegt
+- Schreiben erfolgt append-sicher
+- Doppelte Statistik-Eintraege werden verhindert
+- Das zuletzt geloggte Datum bleibt ueber Neustarts erhalten
+- Falls die State-Datei fehlt, wird der letzte Stand aus der JSONL-Datei rekonstruiert
+
+## Projektstruktur
+
+- `src/index.ts`: Homebridge-Registrierung
+- `src/platform.ts`: Plattform-Lebenszyklus, Polling und Command-Ausfuehrung
+- `src/biocat-client.ts`: REST-Client fuer die offizielle API
+- `src/normalizer.ts`: Defensive Normalisierung von `state` und Statistikantworten
+- `src/biocat-accessory.ts`: HomeKit-Service-Mapping und `onSet`-Handler
+- `src/statistics-logger.ts`: JSONL-Logging mit Zustands-Persistenz
+- `src/config.ts`: Konfig-Aufbereitung und Defaultwerte
+- `config.schema.json`: Homebridge UI-Konfigurationsformular
+
+Build:
+
+```bash
+npm install
+npm run build
+```
+
+Paket pruefen:
+
+```bash
+npm pack --dry-run
+```
+
+Veroeffentlichen:
+
+```bash
+npm publish
+```
+
+## Hinweise
+
+- Ohne `apiKey` bleibt die Plattform absichtlich inaktiv.
+- Laut offizieller API sind maximal 10 Requests pro Sekunde sowie 200 Requests in 15 Minuten pro Kunde und Geraet erlaubt.
+- Das Plugin behandelt fehlende oder leere `event`- und `waterProtection`-Objekte defensiv.
+- Leckage wird in der offiziellen API nicht als eigenes boolesches Feld geliefert. Das Plugin leitet sie deshalb aus `mlState`, Eventdaten und bekannten Textmustern ab.

package/config.schema.json

@@ -0,0 +1,98 @@
+{
+  "pluginAlias": "BiocatPlatform",
+  "pluginType": "platform",
+  "singular": true,
+  "strictValidation": false,
+  "schema": {
+    "type": "object",
+    "required": [
+      "name",
+      "apiKey"
+    ],
+    "additionalProperties": false,
+    "properties": {
+      "name": {
+        "title": "Name",
+        "type": "string",
+        "default": "BIOCAT",
+        "minLength": 1,
+        "required": true,
+        "description": "Display name used by Homebridge and HomeKit."
+      },
+      "apiBaseUrl": {
+        "title": "API Base URL",
+        "type": "string",
+        "format": "uri",
+        "default": "https://appapi.watercryst.com/v1",
+        "description": "Base URL of the WATERCryst myBIOCAT REST API."
+      },
+      "apiKey": {
+        "title": "API Key",
+        "type": "string",
+        "format": "password",
+        "minLength": 1,
+        "required": true,
+        "description": "API key from app.watercryst.com. It is sent as the X-API-KEY header."
+      },
+      "pollIntervalSeconds": {
+        "title": "Polling Interval",
+        "type": "integer",
+        "default": 60,
+        "minimum": 15,
+        "maximum": 86400,
+        "description": "Seconds between BIOCAT status refreshes."
+      },
+      "requestTimeoutMs": {
+        "title": "Request Timeout",
+        "type": "integer",
+        "default": 15000,
+        "minimum": 1000,
+        "maximum": 120000,
+        "description": "Maximum time in milliseconds for one API request."
+      },
+      "allowWaterSupplyOpen": {
+        "title": "Allow Opening Water Supply",
+        "type": "boolean",
+        "default": false,
+        "description": "Allows HomeKit to reopen the water supply. Closing remains available regardless of this setting."
+      },
+      "statistics": {
+        "title": "Statistics Logging",
+        "type": "object",
+        "additionalProperties": false,
+        "default": {
+          "enabled": true,
+          "directory": "biocat",
+          "fileName": "statistics.jsonl",
+          "stateFileName": ".statistics-state.json"
+        },
+        "properties": {
+          "enabled": {
+            "title": "Enabled",
+            "type": "boolean",
+            "default": true,
+            "description": "Writes daily statistics to a JSONL file in the Homebridge storage directory."
+          },
+          "directory": {
+            "title": "Directory",
+            "type": "string",
+            "default": "biocat",
+            "description": "Relative directory below the Homebridge storage path."
+          },
+          "fileName": {
+            "title": "File Name",
+            "type": "string",
+            "default": "statistics.jsonl",
+            "description": "JSONL file name for daily statistics."
+          },
+          "stateFileName": {
+            "title": "State File Name",
+            "type": "string",
+            "default": ".statistics-state.json",
+            "description": "File name used to remember the last logged statistics entry."
+          }
+        }
+      }
+    }
+  }
+}

package/dist/biocat-accessory.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BiocatAccessory = void 0;
+class BiocatAccessory {
+    platform;
+    accessory;
+    informationService;
+    leakSensorService;
+    valveService;
+    absenceSwitchService;
+    maintenanceService;
+    currentSnapshot;
+    constructor(platform, accessory) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.informationService = this.accessory.getService(this.platform.Service.AccessoryInformation)
+            ?? this.accessory.addService(this.platform.Service.AccessoryInformation);
+        this.leakSensorService = this.accessory.getServiceById(this.platform.Service.LeakSensor, 'leak-sensor')
+            ?? this.accessory.addService(this.platform.Service.LeakSensor, `${this.platform.accessoryName} Leak Protection`, 'leak-sensor');
+        this.valveService = this.accessory.getServiceById(this.platform.Service.Valve, 'water-supply')
+            ?? this.accessory.addService(this.platform.Service.Valve, `${this.platform.accessoryName} Water Supply`, 'water-supply');
+        this.absenceSwitchService = this.accessory.getServiceById(this.platform.Service.Switch, 'absence-mode')
+            ?? this.accessory.addService(this.platform.Service.Switch, `${this.platform.accessoryName} Absence Mode`, 'absence-mode');
+        this.maintenanceService = this.accessory.getServiceById(this.platform.Service.FilterMaintenance, 'maintenance')
+            ?? this.accessory.addService(this.platform.Service.FilterMaintenance, `${this.platform.accessoryName} Maintenance`, 'maintenance');
+        this.leakSensorService.setCharacteristic(this.platform.Characteristic.Name, `${this.platform.accessoryName} Leak Protection`);
+        this.absenceSwitchService.setCharacteristic(this.platform.Characteristic.Name, `${this.platform.accessoryName} Absence Mode`);
+        this.maintenanceService.setCharacteristic(this.platform.Characteristic.Name, `${this.platform.accessoryName} Maintenance`);
+        this.valveService
+            .setCharacteristic(this.platform.Characteristic.Name, `${this.platform.accessoryName} Water Supply`)
+            .setCharacteristic(this.platform.Characteristic.ValveType, this.platform.Characteristic.ValveType.GENERIC_VALVE);
+        this.absenceSwitchService
+            .getCharacteristic(this.platform.Characteristic.On)
+            .onGet(() => this.currentSnapshot?.waterProtection.absenceModeEnabled ?? false)
+            .onSet(async (value) => {
+            await this.platform.setAbsenceMode(Boolean(value));
+        });
+        this.valveService
+            .getCharacteristic(this.platform.Characteristic.Active)
+            .onGet(() => this.isWaterSupplyOpen()
+            ? this.platform.Characteristic.Active.ACTIVE
+            : this.platform.Characteristic.Active.INACTIVE)
+            .onSet(async (value) => {
+            const desiredOpen = Number(value) === this.platform.Characteristic.Active.ACTIVE;
+            await this.platform.setWaterSupplyOpen(desiredOpen);
+        });
+        this.valveService
+            .getCharacteristic(this.platform.Characteristic.InUse)
+            .onGet(() => this.isWaterSupplyOpen()
+            ? this.platform.Characteristic.InUse.IN_USE
+            : this.platform.Characteristic.InUse.NOT_IN_USE);
+    }
+    update(snapshot) {
+        this.currentSnapshot = snapshot;
+        const leakServiceFault = !snapshot.online ||
+            snapshot.waterProtection.faultActive ||
+            snapshot.event.severity === 'error' ||
+            snapshot.event.severity === 'alarm';
+        this.informationService
+            .setCharacteristic(this.platform.Characteristic.Manufacturer, snapshot.manufacturer)
+            .setCharacteristic(this.platform.Characteristic.Model, snapshot.model)
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, snapshot.serialNumber)
+            .setCharacteristic(this.platform.Characteristic.FirmwareRevision, snapshot.firmwareVersion);
+        this.leakSensorService
+            .updateCharacteristic(this.platform.Characteristic.LeakDetected, snapshot.waterProtection.leakDetected
+            ? this.platform.Characteristic.LeakDetected.LEAK_DETECTED
+            : this.platform.Characteristic.LeakDetected.LEAK_NOT_DETECTED)
+            .updateCharacteristic(this.platform.Characteristic.StatusFault, leakServiceFault
+            ? this.platform.Characteristic.StatusFault.GENERAL_FAULT
+            : this.platform.Characteristic.StatusFault.NO_FAULT)
+            .updateCharacteristic(this.platform.Characteristic.StatusActive, snapshot.waterProtection.protectionActive);
+        this.absenceSwitchService.updateCharacteristic(this.platform.Characteristic.On, snapshot.waterProtection.absenceModeEnabled);
+        this.valveService
+            .updateCharacteristic(this.platform.Characteristic.Active, this.isWaterSupplyOpen()
+            ? this.platform.Characteristic.Active.ACTIVE
+            : this.platform.Characteristic.Active.INACTIVE)
+            .updateCharacteristic(this.platform.Characteristic.InUse, this.isWaterSupplyOpen()
+            ? this.platform.Characteristic.InUse.IN_USE
+            : this.platform.Characteristic.InUse.NOT_IN_USE);
+        this.maintenanceService.updateCharacteristic(this.platform.Characteristic.FilterChangeIndication, snapshot.maintenance.changeRequired
+            ? this.platform.Characteristic.FilterChangeIndication.CHANGE_FILTER
+            : this.platform.Characteristic.FilterChangeIndication.FILTER_OK);
+        if (snapshot.maintenance.filterLifeLevel !== undefined) {
+            this.maintenanceService.updateCharacteristic(this.platform.Characteristic.FilterLifeLevel, snapshot.maintenance.filterLifeLevel);
+        }
+        this.accessory.context.lastSnapshot = {
+            refreshedAt: snapshot.refreshedAt,
+            online: snapshot.online,
+            modeId: snapshot.modeId,
+            eventSeverity: snapshot.event.severity,
+            absenceModeEnabled: snapshot.waterProtection.absenceModeEnabled,
+            leakDetected: snapshot.waterProtection.leakDetected,
+            valveClosed: snapshot.waterProtection.valveClosed,
+            statisticsLogDate: snapshot.statistics?.logDate,
+        };
+    }
+    markConnectionFault() {
+        this.leakSensorService.updateCharacteristic(this.platform.Characteristic.StatusFault, this.platform.Characteristic.StatusFault.GENERAL_FAULT);
+    }
+    isWaterSupplyOpen() {
+        return !(this.currentSnapshot?.waterProtection.valveClosed ?? false);
+    }
+}
+exports.BiocatAccessory = BiocatAccessory;

package/dist/biocat-client.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BiocatClient = void 0;
+class BiocatApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'BiocatApiError';
+    }
+}
+class BiocatClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async fetchState() {
+        return this.getJson('/state');
+    }
+    async fetchDailyStatistics() {
+        try {
+            return await this.getJson('/statistics/daily/direct');
+        }
+        catch (error) {
+            if (!(error instanceof BiocatApiError) || error.status !== 400) {
+                throw error;
+            }
+        }
+        const dailyConsumption = await this.getJson('/statistics/cumulative/daily');
+        return {
+            type: 'statistics',
+            entries: [
+                {
+                    consumption: typeof dailyConsumption === 'number' ? dailyConsumption : Number(dailyConsumption),
+                    date: new Date().toISOString(),
+                },
+            ],
+        };
+    }
+    async setAbsenceMode(enabled) {
+        await this.invokeCommand(enabled ? '/absence/enable' : '/absence/disable');
+    }
+    async setWaterSupplyOpen(open) {
+        await this.invokeCommand(open ? '/watersupply/open' : '/watersupply/close');
+    }
+    async invokeCommand(path) {
+        await this.request(path);
+    }
+    async getJson(path, query) {
+        const responseText = await this.request(path, query);
+        if (responseText.trim() === '') {
+            throw new Error(`BIOCAT response was empty for ${path}.`);
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new Error(`BIOCAT response was not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async request(path, query) {
+        if (!this.config.apiKey) {
+            throw new Error('No BIOCAT apiKey configured.');
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+        try {
+            const headers = new Headers(this.config.headers);
+            headers.set('Accept', 'application/json');
+            headers.set('X-API-KEY', this.config.apiKey);
+            const url = new URL(path.replace(/^\//, ''), `${this.config.apiBaseUrl}/`);
+            if (query) {
+                for (const [key, value] of Object.entries(query)) {
+                    if (value === undefined) {
+                        continue;
+                    }
+                    url.searchParams.set(key, String(value));
+                }
+            }
+            const response = await fetch(url, {
+                method: 'GET',
+                headers,
+                signal: controller.signal,
+            });
+            const responseText = await response.text();
+            if (!response.ok) {
+                throw new BiocatApiError(`BIOCAT request failed for ${path} with HTTP ${response.status} ${response.statusText}`, response.status);
+            }
+            return responseText;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.BiocatClient = BiocatClient;

package/dist/config.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlatformConfig = resolvePlatformConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const settings_1 = require("./settings");
+function clampInt(value, fallback, min, max) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.min(max, Math.max(min, Math.round(value)));
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return Math.min(max, Math.max(min, Math.round(parsed)));
+        }
+    }
+    return fallback;
+}
+function sanitizeRelativeDirectory(input, fallback) {
+    if (typeof input !== 'string' || input.trim() === '') {
+        return fallback;
+    }
+    const normalized = node_path_1.default
+        .normalize(input.trim())
+        .replace(/^([/\\])+/, '')
+        .replace(/^(\.\.(\/|\\|$))+/, '');
+    if (normalized === '' || normalized === '.') {
+        return fallback;
+    }
+    return normalized;
+}
+function sanitizeFileName(input, fallback) {
+    if (typeof input !== 'string' || input.trim() === '') {
+        return fallback;
+    }
+    const sanitized = node_path_1.default.basename(input.trim());
+    return sanitized === '' || sanitized === '.' ? fallback : sanitized;
+}
+function normalizeHeaders(headers) {
+    if (!headers) {
+        return {};
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof key !== 'string' || key.trim() === '') {
+            continue;
+        }
+        if (typeof value === 'string' && value.trim() !== '') {
+            normalized[key] = value;
+            continue;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            normalized[key] = String(value);
+        }
+    }
+    return normalized;
+}
+function normalizeApiBaseUrl(apiBaseUrl, statusUrl) {
+    const configuredValue = typeof apiBaseUrl === 'string' && apiBaseUrl.trim() !== ''
+        ? apiBaseUrl.trim()
+        : typeof statusUrl === 'string' && statusUrl.trim() !== ''
+            ? statusUrl.trim()
+            : settings_1.DEFAULT_API_BASE_URL;
+    const trimmed = configuredValue.replace(/\/+$/, '');
+    return trimmed.endsWith('/state') ? trimmed.slice(0, -'/state'.length) : trimmed;
+}
+function resolvePlatformConfig(config) {
+    return {
+        name: typeof config.name === 'string' && config.name.trim() !== '' ? config.name.trim() : 'BIOCAT',
+        apiBaseUrl: normalizeApiBaseUrl(config.apiBaseUrl, config.statusUrl),
+        apiKey: typeof config.apiKey === 'string' && config.apiKey.trim() !== ''
+            ? config.apiKey.trim()
+            : typeof config.authToken === 'string' && config.authToken.trim() !== ''
+                ? config.authToken.trim()
+                : undefined,
+        allowWaterSupplyOpen: config.allowWaterSupplyOpen ?? false,
+        headers: normalizeHeaders(config.headers),
+        pollIntervalSeconds: clampInt(config.pollIntervalSeconds, settings_1.DEFAULT_POLL_INTERVAL_SECONDS, 15, 86_400),
+        requestTimeoutMs: clampInt(config.requestTimeoutMs, settings_1.DEFAULT_REQUEST_TIMEOUT_MS, 1_000, 120_000),
+        statistics: {
+            enabled: config.statistics?.enabled ?? true,
+            directory: sanitizeRelativeDirectory(config.statistics?.directory, settings_1.DEFAULT_LOG_DIRECTORY),
+            fileName: sanitizeFileName(config.statistics?.fileName, settings_1.DEFAULT_STATISTICS_FILE_NAME),
+            stateFileName: sanitizeFileName(config.statistics?.stateFileName, settings_1.DEFAULT_STATISTICS_STATE_FILE_NAME),
+        },
+    };
+}

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+const settings_1 = require("./settings");
+const platform_1 = require("./platform");
+module.exports = (api) => {
+    api.registerPlatform(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, platform_1.BiocatPlatform);
+};