smart-home-engine 1.51.3 → 1.52.0

package/dist/web/assets/{tsMode-sNUSGo5H.js → tsMode-CQwwRC_t.js}

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

package/package.json

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

package/src/index.js

@@ -44,24 +44,14 @@ require('./lib/storage').ensureRoot();
 }
 
 // ---------------------------------------------------------------------------
-// Persistent JSON-Lines log file — written alongside the pino-pretty stream.
-// On each daemon start: rotate she.jsonl → she.jsonl.1, then open fresh.
+// Persistent JSON-Lines log file — written alongside the pino-pretty stream,
+// rotated on every start and by size (roadmap B-12; src/lib/log-file.js).
 // ---------------------------------------------------------------------------
 const _fs = require('fs');
 const _path = require('path');
 const { LOGS_DIR } = require('./lib/storage');
 const secrets = require('./lib/secrets');
-const _logFileCurrent = _path.join(LOGS_DIR, 'she.jsonl');
-const _logFilePrev = _path.join(LOGS_DIR, 'she.jsonl.1');
-try {
-    _fs.renameSync(_logFileCurrent, _logFilePrev);
-} catch {
-    /* no previous file — ignore */
-}
-const _logFileStream = _fs.createWriteStream(_logFileCurrent, { flags: 'w' });
-function _writeLogLine(level, msg) {
-    _logFileStream.write(JSON.stringify({ level, msg, ts: Date.now() }) + '\n');
-}
+const _logFile = require('./lib/log-file').createLogFile({ dir: LOGS_DIR });
 // ---------------------------------------------------------------------------
 
 const config = require('./config');
@@ -83,35 +73,11 @@ const _pino = require('pino')(
 // Lazy import — log-ws exports a no-op broadcastLog when the HTTP server is not started.
 const { broadcastLog, broadcast, setWelcomeProvider } = require('./web/log-ws');
 const shedb = require('./web/shedb');
-const log = {
-    debug: (...args) => {
-        const msg = secrets.redact(args.join(' '));
-        _pino.debug(msg);
-        broadcastLog({ level: 'debug', msg, ts: Date.now() });
-        _writeLogLine('debug', msg);
-    },
-    info: (...args) => {
-        const msg = secrets.redact(args.join(' '));
-        _pino.info(msg);
-        broadcastLog({ level: 'info', msg, ts: Date.now() });
-        _writeLogLine('info', msg);
-    },
-    warn: (...args) => {
-        const msg = secrets.redact(args.join(' '));
-        _pino.warn(msg);
-        broadcastLog({ level: 'warn', msg, ts: Date.now() });
-        _writeLogLine('warn', msg);
-    },
-    error: (...args) => {
-        const msg = secrets.redact(args.join(' '));
-        _pino.error(msg);
-        broadcastLog({ level: 'error', msg, ts: Date.now() });
-        _writeLogLine('error', msg);
-    },
-    setLevel: (level) => {
-        _pino.level = level;
-    },
-};
+// One level for every sink (roadmap B-12): a line below it is dropped before any work on it.
+const log = require('./lib/logger').createLogger({
+    redact: (s) => secrets.redact(s),
+    sinks: [(level, msg) => _pino[level](msg), (level, msg) => broadcastLog({ level, msg, ts: Date.now() }), (level, msg) => _logFile.write(level, msg)],
+});
 
 // Secrets store (roadmap A5): read once at startup; the UI/CLI keep it current afterwards.
 {
@@ -177,6 +143,16 @@ process.on('exit', _clearSentinel);
 // Wall-clock budget for a script's synchronous top-level code (0 = no limit).
 const SCRIPT_TIMEOUT_MS = typeof config.scriptTimeout === 'number' && config.scriptTimeout >= 0 ? config.scriptTimeout : 5000;
 
+/** remember which topics a script publishes to (roadmap I19), at most 200 per script */
+function recordPublish(scriptFile, topic) {
+    let set = scriptPublishes.get(scriptFile);
+    if (!set) {
+        set = new Set();
+        scriptPublishes.set(scriptFile, set);
+    }
+    if (set.size < 200 || set.has(topic)) set.add(topic);
+}
+
 /**
  * Build a short log label for a script file.
  * Uses the path relative to the configured script dir(s) when possible,
@@ -193,6 +169,7 @@ function makeLabel(filePath) {
 }
 
 log.setLevel(['debug', 'info', 'warn', 'error'].indexOf(config.verbosity) === -1 ? 'info' : config.verbosity);
+_pino.level = log.level;
 
 // Safety net: unhandled Promise rejections from async script callbacks are not caught
 // by the per-script domain (Node.js domains don't intercept Promise rejections).
@@ -271,6 +248,7 @@ const varSubscriptions = []; // store-based var:: subscriptions { key, handler,
 
 // Per-script resource tracking for hot-reload
 const scriptJobs = new Map(); // scriptFile → node-schedule Job[]
+const scriptPublishes = new Map(); // scriptFile → Set<topic> a script published to (roadmap I19; capped)
 const scriptTimers = new Map(); // scriptFile → Set<timer id>
 
 const _global = {};
@@ -448,7 +426,6 @@ require('./web/mqtt-api').init(store, () => mqtt);
 require('./web/services-api').init(store, () => mqtt, {
     getMqttConfig: () => ({ url: config.url, username: config.mqttUsername, password: config.mqttPassword }),
 });
-require('./web/ai-api').init(store, log);
 
 // MQTT message rate counter — reset on each stats poll
 let _mqttMsgCount = 0;
@@ -473,7 +450,7 @@ new PerformanceObserver((list) => {
 }).observe({ type: 'gc', buffered: false });
 
 // Register runtime stats provider for GET /she/status
-require('./web/server').setStatsProvider(() => {
+const statsSnapshot = () => {
     let topics = 0;
     // eslint-disable-next-line no-unused-vars
     for (const _ of store.mqttEntries()) topics++;
@@ -532,16 +509,55 @@ require('./web/server').setStatsProvider(() => {
         elMaxMs,
         safeMode: SAFE_MODE,
     };
-});
+};
+require('./web/server').setStatsProvider(statsSnapshot);
 
 // Health probe for GET /she/health (roadmap A1) — cheap, no counting, no allocation.
-require('./web/server').setHealthProvider(() => ({
+const healthSnapshot = () => ({
     started: _started,
     mqttConfigured: !!config.url,
     mqttConnected: connected,
     scripts: Object.keys(scripts).length,
     safeMode: SAFE_MODE,
-}));
+});
+require('./web/server').setHealthProvider(healthSnapshot);
+
+// What the AI chat may look at (roadmap I19, I27, I28): read-only views of the daemon's state.
+const nextOf = (job) => {
+    try {
+        const d = job && typeof job.nextInvocation === 'function' ? job.nextInvocation() : null;
+        const date = d && typeof d.toDate === 'function' ? d.toDate() : d;
+        return date instanceof Date ? date.getTime() : null;
+    } catch {
+        return null;
+    }
+};
+const introspect = {
+    // the AI's publish tool (roadmap I20), guarded and confirmed in ai-api; here only the broker call
+    publish: (topic, payload, opts) =>
+        new Promise((resolve, reject) => {
+            if (!mqtt || !connected) return reject(new Error('MQTT is not connected'));
+            mqtt.publish(String(topic), typeof payload === 'object' ? JSON.stringify(payload) : String(payload), opts || {}, (err) => (err ? reject(err) : resolve()));
+        }),
+    config: () => ({ name: config.name, variablePrefix: config.variablePrefix || 'var', version: pkg.version }),
+    scripts: () =>
+        Object.keys(scripts).map((file) => ({
+            file,
+            label: makeLabel(file).slice(0, -1),
+            origin: scriptOrigins.get(file) || 'user',
+            subscriptions: subscriptions.filter((x) => x._script === file).flatMap((x) => (Array.isArray(x.topic) ? x.topic : [x.topic])),
+            varSubscriptions: varSubscriptions.filter((x) => x._script === file).map((x) => x.key),
+            publishes: [...(scriptPublishes.get(file) || [])],
+            jobs: (scriptJobs.get(file) || []).filter(Boolean).map((job) => ({ next: nextOf(job) })),
+            sunEvents: sunEvents.filter((e) => e._script === file).map((e) => ({ pattern: e.pattern, next: nextOf(e._job) })),
+            timers: [...(scriptTimers.get(file) || [])].map((t) => ({ due: t.due || null, every: t.every || null })),
+        })),
+    stats: statsSnapshot,
+    health: healthSnapshot,
+    instances: () => require('./lib/services-inventory').analyzeServices(store.mqttEntries()).instances,
+    devices: () => require('./lib/ha-discovery').analyzeDiscovery(store.mqttEntries()).devices,
+};
+require('./web/ai-api').init(store, log, introspect);
 
 // Push current script:running state so the UI green dots survive a browser reload.
 setWelcomeProvider(() => Object.keys(scripts).map((f) => ({ type: 'script:running', path: makeLabel(f).slice(0, -1), running: true })));
@@ -1089,6 +1105,7 @@ function runScript(script, name, _origin) {
             }
 
             topic = topic.replace(/^([^/]+)\/\/(.+)$/, '$1/set/$2');
+            recordPublish(name, topic);
 
             if (typeof payload === 'object') {
                 payload = JSON.stringify(payload);
@@ -1216,6 +1233,8 @@ function runScript(script, name, _origin) {
         setInterval: (fn, delay, ...args) => {
             const wrapped = args.length ? () => fn(...args) : fn;
             const id = setInterval(() => _dispatch(name, wrapped), delay);
+            id.every = delay;
+            id.due = Date.now() + delay;
             _myTimers.add(id);
             return id;
         },
@@ -1442,6 +1461,7 @@ function unloadScript(file) {
         removedTimers += timers.size;
         scriptTimers.delete(file);
     }
+    scriptPublishes.delete(file);
 
     // Remove store-based var:: subscriptions belonging to this script
     for (let i = varSubscriptions.length - 1; i >= 0; i--) {

package/src/lib/log-file.js

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+ * JSON-lines log file with rotation by size (roadmap B-12).
+ *
+ * `she.jsonl` is rotated on every daemon start and whenever it passes `maxBytes`:
+ * `.jsonl` → `.jsonl.1` → … → `.jsonl.<keep>`; the oldest file is dropped.
+ * The stream is written without waiting for the disk; what the thread pool has not
+ * written yet sits in the stream's buffer, which is transient.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_KEEP = 5;
+
+/**
+ * @param {{ dir: string, name?: string, maxBytes?: number, keep?: number }} opts
+ */
+function createLogFile({ dir, name = 'she.jsonl', maxBytes = DEFAULT_MAX_BYTES, keep = DEFAULT_KEEP }) {
+    const current = path.join(dir, name);
+    let stream = null;
+    let bytes = 0;
+
+    function shift() {
+        // .keep is dropped, .(keep-1) → .keep, …, current → .1
+        for (let i = keep; i >= 1; i--) {
+            const from = i === 1 ? current : `${current}.${i - 1}`;
+            const to = `${current}.${i}`;
+            try {
+                if (i === keep) fs.rmSync(to, { force: true });
+                fs.renameSync(from, to);
+            } catch {
+                /* a missing file in the chain — nothing to move */
+            }
+        }
+    }
+
+    function open() {
+        shift();
+        if (stream) stream.end();
+        // open synchronously: the file must exist and be bound before the next rotation renames it,
+        // and a stream opened lazily would bind to whatever carries the name by then
+        stream = fs.createWriteStream(null, { fd: fs.openSync(current, 'w') });
+        stream.on('error', () => {
+            /* the log file is a convenience: a disk error must not take the daemon down */
+        });
+        bytes = 0;
+    }
+
+    open();
+
+    return {
+        /** @param {string} level @param {string} msg */
+        write(level, msg) {
+            const line = JSON.stringify({ level, msg, ts: Date.now() }) + '\n';
+            bytes += Buffer.byteLength(line);
+            stream.write(line);
+            if (bytes >= maxBytes) open();
+        },
+        /** the files that exist, newest first — what the AI log tool reads */
+        files() {
+            const list = [];
+            for (let i = 0; i <= keep; i++) {
+                const f = i === 0 ? current : `${current}.${i}`;
+                if (fs.existsSync(f)) list.push(f);
+            }
+            return list;
+        },
+        close() {
+            if (stream) stream.end();
+            stream = null;
+        },
+        get path() {
+            return current;
+        },
+    };
+}
+
+module.exports = { createLogFile, DEFAULT_MAX_BYTES, DEFAULT_KEEP };

package/src/lib/logger.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * The daemon's logger: one level for every sink (roadmap B-12).
+ *
+ * A line below the configured level is dropped here, before redaction, serialisation
+ * and the sinks — the journal (pino), the UI (ring buffer and websocket) and the file.
+ * Until B-12 only pino honoured the level; the other two got every debug line.
+ */
+
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+
+/**
+ * @param {{ level?: string, redact?: (s: string) => string, sinks: Array<(level: string, msg: string) => void> }} opts
+ */
+function createLogger({ level = 'info', redact = (s) => s, sinks = [] }) {
+    let threshold = LEVELS[level] ?? LEVELS.info;
+    const logger = {};
+    for (const name of Object.keys(LEVELS)) {
+        logger[name] = (...args) => {
+            if (LEVELS[name] < threshold) return;
+            const msg = redact(args.join(' '));
+            for (const sink of sinks) sink(name, msg);
+        };
+    }
+    logger.setLevel = (l) => {
+        threshold = LEVELS[l] ?? LEVELS.info;
+    };
+    Object.defineProperty(logger, 'level', { get: () => Object.keys(LEVELS).find((k) => LEVELS[k] === threshold) });
+    return logger;
+}
+
+module.exports = { createLogger, LEVELS };

package/src/lib/script-timers.js

@@ -19,6 +19,7 @@ function trackTimeout(timers, fn, delay, setTimeoutFn = setTimeout) {
         timers.delete(id);
         fn();
     }, delay);
+    if (id && typeof id === 'object') id.due = Date.now() + delay; // when it fires (roadmap I28: list_timers)
     timers.add(id);
     return id;
 }

package/src/lib/text-diff.js

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * A unified diff of two texts, line based (roadmap I16): what the chat shows for a script draft.
+ * Plain LCS over lines — scripts are a few hundred lines, so quadratic is fine.
+ */
+
+function lcsTable(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const t = new Array(n + 1);
+    for (let i = 0; i <= n; i++) t[i] = new Uint32Array(m + 1);
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            t[i][j] = a[i] === b[j] ? t[i + 1][j + 1] + 1 : Math.max(t[i + 1][j], t[i][j + 1]);
+        }
+    }
+    return t;
+}
+
+/** @returns {Array<{ kind: ' '|'-'|'+', line: string, a?: number, b?: number }>} */
+function diffLines(a, b) {
+    const t = lcsTable(a, b);
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            out.push({ kind: ' ', line: a[i], a: i, b: j });
+            i++;
+            j++;
+        } else if (t[i + 1][j] >= t[i][j + 1]) {
+            out.push({ kind: '-', line: a[i], a: i });
+            i++;
+        } else {
+            out.push({ kind: '+', line: b[j], b: j });
+            j++;
+        }
+    }
+    while (i < a.length) out.push({ kind: '-', line: a[i++] });
+    while (j < b.length) out.push({ kind: '+', line: b[j++] });
+    return out;
+}
+
+/**
+ * @param {string} oldText
+ * @param {string} newText
+ * @param {{ context?: number, fromName?: string, toName?: string }} [opts]
+ * @returns {{ text: string, added: number, removed: number }}
+ */
+// a text's lines, without the empty one a trailing newline would produce
+function toLines(text) {
+    const str = String(text ?? '');
+    if (str === '') return [];
+    const lines = str.split('\n');
+    if (lines[lines.length - 1] === '') lines.pop();
+    return lines;
+}
+
+function unifiedDiff(oldText, newText, opts = {}) {
+    const context = opts.context ?? 3;
+    const a = toLines(oldText);
+    const b = toLines(newText);
+    const ops = diffLines(a, b);
+    let added = 0;
+    let removed = 0;
+    for (const op of ops) {
+        if (op.kind === '+') added++;
+        else if (op.kind === '-') removed++;
+    }
+    const lines = [`--- ${opts.fromName || 'a'}`, `+++ ${opts.toName || 'b'}`];
+    if (added === 0 && removed === 0) return { text: '', added, removed };
+    // hunks: runs of changes with `context` lines around them
+    let idx = 0;
+    while (idx < ops.length) {
+        if (ops[idx].kind === ' ') {
+            idx++;
+            continue;
+        }
+        let start = Math.max(0, idx - context);
+        let end = idx;
+        while (end < ops.length) {
+            // extend the hunk while changes are within 2*context of each other
+            let next = end;
+            while (next < ops.length && ops[next].kind !== ' ') next++;
+            let gap = next;
+            while (gap < ops.length && ops[gap].kind === ' ' && gap - next < 2 * context) gap++;
+            if (gap < ops.length && ops[gap].kind !== ' ' && gap - next < 2 * context) {
+                end = gap;
+                continue;
+            }
+            end = Math.min(ops.length, next + context);
+            break;
+        }
+        const hunk = ops.slice(start, end);
+        const aStart = (hunk.find((o) => o.a !== undefined)?.a ?? (hunk[0].b !== undefined ? aIndexBefore(ops, start) : 0)) + 1;
+        const bStart = (hunk.find((o) => o.b !== undefined)?.b ?? bIndexBefore(ops, start)) + 1;
+        const aLen = hunk.filter((o) => o.kind !== '+').length;
+        const bLen = hunk.filter((o) => o.kind !== '-').length;
+        lines.push(`@@ -${aStart},${aLen} +${bStart},${bLen} @@`);
+        for (const o of hunk) lines.push(o.kind + o.line);
+        idx = end;
+    }
+    return { text: lines.join('\n'), added, removed };
+}
+
+function aIndexBefore(ops, k) {
+    for (let i = k - 1; i >= 0; i--) if (ops[i].a !== undefined) return ops[i].a + 1;
+    return 0;
+}
+function bIndexBefore(ops, k) {
+    for (let i = k - 1; i >= 0; i--) if (ops[i].b !== undefined) return ops[i].b + 1;
+    return 0;
+}
+
+module.exports = { unifiedDiff, diffLines };