@bldgblocks/node-red-contrib-control 0.1.37 → 0.2.0

package/nodes/global-setter.js

@@ -59,7 +59,8 @@ module.exports = function(RED) {
                 // Send properly formed state object downstream after full initialization
                 // Allows network-register and other downstream nodes to register on startup
                 // Use setTimeout with delay to allow getter nodes time to establish their event listeners
-                setTimeout(() => {
+                initTimer = setTimeout(() => {
+                    initTimer = null;
                     // Emit event so getter nodes with 'always' update mode receive initial value
                     RED.events.emit("bldgblocks:global:value-changed", {
                         key: node.varName,
@@ -91,16 +92,46 @@ module.exports = function(RED) {
                 }
                 node.isBusy = true;
 
-                // Evaluate Dynamic Properties (Exact same logic as before)
+                // Resolve write priority — three sources, in order of precedence:
+                //   1. msg.priority (number 1-16 or "default") — explicit per-message override
+                //   2. msg.context  ("priority1"–"priority16" or "default") — tagged-input pattern (matches priority-block)
+                //   3. Configured writePriority (dropdown / msg / flow typed-input)
                 try {
-                    const evaluations = [];
-                    evaluations.push(
-                        utils.requiresEvaluation(config.writePriorityType) 
-                            ? utils.evaluateNodeProperty(config.writePriority, config.writePriorityType, node, msg)
-                            : Promise.resolve(node.writePriority)
-                    );
-                    const results = await Promise.all(evaluations);   
-                    node.writePriority = results[0];
+                    if (msg.hasOwnProperty("priority")) {
+                        // Source 1: msg.priority (direct number or "default")
+                        const mp = msg.priority;
+                        if (mp === "default") {
+                            node.writePriority = "default";
+                        } else {
+                            const p = parseInt(mp, 10);
+                            if (isNaN(p) || p < 1 || p > 16) {
+                                node.isBusy = false;
+                                return utils.sendError(node, msg, done, `Invalid msg.priority: ${mp}`);
+                            }
+                            node.writePriority = String(p);
+                        }
+                    } else if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
+                        // Source 2: msg.context tagged-input ("priority8", "default", etc.)
+                        // "reload" is handled separately below — skip it here
+                        const ctx = msg.context;
+                        const priorityMatch = /^priority([1-9]|1[0-6])$/.exec(ctx);
+                        if (priorityMatch) {
+                            node.writePriority = priorityMatch[1];
+                        } else if (ctx === "default") {
+                            node.writePriority = "default";
+                        }
+                        // Other contexts (e.g. "reload") fall through — config stays as-is
+                    } else {
+                        // Source 3: Configured typed-input (dropdown, msg path, flow variable)
+                        const evaluations = [];
+                        evaluations.push(
+                            utils.requiresEvaluation(config.writePriorityType) 
+                                ? utils.evaluateNodeProperty(config.writePriority, config.writePriorityType, node, msg)
+                                : Promise.resolve(node.writePriority)
+                        );
+                        const results = await Promise.all(evaluations);   
+                        node.writePriority = results[0];
+                    }
                 } catch (err) {
                     throw new Error(`Property Eval Error: ${err.message}`);
                 } finally {
@@ -120,7 +151,7 @@ module.exports = function(RED) {
                     await utils.setGlobalState(node, node.varName, node.storeName, state);
                     
                     prefix = state.activePriority === 'default' ? '' : 'P';
-                    const statusText = `reload: ${prefix}${state.activePriority}:${state.value}${state.units}`;
+                    const statusText = `reload: ${prefix}${state.activePriority}:${state.value}${state.units || ''}`;
                     
                     return utils.sendSuccess(node, { ...state }, done, statusText, null, "dot");
                 }
@@ -158,8 +189,16 @@ module.exports = function(RED) {
 
                 // Check for change
                 if (value === state.value && priority === state.activePriority) {
+                    // Ensure payload stays in sync with value
+                    state.payload = state.value;
+                    // Persist even when output unchanged — the priority array itself changed
+                    await utils.setGlobalState(node, node.varName, node.storeName, state);
+                    if (node.storeName !== 'default') {
+                        await utils.setGlobalState(node, node.varName, 'default', state);
+                    }
                     prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
-                    const noChangeText = `no change: ${prefix}${node.writePriority}:${state.value}${state.units}`;
+                    const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
+                    const noChangeText = `no change: ${prefix}${node.writePriority}:${inputValue} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units || ''}`;
                     utils.setStatusUnchanged(node, noChangeText);
                     // Pass message through even if no context change
                     send({ ...state });
@@ -199,7 +238,7 @@ module.exports = function(RED) {
 
                 prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
                 const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
-                const statusText = `write: ${prefix}${node.writePriority}:${inputValue}${state.units} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units}`;
+                const statusText = `write: ${prefix}${node.writePriority}:${inputValue}${state.units || ''} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units || ''}`;
 
                 RED.events.emit("bldgblocks:global:value-changed", {
                     key: node.varName,
@@ -216,8 +255,8 @@ module.exports = function(RED) {
         });
 
         node.on('close', function(removed, done) {
+            if (initTimer) { clearTimeout(initTimer); initTimer = null; }
             if (removed && node.varName) {
-                RED.events.removeAllListeners("bldgblocks:global:value-changed");
                 // Callback style safe for close
                 node.context().global.set(node.varName, undefined, node.storeName, function() {
                     done();
@@ -228,4 +267,47 @@ module.exports = function(RED) {
         });
     }
     RED.nodes.registerType("global-setter", GlobalSetterNode);
+
+    // --- Admin endpoint: Clear all priority slots for a given setter node ---
+    RED.httpAdmin.post('/global-setter/:id/clear-priorities', RED.auth.needsPermission('global-setter.write'), async function(req, res) {
+        const targetNode = RED.nodes.getNode(req.params.id);
+        if (!targetNode) {
+            return res.status(404).json({ error: "Node not found" });
+        }
+        try {
+            let state = await utils.getGlobalState(targetNode, targetNode.varName, targetNode.storeName);
+            if (!state || typeof state !== 'object' || !state.priority) {
+                return res.status(200).json({ message: "No state to clear" });
+            }
+            // Clear all 16 priority slots
+            for (let i = 1; i <= 16; i++) {
+                state.priority[i] = null;
+            }
+            // Recalculate winner (will fall back to default)
+            const { value, priority } = utils.getHighestPriority(state);
+            state.payload = value;
+            state.value = value;
+            state.activePriority = priority;
+            state.metadata.lastSet = new Date().toISOString();
+            state.metadata.sourceId = targetNode.id;
+
+            await utils.setGlobalState(targetNode, targetNode.varName, targetNode.storeName, state);
+            if (targetNode.storeName !== 'default') {
+                await utils.setGlobalState(targetNode, targetNode.varName, 'default', state);
+            }
+
+            RED.events.emit("bldgblocks:global:value-changed", {
+                key: targetNode.varName,
+                store: targetNode.storeName,
+                data: state
+            });
+            utils.setStatusOK(targetNode, `cleared: default:${state.value}`);
+            targetNode.send({ ...state });
+
+            res.status(200).json({ message: "Priorities cleared", value: state.value, activePriority: state.activePriority });
+        } catch (err) {
+            targetNode.error(`Clear priorities error: ${err.message}`);
+            res.status(500).json({ error: err.message });
+        }
+    });
 }

package/nodes/history-buffer.js

@@ -20,9 +20,10 @@ module.exports = function(RED) {
         // Constants
         const TRENDS_DIR = getTrendsDirPath();
         // Use node ID in filename to prevent collisions between multiple history nodes
-        const BUFFER_FILE = path.join(TRENDS_DIR, `buffer_${node.id}.json`);
-        // Legacy file path for migration
+        const BUFFER_FILE = path.join(TRENDS_DIR, `buffer_${node.id}.jsonl`);
+        // Legacy file paths for migration
         const LEGACY_BUFFER_FILE = path.join(TRENDS_DIR, 'buffer_current.json');
+        const LEGACY_BUFFER_FILE_JSON = path.join(TRENDS_DIR, `buffer_${node.id}.json`);
         
         const COMMIT_INTERVAL_MS = 30 * 1000;  // 30 seconds
         const PRUNE_INTERVAL_MS = 60 * 1000;   // 60 seconds
@@ -122,6 +123,26 @@ module.exports = function(RED) {
             const now = new Date();
             const currentTimestamp = Math.floor(now.getTime() / 1000);
 
+            // Migrate old .json buffer to .jsonl if it exists
+            try {
+                await fs.promises.access(LEGACY_BUFFER_FILE_JSON);
+                // If the new .jsonl doesn't exist, rename; otherwise append and delete
+                try {
+                    await fs.promises.access(BUFFER_FILE);
+                    // Both exist: append old into new, then remove old
+                    const oldData = await fs.promises.readFile(LEGACY_BUFFER_FILE_JSON);
+                    if (oldData.length > 0) {
+                        await fs.promises.appendFile(BUFFER_FILE, oldData);
+                    }
+                    await fs.promises.unlink(LEGACY_BUFFER_FILE_JSON);
+                } catch (e) {
+                    // New .jsonl doesn't exist, just rename
+                    await fs.promises.rename(LEGACY_BUFFER_FILE_JSON, BUFFER_FILE);
+                }
+            } catch (err) {
+                // No legacy .json buffer, nothing to migrate
+            }
+
             // Check for this node's specific buffer
             try {
                 const stats = await fs.promises.stat(BUFFER_FILE);
@@ -136,7 +157,7 @@ module.exports = function(RED) {
 
                 if (isStale) {
                     const fileTs = Math.floor(stats.mtimeMs / 1000);
-                    const newName = path.join(TRENDS_DIR, `trend_${fileTs}_${node.id}.json`);
+                    const newName = path.join(TRENDS_DIR, `trend_${fileTs}_${node.id}.jsonl`);
                     await fs.promises.rename(BUFFER_FILE, newName);
                 }
 
@@ -147,7 +168,7 @@ module.exports = function(RED) {
             // Check for legacy buffer (migration)
             try {
                 await fs.promises.access(LEGACY_BUFFER_FILE);
-                const legacyName = path.join(TRENDS_DIR, `trend_${currentTimestamp}_legacy.json`);
+                const legacyName = path.join(TRENDS_DIR, `trend_${currentTimestamp}_legacy.jsonl`);
                 await fs.promises.rename(LEGACY_BUFFER_FILE, legacyName);
             } catch (err) {
                 // Ignore
@@ -157,9 +178,9 @@ module.exports = function(RED) {
         async function getHistoricalFiles() {
             try {
                 const files = await fs.promises.readdir(TRENDS_DIR);
-                // Filter for our files: trend_TIMESTAMP_*.json
+                // Filter for our files: trend_TIMESTAMP_*.json or .jsonl
                 return files
-                    .filter(f => f.startsWith('trend_') && f.endsWith('.json'))
+                    .filter(f => f.startsWith('trend_') && (f.endsWith('.json') || f.endsWith('.jsonl')))
                     .sort(); // String sort works for fixed-length timestamps usually, but numeric would be safer
             } catch (err) {
                 return [];
@@ -250,20 +271,10 @@ module.exports = function(RED) {
                 // Reset live buffer immediately so new messages go into next batch
                 liveBuffer = [];
                 
-                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n');
+                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n') + '\n';
                 
                 try {
-                    // Only add prefix newline if file exists and has content (simplified check)
-                    // We'll let the next append handle its own newline or just ensure we join efficiently.
-                    // Actually, safest is to append WITH a preceding newline if file exists.
-                    
-                    let prefix = '';
-                    try {
-                        const stats = await fs.promises.stat(BUFFER_FILE);
-                        if (stats.size > 0) prefix = '\n';
-                    } catch(e) { /* File doesn't exist, no prefix needed */ }
-
-                    await fs.promises.appendFile(BUFFER_FILE, prefix + lines);
+                    await fs.promises.appendFile(BUFFER_FILE, lines);
                 } catch (err) {
                     node.warn(`Buffer commit failed: ${err.message}`);
                     // Put points back at the start of buffer if write failed
@@ -336,15 +347,9 @@ module.exports = function(RED) {
             if (liveBuffer.length > 0) {
                 const pointsToCommit = liveBuffer;
                 liveBuffer = []; // Clear memory
-                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n');
+                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n') + '\n';
                 try {
-                    let prefix = '';
-                    try {
-                        const stats = await fs.promises.stat(BUFFER_FILE);
-                        if (stats.size > 0) prefix = '\n';
-                    } catch(e) { /* File doesn't exist */ }
-
-                    await fs.promises.appendFile(BUFFER_FILE, prefix + lines);
+                    await fs.promises.appendFile(BUFFER_FILE, lines);
                 } catch (err) {
                     // If append fails, we might lose these points during rotation, 
                     // put them back and abort rotation. Use concat for safety.
@@ -356,7 +361,7 @@ module.exports = function(RED) {
 
             // Perform Rotation (Rename)
             const timestamp = Math.floor(Date.now() / 1000);
-            const newName = path.join(TRENDS_DIR, `trend_${timestamp}_${node.id}.json`);
+            const newName = path.join(TRENDS_DIR, `trend_${timestamp}_${node.id}.jsonl`);
 
             try {
                 await fs.promises.access(BUFFER_FILE);

package/nodes/history-collector.html

@@ -95,7 +95,9 @@
                 
                 // 1. Update Series Dropdown
                 const seriesOptions = configNode && configNode.series ?
-                    configNode.series.map(s => ({ value: s.seriesName, label: s.seriesName })) :
+                    configNode.series
+                        .map(s => ({ value: s.seriesName, label: s.seriesName }))
+                        .sort((a, b) => a.label.localeCompare(b.label, undefined, { sensitivity: 'base' })) :
                     [];
                 
                 seriesInput.typedInput('types', [{

package/nodes/history-collector.js

@@ -134,7 +134,7 @@ module.exports = function(RED) {
                 msg.measurement = escapedMeasurementName;
                 msg.payload = line;
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'object') {
                 msg.measurement = escapedMeasurementName;
                 msg.payload = {
@@ -144,7 +144,7 @@ module.exports = function(RED) {
                     timestamp: timestamp
                 };
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'objectArray') {
                 msg.measurement = escapedMeasurementName;
                 msg.timestamp = timestamp;
@@ -155,7 +155,7 @@ module.exports = function(RED) {
                     tagsObj
                 ]
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'batchObject') {
                 msg.payload = {
                     measurement: escapedMeasurementName,
@@ -166,7 +166,7 @@ module.exports = function(RED) {
                     tags: tagsObj
                 }
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             }
 
             if (done) done();

package/nodes/history-config.html

@@ -149,8 +149,11 @@
                 );
             }
 
-            (node.series || []).forEach(addRow);
-            if (node.series.length === 0) {
+            const sortedSeries = (node.series || []).slice().sort((a, b) =>
+                (a.seriesName || '').localeCompare(b.seriesName || '', undefined, { sensitivity: 'base' })
+            );
+            sortedSeries.forEach(addRow);
+            if (sortedSeries.length === 0) {
                 addRow({seriesName: "OutsideTemp", seriesUnits: "°F"});
             }
 
@@ -223,6 +226,9 @@
                 RED.notify("At least one valid series is required", "error");
                 throw new Error("No valid series");
             }
+            series.sort((a, b) =>
+                (a.seriesName || '').localeCompare(b.seriesName || '', undefined, { sensitivity: 'base' })
+            );
             this.series = series;
             this.name = cleanSaveStr($("#node-config-input-name").val()) || 'default';
         }

package/nodes/network-point-read.js

@@ -147,9 +147,14 @@ module.exports = function(RED) {
             
             // Check for error response
             if (data.error) {
+                // During startup phase, suppress error display (network still coming online)
+                if (data.isStartupPhase) {
+                    // Keep stale value, don't show error - just stay in waiting state
+                    return;
+                }
                 const errorText = `Read failed for point #${node.pointId}: ${data.errorMessage || "Unknown error"}`;
                 utils.setStatusError(node, `Error: ${data.errorMessage || "Unknown error"}`);
-                node.error(errorText);  // Show in debug panel
+                //node.error(errorText);  // Show in debug panel
                 // Don't update cache on error, keep stale value
                 return;
             }

package/nodes/network-point-register.html

@@ -126,7 +126,7 @@
                 });
 
                 // Also check deployed registry for any points not visible in editor
-                $.getJSON(`/network-point-registry/list/${registry}`, function (data) {
+                $.getJSON(`network-point-registry/list/${registry}`, function (data) {
                     const maxDeployedId = data.reduce((max, pt) => Math.max(max, pt.id), 0);
                     const next = Math.max(maxEditorId, maxDeployedId) + 1;
                     idInput.val(next);

package/nodes/network-service-bridge.js

@@ -112,10 +112,18 @@ module.exports = function(RED) {
                     const pending = node.pendingRequests[data.requestId];
                     delete node.pendingRequests[data.requestId];
                     
-                    // Suppress error notification during startup phase
-                    // (allows network to come online without nuisance errors)
                     if (pending.isStartupPhase) {
-                        // Silently drop timeout during startup
+                        // During startup: still notify point-read to reset isPollPending,
+                        // but suppress error logging (network may still be coming online)
+                        RED.events.emit('pointReference:response', {
+                            sourceNodeId: data.sourceNodeId,
+                            pointId: data.pointId,
+                            value: null,
+                            error: true,
+                            errorMessage: "Startup timeout",
+                            requestId: data.requestId,
+                            isStartupPhase: true
+                        });
                         return;
                     }
                     
@@ -195,10 +203,16 @@ module.exports = function(RED) {
                     const pending = node.pendingRequests[data.requestId];
                     delete node.pendingRequests[data.requestId];
                     
-                    // Suppress error notification during startup phase
-                    // (allows network to come online without nuisance errors)
                     if (pending.isStartupPhase) {
-                        // Silently drop timeout during startup
+                        // During startup: still notify point-write to reset pending state,
+                        // but suppress error logging
+                        RED.events.emit('pointWrite:response', {
+                            sourceNodeId: pending.sourceNodeId,
+                            pointId: data.pointId,
+                            error: "Startup timeout",
+                            requestId: data.requestId,
+                            isStartupPhase: true
+                        });
                         return;
                     }
                     
@@ -240,14 +254,16 @@ module.exports = function(RED) {
             // ================================================================
             
             // Check if this looks like a point response (has network.pointId or status.pointId)
-            const responsePointId = msg.network?.pointId ?? msg.status?.pointId ?? msg.pointId;
+            const rawPointId = msg.network?.pointId ?? msg.status?.pointId ?? msg.pointId;
+            // Normalize to number - point-read stores pointId as int, but WebSocket responses may return strings
+            const responsePointId = rawPointId !== undefined && rawPointId !== null ? parseInt(rawPointId, 10) : undefined;
             const responseValue = msg.value ?? msg.payload;
             const statusCode = msg.status?.code;
             const statusMessage = msg.status?.message || "";
             const isError = statusCode === "error";
             
-            // Valid response if we have a pointId (value can be null/undefined on error)
-            const isValidResponse = responsePointId !== undefined;
+            // Valid response if we have a valid numeric pointId
+            const isValidResponse = responsePointId !== undefined && !isNaN(responsePointId);
             
             if (isValidResponse) {
                 // Find ALL matching pending requests by pointId
@@ -313,8 +329,10 @@ module.exports = function(RED) {
                         updateStatus();
                     }
                 } else {
-                    // Response without matching request - could be stale or unsolicited
-                    utils.setStatusWarn(node, `Unmatched response for point #${responsePointId}`);
+                    // Response without matching request - duplicate, stale, or already timed-out
+                    // This is normal when remote has multiple WebSocket nodes or response arrives after timeout cleanup
+                    // Don't change node status - just log at trace level
+                    node.trace(`Ignoring duplicate/stale response for point #${responsePointId}`);
                 }
 
                 if (done) done();
@@ -358,6 +376,11 @@ module.exports = function(RED) {
         // Node lifecycle
         // ====================================================================
         node.on("close", function(done) {
+            // Clear startup timer
+            if (node.startupTimer) {
+                clearTimeout(node.startupTimer);
+                node.startupTimer = null;
+            }
             // Clear pending requests on close
             node.pendingRequests = {};
             // Remove event listeners
@@ -369,6 +392,15 @@ module.exports = function(RED) {
         // ====================================================================
         // Initialize
         // ====================================================================
+        // One-shot timer to guarantee startup delay completes even if no messages arrive
+        node.startupTimer = setTimeout(() => {
+            if (!node.startupComplete) {
+                node.startupComplete = true;
+                updateStatus();
+            }
+            node.startupTimer = null;
+        }, node.startupDelay * 1000);
+
         updateStatus();
     }