hm2mqtt 3.5.0 → 3.5.2

package/index.js

@@ -149,11 +149,17 @@ const renderSysvarStatus = compileTemplate(config.topicSysvarStatus);
 const renderSysvarSet = compileTemplate(config.topicSysvarSet);
 const renderProgramStatus = compileTemplate(config.topicProgramStatus);
 const renderProgramSet = compileTemplate(config.topicProgramSet);
-/** what the plain mirror tree calls an item: the status topic without the `<name>/status/` head */
+/** the literal part of the status template - what every rendered status topic starts with */
+const statusLiteral = subscribePattern(config.topicStatus, topicFields).replace(/#$/, '');
+/** what the plain mirror tree calls an item: the status topic without the template's literal head */
 const plainItem = (topic) => {
-    const head = `${config.name}/status/`;
-    return topic.startsWith(head) ? topic.slice(head.length) : topic;
+    const remainder = templateRemainder(config.topicStatus, topic, topicFields);
+    return remainder === null || remainder === '' ? topic : remainder;
 };
+/** the set subscriptions that leave `<name>/set/` and therefore need a listen pattern */
+const listenPatterns = [...new Set([config.topicSet, config.topicSysvarSet, config.topicProgramSet])]
+    .map((template) => subscribePattern(template, topicFields))
+    .filter((pattern) => !pattern.startsWith(`${config.name}/set/`));
 const adapter = createAdapter({
     pkg,
     config,
@@ -190,12 +196,7 @@ const adapter = createAdapter({
      * the index is keyed by.
      */
     onSet: (parts, value, topic) => handleSetTopic(topic, value),
-    listen: Object.fromEntries(
-        [...new Set([config.topicSet, config.topicSysvarSet, config.topicProgramSet])]
-            .map((template) => subscribePattern(template, topicFields))
-            .filter((pattern) => !pattern.startsWith(`${config.name}/set/`))
-            .map((pattern) => [pattern, handleSetTopic]),
-    ),
+    listen: Object.fromEntries(listenPatterns.map((pattern) => [pattern, handleSetTopic])),
     subscriptions: {
         'paramset/#': handleParamset,
         ...(config.rpcTopics ? {'rpc/+/+/+': handleRpc} : {}),
@@ -205,6 +206,21 @@ const adapter = createAdapter({
 });
 const {log, pubStatus} = adapter;
 
+for (const warning of config.$warnings || []) {
+    log.warn(warning);
+}
+if (config.topicStatus === config.topicSet) {
+    log.warn('--topic-status and --topic-set are identical: every own publication would come back as a set');
+}
+for (const pattern of listenPatterns) {
+    const literal = pattern.replace(/#$/, '');
+    if (statusLiteral.startsWith(literal)) {
+        log.warn(
+            `the set subscription ${pattern} also matches the status topics under ${statusLiteral} - own publications there are ignored`,
+        );
+    }
+}
+
 /*
  * Running on the CCU itself, the interface processes are on loopback and the familiar
  * 2000/2001/2010/9292/8181 are only lighttpd proxies in front of them: an extra hop, XML over HTTP
@@ -212,7 +228,9 @@ const {log, pubStatus} = adapter;
  * default we probe, because node-red-contrib-ccu's config-file check stopped working on current
  * firmware (see lib/interfaces.js).
  */
-const localMode = config.local === undefined ? await detectLocal(host) : Boolean(config.local);
+// an explicit --ccu-tls is a tunnel or a proxy by definition - local mode would silently drop the
+// TLS and the ports the user asked for, so it is never probed into, only chosen with --local
+const localMode = config.local === undefined ? !config.ccuTls && (await detectLocal(host)) : Boolean(config.local);
 if (localMode) {
     log.info('local mode: BidCos over binrpc (32001/32000), hmipserver on 32010, ReGa on 8183');
 }
@@ -560,11 +578,21 @@ async function handleSetTopic(topic, value) {
     }
     let target = topicIndex.get(topic);
     if (!target) {
-        const remainder = templateRemainder(config.topicSet, topic, topicFields);
+        // the reserved namespace stays positional whatever the template says: the address form,
+        // the rega commands and the sysvar/program names below <name>/set/ keep working
+        const head = `${config.name}/set/`;
+        const remainder = topic.startsWith(head)
+            ? topic.slice(head.length)
+            : templateRemainder(config.topicSet, topic, topicFields);
         const positional = remainder === null ? null : remainder.split('/').filter(Boolean);
         target = positional && positional.length > 0 ? resolveSet(positional, lookup) : null;
     }
     if (!target) {
+        // a set subscription that overlaps the status tree (a template whose literal part ends
+        // above it) delivers our own publications here - those are not errors
+        if (statusLiteral && topic.startsWith(statusLiteral)) {
+            return;
+        }
         throw new Error('unknown channel, variable or program');
     }
     switch (target.kind) {

package/lib/hadiscovery.js

@@ -147,17 +147,29 @@ function deviceBlock({iface, device, list, ctx, t, st, cmd, bridgeId, ignored})
 
     for (const ch of channels) {
         const consumed = new Set();
-        const e = (dp, platform, label, more = {}) =>
-            entity({
+        const e = (dp, platform, label, more = {}) => {
+            const built = entity({
                 id,
                 name,
-                item: ctx.statusTopicFor(iface, ch.ADDRESS, dp),
+                item: `${ch.index}/${dp}`,
                 platform,
                 label,
                 uid: `${ch.index}_${dp}`,
                 jsonPayloads: json,
                 ...more,
             });
+            // The topics are whole, rendered from the configured templates. entity() composes
+            // <name>/status|set/<item> for a core-style item, so exactly its composed values are
+            // replaced here; an explicit stat_t/cmd_t from `extra` and the stateless platforms
+            // (which get none) stay as they are.
+            if (built.stat_t === `${name}/status/${ch.index}/${dp}`) {
+                built.stat_t = own(dp);
+            }
+            if (built.cmd_t === `${name}/set/${ch.index}/${dp}`) {
+                built.cmd_t = scmd(dp);
+            }
+            return built;
+        };
         const fallback = ch.index === 0 ? 'Maintenance' : `Channel ${ch.index}`;
         const label = labelOf(ch, deviceName, fallback);
         const has = (dp) => Boolean(ch.description[dp]) && !ignored(iface, ch.ADDRESS, dp);

package/lib/interfaces.js

@@ -180,10 +180,8 @@ export async function detectLocal(host, {timeout = 500, connect = portOpen} = {}
         return false;
     }
     const ports = INTERFACE_NAMES.map((name) => INTERFACES[name].localPort).filter(Boolean);
-    for (const port of [...ports, REGA_LOCAL_PORT]) {
-        if (await connect(host, port, timeout)) {
-            return true;
-        }
-    }
-    return false;
+    // concurrently: this runs at every startup, and closed-but-filtered ports would otherwise
+    // stack their timeouts
+    const results = await Promise.all([...ports, REGA_LOCAL_PORT].map((port) => connect(host, port, timeout)));
+    return results.some(Boolean);
 }

package/lib/topics.js

@@ -17,11 +17,6 @@ export const DEFAULT_TOPIC_SYSVAR_SET = '${prefix}/set/${name}';
 export const DEFAULT_TOPIC_PROGRAM_STATUS = '${prefix}/status/${name}';
 export const DEFAULT_TOPIC_PROGRAM_SET = '${prefix}/set/${name}';
 
-/** The item part of the classic topics, kept for `--item-template` and for the plain mirror tree. */
-export const DEFAULT_ITEM_TEMPLATE = '${channelName|channel}/${datapoint}';
-export const DEFAULT_SYSVAR_ITEM_TEMPLATE = '${name}';
-export const DEFAULT_PROGRAM_ITEM_TEMPLATE = '${name}';
-
 /** first topic levels an adapter uses itself; a channel or variable with such a name gets a suffix */
 export const RESERVED = new Set(['counter', 'interface', 'rega', 'paramset', 'rpc', 'response']);
 
@@ -266,25 +261,52 @@ export function templateRemainder(template, topic, fields = {}) {
     return topic.startsWith(literal) ? topic.slice(literal.length) : null;
 }
 
+const kebab = (name) => name.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
+
 /**
  * `--item-template` and its two siblings named the part after `<name>/status/`. They still work:
  * an item template becomes the corresponding pair of topic templates, so an existing config keeps
- * publishing exactly where it did.
+ * publishing exactly where it did. A topic template the user changed wins over the deprecated
+ * option; either way the migration explains itself in `config.$warnings`.
  * @param {object} config
  * @returns {object} the same config, with the topic templates filled in
  */
 export function applyItemTemplates(config) {
     const pairs = [
-        ['itemTemplate', 'topicStatus', 'topicSet'],
-        ['sysvarItemTemplate', 'topicSysvarStatus', 'topicSysvarSet'],
-        ['programItemTemplate', 'topicProgramStatus', 'topicProgramSet'],
+        ['itemTemplate', 'topicStatus', DEFAULT_TOPIC_STATUS, 'topicSet', DEFAULT_TOPIC_SET],
+        [
+            'sysvarItemTemplate',
+            'topicSysvarStatus',
+            DEFAULT_TOPIC_SYSVAR_STATUS,
+            'topicSysvarSet',
+            DEFAULT_TOPIC_SYSVAR_SET,
+        ],
+        [
+            'programItemTemplate',
+            'topicProgramStatus',
+            DEFAULT_TOPIC_PROGRAM_STATUS,
+            'topicProgramSet',
+            DEFAULT_TOPIC_PROGRAM_SET,
+        ],
     ];
-    for (const [item, status, set] of pairs) {
+    for (const [item, status, statusDefault, set, setDefault] of pairs) {
         if (!config[item]) {
             continue;
         }
-        config.$deprecated = config.$deprecated || [];
-        config.$deprecated.push(item);
+        config.$warnings = config.$warnings || [];
+        const changed = [
+            [status, statusDefault],
+            [set, setDefault],
+        ]
+            .filter(([key, fallback]) => config[key] !== fallback)
+            .map(([key]) => '--' + kebab(key));
+        if (changed.length > 0) {
+            config.$warnings.push(
+                `--${kebab(item)} is deprecated and ignored here because ${changed.join(' and ')} ${changed.length > 1 ? 'are' : 'is'} set`,
+            );
+            continue;
+        }
+        config.$warnings.push(`--${kebab(item)} is deprecated - use --${kebab(status)} and --${kebab(set)}`);
         config[status] = '${prefix}/status/' + config[item];
         config[set] = '${prefix}/set/' + config[item];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hm2mqtt",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "Interface between Homematic CCU and MQTT",
   "type": "module",
   "main": "index.js",

package/scripts/addon-api.js

@@ -9,7 +9,6 @@
  *   node scripts/addon-api.js discover   [--timeout 4000]
  *   node scripts/addon-api.js probe      --host 127.0.0.1 [--tls]
  *   node scripts/addon-api.js mqtt-test  --url mqtt://host:1883 [--username u] [--password p]
- *   node scripts/addon-api.js channels   --host 127.0.0.1 [--limit 20]
  *   node scripts/addon-api.js preview    --host 127.0.0.1 --template '${prefix}/status/${channelName|channel}/${datapoint}' [--prefix hm]
  *
  * Errors are JSON too ({"error": "..."}), so the UI never has to parse a stack trace.
@@ -17,7 +16,7 @@
 
 import Rega from 'homematic-rega';
 import {discover} from 'mqtt-interfaces-core';
-import {probeInterfaces, detectLocal, INTERFACE_NAMES} from '../lib/interfaces.js';
+import {probeInterfaces, detectLocal, isLocalHost, regaPort, INTERFACE_NAMES} from '../lib/interfaces.js';
 import {discoveryHint, interfacesOf} from '../lib/discovery.js';
 import {compileTemplate, DEFAULT_TOPIC_STATUS} from '../lib/topics.js';
 
@@ -53,10 +52,9 @@ const args = parseArgs(rest);
  * @returns {Rega}
  */
 function rega({host = '127.0.0.1', port, username, password} = {}) {
-    const local = host === '127.0.0.1' || host === 'localhost';
     return new Rega({
         host,
-        port: port ? Number(port) : local ? 8183 : 8181,
+        port: port ? Number(port) : regaPort({local: isLocalHost(host)}),
         username,
         password,
         translate: false,
@@ -117,15 +115,6 @@ const commands = {
         }
     },
 
-    async channels() {
-        const limit = Number(args.limit || 20);
-        const channels = await rega(args).getChannels();
-        return {
-            count: channels.length,
-            channels: channels.slice(0, limit).map(({address, name}) => ({address, name})),
-        };
-    },
-
     async preview() {
         const template = String(args.template || DEFAULT_TOPIC_STATUS);
         const prefix = String(args.prefix || 'hm');