smart-home-engine 1.49.0 → 1.50.0

package/dist/web/assets/{tsMode-DPnnht_o.js → tsMode-D_ifZuZE.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-home-engine",
-    "version": "1.49.0",
+    "version": "1.50.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,7 +31,7 @@
 #   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|--stable]           install/refresh tj/n (downloaded, no npm), then n install <label> — JSON with the version before and after
+#   she-servicectl node update [--lts|--latest|--stable|--version X.Y.Z]  install/refresh tj/n (downloaded, no npm), then n install <label|version> — 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
@@ -45,7 +45,7 @@
 
 set -eu
 
-VERSION=14
+VERSION=15
 BROKER_ENV=/etc/mqtt-interfaces/broker.env
 UNIT_DIR=/etc/systemd/system
 
@@ -84,26 +84,41 @@ need_instance() {
     valid_instance "$1" || die "invalid instance name: $1"
 }
 
-# the command behind <adapter> belongs to an npm package of that name — what tells an adapter
-# apart from any other daemon that happens to keep its binary in /usr/local/bin
-npm_adapter_pkg() {
+# where npm keeps globally installed packages
+npm_roots() {
+    r=$(command -v npm >/dev/null 2>&1 && npm root -g 2>/dev/null || true)
+    printf '%s\n/usr/local/lib/node_modules\n' "$r" | grep -v '^$' | LC_ALL=C sort -u
+}
+
+# package.json of an npm-installed <adapter>: from a global root, or from wherever the command
+# behind the name lives (a unit may run the package without a binary on PATH at all)
+adapter_pkg_json() {
+    for root in $(npm_roots); do
+        if [ -f "$root/$1/package.json" ]; then printf '%s' "$root/$1/package.json"; return 0; fi
+    done
     dir=$(adapter_dir "$1" 2>/dev/null) || return 1
-    [ "$(basename "$dir")" = "$1" ] && return 0
-    grep -Eq "\"name\"[[:space:]]*:[[:space:]]*\"(@[^\"/]*/)?$1\"" "$dir/package.json" 2>/dev/null
+    [ -f "$dir/package.json" ] || return 1
+    printf '%s' "$dir/package.json"
 }
 
-# a plain <adapter>.service of an npm-installed adapter (pre-core layout)
+# an mqtt-interfaces adapter: the package says so itself, either with the mqttInterfaces block
+# the core reads or by depending on the core. The same question npm_adapters asks — a host runs
+# plenty of other things, npm packages among them.
+mqtt_interfaces_pkg() {
+    pkg=$(adapter_pkg_json "$1") || return 1
+    grep -q '"mqttInterfaces"' "$pkg" 2>/dev/null && return 0
+    grep -q '"mqtt-interfaces-core"' "$pkg" 2>/dev/null
+}
+
+# a plain <adapter>.service of an npm-installed adapter (pre-core layout). That the unit runs the
+# package or a binary of that name is not enough on its own: dnscrypt-proxy keeps its binary in
+# /usr/local/bin, nut-display is an npm package — neither is an adapter.
 legacy_unit() {
     [ -f "$UNIT_DIR/$1.service" ] || return 1
-    # the unit naming the package directory is conclusive on its own
-    if grep -Eq "/node_modules/$1/" "$UNIT_DIR/$1.service" 2>/dev/null; then
-        return 0
-    fi
-    # ExecStart=/usr/local/bin/<name> alone is not: dnscrypt-proxy, dnsproxy and the like live
-    # there too. It counts only when that binary is an npm package called <adapter>.
-    grep -Eq "/usr/local/bin/$1( |$)" "$UNIT_DIR/$1.service" 2>/dev/null || return 1
-    npm_adapter_pkg "$1"
+    grep -Eq "(/node_modules/$1/|/usr/local/bin/$1( |$))" "$UNIT_DIR/$1.service" 2>/dev/null || return 1
+    mqtt_interfaces_pkg "$1"
 }
+
 # the env file of a legacy unit: its EnvironmentFile= (leading - stripped), default /etc/default/<adapter>;
 # only /etc/default/<adapter> or something inside /etc/<adapter>/ is accepted
 legacy_env_file() {
@@ -254,10 +269,6 @@ read_env_stdin() {
 
 # ── adapters installed with npm but without a template unit yet ─────────────────
 # (a catalog install is `npm install -g <adapter>`; the unit appears with the first `--install`)
-npm_roots() {
-    r=$(command -v npm >/dev/null 2>&1 && npm root -g 2>/dev/null || true)
-    printf '%s\n/usr/local/lib/node_modules\n' "$r" | grep -v '^$' | LC_ALL=C sort -u
-}
 npm_adapters() {
     for root in $(npm_roots); do
         for pkg in "$root"/*/package.json; do
@@ -278,9 +289,13 @@ cmd_version() {
 cmd_list() {
     hostname=$(hostname 2>/dev/null || uname -n)
     node=$(command -v node >/dev/null 2>&1 && node --version 2>/dev/null || true)
-    printf '{"helper":%s,"hostname":"%s","node":%s,"brokerEnv":%s,"adapters":[' \
+    # the machine type decides which node builds exist for this host (an old Pi has none
+    # past the armv6l/armv7l lines) — she reads it off nodejs.org's index per architecture
+    arch=$(uname -m 2>/dev/null || true)
+    printf '{"helper":%s,"hostname":"%s","node":%s,"arch":%s,"brokerEnv":%s,"adapters":[' \
         "$VERSION" "$(json_escape "$hostname")" \
         "$([ -n "$node" ] && printf '"%s"' "$node" || printf 'null')" \
+        "$([ -n "$arch" ] && printf '"%s"' "$(json_escape "$arch")" || printf 'null')" \
         "$([ -f "$BROKER_ENV" ] && printf 'true' || printf 'false')"
     first=1
     adapters=""
@@ -716,6 +731,14 @@ cmd_node() {
             --lts) spec=lts ;;
             --latest) spec=latest ;;
             --stable) spec=stable ;;
+            # an exact release: what a label resolves to depends on the architecture, and she
+            # resolved it against the builds that exist for this host before asking
+            --version)
+                shift
+                [ $# -gt 0 ] || die "--version needs a version"
+                printf '%s' "$1" | grep -Eq '^v?[0-9]{1,3}(\.[0-9]{1,3}){0,2}$' || die "invalid version: $1"
+                spec=$1
+                ;;
             *) die "unknown option: $1" ;;
         esac
         shift

package/src/lib/node-releases.js

@@ -7,6 +7,11 @@
  * 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.
+ *
+ * Not every release is built for every machine: an old Raspberry Pi runs armv6l/armv7l, and
+ * the newest lines have no build for those at all. index.json lists the files of each release,
+ * so `byArch` answers the same two questions per architecture — offering a host a version that
+ * does not exist for it is a promise `n install` cannot keep.
  */
 
 const INDEX_URL = 'https://nodejs.org/dist/index.json';
@@ -19,7 +24,23 @@ function setFetch(fn) {
     _fetch = fn;
 }
 
-/** @type {{lts: string|null, ltsName: string|null, latest: string|null, ts: number, ok: boolean}|null} */
+/**
+ * Node's own name for a machine type, by what `uname -m` calls it — the keys of `byArch` are
+ * both, so a host's raw uname string is enough to look its releases up.
+ * @type {Record<string, string>}
+ */
+const UNAME_ALIASES = {
+    x86_64: 'x64',
+    amd64: 'x64',
+    aarch64: 'arm64',
+    aarch64_be: 'arm64',
+    i386: 'x86',
+    i486: 'x86',
+    i586: 'x86',
+    i686: 'x86',
+};
+
+/** @type {{lts: string|null, ltsName: string|null, latest: string|null, byArch: object, ts: number, ok: boolean}|null} */
 let _cache = null;
 /** @type {Promise<object>|null} */
 let _inflight = null;
@@ -29,15 +50,43 @@ function clearCache() {
     _inflight = null;
 }
 
+function answer(c, fetchedAt) {
+    return { lts: c.lts, ltsName: c.ltsName, latest: c.latest, byArch: c.byArch ?? {}, fetchedAt, stale: !c.ok };
+}
+
+/**
+ * The newest release and the newest LTS release *that have a linux build for that machine*,
+ * per architecture. A release lists its downloads in `files` ("linux-armv7l", "linux-x64", …),
+ * which is exactly what `n install` will look for.
+ * @param {object[]} list index.json, newest first
+ */
+function byArch(list) {
+    const out = {};
+    for (const entry of list) {
+        if (!entry || typeof entry.version !== 'string' || !Array.isArray(entry.files)) continue;
+        for (const file of entry.files) {
+            if (typeof file !== 'string' || !file.startsWith('linux-')) continue;
+            const arch = file.slice('linux-'.length);
+            if (!arch || arch.includes('-')) continue; // linux-x64-musl and the like are not n's target
+            const seen = (out[arch] ??= { lts: null, latest: null });
+            if (!seen.latest) seen.latest = entry.version;
+            if (!seen.lts && entry.lts) seen.lts = entry.version;
+        }
+    }
+    // a host reports what uname says; let that name find the same entry
+    for (const [uname, arch] of Object.entries(UNAME_ALIASES)) {
+        if (out[arch]) out[uname] = out[arch];
+    }
+    return out;
+}
+
 /**
  * @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 (_cache && !opts.force && now - _cache.ts < TTL) return answer(_cache, _cache.ts);
     if (_inflight) return _inflight;
 
     _inflight = (async () => {
@@ -49,17 +98,24 @@ async function releases(opts = {}) {
             // 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 };
+            _cache = {
+                lts: ltsEntry ? ltsEntry.version : null,
+                ltsName: ltsEntry ? String(ltsEntry.lts) : null,
+                latest,
+                byArch: byArch(list),
+                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 };
+            _cache = _cache ? { ..._cache, ts: now, ok: false } : { lts: null, ltsName: null, latest: null, byArch: {}, 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 answer(_cache, _cache.ok ? _cache.ts : null);
     })();
 
     return _inflight;
 }
 
-module.exports = { releases, setFetch, clearCache, INDEX_URL, TTL };
+module.exports = { releases, byArch, setFetch, clearCache, UNAME_ALIASES, 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 = 14; // must match VERSION in service/she-servicectl (test/unit/helper-version.test.js)
+const HELPER_VERSION = 15; // 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). */
@@ -179,6 +179,8 @@ function parseList(stdout) {
         helperOutdated: (Number(data.helper) || 0) < HELPER_VERSION,
         hostname: data.hostname || null,
         node: data.node || null,
+        /** uname -m of the host (helper v15+): which node builds exist for it */
+        arch: data.arch || null,
         brokerEnv: data.brokerEnv === true,
         adapters: Array.isArray(data.adapters) ? data.adapters : [],
         instances: Array.isArray(data.instances) ? data.instances : [],

package/src/web/services-api.js

@@ -30,7 +30,7 @@
  *   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: stable|lts|latest } update Node.js with tj/n (helper v13)
+ *   POST   /she/services/hosts/:host/node/update                     { channel: stable|lts|latest, version? } update Node.js with tj/n (helper v13, exact version v15)
  *   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
@@ -1056,16 +1056,22 @@ 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' }
+// POST /she/services/hosts/:host/node/update { channel?: 'lts' | 'latest', version?: 'vX.Y.Z' }
 router.post('/hosts/:host/node/update', async (req, res) => {
     const entry = resolve(req, res);
     if (!entry) return;
     // n's own labels, passed through as they are: stable and lts both mean the newest LTS
     const channel = (req.body && req.body.channel) || 'lts';
     if (!['stable', 'lts', 'latest'].includes(channel)) return res.status(400).json({ error: "channel must be 'stable', 'lts' or 'latest'" });
+    // A label means something else on a host whose architecture the newest lines are not built
+    // for — n would resolve `lts` to a release that has no download for an old Pi. The caller
+    // resolved it against that host's builds, so the exact version is what gets installed.
+    const version = (req.body && req.body.version) || null;
+    if (version !== null && !/^v?\d{1,3}(\.\d{1,3}){0,2}$/.test(String(version))) return res.status(400).json({ error: 'invalid version' });
+    const spec = version ? ['--version', String(version)] : ['--' + channel];
     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 });
+        const { stdout } = await entry.driver.exec(['node', 'update', ...spec], { timeout: 900000 });
         let result = {};
         try {
             result = JSON.parse(stdout);