smart-home-engine 0.14.0 → 0.16.0

package/src/index.js

@@ -21,7 +21,7 @@ const _pino = require('pino')(
         sync: true,
     }),
 );
-// Lazy import — log-ws exports a no-op broadcastLog when the HTTP server is not started.
+// Lazy import — log-ws exports a no-op broadcastLog when the HTTP server is not started.
 const { broadcastLog, broadcast } = require('./web/log-ws');
 const shedb = require('./web/shedb');
 const log = {
@@ -55,7 +55,7 @@ log.debug('loaded config: ', config);
 if (typeof config.port !== 'undefined') {
     // Validate: password mode requires a password hash
     if (config.auth === 'password' && !config.password) {
-        log.error('auth is set to "password" but no password is configured. Set a password via the web UI Config → Authentication section first.');
+        log.error('auth is set to "password" but no password is configured. Set a password via the web UI Config → Authentication section first.');
         process.exit(1);
     }
     require('./web/server')
@@ -79,7 +79,7 @@ const modules = {
     'fs': require('fs'),
     'path': require('path'),
     'vm': require('vm'),
-    /* eslint-disable no-restricted-modules */
+    /* eslint-disable no-restricted-modules, n/no-deprecated-api */
     'domain': require('domain'),
     'mqtt': require('mqtt'),
     'node-schedule': require('node-schedule'),
@@ -92,25 +92,21 @@ const Module = require('module');
 const { STORAGE_ROOT } = require('./lib/storage');
 const _userRequire = Module.createRequire(modules.path.join(STORAGE_ROOT, '_anchor.js'));
 
-const domain = modules.domain;
-const vm = modules.vm;
-const fs = modules.fs;
-const path = modules.path;
+const { domain, vm, fs, path, suncalc } = modules;
 const scheduler = modules['node-schedule'];
-const suncalc = modules.suncalc;
 
 const StateStore = require('./lib/state-store');
 const sandboxModules = [];
 const store = new StateStore();
 const scripts = {};
-const scriptOrigins = new Map(); // file → 'builtin' | 'user'
+const scriptOrigins = new Map(); // file → 'builtin' | 'user'
 const subscriptions = [];
 const mqttEventCallbacks = [];
 const varSubscriptions = []; // store-based var:: subscriptions { key, handler, _script }
 
 // Per-script resource tracking for hot-reload
-const scriptJobs = new Map(); // scriptFile → node-schedule Job[]
-const scriptTimers = new Map(); // scriptFile → Set<timer id>
+const scriptJobs = new Map(); // scriptFile → node-schedule Job[]
+const scriptTimers = new Map(); // scriptFile → Set<timer id>
 
 const _global = {};
 
@@ -200,7 +196,7 @@ function sunScheduleEvent(obj, shift) {
     }
 }
 
-// MQTT — only connect when a broker URL is configured
+// MQTT — only connect when a broker URL is configured
 let mqtt = null;
 let connected = false;
 
@@ -209,9 +205,10 @@ let connected = false;
 require('./web/mqtt-api').init(store, () => mqtt);
 require('./web/ai-api').init(store);
 
-// MQTT message rate counter — reset on each stats poll
+// MQTT message rate counter — reset on each stats poll
 let _mqttMsgCount = 0;
 let _mqttMsgTs = Date.now();
+let _prevCpuUsage = process.cpuUsage();
 
 // Register runtime stats provider for GET /she/status
 require('./web/server').setStatsProvider(() => {
@@ -223,6 +220,14 @@ require('./web/server').setStatsProvider(() => {
     const mqttMsgPerSec = elapsed > 0 ? Math.round((_mqttMsgCount / elapsed) * 10) / 10 : 0;
     _mqttMsgCount = 0;
     _mqttMsgTs = now;
+    const cpuDelta = process.cpuUsage(_prevCpuUsage);
+    _prevCpuUsage = process.cpuUsage();
+    const cpuPercent = elapsed > 0 ? Math.round(((cpuDelta.user + cpuDelta.system) / 1000 / (elapsed * 1000)) * 1000) / 10 : 0;
+    const mem = process.memoryUsage();
+    const memMb = Math.round(mem.rss / 1048576);
+    const core = shedb.getCore();
+    const dbDocs = core ? Object.keys(core.docs).length : null;
+    const dbViews = core ? Object.keys(core.queries).length : null;
     let matterNodes = 0;
     let matterEndpoints = 0;
     if (config.matterStorage) {
@@ -231,9 +236,15 @@ require('./web/server').setStatsProvider(() => {
             const paired = mc.listPaired();
             matterNodes = paired.length;
             for (const { nodeId } of paired) {
-                try { matterEndpoints += mc.getEndpoints(nodeId).length; } catch { /* offline */ }
+                try {
+                    matterEndpoints += mc.getEndpoints(nodeId).length;
+                } catch {
+                    /* offline */
+                }
             }
-        } catch { /* controller not ready */ }
+        } catch {
+            /* controller not ready */
+        }
     }
     return {
         scripts: Object.keys(scripts).length,
@@ -242,11 +253,17 @@ require('./web/server').setStatsProvider(() => {
         matterEnabled: !!config.matterStorage,
         matterNodes,
         matterEndpoints,
+        dbEnabled: !!config.dbPath,
+        dbDocs,
+        dbViews,
+        handlers: subscriptions.length + varSubscriptions.length + mqttEventCallbacks.length,
+        memMb,
+        cpuPercent,
     };
 });
 
 if (!config.url) {
-    log.warn('no MQTT broker URL configured — set "url" in ' + path.join(require('os').homedir(), '.she', 'config.json'));
+    log.warn('no MQTT broker URL configured — set "url" in ' + path.join(require('os').homedir(), '.she', 'config.json'));
 }
 
 if (config.url) {
@@ -313,30 +330,39 @@ if (config.url) {
     });
 }
 
-// sheDB — only init when --db-path is given
+// sheDB — only init when --db-path is given
 if (config.dbPath) {
     const dbPathResolved = config.dbPath.replace(/^~(?=[/\\]|$)/, require('os').homedir());
-    shedb.init({ dbPath: dbPathResolved, dbPublish: config.dbPublish || false, dbRetain: config.dbRetain || false, dbPrefix: config.dbPrefix || 'she/db/', mqttName: config.name, mqtt, log, broadcast });
+    shedb.init({
+        dbPath: dbPathResolved,
+        dbPublish: config.dbPublish || false,
+        dbRetain: config.dbRetain || false,
+        dbPrefix: config.dbPrefix || 'she/db/',
+        mqttName: config.name,
+        mqtt,
+        log,
+        broadcast,
+    });
 }
 
-// Redis write-through cache — only init when config.redis.url is given
+// Redis write-through cache — only init when config.redis.url is given
 if (config.redis && config.redis.url) {
     require('./lib/redis')
         .init({ url: config.redis.url, store, log })
         .catch((err) => log.error('redis init failed:', err.message));
 }
 
-// InfluxDB — only init when --influx is set
+// InfluxDB — only init when --influx is set
 if (config.influx) {
     require('./influx').init(config.influx);
 }
 
-// Elasticsearch — only init when --elastic is set
+// Elasticsearch — only init when --elastic is set
 if (config.elastic) {
     require('./elastic').init(config.elastic);
 }
 
-// Matter controller — only init when --matter-storage is set
+// Matter controller — only init when --matter-storage is set
 if (config.matterStorage) {
     const { ensureStorageDir } = require('./lib/storage');
     const matterController = require('./matter/controller');
@@ -352,10 +378,10 @@ if (config.matterStorage) {
         log.error('matter controller init failed:', err.message, err.stack);
     });
 } else {
-    log.warn('matter controller disabled — set matterStorage in config.json to enable');
+    log.warn('matter controller disabled — set matterStorage in config.json to enable');
 }
 
-// Start scripts immediately — MQTT retained state will populate the store asynchronously
+// Start scripts immediately — MQTT retained state will populate the store asynchronously
 start();
 
 function stateChange(topic, state, oldState, msg) {
@@ -428,7 +454,7 @@ function setVariable(name, val) {
     }
 
     const changed = newState.val !== oldState.val;
-    store.setObject(storeKey, newState); // primary: fires 'change' → she.on() callbacks
+    store.setObject(storeKey, newState); // primary: fires 'change' → she.on() callbacks
     store.setObject('mqtt::' + mqttTopic, newState); // compat: so mqttsub('var//name') still works
     stateChange(mqttTopic, newState, oldState, {}); // fires mqttsub callbacks
 
@@ -471,40 +497,32 @@ function runScript(script, name, origin) {
          * @method debug
          * @param {...*}
          */
-        debug() {
-            const args = Array.prototype.slice.call(arguments);
-            args.unshift(logLabel);
-            log.debug.apply(log, args);
+        debug(...args) {
+            log.debug(logLabel, ...args);
         },
         /**
          * Log an info message
          * @method info
          * @param {...*}
          */
-        info() {
-            const args = Array.prototype.slice.call(arguments);
-            args.unshift(logLabel);
-            log.info.apply(log, args);
+        info(...args) {
+            log.info(logLabel, ...args);
         },
         /**
          * Log a warning message
          * @method warn
          * @param {...*}
          */
-        warn() {
-            const args = Array.prototype.slice.call(arguments);
-            args.unshift(logLabel);
-            log.warn.apply(log, args);
+        warn(...args) {
+            log.warn(logLabel, ...args);
         },
         /**
          * Log an error message
          * @method error
          * @param {...*}
          */
-        error() {
-            const args = Array.prototype.slice.call(arguments);
-            args.unshift(logLabel);
-            log.error.apply(log, args);
+        error(...args) {
+            log.error(logLabel, ...args);
         },
 
         /**
@@ -519,30 +537,29 @@ function runScript(script, name, origin) {
          * @param {(string|function)} [options.condition] - conditional function or condition string
          * @param {subscribeCallback} callback
          */
-        mqttsub: function Sandbox_mqttsub(topic, /* optional */ options, callback) {
+        mqttsub: function Sandbox_mqttsub(topic, ...rest) {
             if (typeof topic === 'undefined') {
                 throw new TypeError('argument topic missing');
             }
 
-            if (arguments.length === 2) {
-                if (typeof arguments[1] !== 'function') {
+            let options, callback;
+            if (rest.length === 1) {
+                if (typeof rest[0] !== 'function') {
                     throw new TypeError('callback is not a function');
                 }
-
-                callback = arguments[1];
+                [callback] = rest;
                 options = {};
-            } else if (arguments.length === 3) {
-                if (typeof arguments[2] !== 'function') {
+            } else if (rest.length === 2) {
+                if (typeof rest[1] !== 'function') {
                     throw new TypeError('callback is not a function');
                 }
-                options = arguments[1] || {};
+                [options, callback] = rest;
+                options = options || {};
 
                 if (typeof options === 'string' || typeof options === 'function') {
                     options = { condition: options };
                 }
-
-                callback = arguments[2];
-            } else if (arguments.length > 3) {
+            } else if (rest.length > 2) {
                 throw new Error('wrong number of arguments');
             }
 
@@ -589,22 +606,23 @@ function runScript(script, name, origin) {
          * @param {string|Date|Object|Array} pattern - Cron string, suncalc event name, Date, node-schedule literal, or an array of any mix.
          * @param {Object} [options]
          * @param {number} [options.random] - random delay in seconds
-         * @param {number} [options.shift]  - offset in seconds for solar events (-86400…86400)
+         * @param {number} [options.shift]  - offset in seconds for solar events (-86400…86400)
          * @param {function} callback - is called with no arguments
          */
-        schedule: function Sandbox_schedule(pattern, /* optional */ options, callback) {
-            if (arguments.length === 2) {
-                if (typeof arguments[1] !== 'function') {
+        schedule: function Sandbox_schedule(pattern, ...rest) {
+            let options, callback;
+            if (rest.length === 1) {
+                if (typeof rest[0] !== 'function') {
                     throw new TypeError('callback is not a function');
                 }
-                callback = arguments[1];
+                [callback] = rest;
                 options = {};
-            } else if (arguments.length === 3) {
-                if (typeof arguments[2] !== 'function') {
+            } else if (rest.length === 2) {
+                if (typeof rest[1] !== 'function') {
                     throw new TypeError('callback is not a function');
                 }
-                options = arguments[1] || {};
-                callback = arguments[2];
+                [options, callback] = rest;
+                options = options || {};
             } else {
                 throw new Error('wrong number of arguments');
             }
@@ -695,7 +713,7 @@ function runScript(script, name, origin) {
 
             const tmp = topic.split('/');
             if (tmp[0] === config.variablePrefix && !config.disableVariables) {
-                // Variable — delegate to setVariable (handles var:: store + MQTT publish)
+                // Variable — delegate to setVariable (handles var:: store + MQTT publish)
                 const varName = tmp.slice(2).join('/');
                 setVariable(varName, val);
             } else if (tmp[0] === config.variablePrefix && config.disableVariables) {
@@ -731,18 +749,18 @@ function runScript(script, name, origin) {
          * @example // returns the timestamp of a given topic
          * she.getProp('hm//Bewegungsmelder Keller/MOTION', 'ts');
          */
-        getProp: function Sandbox_getProp(topic /* , optional property, optional nested property, ... */) {
+        getProp: function Sandbox_getProp(topic, ...props) {
             topic = topic.replace(/^([^/]+)\/\/(.+)$/, '$1/status/$2');
-            if (arguments.length > 1) {
+            if (props.length > 0) {
                 let tmp = store.getObject('mqtt::' + topic);
                 if (typeof tmp === 'undefined') {
                     return;
                 }
-                for (let i = 1; i < arguments.length; i++) {
-                    if (typeof tmp[arguments[i]] === 'undefined') {
+                for (const prop of props) {
+                    if (typeof tmp[prop] === 'undefined') {
                         return;
                     }
-                    tmp = tmp[arguments[i]];
+                    tmp = tmp[prop];
                 }
                 return tmp;
             }
@@ -835,7 +853,7 @@ function runScript(script, name, origin) {
         /** @internal Register a callback for MQTT connection lifecycle events. */
         _registerMqttEvent: function Sandbox_she_registerMqttEvent(event, callback) {
             if (event !== 'connect' && event !== 'disconnect') {
-                throw new TypeError('she.mqtt.on: unknown event "' + event + '" — use "connect" or "disconnect"');
+                throw new TypeError('she.mqtt.on: unknown event "' + event + '" — use "connect" or "disconnect"');
             }
             mqttEventCallbacks.push({ event, callback: scriptDomain.bind(callback), _script: name });
         },
@@ -873,12 +891,12 @@ function runScript(script, name, origin) {
             try {
                 let result;
                 if (md.match(/^\.\//) || md.match(/^\.\.\//)) {
-                    // Relative import — resolve from the script's own directory
+                    // 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),
+                    // Absolute import — try ~/.she/node_modules/ first (user-installed),
                     // then fall back to engine's own require (builtins + engine deps).
                     try {
                         result = _userRequire(md);
@@ -1147,17 +1165,17 @@ function loadDir(dir) {
             filePath = filePath.replace(/\\/g, '/');
             const basename = path.basename(filePath);
 
-            // .shelib marker changes — warn only, manual restart required
+            // .shelib marker changes — warn only, manual restart required
             if (basename === '.shelib') {
                 if (event === 'add') {
-                    log.warn(filePath, 'library marker added — .js files in this directory will no longer load as scripts after daemon restart');
+                    log.warn(filePath, 'library marker added — .js files in this directory will no longer load as scripts after daemon restart');
                 } else if (event === 'unlink') {
-                    log.warn(filePath, 'library marker removed — .js files in this directory will load as scripts after daemon restart');
+                    log.warn(filePath, 'library marker removed — .js files in this directory will load as scripts after daemon restart');
                 }
                 return;
             }
 
-            // Directory events — handle gracefully (no process.exit)
+            // Directory events — handle gracefully (no process.exit)
             if (event === 'addDir') return;
 
             if (event === 'unlinkDir') {
@@ -1174,7 +1192,7 @@ function loadDir(dir) {
 
             if (event === 'change' && filePath.endsWith('.js')) {
                 if (isLibFile(filePath, dir)) {
-                    log.warn(filePath, 'is a library file — scripts that require() it will see the old version until they or the daemon are restarted');
+                    log.warn(filePath, 'is a library file — scripts that require() it will see the old version until they or the daemon are restarted');
                     return;
                 }
                 log.info(filePath, 'change detected. hot-reloading.');
@@ -1182,7 +1200,7 @@ function loadDir(dir) {
                 loadScript(filePath);
             } else if (event === 'add' && filePath.endsWith('.js')) {
                 if (isLibFile(filePath, dir)) {
-                    log.debug(filePath, 'is a library file — not loading as script');
+                    log.debug(filePath, 'is a library file — not loading as script');
                     return;
                 }
                 log.info(filePath, 'added. loading.');

package/src/matter/controller.js

@@ -22,6 +22,11 @@ let _broadcast = null;
 const _listeners = new Map();
 let _nextListenerId = 1;
 
+// ── WS attribute broadcast ───────────────────────────────────────────────────
+// Tracks nodeIds that already have global attribute broadcast listeners set up
+// so we never attach them more than once per node object.
+const _attrBroadcastNodes = new Set();
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function _bigintNodeId(nodeId) {
@@ -65,6 +70,18 @@ function _resolveEndpoint(node, endpointIdOrName) {
     throw new Error(`Endpoint not found: ${endpointIdOrName}`);
 }
 
+/** Recursively convert BigInt values to numbers/strings so the result is JSON-serialisable. */
+function _jsonSafe(v) {
+    if (typeof v === 'bigint') return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v.toString();
+    if (Array.isArray(v)) return v.map(_jsonSafe);
+    if (v !== null && typeof v === 'object') {
+        const out = {};
+        for (const [k, val] of Object.entries(v)) out[k] = _jsonSafe(val);
+        return out;
+    }
+    return v;
+}
+
 /** Resolve a cluster name (camelCase) from a cluster ID number or string. */
 function _clusterName(clusterId) {
     // matter.js cluster state keys are camelCase cluster names.
@@ -107,6 +124,15 @@ async function init(storagePath, log, broadcastFn) {
 
     await _server.start();
     _log.info('matter controller started, storage:', storagePath);
+
+    // Subscribe lifecycle events for already-paired nodes (persisted from previous session).
+    for (const node of _server.peers) {
+        const addr = node.peerAddress;
+        if (!addr) continue;
+        const nodeId = _nodeIdStr(addr.nodeId);
+        _subscribeNodeLifecycle(node, nodeId);
+        if (node.lifecycle?.isOnline) _broadcastNodeAttributes(node, nodeId);
+    }
 }
 
 async function close() {
@@ -136,7 +162,9 @@ function _getDeviceName(node) {
             if (bi?.nodeLabel) return bi.nodeLabel;
             if (bi?.productName) return bi.productName;
         }
-    } catch { /* node may be offline */ }
+    } catch {
+        /* node may be offline */
+    }
     return null;
 }
 
@@ -156,7 +184,9 @@ function _getEndpointName(endpoint) {
         const bi = state.basicInformation;
         if (bi?.nodeLabel) return bi.nodeLabel;
         if (bi?.productName) return bi.productName;
-    } catch { /* best-effort */ }
+    } catch {
+        /* best-effort */
+    }
     return null;
 }
 
@@ -176,7 +206,9 @@ function _getDeviceSubtitle(node) {
             if (bi?.productName && bi.productName !== _getDeviceName(node)) parts.push(bi.productName);
             return parts.length ? parts.join(' · ') : null;
         }
-    } catch { /* offline */ }
+    } catch {
+        /* offline */
+    }
     return null;
 }
 
@@ -273,7 +305,18 @@ function getEndpoints(nodeId) {
     const node = _findClientNode(nodeId);
     const result = [];
     for (const endpoint of node.endpoints) {
-        const clusters = endpoint.state ? Object.keys(endpoint.state) : [];
+        const clusters = [];
+        if (endpoint.state) {
+            for (const [clusterName, clusterState] of Object.entries(endpoint.state)) {
+                const attrs = {};
+                if (clusterState && typeof clusterState === 'object') {
+                    for (const [k, v] of Object.entries(clusterState)) {
+                        attrs[k] = _jsonSafe(v);
+                    }
+                }
+                clusters.push({ name: clusterName, attrs });
+            }
+        }
         result.push({ endpointId: endpoint.number ?? 0, clusters, name: _getEndpointName(endpoint) });
     }
     return result;
@@ -315,23 +358,69 @@ async function sendCommand(nodeId, endpointId, clusterName, commandName, args) {
     // Use the target endpoint's own act() instead of navigating via agent.parts,
     // because Parts in @matter/node is a set-like iterable, not a Map (.get doesn't exist).
     const endpoint = _resolveEndpoint(node, endpointId);
-    return endpoint.act(
-        `she.matter.send(${nodeId}, ${endpointId}, ${clusterName}.${commandName})`,
-        async (agent) => {
-            const clusterAgent = agent[_clusterName(clusterName)];
-            if (!clusterAgent) throw new Error(`Cluster "${clusterName}" not found on endpoint ${endpointId}`);
-            const cmd = clusterAgent[commandName];
-            if (typeof cmd !== 'function') throw new Error(`Command "${commandName}" not found in cluster "${clusterName}"`);
-            // Only pass args when the caller actually provided non-empty args.
-            // Void commands (e.g. onOff.off) fail TLV validation if passed an empty object.
-            const hasArgs = args !== undefined && args !== null && Object.keys(args).length > 0;
-            return hasArgs ? cmd.call(clusterAgent, args) : cmd.call(clusterAgent);
-        }
-    );
+    return endpoint.act(`she.matter.send(${nodeId}, ${endpointId}, ${clusterName}.${commandName})`, async (agent) => {
+        const clusterAgent = agent[_clusterName(clusterName)];
+        if (!clusterAgent) throw new Error(`Cluster "${clusterName}" not found on endpoint ${endpointId}`);
+        const cmd = clusterAgent[commandName];
+        if (typeof cmd !== 'function') throw new Error(`Command "${commandName}" not found in cluster "${clusterName}"`);
+        // Only pass args when the caller actually provided non-empty args.
+        // Void commands (e.g. onOff.off) fail TLV validation if passed an empty object.
+        const hasArgs = args !== undefined && args !== null && Object.keys(args).length > 0;
+        return hasArgs ? cmd.call(clusterAgent, args) : cmd.call(clusterAgent);
+    });
 }
 
 // ── Node lifecycle events (online / offline) ────────────────────────────────
 
+/**
+ * Subscribe to all attribute $Changed events on every endpoint/cluster of a node
+ * and forward each change to the WS broadcast so the web UI can display a live
+ * event feed.  A per-node guard prevents double-registration on reconnects.
+ *
+ * @param {object} node   ClientNode
+ * @param {string} nodeId decimal string
+ */
+function _broadcastNodeAttributes(node, nodeId) {
+    if (!_broadcast) return;
+    if (_attrBroadcastNodes.has(nodeId)) return;
+    _attrBroadcastNodes.add(nodeId);
+    let count = 0;
+    try {
+        for (const endpoint of node.endpoints) {
+            const endpointId = endpoint.number ?? 0;
+            if (!endpoint.state) continue;
+            // Iterate cluster names from state (enumerable), then access events via
+            // bracket notation — endpoint.events may be a Proxy that doesn't enumerate.
+            for (const clusterName of Object.keys(endpoint.state)) {
+                const clusterState = endpoint.state[clusterName];
+                if (!clusterState || typeof clusterState !== 'object') continue;
+                const clusterEvents = endpoint.events?.[clusterName];
+                if (!clusterEvents) continue;
+                for (const attrName of Object.keys(clusterState)) {
+                    const changeEvent = clusterEvents[`${attrName}$Changed`];
+                    if (!changeEvent || typeof changeEvent.on !== 'function') continue;
+                    changeEvent.on((value) => {
+                        _broadcast?.({
+                            type: 'matter:attr',
+                            nodeId,
+                            endpointId,
+                            clusterName,
+                            attrName,
+                            value: _jsonSafe(value),
+                            ts: Date.now(),
+                        });
+                    });
+                    count++;
+                }
+            }
+        }
+        _log?.info(`matter: watching ${count} attribute(s) on node ${nodeId}`);
+    } catch (err) {
+        _attrBroadcastNodes.delete(nodeId); // allow retry
+        _log?.warn(`matter: attribute broadcast setup failed for ${nodeId}: ${err.message}`);
+    }
+}
+
 /**
  * Subscribe to online/offline lifecycle changes for a node and broadcast them.
  * @param {object} node ClientNode
@@ -342,6 +431,7 @@ function _subscribeNodeLifecycle(node, nodeId) {
     if (!lc) return;
     lc.online?.on?.(() => {
         _broadcast?.({ type: 'matter:deviceStatus', nodeId, online: true });
+        _broadcastNodeAttributes(node, nodeId);
     });
     lc.offline?.on?.(() => {
         _broadcast?.({ type: 'matter:deviceStatus', nodeId, online: false });