node-red-contrib-knx-ultimate 7.1.0-beta.2 → 7.1.2

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "7.1.0-beta.2",
+  "version": "7.1.2",
   "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 and Modbus adapters, diagnostics, virtual devices, and powerful automation nodes. Build professional, reliable, and scalable smart home and building automation projects with minimal effort.",
   "files": [
     "nodes/",
@@ -24,13 +24,17 @@
     "mqtt": "^5.15.2",
     "ping": "0.4.4",
     "simple-get": "4.0.1",
-    "winston": "^3.17.0"
+    "winston": "^3.17.0",
+    "google-translate-tts": "^0.3.0",
+    "js-yaml": "4.3.2"
   },
   "node-red": {
     "version": ">=3.1.1",
     "plugins": {
       "commonFunctions": "/nodes/commonFunctions.js",
-      "knxUltimateFlowBubbles": "/nodes/plugins/knxUltimate-flow-bubbles-plugin.html"
+      "knxUltimateFlowBubbles": "/nodes/plugins/knxUltimate-flow-bubbles-plugin.html",
+      "knxUltimateMigrationNotice": "/nodes/plugins/knxUltimate-migration-notice-plugin.html",
+      "knxUltimateCerebrumRuntime": "/nodes/plugins/knxUltimate-cerebrum-runtime-plugin.js"
     },
     "nodes": {
       "knxUltimate": "/nodes/knxUltimate.js",
@@ -71,7 +75,9 @@
       "knxUltimateHueCameraMotion": "/nodes/knxUltimateHueCameraMotion.js",
       "matter-config": "/nodes/matter-config.js",
       "matterbridge-config": "/nodes/matterbridge-config.js",
-      "knxUltimateMatterBridge": "/nodes/knxUltimateMatterBridge.js"
+      "knxUltimateMatterBridge": "/nodes/knxUltimateMatterBridge.js",
+      "knxUltimateAI": "/nodes/knxUltimateAI.js",
+      "knxUltimateAIHomeAssistant": "/nodes/knxUltimateAIHomeAssistant.js"
     }
   },
   "repository": {
@@ -105,7 +111,7 @@
   },
   "license": "MIT",
   "scripts": {
-    "build": "npm run knx-viewer:build",
+    "build": "npm run knx-ai:build && npm run knx-viewer:build",
     "prepack": "npm run build",
     "prepublishOnly": "npm run build",
     "test": "npm run hue-controller:check && npm run knx-utility:check && DEBUG_KNX_HUE_TEST=0 npm run test:unit && node scripts/check-node-load.js",
@@ -137,15 +143,17 @@
     "docs:serve": "node scripts/dev-serve-docs.js",
     "docs:serve:norl": "node scripts/dev-serve-docs.js",
     "knx-utility:generate": "node scripts/generate-knx-utility-profiles.js",
-    "knx-utility:check": "node scripts/generate-knx-utility-profiles.js --check"
+    "knx-utility:check": "node scripts/generate-knx-utility-profiles.js --check",
+    "knx-ai:dev": "vite --config ui/knxUltimateAI-vue/vite.config.mjs",
+    "knx-ai:build": "vite build --config ui/knxUltimateAI-vue/vite.config.mjs"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.8",
     "chai": "^4.3.10",
-    "js-yaml": "4.3.2",
     "marked": "^14.1.0",
     "mocha": "^10.4.0",
     "vite": "^7.3.6",
-    "vue": "^3.5.41"
+    "vue": "^3.5.41",
+    "jspdf": "^4.2.1"
   }
-}
+}

package/resources/KNXAIChatAdapterMappings.js

@@ -0,0 +1,416 @@
+; (function (root) {
+  const KNXAIChatAdapterMappings = [
+    {
+      id: 'windkh-telegrambot',
+      title: 'windkh/node-red-contrib-telegrambot',
+      inputCode: `// Receiver/Event -> Cerebrum Ultimate
+// Supports normal "telegram receiver" messages, including the one-time
+// reply-keyboard confirmation buttons, plus legacy callback_query events.
+const telegram = msg.payload;
+if (!telegram || typeof telegram !== 'object') return;
+
+const chatId = telegram.chatId;
+if (chatId === undefined || chatId === null) return;
+
+msg.sessionId = String(chatId);
+msg.language =
+    (msg.originalMessage && msg.originalMessage.from && msg.originalMessage.from.language_code) ||
+    msg.language ||
+    '';
+
+if (telegram.type === 'voice') {
+    const original = msg.originalMessage && typeof msg.originalMessage === 'object'
+        ? msg.originalMessage
+        : {};
+    const voice = original.voice && typeof original.voice === 'object'
+        ? original.voice
+        : original.message && original.message.voice && typeof original.message.voice === 'object'
+            ? original.message.voice
+            : {};
+    const fileId = String(telegram.content || voice.file_id || '').trim();
+    const weblink = String(telegram.weblink || msg.weblink || '').trim();
+    const botDetails = msg.telegramBot && typeof msg.telegramBot === 'object' ? msg.telegramBot : {};
+    const botApiBase = String(botDetails.baseApiUrl || botDetails.baseapiurl || botDetails.baseApiURL || '').trim();
+    let allowedOrigin = 'https://api.telegram.org';
+    if (botApiBase) {
+        try { allowedOrigin = new URL(botApiBase).origin; } catch (error) { /* use Telegram default */ }
+    }
+    if (!fileId && !weblink) return;
+    msg.topic = 'ask';
+    msg.knxAi = Object.assign({}, msg.knxAi, {
+        sessionId: String(chatId),
+        voiceInput: {
+            source: 'telegram',
+            originalType: 'voice',
+            fileId: fileId,
+            weblink: weblink,
+            allowedOrigin: allowedOrigin,
+            mediaType: String(voice.mime_type || telegram.contentType || telegram.mimeType || 'audio/ogg'),
+            filename: String(voice.file_name || telegram.filename || 'telegram-voice.ogg'),
+            durationSeconds: Math.max(0, Number(voice.duration || telegram.duration) || 0),
+            fileSize: Math.max(0, Number(voice.file_size || telegram.fileSize) || 0)
+        }
+    });
+    return msg;
+}
+
+const content = typeof telegram.content === 'string' ? telegram.content.trim() : '';
+if (content === '') return;
+
+if (telegram.type === 'callback_query' && (content === 'confirm' || content === 'cancel')) {
+    msg.topic = content;
+    msg.knxAi = Object.assign({}, msg.knxAi, {
+        sessionId: String(chatId),
+        confirm: content === 'confirm'
+    });
+    return msg;
+}
+
+if (telegram.type !== 'message') return;
+msg.topic = 'ask';
+msg.prompt = content;
+return msg;`,
+      outputCode: `// Cerebrum Ultimate chat output -> Telegram sender
+// Converts the text reply and, when required, adds a one-time reply keyboard.
+// A button click returns through the normal Telegram receiver, so no separate
+// callback event node is required.
+const source = msg.inputMessage && typeof msg.inputMessage === 'object'
+    ? msg.inputMessage
+    : inputMessage;
+const sourcePayload = source && source.payload && typeof source.payload === 'object'
+    ? source.payload
+    : {};
+const chatId = sourcePayload.chatId !== undefined
+    ? sourcePayload.chatId
+    : source && source.chatId;
+if (chatId === undefined || chatId === null) return;
+
+let content = msg.payload;
+if (content && typeof content === 'object') {
+    content = content.error || content.message || JSON.stringify(content);
+}
+content = String(content === undefined || content === null ? '' : content);
+
+const image = msg.knxAi && msg.knxAi.image;
+if (image && Buffer.isBuffer(image.data)) {
+    msg.payload = {
+        chatId: chatId,
+        type: 'photo',
+        content: image.data,
+        options: {
+            caption: content.slice(0, 1024)
+        },
+        fileOptions: {
+            filename: image.filename || 'camera-snapshot.jpg',
+            contentType: image.mediaType || 'image/jpeg'
+        }
+    };
+    return msg;
+}
+
+const audio = msg.knxAi && msg.knxAi.audio;
+if (audio && Buffer.isBuffer(audio.data)) {
+    const voiceLanguage = String(msg.knxAi.language || (source && source.language) || '').trim().toLowerCase().split(/[-_]/)[0];
+    const disclosureLabels = {
+        de: 'KI-generierte Stimme',
+        en: 'AI-generated voice',
+        es: 'Voz generada por IA',
+        fr: 'Voix générée par l’IA',
+        it: 'Voce generata dall’IA',
+        zh: 'AI 生成的语音'
+    };
+    const disclosure = disclosureLabels[voiceLanguage] || disclosureLabels.en;
+    const voiceOptions = { caption: [disclosure, content].filter(Boolean).join('\\n').slice(0, 1024) };
+    const confirmation = msg.knxAi && msg.knxAi.confirmationRequest;
+    if (confirmation && confirmation.required === true && Array.isArray(confirmation.actions)) {
+        voiceOptions.reply_markup = JSON.stringify({
+            keyboard: [confirmation.actions.map(function (action) {
+                return { text: action.label };
+            })],
+            resize_keyboard: true,
+            one_time_keyboard: true
+        });
+    } else if (msg.knxAi && Array.isArray(msg.knxAi.suggestions) && msg.knxAi.suggestions.length) {
+        voiceOptions.reply_markup = JSON.stringify({
+            keyboard: msg.knxAi.suggestions.slice(0, 3).map(function (suggestion) {
+                return [{ text: Array.from(String(suggestion.text || suggestion.label || '').trim()).slice(0, 64).join('') }];
+            }).filter(function (row) { return row[0].text; }),
+            resize_keyboard: true,
+            one_time_keyboard: true
+        });
+    } else if (/^knx_confirmation_/.test(String(msg.knxAi.type || '')) || /^knx_routine_/.test(String(msg.knxAi.type || ''))) {
+        voiceOptions.reply_markup = JSON.stringify({ remove_keyboard: true });
+    }
+    msg.payload = {
+        chatId: chatId,
+        type: 'voice',
+        content: audio.data,
+        options: voiceOptions,
+        fileOptions: {
+            filename: audio.filename || 'knx-ai-reply.ogg',
+            contentType: audio.mediaType || 'audio/ogg'
+        }
+    };
+    return msg;
+}
+
+const telegramPayload = {
+    chatId: chatId,
+    type: 'message',
+    content: content
+};
+const confirmation = msg.knxAi && msg.knxAi.confirmationRequest;
+if (confirmation && confirmation.required === true && Array.isArray(confirmation.actions)) {
+    telegramPayload.options = {
+        reply_markup: JSON.stringify({
+            keyboard: [confirmation.actions.map(function (action) {
+                return { text: action.label };
+            })],
+            resize_keyboard: true,
+            one_time_keyboard: true
+        })
+    };
+} else if (msg.knxAi && Array.isArray(msg.knxAi.suggestions) && msg.knxAi.suggestions.length) {
+    telegramPayload.options = {
+        reply_markup: JSON.stringify({
+            keyboard: msg.knxAi.suggestions.slice(0, 3).map(function (suggestion) {
+                return [{ text: Array.from(String(suggestion.text || suggestion.label || '').trim()).slice(0, 64).join('') }];
+            }).filter(function (row) { return row[0].text; }),
+            resize_keyboard: true,
+            one_time_keyboard: true
+        })
+    };
+} else if (msg.knxAi && (/^knx_confirmation_/.test(String(msg.knxAi.type || '')) || /^knx_routine_/.test(String(msg.knxAi.type || '')))) {
+    telegramPayload.options = {
+        reply_markup: JSON.stringify({ remove_keyboard: true })
+    };
+}
+
+msg.payload = telegramPayload;
+return msg;`
+    },
+    {
+      id: 'redbot-telegram',
+      title: 'RedBot / node-red-contrib-chatbot (Telegram)',
+      inputCode: `// RedBot Telegram Receiver -> Cerebrum Ultimate
+// RedBot normalizes Telegram text, voice audio and inline-button postbacks in msg.payload.
+const redbot = msg.payload;
+if (!redbot || typeof redbot !== 'object') return;
+if (redbot.transport && redbot.transport !== 'telegram') return;
+
+const chatId = redbot.chatId;
+if (chatId === undefined || chatId === null) return;
+
+msg.sessionId = String(chatId);
+msg.language =
+    (msg.originalMessage && msg.originalMessage.from && msg.originalMessage.from.language_code) ||
+    redbot.language ||
+    msg.language ||
+    '';
+
+const redbotType = String(redbot.type || '').trim().toLowerCase();
+if ((redbotType === 'audio' || redbotType === 'voice') && Buffer.isBuffer(redbot.content)) {
+    const original = msg.originalMessage && typeof msg.originalMessage === 'object'
+        ? msg.originalMessage
+        : {};
+    const voice = original.voice && typeof original.voice === 'object'
+        ? original.voice
+        : original.message && original.message.voice && typeof original.message.voice === 'object'
+            ? original.message.voice
+            : {};
+    msg.topic = 'ask';
+    msg.knxAi = Object.assign({}, msg.knxAi, {
+        sessionId: String(chatId),
+        voiceInput: {
+            source: 'telegram',
+            originalType: 'voice',
+            transport: 'redbot-buffer',
+            data: redbot.content,
+            fileId: String(voice.file_id || '').trim(),
+            mediaType: String(voice.mime_type || redbot.mimeType || 'audio/ogg'),
+            filename: String(voice.file_name || redbot.filename || 'telegram-voice.ogg'),
+            durationSeconds: Math.max(0, Number(voice.duration || redbot.duration) || 0),
+            fileSize: Math.max(0, Number(voice.file_size || redbot.fileSize) || redbot.content.length)
+        }
+    });
+    return msg;
+}
+
+const content = typeof redbot.content === 'string' ? redbot.content.trim() : '';
+if (redbotType !== 'message' || content === '') return;
+
+const action = content.toLowerCase();
+if (action === 'confirm' || action === 'cancel') {
+    msg.topic = action;
+    msg.knxAi = Object.assign({}, msg.knxAi, {
+        sessionId: String(chatId),
+        confirm: action === 'confirm'
+    });
+    return msg;
+}
+
+msg.topic = 'ask';
+msg.prompt = content;
+return msg;`,
+      outputCode: `// Cerebrum Ultimate chat output -> RedBot Telegram Sender
+// Preserves RedBot conversation helpers and emits either a plain message
+// or inline postback buttons for KNX confirmation/cancellation.
+const source = msg.inputMessage && typeof msg.inputMessage === 'object'
+    ? msg.inputMessage
+    : inputMessage;
+const sourcePayload = source && source.payload && typeof source.payload === 'object'
+    ? source.payload
+    : {};
+const originalMessage = source && source.originalMessage && typeof source.originalMessage === 'object'
+    ? source.originalMessage
+    : {};
+const chatId = sourcePayload.chatId !== undefined
+    ? sourcePayload.chatId
+    : originalMessage.chat && originalMessage.chat.id;
+if (chatId === undefined || chatId === null) return;
+
+// RedBot's Sender uses these helpers to resolve the active bot and chat context.
+['originalMessage', 'chat', 'api', 'client', 'redBot'].forEach(function (key) {
+    if (msg[key] === undefined && source && source[key] !== undefined) {
+        msg[key] = source[key];
+    }
+});
+
+// A persisted camera watch can fire immediately after Node-RED restarts,
+// before a new inbound RedBot message has recreated its conversation helpers.
+// RedBot's Telegram Sender still needs transport metadata and a chat accessor,
+// even when tracking is disabled. Supply the smallest compatible outbound
+// envelope; the configured Sender remains responsible for choosing the bot.
+if (!msg.originalMessage || typeof msg.originalMessage !== 'object') {
+    msg.originalMessage = {};
+}
+if (!msg.originalMessage.transport) msg.originalMessage.transport = sourcePayload.transport || 'telegram';
+if (msg.originalMessage.chatId === undefined) msg.originalMessage.chatId = chatId;
+if (sourcePayload.userId !== undefined && msg.originalMessage.userId === undefined) {
+    msg.originalMessage.userId = sourcePayload.userId;
+}
+if (typeof msg.chat !== 'function') {
+    const contextValues = {
+        chatId: chatId,
+        userId: sourcePayload.userId,
+        transport: sourcePayload.transport || 'telegram'
+    };
+    const syntheticContext = {
+        get: function () {
+            const keys = Array.prototype.slice.call(arguments);
+            if (keys.length === 0) return Object.assign({}, contextValues);
+            if (keys.length === 1) return contextValues[keys[0]];
+            return keys.reduce(function (result, key) {
+                result[key] = contextValues[key];
+                return result;
+            }, {});
+        },
+        set: function (key, value) {
+            if (key && typeof key === 'object') Object.assign(contextValues, key);
+            else if (key !== undefined) contextValues[key] = value;
+            return syntheticContext;
+        },
+        remove: function () {
+            Array.prototype.slice.call(arguments).forEach(function (key) { delete contextValues[key]; });
+            return syntheticContext;
+        },
+        clear: function () {
+            Object.keys(contextValues).forEach(function (key) { delete contextValues[key]; });
+            return syntheticContext;
+        },
+        all: function () { return Object.assign({}, contextValues); }
+    };
+    msg.chat = function () {
+        return syntheticContext;
+    };
+}
+if (typeof msg.get !== 'function') {
+    msg.get = function (key) {
+        if (key === 'userId') return sourcePayload.userId;
+        if (key === 'chatId') return chatId;
+        if (key === 'transport') return sourcePayload.transport || 'telegram';
+        return undefined;
+    };
+}
+
+let content = msg.payload;
+if (content && typeof content === 'object') {
+    content = content.error || content.message || JSON.stringify(content);
+}
+content = String(content === undefined || content === null ? '' : content);
+
+const image = msg.knxAi && msg.knxAi.image;
+if (image && Buffer.isBuffer(image.data)) {
+    msg.payload = {
+        transport: sourcePayload.transport || 'telegram',
+        chatId: chatId,
+        type: 'photo',
+        inbound: false,
+        content: image.data,
+        filename: image.filename || 'camera-snapshot.jpg',
+        mimeType: image.mediaType || 'image/jpeg',
+        caption: content.slice(0, 1024)
+    };
+    if (sourcePayload.userId !== undefined) msg.payload.userId = sourcePayload.userId;
+    return msg;
+}
+
+const confirmation = msg.knxAi && msg.knxAi.confirmationRequest;
+const audio = msg.knxAi && msg.knxAi.audio;
+if (audio && Buffer.isBuffer(audio.data) && !(confirmation && confirmation.required === true)) {
+    const voiceLanguage = String(msg.knxAi.language || (source && source.language) || '').trim().toLowerCase().split(/[-_]/)[0];
+    const disclosureLabels = {
+        de: 'KI-generierte Stimme',
+        en: 'AI-generated voice',
+        es: 'Voz generada por IA',
+        fr: 'Voix générée par l’IA',
+        it: 'Voce generata dall’IA',
+        zh: 'AI 生成的语音'
+    };
+    const disclosure = disclosureLabels[voiceLanguage] || disclosureLabels.en;
+    msg.payload = {
+        transport: sourcePayload.transport || 'telegram',
+        chatId: chatId,
+        type: 'audio',
+        inbound: false,
+        content: audio.data,
+        filename: audio.filename || 'knx-ai-reply.ogg',
+        mimeType: audio.mediaType || 'audio/ogg',
+        caption: [disclosure, content].filter(Boolean).join('\\n').slice(0, 1024)
+    };
+    if (sourcePayload.userId !== undefined) msg.payload.userId = sourcePayload.userId;
+    return msg;
+}
+
+const redbotPayload = {
+    transport: sourcePayload.transport || 'telegram',
+    chatId: chatId,
+    type: 'message',
+    inbound: false,
+    content: content
+};
+if (sourcePayload.userId !== undefined) redbotPayload.userId = sourcePayload.userId;
+
+if (confirmation && confirmation.required === true && Array.isArray(confirmation.actions)) {
+    redbotPayload.type = 'inline-buttons';
+    redbotPayload.buttons = confirmation.actions.map(function (action) {
+        return {
+            type: 'postback',
+            label: action.label,
+            value: action.callbackData
+        };
+    });
+}
+
+msg.payload = redbotPayload;
+return msg;`
+    }
+  ]
+
+  if (root) {
+    root.KNXAIChatAdapterMappings = KNXAIChatAdapterMappings
+  }
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = KNXAIChatAdapterMappings
+  }
+})(typeof window !== 'undefined' ? window : (typeof globalThis !== 'undefined' ? globalThis : this))

package/resources/hueControllerMigrationDialog.js

@@ -115,12 +115,14 @@
       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')
       }
+      if (typeof options.onClose === 'function') options.onClose()
       return function () {}
     }
 
     const legacyNodes = migrationApi.collectLegacyHueNodes(RED)
     if (legacyNodes.length === 0) {
       if (typeof RED.notify === 'function') RED.notify(translate('migration_none', 'No legacy HUE nodes were found.'), 'warning')
+      if (typeof options.onClose === 'function') options.onClose()
       return function () {}
     }
 
@@ -158,6 +160,7 @@
       if ($convert) $convert.off(EVENT_NAMESPACE)
       try { $dialog.dialog('destroy') } catch (error) { /* already detached */ }
       $dialog.remove()
+      if (typeof options.onClose === 'function') options.onClose()
     }
 
     const performMigration = () => {

package/resources/knxUtilityMigration.js

@@ -210,6 +210,7 @@
     const t = (key, fallback, values) => translate(RED, key, fallback, values)
     if (legacyNodes.length === 0) {
       RED.notify(t('migration_none', 'No compatible legacy KNX utility nodes were found.'), 'info')
+      if (typeof options.onClose === 'function') options.onClose()
       return
     }
     if (activeNotification && typeof activeNotification.close === 'function') activeNotification.close()
@@ -217,8 +218,10 @@
     let closed = false
     let notification
     const close = () => {
+      if (closed) return
       closed = true
       if (notification && typeof notification.close === 'function') notification.close()
+      if (typeof options.onClose === 'function') options.onClose()
     }
     notification = RED.notify(t('migration_confirm', 'Convert all {{count}} compatible legacy KNX utility nodes in every flow and subflow to KNX Utility? Before conversion, the browser automatically starts downloading a JSON backup of all flows. Protected credentials are excluded, as in the standard Node-RED export. Your browser may ask where to save the file. The current node editor will close and discard unsaved edits. IDs, settings, connections and groups are preserved. Conversion happens in this browser, can be undone, and takes effect when you Deploy.', { count: legacyNodes.length }), {
       modal: true,

package/resources/legacyMigrationNotice.js

@@ -0,0 +1,143 @@
+(function (root, factory) {
+  const api = factory()
+  if (typeof module === 'object' && module.exports) module.exports = api
+  if (root) root.KNXUltimateLegacyMigrationNotice = api
+}(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict'
+
+  const I18N_PREFIX = 'node-red-contrib-knx-ultimate/knxUltimateUtility:knxUltimateUtility.startup_migration.'
+  const installations = new WeakMap()
+
+  function install (RED, options = {}) {
+    if (installations.has(RED)) return installations.get(RED)
+    const environment = options.environment || globalThis
+    const $ = options.$ || environment.jQuery
+    const documentObject = environment.document
+    let notification
+    let timer
+    let dismissed = false
+    let disposed = false
+    let migrating = false
+    let closeMigration
+    let lastCounts = ''
+
+    function translate (key, fallback, values = {}) {
+      const qualifiedKey = I18N_PREFIX + key
+      let result
+      try { result = RED._(qualifiedKey, values) } catch (error) { /* use fallback */ }
+      result = result && result !== qualifiedKey ? result : fallback
+      return result.replace(/{{\s*(\w+)\s*}}/g, (match, name) => values[name] === undefined ? match : String(values[name]))
+    }
+
+    function closeNotice () {
+      if (notification) notification.close()
+      notification = undefined
+      lastCounts = ''
+    }
+
+    // Defer scans until the current import, undo or conversion batch finishes.
+    // Node events also cover initial loading in Node-RED's safe mode.
+    function schedule () {
+      if (disposed) return
+      if (timer !== undefined) environment.clearTimeout(timer)
+      timer = environment.setTimeout(refresh, 150)
+    }
+
+    function migrationClosed () {
+      migrating = false
+      closeMigration = undefined
+      schedule()
+    }
+
+    function openMigration (kind) {
+      if (disposed || migrating) return
+      closeNotice()
+      migrating = true
+      try {
+        if (kind === 'hue') {
+          closeMigration = environment.KNXUltimateHueControllerMigrationDialog.open({
+            RED, $, windowObject: environment, documentObject, onClose: migrationClosed
+          })
+        } else {
+          closeMigration = environment.KNXUltimateUtilityMigration.migrate(RED, {
+            environment, $, onClose: migrationClosed
+          })
+        }
+      } catch (error) {
+        migrationClosed()
+        RED.notify(translate('unavailable', 'The migration tool is unavailable. Reload the editor after restarting Node-RED.'), 'error')
+      }
+    }
+
+    function refresh () {
+      timer = undefined
+      if (disposed || dismissed || migrating) return
+      const hueApi = environment.KNXUltimateHueControllerMigration
+      const knxApi = environment.KNXUltimateUtilityMigration
+      if (!hueApi || !knxApi) return
+      const hue = hueApi.collectLegacyHueNodes(RED).length
+      const knx = knxApi.collectLegacyUtilityNodes(RED).length
+      if (!hue && !knx) {
+        closeNotice()
+        return
+      }
+      const counts = `${hue}:${knx}`
+      if (notification && counts === lastCounts) return
+      lastCounts = counts
+
+      const message = $('<div></div>')
+      $('<p></p>').append($('<strong></strong>').text(translate('title', 'Legacy KNX Ultimate nodes'))).appendTo(message)
+      $('<p></p>').text(translate('message', 'Legacy nodes found in your flows and subflows: HUE: {{hue}}; KNX utility: {{knx}}. These nodes still work, but are hidden from the palette. Migrate them to HUE Controller and KNX Utility. Each migration downloads a flow backup; review the result before deploying.', { hue, knx })).appendTo(message)
+      const buttons = []
+      if (hue) {
+        buttons.push({
+          text: translate('hue_button', 'Migrate HUE ({{count}})', { count: hue }),
+          click: () => openMigration('hue')
+        })
+      }
+      if (knx) {
+        buttons.push({
+          text: translate('knx_button', 'Migrate KNX ({{count}})', { count: knx }),
+          click: () => openMigration('knx')
+        })
+      }
+      buttons.push({
+        text: translate('later', 'Later'),
+        click () {
+          dismissed = true
+          closeNotice()
+        }
+      })
+      const settings = { type: 'warning', fixed: true, modal: false, buttons, silent: true }
+      if (notification) notification.update(message, settings)
+      else notification = RED.notify(message, settings)
+    }
+
+    function reset () {
+      dismissed = false
+      closeNotice()
+      if (closeMigration) closeMigration()
+      migrating = false
+      schedule()
+    }
+
+    const events = ['nodes:add', 'nodes:remove', 'nodes:change', 'workspace:dirty', 'deploy']
+    events.forEach(event => RED.events.on(event, schedule))
+    RED.events.on('workspace:clear', reset)
+    const dispose = () => {
+      disposed = true
+      if (timer !== undefined) environment.clearTimeout(timer)
+      events.forEach(event => RED.events.off(event, schedule))
+      RED.events.off('workspace:clear', reset)
+      if (closeMigration) closeMigration()
+      closeNotice()
+      installations.delete(RED)
+    }
+    const installation = { dispose }
+    installations.set(RED, installation)
+    schedule()
+    return installation
+  }
+
+  return { install }
+}))