node-red-contrib-ccu 4.4.4 → 4.5.0

package/nodes/ccu-connection.js

@@ -7,15 +7,17 @@ const crypto = require('crypto');
 const base62 = require('./lib/base62.js').toBase62;
 const {castValue, castSysvar} = require('./lib/cast.js');
 const {combinedParameterValue} = require('./lib/combined.js');
+const {isPartyWrite, mergePartyValues, PARTY_DATAPOINTS} = require('./lib/party.js');
 const {createMessage} = require('./lib/message.js');
 const {topicReplace} = require('./lib/topic.js');
 const {isLocalCcu} = require('./lib/localccu.js');
+const {resolveTransport} = require('./lib/transport.js');
 const {bestMatch} = require('./lib/similarity.js');
 const nextport = require('./lib/nextport.js');
 const hmDiscover = require('./lib/discover.js');
 const {Rega} = require('homematic-rega'); // ES module - require(esm) needs Node >= 20.19 / >= 22.12
 const metaProvider = require('./lib/metaprovider.js');
-const {InitRetry} = require('./lib/initretry.js');
+const {InitRetry, retryDelay} = require('./lib/initretry.js');
 const xmlrpc = require('homematic-xmlrpc');
 const binrpc = require('binrpc');
 
@@ -44,6 +46,24 @@ function execToCallback(promise, callback) {
     );
 }
 
+/** B-28: how often an inconclusive metadata api detection is repeated (1, 2, 4, 8 s, then every 15 s) */
+const META_REDETECT_ATTEMPTS = 20;
+
+/**
+ * task 9: has a device description changed in a way that changes its paramsets?
+ * (the paramset key is TYPE/FIRMWARE/VERSION of the device and the channel TYPE)
+ * @param {object} known the cached description
+ * @param {object} device the one the process reports
+ * @returns {boolean}
+ */
+function deviceChanged(known, device) {
+    return ['TYPE', 'VERSION', 'FIRMWARE', 'PARENT_TYPE'].some(
+        (key) =>
+            (known[key] === undefined ? '' : String(known[key])) !==
+            (device[key] === undefined ? '' : String(device[key])),
+    );
+}
+
 function isIterable(object) {
     return object != null && typeof object[Symbol.iterator] === 'function' && typeof object.forEach === 'function';
 }
@@ -85,6 +105,42 @@ module.exports = function (RED) {
     });
     ccu.network.listen.push('0.0.0.0');
 
+    /**
+     * task 9: the editor's channel pickers ask while the connection may still be
+     * initialising - an empty answer then means "not yet", not "nothing". The
+     * header lets the dialog show "loading" and ask again instead of emptying
+     * the picker (and the configured channel with it).
+     * @param {object} config the connection node
+     * @param {string} [iface] the interface asked for, or every enabled one
+     * @returns {boolean}
+     */
+    function deviceDataLoading(config, iface) {
+        const ifaces = iface ? [iface] : Object.keys(config.ifaceTypes).filter((i) => config.ifaceTypes[i].enabled);
+        const connecting = ifaces.some(
+            (i) =>
+                config.ifaceTypes[i] &&
+                config.ifaceTypes[i].init &&
+                config.ifaceTypes[i].enabled &&
+                !config.ifaceStatus[i],
+        );
+        const fetching = Boolean(config.paramsetPending) || (config.paramsetQueue && config.paramsetQueue.length > 0);
+        return connecting || fetching;
+    }
+
+    // task 9: "re-read device data" from the connection node's dialog
+    RED.httpAdmin.post('/ccu/:id/reread', RED.auth.needsPermission('ccu.write'), (request, res) => {
+        const config = RED.nodes.getNode(request.params.id);
+        if (!config || typeof config.rereadDevices !== 'function') {
+            res.status(404).send(JSON.stringify({error: 'connection not deployed'}));
+            return;
+        }
+
+        config
+            .rereadDevices()
+            .then((summary) => res.status(200).send(JSON.stringify(summary)))
+            .catch((error) => res.status(500).send(JSON.stringify({error: error.message})));
+    });
+
     RED.httpAdmin.get('/ccu', RED.auth.needsPermission('ccu.read'), (request, res) => {
         if (request.query.config && request.query.config !== '_ADD_') {
             const config = RED.nodes.getNode(request.query.config);
@@ -95,6 +151,10 @@ module.exports = function (RED) {
 
             const object = {};
 
+            if (['channels', 'tree'].includes(request.query.type) && deviceDataLoading(config, request.query.iface)) {
+                res.set('X-CCU-Loading', '1');
+            }
+
             switch (request.query.type) {
                 case 'ifaces': {
                     Object.keys(config.ifaceTypes).forEach((iface) => {
@@ -407,6 +467,13 @@ module.exports = function (RED) {
         constructor(config) {
             RED.nodes.createNode(this, config);
 
+            // B-31: the CCU password and the openccu-lite token come from Node-RED's
+            // credentials. A flow written by an older version still carries them as
+            // plain properties: use them once and move them into the credentials, so
+            // the next deploy drops them from flows.json.
+            const secrets = this.migrateSecrets(config);
+            config = {...config, password: secrets.password, metaToken: secrets.metaToken};
+
             this.logger.debug('ccu-connection', config.host);
 
             this.checkDuplicateConfig(config);
@@ -420,6 +487,21 @@ module.exports = function (RED) {
                 this.logger.info('local connection on ccu >= v3.41 detected');
             }
 
+            // task 5 (#27): TLS and credentials belong to the CCU's web server, which
+            // fronts the interface processes for the LAN; a local connection reaches
+            // them directly and uses neither, BIN-RPC has neither (lib/transport.js)
+            const transport = resolveTransport({
+                isLocal: this.isLocal,
+                tls: config.tls,
+                authentication: config.authentication,
+                inSecure: config.inSecure,
+                bcrfBinRpc: config.bcrfBinRpc,
+            });
+            transport.notes.forEach((note) => this.logger[note.level](note.message));
+            const {tls, auth, inSecure} = transport;
+            const user = auth ? config.username : undefined;
+            const pass = auth ? config.password : undefined;
+
             this.ifaceTypes = {
                 ReGaHSS: {
                     conf: 'rega',
@@ -431,55 +513,59 @@ module.exports = function (RED) {
                 },
                 'BidCos-RF': {
                     conf: 'bcrf',
-                    rpc: this.isLocal || config.bcrfBinRpc ? binrpc : xmlrpc,
-                    port: this.isLocal ? 32001 : config.tls ? 42001 : 2001,
-                    protocol: this.isLocal || config.bcrfBinRpc ? 'binrpc' : 'http',
-                    auth: config.authentication,
-                    user: config.username,
-                    pass: config.password,
-                    tls: config.tls,
-                    inSecure: config.inSecure,
+                    rpc: this.isLocal || transport.bcrfBinRpc ? binrpc : xmlrpc,
+                    port: this.isLocal ? 32001 : tls ? 42001 : 2001,
+                    protocol: this.isLocal || transport.bcrfBinRpc ? 'binrpc' : 'http',
+                    auth,
+                    user,
+                    pass,
+                    tls,
+                    inSecure,
                     init: true,
                     ping: true,
                 },
                 'BidCos-Wired': {
                     conf: 'bcwi',
                     rpc: this.isLocal ? binrpc : xmlrpc,
-                    port: this.isLocal ? 32000 : config.tls ? 42000 : 2000,
+                    port: this.isLocal ? 32000 : tls ? 42000 : 2000,
                     protocol: this.isLocal ? 'binrpc' : 'http',
-                    auth: config.authentication,
-                    user: config.username,
-                    pass: config.password,
-                    tls: config.tls,
-                    inSecure: config.inSecure,
+                    auth,
+                    user,
+                    pass,
+                    tls,
+                    inSecure,
                     init: true,
                     ping: true,
                 },
                 'HmIP-RF': {
                     conf: 'iprf',
                     rpc: xmlrpc,
-                    port: this.isLocal ? 32010 : config.tls ? 42010 : 2010,
+                    port: this.isLocal ? 32010 : tls ? 42010 : 2010,
                     protocol: 'http',
-                    auth: config.authentication,
-                    user: config.username,
-                    pass: config.password,
-                    tls: config.tls,
-                    inSecure: config.inSecure,
+                    auth,
+                    user,
+                    pass,
+                    tls,
+                    inSecure,
                     init: true,
                     ping: true, // Todo https://github.com/eq-3/occu/issues/42 - should be fixed, but isn't
                     pingTimeout: 600, // Overwrites ccu-connection config
+                    // B-29: hmipserver forgets its clients when it restarts and does not tell them;
+                    // a ping every 30 s without an event, and init again when no PONG comes within 10 s
+                    pingInterval: 30,
+                    pongTimeout: 10,
                 },
                 VirtualDevices: {
                     conf: 'virt',
                     rpc: xmlrpc,
-                    port: this.isLocal ? 39292 : config.tls ? 49292 : 9292,
+                    port: this.isLocal ? 39292 : tls ? 49292 : 9292,
                     path: 'groups',
                     protocol: 'http',
-                    auth: config.authentication,
-                    user: config.username,
-                    pass: config.password,
-                    tls: config.tls,
-                    inSecure: config.inSecure,
+                    auth,
+                    user,
+                    pass,
+                    tls,
+                    inSecure,
                     init: true,
                     ping: false, // Todo ?
                 },
@@ -494,14 +580,14 @@ module.exports = function (RED) {
                 'CCU-Jack': {
                     conf: 'jack',
                     rpc: xmlrpc,
-                    port: Number(config.jackPort) || (config.tls ? 2122 : 2121),
+                    port: Number(config.jackPort) || (tls ? 2122 : 2121),
                     path: 'RPC3',
                     protocol: 'http',
-                    auth: config.authentication,
-                    user: config.username,
-                    pass: config.password,
-                    tls: config.tls,
-                    inSecure: config.inSecure,
+                    auth,
+                    user,
+                    pass,
+                    tls,
+                    inSecure,
                     init: true,
                     ping: false,
                 },
@@ -536,6 +622,9 @@ module.exports = function (RED) {
             // reconnecting after a CCU restart is then up to the CCU.
             this.rpcPingEnabled = config.rpcPing === undefined ? true : Boolean(config.rpcPing);
             this.rpcPingTimer = {};
+            // B-29: the liveness ping per interface, and when an event (PONG included) last arrived
+            this.liveness = {};
+            this.lastRealEvent = {};
             this.ifaceStatus = {};
             // task 11: interfaces whose init failed and is retried (InitRetry per iface),
             // and which of them are waiting for an unreachable process
@@ -553,9 +642,9 @@ module.exports = function (RED) {
             // B-17 openccu-lite: the metadata api sits behind the box's
             // lighttpd, i.e. on the plain http(s) port. The field exists for
             // reverse proxies and tests, it is empty in every normal install.
-            this.tlsEnabled = Boolean(config.tls);
-            this.inSecure = Boolean(config.inSecure);
-            this.metaPort = Number.parseInt(config.metaPort, 10) || (config.tls ? 443 : 80);
+            this.tlsEnabled = tls;
+            this.inSecure = inSecure;
+            this.metaPort = Number.parseInt(config.metaPort, 10) || (tls ? 443 : 80);
             this.metaToken = config.metaToken || metaProvider.readLocalToken();
             this.metaMode = false;
             this.meta = null;
@@ -612,6 +701,9 @@ module.exports = function (RED) {
             this.setValueThrottle = 500;
             this.setValueTimers = {};
             this.setValueCache = {};
+            // B-19: the value this connection last wrote to a datapoint, so the queued
+            // write's dedupe can tell the echo of its own write from another source
+            this.lastWrite = {};
             this.setValueQueue = [];
 
             this.lastEvent = {};
@@ -639,11 +731,11 @@ module.exports = function (RED) {
 
             this.rega = new Rega({
                 host: this.host,
-                port: this.isLocal ? 8183 : config.tls ? 48181 : 8181,
-                tls: config.tls,
-                insecure: config.inSecure,
-                username: config.authentication ? config.username : undefined,
-                password: config.authentication ? config.password : undefined,
+                port: this.isLocal ? 8183 : tls ? 48181 : 8181,
+                tls,
+                insecure: inSecure,
+                username: user,
+                password: pass,
             });
 
             this.enabledIfaces = [];
@@ -661,12 +753,15 @@ module.exports = function (RED) {
                 // metadata api. It does not on a CCU/RaspberryMatic/OpenCCU,
                 // where everything below runs exactly as before.
                 this.lastMetaProbe = now();
-                this.detectMeta()
-                    .then((info) => {
-                        if (info) {
-                            return this.startMeta(info);
+                this.detectMetaOutcome()
+                    .then((outcome) => {
+                        if (outcome.info) {
+                            return this.startMeta(outcome.info);
                         }
 
+                        // B-28: a timeout or a refused connection decides nothing -
+                        // the ReGa path starts, and the detection is repeated
+                        this.scheduleMetaRedetect(outcome);
                         return this.getRegaData().then(() => {
                             this.regaPoll();
                         });
@@ -686,6 +781,41 @@ module.exports = function (RED) {
             this.on('close', this.destructor);
         }
 
+        /**
+         * B-31: the password and the token, from the credentials or - once - from the
+         * plain properties of a flow written before 4.4.6.
+         * @param {object} config the node's configuration as deployed
+         * @returns {{password: string, metaToken: string}}
+         */
+        migrateSecrets(config) {
+            const credentials = this.credentials || {};
+            const result = {
+                password: credentials.password || config.password || '',
+                metaToken: credentials.metaToken || config.metaToken || '',
+            };
+            const plain = ['password', 'metaToken'].filter((key) => config[key] && !credentials[key]);
+            if (plain.length > 0) {
+                const moved = {...credentials};
+                plain.forEach((key) => {
+                    moved[key] = config[key];
+                });
+                if (typeof RED.nodes.addCredentials === 'function') {
+                    RED.nodes.addCredentials(this.id, moved);
+                    this.warn(
+                        'the ' +
+                            plain.join(' and ') +
+                            ' of this connection came from the flow in plain text - moved into the credentials, the next deploy removes ' +
+                            (plain.length > 1 ? 'them' : 'it') +
+                            ' from flows.json',
+                    );
+                } else {
+                    this.warn('the ' + plain.join(' and ') + ' of this connection is stored in the flow in plain text');
+                }
+            }
+
+            return result;
+        }
+
         get logger() {
             return {
                 trace: (...args) => {
@@ -807,6 +937,11 @@ module.exports = function (RED) {
          * @param connected
          */
         setIfaceStatus(iface, connected, waiting = false) {
+            if (!iface || !this.ifaceTypes[iface]) {
+                // B-32: never a status line for something that is not an interface of ours
+                return;
+            }
+
             waiting = Boolean(waiting) && !connected;
             const waitingChanged = Boolean(this.ifaceWaiting[iface]) !== waiting;
             if (this.ifaceStatus[iface] !== connected || waitingChanged) {
@@ -1115,6 +1250,8 @@ module.exports = function (RED) {
             this.logger.debug('clear regaPollTimeout');
             this.cancelRegaPoll = true;
             clearTimeout(this.regaPollTimeout);
+            clearTimeout(this.metaRedetectTimeout);
+            this.metaRedetectTimeout = null;
 
             if (this.meta) {
                 this.logger.debug('stop metadata event stream');
@@ -1126,6 +1263,7 @@ module.exports = function (RED) {
                 this.logger.debug('clear rpcPingTimer', iface);
                 clearTimeout(this.rpcPingTimer[iface]);
             });
+            Object.keys(this.liveness).forEach((iface) => this.stopLiveness(iface));
 
             this.saveRegadata();
             this.saveValues();
@@ -1214,7 +1352,17 @@ module.exports = function (RED) {
          * @returns {Promise<object|null>}
          */
         detectMeta() {
-            return metaProvider.detect({
+            return this.detectMetaOutcome().then((outcome) => outcome.info);
+        }
+
+        /**
+         * B-28: the detection with its outcome - `info` for an openccu-lite,
+         * `inconclusive` when nothing was decided (timeout, refused connection,
+         * the web server up but the api behind it not yet).
+         * @returns {Promise<{info: object|null, inconclusive: boolean, reason?: string}>}
+         */
+        detectMetaOutcome() {
+            return metaProvider.detectOutcome({
                 host: this.host,
                 port: this.metaPort,
                 tls: Boolean(this.tlsEnabled),
@@ -1223,6 +1371,81 @@ module.exports = function (RED) {
             });
         }
 
+        /**
+         * B-28: an inconclusive detection (the box busy or still starting) used
+         * to leave the connection in ReGa mode for good - the only re-detection
+         * ran from rare error paths, at most every five minutes. Ask again after
+         * 1, 2, 4, 8 s, then every 15 s, up to META_REDETECT_ATTEMPTS times;
+         * after that the five-minute rule of recheckMeta() applies.
+         * @param {{inconclusive: boolean, reason?: string}} outcome
+         */
+        scheduleMetaRedetect(outcome) {
+            if (!outcome || !outcome.inconclusive || this.metaMode || this.cancelRegaPoll) {
+                this.metaRedetectAttempt = 0;
+                return;
+            }
+
+            this.metaRedetectAttempt = (this.metaRedetectAttempt || 0) + 1;
+            if (this.metaRedetectAttempt > META_REDETECT_ATTEMPTS) {
+                this.logger.info(
+                    'meta api detection still inconclusive (' +
+                        outcome.reason +
+                        ') after ' +
+                        META_REDETECT_ATTEMPTS +
+                        ' attempts - staying with the ReGaHSS, detecting again every five minutes',
+                );
+                this.metaRedetectAttempt = 0;
+                return;
+            }
+
+            const delay = retryDelay(this.metaRedetectAttempt);
+            const line =
+                'meta api detection inconclusive (' +
+                outcome.reason +
+                ') - names come from the ReGaHSS until the box answers, detecting again in ' +
+                delay / 1000 +
+                ' s';
+            if (this.metaRedetectAttempt === 1) {
+                this.logger.info(line);
+            } else {
+                this.logger.debug(line);
+            }
+
+            clearTimeout(this.metaRedetectTimeout);
+            this.metaRedetectTimeout = setTimeout(() => this.redetectMeta(), delay);
+        }
+
+        /** B-28: one scheduled re-detection. */
+        redetectMeta() {
+            this.metaRedetectTimeout = null;
+            if (this.metaMode || this.cancelRegaPoll) {
+                return;
+            }
+
+            this.lastMetaProbe = now();
+            this.detectMetaOutcome().then((outcome) => {
+                if (this.metaMode || this.cancelRegaPoll) {
+                    return;
+                }
+
+                if (outcome.info) {
+                    this.logger.info('meta api detected after ' + (this.metaRedetectAttempt + 1) + ' attempts');
+                    this.metaRedetectAttempt = 0;
+                    return this.startMeta(outcome.info);
+                }
+
+                if (outcome.inconclusive) {
+                    this.scheduleMetaRedetect(outcome);
+                    return;
+                }
+
+                this.metaRedetectAttempt = 0;
+                this.logger.info(
+                    'not an openccu-lite (' + outcome.reason + ') - names, rooms and functions come from the ReGaHSS',
+                );
+            });
+        }
+
         /**
          * Take names, rooms and functions from the openccu-lite metadata api
          * instead of from the ReGaHSS. Resolves as soon as the first snapshot
@@ -1291,11 +1514,14 @@ module.exports = function (RED) {
                         this.meta = null;
                         this.lastMetaProbe = 0;
                         this.logger.warn('this box no longer answers as openccu-lite - detecting again');
-                        this.detectMeta().then((again) => {
-                            if (again) {
-                                return this.startMeta(again);
+                        this.detectMetaOutcome().then((outcome) => {
+                            if (outcome.info) {
+                                return this.startMeta(outcome.info);
                             }
 
+                            // B-28: an unreachable box is not a CCU yet - keep asking
+                            this.scheduleMetaRedetect(outcome);
+
                             if (this.ifaceTypes.ReGaHSS.enabled && !this.clients.ReGaHSS) {
                                 this.createClient('ReGaHSS').then(() => this.setIfaceStatus('ReGaHSS', true));
                             }
@@ -1341,7 +1567,7 @@ module.exports = function (RED) {
          * picked up without a redeploy.
          */
         recheckMeta() {
-            if (this.metaMode || this.cancelRegaPoll || this.metaRecheckPending) {
+            if (this.metaMode || this.cancelRegaPoll || this.metaRecheckPending || this.metaRedetectTimeout) {
                 return;
             }
 
@@ -1663,9 +1889,16 @@ module.exports = function (RED) {
                 this.regaPollPending = true;
                 clearTimeout(this.regaPollTimeout);
                 this.getRegaVariables()
-                    .catch((error) => this.logger.error('getRegaVariables', error))
+                    .catch((error) => {
+                        this.logger.error('getRegaVariables', error);
+                        // B-28: the poll is what fails on a box without ReGaHSS
+                        this.recheckMeta();
+                    })
                     .then(() => this.getRegaPrograms())
-                    .catch((error) => this.logger.error('getRegaPrograms', error))
+                    .catch((error) => {
+                        this.logger.error('getRegaPrograms', error);
+                        this.recheckMeta();
+                    })
                     .finally(() => {
                         if (this.regaInterval && this.regaPollEnabled && !this.cancelRegaPoll) {
                             //this.logger.trace('rega next poll in', this.regaInterval, 'seconds');
@@ -2108,6 +2341,7 @@ module.exports = function (RED) {
                         // a failed one is retried by rpcInitFailed (task 11)
                         if (this.ifaceTypes[iface].ping && !this.closing) {
                             this.rpcCheckInit(iface);
+                            this.startLiveness(iface);
                         }
 
                         if (iface === 'CUxD') {
@@ -2163,32 +2397,237 @@ module.exports = function (RED) {
                         }
 
                         const knownDevices = [];
-                        let change = false;
+                        const summary = {total: 0, added: 0, changed: 0, removed: 0};
                         devices.forEach((device) => {
+                            if (!device || typeof device.ADDRESS !== 'string' || !device.TYPE) {
+                                return;
+                            }
+
                             knownDevices.push(device.ADDRESS);
-                            if (!this.metadata.devices[iface][device.ADDRESS]) {
+                            const known = this.metadata.devices[iface][device.ADDRESS];
+                            if (!known) {
                                 this.newDevice(iface, device);
-                                change = true;
+                                summary.added += 1;
+                            } else if (deviceChanged(known, device)) {
+                                // task 9: a TYPE/VERSION change since the cache was written
+                                this.newDevice(iface, device);
+                                summary.changed += 1;
                             }
                         });
 
                         Object.keys(this.metadata.devices[iface]).forEach((addr) => {
                             if (!knownDevices.includes(addr)) {
                                 this.deleteDevice(iface, addr);
-                                change = true;
+                                summary.removed += 1;
                             }
                         });
 
-                        if (change) {
+                        summary.total = Object.keys(this.metadata.devices[iface]).length;
+                        if (summary.added || summary.changed || summary.removed) {
                             this.saveMetadata();
                         }
 
-                        resolve();
+                        resolve(summary);
                     })
                     .catch(reject);
             });
         }
 
+        /**
+         * task 9: re-read the device table of every connected interface from its
+         * process (the button in the connection node's dialog). New and changed
+         * devices get their paramset descriptions fetched, vanished ones go.
+         * @returns {Promise<object>} per interface: total, added, changed, removed - or an error text
+         */
+        rereadDevices() {
+            const ifaces = Object.keys(this.ifaceTypes).filter(
+                (iface) => this.ifaceTypes[iface].enabled && this.ifaceTypes[iface].init && iface !== 'CUxD',
+            );
+            this.logger.info('re-reading device data:', ifaces.join(', '));
+            return Promise.all(
+                ifaces.map((iface) =>
+                    this.getDevices(iface)
+                        .then((summary) => [iface, summary])
+                        .catch((error) => [iface, {error: error.message || String(error)}]),
+                ),
+            ).then((entries) => {
+                const summary = {};
+                entries.forEach(([iface, result]) => {
+                    summary[iface] = result;
+                });
+                this.logger.info('device data re-read', JSON.stringify(summary));
+                return summary;
+            });
+        }
+
+        /**
+         * B-29: the liveness ping of an interface with a `pingInterval` (HmIP-RF).
+         * hmipserver forgets its clients when it restarts and does not tell them:
+         * `init` had succeeded, so nothing failed, and the events simply stopped
+         * until the 600 s silence timeout of rpcCheckInit(). After `pingInterval`
+         * seconds without an event a `ping` goes out; when no event (the PONG)
+         * arrives within `pongTimeout` seconds the subscription is lost and `init`
+         * is called again at once - task 11's retry then covers the time the
+         * process is down. Only an event counts as proof; a device callback
+         * (newDevices after a restart) triggers the ping instead. An interface
+         * that never delivered an event since its init is not re-subscribed by
+         * this (a callback address the CCU cannot reach would cost an init, and
+         * hmipserver's full newDevices re-send, every 40 s).
+         * @param iface
+         */
+        startLiveness(iface) {
+            const {pingInterval} = this.ifaceTypes[iface] || {};
+            if (!pingInterval || !this.rpcPingEnabled || this.closing) {
+                return;
+            }
+
+            this.stopLiveness(iface);
+            this.liveness[iface] = {initAt: now(), pingAt: 0, timer: null, pongTimer: null, quietLogged: false};
+            this.scheduleLiveness(iface, pingInterval * 1000);
+        }
+
+        /** @param iface */
+        stopLiveness(iface) {
+            const state = this.liveness[iface];
+            if (state) {
+                clearTimeout(state.timer);
+                clearTimeout(state.pongTimer);
+                delete this.liveness[iface];
+            }
+        }
+
+        /**
+         * @param iface
+         * @param {number} delay ms until the next check
+         */
+        scheduleLiveness(iface, delay) {
+            const state = this.liveness[iface];
+            if (!state) {
+                return;
+            }
+
+            clearTimeout(state.timer);
+            state.timer = setTimeout(() => this.livenessCheck(iface), Math.max(delay, 100));
+        }
+
+        /** @param iface */
+        livenessCheck(iface) {
+            const state = this.liveness[iface];
+            if (!state || this.closing) {
+                return;
+            }
+
+            const {pingInterval} = this.ifaceTypes[iface];
+            const sinceEvent = now() - (this.lastRealEvent[iface] || 0);
+            if (sinceEvent < pingInterval * 1000) {
+                // events arrive: the subscription is alive, no ping needed
+                this.scheduleLiveness(iface, pingInterval * 1000 - sinceEvent);
+                return;
+            }
+
+            this.livenessPing(iface);
+        }
+
+        /** @param iface */
+        livenessPing(iface) {
+            const state = this.liveness[iface];
+            if (!state || state.pongTimer || this.closing) {
+                return;
+            }
+
+            const {pongTimeout} = this.ifaceTypes[iface];
+            clearTimeout(state.timer);
+            state.pingAt = now();
+            this.logger.debug('liveness ping', iface);
+            state.pongTimer = setTimeout(() => this.livenessPongMissing(iface), pongTimeout * 1000);
+            this.methodCall(iface, 'ping', ['nr'], {quiet: true}).catch((error) => {
+                // the process itself does not answer: no need to wait for the PONG
+                const current = this.liveness[iface];
+                if (current && current.pongTimer) {
+                    clearTimeout(current.pongTimer);
+                    current.pongTimer = null;
+                    this.livenessLost(iface, 'ping failed: ' + (error && error.message ? error.message : error));
+                }
+            });
+        }
+
+        /** the PONG did not arrive in time @param iface */
+        livenessPongMissing(iface) {
+            const state = this.liveness[iface];
+            if (!state) {
+                return;
+            }
+
+            state.pongTimer = null;
+            const {pingInterval, pongTimeout} = this.ifaceTypes[iface];
+            if (!this.lastRealEvent[iface] || this.lastRealEvent[iface] < state.initAt) {
+                // never an event since the init: do not re-subscribe on that alone
+                if (!state.quietLogged) {
+                    state.quietLogged = true;
+                    this.logger.debug(
+                        'liveness',
+                        iface,
+                        'no PONG within ' + pongTimeout + ' s and no event since init - not subscribing again',
+                    );
+                }
+
+                this.scheduleLiveness(iface, pingInterval * 1000);
+                return;
+            }
+
+            this.livenessLost(iface, 'no answer to a ping within ' + pongTimeout + ' s');
+        }
+
+        /**
+         * The subscription is lost: init again at once.
+         * @param iface
+         * @param {string} reason
+         */
+        livenessLost(iface, reason) {
+            if (!this.liveness[iface] || this.closing) {
+                return;
+            }
+
+            this.stopLiveness(iface);
+            this.logger.warn(iface + ': ' + reason + ' - subscribing again');
+            this.hadTimeout.add(iface);
+            this.setIfaceStatus(iface, false, true);
+            this.rpcInit(iface)
+                .then(() => {
+                    this.logger.info(iface + ' subscribed again');
+                    this.rpcInitSucceeded(iface);
+                })
+                .catch((error) => this.rpcInitFailed(iface, error));
+        }
+
+        /**
+         * An event arrived (PONG included): the subscription delivers.
+         * @param iface
+         */
+        livenessEvent(iface) {
+            this.lastRealEvent[iface] = now();
+            const state = this.liveness[iface];
+            if (state && state.pongTimer) {
+                clearTimeout(state.pongTimer);
+                state.pongTimer = null;
+                this.scheduleLiveness(iface, this.ifaceTypes[iface].pingInterval * 1000);
+            }
+        }
+
+        /**
+         * A device callback (newDevices, deleteDevices, ...) arrived. After a
+         * restart hmipserver sends newDevices to the read-back handler about
+         * 16 s in, before any event: ask for the PONG at once instead of
+         * waiting for the interval.
+         * @param iface
+         */
+        deviceCallback(iface) {
+            const state = this.liveness[iface];
+            if (state && !state.pongTimer && !this.closing) {
+                this.livenessPing(iface);
+            }
+        }
+
         /**
          *
          * @param iface
@@ -2198,15 +2637,21 @@ module.exports = function (RED) {
                 return;
             }
 
-            if (!this.metadata.devices[iface] || !Object.keys(this.metadata.devices[iface]).length > 0) {
-                return;
-            }
+            // task 9 (old B-11): the watchdog used to return here for an interface without
+            // devices in the cache, so such an interface never pinged and never re-initialised
+            // after a CCU reboot. It pings now; it re-initialises only when the interface has
+            // devices or has ever delivered an event (a PONG counts) - a process that answers
+            // no ping at all is not asked to init every timeout.
+            const hasDevices = Boolean(
+                this.metadata.devices[iface] && Object.keys(this.metadata.devices[iface]).length > 0,
+            );
+            const mayReinit = hasDevices || Boolean(this.lastRealEvent[iface]);
 
             clearTimeout(this.rpcPingTimer[iface]);
             const pingTimeout = this.ifaceTypes[iface].pingTimeout || this.rpcPingTimeout;
             const elapsed = Math.round((now() - (this.lastEvent[iface] || 0)) / 1000);
             this.logger.debug('rpcCheckInit', iface, elapsed, pingTimeout);
-            if (elapsed > pingTimeout) {
+            if (elapsed > pingTimeout && mayReinit) {
                 this.hadTimeout.add(iface);
                 this.setIfaceStatus(iface, false);
                 this.logger.warn('ping timeout', iface, elapsed);
@@ -2358,12 +2803,10 @@ module.exports = function (RED) {
                         }
 
                         this.logger.debug('rpc <', protocol, method, JSON.stringify(parameters));
-                        if (method === 'event') {
-                            method = 'eventSingle';
-                        }
+                        const handler = method === 'event' ? 'eventSingle' : method;
 
                         if (isIterable(parameters)) {
-                            this.rpcMethods[method](err, parameters, callback);
+                            this.callRpcMethod(handler, err, parameters, callback);
                         } else {
                             this.logger.error(
                                 'rpc <',
@@ -2373,7 +2816,7 @@ module.exports = function (RED) {
                                 'params not iterable',
                                 JSON.stringify(parameters),
                             );
-                            callback(null, '');
+                            callback(null, this.rpcDefaultAnswer(method));
                         }
                     });
                 });
@@ -2558,7 +3001,29 @@ module.exports = function (RED) {
                 this.metadata.types[iface] = {};
             }
 
-            if (this.metadata.devices[iface][device.ADDRESS]) {
+            const known = this.metadata.devices[iface][device.ADDRESS];
+            if (known && deviceChanged(known, device)) {
+                // task 9 (#146, #181): a channel whose TYPE (or the device's VERSION/FIRMWARE)
+                // changed in place kept its old datapoints; the paramset key changes with
+                // it, so the description is fetched anew below, and the old type list
+                // forgets the address
+                this.logger.info(
+                    'device data changed',
+                    iface,
+                    device.ADDRESS,
+                    known.TYPE + '/' + (known.FIRMWARE || '-') + '/' + (known.VERSION || '-'),
+                    '->',
+                    device.TYPE + '/' + (device.FIRMWARE || '-') + '/' + (device.VERSION || '-'),
+                );
+                if (this.metadata.types[iface][known.TYPE]) {
+                    this.metadata.types[iface][known.TYPE] = this.metadata.types[iface][known.TYPE].filter(
+                        (addr) => addr !== device.ADDRESS,
+                    );
+                    if (this.metadata.types[iface][known.TYPE].length === 0) {
+                        delete this.metadata.types[iface][known.TYPE];
+                    }
+                }
+            } else if (known) {
                 this.logger.trace('newDevice (already known)', iface, device.ADDRESS);
             } else {
                 this.logger.debug('newDevice', iface, device.ADDRESS);
@@ -2607,10 +3072,11 @@ module.exports = function (RED) {
             if (this.metadata.devices[iface]) {
                 Object.keys(this.metadata.devices[iface]).forEach((addr) => {
                     const dev = this.metadata.devices[iface][addr];
-                    if (dev.TYPE === 'HmIP-RCV-50' || dev.PARENT_TYPE === 'HmIP-RCV-50') {
-                        // Würgaround for Firmware 3.43.15
-                        return;
-                    }
+                    // The CCU's own virtual remote control (HmIP-RCV-1, type HmIP-RCV-50) is listed
+                    // like any other device. It was left out since CCU3 firmware 3.43.15 (2019),
+                    // whose hmipserver failed on an answer that held it; current hmipservers do
+                    // not, and without it every init made hmipserver log a handleIDMigration
+                    // warning and send the whole virtual remote again with newDevices (task 13).
 
                     if (dev.TYPE === 'MULTI_MODE_INPUT_TRANSMITTER') {
                         //this.paramsQueuePush(iface, dev);
@@ -2684,98 +3150,208 @@ module.exports = function (RED) {
          * @returns {*}
          */
         getIfaceFromIdInit(idInit) {
+            if (typeof idInit !== 'string') {
+                return null;
+            }
+
             if (idInit === 'CUxD') {
                 return idInit;
             }
 
             const match = idInit.match(/^nr_[\da-zA-Z]{6}_([a-zA-Z-]+)$/);
-            return match && match[1];
+            return match && this.ifaceTypes[match[1]] ? match[1] : null;
+        }
+
+        /**
+         * B-32: the interface a callback call belongs to, or null with a debug line when the
+         * first parameter is not one of our own init ids. Anything on the system can connect
+         * to the callback ports on the loopback; such a call is answered, never thrown on.
+         * @param {string} method
+         * @param {Array} parameters
+         * @returns {string|null}
+         */
+        rpcIface(method, parameters) {
+            const [idInit] = parameters;
+            const iface = this.getIfaceFromIdInit(idInit);
+            if (!iface) {
+                this.logger.debug('rpc <', method, 'unknown interface id', JSON.stringify(idInit));
+            }
+
+            return iface;
+        }
+
+        /**
+         * B-32: what a callback call is answered with when it cannot be handled.
+         * @param {string} method
+         * @returns {Array|string}
+         */
+        rpcDefaultAnswer(method) {
+            if (method === 'system.listMethods') {
+                return Object.keys(this.rpcMethods);
+            }
+
+            if (method === 'listDevices' || method === 'system.multicall') {
+                return [];
+            }
+
+            return '';
+        }
+
+        /**
+         * B-32: run a callback handler so that a throw inside it is logged and answered
+         * instead of ending the process (the RPC servers call us from an event emitter,
+         * so an exception there is uncaught). The callback is answered exactly once.
+         * @param {string} method the key in rpcMethods
+         * @param {*} err
+         * @param {Array} parameters
+         * @param {function} callback
+         */
+        callRpcMethod(method, err, parameters, callback) {
+            let answered = false;
+            const answer = (error, result) => {
+                if (!answered) {
+                    answered = true;
+                    callback(error, result);
+                }
+            };
+
+            try {
+                this.rpcMethods[method](err, parameters, answer);
+            } catch (error) {
+                this.logger.error(
+                    'rpc <',
+                    method,
+                    'failed:',
+                    error && error.message ? error.message : String(error),
+                    JSON.stringify(parameters),
+                );
+                answer(null, this.rpcDefaultAnswer(method === 'eventSingle' ? 'event' : method));
+            }
         }
 
         get rpcMethods() {
             return {
                 'system.listMethods': (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
-                    this.lastEvent[iface] = now();
-                    this.setIfaceStatus(iface, true);
+                    const iface = this.rpcIface('system.listMethods', parameters);
                     const res = Object.keys(this.rpcMethods);
+                    if (iface) {
+                        this.lastEvent[iface] = now();
+                        this.setIfaceStatus(iface, true);
+                    }
+
                     this.logger.debug('    >', iface, 'system.listMethods', JSON.stringify(res));
                     callback(null, res);
                 },
                 setReadyConfig: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('setReadyConfig', parameters);
                     this.logger.debug('    >', iface, 'setReadyConfig ""');
                     callback(null, '');
                 },
                 updateDevice: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('updateDevice', parameters);
                     this.logger.debug('    >', iface, 'updateDevice ""');
                     callback(null, '');
+                    if (iface) {
+                        this.deviceCallback(iface);
+                    }
                 },
                 replaceDevice: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('replaceDevice', parameters);
                     this.logger.debug('    >', iface, 'replaceDevice ""');
                     callback(null, '');
+                    if (iface) {
+                        this.deviceCallback(iface);
+                    }
                 },
                 readdedDevice: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('readdedDevice', parameters);
                     this.logger.debug('    >', iface, 'readdedDevice ""');
                     callback(null, '');
+                    if (iface) {
+                        this.deviceCallback(iface);
+                    }
                 },
                 newDevices: (_, parameters, callback) => {
-                    const [idInit, devices] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const [, devices] = parameters;
+                    const iface = this.rpcIface('newDevices', parameters);
 
-                    devices.forEach((device) => {
-                        this.newDevice(iface, device);
-                    });
+                    let changed = false;
+                    if (iface && Array.isArray(devices)) {
+                        devices.forEach((device) => {
+                            if (device && typeof device.ADDRESS === 'string' && device.TYPE) {
+                                this.newDevice(iface, device);
+                                changed = true;
+                            } else {
+                                this.logger.warn(
+                                    'newDevices',
+                                    iface,
+                                    'skipping malformed entry',
+                                    JSON.stringify(device),
+                                );
+                            }
+                        });
+                    }
 
                     this.logger.debug('    >', iface, 'newDevices ""');
                     callback(null, '');
 
-                    this.saveMetadata();
+                    if (changed) {
+                        this.saveMetadata();
+                    }
+
+                    if (iface) {
+                        this.deviceCallback(iface);
+                    }
                 },
                 deleteDevices: (_, parameters, callback) => {
-                    const [idInit, devices] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const [, devices] = parameters;
+                    const iface = this.rpcIface('deleteDevices', parameters);
 
-                    devices.forEach((device) => {
-                        this.deleteDevice(iface, device);
-                    });
+                    let changed = false;
+                    if (iface && Array.isArray(devices) && this.metadata.devices[iface]) {
+                        devices.forEach((device) => {
+                            if (typeof device === 'string' && this.metadata.devices[iface][device]) {
+                                this.deleteDevice(iface, device);
+                                changed = true;
+                            }
+                        });
+                    }
 
                     this.logger.debug('    >', iface, 'deleteDevices ""');
                     callback(null, '');
 
-                    this.saveMetadata();
+                    if (changed) {
+                        this.saveMetadata();
+                    }
+
+                    if (iface) {
+                        this.deviceCallback(iface);
+                    }
                 },
                 listDevices: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
-                    this.lastEvent[iface] = now();
-                    this.setIfaceStatus(iface, true);
-                    const res = this.listDevices(iface) || [];
+                    const iface = this.rpcIface('listDevices', parameters);
+                    let res = [];
+                    if (iface) {
+                        this.lastEvent[iface] = now();
+                        this.setIfaceStatus(iface, true);
+                        res = this.listDevices(iface) || [];
+                    }
+
                     this.logger.debug('    >', iface, 'listDevices', JSON.stringify(res));
                     callback(null, res);
                 },
                 event: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('event', parameters);
                     this.logger.debug('    >', iface, 'event ""');
                     this.publishEvent(parameters);
                     callback(null, '');
                 },
                 eventSingle: (_, parameters, callback) => {
-                    const [idInit] = parameters;
-                    const iface = this.getIfaceFromIdInit(idInit);
+                    const iface = this.rpcIface('event', parameters);
                     this.logger.debug('    >', iface, 'event ""');
                     this.publishEvent(parameters);
 
-                    if (parameters[2] !== 'PONG') {
+                    if (iface && parameters[2] !== 'PONG') {
                         if (this.rxCounters[iface]) {
                             this.rxCounters[iface] += 1;
                         } else {
@@ -2796,8 +3372,8 @@ module.exports = function (RED) {
                     if (isIterable(parameters[0])) {
                         parameters[0].forEach((call) => {
                             if (call && call.methodName === 'event') {
-                                queue.push(call);
                                 if (isIterable(call.params)) {
+                                    queue.push(call);
                                     const [idInit, , datapoint, value] = call.params;
                                     if (datapoint !== 'PONG') {
                                         pong = false;
@@ -2819,16 +3395,32 @@ module.exports = function (RED) {
                                         }
                                     }
 
-                                    iface = this.getIfaceFromIdInit(idInit);
+                                    iface = this.getIfaceFromIdInit(idInit) || iface;
+                                } else {
+                                    this.logger.debug(
+                                        'rpc <',
+                                        'event',
+                                        'params not iterable',
+                                        JSON.stringify(call.params),
+                                    );
                                 }
 
                                 result.push('');
-                            } else if (call && this.rpcMethods[call.methodName]) {
+                            } else if (
+                                call &&
+                                call.methodName !== 'system.multicall' &&
+                                this.rpcMethods[call.methodName]
+                            ) {
                                 pong = false;
                                 if (isIterable(call.params)) {
-                                    this.rpcMethods[call.methodName](call.methodName, call.params, (_, res) =>
-                                        result.push(res),
-                                    );
+                                    let answered = false;
+                                    this.callRpcMethod(call.methodName, null, call.params, (_, res) => {
+                                        answered = true;
+                                        result.push(res);
+                                    });
+                                    if (!answered) {
+                                        result.push(this.rpcDefaultAnswer(call.methodName));
+                                    }
                                 } else {
                                     this.logger.error(
                                         'rpc <',
@@ -2836,7 +3428,11 @@ module.exports = function (RED) {
                                         'params not iterable',
                                         JSON.stringify(call.params),
                                     );
+                                    result.push(this.rpcDefaultAnswer(call.methodName));
                                 }
+                            } else {
+                                // B-32: an unknown or nested method keeps the answer's shape
+                                result.push('');
                             }
                         });
                         queue.forEach((call) => {
@@ -3063,7 +3659,14 @@ module.exports = function (RED) {
             const [idInit, channel, datapoint, payload] = parameters;
             const iface = this.getIfaceFromIdInit(idInit);
 
+            if (!iface || typeof channel !== 'string' || typeof datapoint !== 'string') {
+                // B-32: not one of our interfaces, or not an event's shape - nothing to publish
+                this.logger.debug('rpc <', 'event', 'ignored', JSON.stringify(parameters));
+                return;
+            }
+
             this.lastEvent[iface] = now();
+            this.livenessEvent(iface);
             if (this.hadTimeout.has(iface)) {
                 this.setIfaceStatus(iface, true);
             }
@@ -3371,7 +3974,14 @@ module.exports = function (RED) {
                 const datapointName = iface + '.' + address + '.' + datapoint;
                 const currentValue = this.values[datapointName] && this.values[datapointName].value;
                 const cache = this.values[datapointName] && this.values[datapointName].cache;
-                if (force || value !== currentValue || cache || datapoint.startsWith('PRESS_')) {
+                // B-19: a cached value that is the echo of our own last write does not
+                // prove the actuator is there - a blind moved by hand keeps its control
+                // channel's set point (#151). Only a value from another source dedupes:
+                // one that differs from what we wrote last, or one reported before it.
+                const lastWrite = this.lastWrite[datapointName];
+                const cachedTs = this.values[datapointName] && this.values[datapointName].ts;
+                const ownEcho = Boolean(lastWrite) && lastWrite.value === currentValue && cachedTs > lastWrite.ts;
+                if (force || value !== currentValue || cache || ownEcho || datapoint.startsWith('PRESS_')) {
                     this.setValueQueue.push({iface, address, datapoint, value, burst, resolve, reject});
                     this.setValueShiftQueue();
                 } else {
@@ -3433,8 +4043,16 @@ module.exports = function (RED) {
          * @returns {Promise<any>}
          */
         setValue(iface, address, datapoint, value, burst) {
+            this.lastWrite[iface + '.' + address + '.' + datapoint] = {value, ts: now()};
             const device = this.metadata.devices[iface] && this.metadata.devices[iface][address];
             const description = this.paramsetDescriptions[this.paramsetName(iface, device, 'VALUES')];
+            if (isPartyWrite(datapoint, description)) {
+                // an HmIP thermostat takes PARTY_TIME_START, PARTY_TIME_END and
+                // PARTY_SET_POINT_TEMPERATURE only together - one alone resets the
+                // other two (#156, #161): write all three in one putParamset
+                return this.setPartyValues(iface, address, datapoint, value);
+            }
+
             const combined = combinedParameterValue(datapoint, value, description);
             if (combined !== null) {
                 // HmIP actuators accept but ignore a lone LEVEL_2 write; the CCU
@@ -3477,6 +4095,80 @@ module.exports = function (RED) {
             });
         }
 
+        /**
+         * Party mode on an HmIP thermostat (task 2, #156, #161): the written
+         * datapoint merged with the current values of the other two - our own
+         * last write when it is newer than the cache, else the cached value,
+         * else the values read from the interface process (hmipserver answers
+         * getParamset from its own state) - into one putParamset on VALUES.
+         * @param {string} iface
+         * @param {string} address the channel
+         * @param {string} datapoint the one being written
+         * @param {*} value
+         * @returns {Promise<any>}
+         */
+        setPartyValues(iface, address, datapoint, value) {
+            const current = {};
+            for (const name of PARTY_DATAPOINTS) {
+                if (name === datapoint) {
+                    continue;
+                }
+
+                const key = iface + '.' + address + '.' + name;
+                const cached = this.values[key];
+                const written = this.lastWrite[key];
+                if (written && (!cached || !(cached.ts > written.ts))) {
+                    current[name] = written.value;
+                } else if (cached && cached.value !== undefined) {
+                    current[name] = cached.value;
+                }
+            }
+
+            let merged = mergePartyValues(datapoint, value, current);
+            const read =
+                merged.missing.length > 0
+                    ? this.methodCall(iface, 'getParamset', [address, 'VALUES']).then((values) => {
+                          merged.missing.forEach((name) => {
+                              if (values && values[name] !== undefined) {
+                                  current[name] = values[name];
+                              }
+                          });
+                          merged = mergePartyValues(datapoint, value, current);
+                      })
+                    : Promise.resolve();
+
+            return read.then(() => {
+                if (merged.missing.length > 0) {
+                    throw new Error(
+                        'party mode: no current value for ' +
+                            merged.missing.join(', ') +
+                            ' on ' +
+                            iface +
+                            ' ' +
+                            address,
+                    );
+                }
+
+                const parameters = {};
+                Object.keys(merged.values).forEach((name) => {
+                    parameters[name] = this.paramCast(iface, address, 'VALUES', name, merged.values[name]);
+                    this.lastWrite[iface + '.' + address + '.' + name] = {value: merged.values[name], ts: now()};
+                });
+                this.logger.debug('setValue', datapoint, value, '-> putParamset VALUES', JSON.stringify(parameters));
+                return this.methodCall(iface, 'putParamset', [address, 'VALUES', parameters]).catch((error) => {
+                    this.logger.error(
+                        'rpc >',
+                        iface,
+                        'putParamset',
+                        JSON.stringify([address, 'VALUES', parameters]),
+                        '<',
+                        error,
+                    );
+                    throw error;
+                });
+            });
+        }
+
         /**
          *
          * @param id
@@ -3540,5 +4232,10 @@ module.exports = function (RED) {
         }
     }
 
-    RED.nodes.registerType('ccu-connection', CcuConnectionNode, {});
+    RED.nodes.registerType('ccu-connection', CcuConnectionNode, {
+        credentials: {
+            password: {type: 'password'},
+            metaToken: {type: 'password'},
+        },
+    });
 };