iobroker.miele-local 0.2.0

package/lib/discovery.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * mDNS-Discovery der Miele-Geräte (_mieleathome._tcp).
+ *
+ * Record-Struktur (real beobachtet):
+ *   PTR  _mieleathome._tcp.local            → "Miele <TechType>._mieleathome._tcp.local"
+ *   SRV  Miele <TechType>._mieleathome...   → target "Miele-<MAC>.local", port 80
+ *   TXT  Miele <TechType>._mieleathome...   → group=<GroupID>, devicetype, pairing, …
+ *   A    Miele-<MAC>.local                  → IP
+ *
+ * Liefert je Gerät: ip, host, techType, txt (group/devicetype/pairing/…).
+ * Die Seriennummer steht NICHT im mDNS – sie kommt aus dem signierten /Ident.
+ *
+ * Nutzt `multicast-dns` (pure JS, keine nativen Abhängigkeiten).
+ */
+
+// multicast-dns wird bewusst NICHT top-level geladen: mDNS-Discovery ist experimentell und im
+// Bridge-Netz (Docker) ohnehin funktionslos (Multicast wird nicht gebrückt) - der Normalbetrieb
+// nutzt manuelle Geräte-IPs. Fehlt das Modul (z. B. nach einem abgebrochenen npm-Install), darf das
+// NICHT den ganzen Adapter am Start crashen. Daher lazy require erst in discover().
+const SERVICE = '_mieleathome._tcp.local';
+
+function parseTxt(buffers) {
+    const txt = {};
+    for (const b of buffers || []) {
+        const s = b.toString('utf8');
+        const eq = s.indexOf('=');
+        if (eq > 0) {
+            txt[s.slice(0, eq)] = s.slice(eq + 1);
+        } else if (s) {
+            txt[s] = true;
+        }
+    }
+    return txt;
+}
+
+/**
+ * @param {number} timeoutMs  Sammelzeit
+ * @param {(msg:string)=>void} [log]
+ * @returns {Promise<Array<{ip:string, host:string, port:number, techType:string, txt:object}>>}
+ */
+function discover(timeoutMs = 5000, log = () => {}, adapter = null) {
+    // Timer über den Adapter, damit sie beim Beenden sauber aufgeräumt werden (ioBroker-Vorgabe)
+    const setT = adapter ? adapter.setTimeout.bind(adapter) : global.setTimeout;
+    const clearT = adapter ? adapter.clearTimeout.bind(adapter) : global.clearTimeout;
+    return new Promise(resolve => {
+        let multicastDns;
+        try {
+            multicastDns = require('multicast-dns');
+        } catch (e) {
+            log('mDNS-Discovery nicht verfügbar (multicast-dns nicht installiert) - bitte Geräte-IPs manuell eintragen.');
+            return resolve([]);
+        }
+        const mdns = multicastDns();
+        const instances = {}; // instanceName → { techType, host, port, txt }
+        const hostToIp = {}; // host → ip
+
+        mdns.on('response', res => {
+            for (const a of [...(res.answers || []), ...(res.additionals || [])]) {
+                if (a.type === 'SRV' && a.name.endsWith(`.${SERVICE}`)) {
+                    const inst = (instances[a.name] = instances[a.name] || { techType: '', host: null, port: 80, txt: {} });
+                    inst.host = a.data.target;
+                    inst.port = a.data.port;
+                    inst.techType = a.name.replace(`.${SERVICE}`, '').replace(/^Miele\s*/i, '').trim();
+                } else if (a.type === 'TXT' && a.name.endsWith(`.${SERVICE}`)) {
+                    const inst = (instances[a.name] = instances[a.name] || { techType: '', host: null, port: 80, txt: {} });
+                    Object.assign(inst.txt, parseTxt(a.data));
+                    if (!inst.techType) {
+                        inst.techType = a.name.replace(`.${SERVICE}`, '').replace(/^Miele\s*/i, '').trim();
+                    }
+                } else if (a.type === 'A') {
+                    hostToIp[a.name] = a.data;
+                }
+            }
+        });
+
+        const query = () => mdns.query({ questions: [{ name: SERVICE, type: 'PTR' }] });
+        query();
+        const q2 = setT(query, 1000);
+
+        setT(() => {
+            clearT(q2);
+            try {
+                mdns.destroy();
+            } catch {
+                /* egal */
+            }
+            const list = [];
+            for (const inst of Object.values(instances)) {
+                const ip = inst.host ? hostToIp[inst.host] : null;
+                if (ip) {
+                    list.push({ ip, host: inst.host, port: inst.port, techType: inst.techType, txt: inst.txt });
+                }
+            }
+            log(`mDNS: ${list.length} Miele-Gerät(e) gefunden`);
+            resolve(list);
+        }, timeoutMs);
+    });
+}
+
+module.exports = { discover, SERVICE };

package/lib/dop2.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * Minimaler DOP2-Binärparser (portiert aus akappner/MieleRESTServer MieleDop2.py).
+ * Dekodiert einen Leaf in eine Map { feldindex(1-based) -> { type, value } }.
+ * Struct-Werte sind Arrays von Sub-Attributen; Integer sind Big-Endian.
+ */
+
+// Feste Byte-Längen je Feldtyp
+const FIXED = { 1: 1, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2, 7: 2, 8: 4, 9: 4, 10: 4, 11: 8, 12: 8, 13: 8, 14: 4, 15: 8 };
+const SIGNED = new Set([3, 6, 9, 12]);
+// Array-Elementtypen: type -> elementByteLength
+const ARRAY_ELEM = { 17: 1, 20: 1, 21: 2, 22: 2, 23: 2, 25: 4, 27: 8 };
+
+function readInt(buf, off, len, signed) {
+    let v = 0n;
+    for (let i = 0; i < len; i++) v = (v << 8n) | BigInt(buf[off + i]);
+    if (signed) {
+        const bits = BigInt(len * 8);
+        if (v >= 1n << (bits - 1n)) v -= 1n << bits;
+    }
+    return len > 4 ? v : Number(v); // 8-Byte als BigInt, sonst Number
+}
+
+/** Dekodiert EIN Feld ab off. Gibt { value, wireLength } zurück. */
+function decodeField(type, buf, off) {
+    if (FIXED[type] != null) {
+        const len = FIXED[type];
+        if (type === 1) return { value: buf[off] === 1, wireLength: 1 };
+        if (type === 14) return { value: buf.readFloatBE(off), wireLength: 4 };
+        if (type === 15) return { value: buf.readDoubleBE(off), wireLength: 8 };
+        return { value: readInt(buf, off, len, SIGNED.has(type)), wireLength: len };
+    }
+    if (type === 16) return decodeStruct(buf, off);
+    if (type === 18 || type === 32) {
+        const strLen = (buf[off] << 8) + buf[off + 1];
+        return { value: buf.subarray(off + 2, off + 2 + strLen), wireLength: 2 + strLen };
+    }
+    if (ARRAY_ELEM[type] != null) {
+        const n = (buf[off] << 8) + buf[off + 1];
+        const el = ARRAY_ELEM[type];
+        const vals = [];
+        for (let i = 0; i < n; i++) {
+            const p = off + 2 + i * el;
+            vals.push(type === 17 ? buf[p] === 1 : readInt(buf, p, el, SIGNED.has(type - 10)));
+        }
+        return { value: vals, wireLength: 2 + n * el };
+    }
+    throw new Error(`Unbekannter DOP2-Feldtyp ${type} @${off}`);
+}
+
+/** Struct: Header [byte0, numberOfFields, byte2], dann Felder [id, type, value] mit 0x00-Padding. */
+function decodeStruct(buf, off) {
+    const numberOfFields = buf[off + 1];
+    if (numberOfFields === 0 || numberOfFields > 160) throw new Error(`Struct unplausibel (${numberOfFields})`);
+    let p = off + 3;
+    let fieldLength = 0;
+    const fields = [];
+    while (true) {
+        const dataType = buf[p + 1];
+        const f = decodeField(dataType, buf, p + 2);
+        const cur = f.wireLength + 2;
+        fieldLength += cur;
+        fields.push({ type: dataType, value: f.value });
+        if (fields.length === numberOfFields) break;
+        p += cur;
+        if (buf[p] === 0x00) { p += 1; fieldLength += 1; }
+    }
+    return { value: fields, wireLength: fieldLength + 3 };
+}
+
+/**
+ * Parst einen ganzen DOP2-Leaf (entschlüsselte Bytes) → { unit, attr, fields{idx:{type,value}} }.
+ */
+function parseLeaf(buf) {
+    const payloadLength = (buf[0] << 8) + buf[1];
+    const unit = (buf[2] << 8) + buf[3];
+    const attr = (buf[4] << 8) + buf[5];
+    const padding = buf.length - payloadLength - 2;
+    const payload = buf.subarray(8, buf.length - (padding > 0 ? padding : 0));
+    const fields = {};
+    if (payload.length === 0) return { unit, attr, fields };
+    const numberOfFields = payload[3] + (payload[4] << 8);
+    let rem = payload.subarray(5);
+    let count = 0;
+    while (count < numberOfFields && rem.length >= 2) {
+        const idx = rem[0];
+        const type = rem[1];
+        const f = decodeField(type, rem, 2);
+        fields[idx] = { type, value: f.value };
+        count++;
+        rem = rem.subarray(3 + f.wireLength);
+    }
+    return { unit, attr, fields };
+}
+
+/** Wert eines "interpretierten" Feldes (Struct [mask, value, interpretation]) → mittleres Sub-Feld. */
+function interpValue(fields, idx) {
+    const f = fields[idx];
+    if (!f || !Array.isArray(f.value) || f.value.length < 2) return null;
+    return f.value[1].value;
+}
+
+module.exports = { parseLeaf, interpValue, decodeField };

package/lib/enroll.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * SuperVision-Enrollment: bringt ein Gerät dazu, Zustandsänderungen aktiv an
+ * unseren Push-Listener zu senden.
+ *
+ * Ablauf pro Gerät (alles MieleH256-signiert, Body AES-verschlüsselt):
+ *   1. PUT  /Devices/<route>/SuperVision/<ourFab>   {"Show":true,"Signal":true}
+ *      → registriert uns als SuperVision-Peer (manche Basisgeräte: 404 → übersprungen).
+ *   2. POST /Subscriptions   je Ressource
+ *      Body {"Resource":"/Devices/<route><res>","Callback":"http://<ip>:<port>/Devices/<ourFab>/SuperVision/<route><res>"}
+ *      → das Gerät POSTet künftig an unsere Callback-URL.
+ *
+ * Subscriptions laufen ab → periodisch erneuern (renew).
+ */
+
+const PUSH_RESOURCES = ['/State/', '/State/Light/', '/State/Status/', '/Ident/'];
+
+/**
+ * @param {import('./api').MieleDeviceApi} api
+ * @param {object} opts { route, ourFab, hostIp, port, log }
+ * @returns {Promise<{supervisionOk:boolean, subscriptions:string[]}>}
+ */
+async function enrollDevice(api, opts) {
+    const { route, ourFab, hostIp, port, log = console } = opts;
+    let supervisionOk = false;
+
+    // 1. SuperVision-Peer-Eintrag
+    try {
+        const body = JSON.stringify({ Show: true, Signal: true });
+        const status = await api.put(`Devices/${route}/SuperVision/${ourFab}`, body);
+        if (status >= 200 && status < 300) {
+            supervisionOk = true;
+            log.debug(`[${route}] SuperVision Show/Signal akzeptiert (${status})`);
+        } else if (status === 404) {
+            log.debug(`[${route}] kein /SuperVision-Endpunkt – nur Subscriptions`);
+        } else {
+            log.debug(`[${route}] SuperVision PUT → ${status}`);
+        }
+    } catch (e) {
+        log.debug(`[${route}] SuperVision PUT Fehler: ${e.message}`);
+    }
+
+    // 2. Subscriptions je Ressource
+    const subscriptions = [];
+    for (const res of PUSH_RESOURCES) {
+        const body = JSON.stringify({
+            Resource: `/Devices/${route}${res}`,
+            Callback: `http://${hostIp}:${port}/Devices/${ourFab}/SuperVision/${route}${res}`,
+        });
+        try {
+            const { status } = await api.post('Subscriptions', body);
+            if (status >= 200 && status < 300) {
+                subscriptions.push(res);
+                log.debug(`[${route}] Subscription ${res} → ${status}`);
+            } else {
+                log.debug(`[${route}] Subscription ${res} → ${status}`);
+            }
+        } catch (e) {
+            log.debug(`[${route}] Subscription ${res} Fehler: ${e.message}`);
+        }
+    }
+
+    return { supervisionOk, subscriptions };
+}
+
+module.exports = { enrollDevice, PUSH_RESOURCES };