smart-home-engine 1.19.0 → 1.20.0

package/dist/web/assets/{tsMode-DXWg2fgD.js → tsMode-Dbzvu1EX.js}

@@ -1,4 +1,4 @@
-import{m as O}from"./monaco-langs-Dt8a9eeo.js";import{t as I}from"./index-xdnNresq.js";/*!-----------------------------------------------------------------------------
+import{m as O}from"./monaco-langs-Dt8a9eeo.js";import{t as I}from"./index-BUev42o8.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

package/dist/web/index.html

@@ -172,7 +172,7 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-xdnNresq.js"></script>
+      <script type="module" crossorigin src="/assets/index-BUev42o8.js"></script>
       <link rel="modulepreload" crossorigin href="/assets/monaco-langs-Dt8a9eeo.js">
       <link rel="stylesheet" crossorigin href="/assets/monaco-langs-DyX1CsEw.css">
       <link rel="stylesheet" crossorigin href="/assets/index-nf1nG74s.css">

package/package.json

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

package/service/smart-home-engine.service

@@ -9,6 +9,8 @@ User=she
 Group=she
 Restart=on-failure
 RestartSec=5s
+TimeoutStopSec=3
+KillMode=mixed
 
 ExecStart=/usr/local/bin/she --data-dir /var/lib/she
 

package/src/index.js

@@ -194,14 +194,15 @@ const _global = {};
 
 // ── Event-loop heartbeat ─────────────────────────────────────────────────────
 let _blockingScript = null;
+let _blockingScriptTs = 0; // timestamp when the last _dispatch() call finished
 
 /** Wrap a user callback dispatch so the heartbeat can identify the active script. */
 function _dispatch(label, fn) {
     _blockingScript = label;
     fn();
-    setImmediate(() => {
-        _blockingScript = null;
-    });
+    // Record end-time synchronously — no setImmediate, which would race with the
+    // heartbeat timer when blocking occurs inside a poll-phase (I/O) callback.
+    _blockingScriptTs = Date.now();
 }
 
 // Sun scheduling
@@ -361,7 +362,7 @@ require('./web/server').setStatsProvider(() => {
     const eluDelta = performance.eventLoopUtilization(_prevElu);
     _prevElu = performance.eventLoopUtilization();
     const elMeanMs = Math.round(_elHisto.mean / 1e6);
-    const elP99Ms = Math.round(_elHisto.percentile(99) / 1e6);
+    const elMaxMs = Math.round(_elHisto.max / 1e6);
     _elHisto.reset();
     const mem = process.memoryUsage();
     const memMb = Math.round(mem.rss / 1048576);
@@ -402,7 +403,7 @@ require('./web/server').setStatsProvider(() => {
         cpuPercent,
         eluPercent: Math.round(eluDelta.utilization * 100),
         elMeanMs,
-        elP99Ms,
+        elMaxMs,
     };
 });
 
@@ -1512,9 +1513,11 @@ function start() {
         const _hbTimer = setInterval(() => {
             const now = Date.now();
             const lag = now - _lastBeat - _hbInterval;
+            const prevBeat = _lastBeat;
             _lastBeat = now;
             if (lag > _hbThreshold) {
-                const label = _blockingScript ?? 'unknown';
+                // Attribute to a script only if it dispatched a callback since the previous beat.
+                const label = _blockingScriptTs >= prevBeat ? (_blockingScript ?? 'unknown') : 'unknown';
                 if (lag > 2000) {
                     log.warn(`event loop blocked ${lag}ms — script: ${label}`);
                 } else {

package/src/influx.js

@@ -1,16 +1,34 @@
 'use strict';
 
-let _client = null;
+let _client = null; // v2 client (@influxdata/influxdb-client)
 let _opts = null;
+let _mode = null; // 'v1' | 'v2' | null
+
+const V1_TIMEOUT_MS = 10000;
 
 /**
  * Initialise the InfluxDB client.  Called from index.js when config.influx is set.
- * @param {{ url: string, token: string, org: string, bucket: string }} opts
+ *
+ * v2 (token/org/bucket):      { url, token, org, bucket }
+ * v1 (database/user/password): { url, database, username?, password?, retentionPolicy?, version?: 1 }
+ *
+ * The API version is taken from opts.version when present; otherwise it is
+ * inferred: a `database` key (and no `token`) means v1, a `token` means v2.
+ * @param {object} opts
  */
 function init(opts) {
-    if (!opts || !opts.url || !opts.token) return;
+    if (!opts || !opts.url) return;
+    const version = Number(opts.version) || (opts.database && !opts.token ? 1 : 2);
+    if (version === 1) {
+        if (!opts.database) return;
+        _opts = opts;
+        _mode = 'v1';
+        return;
+    }
+    if (!opts.token) return;
     const { InfluxDB } = require('@influxdata/influxdb-client');
     _opts = opts;
+    _mode = 'v2';
     _client = new InfluxDB({ url: opts.url, token: opts.token });
 }
 
@@ -22,4 +40,134 @@ function getOpts() {
     return _opts;
 }
 
-module.exports = { init, getClient, getOpts };
+/** @returns {'v1'|'v2'|null} */
+function getMode() {
+    return _mode;
+}
+
+// ── v1 (InfluxDB 1.x) HTTP API ──────────────────────────────────────────────
+
+function v1Headers() {
+    const headers = {};
+    if (_opts.username) {
+        headers.Authorization = 'Basic ' + Buffer.from(`${_opts.username}:${_opts.password || ''}`).toString('base64');
+    }
+    return headers;
+}
+
+/**
+ * Escape a measurement name for line protocol (commas and spaces).
+ * @param {string} s
+ */
+function escapeMeasurement(s) {
+    return String(s).replace(/,/g, '\\,').replace(/ /g, '\\ ');
+}
+
+/**
+ * Escape a tag key, tag value or field key for line protocol (commas, equals signs, spaces).
+ * @param {string} s
+ */
+function escapeTag(s) {
+    return String(s).replace(/,/g, '\\,').replace(/=/g, '\\=').replace(/ /g, '\\ ');
+}
+
+/**
+ * Serialise a field value for line protocol: booleans and finite numbers pass
+ * through natively, everything else becomes a quoted string.
+ * @param {*} v
+ */
+function fieldValue(v) {
+    if (typeof v === 'boolean') return v ? 'true' : 'false';
+    if (typeof v === 'number' && Number.isFinite(v)) return String(v);
+    return '"' + String(v).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}
+
+/**
+ * Build a single line-protocol line.
+ * @param {string} measurement
+ * @param {object} fields          e.g. { temperature: 21.5 }
+ * @param {object} [tags]          e.g. { room: 'living' }
+ * @param {Date|number} [timestamp] ms precision
+ * @returns {string}
+ */
+function buildLine(measurement, fields, tags, timestamp) {
+    let line = escapeMeasurement(measurement);
+    if (tags) {
+        for (const [k, v] of Object.entries(tags)) line += `,${escapeTag(k)}=${escapeTag(v)}`;
+    }
+    line +=
+        ' ' +
+        Object.entries(fields)
+            .map(([k, v]) => `${escapeTag(k)}=${fieldValue(v)}`)
+            .join(',');
+    if (timestamp !== undefined) {
+        const ts = timestamp instanceof Date ? timestamp.getTime() : Number(timestamp);
+        line += ' ' + ts;
+    }
+    return line;
+}
+
+/**
+ * Write line-protocol data via the v1 endpoint (POST /write?db=…&precision=ms).
+ * @param {string} lines one or more line-protocol lines, newline-separated
+ * @returns {Promise<void>}
+ */
+async function v1Write(lines) {
+    const params = new URLSearchParams({ db: _opts.database, precision: 'ms' });
+    if (_opts.retentionPolicy) params.set('rp', _opts.retentionPolicy);
+    const res = await fetch(`${_opts.url.replace(/\/$/, '')}/write?${params}`, {
+        method: 'POST',
+        headers: v1Headers(),
+        body: lines,
+        signal: AbortSignal.timeout(V1_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`influx v1 write failed: HTTP ${res.status} ${body}`.trim());
+    }
+}
+
+/**
+ * Run an InfluxQL query via the v1 endpoint (GET /query?db=…&q=…&epoch=ms) and
+ * flatten the result into plain row objects: one object per value row, with the
+ * series' columns as keys, series tags merged in, and the measurement name as
+ * `_measurement`. `time` is a millisecond timestamp (epoch=ms).
+ * @param {string} q InfluxQL query
+ * @returns {Promise<object[]>}
+ */
+async function v1Query(q) {
+    const params = new URLSearchParams({ db: _opts.database, q, epoch: 'ms' });
+    const res = await fetch(`${_opts.url.replace(/\/$/, '')}/query?${params}`, {
+        headers: v1Headers(),
+        signal: AbortSignal.timeout(V1_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`influx v1 query failed: HTTP ${res.status} ${body}`.trim());
+    }
+    const json = await res.json();
+    const rows = [];
+    for (const result of json.results || []) {
+        if (result.error) throw new Error(`influx v1 query failed: ${result.error}`);
+        for (const series of result.series || []) {
+            for (const values of series.values || []) {
+                const row = { _measurement: series.name, ...series.tags };
+                series.columns.forEach((col, i) => {
+                    row[col] = values[i];
+                });
+                rows.push(row);
+            }
+        }
+    }
+    return rows;
+}
+
+/**
+ * Escape a string for use inside an InfluxQL single-quoted string literal.
+ * @param {string} s
+ */
+function escapeQL(s) {
+    return String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+module.exports = { init, getClient, getOpts, getMode, buildLine, v1Write, v1Query, escapeQL };

package/src/sandbox/influx-sandbox.js

@@ -5,30 +5,54 @@ const influx = require('../influx');
 /**
  * Sandbox module — adds she.influx.* to every script context.
  *
+ * Works against InfluxDB 2.x (url/token/org/bucket → Flux) and InfluxDB 1.x
+ * (url/database/username/password → InfluxQL over the v1 HTTP API).
+ *
  * All methods return Promises and are no-ops (returning empty results) when
- * InfluxDB is not configured (no --influx.url / --influx.token in config).
+ * InfluxDB is not configured (no influx block in config).
  *
  * she.influx API:
- *   she.influx.query(fluxQuery)                         → Promise<object[]>
+ *   she.influx.query(query)                             → Promise<object[]>
+ *       (Flux in v2 mode, InfluxQL in v1 mode)
  *   she.influx.write(measurement, fields, tags, ts)     → Promise<void>
  *   she.influx.getLast(topic, n)                        → Promise<{ ts, val }[]>
  *   she.influx.getRange(topic, from, to)                → Promise<{ ts, val }[]>
  */
+
+/**
+ * Extract the value from a v1 result row: prefer the conventional "value"
+ * (then "val") field, otherwise take the first column that is not time/topic
+ * metadata.
+ * @param {object} row
+ */
+function v1RowVal(row) {
+    if (row.value !== undefined && row.value !== null) return row.value;
+    if (row.val !== undefined && row.val !== null) return row.val;
+    for (const [k, v] of Object.entries(row)) {
+        if (k === 'time' || k === 'topic' || k === '_measurement' || v === null || v === undefined) continue;
+        return v;
+    }
+    return null;
+}
+
 module.exports = function (she) {
     she.influx = {
         /**
-         * Execute a Flux query against InfluxDB.
-         * @param {string} fluxQuery
+         * Execute a query against InfluxDB — a Flux query in v2 mode, an
+         * InfluxQL query in v1 mode.
+         * @param {string} query
          * @returns {Promise<object[]>}
          */
-        query(fluxQuery) {
+        query(query) {
+            const mode = influx.getMode();
+            if (!mode) return Promise.resolve([]);
+            if (mode === 'v1') return influx.v1Query(query);
             const client = influx.getClient();
             const opts = influx.getOpts();
-            if (!client) return Promise.resolve([]);
             const queryApi = client.getQueryApi(opts.org);
             return new Promise((resolve, reject) => {
                 const rows = [];
-                queryApi.queryRows(fluxQuery, {
+                queryApi.queryRows(query, {
                     next(row, tableMeta) {
                         rows.push(tableMeta.toObject(row));
                     },
@@ -49,9 +73,13 @@ module.exports = function (she) {
          * @returns {Promise<void>}
          */
         write(measurement, fields, tags, timestamp) {
+            const mode = influx.getMode();
+            if (!mode) return Promise.resolve();
+            if (mode === 'v1') {
+                return influx.v1Write(influx.buildLine(measurement, fields, tags, timestamp));
+            }
             const client = influx.getClient();
             const opts = influx.getOpts();
-            if (!client) return Promise.resolve();
             const { Point } = require('@influxdata/influxdb-client');
             const writeApi = client.getWriteApi(opts.org, opts.bucket, 'ns');
             const point = new Point(measurement);
@@ -74,14 +102,29 @@ module.exports = function (she) {
 
         /**
          * Return the last N recorded values for an MQTT topic.
-         * Assumes data was stored with a "topic" tag and value in the "_value" field.
+         * Assumes data was stored with a "topic" tag; the value comes from the
+         * "_value" field (v2) or the "value" field (v1, falling back to the
+         * first data column). Results are sorted oldest-first.
          * @param {string} topic
          * @param {number} n
          * @returns {Promise<{ ts: number, val: any }[]>}
          */
         getLast(topic, n) {
+            const mode = influx.getMode();
+            if (!mode) return Promise.resolve([]);
+            if (mode === 'v1') {
+                // LIMIT applies per series in InfluxQL — query across all
+                // measurements, then merge, trim to n and sort ascending.
+                const ql = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' ORDER BY time DESC LIMIT ${Number(n)}`;
+                return influx.v1Query(ql).then((rows) =>
+                    rows
+                        .map((r) => ({ ts: r.time, val: v1RowVal(r) }))
+                        .sort((a, b) => b.ts - a.ts)
+                        .slice(0, Number(n))
+                        .reverse(),
+                );
+            }
             const opts = influx.getOpts();
-            if (!opts) return Promise.resolve([]);
             const safeTopic = topic.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
             const flux = `from(bucket: "${opts.bucket}")` + ` |> range(start: -30d)` + ` |> filter(fn: (r) => r["topic"] == "${safeTopic}")` + ` |> tail(n: ${Number(n)})`;
             return this.query(flux).then((rows) => rows.map((r) => ({ ts: new Date(r._time).getTime(), val: r._value })));
@@ -95,8 +138,15 @@ module.exports = function (she) {
          * @returns {Promise<{ ts: number, val: any }[]>}
          */
         getRange(topic, from, to) {
+            const mode = influx.getMode();
+            if (!mode) return Promise.resolve([]);
+            if (mode === 'v1') {
+                const fromMs = new Date(from).getTime();
+                const toMs = new Date(to).getTime();
+                const ql = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND time >= ${fromMs}ms AND time <= ${toMs}ms`;
+                return influx.v1Query(ql).then((rows) => rows.map((r) => ({ ts: r.time, val: v1RowVal(r) })).sort((a, b) => a.ts - b.ts));
+            }
             const opts = influx.getOpts();
-            if (!opts) return Promise.resolve([]);
             const safeTopic = topic.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
             const start = new Date(from).toISOString();
             const stop = new Date(to).toISOString();

package/src/web/log-ws.js

@@ -23,8 +23,8 @@ const LOG_BUFFER_MAX = 500;
 /**
  * Attach a WebSocketServer to an existing http.Server.
  * Clients connect to /she/ws. Once connected they receive:
- *   - { type: 'log', line: string }  — every pino log line
- *   - { type: 'ping' }               — keepalive every 30 s
+ *   - { type: 'log', level, msg, ts } — every daemon/script log entry
+ *   - { type: 'ping' }                — keepalive every 30 s
  *
  * @param {import('http').Server} httpServer
  * @param {(req: import('http').IncomingMessage) => boolean} [authCheck]