@frangoteam/fuxa-min 1.2.10 → 1.3.0

package/integrations/node-red/index.js

@@ -34,8 +34,8 @@ async function mountNodeRedIfInstalled({ app, server, settings, runtime, logger,
     // Minimal Node-RED settings; extend only what is really needed
     const redSettings = {
         httpAdminRoot: '/nodered/',
-        // Let Node-RED own the HTTP space at root; dashboard will live under /dashboard
-        httpNodeRoot: '/',
+        // Serve Node-RED HTTP nodes under /dashboard to avoid intercepting FUXA routes
+        httpNodeRoot: '/dashboard',
         userDir,
         nodesDir: [path.join(__dirname, 'node-red-contrib-fuxa')],
         flowFile: 'flows.json',
@@ -44,7 +44,7 @@ async function mountNodeRedIfInstalled({ app, server, settings, runtime, logger,
             tours: { enabled: false },
         },
         // Dashboard will be exposed at /dashboard/...
-        ui: { path: '/dashboard' },
+        ui: { path: '/' },
         // Values used by FlowFuse dashboard's ui_base.js for layout saves
         // These mirror the FUXA HTTP bind address so Node-RED can call its own /nodered/flows API
         uiHost: settings.uiHost,
@@ -99,10 +99,8 @@ async function mountNodeRedIfInstalled({ app, server, settings, runtime, logger,
             path: require('path'),
             util: require('util'),
             os: require('os'),
-            child_process: require('child_process'),
             http: require('http'),
             https: require('https'),
-            net: require('net'),
             dgram: require('dgram'),
             dns: require('dns'),
             url: require('url'),
@@ -114,40 +112,109 @@ async function mountNodeRedIfInstalled({ app, server, settings, runtime, logger,
             buffer: require('buffer'),
             sqlite3: require('sqlite3'),
             serialport: require('serialport'),
+            // Dangerous modules are opt-in only (see settings.nodeRedUnsafeModules)
+            ...(settings.nodeRedUnsafeModules ? {
+                child_process: require('child_process'),
+                net: require('net'),
+            } : {}),
         },
     };
 
     // Initialize Node-RED on the existing HTTP server (must be done before server.listen)
     RED.init(server, redSettings);
 
-    // Allow dashboard UI, its admin APIs and socket.io without extra JWT; enforce auth for the rest
+    const getCookieValue = (req, name) => {
+        const cookieHeader = req.headers.cookie;
+        if (!cookieHeader) return null;
+        const cookies = cookieHeader.split(';');
+        for (const cookie of cookies) {
+            const [key, ...rest] = cookie.trim().split('=');
+            if (key === name) {
+                return rest.join('=');
+            }
+        }
+        return null;
+    };
+
+    const verifyApiKey = (runtimeRef, apiKey) => {
+        return runtimeRef.apiKeys.getApiKeys().then(stored => {
+            const now = Date.now();
+            return stored.find(k => {
+                if (!k || k.key !== apiKey || k.enabled === false) {
+                    return false;
+                }
+                if (!k.expires) {
+                    return true;
+                }
+                const expiresAt = new Date(k.expires).getTime();
+                return !isNaN(expiresAt) && expiresAt > now;
+            });
+        });
+    };
+
+    // Allow public dashboard UI and socket.io; require JWT or API key for admin/editor/flows when security is enabled
     const allowDashboard = (req, res, next) => {
-            const url = req.originalUrl || req.url || req.path;
+        const url = req.originalUrl || req.url || req.path;
 
-            // Public dashboard UI and its HTTP APIs (served from httpNodeRoot/ui.path)
-            if (url.includes('/dashboard') || url.includes('/socket.io')) return next();
+        // Public dashboard UI and its HTTP APIs (served from httpNodeRoot/ui.path)
+        if (url.includes('/dashboard') || url.includes('/socket.io')) return next();
 
-            // Node-RED dashboard admin APIs used by the layout editor under /nodered/dashboard/...
-            if (url.startsWith('/nodered/dashboard/')) return next();
+        if (!settings.secureEnabled || settings.nodeRedAuthMode === 'legacy-open') {
+            return next();
+        }
 
-            // Internal Node-RED flows APIs used by FlowFuse layout saves and deployments
-            if (url === '/nodered/flows' || url === '/nodered/flows/') return next();
-            if (url === '/nodered/flows/state' || url === '/nodered/flows/state/') return next();
-            if (url === '/nodered/flows/deploy' || url === '/nodered/flows/deploy/') return next();
+        const apiKey = req.headers['x-api-key'];
+        if (apiKey) {
+            return verifyApiKey(runtime, apiKey)
+                .then(validKey => {
+                    if (!validKey) {
+                        return res.status(401).json({ error: "unauthorized_error", message: "Invalid API Key" });
+                    }
+                    return next();
+                })
+                .catch(err => {
+                    logger.error(`api-key validation failed: ${err}`);
+                    return res.status(500).json({ error: "unexpected_error", message: "ApiKey validation failed" });
+                });
+        }
 
-            const referer = req.headers.referer;
-            if (referer) {
-                const ok = ['/editor', '/viewer', '/lab', '/home', '/fuxa', '/flows', '/nodered']
-                        .some(p => referer.includes(p));
-                if (ok) return next();
-            }
-            return authJwt.requireAuth(req, res, next);
+        const headerToken = req.headers['x-access-token'];
+        const queryToken = req.query?.token;
+        const cookieToken = getCookieValue(req, 'nodered_auth');
+        // Prefer explicit tokens over cookie to avoid stale cookie blocking valid logins
+        const token = headerToken || queryToken || cookieToken;
+        if (!token) {
+            return res.status(401).json({ error: "unauthorized_error", message: "Authentication required!" });
+        }
+
+        return authJwt.verify(token)
+            .then(() => {
+                if (queryToken) {
+                    res.cookie('nodered_auth', token, {
+                        httpOnly: true,
+                        sameSite: 'lax',
+                        secure: !!settings.https,
+                    });
+                    if (req.method === 'GET') {
+                        const cleanUrl = new URL(req.originalUrl, `http://${req.headers.host}`);
+                        cleanUrl.searchParams.delete('token');
+                        return res.redirect(cleanUrl.pathname + cleanUrl.search);
+                    }
+                }
+                return next();
+            })
+            .catch(() => {
+                if (cookieToken) {
+                    res.clearCookie('nodered_auth');
+                }
+                return res.status(401).json({ error: "unauthorized_error", message: "Invalid token!" });
+            });
     };
 
     // Mount Node-RED admin/editor under /nodered; HTTP nodes (including dashboard)
-    // are served from httpNodeRoot ('/') so they appear at /dashboard/... etc.
+    // are served from httpNodeRoot ('/dashboard') so they appear at /dashboard/... etc.
     app.use('/nodered', allowDashboard, RED.httpAdmin);
-    app.use('/', allowDashboard, RED.httpNode);
+    app.use('/dashboard', allowDashboard, RED.httpNode);
 
     await RED.start();
 

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-daq.html

@@ -4,7 +4,8 @@
         color: '#a6bbcf',
         defaults: {
             name: {value:""},
-            tag: {value:"", required:true},
+            tag: {value:""},           // Keep: tag name for display and backward compatibility
+            tagId: {value:""},         // New: unique identifier (optional, for backward compatibility)
             from: {value:""},
             to: {value:""}
         },
@@ -12,17 +13,65 @@
         outputs:1,
         icon: "white-globe.png",
         label: function() {
-            return this.name||this.tag||"get daq";
+            if (this.name) {
+                return this.name;
+            }
+            // Display tag name or tagId
+            return this.tag || this.tagId || "get daq";
         },
         oneditprepare: function() {
+            var node = this;
+            var tagMap = {}; // Use tag.id as key to avoid tag.name duplication issues
+            
             $.getJSON('/nodered/fuxa/devices', function(data) {
                 var datalist = $('#fuxa-tags-daq');
                 datalist.empty();
+                
                 data.forEach(function(device) {
                     device.tags.forEach(function(tag) {
-                        datalist.append('<option value="' + tag.name + '">' + device.name + ' - ' + tag.name + '</option>');
+                        var fullName = device.name + ' - ' + tag.name;
+                        // datalist option value format: tag.name(tag.id)
+                        var optionValue = tag.name + '(' + tag.id + ')';
+                        datalist.append('<option value="' + optionValue + '">' + fullName + '</option>');
+                        tagMap[tag.id] = {
+                            name: tag.name,
+                            deviceName: device.name,
+                            fullName: fullName
+                        };
                     });
                 });
+                
+                // Listen for tagSelected input changes
+                $('#node-input-tagSelected').on('change', function() {
+                    var selectedValue = $(this).val();
+                    // Parse format: tag.name(tag.id)
+                    var match = selectedValue.match(/^(.+)\(([^)]+)\)$/);
+                    if (match) {
+                        var tagName = match[1];
+                        var tagId = match[2];
+                        
+                        // Set the actual stored fields
+                        $('#node-input-tag').val(tagName);
+                        $('#node-input-tagId').val(tagId);
+                    }
+                });
+                
+                // Initialize display (when editing existing node)
+                if (node.tagId && tagMap[node.tagId]) {
+                    // Has tagId, construct tagSelected value
+                    var tagName = node.tag || tagMap[node.tagId].name;
+                    $('#node-input-tagSelected').val(tagName + '(' + node.tagId + ')');
+                } else if (node.tag && !node.tagId) {
+                    // Old node: only has tag (tag.name), need to find corresponding tagId
+                    // Note: if there are duplicate names, only the first match will be found
+                    for (var tagId in tagMap) {
+                        if (tagMap[tagId].name === node.tag) {
+                            $('#node-input-tagSelected').val(node.tag + '(' + tagId + ')');
+                            $('#node-input-tagId').val(tagId);
+                            break;
+                        }
+                    }
+                }
             });
 
             // Convert timestamp format for datetime-local inputs
@@ -64,10 +113,12 @@
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
     <div class="form-row">
-        <label for="node-input-tag"><i class="fa fa-tag"></i> Tag</label>
-        <input type="text" id="node-input-tag" list="fuxa-tags-daq" placeholder="Tag Name">
+        <label for="node-input-tagSelected"><i class="fa fa-tag"></i> Tag</label>
+        <input type="text" id="node-input-tagSelected" list="fuxa-tags-daq" placeholder="Select Tag">
         <datalist id="fuxa-tags-daq"></datalist>
     </div>
+    <input type="hidden" id="node-input-tag">
+    <input type="hidden" id="node-input-tagId">
     <div class="form-row">
         <label for="node-input-from"><i class="fa fa-clock-o"></i> From (timestamp)</label>
         <input type="datetime-local" id="node-input-from" placeholder="From timestamp (optional)">

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-daq.js

@@ -6,7 +6,13 @@ module.exports = function(RED) {
 
         this.on('input', async function(msg) {
             try {
-                var tagId = fuxa.getTagId(config.tag, null);
+                // Prefer config.tagId, fallback to config.tag for backward compatibility
+                var tagId = config.tagId;
+                if (!tagId && config.tag) {
+                    // Backward compatibility: old nodes use tag.name, need to convert to tagId
+                    tagId = fuxa.getTagId(config.tag, null);
+                }
+                
                 if (tagId) {
                     var fromts = config.from || msg.from || Date.now() - 3600000; // default 1 hour ago
                     var tots = config.to || msg.to || Date.now();
@@ -14,7 +20,7 @@ module.exports = function(RED) {
                     msg.payload = data;
                     node.send(msg);
                 } else {
-                    node.error('Tag not found: ' + config.tag, msg);
+                    node.error('Tag not found: ' + (config.tag || config.tagId), msg);
                 }
             } catch (err) {
                 node.error(err, msg);

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag-change.html

@@ -4,23 +4,72 @@
         color: '#a6bbcf',
         defaults: {
             name: {value:""},
-            tag: {value:"", required:true}
+            tag: {value:""},           // Keep: tag name for display and backward compatibility
+            tagId: {value:""}          // New: unique identifier (optional, for backward compatibility)
         },
         inputs:0,
         outputs:1,
         icon: "white-globe.png",
         label: function() {
-            return this.name||this.tag||"get tag change";
+            if (this.name) {
+                return this.name;
+            }
+            // Display tag name or tagId
+            return this.tag || this.tagId || "get tag change";
         },
         oneditprepare: function() {
+            var node = this;
+            var tagMap = {}; // Use tag.id as key to avoid tag.name duplication issues
+            
             $.getJSON('/nodered/fuxa/devices', function(data) {
                 var datalist = $('#fuxa-change-tags');
                 datalist.empty();
+                
                 data.forEach(function(device) {
                     device.tags.forEach(function(tag) {
-                        datalist.append('<option value="' + tag.name + '">' + device.name + ' - ' + tag.name + '</option>');
+                        var fullName = device.name + ' - ' + tag.name;
+                        // datalist option value format: tag.name(tag.id)
+                        var optionValue = tag.name + '(' + tag.id + ')';
+                        datalist.append('<option value="' + optionValue + '">' + fullName + '</option>');
+                        tagMap[tag.id] = {
+                            name: tag.name,
+                            deviceName: device.name,
+                            fullName: fullName
+                        };
                     });
                 });
+                
+                // Listen for tagSelected input changes
+                $('#node-input-tagSelected').on('change', function() {
+                    var selectedValue = $(this).val();
+                    // Parse format: tag.name(tag.id)
+                    var match = selectedValue.match(/^(.+)\(([^)]+)\)$/);
+                    if (match) {
+                        var tagName = match[1];
+                        var tagId = match[2];
+                        
+                        // Set the actual stored fields
+                        $('#node-input-tag').val(tagName);
+                        $('#node-input-tagId').val(tagId);
+                    }
+                });
+                
+                // Initialize display (when editing existing node)
+                if (node.tagId && tagMap[node.tagId]) {
+                    // Has tagId, construct tagSelected value
+                    var tagName = node.tag || tagMap[node.tagId].name;
+                    $('#node-input-tagSelected').val(tagName + '(' + node.tagId + ')');
+                } else if (node.tag && !node.tagId) {
+                    // Old node: only has tag (tag.name), need to find corresponding tagId
+                    // Note: if there are duplicate names, only the first match will be found
+                    for (var tagId in tagMap) {
+                        if (tagMap[tagId].name === node.tag) {
+                            $('#node-input-tagSelected').val(node.tag + '(' + tagId + ')');
+                            $('#node-input-tagId').val(tagId);
+                            break;
+                        }
+                    }
+                }
             });
         }
     });
@@ -32,10 +81,12 @@
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
     <div class="form-row">
-        <label for="node-input-tag"><i class="fa fa-tag"></i> Tag</label>
-        <input type="text" id="node-input-tag" list="fuxa-change-tags" placeholder="Tag Name">
+        <label for="node-input-tagSelected"><i class="fa fa-tag"></i> Tag</label>
+        <input type="text" id="node-input-tagSelected" list="fuxa-change-tags" placeholder="Select Tag">
         <datalist id="fuxa-change-tags"></datalist>
     </div>
+    <input type="hidden" id="node-input-tag">
+    <input type="hidden" id="node-input-tagId">
 </script>
 
 <script type="text/x-red" data-help-name="get-tag-change">

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag-change.js

@@ -7,26 +7,26 @@ module.exports = function(RED) {
         // Store previous values to detect actual changes
         var previousValues = {};
 
+        // Prefer config.tagId, fallback to config.tag for backward compatibility
+        var configuredTagId = config.tagId;
+        if (!configuredTagId && config.tag) {
+            // Backward compatibility: old nodes use tag.name, need to convert to tagId
+            configuredTagId = fuxa.getTagId(config.tag, null);
+        }
+
         // Initialize previous value for the configured tag
-        if (config.tag) {
-            var tagId = fuxa.getTagId(config.tag, null);
-            if (tagId) {
-                // Initialize previous value
-                var initialValue = fuxa.getTag(tagId);
-                if (initialValue !== undefined) {
-                    previousValues[tagId] = initialValue;
-                }
+        if (configuredTagId) {
+            var initialValue = fuxa.getTag(configuredTagId);
+            if (initialValue !== undefined) {
+                previousValues[configuredTagId] = initialValue;
             }
         }
 
-                        // Event listener for device value changes (raw events from devices)
+        // Event listener for device value changes (raw events from devices)
         var deviceEventListener = function(deviceEvent) {
             try {
                 // deviceEvent format: { id: deviceId, values: { tagId: tagObject, ... } }
                 if (deviceEvent && deviceEvent.values) {
-                    // Check if any of the changed values match our configured tag
-                    var configuredTagId = fuxa.getTagId(config.tag, null);
-                    
                     if (configuredTagId && deviceEvent.values[configuredTagId]) {
                         var tagData = deviceEvent.values[configuredTagId];
                         

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag-daq-settings.html

@@ -4,23 +4,72 @@
         color: '#a6bbcf',
         defaults: {
             name: {value:""},
-            tag: {value:"", required:true}
+            tag: {value:""},           // Keep: tag name for display and backward compatibility
+            tagId: {value:""}          // New: unique identifier (optional, for backward compatibility)
         },
         inputs:1,
         outputs:1,
         icon: "white-globe.png",
         label: function() {
-            return this.name||this.tag||"get tag daq settings";
+            if (this.name) {
+                return this.name;
+            }
+            // Display tag name or tagId
+            return this.tag || this.tagId || "get tag daq settings";
         },
         oneditprepare: function() {
+            var node = this;
+            var tagMap = {}; // Use tag.id as key to avoid tag.name duplication issues
+            
             $.getJSON('/nodered/fuxa/devices', function(data) {
                 var datalist = $('#fuxa-tags-daq-settings');
                 datalist.empty();
+                
                 data.forEach(function(device) {
                     device.tags.forEach(function(tag) {
-                        datalist.append('<option value="' + tag.name + '">' + device.name + ' - ' + tag.name + '</option>');
+                        var fullName = device.name + ' - ' + tag.name;
+                        // datalist option value format: tag.name(tag.id)
+                        var optionValue = tag.name + '(' + tag.id + ')';
+                        datalist.append('<option value="' + optionValue + '">' + fullName + '</option>');
+                        tagMap[tag.id] = {
+                            name: tag.name,
+                            deviceName: device.name,
+                            fullName: fullName
+                        };
                     });
                 });
+                
+                // Listen for tagSelected input changes
+                $('#node-input-tagSelected').on('change', function() {
+                    var selectedValue = $(this).val();
+                    // Parse format: tag.name(tag.id)
+                    var match = selectedValue.match(/^(.+)\(([^)]+)\)$/);
+                    if (match) {
+                        var tagName = match[1];
+                        var tagId = match[2];
+                        
+                        // Set the actual stored fields
+                        $('#node-input-tag').val(tagName);
+                        $('#node-input-tagId').val(tagId);
+                    }
+                });
+                
+                // Initialize display (when editing existing node)
+                if (node.tagId && tagMap[node.tagId]) {
+                    // Has tagId, construct tagSelected value
+                    var tagName = node.tag || tagMap[node.tagId].name;
+                    $('#node-input-tagSelected').val(tagName + '(' + node.tagId + ')');
+                } else if (node.tag && !node.tagId) {
+                    // Old node: only has tag (tag.name), need to find corresponding tagId
+                    // Note: if there are duplicate names, only the first match will be found
+                    for (var tagId in tagMap) {
+                        if (tagMap[tagId].name === node.tag) {
+                            $('#node-input-tagSelected').val(node.tag + '(' + tagId + ')');
+                            $('#node-input-tagId').val(tagId);
+                            break;
+                        }
+                    }
+                }
             });
         }
     });
@@ -32,10 +81,12 @@
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
     <div class="form-row">
-        <label for="node-input-tag"><i class="fa fa-tag"></i> Tag</label>
-        <input type="text" id="node-input-tag" list="fuxa-tags-daq-settings" placeholder="Tag Name">
+        <label for="node-input-tagSelected"><i class="fa fa-tag"></i> Tag</label>
+        <input type="text" id="node-input-tagSelected" list="fuxa-tags-daq-settings" placeholder="Select Tag">
         <datalist id="fuxa-tags-daq-settings"></datalist>
     </div>
+    <input type="hidden" id="node-input-tag">
+    <input type="hidden" id="node-input-tagId">
 </script>
 
 <script type="text/x-red" data-help-name="get-tag-daq-settings">

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag-daq-settings.js

@@ -6,18 +6,22 @@ module.exports = function(RED) {
 
         this.on('input', async function(msg) {
             try {
-                var tagName = config.tag || msg.tag;
-                if (tagName) {
-                    var tagId = fuxa.getTagId(tagName, null);
-                    if (tagId) {
-                        var settings = await fuxa.getTagDaqSettings(tagId);
-                        msg.payload = settings;
-                        node.send(msg);
-                    } else {
-                        node.error('Tag not found: ' + tagName, msg);
+                // Prefer config.tagId, fallback to config.tag or msg.tag for backward compatibility
+                var tagId = config.tagId;
+                if (!tagId) {
+                    var tagName = config.tag || msg.tag;
+                    if (tagName) {
+                        // Backward compatibility: old nodes use tag.name, need to convert to tagId
+                        tagId = fuxa.getTagId(tagName, null);
                     }
+                }
+                
+                if (tagId) {
+                    var settings = await fuxa.getTagDaqSettings(tagId);
+                    msg.payload = settings;
+                    node.send(msg);
                 } else {
-                    node.error('Tag name not specified', msg);
+                    node.error('Tag not found: ' + (config.tag || msg.tag || config.tagId), msg);
                 }
             } catch (err) {
                 node.error(err, msg);

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag.html

@@ -4,23 +4,72 @@
         color: '#a6bbcf',
         defaults: {
             name: {value:""},
-            tag: {value:"", required:true}
+            tag: {value:""},           // Keep: tag name for display and backward compatibility
+            tagId: {value:""}          // New: unique identifier (optional, for backward compatibility)
         },
         inputs:1,
         outputs:1,
         icon: "white-globe.png",
         label: function() {
-            return this.name||this.tag||"get tag";
+            if (this.name) {
+                return this.name;
+            }
+            // Display tag name or tagId
+            return this.tag || this.tagId || "get tag";
         },
         oneditprepare: function() {
+            var node = this;
+            var tagMap = {}; // Use tag.id as key to avoid tag.name duplication issues
+            
             $.getJSON('/nodered/fuxa/devices', function(data) {
                 var datalist = $('#fuxa-tags');
                 datalist.empty();
+                
                 data.forEach(function(device) {
                     device.tags.forEach(function(tag) {
-                        datalist.append('<option value="' + tag.name + '">' + device.name + ' - ' + tag.name + '</option>');
+                        var fullName = device.name + ' - ' + tag.name;
+                        // datalist option value format: tag.name(tag.id)
+                        var optionValue = tag.name + '(' + tag.id + ')';
+                        datalist.append('<option value="' + optionValue + '">' + fullName + '</option>');
+                        tagMap[tag.id] = {
+                            name: tag.name,
+                            deviceName: device.name,
+                            fullName: fullName
+                        };
                     });
                 });
+                
+                // Listen for tagSelected input changes
+                $('#node-input-tagSelected').on('change', function() {
+                    var selectedValue = $(this).val();
+                    // Parse format: tag.name(tag.id)
+                    var match = selectedValue.match(/^(.+)\(([^)]+)\)$/);
+                    if (match) {
+                        var tagName = match[1];
+                        var tagId = match[2];
+                        
+                        // Set the actual stored fields
+                        $('#node-input-tag').val(tagName);
+                        $('#node-input-tagId').val(tagId);
+                    }
+                });
+                
+                // Initialize display (when editing existing node)
+                if (node.tagId && tagMap[node.tagId]) {
+                    // Has tagId, construct tagSelected value
+                    var tagName = node.tag || tagMap[node.tagId].name;
+                    $('#node-input-tagSelected').val(tagName + '(' + node.tagId + ')');
+                } else if (node.tag && !node.tagId) {
+                    // Old node: only has tag (tag.name), need to find corresponding tagId
+                    // Note: if there are duplicate names, only the first match will be found
+                    for (var tagId in tagMap) {
+                        if (tagMap[tagId].name === node.tag) {
+                            $('#node-input-tagSelected').val(node.tag + '(' + tagId + ')');
+                            $('#node-input-tagId').val(tagId);
+                            break;
+                        }
+                    }
+                }
             });
         }
     });
@@ -32,10 +81,12 @@
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
     <div class="form-row">
-        <label for="node-input-tag"><i class="fa fa-tag"></i> Tag</label>
-        <input type="text" id="node-input-tag" list="fuxa-tags" placeholder="Tag Name">
+        <label for="node-input-tagSelected"><i class="fa fa-tag"></i> Tag</label>
+        <input type="text" id="node-input-tagSelected" list="fuxa-tags" placeholder="Select Tag">
         <datalist id="fuxa-tags"></datalist>
     </div>
+    <input type="hidden" id="node-input-tag">
+    <input type="hidden" id="node-input-tagId">
 </script>
 
 <script type="text/x-red" data-help-name="get-tag">

package/integrations/node-red/node-red-contrib-fuxa/nodes/fuxa-get-tag.js

@@ -7,14 +7,20 @@ module.exports = function(RED) {
 
         this.on('input', function(msg) {
             try {
-                var tagId = fuxa.getTagId(config.tag, null);
+                // Prefer config.tagId, fallback to config.tag for backward compatibility
+                var tagId = config.tagId;
+                if (!tagId && config.tag) {
+                    // Backward compatibility: old nodes use tag.name, need to convert to tagId
+                    tagId = fuxa.getTagId(config.tag, null);
+                }
+                
                 if (tagId) {
                     var value = fuxa.getTag(tagId);
                     msg.payload = value;
                     msg.topic = config.tag;  // Set topic to tag name for join operations
                     node.send(msg);
                 } else {
-                    node.error('Tag not found: ' + config.tag, msg);
+                    node.error('Tag not found: ' + (config.tag || config.tagId), msg);
                 }
             } catch (err) {
                 node.error(err, msg);