smart-home-engine 1.35.0 → 1.36.0

package/dist/web/assets/{tsMode-DS17PuxG.js → tsMode-DIQ3Qnwp.js}

@@ -1,4 +1,4 @@
-import{m as O}from"./monaco-langs-DKJI_o9J.js";import{t as I}from"./index-DfNXDuwc.js";/*!-----------------------------------------------------------------------------
+import{m as O}from"./monaco-langs-DKJI_o9J.js";import{t as I}from"./index-y0wyYG2_.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-DfNXDuwc.js"></script>
+      <script type="module" crossorigin src="/assets/index-y0wyYG2_.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-DwaZ1Sfz.css">
+      <link rel="stylesheet" crossorigin href="/assets/index-hiXQxo8M.css">
     </head>
     <body>
         <div id="app"></div>

package/package.json

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

package/service/she-servicectl

@@ -16,7 +16,8 @@
 # a wrapper or symlink /usr/local/bin/<adapter>.
 #
 #   she-servicectl version
-#   she-servicectl list                                            (adapters = template units + npm packages with mqttInterfaces)
+#   she-servicectl list                                            (adapters = template units + npm packages with mqttInterfaces; instances carry
+#                                                                  systemd's MemoryCurrent / CPUUsageNSec for the dashboard)
 #   she-servicectl unit   <adapter> <instance> start|stop|restart|enable|disable|status
 #   she-servicectl logs   <adapter> <instance> [-n N] [--follow]
 #   she-servicectl env    <adapter> <instance> read|write        (write: file on stdin)
@@ -40,7 +41,7 @@
 
 set -eu
 
-VERSION=9
+VERSION=10
 BROKER_ENV=/etc/mqtt-interfaces/broker.env
 UNIT_DIR=/etc/systemd/system
 
@@ -314,15 +315,20 @@ cmd_list() {
             valid_instance "$i" || continue
             [ $first -eq 1 ] || printf ','
             first=0
-            show=$(systemctl show -p ActiveState -p SubState -p UnitFileState -p ExecMainStartTimestamp -p NRestarts "$a@$i.service" 2>/dev/null || true)
+            show=$(systemctl show -p ActiveState -p SubState -p UnitFileState -p ExecMainStartTimestamp -p NRestarts -p MainPID -p MemoryCurrent -p CPUUsageNSec "$a@$i.service" 2>/dev/null || true)
             active=$(printf '%s\n' "$show" | sed -n 's/^ActiveState=//p')
+            pid=$(printf '%s\n' "$show" | sed -n 's/^MainPID=//p')
+            mem=$(printf '%s\n' "$show" | sed -n 's/^MemoryCurrent=//p')
+            cpuns=$(printf '%s\n' "$show" | sed -n 's/^CPUUsageNSec=//p')
+            case "$mem" in *[!0-9]*|'') mem=null ;; esac
+            case "$cpuns" in *[!0-9]*|'') cpuns=null ;; esac
             sub=$(printf '%s\n' "$show" | sed -n 's/^SubState=//p')
             uf=$(printf '%s\n' "$show" | sed -n 's/^UnitFileState=//p')
             since=$(printf '%s\n' "$show" | sed -n 's/^ExecMainStartTimestamp=//p')
             nr=$(printf '%s\n' "$show" | sed -n 's/^NRestarts=//p')
-            printf '{"adapter":"%s","instance":"%s","active":"%s","sub":"%s","unitFile":"%s","since":"%s","restarts":%s}' \
+            printf '{"adapter":"%s","instance":"%s","active":"%s","sub":"%s","unitFile":"%s","since":"%s","restarts":%s,"pid":%s,"memory":%s,"cpuNs":%s}' \
                 "$a" "$i" "$(json_escape "$active")" "$(json_escape "$sub")" "$(json_escape "$uf")" \
-                "$(json_escape "$since")" "${nr:-0}"
+                "$(json_escape "$since")" "${nr:-0}" "${pid:-0}" "$mem" "$cpuns"
         done
     done
     printf ']}\n'

package/src/lib/services-catalog.js

@@ -10,10 +10,14 @@
  *      package when `versions[dist-tags.latest].dependencies` has mqtt-interfaces-core
  *   3. full packument for the members only → description, homepage, repository, `mqttInterfaces`
  *
- * Cached for 24 h with the last good result kept on failure; `refresh` forces a new sweep.
+ * Cached for 24 h in memory and on disk (the data dir), answered from the cache at once and
+ * refreshed in the background — see catalog(); the last good result is kept on failure.
  * Best effort throughout: a publisher that fails is reported in `errors`, the rest still lists.
  */
 
+const fs = require('fs');
+const path = require('path');
+
 const CORE = 'mqtt-interfaces-core';
 const REGISTRY = 'https://registry.npmjs.org';
 const TTL = 24 * 60 * 60 * 1000;
@@ -23,12 +27,35 @@ function setFetch(fn) {
     _fetch = fn;
 }
 
-/** @type {{key: string, ts: number, result: object, promise?: Promise<object>} | null} */
+/** @type {{key: string, ts: number, result: object|null, promise?: Promise<object>} | null} */
 let _cache = null;
+let _file = null;
 function clearCache() {
     _cache = null;
 }
 
+/** Persist the catalog under the data dir so a restarted daemon answers at once (best effort). */
+function init({ file } = {}) {
+    _file = file || null;
+    _cache = null;
+    if (!_file) return;
+    try {
+        const saved = JSON.parse(fs.readFileSync(_file, 'utf8'));
+        if (saved && typeof saved.key === 'string' && saved.result && Array.isArray(saved.result.packages)) _cache = { key: saved.key, ts: saved.ts || 0, result: saved.result };
+    } catch {
+        /* no cache yet */
+    }
+}
+function persist() {
+    if (!_file || !_cache || !_cache.result) return;
+    try {
+        fs.mkdirSync(path.dirname(_file), { recursive: true });
+        fs.writeFileSync(_file, JSON.stringify({ key: _cache.key, ts: _cache.ts, result: _cache.result }), 'utf8');
+    } catch {
+        /* read-only data dir — the in-memory copy still works */
+    }
+}
+
 function validPublisher(p) {
     return typeof p === 'string' && /^[a-z0-9][a-z0-9._-]{0,63}$/i.test(p);
 }
@@ -107,38 +134,57 @@ async function sweep(publishers, now) {
     return { packages, publishers, errors, fetchedAt: now };
 }
 
+/** A sweep in the background; the last good list survives a failed one. */
+function startSweep(list, key, now) {
+    const previous = _cache && _cache.key === key ? _cache.result : null;
+    const promise = sweep(list, now)
+        .then((r) => {
+            // keep the last good list when the whole sweep produced nothing but errors
+            if (r.packages.length === 0 && r.errors.length > 0 && previous && previous.packages.length > 0) return { ...previous, errors: r.errors, stale: true };
+            return r;
+        })
+        .then((result) => {
+            _cache = { key, ts: now, result };
+            persist();
+            return result;
+        })
+        .catch((err) => {
+            _cache = previous ? { key, ts: now, result: previous } : null;
+            if (previous) return { ...previous, errors: [{ error: err.message }], stale: true };
+            throw err;
+        });
+    _cache = { key, ts: now, result: previous, promise };
+    promise.finally(() => {
+        if (_cache && _cache.promise === promise) delete _cache.promise;
+    });
+    return promise;
+}
+
 /**
- * The catalog for the given trusted publishers (cached).
+ * The catalog for the given trusted publishers. Answers from the cache (memory, or the file from a
+ * previous run) at once and refreshes in the background when the cache is older than a day or
+ * `force` is set — `refreshing: true` tells the caller to ask again. Only the very first sweep (no
+ * cache at all) or `wait: true` makes the call wait for the registry.
  * @param {string[]} publishers
- * @param {{force?: boolean, now?: number}} [opts]
+ * @param {{force?: boolean, wait?: boolean, now?: number}} [opts]
  */
 async function catalog(publishers, opts = {}) {
     const list = [...new Set((publishers || []).filter(validPublisher).map((p) => p.toLowerCase()))];
     const now = opts.now ?? Date.now();
     const key = list.join(',');
-    if (list.length === 0) return { packages: [], publishers: [], errors: [], fetchedAt: now, cached: false };
-    if (_cache && _cache.key === key && !opts.force) {
-        if (_cache.promise) return { ...(await _cache.promise), cached: true };
-        if (now - _cache.ts < TTL) return { ..._cache.result, cached: true };
-    }
-    const previous = _cache && _cache.key === key ? _cache.result : null;
-    const promise = sweep(list, now).then((r) => {
-        // keep the last good list when the whole sweep produced nothing but errors
-        if (r.packages.length === 0 && r.errors.length > 0 && previous && previous.packages.length > 0) {
-            return { ...previous, errors: r.errors, stale: true };
-        }
-        return r;
-    });
-    _cache = { key, ts: now, result: previous, promise };
-    try {
-        const result = await promise;
-        _cache = { key, ts: now, result };
-        return { ...result, cached: false };
-    } catch (err) {
-        _cache = previous ? { key, ts: now, result: previous } : null;
-        if (previous) return { ...previous, errors: [{ error: err.message }], stale: true, cached: true };
-        throw err;
-    }
+    if (list.length === 0) return { packages: [], publishers: [], errors: [], fetchedAt: now, cached: false, refreshing: false };
+    const entry = _cache && _cache.key === key ? _cache : null;
+    const fresh = entry && entry.result && now - entry.ts < TTL;
+    if ((!fresh || opts.force) && !(entry && entry.promise)) startSweep(list, key, now);
+    const cur = _cache;
+    if (cur.result && !opts.wait) return { ...cur.result, cached: true, refreshing: Boolean(cur.promise) };
+    const result = await (cur.promise || Promise.resolve(cur.result));
+    return { ...result, cached: !cur.promise, refreshing: false };
+}
+
+/** Whether a background sweep is running. */
+function refreshing() {
+    return Boolean(_cache && _cache.promise);
 }
 
-module.exports = { catalog, sweep, packagesOf, coreDependency, details, validPublisher, setFetch, clearCache, CORE, REGISTRY };
+module.exports = { catalog, sweep, packagesOf, coreDependency, details, validPublisher, setFetch, clearCache, init, refreshing, CORE, REGISTRY, TTL };

package/src/lib/services-host.js

@@ -26,7 +26,7 @@ const { execFile, spawn } = require('child_process');
 const sshDeploy = require('./ssh-deploy');
 
 const HELPER = '/usr/local/bin/she-servicectl';
-const HELPER_VERSION = 9; // must match VERSION in service/she-servicectl
+const HELPER_VERSION = 10; // must match VERSION in service/she-servicectl
 /** Default identity for services.hosts[].ssh — one key for all managed hosts (I5). */
 const DEFAULT_SERVICES_IDENTITY = '~/.she/ssh/services_id_ed25519';
 /** The helper as shipped with this she version (copied to remote hosts by the deploy route). */

package/src/lib/services-inventory.js

@@ -69,6 +69,21 @@ function parseInfo(val) {
     return v;
 }
 
+/** `<name>/maintenance/stats` payload (core 0.8+): numbers only, anything else → null. */
+function parseStats(v) {
+    if (typeof v === 'string') {
+        try {
+            v = JSON.parse(v);
+        } catch {
+            return null;
+        }
+    }
+    if (!v || typeof v !== 'object' || Array.isArray(v)) return null;
+    const out = {};
+    for (const k of ['rss', 'heapUsed', 'heapTotal', 'cpu', 'eventLoopLag', 'uptime', 'ts']) if (typeof v[k] === 'number' && Number.isFinite(v[k])) out[k] = v[k];
+    return typeof out.rss === 'number' ? out : null;
+}
+
 /**
  * Derive the service inventory from the retained MQTT state.
  *
@@ -80,11 +95,17 @@ function analyzeServices(entries, opts = {}) {
     const now = opts.now ?? Date.now();
     const infos = new Map(); // instance → {info, ts}
     const conns = new Map(); // instance → {connected, ts, lc}
+    const stats = new Map(); // instance → {stats, ts}  (<name>/maintenance/stats, core 0.8+)
     const topics = new Set();
 
     for (const [topic, obj] of entries) {
         topics.add(topic);
         const slash = topic.indexOf('/');
+        if (slash > 0 && topic.slice(slash) === '/maintenance/stats') {
+            const st = parseStats(obj && obj.val);
+            if (st) stats.set(topic.slice(0, slash), { stats: st, ts: obj.ts });
+            continue;
+        }
         if (slash <= 0 || topic.indexOf('/', slash + 1) !== -1) continue; // exactly two levels
         const instance = topic.slice(0, slash);
         const leaf = topic.slice(slash + 1);
@@ -129,6 +150,7 @@ function analyzeServices(entries, opts = {}) {
             connectedTs: c ? c.ts : null,
             connectedLc: c ? (c.lc ?? c.ts) : null,
             infoTs: i ? i.ts : null,
+            stats: stats.has(instance) && connected !== null && connected > 0 ? { ...stats.get(instance).stats, receivedTs: stats.get(instance).ts } : null,
             statusTopics,
             info,
         });

package/src/web/services-api.js

@@ -556,6 +556,19 @@ router.get('/hosts', async (req, res) => {
     res.json({ hosts: await promise, cached: false });
 });
 
+/** CPUUsageNSec samples per host + unit → cpu share (% of one core) between two listings. */
+const _cpuSamples = new Map();
+function withCpuShare(hostName, instances, now = Date.now()) {
+    return (instances || []).map((i) => {
+        if (typeof i.cpuNs !== 'number') return i;
+        const key = hostName + '|' + i.adapter + '@' + i.instance;
+        const prev = _cpuSamples.get(key);
+        _cpuSamples.set(key, { cpuNs: i.cpuNs, ts: now });
+        if (!prev || now - prev.ts < 1000 || i.cpuNs < prev.cpuNs) return { ...i, cpu: null };
+        return { ...i, cpu: Math.round(((i.cpuNs - prev.cpuNs) / ((now - prev.ts) * 1e6)) * 1000) / 10 };
+    });
+}
+
 async function listHosts(req) {
     return Promise.all(
         hostEntries(req).map(async ({ cfg, driver }) => {
@@ -581,7 +594,7 @@ async function listHosts(req) {
                         }
                     }),
                 );
-                return { ...base, ok: true, hostname: base.hostname || list.hostname, ...list, adapters };
+                return { ...base, ok: true, hostname: base.hostname || list.hostname, ...list, instances: withCpuShare(cfg.name, list.instances), adapters };
             } catch (err) {
                 return { ...base, ok: false, code: err.code || 'ERROR', error: err.message };
             }
@@ -1278,6 +1291,33 @@ router.post('/hosts/:host/units/:adapter/:instance/file/create', async (req, res
 });
 
 // ── I7: adapter catalog ───────────────────────────────────────────────────────
+// persisted under the data dir; a daily timer keeps it fresh so the page never waits for npm
+try {
+    catalog.init({ file: path.join(require('../lib/storage').getStoragePath('services'), 'catalog.json') });
+} catch {
+    /* memory only */
+}
+let _catalogConfigPath = null;
+router.use((req, res, next) => {
+    if (req.app && req.app.locals && req.app.locals.configPath) _catalogConfigPath = req.app.locals.configPath;
+    next();
+});
+const _catalogTimer = setInterval(
+    () => {
+        if (!_catalogConfigPath) return;
+        try {
+            const cfg = JSON.parse(fs.readFileSync(_catalogConfigPath, 'utf8'));
+            const svc = cfg.services || {};
+            if (svc.enabled !== true) return;
+            const list = Array.isArray(svc.trustedPublishers) ? svc.trustedPublishers : ['hobbyquaker'];
+            catalog.catalog(list.filter(catalog.validPublisher)).catch(() => {}); // refreshes only when older than a day
+        } catch {
+            /* unreadable config */
+        }
+    },
+    60 * 60 * 1000,
+);
+_catalogTimer.unref();
 
 const DEFAULT_PUBLISHERS = ['hobbyquaker'];
 function trustedPublishers(req) {
@@ -1289,6 +1329,7 @@ function trustedPublishers(req) {
 // GET /she/services/catalog[?refresh=1]
 router.get('/catalog', async (req, res) => {
     try {
+        // answers from the cache at once; a refresh (older than a day, or ?refresh=1) runs in the background and the client asks again while `refreshing`
         const r = await catalog.catalog(trustedPublishers(req), { force: req.query.refresh === '1' });
         res.json(r);
     } catch (err) {