homematic-manager 3.0.0-beta.25 → 3.0.0-beta.26

package/node_modules/@homematic-manager/backend/dist/api/backend.js

@@ -99,8 +99,8 @@ export class Backend {
      * swallows packets takes 30 s); a store that has not started by then never will.
      */
     #metaStarting;
-    /** Task 36: ReGa's first report per `<interface>|<address>|<datapoint>`, from its pending alarms. */
-    #regaFirstSeen = new Map();
+    /** Task 36, B-74: ReGa's pending alarms per `<interface>|<address>|<datapoint>` - the CCU's own list. */
+    #regaAlarms = new Map();
     /** Task 64: `getParamsetId` answers by `<interface>|<address>`; emptied on every connect. */
     #paramsetIds = new Map();
     #serviceMessageTimer;
@@ -665,7 +665,7 @@ export class Backend {
         });
         // B-54: the names are waited for only so long; the store starts after them either way,
         // so its names still land over ReGa's as before (task 27, D-40)
-        this.#regaFirstSeen.clear();
+        this.#regaAlarms.clear();
         const names = this.#rega.refreshNames().then((changed) => {
             if (changed && this.#manager === manager) {
                 this.#caches.saveNames();
@@ -1085,7 +1085,8 @@ export class Backend {
      */
     #stickyUnreachMessages() {
         const states = this.#manager?.states() ?? [];
-        return this.#caches.listServiceMessages().filter((message) => {
+        // B-74: with the messages only ReGa lists - the WebUI's "war gestört" the interface forgot
+        return this.#serviceMessages().filter((message) => {
             if (message.datapoint !== 'STICKY_UNREACH' || message.value === false) {
                 return false;
             }
@@ -1102,9 +1103,7 @@ export class Backend {
      */
     async #acknowledgeExisting(messages) {
         for (const message of messages) {
-            const listed = this.#caches
-                .listServiceMessages(message.interfaceName)
-                .some((entry) => entry.address === message.address && entry.datapoint === message.datapoint);
+            const listed = this.#serviceMessages(message.interfaceName).some((entry) => entry.address === message.address && entry.datapoint === message.datapoint);
             if (!listed || this.#stopped) {
                 continue;
             }
@@ -1432,20 +1431,56 @@ export class Backend {
         return matrix;
     }
     #serviceMessages(interfaceName) {
-        return this.#withRegaTimes(this.#caches.listServiceMessages(interfaceName));
+        return this.#withRegaAlarms(this.#caches.listServiceMessages(interfaceName), interfaceName);
     }
     /**
      * Task 36: where ReGa knows a message, its first report (the WebUI's *Erste Meldung*) replaces
      * the time this application first saw it, and says so.
+     *
+     * B-74 (#150): and a pending alarm whose datapoint the interface process does not list becomes
+     * a row of its own, as the WebUI shows it - value and first report from ReGa, marked as listed
+     * by the CCU only. rfd forgets a `STICKY_UNREACH` at a restart while ReGa keeps the alarm until
+     * it is receipted, so the WebUI had nine messages this list lacked. Only the connection's own
+     * interfaces and the datapoints that are service messages here: an alarm on a system variable
+     * or a CUxD datapoint stays the WebUI's.
      */
-    #withRegaTimes(messages) {
-        if (this.#regaFirstSeen.size === 0) {
+    #withRegaAlarms(messages, interfaceName) {
+        if (this.#regaAlarms.size === 0) {
             return messages;
         }
-        return messages.map((message) => {
-            const first = this.#regaFirstSeen.get(`${message.interfaceName}|${message.address}|${message.datapoint}`);
-            return first === undefined ? message : { ...message, since: first, sinceSource: 'rega' };
+        const listed = new Set();
+        const result = messages.map((message) => {
+            const key = `${message.interfaceName}|${message.address}|${message.datapoint}`;
+            listed.add(key);
+            const alarm = this.#regaAlarms.get(key);
+            return alarm === undefined ? message : { ...message, since: alarm.first, sinceSource: 'rega' };
         });
+        const known = new Set(this.#manager?.names() ?? []);
+        for (const [key, alarm] of this.#regaAlarms) {
+            if (listed.has(key) ||
+                !known.has(alarm.interfaceName) ||
+                (interfaceName !== undefined && alarm.interfaceName !== interfaceName) ||
+                !countsAsServiceMessage(alarm.datapoint, alarm.value)) {
+                continue;
+            }
+            result.push({
+                interfaceName: alarm.interfaceName,
+                address: alarm.address,
+                datapoint: alarm.datapoint,
+                value: alarm.value,
+                since: alarm.first,
+                sinceSource: 'rega',
+                source: 'rega',
+            });
+        }
+        return result;
+    }
+    /** B-74: is this message one only ReGa lists - a pending alarm without the interface's datapoint? */
+    #isRegaOnly(interfaceName, address, datapoint) {
+        return (this.#regaAlarms.has(`${interfaceName}|${address}|${datapoint}`) &&
+            !this.#caches
+                .listServiceMessages(interfaceName)
+                .some((message) => message.address === address && message.datapoint === datapoint));
     }
     /**
      * Task 36: reads ReGa's pending service messages (one short script, read-only) and keeps their
@@ -1457,8 +1492,8 @@ export class Backend {
     async #refreshRegaAlarms() {
         const rega = this.#rega;
         if (!rega?.state.enabled) {
-            if (this.#regaFirstSeen.size > 0) {
-                this.#regaFirstSeen.clear();
+            if (this.#regaAlarms.size > 0) {
+                this.#regaAlarms.clear();
                 this.events.emit('serviceMessages.changed', this.#serviceMessages());
             }
             return;
@@ -1467,12 +1502,15 @@ export class Backend {
         if (alarms === undefined || this.#rega !== rega) {
             return;
         }
-        const next = new Map(alarms.map((alarm) => [`${alarm.interfaceName}|${alarm.address}|${alarm.datapoint}`, alarm.first]));
-        const changed = next.size !== this.#regaFirstSeen.size ||
-            [...next].some(([key, first]) => this.#regaFirstSeen.get(key) !== first);
-        this.#regaFirstSeen.clear();
-        for (const [key, first] of next) {
-            this.#regaFirstSeen.set(key, first);
+        const next = new Map(alarms.map((alarm) => [`${alarm.interfaceName}|${alarm.address}|${alarm.datapoint}`, alarm]));
+        const changed = next.size !== this.#regaAlarms.size ||
+            [...next].some(([key, alarm]) => {
+                const before = this.#regaAlarms.get(key);
+                return before === undefined || before.first !== alarm.first || before.value !== alarm.value;
+            });
+        this.#regaAlarms.clear();
+        for (const [key, alarm] of next) {
+            this.#regaAlarms.set(key, alarm);
         }
         if (changed) {
             this.events.emit('serviceMessages.changed', this.#serviceMessages());
@@ -1705,21 +1743,44 @@ export class Backend {
         if (!isAcknowledgeable(datapoint)) {
             throw validationError(`${datapoint} cannot be acknowledged`);
         }
-        const description = await this.#describe(interfaceName, address, 'VALUES');
-        const parameter = description[datapoint];
-        const value = parameter?.TYPE === 'ACTION';
-        await this.#writer.setValue(interfaceName, address, datapoint, value);
+        // B-74: a message only ReGa lists has no flag left to clear on the interface; the write is
+        // still sent (rfd takes a `false` for a flag it does not hold), but its failure - a device
+        // the interface no longer knows, say - must not keep the alarm standing in the WebUI
+        const regaOnly = this.#isRegaOnly(interfaceName, address, datapoint);
+        try {
+            const description = await this.#describe(interfaceName, address, 'VALUES');
+            const parameter = description[datapoint];
+            const value = parameter?.TYPE === 'ACTION';
+            await this.#writer.setValue(interfaceName, address, datapoint, value);
+        }
+        catch (error) {
+            if (!regaOnly) {
+                throw error;
+            }
+            this.#notice('info', `${address}: ${datapoint} is listed by the CCU only; the interface did not take the write (${errorMessage(error)}), the alarm is receipted in ReGa`, interfaceName);
+        }
         if (this.#caches.serviceMessages.clear(interfaceName, address, datapoint)) {
             this.events.emit('serviceMessages.changed', this.#serviceMessages());
         }
         // Issue #94: the datapoint write above is the acknowledgement that matters, and it happened
         // whether ReGa exists or not. This clears the CCU's own alarm on top, so the WebUI stops
         // showing a message the user has already dealt with here. D-2: silent when ReGa is off.
-        void this.#rega?.acknowledgeAlarm(interfaceName, address, datapoint).then(async (receipted) => {
+        // B-74: for a message only ReGa lists the receipt *is* the acknowledgement, so it is waited
+        // for, and the row goes with the list that follows it.
+        const receipt = (this.#rega?.acknowledgeAlarm(interfaceName, address, datapoint) ?? Promise.resolve(false)).then(async (receipted) => {
             if (receipted) {
                 await this.#refreshRegaAlarms();
             }
+            else if (regaOnly) {
+                this.#notice('warn', `${address}: ${datapoint} is listed by the CCU only, and ReGa did not receipt it`, interfaceName);
+            }
         });
+        if (regaOnly) {
+            await receipt;
+        }
+        else {
+            void receipt;
+        }
         return null;
     }
     #recentEvents(interfaceName, limit) {

package/node_modules/@homematic-manager/backend/dist/rega/scripts.d.ts

@@ -20,6 +20,7 @@
  * the interface process, or is a convenience; a system without ReGa loses nothing but the CCU-side
  * bookkeeping.
  */
+import type { ParamsetValue } from '@homematic-manager/core';
 /** Escapes a string for the ReGa string literal it is written into. */
 export declare function escapeRegaString(value: string): string;
 /** One entry of a rename: the ReGa object id and the name it should carry. */
@@ -72,24 +73,35 @@ export declare function parseConfirmedDevices(output: string): ConfirmedDevice[]
  */
 export declare function acknowledgeAlarmScript(interfaceName: string, address: string, datapoint: string): string | undefined;
 /**
- * Task 36: the CCU's pending service messages with their times, as the WebUI's service-message page
- * reads them: every `OT_ALARMDP` of `ID_SERVICES` that is `asOncoming`, one line per alarm with the
- * trigger datapoint's name, `AlOccurrenceTime()` (the WebUI's *Erste Meldung*) and `Timestamp()`
+ * Task 36, B-74: the CCU's pending service messages with their times and values, as the WebUI's
+ * service-message page lists them: every `OT_ALARMDP` of `ID_SERVICES` that is `Used()`,
+ * `Enabled()` and `asOncoming` (`serviceMessages.htm` of OpenCCU 3.89.8), one line per alarm with
+ * the trigger datapoint's name, `AlOccurrenceTime()` (the WebUI's *Erste Meldung*), `Timestamp()`
  * (*Letzte Meldung*), both as Unix seconds (`ToInteger()`, checked against `date +%s` on the lab's
- * OpenCCU). Read-only.
+ * OpenCCU), and the trigger's `Value()` - ReGa's own last value of the datapoint, which is what
+ * the WebUI shows for the message (`true`/`false`, an ENUM as its index). Read-only.
+ *
+ * B-74 (#150): an alarm stays oncoming until it is receipted, whatever the interface process
+ * reports meanwhile - rfd forgets a `STICKY_UNREACH` at a restart, ReGa does not - so the
+ * WebUI lists messages `getServiceMessages` does not. The value is what such a message is shown
+ * with.
  */
-export declare const REGA_ALARMS_SCRIPT = "string sId;\nforeach (sId, dom.GetObject(ID_SERVICES).EnumIDs()) {\n    object oAlarm = dom.GetObject(sId);\n    if (oAlarm) {\n        if (oAlarm.IsTypeOf(OT_ALARMDP) && (oAlarm.AlState() == asOncoming)) {\n            object oTrigger = dom.GetObject(oAlarm.AlTriggerDP());\n            if (oTrigger) {\n                Write(oTrigger.Name() # \"\\t\" # oAlarm.AlOccurrenceTime().ToInteger() # \"\\t\" # oAlarm.Timestamp().ToInteger() # \"\\n\");\n            }\n        }\n    }\n}\n";
-/** One pending ReGa service message: whose datapoint, first and last reported (epoch ms). */
+export declare const REGA_ALARMS_SCRIPT = "string sId;\nforeach (sId, dom.GetObject(ID_SERVICES).EnumIDs()) {\n    object oAlarm = dom.GetObject(sId);\n    if (oAlarm) {\n        if (oAlarm.IsTypeOf(OT_ALARMDP) && (oAlarm.Used() == true) && (oAlarm.Enabled() == true) && (oAlarm.AlState() == asOncoming)) {\n            object oTrigger = dom.GetObject(oAlarm.AlTriggerDP());\n            if (oTrigger) {\n                Write(oTrigger.Name() # \"\\t\" # oAlarm.AlOccurrenceTime().ToInteger() # \"\\t\" # oAlarm.Timestamp().ToInteger() # \"\\t\" # oTrigger.Value() # \"\\n\");\n            }\n        }\n    }\n}\n";
+/** One pending ReGa service message: whose datapoint, its value, first and last reported (epoch ms). */
 export interface RegaAlarm {
     readonly interfaceName: string;
     readonly address: string;
     readonly datapoint: string;
+    /** ReGa's last value of the trigger datapoint; `true` when the line carries none (older script). */
+    readonly value: ParamsetValue;
     readonly first: number;
     readonly last: number;
 }
 /**
  * Reads what {@link REGA_ALARMS_SCRIPT} wrote. A line whose name is not `<interface>.<channel>.<datapoint>`
- * (a system alarm, a CUxD name with more dots) or whose time is no positive number is skipped.
+ * (a system alarm, a CUxD name with more dots) or whose time is no positive number is skipped. The
+ * value column is ReGa's text of the value: `true`/`false`, a number as it prints it (an ENUM by
+ * its index), anything else stays a string; a line without it means `true`.
  */
 export declare function parseRegaAlarms(output: string): RegaAlarm[];
 /**

package/node_modules/@homematic-manager/backend/dist/rega/scripts.js

@@ -124,20 +124,27 @@ Write(iDone);
 `;
 }
 /**
- * Task 36: the CCU's pending service messages with their times, as the WebUI's service-message page
- * reads them: every `OT_ALARMDP` of `ID_SERVICES` that is `asOncoming`, one line per alarm with the
- * trigger datapoint's name, `AlOccurrenceTime()` (the WebUI's *Erste Meldung*) and `Timestamp()`
+ * Task 36, B-74: the CCU's pending service messages with their times and values, as the WebUI's
+ * service-message page lists them: every `OT_ALARMDP` of `ID_SERVICES` that is `Used()`,
+ * `Enabled()` and `asOncoming` (`serviceMessages.htm` of OpenCCU 3.89.8), one line per alarm with
+ * the trigger datapoint's name, `AlOccurrenceTime()` (the WebUI's *Erste Meldung*), `Timestamp()`
  * (*Letzte Meldung*), both as Unix seconds (`ToInteger()`, checked against `date +%s` on the lab's
- * OpenCCU). Read-only.
+ * OpenCCU), and the trigger's `Value()` - ReGa's own last value of the datapoint, which is what
+ * the WebUI shows for the message (`true`/`false`, an ENUM as its index). Read-only.
+ *
+ * B-74 (#150): an alarm stays oncoming until it is receipted, whatever the interface process
+ * reports meanwhile - rfd forgets a `STICKY_UNREACH` at a restart, ReGa does not - so the
+ * WebUI lists messages `getServiceMessages` does not. The value is what such a message is shown
+ * with.
  */
 export const REGA_ALARMS_SCRIPT = `string sId;
 foreach (sId, dom.GetObject(ID_SERVICES).EnumIDs()) {
     object oAlarm = dom.GetObject(sId);
     if (oAlarm) {
-        if (oAlarm.IsTypeOf(OT_ALARMDP) && (oAlarm.AlState() == asOncoming)) {
+        if (oAlarm.IsTypeOf(OT_ALARMDP) && (oAlarm.Used() == true) && (oAlarm.Enabled() == true) && (oAlarm.AlState() == asOncoming)) {
             object oTrigger = dom.GetObject(oAlarm.AlTriggerDP());
             if (oTrigger) {
-                Write(oTrigger.Name() # "\\t" # oAlarm.AlOccurrenceTime().ToInteger() # "\\t" # oAlarm.Timestamp().ToInteger() # "\\n");
+                Write(oTrigger.Name() # "\\t" # oAlarm.AlOccurrenceTime().ToInteger() # "\\t" # oAlarm.Timestamp().ToInteger() # "\\t" # oTrigger.Value() # "\\n");
             }
         }
     }
@@ -145,12 +152,14 @@ foreach (sId, dom.GetObject(ID_SERVICES).EnumIDs()) {
 `;
 /**
  * Reads what {@link REGA_ALARMS_SCRIPT} wrote. A line whose name is not `<interface>.<channel>.<datapoint>`
- * (a system alarm, a CUxD name with more dots) or whose time is no positive number is skipped.
+ * (a system alarm, a CUxD name with more dots) or whose time is no positive number is skipped. The
+ * value column is ReGa's text of the value: `true`/`false`, a number as it prints it (an ENUM by
+ * its index), anything else stays a string; a line without it means `true`.
  */
 export function parseRegaAlarms(output) {
     const alarms = [];
     for (const line of output.split('\n')) {
-        const [name, first, last] = line.split('\t');
+        const [name, first, last, value] = line.split('\t');
         const match = /^([^.\s]+)\.([^.\s]+)\.([^.\s]+)$/u.exec(name?.trim() ?? '');
         const firstSeconds = Number(first);
         const lastSeconds = Number(last);
@@ -161,12 +170,25 @@ export function parseRegaAlarms(output) {
             interfaceName: match[1] ?? '',
             address: match[2] ?? '',
             datapoint: match[3] ?? '',
+            value: parseRegaValue(value),
             first: firstSeconds * 1000,
             last: Number.isFinite(lastSeconds) && lastSeconds > 0 ? lastSeconds * 1000 : firstSeconds * 1000,
         });
     }
     return alarms;
 }
+/** ReGa's text of a datapoint value, as `Write(oDP.Value())` prints it. */
+function parseRegaValue(text) {
+    const trimmed = text?.trim() ?? '';
+    if (trimmed === '' || trimmed === 'true') {
+        return true;
+    }
+    if (trimmed === 'false') {
+        return false;
+    }
+    const number = Number(trimmed);
+    return Number.isFinite(number) ? number : trimmed;
+}
 /**
  * Is this safe to put inside a ReGa string literal *unescaped*?
  *

package/node_modules/@homematic-manager/backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homematic-manager/backend",
-  "version": "3.0.0-beta.25",
+  "version": "3.0.0-beta.26",
   "type": "module",
   "description": "Homematic Manager backend: XML-RPC/BIN-RPC clients and callback servers, caches, optional ReGa",
   "license": "AGPL-3.0-or-later",

package/node_modules/@homematic-manager/core/dist/api/types.d.ts

@@ -589,6 +589,13 @@ export interface ServiceMessage {
      * WebUI's *Erste Meldung*); absent when it is when this application first saw it.
      */
     sinceSource?: 'rega';
+    /**
+     * B-74 (#150): `rega` when only the CCU's ReGa lists this message - its alarm is pending while
+     * the interface process no longer reports the datapoint (rfd forgets a `STICKY_UNREACH` at a
+     * restart, ReGa keeps the alarm until it is receipted). The WebUI shows such a message; so does
+     * this list. Absent when the interface reports it.
+     */
+    source?: 'rega';
 }
 export interface EventRecord {
     /** Milliseconds since epoch. */

package/node_modules/@homematic-manager/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homematic-manager/core",
-  "version": "3.0.0-beta.25",
+  "version": "3.0.0-beta.26",
   "type": "module",
   "description": "Pure domain logic of the Homematic Manager: no I/O, no DOM",
   "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homematic-manager",
-  "version": "3.0.0-beta.25",
+  "version": "3.0.0-beta.26",
   "type": "module",
   "description": "Configure and administer Homematic and HomematicIP devices - devices and channels, direct links, paramsets, RSSI, service messages, events and an RPC console - from a local HTTP/WebSocket server that also serves the web UI",
   "keywords": [
@@ -67,8 +67,8 @@
     "hm-simulator": "^1.0.0"
   },
   "dependencies": {
-    "@homematic-manager/backend": "3.0.0-beta.25",
-    "@homematic-manager/core": "3.0.0-beta.25",
+    "@homematic-manager/backend": "3.0.0-beta.26",
+    "@homematic-manager/core": "3.0.0-beta.26",
     "binrpc": "^4.2.0",
     "homematic-rega": "^2.0.0",
     "homematic-xmlrpc": "^2.0.0",