smart-home-engine 1.19.1 → 1.20.1

package/dist/web/assets/{tsMode-DeZpXliO.js → tsMode-BNcOSQVq.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-home-engine",
-    "version": "1.19.1",
+    "version": "1.20.1",
     "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/influx.js

@@ -1,16 +1,38 @@
 '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;
+
+function v1Timeout() {
+    return Number(_opts.timeout) || V1_TIMEOUT_MS;
+}
 
 /**
  * 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 +44,143 @@ 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(v1Timeout()),
+    });
+    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(v1Timeout()),
+    });
+    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, "\\'");
+}
+
+/**
+ * Escape a string for use inside an InfluxQL double-quoted identifier
+ * (measurement/tag/field name).
+ * @param {string} s
+ */
+function escapeIdent(s) {
+    return String(s).replace(/"/g, '\\"');
+}
+
+module.exports = { init, getClient, getOpts, getMode, buildLine, v1Write, v1Query, escapeQL, escapeIdent };

package/src/sandbox/influx-sandbox.js

@@ -5,30 +5,66 @@ 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;
+}
+
+/**
+ * Map v1 result rows to the { ts, val } shape, newest-trimmed to n (LIMIT
+ * applies per series in InfluxQL, so multi-series results must be merged and
+ * re-trimmed), sorted oldest-first.
+ * @param {object[]} rows
+ * @param {number} [n]
+ */
+function v1Points(rows, n) {
+    const pts = rows.map((r) => ({ ts: r.time, val: v1RowVal(r) })).sort((a, b) => b.ts - a.ts);
+    return (n ? pts.slice(0, Number(n)) : pts).reverse();
+}
+
 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 +85,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);
@@ -73,15 +113,32 @@ 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.
+         * Return the last N recorded values for an MQTT topic (last 30 days).
+         * v2: assumes points carry a "topic" tag, value from "_value".
+         * v1: tries a measurement named like the topic first (influx4mqtt-style
+         * schema), then falls back to a "topic" tag scan; value from the
+         * "value" field, 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') {
+                // Fast path: measurement named like the topic (the common
+                // mqtt-to-influx v1 schema, e.g. influx4mqtt). Fallback: points
+                // stored with a "topic" tag — that needs a scan across all
+                // measurements, so keep it time-bounded (30d, like the v2 path).
+                const mQl = `SELECT * FROM "${influx.escapeIdent(topic)}" WHERE time >= now() - 30d ORDER BY time DESC LIMIT ${Number(n)}`;
+                return influx.v1Query(mQl).then((rows) => {
+                    if (rows.length) return v1Points(rows, n);
+                    const tagQl = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND time >= now() - 30d ORDER BY time DESC LIMIT ${Number(n)}`;
+                    return influx.v1Query(tagQl).then((tagRows) => v1Points(tagRows, n));
+                });
+            }
             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 +152,20 @@ 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 bounds = `time >= ${fromMs}ms AND time <= ${toMs}ms`;
+                const mQl = `SELECT * FROM "${influx.escapeIdent(topic)}" WHERE ${bounds}`;
+                return influx.v1Query(mQl).then((rows) => {
+                    if (rows.length) return v1Points(rows);
+                    const tagQl = `SELECT * FROM /.*/ WHERE "topic" = '${influx.escapeQL(topic)}' AND ${bounds}`;
+                    return influx.v1Query(tagQl).then((tagRows) => v1Points(tagRows));
+                });
+            }
             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]