smart-home-engine 1.20.7 → 1.20.9

package/dist/web/assets/{tsMode-5LOOlJtc.js → tsMode-HwpLJXZi.js}

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

package/dist/web/index.html

@@ -172,7 +172,7 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-B7lqbVal.js"></script>
+      <script type="module" crossorigin src="/assets/index-C6zGQcmq.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-C3njyEHY.css">

package/package.json

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

package/src/index.js

@@ -303,9 +303,32 @@ let _sentinelValue = null; // unique value for this boot's sentinel
 const _STARTUP_TIMEOUT_MS = 10000; // ms to wait for broker before starting anyway
 const _SENTINEL_TIMEOUT_MS = config.sentinelTimeout; // ms to wait for sentinel after connecting
 
-function startOnce(reason) {
-    if (_started) return;
+// Script start waits on two gates: MQTT retained state (sentinel) and — when
+// the Matter controller is enabled — controller startup, so scripts using
+// she.matter.* at top level don't fail with "Matter controller not started".
+let _mqttGate = false;
+let _matterGate = !config.matterStorage; // pre-open when matter is disabled
+
+function _maybeStart() {
+    if (_started || !_mqttGate || !_matterGate) {
+        if (!_started && _mqttGate && !_matterGate) {
+            log.info('waiting for matter controller before starting scripts');
+        }
+        return;
+    }
     _started = true;
+    start();
+}
+
+function matterGateOpen() {
+    if (_matterGate) return;
+    _matterGate = true;
+    _maybeStart();
+}
+
+function startOnce(reason) {
+    if (_started || _mqttGate) return;
+    _mqttGate = true;
     if (_startupTimeout) {
         clearTimeout(_startupTimeout);
         _startupTimeout = null;
@@ -316,7 +339,7 @@ function startOnce(reason) {
     }
     if (reason) log.info(reason);
     broadcast({ type: 'mqtt:status', ready: true, connected });
-    start();
+    _maybeStart();
 }
 
 // Wire up the MQTT API: pass the state store and a getter for the live MQTT client.
@@ -605,9 +628,21 @@ if (config.matterStorage) {
         matterStoragePath = ensureStorageDir('matter');
     }
     log.info('matter controller starting, storage:', matterStoragePath);
-    matterController.init(matterStoragePath, log, broadcast).catch((err) => {
-        log.error('matter controller init failed:', err.message, err.stack);
-    });
+    // Scripts wait for the controller (see _maybeStart) — but never forever:
+    // a hanging start must not block the whole script engine.
+    const _matterStartTimeout = setTimeout(() => {
+        if (!_started) log.warn('matter controller not ready after 30s — starting scripts anyway');
+        matterGateOpen();
+    }, 30000);
+    matterController
+        .init(matterStoragePath, log, broadcast)
+        .catch((err) => {
+            log.error('matter controller init failed:', err.message, err.stack);
+        })
+        .finally(() => {
+            clearTimeout(_matterStartTimeout);
+            matterGateOpen();
+        });
 } else {
     log.warn('matter controller disabled — set matterStorage in config.json to enable');
 }
@@ -626,7 +661,10 @@ if (config.url) {
         startOnce();
     }, _STARTUP_TIMEOUT_MS);
 } else {
-    start();
+    // No broker configured — open the MQTT gate directly (scripts may still
+    // wait for the Matter controller, see _maybeStart).
+    _mqttGate = true;
+    _maybeStart();
 }
 
 function stateChange(topic, state, oldState, msg) {
@@ -1084,42 +1122,33 @@ function runScript(script, name, _origin) {
             if (modules[md]) {
                 return modules[md];
             }
-            try {
-                let result;
-                if (md.match(/^\.\//) || md.match(/^\.\.\//)) {
-                    // Relative import — resolve from the script's own directory
-                    const tmp = './' + path.relative(__dirname, path.join(scriptDir, md));
-                    she.debug('require', tmp);
-                    result = require(tmp);
-                } else {
-                    // Absolute import — try ~/.she/node_modules/ first (user-installed),
-                    // then fall back to engine's own require (builtins + engine deps).
-                    try {
-                        result = _userRequire(md);
-                        she.debug('require (user)', md);
-                    } catch {
-                        const localMod = path.join(scriptDir, 'node_modules', md, 'package.json');
-                        if (fs.existsSync(localMod)) {
-                            result = require(path.join(scriptDir, 'node_modules', md));
-                            she.debug('require (local)', md);
-                        } else {
-                            result = require(md);
-                            she.debug('require', md);
-                        }
+            // Failures throw (Cannot find module, syntax errors in the required
+            // file, …) and thereby stop the requiring script — a script must not
+            // silently continue with an undefined module.
+            let result;
+            if (md.match(/^\.\//) || md.match(/^\.\.\//)) {
+                // Relative import — resolve from the script's own directory
+                she.debug('require', md);
+                result = require(path.resolve(scriptDir, md));
+            } else {
+                // Absolute import — try ~/.she/node_modules/ first (user-installed),
+                // then fall back to engine's own require (builtins + engine deps).
+                try {
+                    result = _userRequire(md);
+                    she.debug('require (user)', md);
+                } catch {
+                    const localMod = path.join(scriptDir, 'node_modules', md, 'package.json');
+                    if (fs.existsSync(localMod)) {
+                        result = require(path.join(scriptDir, 'node_modules', md));
+                        she.debug('require (local)', md);
+                    } else {
+                        result = require(md);
+                        she.debug('require', md);
                     }
                 }
-                modules[md] = result;
-                return result;
-            } catch (err) {
-                const lines = err.stack.split('\n');
-                const stack = [];
-                lines.forEach((line) => {
-                    if (!line.match(/module\.js:/)) {
-                        stack.push(line);
-                    }
-                });
-                log.error(name + ': ' + stack);
             }
+            modules[md] = result;
+            return result;
         },
 
         console: {
@@ -1174,7 +1203,15 @@ function runScript(script, name, _origin) {
 
     scriptDomain.run(() => {
         log.debug(logLabel, 'running');
-        script.runInContext(context);
+        try {
+            script.runInContext(context);
+        } catch (e) {
+            // Contain top-level script errors: without this, the exception
+            // unwinds through the caller (e.g. the watcher batch loading many
+            // scripts in one tick) and aborts loading of subsequent scripts.
+            // Route through the domain handler for the usual attributed log.
+            scriptDomain.emit('error', e);
+        }
     });
 
     // Log a summary of what was registered — symmetric with the unload summary

package/src/matter/controller.js

@@ -159,9 +159,30 @@ async function init(storagePath, log, broadcastFn) {
     // 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).
+    //
+    // matter.js wires this to process.uncaughtExceptionMonitor, which fires for
+    // EVERY uncaught exception in the process — matter internals, sandbox
+    // script errors, and she's own code alike. Attribute by stack:
+    //   - sandbox script errors are skipped entirely (she's per-script domain
+    //     handles and logs them with correct script attribution);
+    //   - only stacks that actually contain matter.js frames get the
+    //     "matter.js:" label — everything else is reported neutrally, since it
+    //     may just as well be a bug in she itself.
     Logger.reportUnhandledError = (error) => {
         try {
-            _log.error('matter.js: unhandled error:', _inspect(error));
+            const stack = typeof error?.stack === 'string' ? error.stack : '';
+            if (stack) {
+                if (stack.includes('Script.runInContext') || stack.includes('node:vm')) return;
+                try {
+                    const config = require('../config');
+                    const dirs = config.dir ? (Array.isArray(config.dir) ? config.dir : [config.dir]) : [];
+                    if (dirs.some((d) => d && stack.includes(d))) return;
+                } catch {
+                    /* config unavailable — fall through to logging */
+                }
+            }
+            const fromMatter = stack.includes('/@matter/') || stack.includes('\\@matter\\') || stack.includes('@project-chip');
+            _log.error(fromMatter ? 'matter.js: unhandled error:' : 'unhandled error:', _inspect(error));
         } catch {
             /* never throw from the error reporter */
         }
@@ -701,13 +722,18 @@ function subscribeAttribute(scriptFile, nodeId, endpointId, clusterName, attrNam
     if (!changeEvent) throw new Error(`Attribute "${attrName}" on cluster "${clusterName}" has no change event`);
 
     const listenerId = _nextListenerId++;
-    const cancel = changeEvent.on((value, oldValue) => {
+    const observer = (value, oldValue) => {
         try {
             callback(value, oldValue);
         } catch (err) {
             _log?.error(`matter subscriber error in ${scriptFile}:`, err.message);
         }
-    });
+    };
+    // Observable.on() returns void — detaching needs off() with the same
+    // observer reference. (A cancel based on on()'s return value silently did
+    // nothing, leaking one listener per hot-reload.)
+    changeEvent.on(observer);
+    const cancel = () => changeEvent.off(observer);
 
     if (!_listeners.has(scriptFile)) _listeners.set(scriptFile, new Map());
     _listeners.get(scriptFile).set(listenerId, { cancel });
@@ -735,13 +761,18 @@ function unsubscribe(scriptFile, listenerId) {
 function cleanup(scriptFile) {
     const scriptListeners = _listeners.get(scriptFile);
     if (!scriptListeners) return;
+    let cancelled = 0;
     for (const { cancel } of scriptListeners.values()) {
         try {
             cancel();
-        } catch {
-            // ignore
+            cancelled++;
+        } catch (err) {
+            // Don't swallow silently — a broken cancel means a leaked listener
+            // (this hid the on()-returns-void bug above for a long time).
+            _log?.warn(`matter: failed to cancel a subscription of ${scriptFile}: ${err.message}`);
         }
     }
+    if (cancelled > 0) _log?.debug(`matter: cancelled ${cancelled} subscription(s) of ${scriptFile}`);
     _listeners.delete(scriptFile);
 }