node-red-contrib-knx-ultimate 5.2.1 → 5.2.2

package/nodes/knxUltimateMatterBridge.js

@@ -1,24 +1,88 @@
-const path = require('path')
 const dptlib = require('knxultimate').dptlib
 
-// The running Matter servers, keyed by node id. Kept OUTSIDE the node lifecycle:
-// a re-deploy must NOT restart the Matter server, otherwise the paired controllers
-// resume their session without re-reading the structure and never see device changes.
-// The devices are reconciled live instead; the server is closed only when the node
-// is deleted/disabled or Node-RED shuts down.
-const runningBridges = new Map()
-
-// Exposes KNX group addresses as Matter devices (bridge/aggregator):
-// external Matter controllers (Alexa, Google Home, Apple Home...) commission this
-// bridge once and control/see every configured KNX virtual device.
+// One KNX device exposed as a Matter device. It points to a matterbridge-config node
+// (the actual Matter server/bridge, paired once by Alexa/Google/Apple Home) and registers
+// itself as one bridged device. This is the opposite direction of the Matter Device node.
 module.exports = function (RED) {
+  // The functions of each device type, with their GA/DPT config fields.
+  // direction 'command' = Matter -> KNX (write to the bus), 'status' = KNX -> Matter.
+  const DEVICE_FUNCTIONS = {
+    onofflight: [
+      { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
+      { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' }
+    ],
+    onoffplug: [
+      { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
+      { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' }
+    ],
+    dimmablelight: [
+      { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
+      { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
+      { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
+      { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' }
+    ],
+    rgblight: [
+      { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
+      { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
+      { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
+      { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' },
+      { fn: 'rgb', direction: 'command', ga: 'gaRGB', dpt: 'dptRGB', fallbackDpt: '232.600' },
+      { fn: 'rgb', direction: 'status', ga: 'gaRGBStatus', dpt: 'dptRGBStatus', fallbackDpt: '232.600' }
+    ],
+    colortemperaturelight: [
+      { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
+      { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
+      { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
+      { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' },
+      { fn: 'colortemp', direction: 'command', ga: 'gaCT', dpt: 'dptCT', fallbackDpt: '7.600' },
+      { fn: 'colortemp', direction: 'status', ga: 'gaCTStatus', dpt: 'dptCTStatus', fallbackDpt: '7.600' }
+    ],
+    temperaturesensor: [{ fn: 'temperature', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.001' }],
+    humiditysensor: [{ fn: 'humidity', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.007' }],
+    lightsensor: [{ fn: 'illuminance', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.004' }],
+    occupancysensor: [{ fn: 'occupancy', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.011' }],
+    contactsensor: [{ fn: 'contact', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.002' }],
+    windowcovering: [
+      { fn: 'updown', direction: 'command', ga: 'gaUpDown', dpt: 'dptUpDown', fallbackDpt: '1.008' },
+      { fn: 'stop', direction: 'command', ga: 'gaStop', dpt: 'dptStop', fallbackDpt: '1.017' },
+      { fn: 'position', direction: 'command', ga: 'gaPosition', dpt: 'dptPosition', fallbackDpt: '5.001' },
+      { fn: 'position', direction: 'status', ga: 'gaPositionStatus', dpt: 'dptPositionStatus', fallbackDpt: '5.001' }
+    ],
+    thermostat: [
+      { fn: 'currenttemp', direction: 'status', ga: 'gaCurrentTemp', dpt: 'dptCurrentTemp', fallbackDpt: '9.001' },
+      { fn: 'setpoint', direction: 'command', ga: 'gaSetpoint', dpt: 'dptSetpoint', fallbackDpt: '9.001' },
+      { fn: 'setpoint', direction: 'status', ga: 'gaSetpointStatus', dpt: 'dptSetpointStatus', fallbackDpt: '9.001' }
+    ],
+    smokecoalarm: [
+      { fn: 'smoke', direction: 'status', ga: 'gaSmoke', dpt: 'dptSmoke', fallbackDpt: '1.005' },
+      { fn: 'co', direction: 'status', ga: 'gaCO', dpt: 'dptCO', fallbackDpt: '1.005' }
+    ],
+    waterleakdetector: [{ fn: 'leak', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.005' }],
+    airqualitysensor: [{ fn: 'co2', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.008' }],
+    fan: [
+      { fn: 'fanspeed', direction: 'command', ga: 'gaFanSpeed', dpt: 'dptFanSpeed', fallbackDpt: '5.001' },
+      { fn: 'fanspeed', direction: 'status', ga: 'gaFanSpeedStatus', dpt: 'dptFanSpeedStatus', fallbackDpt: '5.001' }
+    ],
+    robotvacuum: [] // Flow-only device: talks to the flow through the node PINs
+  }
+
   function knxUltimateMatterBridge (config) {
     RED.nodes.createNode(this, config)
     const node = this
     node.serverKNX = RED.nodes.getNode(config.server) || undefined
+    node.serverMatterBridge = RED.nodes.getNode(config.serverMatterBridge) || undefined
+
+    node.deviceType = config.deviceType || 'onofflight'
+    node.name = config.name === undefined || config.name === '' ? 'Matter device' : config.name
+    // The Matter device id is the (stable) Node-RED node id, so the endpoint survives re-deploys.
+    node.matterDeviceId = node.id
+    node.invertPosition = config.invertPosition === true || config.invertPosition === 'true'
+    node.readStatusAtStartup = config.readStatusAtStartup === undefined || config.readStatusAtStartup === 'yes'
+    node.enableNodePINS = config.enableNodePINS === 'yes'
+    node.inputs = node.enableNodePINS ? 1 : 0
+    node.outputs = node.enableNodePINS ? 1 : 0
 
-    node.topic = node.name
-    node.name = config.name === undefined || config.name === '' ? 'Matter Bridge (BETA)' : config.name
+    node.topic = ''
     node.dpt = ''
     node.notifyreadrequest = false
     node.notifyreadrequestalsorespondtobus = 'false'
@@ -36,87 +100,7 @@ module.exports = function (RED) {
     node.formatnegativevalue = 'leave'
     node.formatdecimalsvalue = 2
 
-    node.bridgePort = Number(config.bridgePort) || 5540
-    node.bridgeDeviceName = config.bridgeDeviceName || 'KNX-Ultimate Bridge'
-    node.readStatusAtStartup = config.readStatusAtStartup === undefined || config.readStatusAtStartup === 'yes'
-    node.enableNodePINS = config.enableNodePINS === 'yes'
-    node.inputs = node.enableNodePINS ? 1 : 0
-    node.outputs = node.enableNodePINS ? 1 : 0
-    node.devices = []
-    try {
-      node.devices = Array.isArray(config.devices) ? config.devices : JSON.parse(config.devices || '[]')
-    } catch (error) {
-      node.devices = []
-    }
-
-    node.matterBridge = null
-    node.matterInstanceId = `knxultimate-bridge-${node.id.replace(/[^a-zA-Z0-9]/g, '')}`
-    node.matterStoragePath = path.join(RED.settings.userDir || '.', 'knxultimatestorage', 'matter')
-    let startupTimer = null
     let initialReadTimer = null
-    let closing = false
-
-    // The functions of each device type, with their GA/DPT config fields.
-    // direction 'command' = Matter -> KNX (write to the bus), 'status' = KNX -> Matter.
-    const DEVICE_FUNCTIONS = {
-      onofflight: [
-        { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
-        { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' }
-      ],
-      onoffplug: [
-        { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
-        { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' }
-      ],
-      dimmablelight: [
-        { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
-        { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
-        { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
-        { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' }
-      ],
-      rgblight: [
-        { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
-        { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
-        { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
-        { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' },
-        { fn: 'rgb', direction: 'command', ga: 'gaRGB', dpt: 'dptRGB', fallbackDpt: '232.600' },
-        { fn: 'rgb', direction: 'status', ga: 'gaRGBStatus', dpt: 'dptRGBStatus', fallbackDpt: '232.600' }
-      ],
-      colortemperaturelight: [
-        { fn: 'onoff', direction: 'command', ga: 'gaOnOff', dpt: 'dptOnOff', fallbackDpt: '1.001' },
-        { fn: 'onoff', direction: 'status', ga: 'gaOnOffStatus', dpt: 'dptOnOffStatus', fallbackDpt: '1.001' },
-        { fn: 'level', direction: 'command', ga: 'gaLevel', dpt: 'dptLevel', fallbackDpt: '5.001' },
-        { fn: 'level', direction: 'status', ga: 'gaLevelStatus', dpt: 'dptLevelStatus', fallbackDpt: '5.001' },
-        { fn: 'colortemp', direction: 'command', ga: 'gaCT', dpt: 'dptCT', fallbackDpt: '7.600' },
-        { fn: 'colortemp', direction: 'status', ga: 'gaCTStatus', dpt: 'dptCTStatus', fallbackDpt: '7.600' }
-      ],
-      temperaturesensor: [{ fn: 'temperature', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.001' }],
-      humiditysensor: [{ fn: 'humidity', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.007' }],
-      lightsensor: [{ fn: 'illuminance', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.004' }],
-      occupancysensor: [{ fn: 'occupancy', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.011' }],
-      contactsensor: [{ fn: 'contact', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.002' }],
-      windowcovering: [
-        { fn: 'updown', direction: 'command', ga: 'gaUpDown', dpt: 'dptUpDown', fallbackDpt: '1.008' },
-        { fn: 'stop', direction: 'command', ga: 'gaStop', dpt: 'dptStop', fallbackDpt: '1.017' },
-        { fn: 'position', direction: 'command', ga: 'gaPosition', dpt: 'dptPosition', fallbackDpt: '5.001' },
-        { fn: 'position', direction: 'status', ga: 'gaPositionStatus', dpt: 'dptPositionStatus', fallbackDpt: '5.001' }
-      ],
-      thermostat: [
-        { fn: 'currenttemp', direction: 'status', ga: 'gaCurrentTemp', dpt: 'dptCurrentTemp', fallbackDpt: '9.001' },
-        { fn: 'setpoint', direction: 'command', ga: 'gaSetpoint', dpt: 'dptSetpoint', fallbackDpt: '9.001' },
-        { fn: 'setpoint', direction: 'status', ga: 'gaSetpointStatus', dpt: 'dptSetpointStatus', fallbackDpt: '9.001' }
-      ],
-      smokecoalarm: [
-        { fn: 'smoke', direction: 'status', ga: 'gaSmoke', dpt: 'dptSmoke', fallbackDpt: '1.005' },
-        { fn: 'co', direction: 'status', ga: 'gaCO', dpt: 'dptCO', fallbackDpt: '1.005' }
-      ],
-      waterleakdetector: [{ fn: 'leak', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '1.005' }],
-      airqualitysensor: [{ fn: 'co2', direction: 'status', ga: 'gaStatus', dpt: 'dptStatus', fallbackDpt: '9.008' }],
-      fan: [
-        { fn: 'fanspeed', direction: 'command', ga: 'gaFanSpeed', dpt: 'dptFanSpeed', fallbackDpt: '5.001' },
-        { fn: 'fanspeed', direction: 'status', ga: 'gaFanSpeedStatus', dpt: 'dptFanSpeedStatus', fallbackDpt: '5.001' }
-      ],
-      robotvacuum: [] // Flow-only device: talks to the flow through the node PINs
-    }
 
     const formatTs = (date) => {
       const d = date instanceof Date ? date : new Date(date)
@@ -157,205 +141,94 @@ module.exports = function (RED) {
       }
     }
 
-    // Precompute the routing tables:
-    // statusRoutes: GA -> [{ deviceId, fn, dpt }] (KNX -> Matter)
-    // commandRoutes: deviceId + fn -> { ga, dpt } (Matter -> KNX)
+    // Precompute the routing tables for this single device:
+    // statusRoutes: GA -> [{ fn, dpt }] (KNX -> Matter)
+    // commandRoutes: fn -> { ga, dpt } (Matter -> KNX)
     const statusRoutes = new Map()
     const commandRoutes = new Map()
-    // Reads a device config value, also recovering the corrupted keys written by early
-    // 5.2.0 editors (jQuery UI polluted the key with " ui-autocomplete-input").
-    const devConfigValue = (dev, key) => {
-      if (dev[key] !== undefined) return (dev[key] || '').trim()
-      const corrupted = dev[`${key} ui-autocomplete-input`]
-      return (corrupted || '').trim()
-    }
-    node.devices.forEach((dev) => {
-      const functions = DEVICE_FUNCTIONS[dev.type] || []
-      functions.forEach((fnDef) => {
-        const ga = devConfigValue(dev, fnDef.ga)
-        if (ga === '') return
-        const dpt = devConfigValue(dev, fnDef.dpt) || fnDef.fallbackDpt
-        if (fnDef.direction === 'status') {
-          if (!statusRoutes.has(ga)) statusRoutes.set(ga, [])
-          statusRoutes.get(ga).push({ deviceId: dev.id, fn: fnDef.fn, dpt })
-        } else {
-          commandRoutes.set(`${dev.id}#${fnDef.fn}`, { ga, dpt })
-        }
-      })
+    const devConfigValue = (key) => (config[key] || '').toString().trim()
+    ;(DEVICE_FUNCTIONS[node.deviceType] || []).forEach((fnDef) => {
+      const ga = devConfigValue(fnDef.ga)
+      if (ga === '') return
+      const dpt = devConfigValue(fnDef.dpt) || fnDef.fallbackDpt
+      if (fnDef.direction === 'status') {
+        if (!statusRoutes.has(ga)) statusRoutes.set(ga, [])
+        statusRoutes.get(ga).push({ fn: fnDef.fn, dpt })
+      } else {
+        commandRoutes.set(fnDef.fn, { ga, dpt })
+      }
     })
 
-    const updateBridgeStatus = () => {
+    // The device definition consumed by the bridge engine (via the config node).
+    node.getMatterDef = () => ({
+      id: node.matterDeviceId,
+      type: node.deviceType,
+      name: node.name,
+      invertPosition: node.invertPosition === true
+    })
+
+    // Reflects the bridge (config node) status on this device node.
+    node.handleBridgeStatus = () => {
       try {
-        if (node.matterBridge === null) {
-          node.setNodeStatus({ fill: 'grey', shape: 'ring', text: 'Matter bridge starting...' })
+        if (node.serverMatterBridge === undefined) {
+          node.setNodeStatus({ fill: 'red', shape: 'ring', text: 'No Matter bridge selected' })
           return
         }
-        const info = node.matterBridge.getPairingInfo()
+        const info = node.serverMatterBridge.getPairingInfo()
         if (!info.running) {
-          node.setNodeStatus({ fill: 'red', shape: 'ring', text: 'Matter bridge stopped' })
+          node.setNodeStatus({ fill: 'grey', shape: 'ring', text: 'Matter bridge starting...' })
         } else if (info.commissioned) {
-          node.setNodeStatus({ fill: 'green', shape: 'dot', text: `Bridge online, paired with ${info.fabrics.length} controller(s), ${info.deviceCount} device(s), ${commandRoutes.size} cmd GA, ${statusRoutes.size} status GA` })
+          node.setNodeStatus({ fill: 'green', shape: 'dot', text: `Ready (bridge paired with ${info.fabrics.length} controller(s))` })
         } else {
-          node.setNodeStatus({ fill: 'yellow', shape: 'ring', text: `Awaiting pairing. Code ${info.manualPairingCode || ''}, ${info.deviceCount} device(s)` })
+          node.setNodeStatus({ fill: 'yellow', shape: 'ring', text: `Bridge awaiting pairing (code ${info.manualPairingCode || ''})` })
         }
       } catch (error) { /* empty */ }
     }
 
-    // Ask the KNX bus for the current values of all status GAs, so the Matter
-    // attributes are populated before a controller reads them.
-    const doInitialRead = () => {
-      if (!node.readStatusAtStartup) return
-      if (!node.serverKNX) return // Flow-only bridge (no KNX gateway): nothing to read
+    // Matter -> KNX: a controller (Alexa...) sent a command to this device.
+    node.handleMatterCommand = (command) => {
       try {
-        let delay = 0
-        statusRoutes.forEach((routes, ga) => {
-          delay += 200
-          setTimeout(() => {
-            safeSendToKNX({ grpaddr: ga, payload: '', dpt: '', outputtype: 'read' }, 'read')
-          }, delay)
-        })
-      } catch (error) {
-        node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Initial read error ${error.message}` })
-      }
-    }
-
-    const bindEngineEvents = (engine) => {
-      // Matter -> KNX: a controller (Alexa...) sent a command to a bridged device
-      engine.on('command', (command) => {
-        try {
-          const dev = node.devices.find((d) => d.id === command.deviceId)
-          // Forward every controller command to the flow, when the pins are enabled
-          if (node.enableNodePINS) {
-            try {
-              node.send({
-                topic: dev !== undefined ? dev.name : command.deviceId,
-                payload: command.value,
-                device: dev !== undefined ? { id: dev.id, type: dev.type, name: dev.name } : { id: command.deviceId },
-                matter: command
-              })
-            } catch (error) { /* empty */ }
-          }
-          const route = commandRoutes.get(`${command.deviceId}#${command.fn}`)
-          if (route === undefined) {
-            if (node.enableNodePINS) return // Flow-only device: the flow already got the command
-            // Make the misconfiguration visible instead of silently dropping the command
-            node.setNodeStatus({
-              fill: 'yellow',
-              shape: 'ring',
-              text: `No command GA configured for "${dev !== undefined ? dev.name : command.deviceId}" (${command.fn}): open the node, check the GA fields and re-deploy`,
-              payload: ''
-            })
-            RED.log.warn(`knxUltimateMatterBridge: Matter command dropped, no GA route for ${command.deviceId}#${command.fn}`)
-            return
-          }
-          if (!node.serverKNX) {
-            // Flow-only bridge: with the PINs enabled the flow already received the command
-            if (node.enableNodePINS) return
-            node.setNodeStatus({
-              fill: 'yellow',
-              shape: 'ring',
-              text: `No KNX gateway configured: enable the node PINs to handle "${dev !== undefined ? dev.name : command.deviceId}" from the flow`,
-              payload: ''
+        if (node.enableNodePINS) {
+          try {
+            node.send({
+              topic: node.name,
+              payload: command.value,
+              device: { id: node.matterDeviceId, type: node.deviceType, name: node.name },
+              matter: command
             })
-            return
-          }
-          safeSendToKNX({
-            grpaddr: route.ga,
-            payload: command.value,
-            dpt: route.dpt,
-            outputtype: 'write'
-          }, 'write')
-          node.setNodeStatus({
-            fill: 'green',
-            shape: 'dot',
-            text: `Matter->KNX ${dev !== undefined ? dev.name : command.deviceId} ${command.fn}`,
-            payload: command.value
-          })
-        } catch (error) {
-          node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Matter->KNX error ${error.message}` })
+          } catch (error) { /* empty */ }
         }
-      })
-
-      engine.on('commissioned', () => updateBridgeStatus())
-      engine.on('decommissioned', () => updateBridgeStatus())
-      engine.on('fabricsChanged', () => updateBridgeStatus())
-      engine.on('online', () => {
-        updateBridgeStatus()
-        if (initialReadTimer !== null) clearTimeout(initialReadTimer)
-        initialReadTimer = setTimeout(() => doInitialRead(), 5000)
-      })
-    }
-
-    const buildEngineDefs = () => node.devices
-      .filter((dev) => dev.id && dev.type && DEVICE_FUNCTIONS[dev.type] !== undefined)
-      .map((dev) => ({ id: dev.id, type: dev.type, name: dev.name, invertPosition: dev.invertPosition === true }))
-
-    const startBridge = async () => {
-      try {
-        const { classMatterBridge } = await import('./utils/matterBridgeEngine.mjs')
-        const engineDefs = buildEngineDefs()
-        const existing = runningBridges.get(node.id)
-
-        if (existing !== undefined && existing.bridgeStatus === 'running' &&
-          Number(existing.options.port) === node.bridgePort &&
-          existing.options.deviceName === node.bridgeDeviceName) {
-          // Re-deploy: reuse the running Matter server and reconcile the devices live,
-          // so the paired controllers (Alexa & Co.) pick up the changes immediately.
-          existing.removeAllListeners()
-          node.matterBridge = existing
-          bindEngineEvents(existing)
-          await existing.reconcileDevices(engineDefs)
-          updateBridgeStatus()
-          if (initialReadTimer !== null) clearTimeout(initialReadTimer)
-          initialReadTimer = setTimeout(() => doInitialRead(), 5000)
+        const route = commandRoutes.get(command.fn)
+        if (route === undefined) {
+          if (node.enableNodePINS) return // Flow-only device: the flow already got the command
+          node.setNodeStatus({ fill: 'yellow', shape: 'ring', text: `No command GA for ${command.fn}: check the node and re-deploy` })
           return
         }
-
-        if (existing !== undefined) {
-          // Port or bridge name changed: a full restart is unavoidable
-          try {
-            existing.removeAllListeners()
-            await existing.close()
-          } catch (error) { /* empty */ }
-          runningBridges.delete(node.id)
+        if (!node.serverKNX) {
+          if (node.enableNodePINS) return
+          node.setNodeStatus({ fill: 'yellow', shape: 'ring', text: `No KNX gateway: enable the node PINs to handle ${command.fn}` })
+          return
         }
-
-        const engine = new classMatterBridge(node.matterStoragePath, node.matterInstanceId, {
-          info: (m) => RED.log.info(m),
-          warn: (m) => RED.log.warn(m),
-          error: (m) => RED.log.error(m),
-          debug: (m) => RED.log.debug(m)
-        }, { port: node.bridgePort, deviceName: node.bridgeDeviceName })
-        runningBridges.set(node.id, engine)
-        node.matterBridge = engine
-        bindEngineEvents(engine)
-        await engine.start(engineDefs)
-        updateBridgeStatus()
+        safeSendToKNX({ grpaddr: route.ga, payload: command.value, dpt: route.dpt, outputtype: 'write' }, 'write')
+        node.setNodeStatus({ fill: 'green', shape: 'dot', text: `Matter->KNX ${command.fn}`, payload: command.value })
       } catch (error) {
-        node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Matter bridge start error: ${error.message}` })
-        RED.log.error(`knxUltimateMatterBridge: start error: ${error.message}`)
+        node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Matter->KNX error ${error.message}` })
       }
     }
 
-    // KNX -> Matter: telegrams from the bus update the Matter attributes
+    // KNX -> Matter: telegrams from the bus update the Matter attributes of this device.
     node.handleSend = (msg) => {
       try {
         if (!msg || !msg.knx) return
         if (msg.knx.event === 'GroupValue_Read') return
         const routes = statusRoutes.get(msg.knx.destination)
-        if (routes === undefined || node.matterBridge === null) return
+        if (routes === undefined || node.serverMatterBridge === undefined) return
         routes.forEach((route) => {
           try {
             const value = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(route.dpt))
             if (value === undefined || value === null) return
-            node.matterBridge.setDeviceState(route.deviceId, route.fn, value)
-            const dev = node.devices.find((d) => d.id === route.deviceId)
-            node.setNodeStatus({
-              fill: 'blue',
-              shape: 'dot',
-              text: `KNX->Matter ${dev !== undefined ? dev.name : route.deviceId} ${route.fn}`,
-              payload: value
-            })
+            node.serverMatterBridge.setDeviceState(node.matterDeviceId, route.fn, value)
+            node.setNodeStatus({ fill: 'blue', shape: 'dot', text: `KNX->Matter ${route.fn}`, payload: value })
           } catch (error) {
             node.setNodeStatus({ fill: 'red', shape: 'dot', text: `KNX->Matter error ${error.message}` })
           }
@@ -365,18 +238,22 @@ module.exports = function (RED) {
       }
     }
 
-    // Called by the admin endpoints (editor UI)
-    node.getBridgePairingInfo = () => {
-      if (node.matterBridge === null) return { running: false }
-      return node.matterBridge.getPairingInfo()
-    }
-
-    node.factoryResetBridge = async () => {
-      if (node.matterBridge === null) throw new Error('Matter bridge not started')
-      await node.matterBridge.factoryReset()
-      updateBridgeStatus()
+    // Ask the KNX bus for the current values of the status GAs, so the Matter
+    // attributes are populated before a controller reads them.
+    const doInitialRead = () => {
+      if (!node.readStatusAtStartup || !node.serverKNX) return
+      try {
+        let delay = 0
+        statusRoutes.forEach((routes, ga) => {
+          delay += 200
+          setTimeout(() => {
+            safeSendToKNX({ grpaddr: ga, payload: '', dpt: '', outputtype: 'read' }, 'read')
+          }, delay)
+        })
+      } catch (error) { /* empty */ }
     }
 
+    // Register with the KNX gateway (to receive bus telegrams) and the Matter bridge.
     if (node.serverKNX) {
       try {
         node.serverKNX.removeClient(node)
@@ -385,9 +262,20 @@ module.exports = function (RED) {
         RED.log.error(`knxUltimateMatterBridge: register KNX client error ${error.message}`)
       }
     }
+    if (node.serverMatterBridge) {
+      try {
+        node.serverMatterBridge.registerDevice(node)
+      } catch (error) {
+        RED.log.error(`knxUltimateMatterBridge: register bridge device error ${error.message}`)
+      }
+    } else {
+      node.setNodeStatus({ fill: 'red', shape: 'ring', text: 'No Matter bridge selected' })
+    }
+
+    initialReadTimer = setTimeout(() => doInitialRead(), 12000)
 
-    // Flow input pin: updates the Matter state of a virtual device without going through the KNX bus.
-    // msg.payload = { device: 'Kitchen light' (name or id), function: 'onoff'|'level'|'position'|'temperature'|..., value: ... }
+    // Flow input pin: updates the Matter state of this device without going through the KNX bus.
+    // msg.payload = { function: 'onoff'|'level'|'position'|'temperature'|..., value: ... }
     node.on('input', (msg, send, done) => {
       if (!node.enableNodePINS) {
         if (done) done()
@@ -395,16 +283,11 @@ module.exports = function (RED) {
       }
       try {
         const payload = msg.payload || {}
-        const deviceKey = (payload.device !== undefined ? payload.device : msg.topic || '').toString().trim()
         const fn = (payload.function || payload.fn || '').toString().trim()
-        if (deviceKey === '' || fn === '' || payload.value === undefined) {
-          throw new Error('msg.payload must be { device, function, value }')
-        }
-        const dev = node.devices.find((d) => d.id === deviceKey || (d.name || '').toLowerCase() === deviceKey.toLowerCase())
-        if (dev === undefined) throw new Error(`Unknown bridge device "${deviceKey}"`)
-        if (node.matterBridge === null) throw new Error('Matter bridge not started yet')
-        node.matterBridge.setDeviceState(dev.id, fn, payload.value)
-        node.setNodeStatus({ fill: 'green', shape: 'dot', text: `Flow->Matter ${dev.name} ${fn}`, payload: payload.value })
+        if (fn === '' || payload.value === undefined) throw new Error('msg.payload must be { function, value }')
+        if (node.serverMatterBridge === undefined) throw new Error('No Matter bridge selected')
+        node.serverMatterBridge.setDeviceState(node.matterDeviceId, fn, payload.value)
+        node.setNodeStatus({ fill: 'green', shape: 'dot', text: `Flow->Matter ${fn}`, payload: payload.value })
         if (done) done()
       } catch (error) {
         node.setNodeStatus({ fill: 'red', shape: 'dot', text: `Flow error ${error.message}`, payload: '' })
@@ -412,43 +295,17 @@ module.exports = function (RED) {
       }
     })
 
-    node.setNodeStatus({ fill: 'grey', shape: 'ring', text: 'Matter bridge starting in 5s...' })
-    startupTimer = setTimeout(() => {
-      (async () => {
-        if (closing) return
-        try {
-          await startBridge()
-        } catch (error) {
-          RED.log.error(`knxUltimateMatterBridge: startup error: ${error.message}`)
-        }
-      })()
-    }, 5000)
-
-    // On re-deploy (removed === false) the Matter server stays alive: the new node
-    // instance will reuse it and reconcile the devices, so paired controllers never
-    // lose the session. The server is closed only when the node is deleted/disabled.
-    node.on('close', (removed, done) => {
-      closing = true
+    node.on('close', (done) => {
       try {
-        if (startupTimer !== null) clearTimeout(startupTimer)
         if (initialReadTimer !== null) clearTimeout(initialReadTimer)
       } catch (error) { /* empty */ }
       try {
         if (node.serverKNX) node.serverKNX.removeClient(node)
       } catch (error) { /* empty */ }
       try {
-        if (node.matterBridge !== null) node.matterBridge.removeAllListeners()
+        if (node.serverMatterBridge) node.serverMatterBridge.unregisterDevice(node)
       } catch (error) { /* empty */ }
-      (async () => {
-        try {
-          if (removed === true && node.matterBridge !== null) {
-            await node.matterBridge.close()
-            runningBridges.delete(node.id)
-          }
-        } catch (error) { /* empty */ }
-        node.matterBridge = null
-        done()
-      })()
+      if (done) done()
     })
   }
 

package/nodes/knxUltimateMatterDevice.html

@@ -3,6 +3,32 @@
 
 <script type="text/javascript">
     (function () {
+        let manualListResize = false;
+        let programmaticListHeight = -1;
+
+        // Adds the native browser resize grip (bottom-right corner) to the mappings list,
+        // so the user can drag it to any height, exactly like a textarea.
+        function enableManualListResize(container) {
+            try {
+                manualListResize = false;
+                programmaticListHeight = -1;
+                const $ui = container.closest('.red-ui-editableList-container');
+                if (!$ui.length) return;
+                $ui.css('resize', 'vertical');
+                if (window.ResizeObserver) {
+                    const observer = new ResizeObserver(() => {
+                        try {
+                            const h = $ui.outerHeight();
+                            if (programmaticListHeight > 0 && Math.abs(h - programmaticListHeight) > 8) {
+                                manualListResize = true;
+                            }
+                        } catch (error) { /* empty */ }
+                    });
+                    observer.observe($ui[0]);
+                }
+            } catch (error) { /* empty */ }
+        }
+
         RED.nodes.registerType('knxUltimateMatterDevice', {
             category: 'KNX Ultimate Matter',
             color: '#D7C7E9',
@@ -443,6 +469,8 @@
                     container.editableList('addItem', { mapping: m });
                 });
 
+                enableManualListResize(container);
+
                 // Load the structure of the already selected device
                 if (node.matterNodeId) {
                     loadStructure(node.matterNodeId);
@@ -487,6 +515,24 @@
             },
             oneditcancel() {
                 try { RED.sidebar.show('info'); } catch (error) { /* empty */ }
+            },
+            oneditresize(size) {
+                // Grow the mappings list to fill the edit panel. Once the user grabs the native
+                // resize grip of the list, the manual height wins and the auto-fit backs off.
+                try {
+                    if (manualListResize) return;
+                    const rows = $('#dialog-form>div:not(.node-input-mapping-container-row)');
+                    let height = size.height;
+                    for (let i = 0; i < rows.length; i++) {
+                        height -= $(rows[i]).outerHeight(true);
+                    }
+                    const editorRow = $('#dialog-form>div.node-input-mapping-container-row');
+                    height -= (parseInt(editorRow.css('marginTop')) + parseInt(editorRow.css('marginBottom')));
+                    height += 16;
+                    const target = Math.max(220, height);
+                    programmaticListHeight = target;
+                    $('#node-input-mapping-container').editableList('height', target);
+                } catch (error) { /* empty */ }
             }
         });
     }());