@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/modbus-tcp-discover/modbus-tcp-discover.js

@@ -0,0 +1,706 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const net = require("net");
+    const tls = require("tls");
+    const dns = require("dns").promises;
+    const os = require("os");
+    const { spawn } = require("child_process");
+
+    const MAX_HOSTS = 4096;
+    const MAX_PORTS = 32;
+    const MAX_UNIT_IDS = 247;
+    const SUNSPEC_BASES = [39999, 40000, 40001, 40002, 40199, 40200, 40201, 40202];
+    const OUI_VENDORS = { "0003AC": "Fronius International", "001132": "Synology", "0080F4": "Schneider Electric", "D83ADD": "Raspberry Pi", "E43883": "Ubiquiti", "CCB182": "Huawei" };
+
+    function clamp(value, min, max, fallback) {
+        const n = Number(value);
+        return Number.isFinite(n) ? Math.max(min, Math.min(max, Math.round(n))) : fallback;
+    }
+
+    function ipToNumber(ip) {
+        const parts = String(ip || "").trim().split(".");
+        if (parts.length !== 4) throw new Error("Adresa IPv4 invalida: " + ip);
+        const octets = parts.map(function (part) {
+            if (!/^\d+$/.test(part)) throw new Error("Adresa IPv4 invalida: " + ip);
+            const value = Number(part);
+            if (value < 0 || value > 255) throw new Error("Adresa IPv4 invalida: " + ip);
+            return value;
+        });
+        return (((octets[0] * 0x1000000) + (octets[1] << 16) + (octets[2] << 8) + octets[3]) >>> 0);
+    }
+
+    function numberToIp(value) {
+        const n = Number(value) >>> 0;
+        return [(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255].join(".");
+    }
+
+    function isPrivateIp(ip) {
+        const n = ipToNumber(ip);
+        return ((n & 0xff000000) >>> 0) === 0x0a000000 ||
+            ((n & 0xfff00000) >>> 0) === 0xac100000 ||
+            ((n & 0xffff0000) >>> 0) === 0xc0a80000 ||
+            ((n & 0xff000000) >>> 0) === 0x7f000000 ||
+            ((n & 0xffff0000) >>> 0) === 0xa9fe0000;
+    }
+
+    function rangeFromTarget(value, allowPublic) {
+        const target = String(value || "").trim();
+        if (!target) throw new Error("Reteaua sau intervalul IP lipseste");
+        let start;
+        let end;
+        if (target.includes("/")) {
+            const parts = target.split("/");
+            if (parts.length !== 2 || !/^\d+$/.test(parts[1])) throw new Error("CIDR invalid: " + target);
+            const ip = ipToNumber(parts[0]);
+            const prefix = Number(parts[1]);
+            if (prefix < 0 || prefix > 32) throw new Error("Prefix CIDR invalid: " + prefix);
+            const mask = prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;
+            start = (ip & mask) >>> 0;
+            end = (start | (~mask >>> 0)) >>> 0;
+            if (prefix <= 30) { start += 1; end -= 1; }
+        } else if (target.includes("-")) {
+            const parts = target.split("-").map(function (part) { return part.trim(); });
+            if (parts.length !== 2) throw new Error("Interval IP invalid: " + target);
+            start = ipToNumber(parts[0]);
+            if (/^\d+$/.test(parts[1])) {
+                const last = Number(parts[1]);
+                if (last < 0 || last > 255) throw new Error("Ultimul octet este invalid: " + parts[1]);
+                end = ((start & 0xffffff00) | last) >>> 0;
+            } else end = ipToNumber(parts[1]);
+        } else {
+            start = ipToNumber(target);
+            end = start;
+        }
+        if (end < start) throw new Error("Sfarsitul intervalului este mai mic decat inceputul");
+        const count = end - start + 1;
+        if (count > MAX_HOSTS) throw new Error("Intervalul depaseste limita de " + MAX_HOSTS + " gazde");
+        if (!allowPublic && (!isPrivateIp(numberToIp(start)) || !isPrivateIp(numberToIp(end)))) {
+            throw new Error("Scanarea adreselor publice este blocata. Activeaza explicit optiunea daca ai autorizatie.");
+        }
+        return { start: start, end: end, count: count };
+    }
+
+    function parseNumericList(value, min, max, maximumItems, label) {
+        const values = [];
+        String(value || "").split(",").forEach(function (token) {
+            const text = token.trim();
+            if (!text) return;
+            if (text.includes("-")) {
+                const bounds = text.split("-").map(Number);
+                if (bounds.length !== 2 || !bounds.every(Number.isInteger) || bounds[0] < min || bounds[1] > max || bounds[1] < bounds[0]) {
+                    throw new Error("Interval " + label + " invalid: " + text);
+                }
+                for (let value = bounds[0]; value <= bounds[1]; value += 1) values.push(value);
+            } else {
+                const numeric = Number(text);
+                if (!Number.isInteger(numeric) || numeric < min || numeric > max) throw new Error(label + " invalid: " + text);
+                values.push(numeric);
+            }
+        });
+        const unique = Array.from(new Set(values));
+        if (!unique.length) throw new Error("Lista " + label + " este goala");
+        if (unique.length > maximumItems) throw new Error("Lista depaseste limita de " + maximumItems + " " + label);
+        return unique;
+    }
+
+    function wait(ms) {
+        return new Promise(function (resolve) { setTimeout(resolve, ms); });
+    }
+
+    function pingHost(host, timeoutMs, session) {
+        return new Promise(function (resolve) {
+            const windows = os.platform() === "win32";
+            const args = windows ? ["-n", "1", "-w", String(timeoutMs), host] : ["-c", "1", "-W", String(Math.max(1, Math.ceil(timeoutMs / 1000))), host];
+            let child;
+            let settled = false;
+            function done(online) {
+                if (settled) return;
+                settled = true;
+                if (child) session.children.delete(child);
+                resolve(online);
+            }
+            try {
+                child = spawn(windows ? "ping" : "ping", args, { windowsHide: true, stdio: "ignore" });
+                session.children.add(child);
+                child.once("error", function () { done(false); });
+                child.once("exit", function (code) { done(code === 0); });
+            } catch (error) { done(false); }
+        });
+    }
+
+    function neighborTable(session) {
+        return new Promise(function (resolve) {
+            const windows = os.platform() === "win32";
+            const command = windows ? "arp" : "ip";
+            const args = windows ? ["-a"] : ["neigh"];
+            let output = "";
+            let child;
+            function finish() {
+                if (child) session.children.delete(child);
+                const found = new Map();
+                output.split(/\r?\n/).forEach(function (line) {
+                    const ipMatch = line.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/);
+                    const macMatch = line.match(/\b(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}\b/i);
+                    if (!ipMatch) return;
+                    try {
+                        ipToNumber(ipMatch[0]);
+                        found.set(ipMatch[0], macMatch ? macMatch[0].replace(/-/g, ":").toUpperCase() : null);
+                    } catch (error) { /* ignore */ }
+                });
+                resolve(found);
+            }
+            try {
+                child = spawn(command, args, { windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+                session.children.add(child);
+                child.stdout.on("data", function (chunk) { output += chunk.toString(); });
+                child.once("error", finish);
+                child.once("exit", finish);
+            } catch (error) { resolve(new Map()); }
+        });
+    }
+
+    function checkPort(host, port, timeoutMs, session, rateDelayMs) {
+        return new Promise(async function (resolve) {
+            if (rateDelayMs > 0) {
+                const slot = Math.max(Date.now(), session.nextConnectAt || 0);
+                session.nextConnectAt = slot + rateDelayMs;
+                if (slot > Date.now()) await wait(slot - Date.now());
+            }
+            if (session.cancelled) return resolve({ port: port, status: "cancelled", latency_ms: 0, error_code: null });
+            const started = Date.now();
+            const socket = new net.Socket();
+            session.sockets.add(socket);
+            let finished = false;
+            function done(status, errorCode) {
+                if (finished) return;
+                finished = true;
+                session.sockets.delete(socket);
+                socket.destroy();
+                resolve({ port: port, status: status, latency_ms: Date.now() - started, error_code: errorCode || null });
+            }
+            socket.setTimeout(timeoutMs);
+            socket.once("connect", function () { done("open"); });
+            socket.once("timeout", function () { done("timeout", "ETIMEDOUT"); });
+            socket.once("error", function (error) {
+                const code = error && error.code ? error.code : "ERROR";
+                done(code === "ECONNREFUSED" ? "refused" : "error", code);
+            });
+            socket.once("close", function () { if (!finished) done(session.cancelled ? "cancelled" : "error", session.cancelled ? null : "ECLOSED"); });
+            socket.connect({ host: host, port: port });
+        });
+    }
+
+    function modbusRequest(host, port, unitId, pdu, timeoutMs, session) {
+        return new Promise(function (resolve) {
+            if (session.cancelled) return resolve(null);
+            const socket = new net.Socket();
+            session.sockets.add(socket);
+            const transactionId = (Date.now() + unitId) & 0xffff;
+            const header = Buffer.alloc(7);
+            header.writeUInt16BE(transactionId, 0);
+            header.writeUInt16BE(0, 2);
+            header.writeUInt16BE(pdu.length + 1, 4);
+            header.writeUInt8(unitId, 6);
+            const chunks = [];
+            let finished = false;
+            function done(value) {
+                if (finished) return;
+                finished = true;
+                session.sockets.delete(socket);
+                socket.destroy();
+                resolve(value);
+            }
+            socket.setTimeout(timeoutMs);
+            socket.once("connect", function () { socket.write(Buffer.concat([header, pdu])); });
+            socket.on("data", function (chunk) {
+                chunks.push(chunk);
+                const data = Buffer.concat(chunks);
+                if (data.length >= 6) {
+                    const expected = 6 + data.readUInt16BE(4);
+                    if (data.length >= expected) done(data.slice(0, expected));
+                }
+            });
+            socket.once("timeout", function () { done(null); });
+            socket.once("error", function () { done(null); });
+            socket.once("close", function () { if (!finished) done(null); });
+            socket.connect({ host: host, port: port });
+        });
+    }
+
+    function mqttConnectPacket() {
+        const clientId = Buffer.from("nodered-discover", "utf8");
+        const variable = Buffer.from([0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, 0x04, 0x02, 0x00, 0x0a]);
+        const payload = Buffer.concat([Buffer.from([(clientId.length >> 8) & 255, clientId.length & 255]), clientId]);
+        const remaining = variable.length + payload.length;
+        return Buffer.concat([Buffer.from([0x10, remaining]), variable, payload]);
+    }
+
+    function probeMqtt(host, port, timeoutMs, session) {
+        return new Promise(function (resolve) {
+            if (session.cancelled) return resolve(null);
+            const secure = port === 8883;
+            const socket = secure
+                ? tls.connect({ host: host, port: port, rejectUnauthorized: false })
+                : net.connect({ host: host, port: port });
+            session.sockets.add(socket);
+            let finished = false;
+            function done(value) {
+                if (finished) return;
+                finished = true;
+                session.sockets.delete(socket);
+                socket.destroy();
+                resolve(value);
+            }
+            socket.setTimeout(timeoutMs);
+            socket.once("connect", function () { if (!secure) socket.write(mqttConnectPacket()); });
+            if (secure) socket.once("secureConnect", function () { socket.write(mqttConnectPacket()); });
+            socket.once("data", function (data) {
+                if (data.length >= 4 && data[0] === 0x20 && data[1] === 0x02) {
+                    let certificate = null;
+                    if (secure && socket.getPeerCertificate) {
+                        const peer = socket.getPeerCertificate();
+                        certificate = peer && Object.keys(peer).length ? { subject: peer.subject || null, issuer: peer.issuer || null, valid_to: peer.valid_to || null } : null;
+                    }
+                    done({ confirmed: true, port: port, tls: secure, connack_code: data[3], authorized: data[3] === 0, certificate: certificate });
+                } else done(null);
+            });
+            socket.once("timeout", function () { done(null); });
+            socket.once("error", function () { done(null); });
+            socket.once("close", function () { if (!finished) done(null); });
+        });
+    }
+
+    function holdingPdu(address, count) {
+        const pdu = Buffer.alloc(5);
+        pdu[0] = 3;
+        pdu.writeUInt16BE(address, 1);
+        pdu.writeUInt16BE(count, 3);
+        return pdu;
+    }
+
+    function parseHolding(response) {
+        if (!response || response.length < 9) return null;
+        const fc = response[7];
+        if ((fc & 0x80) !== 0) return { exception: response[8], words: [] };
+        if (fc !== 3 || response.length < 9 + response[8]) return null;
+        const words = [];
+        for (let offset = 9; offset + 1 < 9 + response[8]; offset += 2) words.push(response.readUInt16BE(offset));
+        return { exception: null, words: words };
+    }
+
+    function wordsToText(words) {
+        return words.map(function (word) { return String.fromCharCode((word >> 8) & 255, word & 255); }).join("");
+    }
+
+    function decodeSunSpecString(words) {
+        return wordsToText(words).replace(/\0/g, "").trim();
+    }
+
+    async function readSunSpecCommon(host, port, unitId, base, timeoutMs, session) {
+        const header = parseHolding(await modbusRequest(host, port, unitId, holdingPdu(base + 2, 2), timeoutMs, session));
+        if (!header || header.exception || header.words.length < 2 || header.words[0] !== 1) return null;
+        const length = Math.min(65, header.words[1]);
+        if (length < 65) return null;
+        const payload = parseHolding(await modbusRequest(host, port, unitId, holdingPdu(base + 4, length), timeoutMs, session));
+        if (!payload || payload.exception || payload.words.length < 65) return null;
+        return {
+            manufacturer: decodeSunSpecString(payload.words.slice(0, 16)) || null,
+            model: decodeSunSpecString(payload.words.slice(16, 32)) || null,
+            options: decodeSunSpecString(payload.words.slice(32, 40)) || null,
+            version: decodeSunSpecString(payload.words.slice(40, 48)) || null,
+            serial: decodeSunSpecString(payload.words.slice(48, 64)) || null,
+            device_address: payload.words[64]
+        };
+    }
+
+    function parseDeviceIdentification(response) {
+        if (!response || response.length < 14 || response[7] !== 0x2b || response[8] !== 0x0e) return null;
+        const count = response[13];
+        let offset = 14;
+        const objects = {};
+        for (let index = 0; index < count && offset + 2 <= response.length; index += 1) {
+            const objectId = response[offset++];
+            const length = response[offset++];
+            if (offset + length > response.length) break;
+            objects[objectId] = response.slice(offset, offset + length).toString("utf8").replace(/\0/g, "").trim();
+            offset += length;
+        }
+        return { vendor: objects[0] || null, product_code: objects[1] || null, revision: objects[2] || null, objects: objects };
+    }
+
+    async function probeModbus(host, port, unitIds, timeoutMs, session, probeMode) {
+        const devices = [];
+        const preferred = [1, 3, 126].filter(function (unitId) { return unitIds.includes(unitId); });
+        const scanOrder = preferred.concat(unitIds.filter(function (unitId) { return !preferred.includes(unitId); }));
+        const testedUnitIds = [];
+        for (const unitId of scanOrder) {
+            if (session.cancelled) break;
+            testedUnitIds.push(unitId);
+            const identification = parseDeviceIdentification(await modbusRequest(host, port, unitId, Buffer.from([0x2b, 0x0e, 0x01, 0x00]), timeoutMs, session));
+            const profileResponse = probeMode === "sunspec_only" ? null : parseHolding(await modbusRequest(host, port, unitId, holdingPdu(30001, 2), timeoutMs, session));
+            let responds = !!identification || !!(profileResponse && ![10, 11].includes(profileResponse.exception));
+            let profileVersion = null;
+            let protocol = null;
+            if (profileResponse && !profileResponse.exception && profileResponse.words.length >= 2) {
+                profileVersion = ((profileResponse.words[0] * 0x10000) + profileResponse.words[1]) >>> 0;
+                protocol = "sma-native";
+            }
+            let sunspecBase = null;
+            let sunspecCommon = null;
+            if (!protocol && (responds || probeMode === "sunspec_only")) {
+                for (const base of SUNSPEC_BASES) {
+                    const parsed = parseHolding(await modbusRequest(host, port, unitId, holdingPdu(base, 2), timeoutMs, session));
+                    if (parsed && ![10, 11].includes(parsed.exception)) responds = true;
+                    if (parsed && !parsed.exception && wordsToText(parsed.words).includes("SunS")) {
+                        protocol = "sunspec";
+                        sunspecBase = base;
+                        sunspecCommon = await readSunSpecCommon(host, port, unitId, base, timeoutMs, session);
+                        break;
+                    }
+                }
+            }
+            if (responds) devices.push({ unit_id: unitId, protocol: protocol || "modbus", identification: identification, sma_profile_version: profileVersion, sunspec_base: sunspecBase, sunspec_common: sunspecCommon });
+            if (testedUnitIds.length === preferred.length && preferred.length >= 2 && devices.length === preferred.length) {
+                const signatures = new Set(devices.map(function (device) { return JSON.stringify({ protocol: device.protocol, identity: device.identification || device.sunspec_common || null, profile: device.sma_profile_version, base: device.sunspec_base }); }));
+                if (signatures.size === 1) break;
+            }
+        }
+        const signatures = new Map();
+        devices.forEach(function (device) {
+            const id = device.identification || device.sunspec_common || null;
+            const key = JSON.stringify({ protocol: device.protocol, identity: id, profile: device.sma_profile_version, base: device.sunspec_base });
+            if (!signatures.has(key)) signatures.set(key, []);
+            signatures.get(key).push(device.unit_id);
+        });
+        const mirrored = devices.length > 1 && signatures.size === 1;
+        const representative = devices[0] || null;
+        const identity = representative && (representative.sunspec_common || representative.identification) || null;
+        return {
+            confirmed: devices.length > 0,
+            unit_id_behavior: mirrored ? "ignored_or_mirrored" : "distinct",
+            tested_unit_ids: testedUnitIds,
+            responsive_unit_ids: devices.map(function (device) { return device.unit_id; }),
+            units: mirrored ? [representative] : devices,
+            manufacturer: identity && (identity.manufacturer || identity.vendor) || null,
+            model: identity && (identity.model || identity.product_code) || null,
+            firmware: identity && (identity.version || identity.revision) || null,
+            serial: identity && identity.serial || null
+        };
+    }
+
+    function profileDefaults(profile, detail, configuredPorts, configuredUnitIds, configuredProbe) {
+        const level = ["rapid", "standard", "detailed"].includes(detail) ? detail : "standard";
+        const unitSets = {
+            rapid: "1,126",
+            standard: "1,3,126",
+            detailed: "1-20,126"
+        };
+        const definitions = {
+            sunspec: { ports: "502", probe: true, probeMode: "sunspec_only", unitIds: unitSets[level] },
+            modbus: { ports: "502", probe: true, probeMode: "auto", unitIds: level === "rapid" ? "1" : (level === "standard" ? "1-10" : "1-50,126") },
+            mqtt: { ports: "1883,8883", probe: false, probeMode: "none", unitIds: "1" },
+            web: { ports: "80,443,8080,8443", probe: false, probeMode: "none", unitIds: "1" },
+            industrial: { ports: "102,502,1883,4840,20000,44818", probe: true, probeMode: "auto", unitIds: level === "detailed" ? "1-20,126" : "1,3,126" },
+            full: { ports: "80,102,443,502,1883,4840,8080,8443,8883,20000,44818", probe: true, probeMode: "auto", unitIds: level === "detailed" ? "1-50,126" : "1-10,126" }
+        };
+        return definitions[profile] || { ports: configuredPorts, probe: configuredProbe, probeMode: "auto", unitIds: configuredUnitIds };
+    }
+
+    function servicesFor(device) {
+        const ports = new Set(device.open_ports || []);
+        const services = [];
+        if (ports.has(80) || ports.has(8080) || ports.has(8443)) services.push("web");
+        if (ports.has(443) || ports.has(8443)) services.push("https");
+        if (ports.has(1883) || ports.has(8883)) services.push("mqtt-port");
+        if (device.mqtt && Object.keys(device.mqtt).some(function (port) { return device.mqtt[port] && device.mqtt[port].confirmed; })) services.push("mqtt");
+        if (ports.has(102)) services.push("s7-port");
+        if (ports.has(4840)) services.push("opcua-port");
+        if (ports.has(20000)) services.push("dnp3-port");
+        if (ports.has(44818)) services.push("ethernet-ip-port");
+        if (device.modbus && device.modbus.confirmed) services.push("modbus-tcp");
+        if (device.sunspec) services.push("sunspec");
+        return services;
+    }
+
+    function matchesProfile(device, profile) {
+        if (profile === "sunspec") return device.sunspec;
+        if (profile === "modbus") return !!(device.modbus && device.modbus.confirmed);
+        if (profile === "mqtt") return !!(device.mqtt && Object.keys(device.mqtt).some(function (port) { return device.mqtt[port] && device.mqtt[port].confirmed; }));
+        if (profile === "web") return device.open_ports.some(function (port) { return [80, 443, 8080, 8443].includes(port); });
+        if (profile === "industrial") return device.open_ports.length > 0;
+        return device.online;
+    }
+
+    function indexDevices(devices, mode) {
+        if (mode === "array") return devices;
+        const indexed = {};
+        devices.forEach(function (device) {
+            let key = device.ip;
+            if (mode === "last_octet") {
+                const candidate = device.ip.split(".").pop();
+                key = Object.prototype.hasOwnProperty.call(indexed, candidate) ? device.ip : candidate;
+            }
+            indexed[key] = device;
+        });
+        return indexed;
+    }
+
+    async function mapLimit(items, limit, worker) {
+        let cursor = 0;
+        async function runner() {
+            while (cursor < items.length) {
+                const index = cursor++;
+                await worker(items[index], index);
+            }
+        }
+        await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runner));
+    }
+
+    function csvEscape(value) {
+        const text = value === null || value === undefined ? "" : String(value);
+        return /[",\n]/.test(text) ? '"' + text.replace(/"/g, '""') + '"' : text;
+    }
+
+    function removeUnavailable(value) {
+        if (Array.isArray(value)) return value.map(removeUnavailable);
+        if (!value || typeof value !== "object") return value;
+        const cleaned = {};
+        Object.keys(value).forEach(function (key) {
+            const item = value[key];
+            if (item === null || item === undefined) return;
+            cleaned[key] = removeUnavailable(item);
+        });
+        return cleaned;
+    }
+
+    function indexPortResults(checks) {
+        const indexed = {};
+        (checks || []).forEach(function (check) {
+            indexed[String(check.port)] = check;
+        });
+        return indexed;
+    }
+
+    function macVendor(mac) {
+        const prefix = String(mac || "").replace(/[^0-9a-f]/gi, "").slice(0, 6).toUpperCase();
+        return OUI_VENDORS[prefix] || null;
+    }
+
+    function identificationConfidence(device) {
+        const mqttConfirmed = device.mqtt && Object.keys(device.mqtt).some(function (port) { return device.mqtt[port] && device.mqtt[port].confirmed; });
+        if ((device.modbus && device.modbus.manufacturer) || device.sunspec || mqttConfirmed) return "confirmed";
+        if (device.hostname || device.mac_vendor || device.open_ports.length) return "probable";
+        return "unknown";
+    }
+
+    function deviceSummary(device) {
+        const identity = device.manufacturer || device.mac_vendor || device.hostname || device.ip;
+        const model = device.model && device.model !== identity ? device.model : null;
+        return [identity, model].concat(device.services || []).filter(Boolean).join(" | ");
+    }
+
+    function categoryCollections(devices, mode) {
+        function selected(predicate) { return indexDevices(devices.filter(predicate), mode); }
+        return {
+            modbus_devices: selected(function (device) { return !!(device.modbus && device.modbus.confirmed); }),
+            sunspec_devices: selected(function (device) { return device.sunspec === true; }),
+            mqtt_devices: selected(function (device) { return device.services.includes("mqtt"); }),
+            web_devices: selected(function (device) { return device.services.includes("web") || device.services.includes("https"); })
+        };
+    }
+
+    function formatPayload(device, format) {
+        if (format === "influx") {
+            return [{ open_port_count: device.open_ports.length, modbus_unit_count: device.modbus ? device.modbus.units.length : 0 }, { ip: device.ip, hostname: device.hostname || "" }];
+        }
+        if (format === "csv") {
+            return [device.ip, device.hostname || "", device.online, device.open_ports.join("|"), device.modbus && device.modbus.confirmed, device.event || ""].map(csvEscape).join(",");
+        }
+        return removeUnavailable(device);
+    }
+
+    function DiscoverNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+        node.target = String(config.target || "192.168.1.0/24").trim();
+        node.ports = String(config.ports || "502").trim();
+        node.scanProfile = String(config.scanProfile || "custom");
+        node.detailLevel = String(config.detailLevel || "standard");
+        node.timeout = clamp(config.timeout, 100, 10000, 800);
+        node.concurrency = clamp(config.concurrency, 1, 100, 32);
+        node.rateLimit = clamp(config.rateLimit, 1, 1000, 100);
+        node.discoveryMode = String(config.discoveryMode || "tcp");
+        node.resolveHostnames = !!config.resolveHostnames;
+        node.emitClosed = !!config.emitClosed;
+        node.probeModbus = config.probeModbus !== false;
+        node.unitIds = String(config.unitIds || "1-10");
+        node.allowPublic = !!config.allowPublic;
+        node.outputFormat = String(config.outputFormat || "json");
+        node.emitMode = String(config.emitMode || "summary_only");
+        node.deviceCollection = String(config.deviceCollection || "last_octet");
+        node.onlyChanges = !!config.onlyChanges;
+        node.scanOnStart = !!config.scanOnStart;
+        node.interval = Math.max(0, Number(config.interval) || 0);
+        let session = null;
+        let timer = null;
+        let closing = false;
+        const previous = new Map();
+
+        function cancelScan() {
+            if (!session) return;
+            session.cancelled = true;
+            session.sockets.forEach(function (socket) { socket.destroy(); });
+            session.children.forEach(function (child) { try { child.kill(); } catch (error) { /* ignore */ } });
+            session.sockets.clear();
+            session.children.clear();
+        }
+
+        function signature(device) {
+            return JSON.stringify({ online: device.online, open_ports: device.open_ports, modbus: device.modbus });
+        }
+
+        function eventFor(device) {
+            const old = previous.get(device.ip);
+            const current = signature(device);
+            previous.set(device.ip, current);
+            if (old === undefined) return device.discovered ? "device_online" : null;
+            if (old === current) return null;
+            return device.discovered ? "device_changed" : "device_offline";
+        }
+
+        async function scan(msg, send, done) {
+            if (msg && msg.cancel) {
+                cancelScan();
+                node.status({ fill: "yellow", shape: "ring", text: "anulata" });
+                if (done) done();
+                return;
+            }
+            if (session) {
+                const error = new Error("O scanare este deja in curs");
+                if (done) done(error); else node.warn(error.message);
+                return;
+            }
+            const current = { cancelled: false, sockets: new Set(), children: new Set(), nextConnectAt: 0 };
+            session = current;
+            const startedAt = Date.now();
+            try {
+                const target = msg.target !== undefined ? msg.target : node.target;
+                const requestedProfile = String(msg.scanProfile || node.scanProfile || "custom");
+                const requestedDetail = String(msg.detailLevel || node.detailLevel || "standard");
+                const defaults = profileDefaults(requestedProfile, requestedDetail, node.ports, node.unitIds, node.probeModbus);
+                const ports = parseNumericList(msg.ports !== undefined ? msg.ports : defaults.ports, 1, 65535, MAX_PORTS, "porturi");
+                const timeout = clamp(msg.timeout, 100, 10000, node.timeout);
+                const concurrency = clamp(msg.concurrency, 1, 100, node.concurrency);
+                const unitIds = parseNumericList(msg.unitIds !== undefined ? msg.unitIds : defaults.unitIds, 1, 247, MAX_UNIT_IDS, "Unit ID");
+                const probeEnabled = msg.probeModbus !== undefined ? !!msg.probeModbus : defaults.probe;
+                const range = rangeFromTarget(target, node.allowPublic);
+                const hosts = [];
+                for (let address = range.start; address <= range.end; address += 1) hosts.push(numberToIp(address));
+                const estimatedTcpDurationMs = Math.ceil((range.count * ports.length / node.rateLimit) * 1000);
+                if (range.count > 1024) node.warn("Scanare extinsa: " + range.count + " gazde. Faza TCP dureaza minimum aproximativ " + estimatedTcpDurationMs + " ms; probele pot prelungi scanarea.");
+                const discovered = [];
+                let completed = 0;
+                const rateDelayMs = Math.ceil(1000 / node.rateLimit);
+                const usesArp = node.discoveryMode === "arp_tcp" || node.discoveryMode === "full_discovery" || requestedDetail === "detailed";
+                const usesPing = node.discoveryMode === "ping_tcp" || node.discoveryMode === "full_discovery" || requestedDetail === "detailed";
+                const neighbors = usesArp ? await neighborTable(current) : new Map();
+                node.status({ fill: "blue", shape: "dot", text: "0/" + range.count + " · TCP min " + Math.ceil(estimatedTcpDurationMs / 1000) + "s" });
+
+                await mapLimit(hosts, concurrency, async function (host) {
+                    if (current.cancelled) return;
+                    const pingOnline = usesPing ? await pingHost(host, timeout, current) : null;
+                    const arpOnline = usesArp ? neighbors.has(host) : null;
+                    const checks = await Promise.all(ports.map(function (port) { return checkPort(host, port, timeout, current, rateDelayMs); }));
+                    const openPorts = checks.filter(function (item) { return item.status === "open"; }).map(function (item) { return item.port; });
+                    const online = pingOnline === true || arpOnline === true || openPorts.length > 0 || checks.some(function (item) { return item.status === "refused"; });
+                    let hostname = null;
+                    if ((node.resolveHostnames || requestedDetail === "detailed") && online) { try { hostname = (await dns.reverse(host))[0] || null; } catch (error) { hostname = null; } }
+                    let modbus = null;
+                    if (probeEnabled && openPorts.includes(502)) modbus = await probeModbus(host, 502, unitIds, timeout, current, defaults.probeMode);
+                    const mqtt = {};
+                    for (const mqttPort of openPorts.filter(function (port) { return port === 1883 || port === 8883; })) {
+                        const mqttResult = await probeMqtt(host, mqttPort, timeout, current);
+                        if (mqttResult) mqtt[String(mqttPort)] = mqttResult;
+                    }
+                    const device = { ip: host, hostname: hostname, mac: neighbors.get(host) || null, online: online, discovered: online, ping: pingOnline, arp_neighbor: arpOnline, open_ports: openPorts, ports: indexPortResults(checks), modbus: modbus, mqtt: mqtt };
+                    device.event = eventFor(device);
+                    if (device.discovered || node.emitClosed || device.event === "device_offline") discovered.push(device);
+                    if (node.emitMode === "device_and_summary" && ((!node.onlyChanges && (device.discovered || node.emitClosed)) || (node.onlyChanges && device.event))) {
+                        const outputDevice = removeUnavailable(device);
+                        send([{ topic: "modbus-tcp-discover/device", payload: formatPayload(outputDevice, node.outputFormat), device: outputDevice }, null]);
+                    }
+                    completed += 1;
+                    node.status({ fill: "blue", shape: "dot", text: completed + "/" + range.count + " · " + discovered.filter(function (item) { return item.discovered; }).length + " gasite" });
+                });
+
+                const finalNeighbors = await neighborTable(current);
+                discovered.forEach(function (device) {
+                    const finalMac = finalNeighbors.get(device.ip) || null;
+                    device.mac = finalMac || device.mac || null;
+                    if (finalMac) device.arp_neighbor = true;
+                    device.manufacturer = device.modbus && device.modbus.manufacturer || null;
+                    device.model = device.modbus && device.modbus.model || null;
+                    device.firmware = device.modbus && device.modbus.firmware || null;
+                    device.serial = device.modbus && device.modbus.serial || null;
+                    device.sunspec = !!(device.modbus && device.modbus.units.some(function (unit) { return unit && unit.protocol === "sunspec"; }));
+                    device.services = servicesFor(device);
+                    device.mac_vendor = macVendor(device.mac);
+                    device.identification_confidence = identificationConfidence(device);
+                    device.summary = deviceSummary(device);
+                });
+                const filteredDevices = discovered.filter(function (device) { return matchesProfile(device, requestedProfile); });
+                filteredDevices.sort(function (a, b) { return ipToNumber(a.ip) - ipToNumber(b.ip); });
+                const onlineHosts = discovered.filter(function (item) { return item.online; }).length;
+                const openPortHosts = discovered.filter(function (item) { return item.open_ports.length > 0; }).length;
+                const modbusHosts = discovered.filter(function (item) { return item.modbus && item.modbus.confirmed; }).length;
+                const cleanDevices = filteredDevices.map(removeUnavailable);
+                const categories = categoryCollections(cleanDevices, node.deviceCollection);
+                const summary = { status: current.cancelled ? "cancelled" : "complete", target: String(target), scan_profile: requestedProfile, detail_level: requestedDetail, scanned_hosts: completed, checked_ports: ports, online_hosts: onlineHosts, open_port_hosts: openPortHosts, confirmed_modbus_hosts: modbusHosts, discovered_hosts: onlineHosts, detected_devices: filteredDevices.length, device_count: cleanDevices.length, device_index: node.deviceCollection, estimated_tcp_duration_ms: estimatedTcpDurationMs, duration_ms: Date.now() - startedAt, devices: indexDevices(cleanDevices, node.deviceCollection), categories: categories };
+                const matchField = {
+                    sunspec: "detected_sunspec_hosts",
+                    mqtt: "confirmed_mqtt_hosts",
+                    web: "detected_web_hosts",
+                    industrial: "detected_industrial_hosts",
+                    full: "detected_devices",
+                    custom: "detected_devices"
+                }[requestedProfile];
+                if (matchField && !Object.prototype.hasOwnProperty.call(summary, matchField)) summary[matchField] = filteredDevices.length;
+                node.status({ fill: current.cancelled ? "yellow" : "green", shape: "dot", text: summary.discovered_hosts + " dispozitive · " + summary.duration_ms + " ms" });
+                send([null, { topic: "modbus-tcp-discover/summary", payload: summary }]);
+                if (done) done();
+            } catch (error) {
+                node.status({ fill: "red", shape: "ring", text: "eroare" });
+                send([null, { topic: "modbus-tcp-discover/error", payload: { status: "error", error: error.message || String(error) } }]);
+                if (done) done(error);
+            } finally {
+                if (session === current) session = null;
+            }
+        }
+
+        function schedule() {
+            if (closing || node.interval <= 0) return;
+            timer = setTimeout(function () {
+                scan({}, node.send.bind(node), function () { schedule(); });
+            }, node.interval);
+        }
+
+        node.on("input", function (msg, send, done) { scan(msg || {}, send || node.send.bind(node), done); });
+        if (node.scanOnStart) setTimeout(function () { scan({}, node.send.bind(node), function () { schedule(); }); }, 1000);
+        else schedule();
+        node.on("close", function (done) {
+            closing = true;
+            if (timer) clearTimeout(timer);
+            cancelScan();
+            done();
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("modbus-tcp-discover", DiscoverNode);
+};