smart-home-engine 1.20.0 → 1.20.2

package/dist/web/assets/{tsMode-Dbzvu1EX.js → tsMode-wYM5jYsY.js}

@@ -1,4 +1,4 @@
-import{m as O}from"./monaco-langs-Dt8a9eeo.js";import{t as I}from"./index-BUev42o8.js";/*!-----------------------------------------------------------------------------
+import{m as O}from"./monaco-langs-Dt8a9eeo.js";import{t as I}from"./index-C31bVgVn.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

package/dist/web/index.html

@@ -172,10 +172,10 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-BUev42o8.js"></script>
+      <script type="module" crossorigin src="/assets/index-C31bVgVn.js"></script>
       <link rel="modulepreload" crossorigin href="/assets/monaco-langs-Dt8a9eeo.js">
       <link rel="stylesheet" crossorigin href="/assets/monaco-langs-DyX1CsEw.css">
-      <link rel="stylesheet" crossorigin href="/assets/index-nf1nG74s.css">
+      <link rel="stylesheet" crossorigin href="/assets/index-CjRDTePT.css">
     </head>
     <body>
         <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-home-engine",
-    "version": "1.20.0",
+    "version": "1.20.2",
     "description": "Node.js based script runner for use in MQTT based Smart Home environments",
     "main": "src/index.js",
     "scripts": {

package/src/index.js

@@ -498,6 +498,28 @@ if (config.url) {
 
         if (shedb.handleMqttMessage(topic, payload)) return;
 
+        // An empty payload deletes the topic from the state store (mqtt-smarthome
+        // convention; also how a retained message is cleared per MQTT spec). The
+        // retain flag cannot be used to detect this: MQTT 3.1.1 brokers clear it
+        // when forwarding to established subscriptions, so a retained-clear
+        // arrives here as a plain empty message. Previously an empty payload was
+        // stored as { val: NaN }, so the MQTT tab kept showing cleared topics.
+        // Subscription callbacks are still dispatched (empty publishes are also
+        // used as plain triggers) with val '' — only the stored state is dropped.
+        if (payload.length === 0) {
+            const emptyOld = store.getObject('mqtt::' + topic) || {};
+            if (store.delete('mqtt::' + topic)) {
+                log.debug('empty payload, removed topic from state store:', topic);
+            }
+            const delArr = topic.split('/');
+            if (delArr[0] === config.variablePrefix && delArr[1] === 'status') {
+                store.delete('var::' + delArr.slice(2).join('/'));
+            }
+            const ts = new Date().getTime();
+            stateChange(topic, { val: '', ts, lc: ts }, emptyOld, msg);
+            return;
+        }
+
         const state = require('./lib/parse-payload')(payload);
 
         const topicArr = topic.split('/');

package/src/influx.js

@@ -6,6 +6,10 @@ let _mode = null; // 'v1' | 'v2' | null
 
 const V1_TIMEOUT_MS = 10000;
 
+function v1Timeout() {
+    return Number(_opts.timeout) || V1_TIMEOUT_MS;
+}
+
 /**
  * Initialise the InfluxDB client.  Called from index.js when config.influx is set.
  *
@@ -119,7 +123,7 @@ async function v1Write(lines) {
         method: 'POST',
         headers: v1Headers(),
         body: lines,
-        signal: AbortSignal.timeout(V1_TIMEOUT_MS),
+        signal: AbortSignal.timeout(v1Timeout()),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
@@ -139,7 +143,7 @@ async function v1Query(q) {
     const params = new URLSearchParams({ db: _opts.database, q, epoch: 'ms' });
     const res = await fetch(`${_opts.url.replace(/\/$/, '')}/query?${params}`, {
         headers: v1Headers(),
-        signal: AbortSignal.timeout(V1_TIMEOUT_MS),
+        signal: AbortSignal.timeout(v1Timeout()),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
@@ -170,4 +174,13 @@ function escapeQL(s) {
     return String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 }
 
-module.exports = { init, getClient, getOpts, getMode, buildLine, v1Write, v1Query, escapeQL };
+/**
+ * Escape a string for use inside an InfluxQL double-quoted identifier
+ * (measurement/tag/field name).
+ * @param {string} s
+ */
+function escapeIdent(s) {
+    return String(s).replace(/"/g, '\\"');
+}
+
+module.exports = { init, getClient, getOpts, getMode, buildLine, v1Write, v1Query, escapeQL, escapeIdent };

package/src/lib/redis.js

@@ -63,6 +63,13 @@ async function init({ url, store, log }) {
         });
     });
 
+    // Write-through: StateStore deletions (e.g. cleared retained messages) → hdel
+    store.on('delete', (key) => {
+        client.hdel('she:state', key).catch((err) => {
+            log.error('redis: hdel failed:', err.message);
+        });
+    });
+
     log.info('redis: connected', url);
 }
 

package/src/lib/state-store.js

@@ -10,6 +10,7 @@
  *
  * Events:
  *   'change' (key, val, obj, prevObj)
+ *   'delete' (key, prevObj)
  */
 
 const { EventEmitter } = require('events');
@@ -47,6 +48,21 @@ class StateStore extends EventEmitter {
         this.emit('change', key, obj.val, obj, prev);
     }
 
+    /**
+     * Remove a key from the store (e.g. when a retained MQTT message is
+     * deleted via an empty retained publish). Emits 'delete' (key, prevObj)
+     * when the key existed; a no-op otherwise.
+     * @param {string} key
+     * @returns {boolean} true when the key existed and was removed
+     */
+    delete(key) {
+        const prev = this._map.get(key);
+        if (prev === undefined) return false;
+        this._map.delete(key);
+        this.emit('delete', key, prev);
+        return true;
+    }
+
     /**
      * @param {string} key
      * @returns {*} the val of the stored state, or undefined

package/src/matter/controller.js

@@ -9,7 +9,11 @@
  * All nodeIds are exposed as decimal strings (BigInt serialization boundary).
  */
 
-const { Environment, ServerNode, ControllerBehavior } = require('@matter/main');
+const { Environment, ServerNode, ControllerBehavior, Logger, LogLevel, LogFormat } = require('@matter/main');
+
+// Upper bound for a commissioning attempt — matter.js has internal retries that
+// can keep an HTTP request (and the pairing wizard) hanging for a very long time.
+const COMMISSION_TIMEOUT_MS = 120000;
 
 /** @type {import('@matter/main').ServerNode | null} */
 let _server = null;
@@ -105,6 +109,17 @@ async function init(storagePath, log, broadcastFn) {
     if (_server) throw new Error('Matter controller already started');
     _log = log;
 
+    // Route matter.js's own diagnostics into the daemon logger so commissioning
+    // problems (discovery, PASE failures, retries) are visible in the Logs tab —
+    // by default matter.js writes straight to stdout, bypassing she's logging.
+    Logger.format = LogFormat.PLAIN;
+    Logger.level = LogLevel.INFO;
+    Logger.destinations.default.write = (text, message) => {
+        if (message.level >= LogLevel.ERROR) _log.error('matter.js:', text);
+        else if (message.level === LogLevel.WARN) _log.warn('matter.js:', text);
+        else _log.debug('matter.js:', text);
+    };
+
     // Configure storage before anything else touches StorageService
     Environment.default.vars.set('storage.path', storagePath);
 
@@ -240,6 +255,44 @@ function listPaired() {
  */
 async function commission(options) {
     if (!_server) throw new Error('Matter controller not started');
+
+    // Accept QR-code payloads ("MT:...") — matter.js's pairingCode option only
+    // decodes 11/21-digit manual pairing codes, so decode QR payloads here.
+    if (typeof options.pairingCode === 'string' && options.pairingCode.trim().toUpperCase().startsWith('MT:')) {
+        const { QrPairingCodeCodec } = require('@matter/types');
+        const [decoded] = QrPairingCodeCodec.decode(options.pairingCode.trim());
+        const { pairingCode: _pc, ...rest } = options;
+        options = { ...rest, passcode: decoded.passcode, discriminator: decoded.discriminator };
+        _log.debug('matter: decoded QR pairing code, discriminator', decoded.discriminator);
+    }
+
+    const label = options.pairingCode !== undefined ? 'pairing code' : `passcode${options.discriminator !== undefined ? ' + discriminator ' + options.discriminator : ''}`;
+    _log.info(`matter: commissioning start (${label}${options.discoveryAddress ? ', direct address ' + options.discoveryAddress : ''})`);
+    let timer;
+    try {
+        const nodeId = await Promise.race([
+            _commissionInner(options),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(
+                    () =>
+                        reject(
+                            new Error(`commissioning timed out after ${COMMISSION_TIMEOUT_MS / 1000} s — check that the pairing window is still open and the device is reachable`),
+                        ),
+                    COMMISSION_TIMEOUT_MS,
+                );
+            }),
+        ]);
+        _log.info('matter: commissioning succeeded, nodeId', nodeId);
+        return nodeId;
+    } catch (err) {
+        _log.error('matter: commissioning failed:', err.message);
+        throw err;
+    } finally {
+        clearTimeout(timer);
+    }
+}
+
+async function _commissionInner(options) {
     const { discoveryAddress, ...commissionOpts } = options;
     let clientNode;
     if (discoveryAddress) {

package/src/sandbox/influx-sandbox.js

@@ -35,6 +35,18 @@ function v1RowVal(row) {
     return null;
 }
 
+/**
+ * Map v1 result rows to the { ts, val } shape, newest-trimmed to n (LIMIT
+ * applies per series in InfluxQL, so multi-series results must be merged and
+ * re-trimmed), sorted oldest-first.
+ * @param {object[]} rows
+ * @param {number} [n]
+ */
+function v1Points(rows, n) {
+    const pts = rows.map((r) => ({ ts: r.time, val: v1RowVal(r) })).sort((a, b) => b.ts - a.ts);
+    return (n ? pts.slice(0, Number(n)) : pts).reverse();
+}
+
 module.exports = function (she) {
     she.influx = {
         /**
@@ -101,10 +113,12 @@ module.exports = function (she) {
         },
 
         /**
-         * Return the last N recorded values for an MQTT topic.
-         * Assumes data was stored with a "topic" tag; the value comes from the
-         * "_value" field (v2) or the "value" field (v1, falling back to the
-         * first data column). Results are sorted oldest-first.
+         * Return the last N recorded values for an MQTT topic (last 30 days).
+         * v2: assumes points carry a "topic" tag, value from "_value".
+         * v1: tries a measurement named like the topic first (influx4mqtt-style
+         * schema), then falls back to a "topic" tag scan; value from the
+         * "value" field, falling back to the first data column.
+         * Results are sorted oldest-first.
          * @param {string} topic
          * @param {number} n
          * @returns {Promise<{ ts: number, val: any }[]>}
@@ -113,16 +127,16 @@ module.exports = function (she) {
             const mode = influx.getMode();
             if (!mode) return Promise.resolve([]);
             if (mode === 'v1') {
-                // LIMIT applies per series in InfluxQL — query across all
-                // measurements, then merge, trim to n and sort ascending.
-                const ql = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' ORDER BY time DESC LIMIT ${Number(n)}`;
-                return influx.v1Query(ql).then((rows) =>
-                    rows
-                        .map((r) => ({ ts: r.time, val: v1RowVal(r) }))
-                        .sort((a, b) => b.ts - a.ts)
-                        .slice(0, Number(n))
-                        .reverse(),
-                );
+                // Fast path: measurement named like the topic (the common
+                // mqtt-to-influx v1 schema, e.g. influx4mqtt). Fallback: points
+                // stored with a "topic" tag — that needs a scan across all
+                // measurements, so keep it time-bounded (30d, like the v2 path).
+                const mQl = `SELECT * FROM "${influx.escapeIdent(topic)}" WHERE time >= now() - 30d ORDER BY time DESC LIMIT ${Number(n)}`;
+                return influx.v1Query(mQl).then((rows) => {
+                    if (rows.length) return v1Points(rows, n);
+                    const tagQl = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND time >= now() - 30d ORDER BY time DESC LIMIT ${Number(n)}`;
+                    return influx.v1Query(tagQl).then((tagRows) => v1Points(tagRows, n));
+                });
             }
             const opts = influx.getOpts();
             const safeTopic = topic.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
@@ -143,8 +157,13 @@ module.exports = function (she) {
             if (mode === 'v1') {
                 const fromMs = new Date(from).getTime();
                 const toMs = new Date(to).getTime();
-                const ql = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND time >= ${fromMs}ms AND time <= ${toMs}ms`;
-                return influx.v1Query(ql).then((rows) => rows.map((r) => ({ ts: r.time, val: v1RowVal(r) })).sort((a, b) => a.ts - b.ts));
+                const bounds = `time >= ${fromMs}ms AND time <= ${toMs}ms`;
+                const mQl = `SELECT * FROM "${influx.escapeIdent(topic)}" WHERE ${bounds}`;
+                return influx.v1Query(mQl).then((rows) => {
+                    if (rows.length) return v1Points(rows);
+                    const tagQl = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND ${bounds}`;
+                    return influx.v1Query(tagQl).then((tagRows) => v1Points(tagRows));
+                });
             }
             const opts = influx.getOpts();
             const safeTopic = topic.replace(/\\/g, '\\\\').replace(/"/g, '\\"');

package/src/web/mqtt-api.js

@@ -12,7 +12,8 @@
  * (or null when no broker is configured).
  *
  * State changes for mqtt:: keys are automatically broadcast to WebSocket clients
- * as { type: 'mqtt', topic, val, ts }.
+ * as { type: 'mqtt', topic, val, ts }; deletions (retained message cleared via
+ * an empty retained publish) as { type: 'mqtt', topic, deleted: true, ts }.
  */
 
 const express = require('express');
@@ -43,6 +44,12 @@ function init(store, getMqttClient) {
             broadcastBrokerLog(topic.slice('$SYS/broker/log/'.length), String(obj.val), obj.ts);
         }
     });
+
+    // Forward deletions (retained message cleared) so clients drop the topic
+    store.on('delete', (key) => {
+        if (!key.startsWith('mqtt::')) return;
+        broadcast({ type: 'mqtt', topic: key.slice(6), deleted: true, ts: Date.now() });
+    });
 }
 
 // GET /she/mqtt/state — sorted snapshot of all retained MQTT topic values