smart-home-engine 1.20.5 → 1.20.7

package/package.json

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

package/src/index.js

@@ -547,8 +547,13 @@ if (config.url) {
                 state.ts = new Date().getTime();
             }
             oldState = store.getObject('mqtt::' + topic) || {};
-            if (oldState.val !== state.val) {
-                state.lc = state.ts;
+            // lc (last change): prefer a payload-provided value; otherwise set it
+            // on value change and carry the previous lc over when the value is
+            // unchanged. Previously the old lc was simply lost on repeated
+            // identical values, so she.mqtt.age() returned NaN for topics whose
+            // payloads don't carry their own lc (B5).
+            if (state.lc === undefined) {
+                state.lc = oldState.val !== state.val ? state.ts : (oldState.lc ?? state.ts);
             }
             store.setObject('mqtt::' + topic, state);
             stateChange(topic, state, oldState, msg);

package/src/matter/controller.js

@@ -18,6 +18,13 @@ const COMMISSION_TIMEOUT_MS = 120000;
 /** @type {import('@matter/main').ServerNode | null} */
 let _server = null;
 let _log = null;
+// Rate-limit state for repeating matter.js error lines (B6)
+let _lastMatterErr = { line: '', ts: 0, suppressed: 0 };
+
+/** Depth-limited, cycle-safe rendering of arbitrary throwables/objects. */
+function _inspect(v) {
+    return require('util').inspect(v, { depth: 6, breakLength: 160 });
+}
 /** @type {((msg: object) => void) | null} */
 let _broadcast = null;
 
@@ -115,9 +122,49 @@ async function init(storagePath, log, broadcastFn) {
     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);
+        // she's log adds its own timestamp — drop matter.js's embedded one
+        let line = text.replace(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\s*/, '');
+        if (message.level >= LogLevel.ERROR) {
+            // PLAIN formatting renders some throwables as "{}" — recover the
+            // detail from the structured message values (B6).
+            if (/(\{\}|\[object \w+\])\s*$/.test(line)) {
+                const details = (message.values ?? [])
+                    .filter((v) => v !== null && typeof v === 'object')
+                    .map((v) => _inspect(v))
+                    .filter((d) => d && d !== '{}');
+                if (details.length) line += ' — ' + details.join(' — ');
+            }
+            // Rate-limit identical repeating error lines (e.g. a failing
+            // reconnect loop): suppress repeats within 30 s, keep a heartbeat.
+            const now = Date.now();
+            if (line === _lastMatterErr.line && now - _lastMatterErr.ts < 30000) {
+                _lastMatterErr.ts = now;
+                _lastMatterErr.suppressed++;
+                if (_lastMatterErr.suppressed % 20 !== 0) return;
+                _log.error(`matter.js: (error repeated ${_lastMatterErr.suppressed} times) ${line}`);
+                return;
+            }
+            if (_lastMatterErr.suppressed % 20 !== 0) {
+                _log.error(`matter.js: (previous error repeated ${_lastMatterErr.suppressed} more times)`);
+            }
+            _lastMatterErr = { line, ts: now, suppressed: 0 };
+            _log.error('matter.js:', line);
+        } else if (message.level === LogLevel.WARN) {
+            _log.warn('matter.js:', line);
+        } else {
+            _log.debug('matter.js:', line);
+        }
+    };
+
+    // matter.js's default unhandled-error reporter logs the bare value, which
+    // renders as "{}" for non-Error throwables and drops cause / AggregateError
+    // details. The hook is explicitly replaceable — report full detail (B6).
+    Logger.reportUnhandledError = (error) => {
+        try {
+            _log.error('matter.js: unhandled error:', _inspect(error));
+        } catch {
+            /* never throw from the error reporter */
+        }
     };
 
     // Configure storage before anything else touches StorageService

package/src/sandbox/stdlib.js

@@ -52,9 +52,15 @@ module.exports = function (she, ctx = {}) {
                 she.setValue(target, val);
             });
         },
-        /** Seconds since the topic's value last changed. */
-        age: function Sandbox_mqtt_age(topic) {
-            return Math.round((new Date().getTime() - she.getProp(topic, 'lc')) / 1000);
+        /**
+         * Seconds since the topic's value last changed.
+         * Pass 'message' (or 'ts') as second argument to get the seconds since
+         * the last received message instead — repeated identical values reset
+         * that clock, useful for sensor heartbeat checks.
+         */
+        age: function Sandbox_mqtt_age(topic, mode) {
+            const prop = mode === 'message' || mode === 'ts' ? 'ts' : 'lc';
+            return Math.round((new Date().getTime() - she.getProp(topic, prop)) / 1000);
         },
         /**
          * Publish 1 to target when any source is truthy, 0 otherwise.
@@ -148,7 +154,8 @@ module.exports = function (she, ctx = {}) {
     she.http = {
         /**
          * Fetch a URL and return a Promise that resolves to the response body.
-         * Resolves to parsed JSON when the Content-Type is application/json, plain text otherwise.
+         * Resolves to parsed JSON when the Content-Type is application/json and
+         * the body parses; falls back to the raw text body when parsing fails.
          * Rejects on non-2xx responses.
          * @param {string} url
          * @param {RequestInit} [options]
@@ -171,7 +178,15 @@ module.exports = function (she, ctx = {}) {
             const promise = fetch(url, { ...options, signal })
                 .then(async (r) => {
                     const ct = r.headers.get('content-type') || '';
-                    const body = ct.includes('json') ? await r.json() : await r.text();
+                    const text = await r.text();
+                    let body = text;
+                    if (ct.includes('json')) {
+                        try {
+                            body = JSON.parse(text);
+                        } catch {
+                            // Content-Type lied — deliver the raw body instead of throwing
+                        }
+                    }
                     const headers = {};
                     r.headers.forEach((v, k) => {
                         headers[k] = v;