smart-home-engine 1.35.0 → 1.35.1

package/dist/web/assets/{tsMode-DS17PuxG.js → tsMode-CLFEQmTc.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-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-DfNXDuwc.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-DwaZ1Sfz.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.35.0",
+    "version": "1.35.1",
     "description": "Node.js based script runner for use in MQTT based Smart Home environments",
     "main": "src/index.js",
     "scripts": {

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/web/services-api.js

@@ -1278,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) {
@@ -1289,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) {