node-red-contrib-ccu 4.7.0 → 4.7.1

package/CHANGELOG.md

@@ -5,6 +5,28 @@ Notable changes to node-red-contrib-ccu. Format follows
 user-visible symptom and the cause, not the commit list (the release notes
 append commits automatically).
 
+## 4.7.1 (2026-10-28)
+
+### Fixed
+
+- **On openccu-lite every write of a decimal value failed** - a dimmer's or a
+  blind's `LEVEL`, a thermostat's set point, an `ON_TIME`, through _value_,
+  _set value_, _rpc_ and the other nodes alike. A `FLOAT` datapoint is sent as
+  a typed double, which over XML-RPC is homematic-xmlrpc's
+  `{explicitDouble: n}`; the lite-rpc connection of 4.7.0 passed that object
+  on as it was, so the interface process got a struct where a number belongs
+  and refused it (`Failure` from rfd and hs485d,
+  `-5 Invalid parameter or value` from hmipserver). The lite-rpc connection
+  now sends lite-rpc's own typed double, `{double: n}` (or the plain number
+  on a system that does not announce it) - in `setValue`, in a paramset of
+  `putParamset` and in a multicall. The direct connection to a CCU is unchanged. Until this version
+  the workaround was _CCU_ in the connection node's _openccu-lite interfaces_.
+- **Errors of the lite-rpc connection said less than they should:** a fault
+  of the interface process was logged as `fault -1 undefined` and reached the
+  flow as `OccuLiteError: Failure`, and a token without the needed rights did
+  not say which right it lacks. The fault now carries its code and text, and a
+  refused call names the missing scope.
+
 ## 4.7.0 (2026-10-27)
 
 ### Added

package/nodes/lib/lite.js

@@ -80,7 +80,26 @@ function readAddonToken(file = module.exports.ADDON_TOKEN_FILE) {
  * @returns {boolean}
  */
 function isFault(error) {
-    return Boolean(error) && error.kind === 'rpc-fault' && error.faultCode !== undefined;
+    return kindOf(error) === 'rpc-fault' && error.faultCode !== undefined;
+}
+
+/**
+ * The client's error kind: occulite-client's OccuLiteError carries it as `code` (rpc-fault,
+ * forbidden, timeout ...); `kind` is ours, on an error translated before. A Node system error's
+ * `code` (ECONNREFUSED ...) is not a kind.
+ * @param {*} error
+ * @returns {string|undefined}
+ */
+function kindOf(error) {
+    if (!error) {
+        return undefined;
+    }
+
+    if (error.kind) {
+        return error.kind;
+    }
+
+    return error.name === 'OccuLiteError' && typeof error.code === 'string' ? error.code : undefined;
 }
 
 /**
@@ -97,7 +116,8 @@ function translateError(error) {
         return fault;
     }
 
-    if (error && error.kind === 'forbidden') {
+    const kind = kindOf(error);
+    if (kind === 'forbidden') {
         const refused = new Error(
             'the openccu-lite token may not call this method' + (error.scope ? ' (needs ' + error.scope + ')' : ''),
         );
@@ -106,15 +126,47 @@ function translateError(error) {
         return refused;
     }
 
-    if (error && error.kind) {
-        const translated = new Error(error.message || error.kind);
-        translated.kind = error.kind;
+    if (kind) {
+        const translated = new Error(error.message || kind);
+        translated.kind = kind;
         return translated;
     }
 
     return error instanceof Error ? error : new Error(String(error));
 }
 
+/**
+ * B-41: cast.js marks a FLOAT as homematic-xmlrpc's `{explicitDouble: n}` (the XML-RPC client's
+ * `<double>`). lite-rpc's JSON path does not know that marker and would hand the process a struct
+ * where a double belongs - hs485d and hmipserver refuse it. Its own marker is `{double: n}`
+ * (capability `json_double`); a system without it gets the plain number. Walks the whole
+ * parameter list: the top level, structs and paramsets, a multicall's calls.
+ * @param {*} value
+ * @param {boolean} jsonDouble whether the system announces `json_double`
+ * @returns {*} the value for lite-rpc
+ */
+function liteValue(value, jsonDouble) {
+    if (Array.isArray(value)) {
+        return value.map((item) => liteValue(item, jsonDouble));
+    }
+
+    if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        const keys = Object.keys(value);
+        if (keys.length === 1 && keys[0] === 'explicitDouble') {
+            const number = Number(value.explicitDouble);
+            return jsonDouble ? {double: number} : number;
+        }
+
+        const out = {};
+        keys.forEach((key) => {
+            out[key] = liteValue(value[key], jsonDouble);
+        });
+        return out;
+    }
+
+    return value;
+}
+
 const RPC_TIERS = ['rpc:operate', 'rpc:configure', 'rpc:admin'];
 
 /**
@@ -263,7 +315,8 @@ class LiteConnection {
             return Promise.reject(new Error('lite-rpc client not started'));
         }
 
-        return this.box.call(iface, method, parameters || []).then(
+        const jsonDouble = Boolean(this.box.capabilities && this.box.capabilities.json_double);
+        return this.box.call(iface, method, liteValue(parameters || [], jsonDouble)).then(
             (result) => (result === null || result === undefined ? '' : result),
             (error) => {
                 throw translateError(error);
@@ -302,6 +355,7 @@ module.exports = {
     ADDON_TOKEN_FILE,
     CALLBACK_METHODS,
     readAddonToken,
+    liteValue,
     tierAwareTransport,
     translateError,
     isFault,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-ccu",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "license": "MIT",
   "main": "none",
   "keywords": [