smart-home-engine 1.42.0 → 1.44.0

package/dist/web/assets/{tsMode-C0zJ2TUA.js → tsMode-IQCYIRzL.js}

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

package/package.json

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

package/service/she-servicectl

@@ -31,6 +31,8 @@
 #   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)
+#   she-servicectl node update [--lts|--latest]                    install/refresh tj/n (downloaded, no npm), then n install lts (or latest) — JSON with the version before and after
+#   she-servicectl restart-all                                     restart every running instance on this host (after a node update, say)
 #   she-servicectl self-update                                     replace this script with the one on stdin (she ships it)
 #   she-servicectl remove-key                                      drop the public key on stdin from the calling user's authorized_keys
 #   she-servicectl teardown [--force]                              remove she from this host: that key, the sudoers rule, this script,
@@ -43,10 +45,17 @@
 
 set -eu
 
-VERSION=12
+VERSION=13
 BROKER_ENV=/etc/mqtt-interfaces/broker.env
 UNIT_DIR=/etc/systemd/system
 
+# tj/n, pinned: n is a self-contained bash script, so it is installed by downloading that one
+# file — not with `npm install -g n`, which needs a node that may not be there yet and would
+# drop n into whatever prefix the current node uses (where the node n installs then shadows it).
+N_VERSION=10.2.0
+N_BIN=/usr/local/bin/n
+N_URL=https://raw.githubusercontent.com/tj/n/v$N_VERSION/bin/n
+
 die() { printf 'she-servicectl: %s\n' "$*" >&2; exit 2; }
 
 # ── validation ──────────────────────────────────────────────────────────────────
@@ -104,6 +113,11 @@ need_any() {
 
 # ── helpers ─────────────────────────────────────────────────────────────────────
 
+# a JSON string, or null when the value is empty
+json_str() {
+    [ -n "$1" ] && printf '"%s"' "$(json_escape "$1")" || printf 'null'
+}
+
 json_escape() {
     # minimal JSON string escaping for the few free-form values (timestamps, paths)
     printf '%s' "$1" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' | tr -d '\n\r'
@@ -651,6 +665,120 @@ cmd_teardown() {
     printf 'removed %s\n' "$self"
 }
 
+# ── node ────────────────────────────────────────────────────────────────────────
+# Node itself is managed with tj/n (https://github.com/tj/n). Running services keep the
+# binary they were started with, so restart-all is what a version change needs afterwards.
+
+# Download the pinned n and put it at $1. Checked the way self-update checks this script:
+# interpreter line, VERSION, and a syntax check — before anything is moved into place.
+fetch_n() {
+    tmp=$(mktemp) || die "mktemp failed"
+    if command -v curl >/dev/null 2>&1; then
+        curl -fsSL -o "$tmp" "$N_URL" || { rm -f "$tmp"; die "could not download n $N_VERSION from $N_URL"; }
+    elif command -v wget >/dev/null 2>&1; then
+        wget -qO "$tmp" "$N_URL" || { rm -f "$tmp"; die "could not download n $N_VERSION from $N_URL"; }
+    else
+        rm -f "$tmp"
+        die "neither curl nor wget on this host — cannot fetch n (and n needs one of them itself)"
+    fi
+    head -n 1 "$tmp" | grep -q '^#!.*bash' || { rm -f "$tmp"; die "downloaded file is not the n script"; }
+    grep -q "^VERSION=\"\{0,1\}$N_VERSION" "$tmp" || { rm -f "$tmp"; die "downloaded n is not version $N_VERSION"; }
+    bash -n "$tmp" 2>/dev/null || { rm -f "$tmp"; die "downloaded n failed the syntax check"; }
+    install -m 0755 "$tmp" "$1" || { rm -f "$tmp"; die "could not install n to $1"; }
+    rm -f "$tmp"
+}
+
+cmd_node() {
+    [ $# -ge 1 ] || die "usage: node update [--lts|--stable]"
+    action=$1
+    shift
+    [ "$action" = update ] || die "unknown node action: $action"
+    # n's labels: lts = newest long-term-support release, latest = newest release of all.
+    # (n also accepts "stable", but only as its own old alias for lts — not a third channel.)
+    spec=lts
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --lts) spec=lts ;;
+            --latest) spec=latest ;;
+            --stable) spec=lts ;;
+            *) die "unknown option: $1" ;;
+        esac
+        shift
+    done
+
+    command -v bash >/dev/null 2>&1 || die "n is a bash script and this host has no bash (Alpine: apk add bash curl)"
+    N_PREFIX=${N_PREFIX:-/usr/local}
+    export N_PREFIX
+
+    before=$(node --version 2>/dev/null || true)
+
+    have=""
+    if [ -x "$N_BIN" ]; then have=$("$N_BIN" --version 2>/dev/null || true); fi
+    n_installed=false
+    if [ "$have" != "$N_VERSION" ]; then
+        fetch_n "$N_BIN"
+        n_installed=true
+    fi
+
+    "$N_BIN" install "$spec" >&2 || die "n install $spec failed"
+
+    hash -r 2>/dev/null || true
+    installed_path="$N_PREFIX/bin/node"
+    installed=$("$installed_path" --version 2>/dev/null || true)
+    active_path=$(command -v node 2>/dev/null || true)
+    after=$(node --version 2>/dev/null || true)
+    # n put a node in N_PREFIX, but another one (distro package, nvm, an /opt/nodeXX wrapper)
+    # still wins on PATH — that is the version the adapters keep running on.
+    mismatch=false
+    if [ -n "$installed" ] && [ "$after" != "$installed" ]; then mismatch=true; fi
+
+    printf '{"spec":"%s","before":%s,"after":%s,"installed":%s,"activePath":%s,"installedPath":"%s","mismatch":%s,"n":"%s","nInstalled":%s}\n' \
+        "$spec" \
+        "$(json_str "$before")" "$(json_str "$after")" "$(json_str "$installed")" "$(json_str "$active_path")" \
+        "$(json_escape "$installed_path")" "$mismatch" "$N_VERSION" "$n_installed"
+}
+
+# Restart every instance that is currently running — units that are stopped or disabled
+# on purpose stay that way.
+cmd_restart_all() {
+    [ $# -eq 0 ] || die "usage: restart-all"
+    first=1
+    printf '{"restarted":['
+    for unit in "$UNIT_DIR"/*@.service; do
+        [ -f "$unit" ] || continue
+        a=$(basename "$unit" @.service)
+        valid_adapter "$a" || continue
+        installed_adapter "$a" || continue
+        for envf in "/etc/$a"/*.env; do
+            [ -f "$envf" ] || continue
+            i=$(basename "$envf" .env)
+            valid_instance "$i" || continue
+            systemctl is-active --quiet "$a@$i.service" || continue
+            if err=$(systemctl restart "$a@$i.service" 2>&1); then ok=true; else ok=false; fi
+            [ $first -eq 1 ] || printf ','
+            first=0
+            printf '{"adapter":"%s","instance":"%s","ok":%s,"error":%s}' \
+                "$a" "$i" "$ok" \
+                "$([ "$ok" = true ] && printf 'null' || printf '"%s"' "$(json_escape "$err")")"
+        done
+    done
+    for unit in "$UNIT_DIR"/*.service; do
+        [ -f "$unit" ] || continue
+        a=$(basename "$unit" .service)
+        case "$a" in *@) continue ;; esac
+        valid_adapter "$a" || continue
+        legacy_unit "$a" || continue
+        systemctl is-active --quiet "$a.service" || continue
+        if err=$(systemctl restart "$a.service" 2>&1); then ok=true; else ok=false; fi
+        [ $first -eq 1 ] || printf ','
+        first=0
+        printf '{"adapter":"%s","instance":"-","ok":%s,"error":%s}' \
+            "$a" "$ok" \
+            "$([ "$ok" = true ] && printf 'null' || printf '"%s"' "$(json_escape "$err")")"
+    done
+    printf ']}\n'
+}
+
 cmd_npm() {
     [ $# -ge 2 ] || die "usage: npm <adapter> version|origin|install|update|uninstall [--purge]"
     need_adapter "$1"
@@ -697,6 +825,8 @@ case "$c" in
     install) cmd_install "$@" ;;
     uninstall) cmd_uninstall "$@" ;;
     npm) cmd_npm "$@" ;;
+    node) cmd_node "$@" ;;
+    restart-all) cmd_restart_all "$@" ;;
     files) cmd_files "$@" ;;
     file) cmd_file "$@" ;;
     asset) cmd_asset "$@" ;;

package/src/lib/node-releases.js

@@ -0,0 +1,65 @@
+'use strict';
+
+/**
+ * Which Node.js versions a host could be updated to — the two labels tj/n understands:
+ * `lts` (newest Long Term Support release) and `latest` (newest official release).
+ *
+ * she asks nodejs.org once for all hosts and caches the answer, so the Hosts tab can show
+ * what a click would install and hide the button when the host already runs it. Best-effort:
+ * every failure yields the last good answer, or nulls — nothing throws.
+ */
+
+const INDEX_URL = 'https://nodejs.org/dist/index.json';
+const TTL = 6 * 60 * 60 * 1000;
+
+let _fetch = (...args) => fetch(...args);
+
+/** Test hook: replace the fetch implementation. */
+function setFetch(fn) {
+    _fetch = fn;
+}
+
+/** @type {{lts: string|null, ltsName: string|null, latest: string|null, ts: number, ok: boolean}|null} */
+let _cache = null;
+/** @type {Promise<object>|null} */
+let _inflight = null;
+
+function clearCache() {
+    _cache = null;
+    _inflight = null;
+}
+
+/**
+ * @param {{force?: boolean, now?: number}} [opts]
+ * @returns {Promise<{lts: string|null, ltsName: string|null, latest: string|null, fetchedAt: number|null, stale: boolean}>}
+ */
+async function releases(opts = {}) {
+    const now = opts.now ?? Date.now();
+    if (_cache && !opts.force && now - _cache.ts < TTL) {
+        return { lts: _cache.lts, ltsName: _cache.ltsName, latest: _cache.latest, fetchedAt: _cache.ts, stale: !_cache.ok };
+    }
+    if (_inflight) return _inflight;
+
+    _inflight = (async () => {
+        try {
+            const res = await _fetch(INDEX_URL, { signal: AbortSignal.timeout(15000) });
+            if (!res.ok) throw new Error(String(res.status));
+            const list = await res.json();
+            if (!Array.isArray(list) || list.length === 0) throw new Error('unexpected index.json');
+            // index.json is ordered newest first; an LTS entry carries its codename in `lts`
+            const latest = typeof list[0].version === 'string' ? list[0].version : null;
+            const ltsEntry = list.find((e) => e && e.lts && typeof e.version === 'string') || null;
+            _cache = { lts: ltsEntry ? ltsEntry.version : null, ltsName: ltsEntry ? String(ltsEntry.lts) : null, latest, ts: now, ok: true };
+        } catch {
+            // keep whatever was known before, just mark it stale
+            _cache = _cache ? { ..._cache, ts: now, ok: false } : { lts: null, ltsName: null, latest: null, ts: now, ok: false };
+        } finally {
+            _inflight = null;
+        }
+        return { lts: _cache.lts, ltsName: _cache.ltsName, latest: _cache.latest, fetchedAt: _cache.ok ? _cache.ts : null, stale: !_cache.ok };
+    })();
+
+    return _inflight;
+}
+
+module.exports = { releases, setFetch, clearCache, INDEX_URL, 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 = 12; // must match VERSION in service/she-servicectl (test/unit/helper-version.test.js)
+const HELPER_VERSION = 13; // must match VERSION in service/she-servicectl (test/unit/helper-version.test.js)
 /** 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/config-api.js

@@ -50,4 +50,51 @@ router.put('/', (req, res) => {
     }
 });
 
+/**
+ * PATCH / — write a single subtree, leaving the rest of the file as it is on disk.
+ *
+ * Body: { path: 'broker.ssh', value: … }. A page that edits one branch of the config
+ * must not send the whole document back: it would carry a snapshot taken when the page
+ * was opened and silently revert anything another page wrote in the meantime (that is
+ * how a freshly configured services.hosts list disappeared when the broker SSH page was
+ * saved afterwards). Omitting `value` deletes the key.
+ */
+router.patch('/', (req, res) => {
+    const configPath = req.app.locals.configPath || DEFAULT_CONFIG_PATH;
+    try {
+        const { path: dotted, value } = req.body || {};
+        if (typeof dotted !== 'string' || !dotted) return res.status(400).json({ error: 'path required' });
+        const segments = dotted.split('.');
+        if (segments.length > 5 || !segments.every((k) => /^[A-Za-z0-9_-]+$/.test(k))) {
+            return res.status(400).json({ error: `invalid config path: ${dotted}` });
+        }
+
+        let config = {};
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        } catch {
+            /* ok — file may not exist yet */
+        }
+        if (!config || typeof config !== 'object' || Array.isArray(config)) config = {};
+
+        const before = JSON.stringify(config[segments[0]]);
+        let node = config;
+        for (const key of segments.slice(0, -1)) {
+            if (!node[key] || typeof node[key] !== 'object' || Array.isArray(node[key])) node[key] = {};
+            node = node[key];
+        }
+        const last = segments[segments.length - 1];
+        if (value === undefined) delete node[last];
+        else node[last] = value;
+
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+        const restartRequired = !FRONTEND_ONLY_KEYS.has(segments[0]) && before !== JSON.stringify(config[segments[0]]);
+        res.json({ ok: true, restartRequired, configPath });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
 module.exports = { router, DEFAULT_CONFIG_PATH };

package/src/web/services-api.js

@@ -29,6 +29,9 @@
  *   GET    /she/services/ssh/pubkey                                  public key of the services identity (I5)
  *   POST   /she/services/ssh/keygen                                  generate it
  *   POST   /she/services/hosts/:host/test                            run `she-servicectl version` → ok / code
+ *   GET    /she/services/node/releases[?refresh=1]                   what a node update would install: the newest lts and latest release
+ *   POST   /she/services/hosts/:host/node/update                     { channel: lts|latest } update Node.js with tj/n (helper v13)
+ *   POST   /she/services/hosts/:host/instances/restart-all           restart every running instance (after a node update)
  *   POST   /she/services/hosts/:host/helper/deploy                   scp the helper to a remote host, install it, print the sudoers line
  *   POST   /she/services/hosts/:host/helper/remove                   { mode: key|all, force? } remove she from the host (I11), drop the host entry
  *   POST   /she/services/setup/token                                 mint a one-time token + the curl | bash command (I9)
@@ -54,6 +57,7 @@ const dns = require('dns');
 const { analyzeServices, wipeTopics, LOG_LEVELS } = require('../lib/services-inventory');
 const { shapeDevices, discoverTarget } = require('../lib/device-discovery');
 const npmRegistry = require('../lib/npm-registry');
+const nodeReleases = require('../lib/node-releases');
 const catalog = require('../lib/services-catalog');
 const os = require('os');
 const path = require('path');
@@ -1030,6 +1034,65 @@ router.post('/hosts/:host/adapters/:adapter/update', async (req, res) => {
     }
 });
 
+/** The two node commands need helper v13; older hosts answer with "unknown command". */
+function nodeHostError(res, err) {
+    if (/unknown command/i.test(err.message || '')) {
+        return res.status(400).json({
+            error: 'the she-servicectl helper on this host is too old for Node.js management — update it on the Hosts tab',
+            code: 'HELPER_OUTDATED',
+        });
+    }
+    return hostError(res, err);
+}
+
+// GET /she/services/node/releases[?refresh=1] — what the update buttons would install
+router.get('/node/releases', async (req, res) => {
+    res.json(await nodeReleases.releases({ force: req.query.refresh === '1' }));
+});
+
+// POST /she/services/hosts/:host/node/update { channel?: 'lts' | 'latest' }
+router.post('/hosts/:host/node/update', async (req, res) => {
+    const entry = resolve(req, res);
+    if (!entry) return;
+    // 'stable' is n's old alias for lts — accepted so an older client keeps working
+    const channel = (req.body && req.body.channel) === 'stable' ? 'lts' : (req.body && req.body.channel) || 'lts';
+    if (channel !== 'lts' && channel !== 'latest') return res.status(400).json({ error: "channel must be 'lts' or 'latest'" });
+    try {
+        // downloading and unpacking a node build on a small host takes a while
+        const { stdout } = await entry.driver.exec(['node', 'update', '--' + channel], { timeout: 900000 });
+        let result = {};
+        try {
+            result = JSON.parse(stdout);
+        } catch {
+            return res.status(500).json({ error: 'helper returned unexpected output', output: stdout });
+        }
+        invalidateHosts();
+        res.json({ ok: true, ...result, restartRequired: result.before !== result.after });
+    } catch (err) {
+        nodeHostError(res, err);
+    }
+});
+
+// POST /she/services/hosts/:host/instances/restart-all
+router.post('/hosts/:host/instances/restart-all', async (req, res) => {
+    const entry = resolve(req, res);
+    if (!entry) return;
+    try {
+        const { stdout } = await entry.driver.exec(['restart-all'], { timeout: 300000 });
+        let result = { restarted: [] };
+        try {
+            result = JSON.parse(stdout);
+        } catch {
+            return res.status(500).json({ error: 'helper returned unexpected output', output: stdout });
+        }
+        const restarted = (result.restarted || []).filter((r) => r.ok);
+        const failed = (result.restarted || []).filter((r) => !r.ok);
+        res.json({ ok: failed.length === 0, restarted, failed });
+    } catch (err) {
+        nodeHostError(res, err);
+    }
+});
+
 // POST /she/services/hosts/:host/units/:adapter/-/migrate { name } — legacy <adapter>.service → <adapter>@<name>
 router.post('/hosts/:host/units/:adapter/' + LEGACY + '/migrate', async (req, res) => {
     const entry = resolve(req, res, { adapter: true });