smart-home-engine 1.53.4 → 2.0.1

package/dist/web/assets/{tsMode-Ci4l56iF.js → tsMode-20i8zomj.js}

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

package/dist/web/index.html

@@ -175,10 +175,10 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-DPRtP55L.js"></script>
+      <script type="module" crossorigin src="/assets/index-CqYTIaIG.js"></script>
       <link rel="modulepreload" crossorigin href="/assets/monaco-langs-DKJI_o9J.js">
       <link rel="stylesheet" crossorigin href="/assets/monaco-langs-DyX1CsEw.css">
-      <link rel="stylesheet" crossorigin href="/assets/index-Cp--IWao.css">
+      <link rel="stylesheet" crossorigin href="/assets/index-Bu5o4KXc.css">
     </head>
     <body>
         <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-home-engine",
-    "version": "1.53.4",
+    "version": "2.0.1",
     "description": "Node.js based script runner for use in MQTT based Smart Home environments",
     "main": "src/index.js",
     "scripts": {
@@ -32,7 +32,9 @@
     "dependencies": {
         "@elastic/elasticsearch": "^9.4.2",
         "@influxdata/influxdb-client": "^1.35.0",
-        "@matter/main": "^0.17.0",
+        "@matter/dcl-data": "^2026.10.18",
+        "@matter/main": "^0.17.9",
+        "@matter/thread-br-client": "^0.17.9",
         "bcryptjs": "^2.4.3",
         "chokidar": "^4.0.0",
         "express": "^5.2.1",

package/src/config.js

@@ -29,6 +29,11 @@ const config = require('yargs')
         describe: 'enable Matter controller; pass a directory path or true to use <data-dir>/matter',
         type: 'string',
     })
+    .option('matter-dcl-offline', {
+        describe: 'never contact the CSA Distributed Compliance Ledger (vendor names from the bundled snapshot, product details from the cache only)',
+        type: 'boolean',
+        default: false,
+    })
     .option('port', {
         alias: 'p',
         describe: 'HTTP server port (0 = OS-assigned random port)',
@@ -127,10 +132,25 @@ const config = require('yargs')
         type: 'boolean',
     })
     .option('safe-mode-auto-detect', {
-        describe: 'enter safe mode automatically after an unclean shutdown (default: true)',
+        describe: 'enter safe mode automatically when the daemon crashes repeatedly shortly after start (default: true)',
         default: true,
         type: 'boolean',
     })
+    .option('safe-mode-early-crash', {
+        describe: 'seconds after start within which an unclean end counts as an early crash (default: 300)',
+        default: 300,
+        type: 'number',
+    })
+    .option('safe-mode-crash-count', {
+        describe: 'how many early crashes in a row put the next start into safe mode (default: 3)',
+        default: 3,
+        type: 'number',
+    })
+    .option('safe-mode-crash-window', {
+        describe: 'seconds within which those crashes must have happened (default: 1800)',
+        default: 1800,
+        type: 'number',
+    })
     .option('script-timeout', {
         describe: "ms a script's synchronous top-level code may run before it is terminated, 0 = no limit (default: 5000)",
         default: 5000,

package/src/index.js

@@ -102,23 +102,44 @@ const _sentinelFile = _path.join(require('./lib/storage').STORAGE_ROOT, '.she-ru
  * unrelated process after a reboot is the one case this misses, which is the harmless
  * direction to be wrong in.
  */
+const _crashRecord = require('./lib/crash-record');
+const _crashFile = _path.join(require('./lib/storage').STORAGE_ROOT, '.she-crashes.json');
+let _deadRun = null; // the stale sentinel's { pid, startMs }
 function _sentinelState() {
-    let pid;
+    let parsed;
     try {
-        pid = parseInt(_fs.readFileSync(_sentinelFile, 'utf8').trim(), 10);
+        parsed = _crashRecord.parseSentinel(_fs.readFileSync(_sentinelFile, 'utf8'));
     } catch {
         return null; // no marker
     }
-    if (!pid) return 'stale';
+    if (!parsed.pid) {
+        _deadRun = parsed;
+        return 'stale';
+    }
     try {
-        process.kill(pid, 0);
+        process.kill(parsed.pid, 0);
         return 'live';
     } catch (e) {
-        return e.code === 'EPERM' ? 'live' : 'stale'; // EPERM: alive, just not ours
+        if (e.code === 'EPERM') return 'live'; // alive, just not ours
+        _deadRun = parsed;
+        return 'stale';
     }
 }
 const _sentinelBefore = _sentinelState();
-const SAFE_MODE = config.safeMode === true || (config.safeModeAutoDetect !== false && _sentinelBefore === 'stale');
+// A stale sentinel alone is no longer a reason for safe mode (roadmap A10): only a crash that
+// repeats and happens early — the signature of a script that kills the daemon at load — is.
+// A single crash after days of uptime restarts normally, so the house keeps its automation.
+let _crashEval = null;
+if (_sentinelBefore === 'stale') {
+    _crashEval = _crashRecord.evaluate(_deadRun, _crashRecord.readCrashes(_crashFile), {
+        earlyCrashSec: config.safeModeEarlyCrash,
+        crashCount: config.safeModeCrashCount,
+        windowSec: config.safeModeCrashWindow,
+    });
+    _crashRecord.writeCrashes(_crashFile, _crashEval.crashes);
+}
+const SAFE_MODE = config.safeMode === true || (config.safeModeAutoDetect !== false && _sentinelBefore === 'stale' && !!_crashEval?.safeMode);
+const SAFE_MODE_REASON = !SAFE_MODE ? null : config.safeMode === true ? '--safe-mode' : _crashEval.reason;
 let _sentinelWritten = false;
 function _clearSentinel() {
     if (!_sentinelWritten) return;
@@ -131,7 +152,7 @@ function _clearSentinel() {
 }
 if (_sentinelBefore !== 'live') {
     try {
-        _fs.writeFileSync(_sentinelFile, String(process.pid));
+        _fs.writeFileSync(_sentinelFile, _crashRecord.formatSentinel(process.pid, Date.now()));
         _sentinelWritten = true;
     } catch (e) {
         // not fatal — auto-detect simply never triggers when the file cannot be written
@@ -185,8 +206,19 @@ if (SAFE_MODE) {
     if (config.safeMode === true) log.warn('SAFE MODE (--safe-mode): user scripts are not loaded. Restart without the flag to run them.');
     else
         log.warn(
-            `SAFE MODE: ${_sentinelFile} was left behind, so the previous run was killed rather than stopped — a script may be blocking the event loop. User scripts are not loaded; fix the script and restart. Set "safeModeAutoDetect": false to disable this detection.`,
+            `SAFE MODE: ${_crashEval.reason} — ${_sentinelFile} was left behind each time, so the daemon was killed rather than stopped shortly after start; a script may be blocking the event loop or crashing the daemon at load. User scripts are not loaded; fix the script and restart. Set "safeModeAutoDetect": false to disable this detection, or raise safeModeCrashCount.`,
         );
+} else if (_sentinelBefore === 'stale' && _crashEval) {
+    log.warn(`${_crashEval.message} (${_sentinelFile} was left behind${config.safeModeAutoDetect === false ? '; safe-mode detection is off' : ''})`);
+}
+// a run that stays up past the early-crash threshold is healthy: the crash record starts over
+if (_sentinelBefore !== 'live' && !SAFE_MODE) {
+    setTimeout(
+        () => {
+            _crashRecord.writeCrashes(_crashFile, []);
+        },
+        (config.safeModeEarlyCrash || 300) * 1000,
+    ).unref();
 }
 log.debug('loaded config: ', config);
 
@@ -386,6 +418,7 @@ const _SENTINEL_TIMEOUT_MS = config.sentinelTimeout; // ms to wait for sentinel
 // 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
+let _matterStoragePath = null;
 
 function _maybeStart() {
     if (_started || !_mqttGate || !_matterGate) {
@@ -396,6 +429,41 @@ function _maybeStart() {
     }
     _started = true;
     start();
+    // the Matter ↔ MQTT bridge needs both: the controller and the retained state (M19)
+    if (config.matterStorage) {
+        try {
+            require('./matter/mqtt-bridge').start();
+        } catch (err) {
+            log.warn('matter bridge start failed:', err.message);
+        }
+        // Device health (M21): batteries, last seen, offline history — published under <name>/status/matter/health
+        try {
+            require('./matter/device-health').start({
+                publish: (topic, payload, opts) => {
+                    if (mqtt && connected) mqtt.publish(topic, payload, opts || {});
+                },
+                name: config.name,
+                log,
+                broadcast,
+                storageDir: _matterStoragePath,
+            });
+        } catch (err) {
+            log.warn('matter device health start failed:', err.message);
+        }
+        // Thread health alerts (M26): evaluated once a minute, published under <name>/status/thread/health
+        try {
+            require('./matter/thread-health').start({
+                publish: (topic, payload, opts) => {
+                    if (mqtt && connected) mqtt.publish(topic, payload, opts || {});
+                },
+                name: config.name,
+                log,
+                broadcast,
+            });
+        } catch (err) {
+            log.warn('matter thread health start failed:', err.message);
+        }
+    }
 }
 
 function matterGateOpen() {
@@ -508,6 +576,7 @@ const statsSnapshot = () => {
         elMeanMs,
         elMaxMs,
         safeMode: SAFE_MODE,
+        safeModeReason: SAFE_MODE_REASON,
     };
 };
 require('./web/server').setStatsProvider(statsSnapshot);
@@ -519,6 +588,7 @@ const healthSnapshot = () => ({
     mqttConnected: connected,
     scripts: Object.keys(scripts).length,
     safeMode: SAFE_MODE,
+    safeModeReason: SAFE_MODE_REASON,
 });
 require('./web/server').setHealthProvider(healthSnapshot);
 
@@ -652,6 +722,15 @@ if (config.url) {
 
         if (shedb.handleMqttMessage(topic, payload)) return;
 
+        // matter/set/… and matter/get/… go to the Matter bridge (M19); the message is still stored below
+        if (config.matterStorage && _started) {
+            try {
+                require('./matter/mqtt-bridge').onMessage(topic, payload);
+            } catch (err) {
+                log.warn('matter bridge:', err.message);
+            }
+        }
+
         // 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
@@ -774,6 +853,18 @@ if (config.matterStorage) {
         matterStoragePath = ensureStorageDir('matter');
     }
     log.info('matter controller starting, storage:', matterStoragePath);
+    _matterStoragePath = matterStoragePath;
+    require('./matter/mqtt-bridge').init({
+        publish: (topic, payload, opts) => {
+            if (!mqtt) throw new Error('MQTT is not connected');
+            mqtt.publish(topic, payload, opts || {});
+        },
+        isConnected: () => !!mqtt && connected,
+        store,
+        log,
+        storageDir: matterStoragePath,
+        broadcast,
+    });
     // Scripts wait for the controller (see _maybeStart) — but never forever:
     // a hanging start must not block the whole script engine.
     const _matterStartTimeout = setTimeout(() => {
@@ -781,7 +872,7 @@ if (config.matterStorage) {
         matterGateOpen();
     }, 30000);
     matterController
-        .init(matterStoragePath, log, broadcast)
+        .init(matterStoragePath, log, broadcast, { dclOffline: config.matterDclOffline === true })
         .catch((err) => {
             log.error('matter controller init failed:', err.message, err.stack);
         })
@@ -1796,6 +1887,13 @@ async function gracefulShutdown(signal) {
     _clearSentinel();
     log.info(`got ${signal}. exiting.`);
     if (config.matterStorage) {
+        try {
+            require('./matter/mqtt-bridge').stop();
+            require('./matter/thread-health').stop();
+            require('./matter/device-health').stop();
+        } catch {
+            // ignore
+        }
         try {
             await require('./matter/controller').close();
         } catch {

package/src/lib/crash-record.js

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * Crash record for the safe-mode decision (roadmap A10). Safe mode — starting without any user
+ * script — is the right answer to a script that kills the daemon at or shortly after load, where
+ * every restart would fail the same way; it is the wrong answer to a crash after days of normal
+ * operation, where systemd restarts the daemon and the house then runs without automation until
+ * someone notices. So: a crash on its own is not a reason. Safe mode only when the crash repeats
+ * and happens early.
+ *
+ * The sentinel `.she-running` carries `<pid> <startMs>`; a stale one at start tells when the dead
+ * run began. The crash record `.she-crashes.json` next to it keeps the last few unclean runs. Pure
+ * functions here; the daemon reads and writes the files.
+ */
+
+const fs = require('fs');
+
+const DEFAULTS = Object.freeze({ earlyCrashSec: 300, crashCount: 3, windowSec: 1800 });
+const KEEP = 10;
+
+/** `<pid> <startMs>` (or the pre-A10 `<pid>` alone) → { pid, startMs }; null when unreadable. */
+function parseSentinel(text) {
+    const parts = String(text ?? '')
+        .trim()
+        .split(/\s+/);
+    const pid = parseInt(parts[0], 10);
+    if (!Number.isFinite(pid) || pid <= 0) return { pid: null, startMs: null };
+    const startMs = parts.length > 1 ? parseInt(parts[1], 10) : NaN;
+    return { pid, startMs: Number.isFinite(startMs) && startMs > 0 ? startMs : null };
+}
+
+function formatSentinel(pid, startMs) {
+    return `${pid} ${startMs}\n`;
+}
+
+function readCrashes(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const list = Array.isArray(raw) ? raw : Array.isArray(raw?.crashes) ? raw.crashes : [];
+        return list.filter((c) => c && typeof c === 'object' && Number.isFinite(c.end));
+    } catch {
+        return [];
+    }
+}
+
+function writeCrashes(file, crashes) {
+    try {
+        if (!crashes.length) {
+            fs.rmSync(file, { force: true });
+            return;
+        }
+        fs.writeFileSync(file, JSON.stringify({ v: 1, crashes: crashes.slice(-KEEP) }) + '\n');
+    } catch {
+        /* a record that cannot be written costs at most one safe-mode decision */
+    }
+}
+
+function fmtUptime(ms) {
+    if (ms === null) return 'unknown uptime';
+    const s = Math.round(ms / 1000);
+    if (s < 120) return `${s} s`;
+    const m = Math.round(s / 60);
+    if (m < 120) return `${m} min`;
+    const h = Math.round(m / 60);
+    if (h < 48) return `${h} h`;
+    return `${Math.round(h / 24)} d`;
+}
+
+/**
+ * The decision at a start that found a stale sentinel.
+ *
+ * @param {{ startMs: number|null }} dead   the dead run (from its sentinel; startMs null for a pre-A10 sentinel)
+ * @param {{ start: number|null, end: number, early: boolean }[]} crashes  the record so far
+ * @param {{ now?: number, earlyCrashSec?: number, crashCount?: number, windowSec?: number }} [opts]
+ * @returns {{ safeMode: boolean, reason: string|null, crashes: object[], uptimeMs: number|null, early: boolean, message: string }}
+ */
+function evaluate(dead, crashes, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const earlyMs = (opts.earlyCrashSec ?? DEFAULTS.earlyCrashSec) * 1000;
+    const count = Math.max(1, opts.crashCount ?? DEFAULTS.crashCount);
+    const windowMs = (opts.windowSec ?? DEFAULTS.windowSec) * 1000;
+    const uptimeMs = dead?.startMs ? Math.max(0, now - dead.startMs) : null;
+    // a dead run whose start is unknown (a sentinel from before this record) counts as early: that is
+    // the case the detection was built for, and it happens once at most
+    const early = uptimeMs === null || uptimeMs < earlyMs;
+    const list = [...crashes, { start: dead?.startMs ?? null, end: now, early }].slice(-KEEP);
+    const recent = list.slice(-count);
+    const safeMode = early && recent.length >= count && recent.every((c) => c.early && now - c.end <= windowMs);
+    let reason = null;
+    let message;
+    if (safeMode) {
+        reason = `${count} crashes within ${fmtUptime(earlyMs)} of start (last ${fmtUptime(now - recent[0].end)})`;
+        message = `the previous run was killed ${uptimeMs === null ? '' : 'after ' + fmtUptime(uptimeMs) + ' '}— the ${count}. early crash in a row`;
+    } else if (early) {
+        const n = list.filter((c, i) => i >= list.length - count && c.early && now - c.end <= windowMs).length;
+        message = `the previous run was killed ${uptimeMs === null ? '(uptime unknown) ' : 'after ' + fmtUptime(uptimeMs) + ' '}— early crash ${n} of ${count} within ${fmtUptime(windowMs)}; starting normally`;
+    } else {
+        message = `the previous run was killed after ${fmtUptime(uptimeMs)} of uptime — not an early crash; starting normally`;
+    }
+    return { safeMode, reason, crashes: list, uptimeMs, early, message };
+}
+
+module.exports = { DEFAULTS, KEEP, parseSentinel, formatSentinel, readCrashes, writeCrashes, evaluate, fmtUptime };

package/src/lib/secrets.js

@@ -317,4 +317,31 @@ function cli(argv, io = { stdout: process.stdout, stderr: process.stderr, stdin:
     }
 }
 
-module.exports = { init, load, status, list, get, has, set, mark, remove, redact, cli, validName, NAME_RE, MAX_VALUE, MIN_REDACT };
+/**
+ * The encryption of the secrets store for other files that must not sit in plaintext in the data
+ * directory (the Matter group keys, the Thread datasets): same key, same format, their own file.
+ */
+function readEncryptedFile(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    } catch (err) {
+        if (err.code === 'ENOENT') return null;
+        throw err;
+    }
+    const key = loadKey();
+    if (!key) throw new Error(`no key to read ${file}: set SHE_SECRETS_KEY or restore ${_keyFile}`);
+    const obj = JSON.parse(raw);
+    if (!obj || obj.alg !== ALG) throw new Error(`${file}: unknown file format`);
+    return JSON.parse(decrypt(key, obj));
+}
+
+function writeEncryptedFile(file, data) {
+    const key = loadKey({ create: true });
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = file + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(encrypt(key, JSON.stringify(data))) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+
+module.exports = { init, load, status, list, get, has, set, mark, remove, redact, cli, validName, NAME_RE, MAX_VALUE, MIN_REDACT, readEncryptedFile, writeEncryptedFile };