smart-home-engine 1.34.3 → 1.35.1

package/dist/web/assets/{tsMode-CFhaNPy5.js → tsMode-CLFEQmTc.js}

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

package/package.json

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

package/service/she-servicectl

@@ -24,7 +24,7 @@
 #   she-servicectl schema <adapter>
 #   she-servicectl install   <adapter> <instance>                 (options as KEY=VALUE lines on stdin)
 #   she-servicectl uninstall <adapter> <instance>
-#   she-servicectl npm    <adapter> version|origin|install|update
+#   she-servicectl npm    <adapter> version|origin|install|update|uninstall [--purge]   (uninstall: package, template unit; --purge also /etc and /var/lib)
 #   she-servicectl files  <adapter> <instance>                     JSON listing of /etc/<adapter>/ and /var/lib/<adapter>/<instance>/
 #   she-servicectl file   <adapter> <instance> read|write <path>  a file inside those two directories (write: content on stdin)
 #   she-servicectl asset  <adapter> <relpath>                      a file shipped in the adapter package (example, schema)
@@ -40,7 +40,7 @@
 
 set -eu
 
-VERSION=8
+VERSION=9
 BROKER_ENV=/etc/mqtt-interfaces/broker.env
 UNIT_DIR=/etc/systemd/system
 
@@ -599,9 +599,25 @@ cmd_teardown() {
 }
 
 cmd_npm() {
-    [ $# -eq 2 ] || die "usage: npm <adapter> version|origin|install|update"
+    [ $# -ge 2 ] || die "usage: npm <adapter> version|origin|install|update|uninstall [--purge]"
     need_adapter "$1"
     case "$2" in
+        uninstall)
+            # the package and what it left behind; instances must be gone (she removes them first)
+            if [ -n "$(ls "/etc/$1"/*.env 2>/dev/null)" ]; then die "instances of $1 still exist — uninstall them first"; fi
+            npm=$(adapter_npm "$1")
+            node=$(adapter_node "$1")
+            PATH="$(dirname "$node"):$PATH" "$npm" uninstall -g "$1" --no-audit --no-fund 2>&1 || true
+            dir=$(adapter_dir "$1" 2>/dev/null || true)
+            if [ -n "$dir" ] && [ -d "$dir" ]; then case "$dir" in */node_modules/"$1") rm -rf "$dir"; printf 'removed %s\n' "$dir" ;; esac; fi
+            [ -L "/usr/local/bin/$1" ] && [ ! -e "/usr/local/bin/$1" ] && rm -f "/usr/local/bin/$1"
+            if [ -f "$UNIT_DIR/$1@.service" ]; then rm -f "$UNIT_DIR/$1@.service"; systemctl daemon-reload; printf 'removed %s\n' "$UNIT_DIR/$1@.service"; fi
+            if [ "${3:-}" = "--purge" ]; then
+                for d in "/etc/$1" "/var/lib/$1"; do [ -d "$d" ] && rm -rf "$d" && printf 'removed %s\n' "$d"; done
+            else
+                for d in "/etc/$1" "/var/lib/$1"; do [ -d "$d" ] && rmdir "$d" 2>/dev/null && printf 'removed empty %s\n' "$d"; done
+            fi
+            printf '%s uninstalled\n' "$1" ;;
         version) adapter_version "$1"; printf '\n' ;;
         origin) adapter_origin "$1"; printf '\n' ;;
         install|update)

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 = 8; // must match VERSION in service/she-servicectl
+const HELPER_VERSION = 9; // 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/web/services-api.js

@@ -18,6 +18,7 @@
  *   POST   /she/services/hosts/:host/adapters/:adapter/update        { force? } → npm install -g, restart instances
  *   POST   /she/services/hosts/:host/units/:adapter/:instance/:action start|stop|restart|enable|disable
  *   DELETE /she/services/hosts/:host/units/:adapter/:instance        <adapter> --uninstall
+ *   POST   /she/services/hosts/:host/adapters/:adapter/uninstall        every instance (--uninstall, dynsec identity), then the package, /etc and /var/lib
  *   GET    /she/services/hosts/:host/units/:adapter/:instance/logs   journal tail (?n=)
  *   POST   /she/services/hosts/:host/units/:adapter/:instance/logs/follow   start/renew a journal follower (serviceLog WS)
  *   DELETE /she/services/hosts/:host/units/:adapter/:instance/logs/follow   stop it
@@ -885,22 +886,52 @@ router.post('/hosts/:host/units/:adapter/:instance/:action', async (req, res) =>
 });
 
 // DELETE /she/services/hosts/:host/units/:adapter/:instance — uninstall
+/** <adapter> --uninstall --name <instance> on the host, plus the instance's dynsec identity if it has one. */
+async function uninstallInstance(entry, adapter, instance) {
+    stopFollower(followKey(entry.driver.name, adapter, instance));
+    let dynsecClient = null;
+    try {
+        dynsecClient = parseEnvFile((await entry.driver.exec(['env', adapter, instance, 'read'])).stdout)[DYNSEC_MARKER] || null;
+    } catch {
+        /* no env file */
+    }
+    const { stdout } = await entry.driver.exec(['uninstall', adapter, instance], { timeout: 60000 });
+    if (dynsecClient) await deleteInstanceCredentials(dynsecClient);
+    return { output: stdout, dynsecRemoved: Boolean(dynsecClient) };
+}
+
 router.delete('/hosts/:host/units/:adapter/:instance', async (req, res) => {
     const entry = resolve(req, res, { adapter: true, instance: true });
     if (!entry) return;
     if (req.params.instance === LEGACY) return res.status(400).json({ error: 'a legacy unit is not uninstalled from here — migrate it to an instance first', code: 'LEGACY' });
     try {
-        stopFollower(followKey(entry.driver.name, req.params.adapter, req.params.instance));
-        let dynsecClient = null;
-        try {
-            dynsecClient = parseEnvFile((await entry.driver.exec(['env', req.params.adapter, req.params.instance, 'read'])).stdout)[DYNSEC_MARKER] || null;
-        } catch {
-            /* no env file */
+        res.json({ ok: true, ...(await uninstallInstance(entry, req.params.adapter, req.params.instance)) });
+    } catch (err) {
+        hostError(res, err);
+    }
+});
+
+// POST /she/services/hosts/:host/adapters/:adapter/uninstall — the adapter with all its instances
+router.post('/hosts/:host/adapters/:adapter/uninstall', async (req, res) => {
+    const entry = resolve(req, res, { adapter: true });
+    if (!entry) return;
+    const adapter = req.params.adapter;
+    try {
+        const list = parseList((await entry.driver.exec(['list'])).stdout);
+        if ((list.legacy || []).some((l) => l.adapter === adapter)) {
+            return res.status(409).json({ error: `${adapter} still runs as a pre-core unit (${adapter}.service) — migrate or stop it by hand first`, code: 'LEGACY' });
+        }
+        const instances = (list.instances || []).filter((i) => i.adapter === adapter).map((i) => i.instance);
+        const removed = [];
+        for (const instance of instances) {
+            await uninstallInstance(entry, adapter, instance);
+            removed.push(instance);
         }
-        const { stdout } = await entry.driver.exec(['uninstall', req.params.adapter, req.params.instance], { timeout: 60000 });
-        if (dynsecClient) await deleteInstanceCredentials(dynsecClient);
-        res.json({ ok: true, output: stdout, dynsecRemoved: Boolean(dynsecClient) });
+        const { stdout } = await entry.driver.exec(['npm', adapter, 'uninstall', '--purge'], { timeout: 120000 });
+        invalidateHosts();
+        res.json({ ok: true, removedInstances: removed, output: stdout });
     } catch (err) {
+        invalidateHosts();
         hostError(res, err);
     }
 });
@@ -1247,6 +1278,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) {
@@ -1258,6 +1316,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) {