node-red-contrib-knx-ultimate 6.2.2 → 6.2.3-beta.0

package/nodes/utils/hueControllerProfiles/runtime/zigbee_connectivity.js

@@ -0,0 +1,185 @@
+// Canonical private runtime profile for HUE Controller: zigbee_connectivity.
+// This module is shipped with the Controller but is intentionally absent from
+// package.json, so Node-RED never registers it as a separate palette node.
+module.exports = function (RED) {
+  function knxUltimateHueZigbeeConnectivity (config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+    node.serverKNX = RED.nodes.getNode(config.server) || undefined
+    node.serverHue = RED.nodes.getNode(config.serverHue) || undefined
+    node.topic = node.name
+    node.name = config.name === undefined ? 'Hue' : config.name
+    node.dpt = ''
+    node.notifyreadrequest = true
+    node.notifyreadrequestalsorespondtobus = 'false'
+    node.notifyreadrequestalsorespondtobusdefaultvalueifnotinitialized = ''
+    node.notifyresponse = false
+    node.notifywrite = true
+    node.initialread = true
+    node.listenallga = true // Don't remove
+    node.outputtype = 'write'
+    node.outputRBE = 'false' // Apply or not RBE to the output (Messages coming from flow)
+    node.inputRBE = 'false' // Apply or not RBE to the input (Messages coming from BUS)
+    node.currentPayload = '' // Current value for the RBE input and for the .previouspayload msg
+    node.passthrough = 'no'
+    node.formatmultiplyvalue = 1
+    node.formatnegativevalue = 'leave'
+    node.formatdecimalsvalue = 2
+    node.hueDevice = config.hueDevice
+    node.initializingAtStart = (config.readStatusAtStartup === undefined || config.readStatusAtStartup === 'yes')
+    node.currentDeviceValue = 0
+    const pinsSetting = (config.enableNodePINS === undefined || config.enableNodePINS === 'yes' || config.enableNodePINS === true)
+    node.enableNodePINS = pinsSetting ? 'yes' : 'no'
+    node.outputs = pinsSetting ? 1 : 0
+    if (!node.serverKNX && node.outputs === 0) {
+      node.enableNodePINS = 'yes'
+      node.outputs = 1
+    }
+
+    const pushStatus = (status) => {
+      if (!status) return
+      const provider = node.serverKNX
+      if (provider && typeof provider.applyStatusUpdate === 'function') {
+        provider.applyStatusUpdate(node, status)
+      } else {
+        node.status(status)
+      }
+    }
+
+    const updateStatus = (status) => {
+      if (!status) return
+      pushStatus(status)
+    }
+
+    const formatTs = (date) => {
+      const d = date instanceof Date ? date : new Date(date)
+      const provider = node.serverKNX
+      if (provider && typeof provider.formatStatusTimestamp === 'function') return provider.formatStatusTimestamp(d)
+      return `${d.getDate()}, ${d.toLocaleTimeString()}`
+    }
+
+    const safeSendToKNX = (telegram, context = 'write') => {
+      try {
+        if (!node.serverKNX || typeof node.serverKNX.sendKNXTelegramToKNXEngine !== 'function') {
+          const now = new Date()
+          updateStatus({ fill: 'red', shape: 'dot', text: `KNX server missing (${context}) (${formatTs(now)})` })
+          return
+        }
+        node.serverKNX.sendKNXTelegramToKNXEngine({ ...telegram, nodecallerid: node.id })
+      } catch (error) {
+        updateStatus({ fill: 'red', shape: 'dot', text: `KNX send error ${error.message}` })
+      }
+    }
+
+    // Used to call the status update from the config node.
+    node.setNodeStatus = ({
+      fill, shape, text, payload
+    }) => {
+      try {
+        if (payload === undefined) payload = ''
+        const dDate = new Date()
+        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
+        node.sKNXNodeStatusText = `|KNX: ${text} ${payload} (${formatTs(dDate)})`
+        pushStatus({ fill, shape, text: (node.sHUENodeStatusText || '') + ' ' + (node.sKNXNodeStatusText || '') })
+      } catch (error) { }
+    }
+    // Used to call the status update from the HUE config node.
+    node.setNodeStatusHue = ({ fill, shape, text, payload }) => {
+      try {
+        if (payload === undefined) payload = ''
+        const dDate = new Date()
+        payload = typeof payload === 'object' ? JSON.stringify(payload) : payload.toString()
+        node.sHUENodeStatusText = `|HUE: ${text} ${payload} (${formatTs(dDate)})`
+        pushStatus({ fill, shape, text: node.sHUENodeStatusText + ' ' + (node.sKNXNodeStatusText || '') })
+      } catch (error) { }
+    }
+
+    // This function is called by the knx-ultimate config node, to output a msg.payload.
+    node.handleSend = (msg) => {
+      // Respond to KNX read telegram, by sending the current value as response telegram.
+      if (msg.knx.event === 'GroupValue_Read') {
+        switch (msg.knx.destination) {
+          case config.GAzigbeeconnectivity:
+            // To the KNX bus wires
+            node.sendResponseToKNX(node.currentDeviceValue)
+            break
+          default:
+            break
+        }
+      }
+    }
+
+    node.handleSendHUE = (_event) => {
+      try {
+        // Event status: one of connected, disconnected, connectivity_issue, unidirectional_incoming
+        if (_event.id === config.hueDevice) {
+          if (!_event.hasOwnProperty('status') || _event.status === undefined) return
+
+          const knxMsgPayload = {}
+          knxMsgPayload.topic = config.GAzigbeeconnectivity
+          knxMsgPayload.dpt = config.dptzigbeeconnectivity
+
+          knxMsgPayload.payload = (_event.status === 'connected')
+          // Send to KNX bus
+          if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+            safeSendToKNX({
+              grpaddr: knxMsgPayload.topic, payload: knxMsgPayload.payload, dpt: knxMsgPayload.dpt, outputtype: 'write'
+            }, 'write')
+          }
+          node.currentDeviceValue = knxMsgPayload.payload
+          // Setup the output msg
+          knxMsgPayload.name = node.name
+          knxMsgPayload.status = _event.status
+          knxMsgPayload.event = 'zigbee_connectivity'
+          // Send payload
+          knxMsgPayload.rawEvent = _event
+          node.send(knxMsgPayload)
+          node.setNodeStatusHue({
+            fill: 'blue', shape: 'ring', text: 'HUE->KNX', payload: knxMsgPayload.payload
+          })
+        }
+      } catch (error) {
+        updateStatus({ fill: 'red', shape: 'dot', text: `HUE->KNX error ${error.message} (${formatTs(new Date())})` })
+      }
+    }
+
+    node.sendResponseToKNX = (_level) => {
+      const knxMsgPayload = {}
+      knxMsgPayload.topic = config.GAzigbeeconnectivity
+      knxMsgPayload.dpt = config.dptzigbeeconnectivity
+
+      knxMsgPayload.payload = _level
+      // Send to KNX bus
+      if (knxMsgPayload.topic !== '' && knxMsgPayload.topic !== undefined) {
+        safeSendToKNX({
+          grpaddr: knxMsgPayload.topic, payload: knxMsgPayload.payload, dpt: knxMsgPayload.dpt, outputtype: 'response'
+        }, 'response')
+      }
+    }
+
+    // On each deploy, unsubscribe+resubscribe
+    if (node.serverKNX) {
+      node.serverKNX.removeClient(node)
+      node.serverKNX.addClient(node)
+    }
+    if (node.serverHue) {
+      node.serverHue.removeClient(node)
+      node.serverHue.addClient(node)
+    }
+
+    node.on('input', (msg) => {
+
+    })
+
+    node.on('close', (done) => {
+      if (node.serverKNX) {
+        node.serverKNX.removeClient(node)
+      }
+      if (node.serverHue) {
+        node.serverHue.removeClient(node)
+      }
+      done()
+    })
+  }
+  RED.nodes.registerType('knxUltimateHueZigbeeConnectivity', knxUltimateHueZigbeeConnectivity)
+}

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "6.2.2",
+  "version": "6.2.3-beta.0",
   "description": "KNX Ultimate is the most advanced KNX integration for Node-RED, providing secure KNX/IP communication, routing, ETS project import, Philips Hue, Matter Controller and Matter Bridge (control matter device via KNX and expose KNX GA via Matter), MQTT, diagnostics with AI, virtual devices, and powerful automation nodes. Build professional, reliable, and scalable smart home and building automation projects with minimal effort.",
   "files": [
     "nodes/",
@@ -53,6 +53,7 @@
       "knxUltimateWatchDog": "/nodes/knxUltimateWatchDog.js",
       "knxUltimate-config": "/nodes/knxUltimate-config.js",
       "hueConfig": "/nodes/hue-config.js",
+      "knxUltimateHueController": "/nodes/knxUltimateHueController.js",
       "knxUltimateHueLight": "/nodes/knxUltimateHueLight.js",
       "knxUltimateMatterControllerDevice": "/nodes/knxUltimateMatterControllerDevice.js",
       "knxUltimateHueButton": "/nodes/knxUltimateHueButton.js",
@@ -108,8 +109,10 @@
     "build": "npm run knx-ai:build && npm run knx-viewer:build",
     "prepack": "npm run knx-ai:build && npm run knx-viewer:build",
     "prepublishOnly": "npm run build",
-    "test": "DEBUG_KNX_HUE_TEST=0 npm run test:unit && node scripts/check-node-load.js",
+    "test": "npm run hue-controller:check && DEBUG_KNX_HUE_TEST=0 npm run test:unit && node scripts/check-node-load.js",
     "test:unit": "mocha \"test/**/*.test.js\"",
+    "hue-controller:generate": "node scripts/generate-hue-controller-profiles.js",
+    "hue-controller:check": "node scripts/generate-hue-controller-profiles.js --check",
     "avviaquesto-itest:light": "node test/integration/hueLiveTest.mjs",
     "avviaquesto-itest:matterlight": "node test/integration/matterLiveTest.mjs",
     "avviaquesto-itest:nodered-knx": "node test/integration/nodeRedLiveTest.mjs",

package/resources/hueControllerMigration.js

@@ -0,0 +1,199 @@
+(function (root, factory) {
+  const api = factory()
+  if (typeof module === 'object' && module.exports) module.exports = api
+  if (root) root.KNXUltimateHueControllerMigration = api
+}(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict'
+
+  const LEGACY_NODE_PROFILES = Object.freeze({
+    knxUltimateHueLight: { controllerType: 'light', pinMode: 'dual', pinsDefault: false },
+    knxUltimateHuePlug: { controllerType: 'plug', pinMode: 'dual', pinsDefault: false },
+    knxUltimateHueButton: { controllerType: 'button', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueTapDial: { controllerType: 'relative_rotary', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueMotion: { controllerType: 'motion', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueAreaMotion: { controllerType: 'area_motion', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueCameraMotion: { controllerType: 'camera_motion', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueContactSensor: { controllerType: 'contact', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueLightSensor: { controllerType: 'light_level', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueTemperatureSensor: { controllerType: 'temperature', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueHumiditySensor: { controllerType: 'humidity', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueScene: { controllerType: 'scene', pinMode: 'dual', pinsDefault: false },
+    knxUltimateHueBattery: { controllerType: 'device_power', pinMode: 'output', pinsDefault: true },
+    knxUltimateHueZigbeeConnectivity: { controllerType: 'zigbee_connectivity', pinMode: 'output', pinsDefault: true },
+    knxUltimateHuedevice_software_update: { controllerType: 'device_software_update', pinMode: 'output', pinsDefault: true }
+  })
+
+  const CONFIG_NODE_REFERENCE_FIELDS = Object.freeze({
+    'knxUltimate-config': 'server',
+    'hue-config': 'serverHue'
+  })
+
+  // Kept as a tiny public predicate so the editor can decide whether the
+  // migration entry point is relevant without duplicating the canonical type
+  // catalog. It only classifies an object; it never reads or changes a flow.
+  function isLegacyHueNode (node) {
+    return Boolean(node && typeof node === 'object' && LEGACY_NODE_PROFILES[node.type])
+  }
+
+  function hasEnabledPins (node, profile) {
+    const rawValue = node.enableNodePINS
+    if (rawValue === true) return true
+    if (rawValue === false) return false
+    if (typeof rawValue === 'string' && rawValue.trim() !== '') {
+      return rawValue.trim().toLowerCase() === 'yes'
+    }
+    return profile.pinsDefault === true
+  }
+
+  function readPinCount (value) {
+    if (value === undefined || value === null || value === '') return undefined
+    const numericValue = Number(value)
+    if (!Number.isInteger(numericValue) || numericValue < 0) return undefined
+    return numericValue
+  }
+
+  function derivePinShape (node, profile) {
+    const enabled = hasEnabledPins(node, profile)
+    const defaults = profile.pinMode === 'dual'
+      ? { inputs: enabled ? 1 : 0, outputs: enabled ? 1 : 0 }
+      : { inputs: 0, outputs: enabled ? 1 : 0 }
+    const exportedInputs = readPinCount(node.inputs)
+    const exportedOutputs = readPinCount(node.outputs)
+    const wiredOutputs = Array.isArray(node.wires) ? node.wires.length : undefined
+
+    return {
+      inputs: exportedInputs === undefined ? defaults.inputs : exportedInputs,
+      outputs: exportedOutputs === undefined
+        ? (wiredOutputs === undefined ? defaults.outputs : wiredOutputs)
+        : exportedOutputs
+    }
+  }
+
+  function cloneFlowNode (node, index) {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) {
+      throw new TypeError(`Flow entry ${index} is not a Node-RED node object`)
+    }
+    return JSON.parse(JSON.stringify(node))
+  }
+
+  function copyTextWithTemporaryTextarea (text, documentObject) {
+    if (!documentObject || !documentObject.body || typeof documentObject.createElement !== 'function') {
+      throw new Error('Clipboard fallback is unavailable')
+    }
+
+    const temporary = documentObject.createElement('textarea')
+    temporary.value = String(text)
+    temporary.readOnly = true
+    temporary.setAttribute('aria-hidden', 'true')
+    temporary.style.position = 'fixed'
+    temporary.style.left = '-9999px'
+    temporary.style.top = '0'
+    documentObject.body.appendChild(temporary)
+
+    try {
+      temporary.focus()
+      temporary.select()
+      if (typeof temporary.setSelectionRange === 'function') {
+        temporary.setSelectionRange(0, temporary.value.length)
+      }
+      if (typeof documentObject.execCommand !== 'function' || documentObject.execCommand('copy') !== true) {
+        throw new Error('The browser refused clipboard access')
+      }
+      return true
+    } finally {
+      if (temporary.parentNode) temporary.parentNode.removeChild(temporary)
+    }
+  }
+
+  function copyTextToClipboard (text, environment = {}) {
+    const value = String(text)
+    const navigatorObject = environment.navigator
+    const documentObject = environment.document
+    const clipboard = navigatorObject && navigatorObject.clipboard
+    const fallback = () => copyTextWithTemporaryTextarea(value, documentObject)
+
+    if (clipboard && typeof clipboard.writeText === 'function') {
+      try {
+        return Promise.resolve(clipboard.writeText(value))
+          .then(() => true)
+          .catch(fallback)
+      } catch (error) {
+        return Promise.resolve().then(fallback)
+      }
+    }
+    return Promise.resolve().then(fallback)
+  }
+
+  function convertLegacyHueFlow (sourceFlow, options = {}) {
+    if (!Array.isArray(sourceFlow)) {
+      throw new TypeError('The pasted Node-RED flow must be a JSON array')
+    }
+
+    let convertedCount = 0
+    const convertedByType = {}
+    const referencedConfigIds = new Set()
+    const flow = sourceFlow.map(function (sourceNode, index) {
+      const node = cloneFlowNode(sourceNode, index)
+      const profile = LEGACY_NODE_PROFILES[node.type]
+      if (!profile) return node
+
+      const oldType = node.type
+      const pinShape = derivePinShape(node, profile)
+      node.type = 'knxUltimateHueController'
+      node.hueControllerType = profile.controllerType
+      node.inputs = pinShape.inputs
+      node.outputs = pinShape.outputs
+      Object.values(CONFIG_NODE_REFERENCE_FIELDS).forEach(function (field) {
+        if (typeof node[field] === 'string' && node[field].trim() !== '') {
+          referencedConfigIds.add(node[field])
+        }
+      })
+      convertedCount += 1
+      convertedByType[oldType] = (convertedByType[oldType] || 0) + 1
+      return node
+    })
+
+    const reuseConfigNodes = options.reuseConfigNodes !== false
+    const omittedConfigByType = {}
+    const convertedFlow = reuseConfigNodes && convertedCount > 0
+      ? flow.filter(function (node) {
+          const referenceField = CONFIG_NODE_REFERENCE_FIELDS[node.type]
+          const omitNode = Boolean(referenceField && referencedConfigIds.has(node.id))
+          if (omitNode) omittedConfigByType[node.type] = (omittedConfigByType[node.type] || 0) + 1
+          return !omitNode
+        })
+      : flow
+    const omittedConfigCount = Object.values(omittedConfigByType)
+      .reduce((total, count) => total + count, 0)
+
+    return {
+      flow: convertedFlow,
+      convertedCount,
+      convertedByType,
+      omittedConfigCount,
+      omittedConfigByType
+    }
+  }
+
+  function convertLegacyHueFlowJson (rawJson, options = {}) {
+    if (typeof rawJson !== 'string' || rawJson.trim() === '') {
+      throw new TypeError('Paste a Node-RED flow before starting the conversion')
+    }
+    const sourceFlow = JSON.parse(rawJson)
+    const result = convertLegacyHueFlow(sourceFlow, options)
+    return {
+      ...result,
+      json: JSON.stringify(result.flow, null, 2)
+    }
+  }
+
+  return {
+    CONFIG_NODE_REFERENCE_FIELDS,
+    LEGACY_NODE_PROFILES,
+    copyTextToClipboard,
+    convertLegacyHueFlow,
+    convertLegacyHueFlowJson,
+    derivePinShape,
+    isLegacyHueNode
+  }
+}))

package/resources/hueControllerMigrationDialog.js

@@ -0,0 +1,189 @@
+(function (root, factory) {
+  const api = factory()
+  if (typeof module === 'object' && module.exports) module.exports = api
+  if (root) {
+    root.KNXUltimateHueControllerMigrationDialog = api
+    if (root.RED && root.jQuery && root.document) {
+      api.installLegacyButton(root.RED, root.jQuery, root, root.document)
+    }
+  }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict'
+
+  const EVENT_NAMESPACE = '.knxUltimateHueControllerMigrationDialog'
+  const BUTTON_SELECTOR = '.hue-legacy-migrate-flow'
+  const I18N_PREFIX = 'node-red-contrib-knx-ultimate/knxUltimateHueController:knxUltimateHueController.'
+  let closeActiveDialog = function () {}
+
+  function defaultTranslate (RED, key, fallback, values) {
+    try {
+      const qualifiedKey = `${I18N_PREFIX}${key}`
+      const translated = RED._(qualifiedKey, values)
+      if (translated && translated !== qualifiedKey) return translated
+    } catch (error) { /* use fallback */ }
+    return fallback
+  }
+
+  function open (options = {}) {
+    const RED = options.RED
+    const $ = options.$
+    const windowObject = options.windowObject
+    const documentObject = options.documentObject
+    const migrationApi = options.migrationApi || (windowObject && windowObject.KNXUltimateHueControllerMigration)
+    const translate = typeof options.translate === 'function'
+      ? options.translate
+      : (key, fallback, values) => defaultTranslate(RED, key, fallback, values)
+
+    if (!RED || !$ || !windowObject || !documentObject || !migrationApi || typeof migrationApi.convertLegacyHueFlowJson !== 'function') {
+      if (RED && typeof RED.notify === 'function') {
+        RED.notify(translate('migration_unavailable', 'The HUE migration tool is unavailable. Restart Node-RED after updating the package.'), 'error')
+      }
+      return function () {}
+    }
+
+    const $dialog = $('<div class="hue-controller-migration-dialog"></div>').appendTo('body')
+    $('<div class="hue-controller-migration-note"></div>')
+      .text(translate('migration_privacy', 'Paste an exported Node-RED flow. Conversion happens locally and does not modify the open flow.'))
+      .css({ marginBottom: '8px' })
+      .appendTo($dialog)
+    $('<div class="hue-controller-migration-credentials"></div>')
+      .text(translate('migration_credentials_notice', 'Node-RED deliberately excludes keys and passwords from exported flows. The converter cannot read or recreate them.'))
+      .css({ marginBottom: '12px', padding: '8px 10px', borderLeft: '4px solid #d79b00', background: '#fff8df' })
+      .appendTo($dialog)
+    $('<label for="hue-controller-migration-input"></label>')
+      .text(translate('migration_input', 'Original flow JSON'))
+      .css({ display: 'block', fontWeight: 'bold', marginBottom: '4px' })
+      .appendTo($dialog)
+    const $input = $('<textarea id="hue-controller-migration-input"></textarea>')
+      .attr('placeholder', translate('migration_input_placeholder', 'Paste the complete Node-RED flow export here'))
+      .css({ width: '100%', height: '190px', boxSizing: 'border-box', fontFamily: 'monospace', resize: 'vertical' })
+      .appendTo($dialog)
+    const $reuseConfigsRow = $('<div></div>')
+      .css({ margin: '10px 0' })
+      .appendTo($dialog)
+    const $reuseConfigs = $('<input type="checkbox" id="hue-controller-migration-reuse-configs">')
+      .prop('checked', true)
+      .appendTo($reuseConfigsRow)
+    $('<label for="hue-controller-migration-reuse-configs"></label>')
+      .text(` ${translate('migration_reuse_configs', 'Reuse existing Hue and KNX config nodes (recommended)')}`)
+      .css({ display: 'inline', fontWeight: 'bold' })
+      .appendTo($reuseConfigsRow)
+    $('<div></div>')
+      .text(translate('migration_reuse_configs_help', 'Keep this selected when importing back into the same Node-RED installation. Referenced config nodes are omitted from the result, so their stored credentials remain untouched.'))
+      .css({ margin: '4px 0 0 22px', color: '#666' })
+      .appendTo($reuseConfigsRow)
+    const $toolbar = $('<div></div>')
+      .css({ display: 'flex', gap: '8px', alignItems: 'center', margin: '10px 0' })
+      .appendTo($dialog)
+    const $convert = $('<button type="button" class="red-ui-button"></button>')
+      .append($('<i class="fa fa-exchange"></i>'))
+      .append(documentObject.createTextNode(` ${translate('migration_convert', 'Convert')}`))
+      .appendTo($toolbar)
+    const $copy = $('<button type="button" class="red-ui-button"></button>')
+      .append($('<i class="fa fa-clipboard"></i>'))
+      .append(documentObject.createTextNode(` ${translate('migration_copy', 'Copy converted flow')}`))
+      .prop('disabled', true)
+      .appendTo($toolbar)
+    const $status = $('<span class="hue-controller-migration-status"></span>')
+      .css({ marginLeft: '4px' })
+      .appendTo($toolbar)
+    $('<label for="hue-controller-migration-output"></label>')
+      .text(translate('migration_output', 'Converted flow JSON'))
+      .css({ display: 'block', fontWeight: 'bold', marginBottom: '4px' })
+      .appendTo($dialog)
+    const $output = $('<textarea id="hue-controller-migration-output" readonly></textarea>')
+      .css({ width: '100%', height: '230px', boxSizing: 'border-box', fontFamily: 'monospace', resize: 'vertical' })
+      .appendTo($dialog)
+
+    $convert.on(`click${EVENT_NAMESPACE}`, () => {
+      try {
+        const result = migrationApi.convertLegacyHueFlowJson($input.val(), {
+          reuseConfigNodes: $reuseConfigs.prop('checked')
+        })
+        $output.val(result.json).scrollTop(0)
+        $copy.prop('disabled', false)
+        if (result.convertedCount === 0) {
+          $status.text(translate('migration_none', 'No legacy HUE nodes were found.')).css('color', '#a15c00')
+        } else {
+          let summary = translate('migration_summary', '{{count}} legacy HUE nodes converted.')
+            .replace('{{count}}', String(result.convertedCount))
+          let statusColor = '#1b7d33'
+          if (result.omittedConfigCount > 0) {
+            summary += ` ${translate('migration_summary_reused', '{{count}} referenced config nodes will be reused with their existing credentials.')
+              .replace('{{count}}', String(result.omittedConfigCount))}`
+          } else if (!$reuseConfigs.prop('checked')) {
+            summary += ` ${translate('migration_configs_included_warning', 'Config nodes are included without exported credentials; enter their keys and passwords after import.')}`
+            statusColor = '#a15c00'
+          }
+          $status.text(summary).css('color', statusColor)
+        }
+      } catch (error) {
+        $output.val('')
+        $copy.prop('disabled', true)
+        const message = error && error.message ? error.message : String(error)
+        $status.text(`${translate('migration_invalid', 'Invalid flow JSON:')} ${message}`).css('color', '#b00020')
+      }
+    })
+
+    $copy.on(`click${EVENT_NAMESPACE}`, () => {
+      const convertedJson = $output.val()
+      if (!convertedJson) return
+      $copy.prop('disabled', true)
+      migrationApi.copyTextToClipboard(convertedJson, {
+        navigator: windowObject.navigator,
+        document: documentObject
+      }).then(() => {
+        RED.notify(translate('migration_copy_success', 'Converted flow copied.'), 'success')
+      }).catch(() => {
+        const outputElement = $output.get(0)
+        if (outputElement) {
+          outputElement.focus()
+          outputElement.select()
+          if (typeof outputElement.setSelectionRange === 'function') {
+            outputElement.setSelectionRange(0, convertedJson.length)
+          }
+        }
+        RED.notify(translate('migration_copy_failed', 'Clipboard access was blocked. The converted JSON has been selected; copy it manually.'), 'error')
+      }).finally(() => {
+        $copy.prop('disabled', false)
+      })
+    })
+
+    let closed = false
+    const closeDialog = () => {
+      if (closed) return
+      closed = true
+      $convert.off(EVENT_NAMESPACE)
+      $copy.off(EVENT_NAMESPACE)
+      try { $dialog.dialog('destroy') } catch (error) { /* already detached */ }
+      $dialog.remove()
+    }
+
+    $dialog.dialog({
+      modal: true,
+      width: Math.min(920, Math.max(620, $(windowObject).width() - 80)),
+      height: Math.min(760, Math.max(600, $(windowObject).height() - 60)),
+      title: translate('migration_title', 'Convert legacy HUE flow'),
+      close: closeDialog,
+      buttons: [{
+        text: translate('migration_close', 'Close'),
+        click () { $(this).dialog('close') }
+      }]
+    })
+    setTimeout(() => $input.trigger('focus'), 0)
+    return closeDialog
+  }
+
+  function installLegacyButton (RED, $, windowObject, documentObject) {
+    if (!RED || !$ || !documentObject) return
+    const $document = $(documentObject)
+    $document.off(`click${EVENT_NAMESPACE}`, BUTTON_SELECTOR)
+    $document.on(`click${EVENT_NAMESPACE}`, BUTTON_SELECTOR, (event) => {
+      event.preventDefault()
+      closeActiveDialog()
+      closeActiveDialog = open({ RED, $, windowObject, documentObject })
+    })
+  }
+
+  return { installLegacyButton, open }
+}))