chore(dev): release 2.7.2 (#30051)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/ci.yml

@@ -22,13 +22,13 @@ jobs:
             actions: read # for Nerivec/action-ci-bench
             pull-requests: write # for Nerivec/action-ci-bench
         steps:
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
               if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
               with:
                   # Required for `release: merge dev -> master and promote dev`
                   token: ${{ secrets.GH_TOKEN }}
 
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
               if: ((github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push') == false
 
             - uses: pnpm/action-setup@v4
@@ -220,7 +220,7 @@ jobs:
         runs-on: ${{ matrix.os }}
         continue-on-error: true
         steps:
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
 
             - uses: pnpm/action-setup@v4
 

.github/workflows/dependency-review.yaml

@@ -10,6 +10,6 @@ jobs:
         runs-on: ubuntu-latest
         steps:
             - name: 'Checkout repository'
-              uses: actions/checkout@v5
+              uses: actions/checkout@v6
             - name: 'Dependency review'
               uses: actions/dependency-review-action@v4

.github/workflows/issue_bot.yml

@@ -0,0 +1,38 @@
+name: Issue Bot
+
+on:
+  issues:
+    types: [opened, edited]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    if: |
+      contains(github.event.issue.labels.*.name, 'new device support') ||
+      contains(github.event.issue.labels.*.name, 'external converter') ||
+      startsWith(github.event.issue.title, '[New device support]') ||
+      startsWith(github.event.issue.title, '[External Converter]')
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          sparse-checkout: |
+            scripts
+          path: z2m
+
+      - uses: actions/checkout@v6
+        with:
+          repository: Koenkk/zigbee-herdsman-converters
+          ref: master
+          fetch-depth: 1
+          path: zhc
+
+      - name: Comment on new device support/external converter issue
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const {newDeviceSupport} = await import("${{ github.workspace }}/z2m/scripts/issueBot.mjs")
+            await newDeviceSupport(github, core, context, "${{ github.workspace }}/zhc")

.github/workflows/merge-master-to-dev.yml

@@ -9,7 +9,7 @@ jobs:
     merge-master-to-dev:
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
             - uses: devmasx/merge-branch@master
               with:
                   type: now

.github/workflows/new_device_external_converter_bot.yml

@@ -1,148 +0,0 @@
-name: New Device Support/External Converter Issue Bot
-
-on:
-  issues:
-    types: [opened, edited]
-
-permissions:
-  issues: write
-  contents: read
-
-jobs:
-  comment:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Comment on new device support/external converter issue
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const issue = context.payload.issue;
-            const newDeviceSupport = issue.title && issue.title.startsWith("[New device support]");
-            const externalConverter = issue.title && issue.title.startsWith("[External Converter]");
-
-            // Only proceed for new device support or external converter issues
-            if (!newDeviceSupport && !externalConverter) {
-              return;
-            }
-
-            // Hide previous bot comments
-            const comments = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: issue.number,
-            });
-
-            for (const comment of comments.data) {
-              if (comment.user.type === 'Bot' && comment.user.login === 'github-actions[bot]') {
-                await github.graphql(`
-                  mutation {
-                    minimizeComment(input: {subjectId: "${comment.node_id}", classifier: OUTDATED}) {
-                      clientMutationId
-                    }
-                  }
-                `);
-              }
-            }
-
-            // Checkout the repo and grep for the manufacturer name
-            const execSync = require('child_process').execSync;
-            execSync(`git clone https://github.com/Koenkk/zigbee-herdsman-converters.git zhc`, {stdio: 'ignore'});
-
-            // Check if Tuya manufacturer name is already supported.
-            const tuyaManufacturerNameRe = /['"](_T\w+_(\w+))['"]/g;
-            const tuyaManufacturerNames = Array.from(issue.body.matchAll(tuyaManufacturerNameRe), m => [m[1], m[2]]);
-            if (tuyaManufacturerNames.length > 0) {
-                for (const [fullName, partialName] of tuyaManufacturerNames) {
-                    const fullMatch = (() => { try { return execSync(`grep -r --include="*.ts" "${fullName}" zhc`, {encoding: 'utf8'}); } catch { return undefined; } })();
-                    if (fullMatch) {
-                      await github.rest.issues.createComment({
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        issue_number: issue.number,
-                        body: [
-                          `👋 Hi there! The Tuya device with manufacturer name \`${fullName}\` is already supported in the latest dev branch.`,
-                          "See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.",
-                          "",
-                          "In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.",
-                          "For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).",
-                          "If you need help with the process, feel free to ask here and we'll be happy to assist."
-                        ].join('\n')
-                      });
-                      await github.rest.issues.update({
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        issue_number: issue.number,
-                        state: "closed",
-                      });
-                      return;
-                    }
-
-                    const partialMatch = (() => { try { return execSync(`grep -r --include="*.ts" "${partialName}" zhc`, {encoding: 'utf8'}); } catch { return undefined; } })();
-                    if (partialMatch) {
-                      const candidates = Array.from(partialMatch.matchAll(tuyaManufacturerNameRe), m => m[1]);
-                      await github.rest.issues.createComment({
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        issue_number: issue.number,
-                        body: [
-                          `👋 Hi there! A similar Tuya device of which the manufacturer name also ends with \`_${partialName}\` is already supported.`,
-                          "This means the device can probably be easily be supported by re-using the existing converter.",
-                          "",
-                          "I found the following matches: " + candidates.map((c) => `\`${c}\``).join(', '),
-                          `Try to stop Z2M, change all occurrences of \`${fullName}\` in the \`data/database.db\` to one of the matches above and start Z2M.`,
-                          "Let us know if it works so we can support this device out-of-the-box!",
-                        ].join('\n')
-                      });
-                      return;
-                    }
-                }
-            } else {
-              // Check if zigbee model is already supported.
-              const zigbeeModelRe = /zigbeeModel: \[['"](.+)['"]\]/g;
-              const zigbeeModels = Array.from(issue.body.matchAll(zigbeeModelRe), m => m[1]);
-              if (zigbeeModels.length > 0) {
-                for (const zigbeeModel of zigbeeModels) {
-                  const fullMatch = (() => { try { return execSync(`grep -r --include="*.ts" '"${zigbeeModel}"' zhc`, {encoding: 'utf8'}); } catch { return undefined; } })();
-                  if (fullMatch) {
-                    await github.rest.issues.createComment({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      issue_number: issue.number,
-                      body: [
-                        `👋 Hi there! The device with zigbee model \`${zigbeeModel}\` is already supported in the latest dev branch.`,
-                        "See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.",
-                        "",
-                        "In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.",
-                        "For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).",
-                        "If you need help with the process, feel free to ask here and we'll be happy to assist."
-                      ].join('\n')
-                    });
-                    await github.rest.issues.update({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      issue_number: issue.number,
-                      state: "closed",
-                    });
-                    return;
-                  }
-                }
-              }
-            }
-
-            // Create a request to pull request comment
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: issue.number,
-              body: [
-              "🙏 Thank you for creating this issue and sharing your external converter!",
-              "",
-              "In case all features work, please submit a pull request on this repository so the device can be supported out-of-the-box with the next release.",
-              "For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).",
-              "",
-              "If **NOT** all features work, please follow the [How To Support new devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html)",
-              tuyaManufacturerNames.length > 0 ? "Since this is a Tuya also consider [How To Support new Tuya devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/02_support_new_tuya_devices.html)" : "",
-              "",
-              "If you need help with the process, feel free to ask here and we'll be happy to assist."
-              ].join('\n')
-            });

.github/workflows/release-please.yml

@@ -31,18 +31,18 @@ jobs:
                   token: ${{secrets.GH_TOKEN}}
 
             # Checkout repos
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m-master
                   ref: master
 
             - name: Restore cache commit-user-lookup.json
-              uses: actions/cache/restore@v4
+              uses: actions/cache/restore@v5
               with:
                   path: z2m/scripts/commit-user-lookup.json
                   key: commit-user-lookup-dummy
@@ -67,7 +67,7 @@ jobs:
               env:
                   GH_TOKEN: ${{secrets.GH_TOKEN}}
             - name: Save cache commit-user-lookup.json
-              uses: actions/cache/save@v4
+              uses: actions/cache/save@v5
               if: always()
               with:
                   path: z2m/scripts/commit-user-lookup.json

.github/workflows/update-dependency.yml

@@ -13,7 +13,7 @@ jobs:
 
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v5
+            - uses: actions/checkout@v6
               with:
                   ref: dev
                   token: ${{ secrets.GH_TOKEN }}
@@ -25,7 +25,7 @@ jobs:
             - run: |
                   pnpm install ${{ github.event.client_payload.package }}@${{ github.event.client_payload.version }} --save-exact
                   pnpm install --no-frozen-lockfile
-            - uses: peter-evans/create-pull-request@v7
+            - uses: peter-evans/create-pull-request@v8
               id: cpr
               with:
                   commit-message: 'fix(ignore): update ${{ github.event.client_payload.package }} to ${{ github.event.client_payload.version }}'

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "2.6.3"
+    ".": "2.7.2"
 }

CHANGELOG.md

@@ -1,5 +1,105 @@
 # Changelog
 
+## [2.7.2](https://github.com/Koenkk/zigbee2mqtt/compare/2.7.1...2.7.2) (2026-01-01)
+
+
+### Bug Fixes
+
+* Biome floating promises detection ([#30137](https://github.com/Koenkk/zigbee2mqtt/issues/30137)) ([0025ef8](https://github.com/Koenkk/zigbee2mqtt/commit/0025ef87c502970b94e1b720516d42631e21323c))
+* Don't fail to start when removing old log directory fails ([#30216](https://github.com/Koenkk/zigbee2mqtt/issues/30216)) ([b39b8d4](https://github.com/Koenkk/zigbee2mqtt/commit/b39b8d478e99c5a5ee5a3a610547168b3724ca91))
+* **ignore:** bump @types/node from 24.10.2 to 24.10.4 in the minor-patch group ([#30390](https://github.com/Koenkk/zigbee2mqtt/issues/30390)) ([93c9704](https://github.com/Koenkk/zigbee2mqtt/commit/93c9704fcd5552e234dd03a7ae1cddc11403622b))
+* **ignore:** bump the minor-patch group across 1 directory with 4 updates ([#30117](https://github.com/Koenkk/zigbee2mqtt/issues/30117)) ([ad3c090](https://github.com/Koenkk/zigbee2mqtt/commit/ad3c09036b804eb108238036f22776d83ea371b2))
+* **ignore:** bump the minor-patch group with 2 updates ([#30207](https://github.com/Koenkk/zigbee2mqtt/issues/30207)) ([1d15c21](https://github.com/Koenkk/zigbee2mqtt/commit/1d15c2142fefb9c7ce96c947e5ac7ddc6101439f))
+* **ignore:** bump the minor-patch group with 2 updates ([#30309](https://github.com/Koenkk/zigbee2mqtt/issues/30309)) ([b10fa93](https://github.com/Koenkk/zigbee2mqtt/commit/b10fa93700febe84634040dbdeb4857258cd2882))
+* **ignore:** bump zigbee2mqtt-windfront from 2.6.1 to 2.6.2 in the minor-patch group ([#30412](https://github.com/Koenkk/zigbee2mqtt/issues/30412)) ([4d6269e](https://github.com/Koenkk/zigbee2mqtt/commit/4d6269e7e89af52df0b2576925abade2f6b60e09))
+* **ignore:** update zigbee-herdsman to 7.0.5 ([#30116](https://github.com/Koenkk/zigbee2mqtt/issues/30116)) ([4574ffc](https://github.com/Koenkk/zigbee2mqtt/commit/4574ffc71a799846c6a04121c3b5908f968ff0be))
+* **ignore:** update zigbee-herdsman to 7.0.6 ([#30142](https://github.com/Koenkk/zigbee2mqtt/issues/30142)) ([ecb0af4](https://github.com/Koenkk/zigbee2mqtt/commit/ecb0af40575ebaadf887685c50cd1a9968cc1c68))
+* **ignore:** update zigbee-herdsman to 8.0.0 and zigbee-herdsman-converters to 25.87.0 ([#30186](https://github.com/Koenkk/zigbee2mqtt/issues/30186)) ([7f5f6a5](https://github.com/Koenkk/zigbee2mqtt/commit/7f5f6a5849d940a6e5288865edf7999c41af12e2))
+* **ignore:** update zigbee-herdsman to 8.0.1 ([#30240](https://github.com/Koenkk/zigbee2mqtt/issues/30240)) ([1688a3b](https://github.com/Koenkk/zigbee2mqtt/commit/1688a3b5323a8774ad2c36775fdb99f48057f72a))
+* **ignore:** update zigbee-herdsman-converters to 25.84.0 ([#30081](https://github.com/Koenkk/zigbee2mqtt/issues/30081)) ([c18d132](https://github.com/Koenkk/zigbee2mqtt/commit/c18d1329c801ce48cf5277c00682ad2f9098f383))
+* **ignore:** update zigbee-herdsman-converters to 25.85.0 ([#30120](https://github.com/Koenkk/zigbee2mqtt/issues/30120)) ([5db6ae0](https://github.com/Koenkk/zigbee2mqtt/commit/5db6ae0a197a180abc5e497aebe6e59fcb9b6b3c))
+* **ignore:** update zigbee-herdsman-converters to 25.86.0 ([#30143](https://github.com/Koenkk/zigbee2mqtt/issues/30143)) ([3460f15](https://github.com/Koenkk/zigbee2mqtt/commit/3460f157df84d10f8de87a37d6b0b0b243de6874))
+* **ignore:** update zigbee-herdsman-converters to 25.88.0 ([#30196](https://github.com/Koenkk/zigbee2mqtt/issues/30196)) ([3818c50](https://github.com/Koenkk/zigbee2mqtt/commit/3818c50b8ae516e56ad07e8fce3c451f35e1b678))
+* **ignore:** update zigbee-herdsman-converters to 25.89.0 ([#30215](https://github.com/Koenkk/zigbee2mqtt/issues/30215)) ([01304cf](https://github.com/Koenkk/zigbee2mqtt/commit/01304cfc6604b86acf181dc3f07688f56ecbe8a1))
+* **ignore:** update zigbee-herdsman-converters to 25.90.0 ([#30267](https://github.com/Koenkk/zigbee2mqtt/issues/30267)) ([ab08947](https://github.com/Koenkk/zigbee2mqtt/commit/ab0894715a002bd5c14d8af45a67e5e546889590))
+* **ignore:** update zigbee-herdsman-converters to 25.91.0 ([#30279](https://github.com/Koenkk/zigbee2mqtt/issues/30279)) ([4c02e3d](https://github.com/Koenkk/zigbee2mqtt/commit/4c02e3da8f66cafbdcde89303bb1aea6eaf73bcd))
+* **ignore:** update zigbee-herdsman-converters to 25.92.0 ([#30300](https://github.com/Koenkk/zigbee2mqtt/issues/30300)) ([c28a024](https://github.com/Koenkk/zigbee2mqtt/commit/c28a024664989fe8a044babe3cdf43403b0ee2b5))
+* **ignore:** update zigbee-herdsman-converters to 25.93.0 ([#30331](https://github.com/Koenkk/zigbee2mqtt/issues/30331)) ([c61f67f](https://github.com/Koenkk/zigbee2mqtt/commit/c61f67f061d2766e99c5cb9c99c02b172832271c))
+* **ignore:** update zigbee-herdsman-converters to 25.94.0 ([#30355](https://github.com/Koenkk/zigbee2mqtt/issues/30355)) ([7cb5c58](https://github.com/Koenkk/zigbee2mqtt/commit/7cb5c58dc028f86c59935b64a738444950ef8e12))
+* **ignore:** update zigbee-herdsman-converters to 25.95.0 ([#30371](https://github.com/Koenkk/zigbee2mqtt/issues/30371)) ([4c48e9c](https://github.com/Koenkk/zigbee2mqtt/commit/4c48e9cfbcedb9cd6aedee9f694db2993038eaee))
+* **ignore:** update zigbee-herdsman-converters to 25.96.0 ([#30383](https://github.com/Koenkk/zigbee2mqtt/issues/30383)) ([2721b0e](https://github.com/Koenkk/zigbee2mqtt/commit/2721b0ea78f4e86e6fe3b5f4831c5787a28585a8))
+* **ignore:** update zigbee-herdsman-converters to 25.97.0 ([#30396](https://github.com/Koenkk/zigbee2mqtt/issues/30396)) ([3727f07](https://github.com/Koenkk/zigbee2mqtt/commit/3727f078ecde73a5c444c42909f36b4a0f35d8c3))
+* **ignore:** update zigbee-herdsman-converters to 25.98.0 ([#30417](https://github.com/Koenkk/zigbee2mqtt/issues/30417)) ([0eba0c9](https://github.com/Koenkk/zigbee2mqtt/commit/0eba0c953d7543b2850a9b9672ffbc3d87840fb3))
+* log dir tz format not working on some systems ([#30324](https://github.com/Koenkk/zigbee2mqtt/issues/30324)) ([58d98c7](https://github.com/Koenkk/zigbee2mqtt/commit/58d98c7263dbe687eb677199eb760799ecff8e8f))
+* Proper timezone in logs dir ([#30297](https://github.com/Koenkk/zigbee2mqtt/issues/30297)) ([8549b37](https://github.com/Koenkk/zigbee2mqtt/commit/8549b372283da8b55804c4049c7341294ced1538))
+* Remove extra `>` in onboarding([#30065](https://github.com/Koenkk/zigbee2mqtt/issues/30065)) ([ed1e7b3](https://github.com/Koenkk/zigbee2mqtt/commit/ed1e7b333f481a4b3a37b021f2058331b86ebd84))
+
+## [2.7.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.7.0...2.7.1) (2025-12-06)
+
+
+### Bug Fixes
+
+* Home Assistant: Accept multiple access levels for `current_humidity` source property ([#29936](https://github.com/Koenkk/zigbee2mqtt/issues/29936)) ([fa99c6d](https://github.com/Koenkk/zigbee2mqtt/commit/fa99c6dcca97d2c8c90136249293dea3d42e0998))
+* Home Assistant: Translate boolean to state topic for `current_humidity_topic` ([#30014](https://github.com/Koenkk/zigbee2mqtt/issues/30014)) ([9ca85df](https://github.com/Koenkk/zigbee2mqtt/commit/9ca85dfac8b0f0421ad0622dfdbe36c8766d22b4))
+* **ignore:** bump finalhandler from 2.1.0 to 2.1.1 in the minor-patch group ([#29920](https://github.com/Koenkk/zigbee2mqtt/issues/29920)) ([ce27ff3](https://github.com/Koenkk/zigbee2mqtt/commit/ce27ff3cbfac204579b38d034e71733e4e4bb18f))
+* **ignore:** update zigbee-herdsman to 7.0.2 ([#29956](https://github.com/Koenkk/zigbee2mqtt/issues/29956)) ([403bd4a](https://github.com/Koenkk/zigbee2mqtt/commit/403bd4a72541bf7342de246b033c5090b186df32))
+* **ignore:** update zigbee-herdsman to 7.0.3 ([#30008](https://github.com/Koenkk/zigbee2mqtt/issues/30008)) ([bae9bb8](https://github.com/Koenkk/zigbee2mqtt/commit/bae9bb8812c81e46d4068b4284e0f9957821f88a))
+* **ignore:** update zigbee-herdsman to 7.0.4 ([#30041](https://github.com/Koenkk/zigbee2mqtt/issues/30041)) ([334fa2a](https://github.com/Koenkk/zigbee2mqtt/commit/334fa2a60d04c66749978b8b8f4b9b5af6c7c7eb))
+* **ignore:** update zigbee-herdsman-converters to 25.81.0 ([#29959](https://github.com/Koenkk/zigbee2mqtt/issues/29959)) ([fd4282b](https://github.com/Koenkk/zigbee2mqtt/commit/fd4282b98d9630f9a98e82f627c12c5920d810b4))
+* **ignore:** update zigbee-herdsman-converters to 25.82.0 ([#29990](https://github.com/Koenkk/zigbee2mqtt/issues/29990)) ([740edd8](https://github.com/Koenkk/zigbee2mqtt/commit/740edd8b58b7d72b7a2a5247f7f6ac8ee99ff0fa))
+* **ignore:** update zigbee-herdsman-converters to 25.83.0 ([#30011](https://github.com/Koenkk/zigbee2mqtt/issues/30011)) ([a7f1345](https://github.com/Koenkk/zigbee2mqtt/commit/a7f1345a9164f6c83cb81688c33511b14646fab8))
+* **ignore:** update zigbee-herdsman-converters to 25.83.1 ([#30050](https://github.com/Koenkk/zigbee2mqtt/issues/30050)) ([9b60353](https://github.com/Koenkk/zigbee2mqtt/commit/9b6035387be6f285fab455f7845baa75f3f722be))
+
+## [2.7.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.3...2.7.0) (2025-12-01)
+
+
+### Features
+
+* Add `action` bridge/request API ([#29730](https://github.com/Koenkk/zigbee2mqtt/issues/29730)) ([a61646d](https://github.com/Koenkk/zigbee2mqtt/commit/a61646d584c0a0de46abb3545cd964f65d84312d))
+* Add new bind/reporting/map features ([#29750](https://github.com/Koenkk/zigbee2mqtt/issues/29750)) ([f26ade4](https://github.com/Koenkk/zigbee2mqtt/commit/f26ade4f938350d10ed22a32a2e30365f7514a72))
+
+
+### Bug Fixes
+
+* Add port 8080 `EXPOSE` to container ([#29754](https://github.com/Koenkk/zigbee2mqtt/issues/29754)) ([4c21b66](https://github.com/Koenkk/zigbee2mqtt/commit/4c21b660794ee3b85c9a9a6d01b0df5ec8bce639))
+* Home Assistant: expose `current_humidity` for `climate` devices exposing `humidity` ([#29842](https://github.com/Koenkk/zigbee2mqtt/issues/29842)) ([631c4f6](https://github.com/Koenkk/zigbee2mqtt/commit/631c4f6a5729888d65a1125e0cca8f9ba2ff0e59))
+* **ignore:** bump @biomejs/biome from 2.3.3 to 2.3.4 in the minor-patch group ([#29571](https://github.com/Koenkk/zigbee2mqtt/issues/29571)) ([517b286](https://github.com/Koenkk/zigbee2mqtt/commit/517b2865835a7c21b4c5ce68018fd30ae45d1a3f))
+* **ignore:** bump debounce from 2.2.0 to 3.0.0 ([#29444](https://github.com/Koenkk/zigbee2mqtt/issues/29444)) ([8099322](https://github.com/Koenkk/zigbee2mqtt/commit/8099322cc2e93e5c1faf355d41485f2c673e0cea))
+* **ignore:** bump the minor-patch group with 2 updates ([#29443](https://github.com/Koenkk/zigbee2mqtt/issues/29443)) ([619b939](https://github.com/Koenkk/zigbee2mqtt/commit/619b939b148394bd6a083c17cc5cf254c8eb3aea))
+* **ignore:** bump the minor-patch group with 2 updates ([#29859](https://github.com/Koenkk/zigbee2mqtt/issues/29859)) ([c02ed09](https://github.com/Koenkk/zigbee2mqtt/commit/c02ed092116c7454220c0611bff5d078e12a8ecc))
+* **ignore:** bump the minor-patch group with 3 updates ([#29804](https://github.com/Koenkk/zigbee2mqtt/issues/29804)) ([e2232e9](https://github.com/Koenkk/zigbee2mqtt/commit/e2232e9e9173ea9ec55152ac33bc0ee0141471bb))
+* **ignore:** bump zigbee2mqtt-windfront from 2.4.0 to 2.4.1 in the minor-patch group ([#29905](https://github.com/Koenkk/zigbee2mqtt/issues/29905)) ([4a020fd](https://github.com/Koenkk/zigbee2mqtt/commit/4a020fd8de2dab2973b859c34b934416a15e82a5))
+* **ignore:** bump zigbee2mqtt-windfront to 2.4.2 ([#29919](https://github.com/Koenkk/zigbee2mqtt/issues/29919)) ([3dce854](https://github.com/Koenkk/zigbee2mqtt/commit/3dce8548ceee111f49a5b3460fdb2cbb4f47da62))
+* **ignore:** prop name convention on new API endpoints ([#29820](https://github.com/Koenkk/zigbee2mqtt/issues/29820)) ([ad06968](https://github.com/Koenkk/zigbee2mqtt/commit/ad0696856a9a63fc74b9c2115f08d7fd97850545))
+* **ignore:** update zigbee-herdsman to 6.3.3 ([#29500](https://github.com/Koenkk/zigbee2mqtt/issues/29500)) ([39c5bc8](https://github.com/Koenkk/zigbee2mqtt/commit/39c5bc8c0446a7ccdffe6f82ae9e7f31f60f20ba))
+* **ignore:** update zigbee-herdsman to 6.4.0 ([#29522](https://github.com/Koenkk/zigbee2mqtt/issues/29522)) ([e788c52](https://github.com/Koenkk/zigbee2mqtt/commit/e788c520a9268498daf0f88d7bedb289546d226e))
+* **ignore:** update zigbee-herdsman to 6.4.1 ([#29595](https://github.com/Koenkk/zigbee2mqtt/issues/29595)) ([61c6ec6](https://github.com/Koenkk/zigbee2mqtt/commit/61c6ec611174529e4c041a56146ba8405cfe9ed8))
+* **ignore:** update zigbee-herdsman to 6.4.2 ([#29683](https://github.com/Koenkk/zigbee2mqtt/issues/29683)) ([53b7eaa](https://github.com/Koenkk/zigbee2mqtt/commit/53b7eaabf0647c8d1edb0de24b89776991af576c))
+* **ignore:** update zigbee-herdsman to 7.0.0 ([3e2aefb](https://github.com/Koenkk/zigbee2mqtt/commit/3e2aefbcf84f43d45c1d6ca33397c8bb76648822))
+* **ignore:** update zigbee-herdsman to 7.0.1 ([#29855](https://github.com/Koenkk/zigbee2mqtt/issues/29855)) ([802271e](https://github.com/Koenkk/zigbee2mqtt/commit/802271ed37d404944d315f83f3b623ba9e424bb9))
+* **ignore:** update zigbee-herdsman-converters to 25.60.0 ([#29426](https://github.com/Koenkk/zigbee2mqtt/issues/29426)) ([eeed56e](https://github.com/Koenkk/zigbee2mqtt/commit/eeed56ef2c01dfe67e7a0cd7cafd35ef1876f5b4))
+* **ignore:** update zigbee-herdsman-converters to 25.62.0 ([#29449](https://github.com/Koenkk/zigbee2mqtt/issues/29449)) ([ea1c5a8](https://github.com/Koenkk/zigbee2mqtt/commit/ea1c5a8f4e8537a2f8c59988bb712f62a0adffd7))
+* **ignore:** update zigbee-herdsman-converters to 25.63.0 ([#29482](https://github.com/Koenkk/zigbee2mqtt/issues/29482)) ([5a6a9cf](https://github.com/Koenkk/zigbee2mqtt/commit/5a6a9cf4d2de803a10cd38bc19f3ec256eff5929))
+* **ignore:** update zigbee-herdsman-converters to 25.64.0 ([#29499](https://github.com/Koenkk/zigbee2mqtt/issues/29499)) ([5c4e43f](https://github.com/Koenkk/zigbee2mqtt/commit/5c4e43fd109321ddcfad3a67b60423f0197c51a6))
+* **ignore:** update zigbee-herdsman-converters to 25.65.0 ([#29523](https://github.com/Koenkk/zigbee2mqtt/issues/29523)) ([8822aed](https://github.com/Koenkk/zigbee2mqtt/commit/8822aedb5e254f5be5f6cda0cfe18fc6f69c84d6))
+* **ignore:** update zigbee-herdsman-converters to 25.66.0 ([#29558](https://github.com/Koenkk/zigbee2mqtt/issues/29558)) ([940fff2](https://github.com/Koenkk/zigbee2mqtt/commit/940fff244c39da04d0de5d7e4076359dc6245aed))
+* **ignore:** update zigbee-herdsman-converters to 25.67.0 ([#29572](https://github.com/Koenkk/zigbee2mqtt/issues/29572)) ([4794b3c](https://github.com/Koenkk/zigbee2mqtt/commit/4794b3c81f9e38660f8549995b7f3ef8b4cd4318))
+* **ignore:** update zigbee-herdsman-converters to 25.68.0 ([#29606](https://github.com/Koenkk/zigbee2mqtt/issues/29606)) ([564e9ab](https://github.com/Koenkk/zigbee2mqtt/commit/564e9ab9eb49c3517913917af8b23d4758c6b6c7))
+* **ignore:** update zigbee-herdsman-converters to 25.69.0 ([#29659](https://github.com/Koenkk/zigbee2mqtt/issues/29659)) ([16d0e56](https://github.com/Koenkk/zigbee2mqtt/commit/16d0e5696859e79be4701154dd35f7780e47acae))
+* **ignore:** update zigbee-herdsman-converters to 25.70.0 ([#29684](https://github.com/Koenkk/zigbee2mqtt/issues/29684)) ([73225e2](https://github.com/Koenkk/zigbee2mqtt/commit/73225e2436bb56ff4ed47d787e8a1793fd10998d))
+* **ignore:** update zigbee-herdsman-converters to 25.71.0 ([#29716](https://github.com/Koenkk/zigbee2mqtt/issues/29716)) ([d6bf517](https://github.com/Koenkk/zigbee2mqtt/commit/d6bf5174be905128432e90d54b3c43c2a68e75ac))
+* **ignore:** update zigbee-herdsman-converters to 25.72.0 ([#29735](https://github.com/Koenkk/zigbee2mqtt/issues/29735)) ([7b7b988](https://github.com/Koenkk/zigbee2mqtt/commit/7b7b9889607a6e48001ae3cda5950386c24f5fd6))
+* **ignore:** update zigbee-herdsman-converters to 25.73.0 ([#29752](https://github.com/Koenkk/zigbee2mqtt/issues/29752)) ([be774a4](https://github.com/Koenkk/zigbee2mqtt/commit/be774a4d0d70122ced0f6ca79f49c060a7d2d2cb))
+* **ignore:** update zigbee-herdsman-converters to 25.74.0 ([#29770](https://github.com/Koenkk/zigbee2mqtt/issues/29770)) ([ba77ce7](https://github.com/Koenkk/zigbee2mqtt/commit/ba77ce7c8df0b29845a090c9defb4ce8aaf0f924))
+* **ignore:** update zigbee-herdsman-converters to 25.75.0 ([#29811](https://github.com/Koenkk/zigbee2mqtt/issues/29811)) ([854df49](https://github.com/Koenkk/zigbee2mqtt/commit/854df498bd3c8999393b683052dfba6b906ba669))
+* **ignore:** update zigbee-herdsman-converters to 25.76.0 ([#29823](https://github.com/Koenkk/zigbee2mqtt/issues/29823)) ([72d862f](https://github.com/Koenkk/zigbee2mqtt/commit/72d862f4a080bfcd91bf99d4c13387e719dfdb8e))
+* **ignore:** update zigbee-herdsman-converters to 25.77.0 ([#29838](https://github.com/Koenkk/zigbee2mqtt/issues/29838)) ([35d8a5d](https://github.com/Koenkk/zigbee2mqtt/commit/35d8a5da7f1d817727f8b029da1992901f5b4115))
+* **ignore:** update zigbee-herdsman-converters to 25.78.0 ([#29856](https://github.com/Koenkk/zigbee2mqtt/issues/29856)) ([49b4876](https://github.com/Koenkk/zigbee2mqtt/commit/49b4876768c5d15fcff1ad0c9c2d02dda96543d0))
+* **ignore:** update zigbee-herdsman-converters to 25.79.0 ([#29903](https://github.com/Koenkk/zigbee2mqtt/issues/29903)) ([d411fc5](https://github.com/Koenkk/zigbee2mqtt/commit/d411fc5c693300863a19c2798f0a7a05cfc7e55f))
+* **ignore:** update zigbee-herdsman-converters to 25.80.0 ([#29924](https://github.com/Koenkk/zigbee2mqtt/issues/29924)) ([445890a](https://github.com/Koenkk/zigbee2mqtt/commit/445890a0710ba7f6b101b651bf379f10390f9e7e))
+* **ignore:** update zigbee2mqtt-windfront to 2.3.1 ([#29788](https://github.com/Koenkk/zigbee2mqtt/issues/29788)) ([17520f7](https://github.com/Koenkk/zigbee2mqtt/commit/17520f7cfb69b577ebd986b86da80931a15a39db))
+* Reporting payload detection fixes ([#29854](https://github.com/Koenkk/zigbee2mqtt/issues/29854)) ([42fc6e0](https://github.com/Koenkk/zigbee2mqtt/commit/42fc6e03a7a3092502e3c3d1defbcb3ed6438230))
+
 ## [2.6.3](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.2...2.6.3) (2025-11-01)
 
 

README.md

@@ -106,7 +106,7 @@ Zigbee2MQTT is made up of three modules, each developed in its own Github projec
 
 ### Developing
 
-Zigbee2MQTT uses TypeScript. Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build-watch` in another terminal session, this will recompile as you change files.
+Zigbee2MQTT uses TypeScript. Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build:watch` in another terminal session, this will recompile as you change files.
 
 Before running any of the commands, you'll first need to run `pnpm install --include=dev`.
 Before submitting changes run `pnpm run check:w` then `pnpm run test:coverage`.

biome.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "https://biomejs.dev/schemas/2.2.5/schema.json",
+    "$schema": "https://biomejs.dev/schemas/2.3.10/schema.json",
     "vcs": {
         "enabled": true,
         "clientKind": "git",
@@ -12,7 +12,7 @@
         "bracketSpacing": false
     },
     "files": {
-        "includes": ["**", "!package.json"]
+        "includes": ["**", "!package.json", "!!**/dist", "!!**/coverage"]
     },
     "linter": {
         "includes": ["**"],
@@ -72,6 +72,11 @@
             "suspicious": {
                 "noConstEnum": "off",
                 "useAwait": "error"
+            },
+            "nursery": {
+                "useExhaustiveSwitchCases": "error",
+                "noFloatingPromises": "error",
+                "noMisusedPromises": "error"
             }
         }
     },

docker/Dockerfile

@@ -1,6 +1,6 @@
 ARG TARGETPLATFORM
 
-FROM alpine:3.22 AS base
+FROM alpine:3.23 AS base
 
 ENV NODE_ENV=production
 WORKDIR /app
@@ -52,5 +52,8 @@ RUN mkdir /app/data
 ARG COMMIT
 RUN echo "$COMMIT" > dist/.hash
 
+# Expose the default frontend port (see lib/util/settings.ts defaults.frontend.port)
+EXPOSE 8080
+
 ENTRYPOINT ["docker-entrypoint.sh"]
 CMD [ "/sbin/tini", "--", "node", "index.js"]

index.js

@@ -174,11 +174,11 @@ async function handleQuit() {
 
 if (require.main === module || require.main.filename.endsWith(`${path.sep}cli.js`)) {
     if (process.argv.length === 3 && process.argv[2] === "writehash") {
-        writeHash();
+        void writeHash();
     } else {
         process.on("SIGINT", handleQuit);
         process.on("SIGTERM", handleQuit);
-        start();
+        void start();
     }
 } else {
     process.on("SIGINT", handleQuit);

lib/controller.ts

@@ -99,7 +99,11 @@ export class Controller {
         // Start zigbee
         try {
             await this.zigbee.start();
-            this.eventBus.onAdapterDisconnected(this, this.onZigbeeAdapterDisconnected);
+
+            this.eventBus.onAdapterDisconnected(this, async () => {
+                logger.error("Adapter disconnected, stopping");
+                await this.stop(false, 2);
+            });
         } catch (error) {
             logger.error("Failed to start zigbee-herdsman");
             logger.error(
@@ -157,7 +161,9 @@ export class Controller {
             }
         }
 
-        this.eventBus.onLastSeenChanged(this, (data) => utils.publishLastSeen(data, settings.get(), false, this.publishEntityState));
+        this.eventBus.onLastSeenChanged(this, (data) => {
+            utils.publishLastSeen(data, settings.get(), false, this.publishEntityState).catch(() => {});
+        });
 
         logger.info("Zigbee2MQTT started!");
 
@@ -317,11 +323,6 @@ export class Controller {
         return await this.exitCallback(code, restart);
     }
 
-    @bind async onZigbeeAdapterDisconnected(): Promise<void> {
-        logger.error("Adapter disconnected, stopping");
-        await this.stop(false, 2);
-    }
-
     @bind async publishEntityState(entity: Group | Device, payload: KeyValue, stateChangeReason?: StateChangeReason): Promise<void> {
         let message: Zigbee2MQTTAPI["{friendlyName}"] = {...payload};
 

lib/eventBus.ts

@@ -61,7 +61,7 @@ export default class EventBus {
     public emitAdapterDisconnected(): void {
         this.emitter.emit("adapterDisconnected");
     }
-    public onAdapterDisconnected(key: ListenerKey, callback: () => void): void {
+    public onAdapterDisconnected(key: ListenerKey, callback: () => Promise<void>): void {
         this.on("adapterDisconnected", callback, key);
     }
 

lib/extension/bind.ts

@@ -184,7 +184,7 @@ interface ParsedMQTTMessage {
 }
 
 export default class Bind extends Extension {
-    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind)`);
+    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind|binds/clear)`);
     private pollDebouncers: {[s: string]: () => void} = {};
 
     // biome-ignore lint/suspicious/useAwait: API
@@ -276,6 +276,36 @@ export default class Bind extends Extension {
     }
 
     @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
+        if (data.topic.endsWith("binds/clear")) {
+            const message = JSON.parse(data.message) as Zigbee2MQTTAPI["bridge/request/device/binds/clear"];
+
+            if (typeof message !== "object" || typeof message.target !== "string") {
+                await this.publishResponse("binds/clear", message, {}, "Invalid payload");
+                return;
+            }
+
+            const target = this.zigbee.resolveEntity(message.target);
+
+            if (!(target instanceof Device)) {
+                await this.publishResponse("binds/clear", message, {}, "Invalid target");
+                return;
+            }
+
+            // this list is raw (not resolved) to allow clearing any specific target (not only currently known)
+            const eui64List = message.ieee_list ?? ["0xffffffffffffffff"];
+
+            await target.zh.clearAllBindings(eui64List);
+
+            const responseData: Zigbee2MQTTAPI["bridge/response/device/binds/clear"] = {
+                target: message.target,
+                ieee_list: eui64List,
+            };
+
+            await this.publishResponse("binds/clear", message, responseData);
+            this.eventBus.emitDevicesChanged();
+            return;
+        }
+
         const [raw, parsed, error] = this.parseMQTTMessage(data);
 
         if (!raw || !parsed) {
@@ -389,7 +419,7 @@ export default class Bind extends Extension {
     }
 
     private async publishResponse<T extends Zigbee2MQTTResponseEndpoints>(
-        type: ParsedMQTTMessage["type"],
+        type: ParsedMQTTMessage["type"] | "binds/clear",
         request: KeyValue,
         data: Zigbee2MQTTAPI[T],
         error?: string,
@@ -488,9 +518,7 @@ export default class Bind extends Extension {
 
         for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
             for (const endpoint of device.zh.endpoints) {
-                for (const bind of endpoint.binds) {
-                    allBinds.push(bind);
-                }
+                allBinds.push(...endpoint.binds);
             }
         }
 

lib/extension/bridge.ts

@@ -31,7 +31,10 @@ export default class Bridge extends Extension {
     private logTransport!: winston.transport;
     private requestLookup: {[key: string]: (message: KeyValue | string) => Promise<Zigbee2MQTTResponse<Zigbee2MQTTResponseEndpoints>>} = {
         "device/options": this.deviceOptions,
-        "device/configure_reporting": this.deviceConfigureReporting,
+        /** @deprecated 3.0 */
+        "device/configure_reporting": this.deviceReportingConfigure,
+        "device/reporting/configure": this.deviceReportingConfigure,
+        "device/reporting/read": this.deviceReportingRead,
         "device/remove": this.deviceRemove,
         "device/interview": this.deviceInterview,
         "device/generate_external_definition": this.deviceGenerateExternalDefinition,
@@ -50,6 +53,7 @@ export default class Bridge extends Extension {
         health_check: this.healthCheck,
         coordinator_check: this.coordinatorCheck,
         options: this.bridgeOptions,
+        action: this.action,
     };
 
     override async start(): Promise<void> {
@@ -466,16 +470,16 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {from: oldOptions, to: newOptions, id: ID, restart_required: this.restartRequired});
     }
 
-    @bind async deviceConfigureReporting(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/configure_reporting">> {
+    @bind async deviceReportingConfigure(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/reporting/configure">> {
         if (
             typeof message !== "object" ||
             message.id === undefined ||
             message.endpoint === undefined ||
             message.cluster === undefined ||
-            message.maximum_report_interval === undefined ||
-            message.minimum_report_interval === undefined ||
-            message.reportable_change === undefined ||
-            message.attribute === undefined
+            message.attribute === undefined ||
+            typeof message.maximum_report_interval !== "number" ||
+            typeof message.minimum_report_interval !== "number" ||
+            (message.reportable_change !== undefined && typeof message.reportable_change !== "number")
         ) {
             throw new Error("Invalid payload");
         }
@@ -518,6 +522,46 @@ export default class Bridge extends Extension {
         });
     }
 
+    @bind async deviceReportingRead(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/reporting/read">> {
+        if (
+            typeof message !== "object" ||
+            message.id === undefined ||
+            message.endpoint === undefined ||
+            message.cluster === undefined ||
+            message.configs === undefined
+        ) {
+            throw new Error("Invalid payload");
+        }
+
+        const device = this.getEntity("device", message.id);
+        const endpoint = device.endpoint(message.endpoint);
+
+        if (!endpoint) {
+            throw new Error(`Device '${device.ID}' does not have endpoint '${message.endpoint}'`);
+        }
+
+        const response = await endpoint.readReportingConfig(
+            message.cluster,
+            message.configs,
+            message.manufacturer_code ? {manufacturerCode: message.manufacturer_code} : {},
+        );
+
+        await this.publishDevices();
+
+        const responseData: Zigbee2MQTTAPI["bridge/response/device/reporting/read"] = {
+            id: message.id,
+            endpoint: message.endpoint,
+            cluster: message.cluster,
+            configs: response,
+        };
+
+        if (message.manufacturer_code) {
+            responseData.manufacturer_code = message.manufacturer_code;
+        }
+
+        return utils.getResponse(message, responseData);
+    }
+
     @bind async deviceInterview(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/interview">> {
         if (typeof message !== "object" || message.id === undefined) {
             throw new Error("Invalid payload");
@@ -554,6 +598,22 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {id: message.id, source});
     }
 
+    @bind async action(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/action">> {
+        if (typeof message !== "object" || !message.action) {
+            throw new Error("Invalid payload");
+        }
+
+        const action = zhc.ACTIONS[message.action];
+
+        if (action === undefined) {
+            throw new Error("Invalid action");
+        }
+
+        const response = await action(this.zigbee.zhController, message.params ?? {});
+
+        return utils.getResponse(message, response);
+    }
+
     async renameEntity<T extends "device" | "group">(
         entityType: T,
         message: string | KeyValue,
@@ -812,6 +872,7 @@ export default class Bridge extends Extension {
         const data: Zigbee2MQTTAPI["bridge/definitions"] = {
             clusters: Zcl.Clusters,
             custom_clusters: {},
+            actions: Object.keys(zhc.ACTIONS),
         };
 
         for (const device of this.zigbee.devicesIterator((d) => !utils.objectIsEmpty(d.customClusters))) {

lib/extension/homeassistant.ts

@@ -752,6 +752,12 @@ export class HomeAssistant extends Extension {
                     discoveryEntries.push(discoveryEntry);
                 }
 
+                const currentHumidity = allExposes?.filter(isNumericExpose).find((e) => e.name === "humidity" && e.access & ACCESS_STATE);
+                if (currentHumidity) {
+                    discoveryEntry.discovery_payload.current_humidity_template = `{{ value_json.${currentHumidity.property} }}`;
+                    discoveryEntry.discovery_payload.current_humidity_topic = true;
+                }
+
                 discoveryEntries.push(discoveryEntry);
                 break;
             }
@@ -1675,6 +1681,10 @@ export class HomeAssistant extends Extension {
                 payload.action_topic = stateTopic;
             }
 
+            if (payload.current_humidity_topic) {
+                payload.current_humidity_topic = stateTopic;
+            }
+
             // Override configuration with user settings.
             if (entity.options.homeassistant != null) {
                 const add = (obj: KeyValue, ignoreName: boolean): void => {

lib/extension/networkMap.ts

@@ -1,7 +1,8 @@
 import bind from "bind-decorator";
 import stringify from "json-stable-stringify-without-jsonify";
+import type {Eui64} from "zigbee-herdsman/dist/zspec/tstypes";
+import type {LQITableEntry, RoutingTableEntry} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
 import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";
-
 import logger from "../util/logger";
 import * as settings from "../util/settings";
 import utils from "../util/utils";
@@ -185,8 +186,8 @@ export default class NetworkMap extends Extension {
 
     async networkScan(includeRoutes: boolean): Promise<Zigbee2MQTTNetworkMap> {
         logger.info(`Starting network scan (includeRoutes '${includeRoutes}')`);
-        const lqis = new Map<Device, zh.LQI>();
-        const routingTables = new Map<Device, zh.RoutingTable>();
+        const lqis = new Map<Device, LQITableEntry[]>();
+        const routingTables = new Map<Device, RoutingTableEntry[]>();
         const failed = new Map<Device, string[]>();
         const requestWithRetry = async <T>(request: () => Promise<T>): Promise<T> => {
             try {
@@ -210,7 +211,7 @@ export default class NetworkMap extends Extension {
             await utils.sleep(1); // sleep 1 second between each scan to reduce stress on network.
 
             try {
-                const result = await requestWithRetry<zh.LQI>(async () => await device.zh.lqi());
+                const result = await requestWithRetry<LQITableEntry[]>(async () => await device.zh.lqi());
                 lqis.set(device, result);
                 logger.debug(`LQI succeeded for '${device.name}'`);
             } catch (error) {
@@ -222,7 +223,7 @@ export default class NetworkMap extends Extension {
 
             if (includeRoutes) {
                 try {
-                    const result = await requestWithRetry<zh.RoutingTable>(async () => await device.zh.routingTable());
+                    const result = await requestWithRetry<RoutingTableEntry[]>(async () => await device.zh.routingTable());
                     routingTables.set(device, result);
                     logger.debug(`Routing table succeeded for '${device.name}'`);
                 } catch (error) {
@@ -274,42 +275,47 @@ export default class NetworkMap extends Extension {
         }
 
         // Add links
-        for (const [device, lqi] of lqis) {
-            for (const neighbor of lqi.neighbors) {
+        for (const [device, table] of lqis) {
+            for (const neighbor of table) {
                 if (neighbor.relationship > 3) {
                     // Relationship is not active, skip it
                     continue;
                 }
 
+                let neighborEui64 = neighbor.eui64;
+
                 // Some Xiaomi devices return 0x00 as the neighbor ieeeAddr (obviously not correct).
                 // Determine the correct ieeeAddr based on the networkAddress.
-                if (neighbor.ieeeAddr === "0x0000000000000000") {
-                    const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.networkAddress);
+                if (neighborEui64 === "0x0000000000000000") {
+                    const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.nwkAddress);
 
                     if (neighborDevice) {
-                        neighbor.ieeeAddr = neighborDevice.ieeeAddr;
+                        neighborEui64 = neighborDevice.ieeeAddr as Eui64;
                     }
                 }
 
                 const link: Zigbee2MQTTNetworkMap["links"][number] = {
-                    source: {ieeeAddr: neighbor.ieeeAddr, networkAddress: neighbor.networkAddress},
+                    source: {ieeeAddr: neighborEui64, networkAddress: neighbor.nwkAddress},
                     target: {ieeeAddr: device.ieeeAddr, networkAddress: device.zh.networkAddress},
-                    linkquality: neighbor.linkquality,
-                    depth: neighbor.depth,
-                    routes: [],
-                    // DEPRECATED:
-                    sourceIeeeAddr: neighbor.ieeeAddr,
-                    targetIeeeAddr: device.ieeeAddr,
-                    sourceNwkAddr: neighbor.networkAddress,
-                    lqi: neighbor.linkquality,
+                    deviceType: neighbor.deviceType,
+                    rxOnWhenIdle: neighbor.rxOnWhenIdle,
                     relationship: neighbor.relationship,
+                    permitJoining: neighbor.permitJoining,
+                    depth: neighbor.depth,
+                    lqi: neighbor.lqi,
+                    routes: [],
+                    // below are @deprecated
+                    sourceIeeeAddr: neighborEui64,
+                    targetIeeeAddr: device.ieeeAddr,
+                    sourceNwkAddr: neighbor.nwkAddress,
+                    linkquality: neighbor.lqi,
                 };
 
                 const routingTable = routingTables.get(device);
 
                 if (routingTable) {
-                    for (const entry of routingTable.table) {
-                        if (entry.status === "ACTIVE" && entry.nextHop === neighbor.networkAddress) {
+                    for (const entry of routingTable) {
+                        if (entry.nextHopAddress === neighbor.nwkAddress) {
                             link.routes.push(entry);
                         }
                     }

lib/types/api.ts

@@ -1,5 +1,8 @@
 import type * as zigbeeHerdsman from "zigbee-herdsman/dist";
+import type {ZclPayload} from "zigbee-herdsman/dist/adapter/events";
+import type {Eui64} from "zigbee-herdsman/dist/zspec/tstypes";
 import type {ClusterDefinition, ClusterName, CustomClusters} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
+import type {GenericZdoResponse, RoutingTableEntry} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
 import type * as zigbeeHerdsmanConverter from "zigbee-herdsman-converters";
 import type {Base} from "zigbee-herdsman-converters/lib/exposes";
 
@@ -278,18 +281,21 @@ export interface Zigbee2MQTTNetworkMap {
     links: {
         source: {ieeeAddr: string; networkAddress: number};
         target: {ieeeAddr: string; networkAddress: number};
-        linkquality: number;
-        depth: number;
-        routes: {
-            destinationAddress: number;
-            status: string;
-            nextHop: number;
-        }[];
-        sourceIeeeAddr: string;
-        targetIeeeAddr: string;
-        sourceNwkAddr: number;
-        lqi: number;
+        deviceType: number;
+        rxOnWhenIdle: number;
         relationship: number;
+        permitJoining: number;
+        depth: number;
+        lqi: number;
+        routes: RoutingTableEntry[];
+        /** @deprecated 3.0 */
+        linkquality: number;
+        /** @deprecated 3.0 */
+        sourceIeeeAddr: string;
+        /** @deprecated 3.0 */
+        targetIeeeAddr: string;
+        /** @deprecated 3.0 */
+        sourceNwkAddr: number;
     }[];
 }
 
@@ -310,6 +316,7 @@ export interface Zigbee2MQTTAPI {
     "bridge/definitions": {
         clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>>;
         custom_clusters: Record<string, CustomClusters>;
+        actions: string[];
     };
 
     "bridge/event":
@@ -558,6 +565,16 @@ export interface Zigbee2MQTTAPI {
         failed: string[];
     };
 
+    "bridge/request/device/binds/clear": {
+        target: string;
+        ieee_list?: Eui64[];
+    };
+
+    "bridge/response/device/binds/clear": {
+        target: string;
+        ieee_list?: Eui64[];
+    };
+
     "bridge/request/device/configure":
         | {
               id: string | number;
@@ -686,25 +703,41 @@ export interface Zigbee2MQTTAPI {
         homeassistant_rename: boolean;
     };
 
-    "bridge/request/device/configure_reporting": {
+    "bridge/request/device/reporting/configure": {
         id: string;
         endpoint: string | number;
         cluster: string | number;
         attribute: string | number | {ID: number; type: number};
         minimum_report_interval: number;
         maximum_report_interval: number;
-        reportable_change: number;
+        reportable_change?: number;
         option: Record<string, unknown>;
     };
 
-    "bridge/response/device/configure_reporting": {
+    "bridge/response/device/reporting/configure": {
         id: string;
         endpoint: string | number;
         cluster: string | number;
         attribute: string | number | {ID: number; type: number};
         minimum_report_interval: number;
         maximum_report_interval: number;
-        reportable_change: number;
+        reportable_change?: number;
+    };
+
+    "bridge/request/device/reporting/read": {
+        id: string;
+        endpoint: string | number;
+        cluster: string | number;
+        configs: {direction?: number; attribute: string | number | {ID: number; type: number}}[];
+        manufacturer_code?: number;
+    };
+
+    "bridge/response/device/reporting/read": {
+        id: string;
+        endpoint: string | number;
+        cluster: string | number;
+        configs: zigbeeHerdsman.Zcl.ClustersTypes.TFoundation["readReportConfigRsp"];
+        manufacturer_code?: number;
     };
 
     "bridge/request/group/remove": {
@@ -821,6 +854,10 @@ export interface Zigbee2MQTTAPI {
         channel: number;
     };
 
+    "bridge/request/action": {action: string; params?: Record<string, unknown>};
+
+    "bridge/response/action": GenericZdoResponse | ZclPayload | undefined;
+
     /**
      * entity state response
      */
@@ -883,6 +920,7 @@ export type Zigbee2MQTTRequestEndpoints =
     | "bridge/request/options"
     | "bridge/request/device/bind"
     | "bridge/request/device/unbind"
+    | "bridge/request/device/binds/clear"
     | "bridge/request/device/configure"
     | "bridge/request/device/remove"
     | "bridge/request/device/ota_update/check"
@@ -896,7 +934,8 @@ export type Zigbee2MQTTRequestEndpoints =
     | "bridge/request/device/generate_external_definition"
     | "bridge/request/device/options"
     | "bridge/request/device/rename"
-    | "bridge/request/device/configure_reporting"
+    | "bridge/request/device/reporting/configure"
+    | "bridge/request/device/reporting/read"
     | "bridge/request/group/remove"
     | "bridge/request/group/add"
     | "bridge/request/group/rename"
@@ -907,6 +946,7 @@ export type Zigbee2MQTTRequestEndpoints =
     | "bridge/request/touchlink/factory_reset"
     | "bridge/request/touchlink/scan"
     | "bridge/request/touchlink/identify"
+    | "bridge/request/action"
     | "{friendlyNameOrId}/set"
     | "{friendlyNameOrId}/set/{attribute}"
     | "{friendlyNameOrId}/{endpoint}/set"
@@ -931,6 +971,7 @@ export type Zigbee2MQTTResponseEndpoints =
     | "bridge/response/options"
     | "bridge/response/device/bind"
     | "bridge/response/device/unbind"
+    | "bridge/response/device/binds/clear"
     | "bridge/response/device/configure"
     | "bridge/response/device/remove"
     | "bridge/response/device/ota_update/check"
@@ -941,7 +982,8 @@ export type Zigbee2MQTTResponseEndpoints =
     | "bridge/response/device/generate_external_definition"
     | "bridge/response/device/options"
     | "bridge/response/device/rename"
-    | "bridge/response/device/configure_reporting"
+    | "bridge/response/device/reporting/configure"
+    | "bridge/response/device/reporting/read"
     | "bridge/response/group/remove"
     | "bridge/response/group/add"
     | "bridge/response/group/rename"
@@ -951,7 +993,8 @@ export type Zigbee2MQTTResponseEndpoints =
     | "bridge/response/group/members/remove_all"
     | "bridge/response/touchlink/factory_reset"
     | "bridge/response/touchlink/scan"
-    | "bridge/response/touchlink/identify";
+    | "bridge/response/touchlink/identify"
+    | "bridge/response/action";
 
 export type Zigbee2MQTTRequest<T extends Zigbee2MQTTRequestEndpoints> = {
     transaction?: string;

lib/types/types.d.ts

@@ -36,9 +36,6 @@ declare global {
         type Endpoint = ZHModels.Endpoint;
         type Device = ZHModels.Device;
         type Group = ZHModels.Group;
-        // biome-ignore lint/style/useNamingConvention: API
-        type LQI = ZHAdapterTypes.Lqi;
-        type RoutingTable = ZHAdapterTypes.RoutingTable;
         type CoordinatorVersion = ZHAdapterTypes.CoordinatorVersion;
         type NetworkParameters = ZHAdapterTypes.NetworkParameters;
         interface Bind {

lib/util/logger.ts

@@ -9,27 +9,25 @@ import * as settings from "./settings";
 const NAMESPACE_SEPARATOR = ":";
 
 class Logger {
-    // @ts-expect-error initalized in `init`
-    private level: settings.LogLevel;
-    // @ts-expect-error initalized in `init`
-    private output: string[];
-    // @ts-expect-error initalized in `init`
-    private directory: string;
-    // @ts-expect-error initalized in `init`
-    private logger: winston.Logger;
-    // @ts-expect-error initalized in `init`
-    private fileTransport: winston.transports.FileTransportInstance;
+    private level!: settings.LogLevel;
+    private output!: string[];
+    private directory!: string;
+    private logger!: winston.Logger;
+    private fileTransport: winston.transports.FileTransportInstance | undefined;
     private debugNamespaceIgnoreRegex?: RegExp;
-    // @ts-expect-error initalized in `init`
-    private namespacedLevels: Record<string, settings.LogLevel>;
-    // @ts-expect-error initalized in `init`
-    private cachedNamespacedLevels: Record<string, settings.LogLevel>;
+    private namespacedLevels!: Record<string, settings.LogLevel>;
+    private cachedNamespacedLevels!: Record<string, settings.LogLevel>;
 
     public init(): void {
         // What transports to enable
         this.output = settings.get().advanced.log_output;
-        // Directory to log to
-        const timestamp = new Date().toISOString().slice(0, 19).replace("T", ".").replace(/:/g, "-");
+        const date = new Date();
+        // offset UTC by current timezone, ISO keeps "Z" (UTC) which is then wrong but we strip it
+        const timestamp = new Date(date.getTime() - date.getTimezoneOffset() * 60000)
+            .toISOString()
+            .slice(0, 19)
+            .replace("T", ".")
+            .replaceAll(":", "-");
         this.directory = settings.get().advanced.log_directory.replace("%TIMESTAMP%", timestamp);
         const logFilename = settings.get().advanced.log_file.replace("%TIMESTAMP%", timestamp);
         this.level = settings.get().advanced.log_level;
@@ -240,7 +238,11 @@ class Logger {
 
             for (const dir of directories) {
                 this.debug(`Removing old log directory '${dir.path}'`);
-                rimrafSync(dir.path);
+                try {
+                    rimrafSync(dir.path);
+                } catch (e) {
+                    this.error(`Failed to remove old log directory '${dir.path}': ${e}`);
+                }
             }
         }
     }
@@ -262,7 +264,10 @@ class Logger {
                     // @ts-expect-error workaround
                     this.fileTransport.on("open", () => this.fileTransport._dest.on("finish", resolve));
                 }
-                this.fileTransport.end();
+
+                if (this.fileTransport) {
+                    this.fileTransport.end();
+                }
             });
         }
     }

lib/util/onboarding.ts

@@ -146,7 +146,7 @@ function generateHtmlForm(currentSettings: RecursivePartial<Settings>, devices:
                     id="serial_rtscts"
                     name="serial_rtscts"
                     ${currentSettings.serial?.rtscts ? "checked" : ""}
-                    ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_RTSCTS ? "disabled" : ""}>
+                    ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_RTSCTS ? "disabled" : ""}
                     style="margin-bottom: 1rem;">
                 <small>Can be ignored for networked coordinators (TCP).</small>
             </fieldset>
@@ -488,7 +488,7 @@ async function startOnboardingServer(): Promise<boolean> {
             }
         });
 
-        server.listen(Number.parseInt(serverUrl.port), serverUrl.hostname, () => {
+        server.listen(Number.parseInt(serverUrl.port, 10), serverUrl.hostname, () => {
             console.log(`Onboarding page is available at ${serverUrl.href}`);
         });
     });
@@ -515,7 +515,7 @@ async function startFailureServer(errors: string): Promise<void> {
             }
         });
 
-        server.listen(Number.parseInt(serverUrl.port), serverUrl.hostname, () => {
+        server.listen(Number.parseInt(serverUrl.port, 10), serverUrl.hostname, () => {
             console.error(`Failure page is available at ${serverUrl.href}`);
         });
     });

lib/util/settings.ts

@@ -607,7 +607,7 @@ export function addGroup(name: string, id?: string): GroupOptions {
         id = "1";
 
         while (settings.groups[id]) {
-            id = (Number.parseInt(id) + 1).toString();
+            id = (Number.parseInt(id, 10) + 1).toString();
         }
     } else {
         // ensure provided ID is not in use

lib/zigbee.ts

@@ -4,7 +4,6 @@ import stringify from "json-stable-stringify-without-jsonify";
 import type {Events as ZHEvents} from "zigbee-herdsman";
 import {Controller} from "zigbee-herdsman";
 import type {StartResult} from "zigbee-herdsman/dist/adapter/tstype";
-
 import Device from "./model/device";
 import Group from "./model/group";
 import data from "./util/data";
@@ -15,7 +14,7 @@ import utils from "./util/utils";
 const entityIDRegex = /^(.+?)(?:\/([^/]+))?$/;
 
 export default class Zigbee {
-    private herdsman!: Controller;
+    #herdsman!: Controller;
     private eventBus: EventBus;
     private groupLookup = new Map<number /* group ID */, Group>();
     private deviceLookup = new Map<string /* IEEE address */, Device>();
@@ -25,6 +24,10 @@ export default class Zigbee {
         this.eventBus = eventBus;
     }
 
+    get zhController() {
+        return this.#herdsman;
+    }
+
     async start(): Promise<StartResult> {
         const infoHerdsman = await utils.getDependencyVersion("zigbee-herdsman");
         logger.info(`Starting zigbee-herdsman (${infoHerdsman.version})`);
@@ -63,37 +66,37 @@ export default class Zigbee {
 
         let startResult: StartResult;
         try {
-            this.herdsman = new Controller(herdsmanSettings);
-            startResult = await this.herdsman.start();
+            this.#herdsman = new Controller(herdsmanSettings);
+            startResult = await this.#herdsman.start();
         } catch (error) {
             logger.error("Error while starting zigbee-herdsman");
             throw error;
         }
 
-        this.coordinatorIeeeAddr = this.herdsman.getDevicesByType("Coordinator")[0].ieeeAddr;
+        this.coordinatorIeeeAddr = this.#herdsman.getDevicesByType("Coordinator")[0].ieeeAddr;
         await this.resolveDevicesDefinitions();
 
-        this.herdsman.on("adapterDisconnected", () => this.eventBus.emitAdapterDisconnected());
-        this.herdsman.on("lastSeenChanged", (data: ZHEvents.LastSeenChangedPayload) => {
+        this.#herdsman.on("adapterDisconnected", () => this.eventBus.emitAdapterDisconnected());
+        this.#herdsman.on("lastSeenChanged", (data: ZHEvents.LastSeenChangedPayload) => {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             this.eventBus.emitLastSeenChanged({device: this.resolveDevice(data.device.ieeeAddr)!, reason: data.reason});
         });
-        this.herdsman.on("permitJoinChanged", (data: ZHEvents.PermitJoinChangedPayload) => {
+        this.#herdsman.on("permitJoinChanged", (data: ZHEvents.PermitJoinChangedPayload) => {
             this.eventBus.emitPermitJoinChanged(data);
         });
-        this.herdsman.on("deviceNetworkAddressChanged", (data: ZHEvents.DeviceNetworkAddressChangedPayload) => {
+        this.#herdsman.on("deviceNetworkAddressChanged", (data: ZHEvents.DeviceNetworkAddressChangedPayload) => {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             const device = this.resolveDevice(data.device.ieeeAddr)!;
             logger.debug(`Device '${device.name}' changed network address`);
             this.eventBus.emitDeviceNetworkAddressChanged({device});
         });
-        this.herdsman.on("deviceAnnounce", (data: ZHEvents.DeviceAnnouncePayload) => {
+        this.#herdsman.on("deviceAnnounce", (data: ZHEvents.DeviceAnnouncePayload) => {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             const device = this.resolveDevice(data.device.ieeeAddr)!;
             logger.debug(`Device '${device.name}' announced itself`);
             this.eventBus.emitDeviceAnnounce({device});
         });
-        this.herdsman.on("deviceInterview", async (data: ZHEvents.DeviceInterviewPayload) => {
+        this.#herdsman.on("deviceInterview", async (data: ZHEvents.DeviceInterviewPayload) => {
             const device = this.resolveDevice(data.device.ieeeAddr);
             /* v8 ignore next */ if (!device) return; // Prevent potential race
             await device.resolveDefinition();
@@ -101,19 +104,19 @@ export default class Zigbee {
             this.logDeviceInterview(d);
             this.eventBus.emitDeviceInterview(d);
         });
-        this.herdsman.on("deviceJoined", async (data: ZHEvents.DeviceJoinedPayload) => {
+        this.#herdsman.on("deviceJoined", async (data: ZHEvents.DeviceJoinedPayload) => {
             const device = this.resolveDevice(data.device.ieeeAddr);
             /* v8 ignore next */ if (!device) return; // Prevent potential race
             await device.resolveDefinition();
             logger.info(`Device '${device.name}' joined`);
             this.eventBus.emitDeviceJoined({device});
         });
-        this.herdsman.on("deviceLeave", (data: ZHEvents.DeviceLeavePayload) => {
+        this.#herdsman.on("deviceLeave", (data: ZHEvents.DeviceLeavePayload) => {
             const name = settings.getDevice(data.ieeeAddr)?.friendly_name || data.ieeeAddr;
             logger.warning(`Device '${name}' left the network`);
             this.eventBus.emitDeviceLeave({ieeeAddr: data.ieeeAddr, name, device: this.deviceLookup.get(data.ieeeAddr)});
         });
-        this.herdsman.on("message", async (data: ZHEvents.MessagePayload) => {
+        this.#herdsman.on("message", async (data: ZHEvents.MessagePayload) => {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             const device = this.resolveDevice(data.device.ieeeAddr)!;
             await device.resolveDefinition();
@@ -129,7 +132,7 @@ export default class Zigbee {
 
         logger.info(`zigbee-herdsman started (${startResult})`);
         logger.info(`Coordinator firmware version: '${stringify(await this.getCoordinatorVersion())}'`);
-        logger.debug(`Zigbee network parameters: ${stringify(await this.herdsman.getNetworkParameters())}`);
+        logger.debug(`Zigbee network parameters: ${stringify(await this.#herdsman.getNetworkParameters())}`);
 
         for (const device of this.devicesIterator(utils.deviceNotCoordinator)) {
             // If a passlist is used, all other device will be removed from the network.
@@ -198,39 +201,39 @@ export default class Zigbee {
     }
 
     async getCoordinatorVersion(): Promise<zh.CoordinatorVersion> {
-        return await this.herdsman.getCoordinatorVersion();
+        return await this.#herdsman.getCoordinatorVersion();
     }
 
     isStopping(): boolean {
-        return this.herdsman.isStopping();
+        return this.#herdsman.isStopping();
     }
 
     async backup(): Promise<void> {
-        return await this.herdsman.backup();
+        return await this.#herdsman.backup();
     }
 
     async coordinatorCheck(): Promise<{missingRouters: Device[]}> {
-        const check = await this.herdsman.coordinatorCheck();
+        const check = await this.#herdsman.coordinatorCheck();
         // biome-ignore lint/style/noNonNullAssertion: assumed valid
         return {missingRouters: check.missingRouters.map((d) => this.resolveDevice(d.ieeeAddr)!)};
     }
 
     async getNetworkParameters(): Promise<zh.NetworkParameters> {
-        return await this.herdsman.getNetworkParameters();
+        return await this.#herdsman.getNetworkParameters();
     }
 
     async stop(): Promise<void> {
         logger.info("Stopping zigbee-herdsman...");
-        await this.herdsman.stop();
+        await this.#herdsman.stop();
         logger.info("Stopped zigbee-herdsman");
     }
 
     getPermitJoin(): boolean {
-        return this.herdsman.getPermitJoin();
+        return this.#herdsman.getPermitJoin();
     }
 
     getPermitJoinEnd(): number | undefined {
-        return this.herdsman.getPermitJoinEnd();
+        return this.#herdsman.getPermitJoinEnd();
     }
 
     async permitJoin(time: number, device?: Device): Promise<void> {
@@ -240,7 +243,7 @@ export default class Zigbee {
             logger.info("Zigbee: disabling joining new devices.");
         }
 
-        await this.herdsman.permitJoin(time, device?.zh);
+        await this.#herdsman.permitJoin(time, device?.zh);
     }
 
     async resolveDevicesDefinitions(ignoreCache = false): Promise<void> {
@@ -251,7 +254,7 @@ export default class Zigbee {
 
     @bind private resolveDevice(ieeeAddr: string): Device | undefined {
         if (!this.deviceLookup.has(ieeeAddr)) {
-            const device = this.herdsman.getDeviceByIeeeAddr(ieeeAddr);
+            const device = this.#herdsman.getDeviceByIeeeAddr(ieeeAddr);
             if (device) {
                 this.deviceLookup.set(ieeeAddr, new Device(device));
             }
@@ -266,7 +269,7 @@ export default class Zigbee {
 
     private resolveGroup(groupID: number): Group | undefined {
         if (!this.groupLookup.has(groupID)) {
-            const group = this.herdsman.getGroupByID(groupID);
+            const group = this.#herdsman.getGroupByID(groupID);
 
             if (group) {
                 this.groupLookup.set(groupID, new Group(group, this.resolveDevice));
@@ -339,33 +342,33 @@ export default class Zigbee {
     }
 
     firstCoordinatorEndpoint(): zh.Endpoint {
-        return this.herdsman.getDevicesByType("Coordinator")[0].endpoints[0];
+        return this.#herdsman.getDevicesByType("Coordinator")[0].endpoints[0];
     }
 
     *devicesAndGroupsIterator(
         devicePredicate?: (value: zh.Device) => boolean,
         groupPredicate?: (value: zh.Group) => boolean,
     ): Generator<Device | Group> {
-        for (const device of this.herdsman.getDevicesIterator(devicePredicate)) {
+        for (const device of this.#herdsman.getDevicesIterator(devicePredicate)) {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             yield this.resolveDevice(device.ieeeAddr)!;
         }
 
-        for (const group of this.herdsman.getGroupsIterator(groupPredicate)) {
+        for (const group of this.#herdsman.getGroupsIterator(groupPredicate)) {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             yield this.resolveGroup(group.groupID)!;
         }
     }
 
     *groupsIterator(predicate?: (value: zh.Group) => boolean): Generator<Group> {
-        for (const group of this.herdsman.getGroupsIterator(predicate)) {
+        for (const group of this.#herdsman.getGroupsIterator(predicate)) {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             yield this.resolveGroup(group.groupID)!;
         }
     }
 
     *devicesIterator(predicate?: (value: zh.Device) => boolean): Generator<Device> {
-        for (const device of this.herdsman.getDevicesIterator(predicate)) {
+        for (const device of this.#herdsman.getDevicesIterator(predicate)) {
             // biome-ignore lint/style/noNonNullAssertion: assumed valid
             yield this.resolveDevice(device.ieeeAddr)!;
         }
@@ -399,33 +402,33 @@ export default class Zigbee {
     }
 
     async touchlinkFactoryResetFirst(): Promise<boolean> {
-        return await this.herdsman.touchlinkFactoryResetFirst();
+        return await this.#herdsman.touchlink.factoryResetFirst();
     }
 
     async touchlinkFactoryReset(ieeeAddr: string, channel: number): Promise<boolean> {
-        return await this.herdsman.touchlinkFactoryReset(ieeeAddr, channel);
+        return await this.#herdsman.touchlink.factoryReset(ieeeAddr, channel);
     }
 
     async addInstallCode(installCode: string): Promise<void> {
-        await this.herdsman.addInstallCode(installCode);
+        await this.#herdsman.addInstallCode(installCode);
     }
 
     async touchlinkIdentify(ieeeAddr: string, channel: number): Promise<void> {
-        await this.herdsman.touchlinkIdentify(ieeeAddr, channel);
+        await this.#herdsman.touchlink.identify(ieeeAddr, channel);
     }
 
     async touchlinkScan(): Promise<{ieeeAddr: string; channel: number}[]> {
-        return await this.herdsman.touchlinkScan();
+        return await this.#herdsman.touchlink.scan();
     }
 
     createGroup(id: number): Group {
-        this.herdsman.createGroup(id);
+        this.#herdsman.createGroup(id);
         // biome-ignore lint/style/noNonNullAssertion: just created
         return this.resolveGroup(id)!;
     }
 
     deviceByNetworkAddress(networkAddress: number): Device | undefined {
-        const device = this.herdsman.getDeviceByNetworkAddress(networkAddress);
+        const device = this.#herdsman.getDeviceByNetworkAddress(networkAddress);
         return device && this.resolveDevice(device.ieeeAddr);
     }
 

package.json

@@ -1,6 +1,6 @@
 {
     "name": "zigbee2mqtt",
-    "version": "2.6.3",
+    "version": "2.7.2",
     "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
     "main": "index.js",
     "types": "dist/types/api.d.ts",
@@ -44,37 +44,37 @@
     "dependencies": {
         "ajv": "^8.17.1",
         "bind-decorator": "^1.0.11",
-        "debounce": "^2.2.0",
+        "debounce": "^3.0.0",
         "express-static-gzip": "^3.0.0",
         "fast-deep-equal": "^3.1.3",
-        "finalhandler": "^2.1.0",
-        "humanize-duration": "^3.33.1",
+        "finalhandler": "^2.1.1",
+        "humanize-duration": "^3.33.2",
         "js-yaml": "^4.1.0",
         "json-stable-stringify-without-jsonify": "^1.0.1",
         "jszip": "^3.10.1",
         "mqtt": "^5.14.1",
         "object-assign-deep": "^0.4.0",
-        "rimraf": "^6.1.0",
+        "rimraf": "^6.1.2",
         "semver": "^7.7.3",
         "source-map-support": "^0.5.21",
         "throttleit": "^2.1.0",
-        "winston": "^3.18.3",
+        "winston": "^3.19.0",
         "winston-syslog": "^2.7.1",
         "winston-transport": "^4.9.0",
         "ws": "^8.18.1",
-        "zigbee-herdsman": "6.3.2",
-        "zigbee-herdsman-converters": "25.59.0",
+        "zigbee-herdsman": "8.0.1",
+        "zigbee-herdsman-converters": "25.98.0",
         "zigbee2mqtt-frontend": "0.9.21",
-        "zigbee2mqtt-windfront": "2.2.3"
+        "zigbee2mqtt-windfront": "2.6.2"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.3.2",
+        "@biomejs/biome": "^2.3.10",
         "@types/finalhandler": "^1.2.3",
         "@types/humanize-duration": "^3.27.4",
         "@types/js-yaml": "^4.0.9",
-        "@types/node": "^24.9.2",
+        "@types/node": "^24.10.4",
         "@types/object-assign-deep": "^0.4.3",
-        "@types/readable-stream": "4.0.22",
+        "@types/readable-stream": "4.0.23",
         "@types/serve-static": "^2.2.0",
         "@types/ws": "8.18.1",
         "@vitest/coverage-v8": "^3.1.1",
@@ -99,4 +99,4 @@
     "optionalDependencies": {
         "unix-dgram": "^2.0.7"
     }
-}
+}

pnpm-lock.yaml

@@ -5,7 +5,7 @@ settings:
   excludeLinksFromLockfile: false
 
 overrides:
-  zigbee-herdsman: 6.3.2
+  zigbee-herdsman: 8.0.1
 
 importers:
 
@@ -18,8 +18,8 @@ importers:
         specifier: ^1.0.11
         version: 1.0.11
       debounce:
-        specifier: ^2.2.0
-        version: 2.2.0
+        specifier: ^3.0.0
+        version: 3.0.0
       express-static-gzip:
         specifier: ^3.0.0
         version: 3.0.0
@@ -27,14 +27,14 @@ importers:
         specifier: ^3.1.3
         version: 3.1.3
       finalhandler:
-        specifier: ^2.1.0
-        version: 2.1.0
+        specifier: ^2.1.1
+        version: 2.1.1
       humanize-duration:
-        specifier: ^3.33.1
-        version: 3.33.1
+        specifier: ^3.33.2
+        version: 3.33.2
       js-yaml:
         specifier: ^4.1.0
-        version: 4.1.0
+        version: 4.1.1
       json-stable-stringify-without-jsonify:
         specifier: ^1.0.1
         version: 1.0.1
@@ -48,8 +48,8 @@ importers:
         specifier: ^0.4.0
         version: 0.4.0
       rimraf:
-        specifier: ^6.1.0
-        version: 6.1.0
+        specifier: ^6.1.2
+        version: 6.1.2
       semver:
         specifier: ^7.7.3
         version: 7.7.3
@@ -60,11 +60,11 @@ importers:
         specifier: ^2.1.0
         version: 2.1.0
       winston:
-        specifier: ^3.18.3
-        version: 3.18.3
+        specifier: ^3.19.0
+        version: 3.19.0
       winston-syslog:
         specifier: ^2.7.1
-        version: 2.7.1(winston@3.18.3)
+        version: 2.7.1(winston@3.19.0)
       winston-transport:
         specifier: ^4.9.0
         version: 4.9.0
@@ -72,21 +72,21 @@ importers:
         specifier: ^8.18.1
         version: 8.18.3
       zigbee-herdsman:
-        specifier: 6.3.2
-        version: 6.3.2
+        specifier: 8.0.1
+        version: 8.0.1
       zigbee-herdsman-converters:
-        specifier: 25.59.0
-        version: 25.59.0
+        specifier: 25.98.0
+        version: 25.98.0
       zigbee2mqtt-frontend:
         specifier: 0.9.21
         version: 0.9.21
       zigbee2mqtt-windfront:
-        specifier: 2.2.3
-        version: 2.2.3
+        specifier: 2.6.2
+        version: 2.6.2
     devDependencies:
       '@biomejs/biome':
-        specifier: ^2.3.2
-        version: 2.3.2
+        specifier: ^2.3.10
+        version: 2.3.10
       '@types/finalhandler':
         specifier: ^1.2.3
         version: 1.2.4
@@ -97,14 +97,14 @@ importers:
         specifier: ^4.0.9
         version: 4.0.9
       '@types/node':
-        specifier: ^24.9.2
-        version: 24.9.2
+        specifier: ^24.10.4
+        version: 24.10.4
       '@types/object-assign-deep':
         specifier: ^0.4.3
         version: 0.4.3
       '@types/readable-stream':
-        specifier: 4.0.22
-        version: 4.0.22
+        specifier: 4.0.23
+        version: 4.0.23
       '@types/serve-static':
         specifier: ^2.2.0
         version: 2.2.0
@@ -113,7 +113,7 @@ importers:
         version: 8.18.1
       '@vitest/coverage-v8':
         specifier: ^3.1.1
-        version: 3.2.4(vitest@3.2.4(@types/node@24.9.2))
+        version: 3.2.4(vitest@3.2.4(@types/node@24.10.4))
       tmp:
         specifier: ^0.2.5
         version: 0.2.5
@@ -122,7 +122,7 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^3.1.1
-        version: 3.2.4(@types/node@24.9.2)
+        version: 3.2.4(@types/node@24.10.4)
     optionalDependencies:
       unix-dgram:
         specifier: ^2.0.7
@@ -159,55 +159,55 @@ packages:
     resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
     engines: {node: '>=18'}
 
-  '@biomejs/biome@2.3.2':
-    resolution: {integrity: sha512-8e9tzamuDycx7fdrcJ/F/GDZ8SYukc5ud6tDicjjFqURKYFSWMl0H0iXNXZEGmcmNUmABgGuHThPykcM41INgg==}
+  '@biomejs/biome@2.3.10':
+    resolution: {integrity: sha512-/uWSUd1MHX2fjqNLHNL6zLYWBbrJeG412/8H7ESuK8ewoRoMPUgHDebqKrPTx/5n6f17Xzqc9hdg3MEqA5hXnQ==}
     engines: {node: '>=14.21.3'}
     hasBin: true
 
-  '@biomejs/cli-darwin-arm64@2.3.2':
-    resolution: {integrity: sha512-4LECm4kc3If0JISai4c3KWQzukoUdpxy4fRzlrPcrdMSRFksR9ZoXK7JBcPuLBmd2SoT4/d7CQS33VnZpgBjew==}
+  '@biomejs/cli-darwin-arm64@2.3.10':
+    resolution: {integrity: sha512-M6xUjtCVnNGFfK7HMNKa593nb7fwNm43fq1Mt71kpLpb+4mE7odO8W/oWVDyBVO4ackhresy1ZYO7OJcVo/B7w==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [darwin]
 
-  '@biomejs/cli-darwin-x64@2.3.2':
-    resolution: {integrity: sha512-jNMnfwHT4N3wi+ypRfMTjLGnDmKYGzxVr1EYAPBcauRcDnICFXN81wD6wxJcSUrLynoyyYCdfW6vJHS/IAoTDA==}
+  '@biomejs/cli-darwin-x64@2.3.10':
+    resolution: {integrity: sha512-Vae7+V6t/Avr8tVbFNjnFSTKZogZHFYl7MMH62P/J1kZtr0tyRQ9Fe0onjqjS2Ek9lmNLmZc/VR5uSekh+p1fg==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [darwin]
 
-  '@biomejs/cli-linux-arm64-musl@2.3.2':
-    resolution: {integrity: sha512-2Zz4usDG1GTTPQnliIeNx6eVGGP2ry5vE/v39nT73a3cKN6t5H5XxjcEoZZh62uVZvED7hXXikclvI64vZkYqw==}
+  '@biomejs/cli-linux-arm64-musl@2.3.10':
+    resolution: {integrity: sha512-B9DszIHkuKtOH2IFeeVkQmSMVUjss9KtHaNXquYYWCjH8IstNgXgx5B0aSBQNr6mn4RcKKRQZXn9Zu1rM3O0/A==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [linux]
 
-  '@biomejs/cli-linux-arm64@2.3.2':
-    resolution: {integrity: sha512-amnqvk+gWybbQleRRq8TMe0rIv7GHss8mFJEaGuEZYWg1Tw14YKOkeo8h6pf1c+d3qR+JU4iT9KXnBKGON4klw==}
+  '@biomejs/cli-linux-arm64@2.3.10':
+    resolution: {integrity: sha512-hhPw2V3/EpHKsileVOFynuWiKRgFEV48cLe0eA+G2wO4SzlwEhLEB9LhlSrVeu2mtSn205W283LkX7Fh48CaxA==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [linux]
 
-  '@biomejs/cli-linux-x64-musl@2.3.2':
-    resolution: {integrity: sha512-gzB19MpRdTuOuLtPpFBGrV3Lq424gHyq2lFj8wfX9tvLMLdmA/R9C7k/mqBp/spcbWuHeIEKgEs3RviOPcWGBA==}
+  '@biomejs/cli-linux-x64-musl@2.3.10':
+    resolution: {integrity: sha512-QTfHZQh62SDFdYc2nfmZFuTm5yYb4eO1zwfB+90YxUumRCR171tS1GoTX5OD0wrv4UsziMPmrePMtkTnNyYG3g==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [linux]
 
-  '@biomejs/cli-linux-x64@2.3.2':
-    resolution: {integrity: sha512-8BG/vRAhFz1pmuyd24FQPhNeueLqPtwvZk6yblABY2gzL2H8fLQAF/Z2OPIc+BPIVPld+8cSiKY/KFh6k81xfA==}
+  '@biomejs/cli-linux-x64@2.3.10':
+    resolution: {integrity: sha512-wwAkWD1MR95u+J4LkWP74/vGz+tRrIQvr8kfMMJY8KOQ8+HMVleREOcPYsQX82S7uueco60L58Wc6M1I9WA9Dw==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [linux]
 
-  '@biomejs/cli-win32-arm64@2.3.2':
-    resolution: {integrity: sha512-lCruqQlfWjhMlOdyf5pDHOxoNm4WoyY2vZ4YN33/nuZBRstVDuqPPjS0yBkbUlLEte11FbpW+wWSlfnZfSIZvg==}
+  '@biomejs/cli-win32-arm64@2.3.10':
+    resolution: {integrity: sha512-o7lYc9n+CfRbHvkjPhm8s9FgbKdYZu5HCcGVMItLjz93EhgJ8AM44W+QckDqLA9MKDNFrR8nPbO4b73VC5kGGQ==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [win32]
 
-  '@biomejs/cli-win32-x64@2.3.2':
-    resolution: {integrity: sha512-6Ee9P26DTb4D8sN9nXxgbi9Dw5vSOfH98M7UlmkjKB2vtUbrRqCbZiNfryGiwnPIpd6YUoTl7rLVD2/x1CyEHQ==}
+  '@biomejs/cli-win32-x64@2.3.10':
+    resolution: {integrity: sha512-pHEFgq7dUEsKnqG9mx9bXihxGI49X+ar+UBrEIj3Wqj3UCZp1rNgV+OoyjFgcXsjCWpuEAF4VJdkZr3TrWdCbQ==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [win32]
@@ -557,14 +557,14 @@ packages:
   '@types/js-yaml@4.0.9':
     resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==}
 
-  '@types/node@24.9.2':
-    resolution: {integrity: sha512-uWN8YqxXxqFMX2RqGOrumsKeti4LlmIMIyV0lgut4jx7KQBcBiW6vkDtIBvHnHIquwNfJhk8v2OtmO8zXWHfPA==}
+  '@types/node@24.10.4':
+    resolution: {integrity: sha512-vnDVpYPMzs4wunl27jHrfmwojOGKya0xyM3sH+UE5iv5uPS6vX7UIoh6m+vQc5LGBq52HBKPIn/zcSZVzeDEZg==}
 
   '@types/object-assign-deep@0.4.3':
     resolution: {integrity: sha512-d9Gxaj5j1hzrxJ61EFEg13B4g4FgrT/DYtcDWFXPehR8DF2SUZbVMFtZIs8exkVRiqrqBpdTc/lUUZjncsPpMw==}
 
-  '@types/readable-stream@4.0.22':
-    resolution: {integrity: sha512-/FFhJpfCLAPwAcN3mFycNUa77ddnr8jTgF5VmSNetaemWB2cIlfCA9t0YTM3JAT0wOcv8D4tjPo7pkDhK3EJIg==}
+  '@types/readable-stream@4.0.23':
+    resolution: {integrity: sha512-wwXrtQvbMHxCbBgjHaMGEmImFTQxxpfMOR/ZoQnXxB1woqkUbdLGFDgauo00Py9IudiaqSeiBiulSV9i6XIPig==}
 
   '@types/serve-static@2.2.0':
     resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==}
@@ -695,23 +695,23 @@ packages:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
 
-  color-convert@3.1.2:
-    resolution: {integrity: sha512-UNqkvCDXstVck3kdowtOTWROIJQwafjOfXSmddoDrXo4cewMKmusCeF22Q24zvjR8nwWib/3S/dfyzPItPEiJg==}
+  color-convert@3.1.3:
+    resolution: {integrity: sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg==}
     engines: {node: '>=14.6'}
 
   color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
-  color-name@2.0.2:
-    resolution: {integrity: sha512-9vEt7gE16EW7Eu7pvZnR0abW9z6ufzhXxGXZEVU9IqPdlsUiMwJeJfRtq0zePUmnbHGT9zajca7mX8zgoayo4A==}
+  color-name@2.1.0:
+    resolution: {integrity: sha512-1bPaDNFm0axzE4MEAzKPuqKWeRaT43U/hyxKPBdqTfmPF+d6n7FSoTFxLVULUJOmiLp01KjhIPPH+HrXZJN4Rg==}
     engines: {node: '>=12.20'}
 
-  color-string@2.1.2:
-    resolution: {integrity: sha512-RxmjYxbWemV9gKu4zPgiZagUxbH3RQpEIO77XoSSX0ivgABDZ+h8Zuash/EMFLTI4N9QgFPOJ6JQpPZKFxa+dA==}
+  color-string@2.1.4:
+    resolution: {integrity: sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg==}
     engines: {node: '>=18'}
 
-  color@5.0.2:
-    resolution: {integrity: sha512-e2hz5BzbUPcYlIRHo8ieAhYgoajrJr+hWoceg6E345TPsATMUKqDgzt8fSXZJJbxfpiPzkWyphz8yn8At7q3fA==}
+  color@5.0.3:
+    resolution: {integrity: sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==}
     engines: {node: '>=18'}
 
   commist@3.2.0:
@@ -728,9 +728,9 @@ packages:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
 
-  debounce@2.2.0:
-    resolution: {integrity: sha512-Xks6RUDLZFdz8LIdR6q0MTH44k7FikOmnh5xkSjMig6ch45afc8sjTjRQf3P6ax8dMgcQrYO/AR2RGWURrruqw==}
-    engines: {node: '>=18'}
+  debounce@3.0.0:
+    resolution: {integrity: sha512-64byRbF0/AirwbuHqB3/ZpMG9/nckDa6ZA0yd6UnaQNwbbemCOwvz2sL5sjXLHhZHADyiwLm0M5qMhltUUx+TA==}
+    engines: {node: '>=20'}
 
   debug@4.4.0:
     resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
@@ -847,9 +847,9 @@ packages:
   file-uri-to-path@1.0.0:
     resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
 
-  finalhandler@2.1.0:
-    resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==}
-    engines: {node: '>= 0.8'}
+  finalhandler@2.1.1:
+    resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==}
+    engines: {node: '>= 18.0.0'}
 
   fn.name@1.1.0:
     resolution: {integrity: sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==}
@@ -867,14 +867,13 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
-  glob@10.4.5:
-    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+  glob@10.5.0:
+    resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==}
     hasBin: true
 
-  glob@11.0.3:
-    resolution: {integrity: sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==}
+  glob@13.0.0:
+    resolution: {integrity: sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==}
     engines: {node: 20 || >=22}
-    hasBin: true
 
   glossy@0.1.7:
     resolution: {integrity: sha512-mTCC51QFadK75MvAhrL5nPVIP291NjML1guo10Sa7Yj04tJU4V++Vgm780NIddg9etQD9D8FM67hFGqM8EE2HQ==}
@@ -894,11 +893,11 @@ packages:
     resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
     engines: {node: '>= 0.8'}
 
-  humanize-duration@3.33.1:
-    resolution: {integrity: sha512-hwzSCymnRdFx9YdRkQQ0OYequXiVAV6ZGQA2uzocwB0F4309Ke6pO8dg0P8LHhRQJyVjGteRTAA/zNfEcpXn8A==}
+  humanize-duration@3.33.2:
+    resolution: {integrity: sha512-K7Ny/ULO1hDm2nnhvAY+SJV1skxFb61fd073SG1IWJl+D44ULrruCuTyjHKjBVVcSuTlnY99DKtgEG39CM5QOQ==}
 
-  iconv-lite@0.7.0:
-    resolution: {integrity: sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==}
+  iconv-lite@0.7.1:
+    resolution: {integrity: sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==}
     engines: {node: '>=0.10.0'}
 
   ieee754@1.2.1:
@@ -947,18 +946,14 @@ packages:
   jackspeak@3.4.3:
     resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
 
-  jackspeak@4.1.1:
-    resolution: {integrity: sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==}
-    engines: {node: 20 || >=22}
-
   js-sdsl@4.3.0:
     resolution: {integrity: sha512-mifzlm2+5nZ+lEcLJMoBK0/IH/bDg8XnJfd/Wq6IP+xoCjLZsTOnV2QpxlVbX9bMnkl5PdEjNtBJ9Cj1NjifhQ==}
 
   js-tokens@9.0.1:
     resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
 
-  js-yaml@4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
   json-schema-traverse@1.0.0:
@@ -1090,8 +1085,8 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
 
-  path-scurry@2.0.0:
-    resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==}
+  path-scurry@2.0.1:
+    resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}
     engines: {node: 20 || >=22}
 
   pathe@2.0.3:
@@ -1141,8 +1136,8 @@ packages:
   rfdc@1.4.1:
     resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
 
-  rimraf@6.1.0:
-    resolution: {integrity: sha512-DxdlA1bdNzkZK7JiNWH+BAx1x4tEJWoTofIopFo6qWUU94jYrFZ0ubY05TqH3nWPJ1nKa1JWVFDINZ3fnrle/A==}
+  rimraf@6.1.2:
+    resolution: {integrity: sha512-cFCkPslJv7BAXJsYlK1dZsbP8/ZNLkCAQ0bi1hf5EKX2QHegmDFEFA6QhuYJlk7UDdc+02JjO80YSOrWPpw06g==}
     engines: {node: 20 || >=22}
     hasBin: true
 
@@ -1234,6 +1229,10 @@ packages:
     resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
     engines: {node: '>= 0.8'}
 
+  statuses@2.0.2:
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
+
   std-env@3.9.0:
     resolution: {integrity: sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==}
 
@@ -1432,8 +1431,8 @@ packages:
     resolution: {integrity: sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==}
     engines: {node: '>= 12.0.0'}
 
-  winston@3.18.3:
-    resolution: {integrity: sha512-NoBZauFNNWENgsnC9YpgyYwOVrl2m58PpQ8lNHjV3kosGs7KJ7Npk9pCUE+WJlawVSe8mykWDKWFSVfs3QO9ww==}
+  winston@3.19.0:
+    resolution: {integrity: sha512-LZNJgPzfKR+/J3cHkxcpHKpKKvGfDZVPS4hfJCc4cCG0CgYzvlD6yE/S3CIL/Yt91ak327YCpiF/0MyeZHEHKA==}
     engines: {node: '>= 12.0.0'}
 
   worker-factory@7.0.45:
@@ -1468,23 +1467,23 @@ packages:
       utf-8-validate:
         optional: true
 
-  zigbee-herdsman-converters@25.59.0:
-    resolution: {integrity: sha512-Pw0L88hLQgv1vxv3uTFKbPDaMd75zuNWIcM0Y8+F0uKDZt8K8djEiBK74RlWYmHcrvBfzeRM61Jw/991/TShcw==}
+  zigbee-herdsman-converters@25.98.0:
+    resolution: {integrity: sha512-GBLmtRnxAvWRxb6fnAGjq3OmZq1mnO3XfH5HgL5apy1iirTzvshVkPdZ3YwNbK2KYRNrmQEtYjugDNMj5IOopw==}
     engines: {node: '>=20.15.0'}
 
-  zigbee-herdsman@6.3.2:
-    resolution: {integrity: sha512-35qPU1KoADQrgIol/pWulVKRj8jFpuogtPWjisHSlss3dvzlj5yg5wBdw9/qpcDxNShtKMtj1K28io5KMmRsAw==}
+  zigbee-herdsman@8.0.1:
+    resolution: {integrity: sha512-avIIufN1QNAvFWw9U1IzqvstbpEznk8PLAJwCF7BgXhtKEsTUAujB3JzKc7mnhgVTyQRmVytoEDD7UpUuurjSw==}
 
-  zigbee-on-host@0.1.13:
-    resolution: {integrity: sha512-mL7s9ic7J85YI7wOG1/QlbRYE3haFzIHqgnM2+xLmjj8CazjhmGjop9TCfuY2JXyDI9ss7bNCLxuI9n6M+TXug==}
+  zigbee-on-host@0.2.4:
+    resolution: {integrity: sha512-NIG6CWp+Yfn7PjqEIRvenHqpwT1U7rSkyimnFOUIFpnmxQOJKrmcwWDfn6WjbU/YIYYWSQPlj+g13icu1xwlyg==}
     engines: {node: ^20.19.0 || >=22.12.0}
 
   zigbee2mqtt-frontend@0.9.21:
     resolution: {integrity: sha512-ClHYlG7g0v/tnIsD6kycNCi1ZEKIbQuU7lGJR3WqYcDmuqEMVcHDGbRiRwYRQcZGMxkqCf7guxNsXiKnC10+kg==}
     engines: {node: '>=20.11'}
 
-  zigbee2mqtt-windfront@2.2.3:
-    resolution: {integrity: sha512-DCTmYqTEr5VLHvrtOGym/aKWgU+JolcEiGk5B9C8Hmugb5owwVLyJhdBl2GzIme6/28H5pb+BdxIJcEz0verUg==}
+  zigbee2mqtt-windfront@2.6.2:
+    resolution: {integrity: sha512-WymwIUskBJo+71DBn9bHenqCw5bEk5HZ5YucjrPGp6Ju4cYyDaQHFAKEOHR0gQRWy/1m0Inl+Rcl5JpINmMkzw==}
     engines: {node: '>=22.12.0'}
 
 snapshots:
@@ -1511,39 +1510,39 @@ snapshots:
 
   '@bcoe/v8-coverage@1.0.2': {}
 
-  '@biomejs/biome@2.3.2':
+  '@biomejs/biome@2.3.10':
     optionalDependencies:
-      '@biomejs/cli-darwin-arm64': 2.3.2
-      '@biomejs/cli-darwin-x64': 2.3.2
-      '@biomejs/cli-linux-arm64': 2.3.2
-      '@biomejs/cli-linux-arm64-musl': 2.3.2
-      '@biomejs/cli-linux-x64': 2.3.2
-      '@biomejs/cli-linux-x64-musl': 2.3.2
-      '@biomejs/cli-win32-arm64': 2.3.2
-      '@biomejs/cli-win32-x64': 2.3.2
+      '@biomejs/cli-darwin-arm64': 2.3.10
+      '@biomejs/cli-darwin-x64': 2.3.10
+      '@biomejs/cli-linux-arm64': 2.3.10
+      '@biomejs/cli-linux-arm64-musl': 2.3.10
+      '@biomejs/cli-linux-x64': 2.3.10
+      '@biomejs/cli-linux-x64-musl': 2.3.10
+      '@biomejs/cli-win32-arm64': 2.3.10
+      '@biomejs/cli-win32-x64': 2.3.10
 
-  '@biomejs/cli-darwin-arm64@2.3.2':
+  '@biomejs/cli-darwin-arm64@2.3.10':
     optional: true
 
-  '@biomejs/cli-darwin-x64@2.3.2':
+  '@biomejs/cli-darwin-x64@2.3.10':
     optional: true
 
-  '@biomejs/cli-linux-arm64-musl@2.3.2':
+  '@biomejs/cli-linux-arm64-musl@2.3.10':
     optional: true
 
-  '@biomejs/cli-linux-arm64@2.3.2':
+  '@biomejs/cli-linux-arm64@2.3.10':
     optional: true
 
-  '@biomejs/cli-linux-x64-musl@2.3.2':
+  '@biomejs/cli-linux-x64-musl@2.3.10':
     optional: true
 
-  '@biomejs/cli-linux-x64@2.3.2':
+  '@biomejs/cli-linux-x64@2.3.10':
     optional: true
 
-  '@biomejs/cli-win32-arm64@2.3.2':
+  '@biomejs/cli-win32-arm64@2.3.10':
     optional: true
 
-  '@biomejs/cli-win32-x64@2.3.2':
+  '@biomejs/cli-win32-x64@2.3.10':
     optional: true
 
   '@colors/colors@1.6.0': {}
@@ -1757,7 +1756,7 @@ snapshots:
 
   '@so-ric/colorspace@1.1.6':
     dependencies:
-      color: 5.0.2
+      color: 5.0.3
       text-hex: 1.0.0
 
   '@types/chai@5.2.2':
@@ -1770,7 +1769,7 @@ snapshots:
 
   '@types/finalhandler@1.2.4':
     dependencies:
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
 
   '@types/http-errors@2.0.5': {}
 
@@ -1778,28 +1777,28 @@ snapshots:
 
   '@types/js-yaml@4.0.9': {}
 
-  '@types/node@24.9.2':
+  '@types/node@24.10.4':
     dependencies:
       undici-types: 7.16.0
 
   '@types/object-assign-deep@0.4.3': {}
 
-  '@types/readable-stream@4.0.22':
+  '@types/readable-stream@4.0.23':
     dependencies:
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
 
   '@types/serve-static@2.2.0':
     dependencies:
       '@types/http-errors': 2.0.5
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
 
   '@types/triple-beam@1.3.5': {}
 
   '@types/ws@8.18.1':
     dependencies:
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
 
-  '@vitest/coverage-v8@3.2.4(vitest@3.2.4(@types/node@24.9.2))':
+  '@vitest/coverage-v8@3.2.4(vitest@3.2.4(@types/node@24.10.4))':
     dependencies:
       '@ampproject/remapping': 2.3.0
       '@bcoe/v8-coverage': 1.0.2
@@ -1814,7 +1813,7 @@ snapshots:
       std-env: 3.9.0
       test-exclude: 7.0.1
       tinyrainbow: 2.0.0
-      vitest: 3.2.4(@types/node@24.9.2)
+      vitest: 3.2.4(@types/node@24.10.4)
     transitivePeerDependencies:
       - supports-color
 
@@ -1826,13 +1825,13 @@ snapshots:
       chai: 5.2.0
       tinyrainbow: 2.0.0
 
-  '@vitest/mocker@3.2.4(vite@6.3.5(@types/node@24.9.2))':
+  '@vitest/mocker@3.2.4(vite@6.3.5(@types/node@24.10.4))':
     dependencies:
       '@vitest/spy': 3.2.4
       estree-walker: 3.0.3
       magic-string: 0.30.17
     optionalDependencies:
-      vite: 6.3.5(@types/node@24.9.2)
+      vite: 6.3.5(@types/node@24.10.4)
 
   '@vitest/pretty-format@3.2.4':
     dependencies:
@@ -1906,7 +1905,7 @@ snapshots:
 
   bl@6.1.3:
     dependencies:
-      '@types/readable-stream': 4.0.22
+      '@types/readable-stream': 4.0.23
       buffer: 6.0.3
       inherits: 2.0.4
       readable-stream: 4.7.0
@@ -1950,22 +1949,22 @@ snapshots:
     dependencies:
       color-name: 1.1.4
 
-  color-convert@3.1.2:
+  color-convert@3.1.3:
     dependencies:
-      color-name: 2.0.2
+      color-name: 2.1.0
 
   color-name@1.1.4: {}
 
-  color-name@2.0.2: {}
+  color-name@2.1.0: {}
 
-  color-string@2.1.2:
+  color-string@2.1.4:
     dependencies:
-      color-name: 2.0.2
+      color-name: 2.1.0
 
-  color@5.0.2:
+  color@5.0.3:
     dependencies:
-      color-convert: 3.1.2
-      color-string: 2.1.2
+      color-convert: 3.1.3
+      color-string: 2.1.4
 
   commist@3.2.0: {}
 
@@ -1984,7 +1983,7 @@ snapshots:
       shebang-command: 2.0.0
       which: 2.0.2
 
-  debounce@2.2.0: {}
+  debounce@3.0.0: {}
 
   debug@4.4.0:
     dependencies:
@@ -2088,14 +2087,14 @@ snapshots:
   file-uri-to-path@1.0.0:
     optional: true
 
-  finalhandler@2.1.0:
+  finalhandler@2.1.1:
     dependencies:
-      debug: 4.4.0
+      debug: 4.4.3
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
       parseurl: 1.3.3
-      statuses: 2.0.1
+      statuses: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
@@ -2111,7 +2110,7 @@ snapshots:
   fsevents@2.3.3:
     optional: true
 
-  glob@10.4.5:
+  glob@10.5.0:
     dependencies:
       foreground-child: 3.3.1
       jackspeak: 3.4.3
@@ -2120,14 +2119,11 @@ snapshots:
       package-json-from-dist: 1.0.1
       path-scurry: 1.11.1
 
-  glob@11.0.3:
+  glob@13.0.0:
     dependencies:
-      foreground-child: 3.3.1
-      jackspeak: 4.1.1
       minimatch: 10.1.1
       minipass: 7.1.2
-      package-json-from-dist: 1.0.1
-      path-scurry: 2.0.0
+      path-scurry: 2.0.1
 
   glossy@0.1.7: {}
 
@@ -2145,9 +2141,9 @@ snapshots:
       statuses: 2.0.1
       toidentifier: 1.0.1
 
-  humanize-duration@3.33.1: {}
+  humanize-duration@3.33.2: {}
 
-  iconv-lite@0.7.0:
+  iconv-lite@0.7.1:
     dependencies:
       safer-buffer: 2.1.2
 
@@ -2194,15 +2190,11 @@ snapshots:
     optionalDependencies:
       '@pkgjs/parseargs': 0.11.0
 
-  jackspeak@4.1.1:
-    dependencies:
-      '@isaacs/cliui': 8.0.2
-
   js-sdsl@4.3.0: {}
 
   js-tokens@9.0.1: {}
 
-  js-yaml@4.1.0:
+  js-yaml@4.1.1:
     dependencies:
       argparse: 2.0.1
 
@@ -2282,7 +2274,7 @@ snapshots:
 
   mqtt@5.14.1:
     dependencies:
-      '@types/readable-stream': 4.0.22
+      '@types/readable-stream': 4.0.23
       '@types/ws': 8.18.1
       commist: 3.2.0
       concat-stream: 2.0.0
@@ -2349,7 +2341,7 @@ snapshots:
       lru-cache: 10.4.3
       minipass: 7.1.2
 
-  path-scurry@2.0.0:
+  path-scurry@2.0.1:
     dependencies:
       lru-cache: 11.2.2
       minipass: 7.1.2
@@ -2402,9 +2394,9 @@ snapshots:
 
   rfdc@1.4.1: {}
 
-  rimraf@6.1.0:
+  rimraf@6.1.2:
     dependencies:
-      glob: 11.0.3
+      glob: 13.0.0
       package-json-from-dist: 1.0.1
 
   rollup@4.44.0:
@@ -2455,7 +2447,7 @@ snapshots:
       ms: 2.1.3
       on-finished: 2.4.1
       range-parser: 1.2.1
-      statuses: 2.0.1
+      statuses: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
@@ -2508,6 +2500,8 @@ snapshots:
 
   statuses@2.0.1: {}
 
+  statuses@2.0.2: {}
+
   std-env@3.9.0: {}
 
   string-width@4.2.3:
@@ -2549,7 +2543,7 @@ snapshots:
   test-exclude@7.0.1:
     dependencies:
       '@istanbuljs/schema': 0.1.3
-      glob: 10.4.5
+      glob: 10.5.0
       minimatch: 9.0.5
 
   text-hex@1.0.0: {}
@@ -2601,13 +2595,13 @@ snapshots:
 
   util-deprecate@1.0.2: {}
 
-  vite-node@3.2.4(@types/node@24.9.2):
+  vite-node@3.2.4(@types/node@24.10.4):
     dependencies:
       cac: 6.7.14
       debug: 4.4.3
       es-module-lexer: 1.7.0
       pathe: 2.0.3
-      vite: 6.3.5(@types/node@24.9.2)
+      vite: 6.3.5(@types/node@24.10.4)
     transitivePeerDependencies:
       - '@types/node'
       - jiti
@@ -2622,7 +2616,7 @@ snapshots:
       - tsx
       - yaml
 
-  vite@6.3.5(@types/node@24.9.2):
+  vite@6.3.5(@types/node@24.10.4):
     dependencies:
       esbuild: 0.25.5
       fdir: 6.4.6(picomatch@4.0.2)
@@ -2631,14 +2625,14 @@ snapshots:
       rollup: 4.44.0
       tinyglobby: 0.2.14
     optionalDependencies:
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
       fsevents: 2.3.3
 
-  vitest@3.2.4(@types/node@24.9.2):
+  vitest@3.2.4(@types/node@24.10.4):
     dependencies:
       '@types/chai': 5.2.2
       '@vitest/expect': 3.2.4
-      '@vitest/mocker': 3.2.4(vite@6.3.5(@types/node@24.9.2))
+      '@vitest/mocker': 3.2.4(vite@6.3.5(@types/node@24.10.4))
       '@vitest/pretty-format': 3.2.4
       '@vitest/runner': 3.2.4
       '@vitest/snapshot': 3.2.4
@@ -2656,11 +2650,11 @@ snapshots:
       tinyglobby: 0.2.14
       tinypool: 1.1.1
       tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@24.9.2)
-      vite-node: 3.2.4(@types/node@24.9.2)
+      vite: 6.3.5(@types/node@24.10.4)
+      vite-node: 3.2.4(@types/node@24.10.4)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 24.9.2
+      '@types/node': 24.10.4
     transitivePeerDependencies:
       - jiti
       - less
@@ -2684,11 +2678,11 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
-  winston-syslog@2.7.1(winston@3.18.3):
+  winston-syslog@2.7.1(winston@3.19.0):
     dependencies:
       glossy: 0.1.7
       triple-beam: 1.4.1
-      winston: 3.18.3
+      winston: 3.19.0
       winston-transport: 4.9.0
     optionalDependencies:
       unix-dgram: 2.0.6
@@ -2699,7 +2693,7 @@ snapshots:
       readable-stream: 3.6.2
       triple-beam: 1.4.1
 
-  winston@3.18.3:
+  winston@3.19.0:
     dependencies:
       '@colors/colors': 1.6.0
       '@dabh/diagnostics': 2.0.8
@@ -2754,31 +2748,31 @@ snapshots:
 
   ws@8.18.3: {}
 
-  zigbee-herdsman-converters@25.59.0:
+  zigbee-herdsman-converters@25.98.0:
     dependencies:
-      iconv-lite: 0.7.0
+      iconv-lite: 0.7.1
       semver: 7.7.3
-      zigbee-herdsman: 6.3.2
+      zigbee-herdsman: 8.0.1
     transitivePeerDependencies:
       - supports-color
 
-  zigbee-herdsman@6.3.2:
+  zigbee-herdsman@8.0.1:
     dependencies:
       '@date-fns/tz': 1.4.1
       '@serialport/bindings-cpp': 13.0.1
       '@serialport/parser-delimiter': 13.0.0
       '@serialport/stream': 13.0.0
       bonjour-service: 1.3.0
-      debounce: 2.2.0
+      debounce: 3.0.0
       fast-deep-equal: 3.1.3
       mixin-deep: 2.0.1
       slip: 1.0.2
-      zigbee-on-host: 0.1.13
+      zigbee-on-host: 0.2.4
     transitivePeerDependencies:
       - supports-color
 
-  zigbee-on-host@0.1.13: {}
+  zigbee-on-host@0.2.4: {}
 
   zigbee2mqtt-frontend@0.9.21: {}
 
-  zigbee2mqtt-windfront@2.2.3: {}
+  zigbee2mqtt-windfront@2.6.2: {}

scripts/generateChangelog.mjs

@@ -59,7 +59,13 @@ if (fs.existsSync(commitUserFile)) {
 }
 
 const definitions = definitionIndex.default.map((d) => zhc.prepareDefinition(d));
-const whiteLabels = definitions.filter((d) => d.whiteLabel).flatMap((d) => d.whiteLabel);
+const whiteLabels = definitions
+    .filter((d) => d.whiteLabel)
+    .flatMap((d) =>
+        d.whiteLabel.map((wl) => {
+            return {model: wl.model, vendor: wl.vendor ?? d.vendor, description: wl.description ?? d.description};
+        }),
+    );
 const capitalizeFirstChar = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 
 for (const changelog of changelogs) {

scripts/issueBot.mjs

@@ -0,0 +1,186 @@
+import {execSync} from "node:child_process";
+
+async function checkDuplicateIssue(github, context, name) {
+    // Search for existing issues with the same `name`
+    const searchQuery = `repo:${context.repo.owner}/${context.repo.repo} is:issue -is:pr "${name}" label:"new device support","external converter"`;
+
+    try {
+        const searchResults = await github.rest.search.issuesAndPullRequests({q: searchQuery, per_page: 100});
+
+        // Filter out the current issue and return the first duplicate found
+        const existingIssues = searchResults.data.items.filter((item) => item.number !== context.payload.issue.number).map((i) => `#${i.number}`);
+        if (existingIssues.length > 0) {
+            await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                body: `👋 Hi there! This issue appears to be a duplicate of ${existingIssues.join(", ")}
+
+This issue will be closed. Please follow the existing issue for updates.`,
+            });
+
+            await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                state: "closed",
+            });
+
+            return true;
+        }
+    } catch (error) {
+        console.error(`Error searching for duplicate issues with ${name}:`, error);
+    }
+
+    return false;
+}
+
+export async function newDeviceSupport(github, _core, context, zhcDir) {
+    const issue = context.payload.issue;
+    // Hide previous bot comments
+    const comments = await github.rest.issues.listComments({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issue.number,
+    });
+
+    for (const comment of comments.data) {
+        if (comment.user.type === "Bot" && comment.user.login === "github-actions[bot]") {
+            await github.graphql(`mutation {
+    minimizeComment(input: {subjectId: "${comment.node_id}", classifier: OUTDATED}) {
+        clientMutationId
+    }
+}`);
+        }
+    }
+
+    const titleAndBody = `${issue.title}\n\n${issue.body ?? ""}`;
+
+    // Check if Tuya manufacturer name is already supported.
+    const tuyaManufacturerNameRe = /['"](_T\w+_(\w+))['"]/g;
+    const tuyaManufacturerNames = Array.from(titleAndBody.matchAll(tuyaManufacturerNameRe), (m) => [m[1], m[2]]);
+    console.log("Found tuyaManufacturerNames", tuyaManufacturerNames);
+    if (tuyaManufacturerNames.length > 0) {
+        for (const [fullName, partialName] of tuyaManufacturerNames) {
+            if (await checkDuplicateIssue(github, context, fullName)) return;
+            const fullMatch = (() => {
+                try {
+                    return execSync(`grep -r --include="*.ts" "${fullName}" "${zhcDir}"`, {encoding: "utf8"});
+                } catch {
+                    return undefined;
+                }
+            })();
+
+            console.log(`Checking full match for '${fullName}', result: '${fullMatch}'`);
+            if (fullMatch) {
+                await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    body: `👋 Hi there! The Tuya device with manufacturer name \`${fullName}\` is already supported in the latest dev branch.
+See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.
+
+In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+                });
+                await github.rest.issues.update({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    state: "closed",
+                });
+
+                return;
+            }
+
+            const partialMatch = (() => {
+                try {
+                    return execSync(`grep -r --include="*.ts" "${partialName}" "${zhcDir}"`, {encoding: "utf8"});
+                } catch {
+                    return undefined;
+                }
+            })();
+
+            console.log(`Checking partial match for '${partialName}', result: '${partialMatch}'`);
+            if (partialMatch) {
+                const candidates = Array.from(partialMatch.matchAll(tuyaManufacturerNameRe), (m) => m[1]);
+
+                await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    body: `👋 Hi there! A similar Tuya device of which the manufacturer name also ends with \`_${partialName}\` is already supported.
+This means the device can probably be easily be supported by re-using the existing converter.
+
+I found the following matches: ${candidates.map((c) => `\`${c}\``).join(", ")}
+Try to stop Z2M, change all occurrences of \`${fullName}\` in the \`data/database.db\` to one of the matches above and start Z2M.
+
+Let us know if it works so we can support this device out-of-the-box!`,
+                });
+
+                return;
+            }
+        }
+    } else {
+        // Check if zigbee model is already supported.
+        const zigbeeModelRe = /zigbeeModel: \[['"](.+)['"]\]/g;
+        const zigbeeModels = Array.from(titleAndBody.matchAll(zigbeeModelRe), (m) => m[1]);
+
+        if (zigbeeModels.length > 0) {
+            for (const zigbeeModel of zigbeeModels) {
+                if (await checkDuplicateIssue(github, context, fullName)) return;
+                const fullMatch = (() => {
+                    try {
+                        return execSync(`grep -r --include="*.ts" '"${zigbeeModel}"' "${zhcDir}"`, {encoding: "utf8"});
+                    } catch {
+                        return undefined;
+                    }
+                })();
+
+                if (fullMatch) {
+                    await github.rest.issues.createComment({
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        issue_number: issue.number,
+                        body: `👋 Hi there! The device with zigbee model \`${zigbeeModel}\` is already supported in the latest dev branch.
+See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.
+
+In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+                    });
+                    await github.rest.issues.update({
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        issue_number: issue.number,
+                        state: "closed",
+                    });
+
+                    return;
+                }
+            }
+        }
+    }
+
+    // Create a request to pull request comment
+    await github.rest.issues.createComment({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issue.number,
+        body: `🙏 Thank you for creating this issue and sharing your external converter!
+
+In case all features work, please submit a pull request on this repository so the device can be supported out-of-the-box with the next release.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+
+If **NOT** all features work, please follow the [How To Support new devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html).
+${
+    tuyaManufacturerNames.length > 0
+        ? "Since this is a Tuya also consider [How To Support new Tuya devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/02_support_new_tuya_devices.html)."
+        : ""
+}
+
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+    });
+}

scripts/zStackEraseAllNvMem.js

@@ -91,4 +91,4 @@ if (processArgs.length !== 1) {
 
 const eraser = new ZStackNvMemEraser(processArgs[0]);
 
-eraser.start();
+void eraser.start();

test/controller.bench.ts

@@ -1,7 +1,7 @@
 import {existsSync, mkdirSync} from "node:fs";
 import stringify from "json-stable-stringify-without-jsonify";
-import {bench, describe} from "vitest";
-import {Zcl, Zdo, ZSpec} from "zigbee-herdsman";
+import {bench, describe, vi} from "vitest";
+import {type Controller, Zcl, Zdo, ZSpec} from "zigbee-herdsman";
 import type Adapter from "zigbee-herdsman/dist/adapter/adapter";
 import type {ZclPayload} from "zigbee-herdsman/dist/adapter/events";
 import {Device, InterviewState} from "zigbee-herdsman/dist/controller/model/device";
@@ -14,6 +14,48 @@ import type {RequestToResponseMap} from "zigbee-herdsman/dist/zspec/zdo/definiti
 import data from "../lib/util/data";
 import {BENCH_OPTIONS} from "./benchOptions";
 
+vi.doMock("zigbee-herdsman", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("zigbee-herdsman")>();
+    class MockHerdsman {
+        on: Controller["on"] = vi.fn();
+        start: Controller["start"] = async () => "resumed" as const;
+        stop: Controller["stop"] = async () => {};
+        isStopping: Controller["isStopping"] = () => false;
+        getCoordinatorVersion: Controller["getCoordinatorVersion"] = async () =>
+            Promise.resolve({
+                type: "Dummy",
+                meta: {revision: "9.9.9"},
+            });
+        getNetworkParameters: Controller["getNetworkParameters"] = async () => Promise.resolve({...NETWORK_PARAMS});
+        getPermitJoin: Controller["getPermitJoin"] = () => false;
+        getPermitJoinEnd: Controller["getPermitJoinEnd"] = () => undefined;
+        getDeviceByIeeeAddr: Controller["getDeviceByIeeeAddr"] = (ieeeAddr) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr);
+        getGroupByID: Controller["getGroupByID"] = (id) => ZH_GROUPS.find((group) => group.groupID === id);
+        getDevicesByType: Controller["getDevicesByType"] = (type) => ZH_DEVICES.filter((device) => device.type === type);
+        getDeviceByNetworkAddress: Controller["getDeviceByNetworkAddress"] = (networkAddress) =>
+            ZH_DEVICES.find((device) => device.networkAddress === networkAddress);
+        *getDevicesIterator(predicate: ((device: Device) => boolean) | undefined) {
+            for (const device of ZH_DEVICES) {
+                if (!predicate || predicate(device)) {
+                    yield device;
+                }
+            }
+        }
+        *getGroupsIterator(predicate: ((group: Group) => boolean) | undefined) {
+            for (const group of ZH_GROUPS) {
+                if (!predicate || predicate(group)) {
+                    yield group;
+                }
+            }
+        }
+    }
+
+    return {
+        ...actual,
+        Controller: MockHerdsman,
+    };
+});
+
 process.env.ZIGBEE2MQTT_DATA = "data-bench";
 data._testReload();
 
@@ -365,45 +407,6 @@ const initController = async () => {
         async () => {},
     );
 
-    controller.zigbee.start = async () => {
-        await controller.zigbee.resolveDevicesDefinitions();
-
-        return "resumed";
-    };
-    controller.zigbee.stop = async () => {
-        await Promise.resolve();
-    };
-    // @ts-expect-error mocking private
-    controller.zigbee.herdsman = {
-        isStopping: () => false,
-        getCoordinatorVersion: async () =>
-            Promise.resolve({
-                type: "Dummy",
-                meta: {revision: "9.9.9"},
-            }),
-        getNetworkParameters: async () => Promise.resolve({...NETWORK_PARAMS}),
-        getPermitJoin: () => false,
-        getPermitJoinEnd: () => undefined,
-        getDeviceByIeeeAddr: (ieeeAddr) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr),
-        getGroupByID: (id) => ZH_GROUPS.find((group) => group.groupID === id),
-        getDevicesByType: (type) => ZH_DEVICES.filter((device) => device.type === type),
-        getDeviceByNetworkAddress: (networkAddress) => ZH_DEVICES.find((device) => device.networkAddress === networkAddress),
-        *getDevicesIterator(predicate) {
-            for (const device of ZH_DEVICES) {
-                if (!predicate || predicate(device)) {
-                    yield device;
-                }
-            }
-        },
-        *getGroupsIterator(predicate) {
-            for (const group of ZH_GROUPS) {
-                if (!predicate || predicate(group)) {
-                    yield group;
-                }
-            }
-        },
-    };
-
     // all dummies, can trigger `controller.mqtt.onMessage(topic, message)` as needed
     // @ts-expect-error mocking private
     controller.mqtt.client = {

test/extensions/bind.test.ts

@@ -795,4 +795,84 @@ describe("Extension: Bind", () => {
         // Should only call Hue bulb, not e.g. tradfri
         expect(devices.bulb_2.getEndpoint(1)!.read).toHaveBeenCalledTimes(0);
     });
+
+    it("clears all bindings", async () => {
+        const device = devices.remote;
+
+        device.mockClear();
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/binds/clear", stringify({transaction: "1234", target: "remote"}));
+        await flushPromises();
+
+        expect(device.clearAllBindings).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/binds/clear",
+            stringify({
+                transaction: "1234",
+                data: {
+                    target: "remote",
+                    ieee_list: ["0xffffffffffffffff"],
+                },
+                status: "ok",
+            }),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), {retain: true});
+    });
+
+    it("clears targeted bindings", async () => {
+        const device = devices.remote;
+        const target = devices.bulb_color;
+
+        device.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/binds/clear",
+            stringify({transaction: "1234", target: "remote", ieee_list: [target.ieeeAddr]}),
+        );
+        await flushPromises();
+
+        expect(device.clearAllBindings).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/binds/clear",
+            stringify({
+                transaction: "1234",
+                data: {
+                    target: "remote",
+                    ieee_list: [target.ieeeAddr],
+                },
+                status: "ok",
+            }),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), {retain: true});
+    });
+
+    it("throw on invalid clears bindings payload", async () => {
+        const device = devices.remote;
+
+        device.mockClear();
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/binds/clear", stringify({targetz: "remote"}));
+        await flushPromises();
+
+        expect(device.clearAllBindings).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/binds/clear",
+            stringify({data: {}, status: "error", error: "Invalid payload"}),
+            {},
+        );
+    });
+
+    it("throw on invalid clears bindings target", async () => {
+        const device = devices.remote;
+
+        device.mockClear();
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/binds/clear", stringify({target: "remotez"}));
+        await flushPromises();
+
+        expect(device.clearAllBindings).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/binds/clear",
+            stringify({data: {}, status: "error", error: "Invalid target"}),
+            {},
+        );
+    });
 });

test/extensions/bridge.test.ts

@@ -1,5 +1,6 @@
 // biome-ignore assist/source/organizeImports: import mocks first
 import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import {Zdo} from "zigbee-herdsman";
 import * as data from "../mocks/data";
 import {mockJSZipFile, mockJSZipGenerateAsync} from "../mocks/jszip";
 import {mockLogger} from "../mocks/logger";
@@ -17,6 +18,7 @@ import {Controller} from "../../lib/controller";
 import Bridge from "../../lib/extension/bridge";
 import * as settings from "../../lib/util/settings";
 import utils, {DEFAULT_BIND_GROUP_ID} from "../../lib/util/utils";
+import {Zcl} from "zigbee-herdsman";
 
 returnDevices.push(devices.coordinator.ieeeAddr);
 returnDevices.push(devices.bulb.ieeeAddr);
@@ -162,6 +164,7 @@ describe("Extension: Bridge", () => {
                         "0x0017880104a44559": {friendly_name: "J1_cover"},
                         "0x0017880104e43559": {friendly_name: "U202DST600ZB"},
                         "0x0017880104e44559": {friendly_name: "3157100_thermostat"},
+                        "0x18fc2600000d7ae3": {friendly_name: "bosch_rm230z"},
                         "0x0017880104e45517": {friendly_name: "remote", retain: true},
                         "0x0017880104e45520": {friendly_name: "button", retain: false},
                         "0x0017880104e45521": {
@@ -545,6 +548,7 @@ describe("Extension: Bridge", () => {
                                 property: "transition",
                                 type: "numeric",
                                 value_min: 0,
+                                value_step: 0.1,
                             },
                             {
                                 access: 2,
@@ -771,6 +775,7 @@ describe("Extension: Bridge", () => {
                                 property: "transition",
                                 type: "numeric",
                                 value_min: 0,
+                                value_step: 0.1,
                             },
                             {
                                 access: 2,
@@ -1883,6 +1888,7 @@ describe("Extension: Bridge", () => {
                                 property: "transition",
                                 type: "numeric",
                                 value_min: 0,
+                                value_step: 0.1,
                             },
                             {
                                 access: 2,
@@ -2149,6 +2155,7 @@ describe("Extension: Bridge", () => {
                                 property: "transition",
                                 type: "numeric",
                                 value_min: 0,
+                                value_step: 0.1,
                             },
                             {
                                 access: 2,
@@ -2583,6 +2590,7 @@ describe("Extension: Bridge", () => {
                                 property: "transition",
                                 type: "numeric",
                                 value_min: 0,
+                                value_step: 0.1,
                             },
                             {
                                 access: 2,
@@ -3532,11 +3540,11 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to touchlink factory reset (succeeds)", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkFactoryResetFirst.mockClear();
-        mockZHController.touchlinkFactoryResetFirst.mockReturnValueOnce(true);
+        mockZHController.touchlink.factoryResetFirst.mockClear();
+        mockZHController.touchlink.factoryResetFirst.mockReturnValueOnce(true);
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/factory_reset", "");
         await flushPromises();
-        expect(mockZHController.touchlinkFactoryResetFirst).toHaveBeenCalledTimes(1);
+        expect(mockZHController.touchlink.factoryResetFirst).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/factory_reset",
             stringify({data: {}, status: "ok"}),
@@ -3546,12 +3554,12 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to touchlink factory reset specific device", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkFactoryReset.mockClear();
-        mockZHController.touchlinkFactoryReset.mockReturnValueOnce(true);
+        mockZHController.touchlink.factoryReset.mockClear();
+        mockZHController.touchlink.factoryReset.mockReturnValueOnce(true);
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/factory_reset", stringify({ieee_address: "0x1239", channel: 12}));
         await flushPromises();
-        expect(mockZHController.touchlinkFactoryReset).toHaveBeenCalledTimes(1);
-        expect(mockZHController.touchlinkFactoryReset).toHaveBeenCalledWith("0x1239", 12);
+        expect(mockZHController.touchlink.factoryReset).toHaveBeenCalledTimes(1);
+        expect(mockZHController.touchlink.factoryReset).toHaveBeenCalledWith("0x1239", 12);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/factory_reset",
             stringify({data: {ieee_address: "0x1239", channel: 12}, status: "ok"}),
@@ -3602,11 +3610,11 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to touchlink identify specific device", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkIdentify.mockClear();
+        mockZHController.touchlink.identify.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/identify", stringify({ieee_address: "0x1239", channel: 12}));
         await flushPromises();
-        expect(mockZHController.touchlinkIdentify).toHaveBeenCalledTimes(1);
-        expect(mockZHController.touchlinkIdentify).toHaveBeenCalledWith("0x1239", 12);
+        expect(mockZHController.touchlink.identify).toHaveBeenCalledTimes(1);
+        expect(mockZHController.touchlink.identify).toHaveBeenCalledWith("0x1239", 12);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/identify",
             stringify({data: {ieee_address: "0x1239", channel: 12}, status: "ok"}),
@@ -3616,10 +3624,10 @@ describe("Extension: Bridge", () => {
 
     it("Touchlink identify fails when payload is invalid", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkIdentify.mockClear();
+        mockZHController.touchlink.identify.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/identify", stringify({ieee_address: "0x1239"}));
         await flushPromises();
-        expect(mockZHController.touchlinkIdentify).toHaveBeenCalledTimes(0);
+        expect(mockZHController.touchlink.identify).toHaveBeenCalledTimes(0);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/identify",
             stringify({data: {}, status: "error", error: "Invalid payload"}),
@@ -3629,11 +3637,11 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to touchlink factory reset (fails)", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkFactoryResetFirst.mockClear();
-        mockZHController.touchlinkFactoryResetFirst.mockReturnValueOnce(false);
+        mockZHController.touchlink.factoryResetFirst.mockClear();
+        mockZHController.touchlink.factoryResetFirst.mockReturnValueOnce(false);
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/factory_reset", "");
         await flushPromises();
-        expect(mockZHController.touchlinkFactoryResetFirst).toHaveBeenCalledTimes(1);
+        expect(mockZHController.touchlink.factoryResetFirst).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/factory_reset",
             stringify({data: {}, status: "error", error: "Failed to factory reset device through Touchlink"}),
@@ -3643,14 +3651,14 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to touchlink scan", async () => {
         mockMQTTPublishAsync.mockClear();
-        mockZHController.touchlinkScan.mockClear();
-        mockZHController.touchlinkScan.mockReturnValueOnce([
+        mockZHController.touchlink.scan.mockClear();
+        mockZHController.touchlink.scan.mockReturnValueOnce([
             {ieeeAddr: "0x123", channel: 12},
             {ieeeAddr: "0x124", channel: 24},
         ]);
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/touchlink/scan", "");
         await flushPromises();
-        expect(mockZHController.touchlinkScan).toHaveBeenCalledTimes(1);
+        expect(mockZHController.touchlink.scan).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/touchlink/scan",
             stringify({
@@ -3673,7 +3681,7 @@ describe("Extension: Bridge", () => {
         endpoint.configureReporting.mockClear();
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
-            "zigbee2mqtt/bridge/request/device/configure_reporting",
+            "zigbee2mqtt/bridge/request/device/reporting/configure",
             stringify({
                 id: "0x000b57fffec6a5b2",
                 endpoint: 1,
@@ -3694,7 +3702,7 @@ describe("Extension: Bridge", () => {
             undefined,
         );
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure_reporting",
+            "zigbee2mqtt/bridge/response/device/reporting/configure",
             stringify({
                 data: {
                     id: "0x000b57fffec6a5b2",
@@ -3719,7 +3727,7 @@ describe("Extension: Bridge", () => {
         endpoint.configureReporting.mockClear();
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
-            "zigbee2mqtt/bridge/request/device/configure_reporting",
+            "zigbee2mqtt/bridge/request/device/reporting/configure",
             stringify({
                 id: "0x000b57fffec6a5b2",
                 endpoint: "1",
@@ -3740,7 +3748,7 @@ describe("Extension: Bridge", () => {
             undefined,
         );
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure_reporting",
+            "zigbee2mqtt/bridge/response/device/reporting/configure",
             stringify({
                 data: {
                     id: "0x000b57fffec6a5b2",
@@ -3764,7 +3772,7 @@ describe("Extension: Bridge", () => {
         endpoint.configureReporting.mockClear();
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
-            "zigbee2mqtt/bridge/request/device/configure_reporting",
+            "zigbee2mqtt/bridge/request/device/reporting/configure",
             stringify({
                 id: "bulb",
                 // endpoint: '1',
@@ -3778,7 +3786,7 @@ describe("Extension: Bridge", () => {
         await flushPromises();
         expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure_reporting",
+            "zigbee2mqtt/bridge/response/device/reporting/configure",
             stringify({data: {}, status: "error", error: "Invalid payload"}),
             {},
         );
@@ -3790,7 +3798,7 @@ describe("Extension: Bridge", () => {
         endpoint.configureReporting.mockClear();
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
-            "zigbee2mqtt/bridge/request/device/configure_reporting",
+            "zigbee2mqtt/bridge/request/device/reporting/configure",
             stringify({
                 id: "non_existing_device",
                 endpoint: "1",
@@ -3804,7 +3812,7 @@ describe("Extension: Bridge", () => {
         await flushPromises();
         expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure_reporting",
+            "zigbee2mqtt/bridge/response/device/reporting/configure",
             stringify({data: {}, status: "error", error: "Device 'non_existing_device' does not exist"}),
             {},
         );
@@ -3816,7 +3824,7 @@ describe("Extension: Bridge", () => {
         endpoint.configureReporting.mockClear();
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
-            "zigbee2mqtt/bridge/request/device/configure_reporting",
+            "zigbee2mqtt/bridge/request/device/reporting/configure",
             stringify({
                 id: "0x000b57fffec6a5b2",
                 endpoint: "non_existing_endpoint",
@@ -3830,7 +3838,243 @@ describe("Extension: Bridge", () => {
         await flushPromises();
         expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure_reporting",
+            "zigbee2mqtt/bridge/response/device/reporting/configure",
+            stringify({data: {}, status: "error", error: "Device '0x000b57fffec6a5b2' does not have endpoint 'non_existing_endpoint'"}),
+            {},
+        );
+    });
+
+    it("Should allow to read reporting config with endpoint as number", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.bind.mockClear();
+        endpoint.readReportingConfig.mockClear();
+        endpoint.readReportingConfig.mockResolvedValueOnce([
+            {
+                status: Zcl.Status.SUCCESS,
+                direction: Zcl.Direction.CLIENT_TO_SERVER,
+                attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                dataType: Zcl.DataType.UINT8,
+                minRepIntval: 10,
+                maxRepIntval: 60,
+                repChange: 2,
+            },
+        ]);
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "0x000b57fffec6a5b2",
+                endpoint: 1,
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(1);
+        expect(endpoint.readReportingConfig).toHaveBeenCalledWith("genLevelCtrl", [{attribute: "currentLevel"}], {});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
+            stringify({
+                data: {
+                    id: "0x000b57fffec6a5b2",
+                    endpoint: 1,
+                    cluster: "genLevelCtrl",
+                    configs: [
+                        {
+                            status: Zcl.Status.SUCCESS,
+                            direction: Zcl.Direction.CLIENT_TO_SERVER,
+                            attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                            dataType: Zcl.DataType.UINT8,
+                            minRepIntval: 10,
+                            maxRepIntval: 60,
+                            repChange: 2,
+                        },
+                    ],
+                },
+                status: "ok",
+            }),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), {retain: true});
+    });
+
+    it("Should allow to read reporting config with endpoint as string", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.bind.mockClear();
+        endpoint.readReportingConfig.mockClear();
+        endpoint.readReportingConfig.mockResolvedValueOnce([
+            {
+                status: Zcl.Status.SUCCESS,
+                direction: Zcl.Direction.CLIENT_TO_SERVER,
+                attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                dataType: Zcl.DataType.UINT8,
+                minRepIntval: 10,
+                maxRepIntval: 60,
+                repChange: 2,
+            },
+        ]);
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "0x000b57fffec6a5b2",
+                endpoint: "1",
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(1);
+        expect(endpoint.readReportingConfig).toHaveBeenCalledWith("genLevelCtrl", [{attribute: "currentLevel"}], {});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
+            stringify({
+                data: {
+                    id: "0x000b57fffec6a5b2",
+                    endpoint: "1",
+                    cluster: "genLevelCtrl",
+                    configs: [
+                        {
+                            status: Zcl.Status.SUCCESS,
+                            direction: Zcl.Direction.CLIENT_TO_SERVER,
+                            attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                            dataType: Zcl.DataType.UINT8,
+                            minRepIntval: 10,
+                            maxRepIntval: 60,
+                            repChange: 2,
+                        },
+                    ],
+                },
+                status: "ok",
+            }),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), {retain: true});
+    });
+
+    it("Should allow to read reporting config with manufacturer code", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.bind.mockClear();
+        endpoint.readReportingConfig.mockClear();
+        endpoint.readReportingConfig.mockResolvedValueOnce([
+            {
+                status: Zcl.Status.SUCCESS,
+                direction: Zcl.Direction.CLIENT_TO_SERVER,
+                attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                dataType: Zcl.DataType.UINT8,
+                minRepIntval: 10,
+                maxRepIntval: 60,
+                repChange: 2,
+            },
+        ]);
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "0x000b57fffec6a5b2",
+                endpoint: 1,
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+                manufacturer_code: 0x1234,
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(1);
+        expect(endpoint.readReportingConfig).toHaveBeenCalledWith("genLevelCtrl", [{attribute: "currentLevel"}], {manufacturerCode: 0x1234});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
+            stringify({
+                data: {
+                    id: "0x000b57fffec6a5b2",
+                    endpoint: 1,
+                    cluster: "genLevelCtrl",
+                    configs: [
+                        {
+                            status: Zcl.Status.SUCCESS,
+                            direction: Zcl.Direction.CLIENT_TO_SERVER,
+                            attrId: Zcl.Clusters.genLevelCtrl.attributes.currentLevel.ID,
+                            dataType: Zcl.DataType.UINT8,
+                            minRepIntval: 10,
+                            maxRepIntval: 60,
+                            repChange: 2,
+                        },
+                    ],
+                    manufacturer_code: 0x1234,
+                },
+                status: "ok",
+            }),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), {retain: true});
+    });
+
+    it("Should throw error when read reporting config is called with malformed payload", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.readReportingConfig.mockClear();
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "bulb",
+                // endpoint: '1',
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
+            stringify({data: {}, status: "error", error: "Invalid payload"}),
+            {},
+        );
+    });
+
+    it("Should throw error when read reporting config is called for non-existing device", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.readReportingConfig.mockClear();
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "non_existing_device",
+                endpoint: "1",
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
+            stringify({data: {}, status: "error", error: "Device 'non_existing_device' does not exist"}),
+            {},
+        );
+    });
+
+    it("Should throw error when read reporting config is called for non-existing endpoint", async () => {
+        const device = devices.bulb;
+        const endpoint = device.getEndpoint(1)!;
+        endpoint.readReportingConfig.mockClear();
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/device/reporting/read",
+            stringify({
+                id: "0x000b57fffec6a5b2",
+                endpoint: "non_existing_endpoint",
+                cluster: "genLevelCtrl",
+                configs: [{attribute: "currentLevel"}],
+            }),
+        );
+        await flushPromises();
+        expect(endpoint.readReportingConfig).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/reporting/read",
             stringify({data: {}, status: "error", error: "Device '0x000b57fffec6a5b2' does not have endpoint 'non_existing_endpoint'"}),
             {},
         );
@@ -4106,4 +4350,97 @@ describe("Extension: Bridge", () => {
         });
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/response/device/configure", expect.any(String), {});
     });
+
+    it("triggers ZHC action by name with params", async () => {
+        mockMQTTPublishAsync.mockClear();
+
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/action",
+            JSON.stringify({
+                action: "raw",
+                params: {
+                    profileId: Zdo.ZDO_PROFILE_ID,
+                    ieeeAddress: "0xf1f2f3f4f5f6f7f8",
+                    networkAddress: 0x1234,
+                    clusterKey: Zdo.ClusterId.NETWORK_ADDRESS_REQUEST,
+                    zdoParams: ["0xa1a2a3a4a5a6a7a8", false, 0],
+                },
+            }),
+        );
+        await flushPromises();
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/action",
+            JSON.stringify({data: [0x00, {assocDevList: [], eui64: "", nwkAddress: 0x1234, startIndex: 0}], status: "ok"}),
+            {},
+        );
+    });
+
+    it("triggers ZHC action by name without params", async () => {
+        mockMQTTPublishAsync.mockClear();
+
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/action",
+            JSON.stringify({
+                action: "raw",
+            }),
+        );
+        await flushPromises();
+
+        // we're mocking the response, so it's always this as long as the action & payload are valid
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/action",
+            JSON.stringify({data: [0x00, {assocDevList: [], eui64: "", nwkAddress: 0x1234, startIndex: 0}], status: "ok"}),
+            {},
+        );
+    });
+
+    it("throws on invalid action payload", async () => {
+        mockMQTTPublishAsync.mockClear();
+
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/action",
+            JSON.stringify({
+                params: {
+                    profileId: Zdo.ZDO_PROFILE_ID,
+                    ieeeAddress: "0xf1f2f3f4f5f6f7f8",
+                    networkAddress: 0x1234,
+                    clusterKey: Zdo.ClusterId.NETWORK_ADDRESS_REQUEST,
+                    zdoParams: ["0xa1a2a3a4a5a6a7a8", false, 0],
+                },
+            }),
+        );
+        await flushPromises();
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/action",
+            stringify({data: {}, status: "error", error: "Invalid payload"}),
+            {},
+        );
+    });
+
+    it("throws on invalid action", async () => {
+        mockMQTTPublishAsync.mockClear();
+
+        mockMQTTEvents.message(
+            "zigbee2mqtt/bridge/request/action",
+            JSON.stringify({
+                action: "DOES_NOT_EXIST",
+                params: {
+                    profileId: Zdo.ZDO_PROFILE_ID,
+                    ieeeAddress: "0xf1f2f3f4f5f6f7f8",
+                    networkAddress: 0x1234,
+                    clusterKey: Zdo.ClusterId.NETWORK_ADDRESS_REQUEST,
+                    zdoParams: ["0xa1a2a3a4a5a6a7a8", false, 0],
+                },
+            }),
+        );
+        await flushPromises();
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/action",
+            stringify({data: {}, status: "error", error: "Invalid action"}),
+            {},
+        );
+    });
 });

test/extensions/homeassistant.test.ts

@@ -1117,10 +1117,10 @@ describe("Extension: HomeAssistant", () => {
             },
             max_temp: "30",
             min_temp: "5",
-            mode_command_template: `{% set values = { 'auto':'schedule', 'heat':'manual', 'off':'pause' } %}{"operating_mode": "{{ values[value] if value in values.keys() else 'pause' }}"}`,
+            mode_command_template: `{% set values = { 'auto':'schedule','heat':'manual','off':'pause'} %}{"operating_mode": "{{ values[value] if value in values.keys() else 'pause' }}"}`,
             mode_command_topic: "zigbee2mqtt/bosch_radiator/set",
             mode_state_template:
-                "{% set values = { 'schedule':'auto', 'manual':'heat', 'pause':'off' } %}{% set value = value_json.operating_mode %}{{ values[value] if value in values.keys() else 'off' }}",
+                "{% set values = {'schedule':'auto','manual':'heat','pause':'off'} %}{% set value = value_json.operating_mode %}{{ values[value] if value in values.keys() else 'off' }}",
             mode_state_topic: "zigbee2mqtt/bosch_radiator",
             modes: ["off", "heat", "auto"],
             name: null,
@@ -1197,6 +1197,51 @@ describe("Extension: HomeAssistant", () => {
         overrideSpy.mockRestore();
     });
 
+    it("Should discover Bosch BTH-RM230Z with a current_humidity attribute", () => {
+        const payload = {
+            action_template:
+                "{% set values = {None:None,'idle':'idle','heat':'heating','cool':'cooling','fan_only':'fan'} %}{{ values[value_json.running_state] }}",
+            action_topic: "zigbee2mqtt/bosch_rm230z",
+            availability: [{topic: "zigbee2mqtt/bridge/state", value_template: "{{ value_json.state }}"}],
+            current_humidity_template: "{{ value_json.humidity }}",
+            current_humidity_topic: "zigbee2mqtt/bosch_rm230z",
+            current_temperature_template: "{{ value_json.local_temperature }}",
+            current_temperature_topic: "zigbee2mqtt/bosch_rm230z",
+            default_entity_id: "climate.bosch_rm230z",
+            device: {
+                identifiers: ["zigbee2mqtt_0x18fc2600000d7ae3"],
+                manufacturer: "Bosch",
+                model: "Room thermostat II 230V",
+                model_id: "BTH-RM230Z",
+                name: "bosch_rm230z",
+                via_device: "zigbee2mqtt_bridge_0x00124b00120144ae",
+            },
+            max_temp: "30",
+            min_temp: "5",
+            mode_command_topic: "zigbee2mqtt/bosch_rm230z/set/system_mode",
+            mode_state_template: "{{ value_json.system_mode }}",
+            mode_state_topic: "zigbee2mqtt/bosch_rm230z",
+            modes: ["off", "heat", "cool"],
+            name: null,
+            object_id: "bosch_rm230z",
+            origin,
+            temp_step: 0.5,
+            temperature_high_command_topic: "zigbee2mqtt/bosch_rm230z/set/occupied_cooling_setpoint",
+            temperature_high_state_template: "{{ value_json.occupied_cooling_setpoint }}",
+            temperature_high_state_topic: "zigbee2mqtt/bosch_rm230z",
+            temperature_low_command_topic: "zigbee2mqtt/bosch_rm230z/set/occupied_heating_setpoint",
+            temperature_low_state_template: "{{ value_json.occupied_heating_setpoint }}",
+            temperature_low_state_topic: "zigbee2mqtt/bosch_rm230z",
+            temperature_unit: "C",
+            unique_id: "0x18fc2600000d7ae3_climate_zigbee2mqtt",
+        };
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("homeassistant/climate/0x18fc2600000d7ae3/climate/config", stringify(payload), {
+            qos: 1,
+            retain: true,
+        });
+    });
+
     it("Should discover devices with cover_position", () => {
         let payload;
 

test/extensions/networkMap.test.ts

@@ -1,5 +1,6 @@
 // biome-ignore assist/source/organizeImports: import mocks first
 import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import type {Eui64} from "zigbee-herdsman/dist/zspec/tstypes";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -25,6 +26,22 @@ returnDevices.push(
 
 const mocksClear = [mockMQTTPublishAsync, mockLogger.warning, mockLogger.debug];
 
+const LQI_BASE_RSP = {
+    extendedPanId: [],
+    deviceType: 0,
+    rxOnWhenIdle: 0,
+    reserved1: 0,
+    permitJoining: 0,
+    reserved2: 0,
+};
+
+const ROUTING_BASE_RSP = {
+    memoryConstrained: 0,
+    manyToOne: 0,
+    routeRecordRequired: 0,
+    reserved1: 0,
+};
+
 describe("Extension: NetworkMap", () => {
     let controller: Controller;
 
@@ -39,58 +56,62 @@ describe("Extension: NetworkMap", () => {
          *                    |  -> CC2530_ROUTER -> WXKG02LM_rev1
          *
          */
-        devices.coordinator.lqi.mockResolvedValueOnce({
-            neighbors: [
-                {
-                    ieeeAddr: devices.bulb_color.ieeeAddr,
-                    networkAddress: devices.bulb_color.networkAddress,
-                    relationship: 2,
-                    depth: 1,
-                    linkquality: 120,
-                },
-                {ieeeAddr: devices.bulb.ieeeAddr, networkAddress: devices.bulb.networkAddress, relationship: 2, depth: 1, linkquality: 92},
-                {
-                    ieeeAddr: devices.external_converter_device.ieeeAddr,
-                    networkAddress: devices.external_converter_device.networkAddress,
-                    relationship: 2,
-                    depth: 1,
-                    linkquality: 92,
-                },
-            ],
-        });
-        devices.coordinator.routingTable.mockResolvedValueOnce({
-            table: [{destinationAddress: devices.CC2530_ROUTER.networkAddress, status: "ACTIVE", nextHop: devices.bulb.networkAddress}],
-        });
-        devices.bulb.lqi.mockResolvedValueOnce({
-            neighbors: [
-                {
-                    ieeeAddr: devices.bulb_color.ieeeAddr,
-                    networkAddress: devices.bulb_color.networkAddress,
-                    relationship: 1,
-                    depth: 2,
-                    linkquality: 110,
-                },
-                {
-                    ieeeAddr: devices.CC2530_ROUTER.ieeeAddr,
-                    networkAddress: devices.CC2530_ROUTER.networkAddress,
-                    relationship: 1,
-                    depth: 2,
-                    linkquality: 100,
-                },
-            ],
-        });
-        devices.CC2530_ROUTER.lqi.mockResolvedValueOnce({
-            neighbors: [
-                {ieeeAddr: "0x0000000000000000", networkAddress: devices.WXKG02LM_rev1.networkAddress, relationship: 1, depth: 2, linkquality: 130},
-                {
-                    ieeeAddr: devices.bulb_color.ieeeAddr,
-                    networkAddress: devices.bulb_color.networkAddress,
-                    relationship: 4,
-                    depth: 2,
-                    linkquality: 130,
-                },
-            ],
-        });
+        devices.coordinator.lqi.mockResolvedValueOnce([
+            {
+                eui64: devices.bulb_color.ieeeAddr as Eui64,
+                nwkAddress: devices.bulb_color.networkAddress,
+                relationship: 2,
+                depth: 1,
+                lqi: 120,
+                ...LQI_BASE_RSP,
+            },
+            {eui64: devices.bulb.ieeeAddr as Eui64, nwkAddress: devices.bulb.networkAddress, relationship: 2, depth: 1, lqi: 92, ...LQI_BASE_RSP},
+            {
+                eui64: devices.external_converter_device.ieeeAddr as Eui64,
+                nwkAddress: devices.external_converter_device.networkAddress,
+                relationship: 2,
+                depth: 1,
+                lqi: 92,
+                ...LQI_BASE_RSP,
+            },
+        ]);
+        devices.coordinator.routingTable.mockResolvedValueOnce([
+            {
+                destinationAddress: devices.CC2530_ROUTER.networkAddress,
+                status: "ACTIVE",
+                nextHopAddress: devices.bulb.networkAddress,
+                ...ROUTING_BASE_RSP,
+            },
+        ]);
+        devices.bulb.lqi.mockResolvedValueOnce([
+            {
+                eui64: devices.bulb_color.ieeeAddr as Eui64,
+                nwkAddress: devices.bulb_color.networkAddress,
+                relationship: 1,
+                depth: 2,
+                lqi: 110,
+                ...LQI_BASE_RSP,
+            },
+            {
+                eui64: devices.CC2530_ROUTER.ieeeAddr as Eui64,
+                nwkAddress: devices.CC2530_ROUTER.networkAddress,
+                relationship: 1,
+                depth: 2,
+                lqi: 100,
+                ...LQI_BASE_RSP,
+            },
+        ]);
+        devices.CC2530_ROUTER.lqi.mockResolvedValueOnce([
+            {eui64: "0x0000000000000000", nwkAddress: devices.WXKG02LM_rev1.networkAddress, relationship: 1, depth: 2, lqi: 130, ...LQI_BASE_RSP},
+            {
+                eui64: devices.bulb_color.ieeeAddr as Eui64,
+                nwkAddress: devices.bulb_color.networkAddress,
+                relationship: 4,
+                depth: 2,
+                lqi: 130,
+                ...LQI_BASE_RSP,
+            },
+        ]);
         devices.unsupported_router.lqi.mockRejectedValueOnce("failed").mockRejectedValueOnce("failed");
         devices.unsupported_router.routingTable.mockRejectedValueOnce("failed").mockRejectedValueOnce("failed");
     };
@@ -143,6 +164,9 @@ describe("Extension: NetworkMap", () => {
                 value: {
                     links: [
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 120,
                             lqi: 120,
@@ -155,11 +179,14 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
                             relationship: 2,
-                            routes: [{destinationAddress: 6540, nextHop: 40369, status: "ACTIVE"}],
+                            routes: [{destinationAddress: 6540, nextHopAddress: 40369, status: "ACTIVE", ...ROUTING_BASE_RSP}],
                             source: {ieeeAddr: "0x000b57fffec6a5b2", networkAddress: 40369},
                             sourceIeeeAddr: "0x000b57fffec6a5b2",
                             sourceNwkAddr: 40369,
@@ -167,6 +194,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
@@ -179,6 +209,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 2,
                             linkquality: 110,
                             lqi: 110,
@@ -191,6 +224,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x000b57fffec6a5b2",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 2,
                             linkquality: 100,
                             lqi: 100,
@@ -203,6 +239,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x000b57fffec6a5b2",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 2,
                             linkquality: 130,
                             lqi: 130,
@@ -492,6 +531,9 @@ describe("Extension: NetworkMap", () => {
                 value: {
                     links: [
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 120,
                             lqi: 120,
@@ -504,11 +546,14 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
                             relationship: 2,
-                            routes: [{destinationAddress: 6540, nextHop: 40369, status: "ACTIVE"}],
+                            routes: [{destinationAddress: 6540, nextHopAddress: 40369, status: "ACTIVE", ...ROUTING_BASE_RSP}],
                             source: {ieeeAddr: "0x000b57fffec6a5b2", networkAddress: 40369},
                             sourceIeeeAddr: "0x000b57fffec6a5b2",
                             sourceNwkAddr: 40369,
@@ -516,6 +561,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
@@ -528,6 +576,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 2,
                             linkquality: 130,
                             lqi: 130,
@@ -649,6 +700,9 @@ describe("Extension: NetworkMap", () => {
                 value: {
                     links: [
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 120,
                             lqi: 120,
@@ -661,11 +715,14 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
                             relationship: 2,
-                            routes: [{destinationAddress: 6540, nextHop: 40369, status: "ACTIVE"}],
+                            routes: [{destinationAddress: 6540, nextHopAddress: 40369, status: "ACTIVE", ...ROUTING_BASE_RSP}],
                             source: {ieeeAddr: "0x000b57fffec6a5b2", networkAddress: 40369},
                             sourceIeeeAddr: "0x000b57fffec6a5b2",
                             sourceNwkAddr: 40369,
@@ -673,6 +730,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 1,
                             linkquality: 92,
                             lqi: 92,
@@ -685,6 +745,9 @@ describe("Extension: NetworkMap", () => {
                             targetIeeeAddr: "0x00124b00120144ae",
                         },
                         {
+                            deviceType: 0,
+                            rxOnWhenIdle: 0,
+                            permitJoining: 0,
                             depth: 2,
                             linkquality: 130,
                             lqi: 130,

test/extensions/otaUpdate.test.ts

@@ -276,50 +276,55 @@ describe("Extension: OTAUpdate", () => {
         );
     });
 
-    it.each(["check", "check/downgrade", "update", "update/downgrade", "schedule", "schedule/downgrade", "unschedule"])(
-        "refuses to %s when already in progress",
-        async (type) => {
-            if (type.includes("schedule") || type.includes("check")) {
-                isUpdateAvailableSpy.mockImplementationOnce(async () => {
-                    return await new Promise((resolve) => {
-                        setTimeout(
-                            () =>
-                                resolve({
-                                    available: false,
-                                    currentFileVersion: 1,
-                                    otaFileVersion: 1,
-                                }),
-                            99999,
-                        );
-                    });
+    it.each([
+        "check",
+        "check/downgrade",
+        "update",
+        "update/downgrade",
+        "schedule",
+        "schedule/downgrade",
+        "unschedule",
+    ])("refuses to %s when already in progress", async (type) => {
+        if (type.includes("schedule") || type.includes("check")) {
+            isUpdateAvailableSpy.mockImplementationOnce(async () => {
+                return await new Promise((resolve) => {
+                    setTimeout(
+                        () =>
+                            resolve({
+                                available: false,
+                                currentFileVersion: 1,
+                                otaFileVersion: 1,
+                            }),
+                        99999,
+                    );
                 });
-            } else {
-                updateSpy.mockImplementationOnce(async () => {
-                    return await new Promise((resolve) => {
-                        setTimeout(() => resolve(1), 99999);
-                    });
+            });
+        } else {
+            updateSpy.mockImplementationOnce(async () => {
+                return await new Promise((resolve) => {
+                    setTimeout(() => resolve(1), 99999);
                 });
-            }
+            });
+        }
 
-            mockMQTTEvents.message(`zigbee2mqtt/bridge/request/device/ota_update/${type.includes("schedule") ? "check" : type}`, "bulb");
-            await flushPromises();
-            mockMQTTEvents.message(`zigbee2mqtt/bridge/request/device/ota_update/${type}`, "bulb");
-            await flushPromises();
+        mockMQTTEvents.message(`zigbee2mqtt/bridge/request/device/ota_update/${type.includes("schedule") ? "check" : type}`, "bulb");
+        await flushPromises();
+        mockMQTTEvents.message(`zigbee2mqtt/bridge/request/device/ota_update/${type}`, "bulb");
+        await flushPromises();
 
-            if (type.includes("schedule") || type.includes("check")) {
-                expect(isUpdateAvailableSpy).toHaveBeenCalledTimes(1);
-            } else {
-                expect(updateSpy).toHaveBeenCalledTimes(1);
-            }
+        if (type.includes("schedule") || type.includes("check")) {
+            expect(isUpdateAvailableSpy).toHaveBeenCalledTimes(1);
+        } else {
+            expect(updateSpy).toHaveBeenCalledTimes(1);
+        }
 
-            await vi.runOnlyPendingTimersAsync();
-            expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-                `zigbee2mqtt/bridge/response/device/ota_update/${type.replace("/downgrade", "")}`,
-                stringify({data: {}, status: "error", error: `Update or check for update already in progress for 'bulb'`}),
-                {},
-            );
-        },
-    );
+        await vi.runOnlyPendingTimersAsync();
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            `zigbee2mqtt/bridge/response/device/ota_update/${type.replace("/downgrade", "")}`,
+            stringify({data: {}, status: "error", error: `Update or check for update already in progress for 'bulb'`}),
+            {},
+        );
+    });
 
     it("does not crash when read modelID before/after OTA update fails", async () => {
         devices.bulb.endpoints[0].read.mockRejectedValueOnce("Failed from").mockRejectedValueOnce("Failed to");

test/extensions/publish.test.ts

@@ -73,7 +73,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness: "200"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({brightness: 200, state: "ON"});
@@ -119,7 +124,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness_percent: "92"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 235, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 235, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON", brightness: 235});
@@ -132,7 +142,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness: 230}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 230, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 230, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON", brightness: 230});
@@ -145,7 +160,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color_temp: "222"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 222, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 222, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color_mode: "color_temp", color_temp: 222});
@@ -158,7 +178,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color_temp_percent: 100}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 500, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 500, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color_mode: "color_temp", color_temp: 500});
@@ -223,7 +248,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/0x0017882194e45543/set", stringify({state_l2: "ON", brightness_l2: 50}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/QS-Zigbee-D02-TRIAC-2C-LN", stringify({brightness_l2: 50, state_l2: "ON"}), {
             retain: false,
             qos: 0,
@@ -284,7 +314,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {x: 100, y: 50}}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 6553500, colory: 3276750, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color_mode: "xy", color: {x: 100, y: 50}});
@@ -298,7 +333,12 @@ describe("Extension: Publish", () => {
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
         expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 6553500, colory: 3276750, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb_color",
@@ -313,8 +353,18 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {x: 100, y: 50}, brightness: 20}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 6553500, colory: 3276750, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb_color",
@@ -329,8 +379,18 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {x: 100, y: 50}, brightness: 20, state: "ON"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 6553500, colory: 3276750, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb_color",
@@ -345,7 +405,13 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {x: 100, y: 50}, brightness: 20, state: "OFF"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command).toHaveBeenNthCalledWith(1, "lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenNthCalledWith(
+            1,
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 6553500, colory: 3276750, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(endpoint.command).toHaveBeenNthCalledWith(2, "genOnOff", "off", {}, {});
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
@@ -361,7 +427,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {r: 100, g: 200, b: 10}}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 17806, colory: 43155, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 17806, colory: 43155, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color: {x: 0.2717, y: 0.6585}, color_mode: "xy"});
@@ -373,7 +444,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({color: {rgb: "100,200,10"}}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 17806, colory: 43155, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 17806, colory: 43155, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color: {x: 0.2717, y: 0.6585}, color_mode: "xy"});
@@ -385,7 +461,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON", brightness: "50"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON", brightness: 50});
@@ -410,7 +491,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({brightness_percent: 50}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 128, transtime: 0}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 128, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2); // 'zigbee2mqtt/bulb_color' + below
         expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/group_1");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({state: "ON", brightness: 128});
@@ -449,7 +535,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({state: "ON", brightness: 50}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2); // 'zigbee2mqtt/bulb_color' + below
         expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/group_1");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({state: "ON", brightness: 50});
@@ -475,7 +566,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({color: {x: 0.37, y: 0.28}}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 24248, colory: 18350, transtime: 0}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 24248, colory: 18350, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2); // 'zigbee2mqtt/bulb_color' + below
         expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/group_1");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({color: {x: 0.37, y: 0.28}, color_mode: "xy"});
@@ -488,7 +584,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({color_temp: 100}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 100, transtime: 0}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 100, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2); // 'zigbee2mqtt/bulb_color' + below
         expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/group_1");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({color_temp: 100, color_mode: "color_temp"});
@@ -515,7 +616,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness: "200"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
     });
 
@@ -526,7 +632,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness: "200"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON"});
     });
@@ -681,7 +792,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set/color", "#64C80A");
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 17806, colory: 43155, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 17806, colory: 43155, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color: {x: 0.2717, y: 0.6585}, color_mode: "xy"});
@@ -798,7 +914,12 @@ describe("Extension: Publish", () => {
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
         expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["lightingColorCtrl", "moveToColor", {colorx: 45940, colory: 19595, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 45940, colory: 19595, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should also use on/off cluster when controlling group with switch", async () => {
@@ -809,7 +930,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/switch_group/set", stringify({state: "ON", brightness: 100}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(2);
-        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 100, transtime: 0}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 100, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(group.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/switch_group", stringify({state: "ON", brightness: 100}), {
             retain: false,
@@ -835,7 +961,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({brightness: 100}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 100, transtime: 200}, {});
+        expect(group.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 100, transtime: 200, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2); // zigbee2mqtt/bulb_color + below
         expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/group_1");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({state: "ON", brightness: 100});
@@ -850,7 +981,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 200}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 200, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should use transition from device_options on brightness command", async () => {
@@ -861,7 +997,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 200}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 200, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should turn bulb on with correct brightness when device is turned off twice and brightness is reported", async () => {
@@ -909,10 +1050,34 @@ describe("Extension: Publish", () => {
         });
 
         expect(endpoint.command).toHaveBeenCalledTimes(4);
-        expect(endpoint.command).toHaveBeenNthCalledWith(1, "genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenNthCalledWith(2, "genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenNthCalledWith(3, "genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenNthCalledWith(4, "genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenNthCalledWith(
+            1,
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenNthCalledWith(
+            2,
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenNthCalledWith(
+            3,
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenNthCalledWith(
+            4,
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
     });
 
     it("Should turn bulb on with full brightness when transition is used and no brightness is known", async () => {
@@ -929,8 +1094,18 @@ describe("Extension: Publish", () => {
             qos: 0,
         });
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 5}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 254, transtime: 5}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 5, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 254, transtime: 5, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Transition parameter should not influence brightness on state ON", async () => {
@@ -944,9 +1119,19 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON", transition: 1}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(3);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(endpoint.command.mock.calls[1]).toEqual(["genOnOff", "on", {}, {}]);
-        expect(endpoint.command.mock.calls[2]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 10}, {}]);
+        expect(endpoint.command.mock.calls[2]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 10, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should use transition when color temp", async () => {
@@ -957,7 +1142,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 200, transtime: 200}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 200, transtime: 200, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should use transition only once when setting brightness and color temperature for TRADFRI", async () => {
@@ -967,8 +1157,18 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 200, transtime: 200}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 200, transtime: 200, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should use transition only once when setting brightness and color temperature for group which contains TRADFRI", async () => {
@@ -976,8 +1176,18 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_with_tradfri/set", stringify({state: "ON", transition: 60, brightness: 20, color_temp: 400}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(2);
-        expect(group.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {}]);
-        expect(group.command.mock.calls[1]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 400, transtime: 600}, {}]);
+        expect(group.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(group.command.mock.calls[1]).toEqual([
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 400, transtime: 600, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Message transition should overrule options transition", async () => {
@@ -988,7 +1198,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 100}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 100, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should set state with brightness before color", async () => {
@@ -998,8 +1213,18 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 100, transtime: 30}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["lightingColorCtrl", "moveToColor", {colorx: 45940, colory: 19595, transtime: 30}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 100, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 45940, colory: 19595, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should turn device off when brightness 0 is send", async () => {
@@ -1012,9 +1237,24 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(3);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 0}, {}]);
-        expect(endpoint.command.mock.calls[2]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[2]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
         expect(mockMQTTPublishAsync.mock.calls[0]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1043,9 +1283,24 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(3);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 30}, {}]);
-        expect(endpoint.command.mock.calls[2]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
+        expect(endpoint.command.mock.calls[2]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 50, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
         expect(mockMQTTPublishAsync.mock.calls[0]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1074,7 +1329,7 @@ describe("Extension: Publish", () => {
         expect(endpoint.command.mock.calls[0]).toEqual([
             "lightingColorCtrl",
             "enhancedMoveToHueAndSaturation",
-            {enhancehue: 45510, saturation: 127, transtime: 0},
+            {enhancehue: 45510, saturation: 127, transtime: 0, optionsMask: 0, optionsOverride: 0},
             {},
         ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
@@ -1129,7 +1384,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 254, transtime: 30}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 254, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should turn device on with on/off with transition when transition 0 is provided", async () => {
@@ -1139,7 +1399,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 254, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 254, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Should turn device off with onOff on off with transition", async () => {
@@ -1149,7 +1414,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 10}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 10, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "OFF"});
@@ -1168,7 +1438,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "OFF", transition: 3}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 30}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1197,7 +1472,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON", transition: 3}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 30}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
         expect(mockMQTTPublishAsync.mock.calls[2]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1219,7 +1499,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "OFF", transition: 3}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 30}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 0, transtime: 30, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1231,7 +1516,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 200, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
         expect(mockMQTTPublishAsync.mock.calls[1]).toEqual([
             "zigbee2mqtt/bulb_color",
@@ -1264,7 +1554,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 100, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 100, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON", color_temp: 100, color_mode: "color_temp"});
@@ -1281,7 +1576,12 @@ describe("Extension: Publish", () => {
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
         expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 100, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "lightingColorCtrl",
+            "moveToColorTemp",
+            {colortemp: 100, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb_color",
@@ -1300,7 +1600,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "moveToColor", {colorx: 26869, colory: 16384, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual([
+            "lightingColorCtrl",
+            "moveToColor",
+            {colorx: 26869, colory: 16384, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/bulb_color");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({color: {x: 0.41, y: 0.25}, state: "ON", color_mode: "xy"});
@@ -1363,7 +1668,7 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness_move: -40}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {movemode: 1, rate: 40}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {movemode: 1, rate: 40, optionsMask: 0, optionsOverride: 0}, {});
     });
 
     it("Should publish brightness_move down to zigbee devices", async () => {
@@ -1371,7 +1676,7 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({brightness_move: 30}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {movemode: 0, rate: 30}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {movemode: 0, rate: 30, optionsMask: 0, optionsOverride: 0}, {});
     });
 
     it("HS2WD-E burglar warning", async () => {
@@ -1442,7 +1747,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/roller_shutter/set", stringify({state: "OPEN"}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 255, transtime: 0}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 255, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
         expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/roller_shutter");
         expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({position: 100});
@@ -1476,7 +1786,12 @@ describe("Extension: Publish", () => {
         await vi.runOnlyPendingTimersAsync();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
         expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/GL-S-007ZS", stringify({state: "ON", brightness: 20}), {
             qos: 0,
             retain: false,
@@ -1509,8 +1824,18 @@ describe("Extension: Publish", () => {
         await flushPromises();
 
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 0}, {});
-        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 10}, {});
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
+        expect(endpoint.command).toHaveBeenCalledWith(
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 20, transtime: 10, optionsMask: 0, optionsOverride: 0},
+            {},
+        );
     });
 
     it("Should restore brightness when its turned off without transition and is turned on with", async () => {
@@ -1527,7 +1852,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON", brightness: 123}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(2);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 123, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 123, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
 
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "OFF"}));
         await flushPromises();
@@ -1537,7 +1867,12 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "ON", transition: 1.0}));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(4);
-        expect(endpoint.command.mock.calls[3]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 123, transtime: 10}, {}]);
+        expect(endpoint.command.mock.calls[3]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 123, transtime: 10, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
     });
 
     it("Shouldnt use moveToLevelWithOnOff on turn on when no transition has been used as some devices do not turn on in that case", async () => {
@@ -1556,7 +1891,12 @@ describe("Extension: Publish", () => {
 
         expect(endpoint.command).toHaveBeenCalledTimes(4);
         expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
-        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 150, transtime: 0}, {}]);
+        expect(endpoint.command.mock.calls[1]).toEqual([
+            "genLevelCtrl",
+            "moveToLevelWithOnOff",
+            {level: 150, transtime: 0, optionsMask: 0, optionsOverride: 0},
+            {},
+        ]);
         expect(endpoint.command.mock.calls[2]).toEqual(["genOnOff", "off", {}, {}]);
         expect(endpoint.command.mock.calls[3]).toEqual(["genOnOff", "on", {}, {}]);
 
@@ -1601,7 +1941,7 @@ describe("Extension: Publish", () => {
         await mockMQTTEvents.message("zigbee2mqtt/group_tradfri_remote/set", stringify({scene_recall: 1}));
         await flushPromises();
         expect(group.command).toHaveBeenCalledTimes(1);
-        expect(group.command).toHaveBeenCalledWith("genScenes", "recall", {groupid: 15071, sceneid: 1}, {});
+        expect(group.command).toHaveBeenCalledWith("genScenes", "recall", {groupid: 15071, sceneid: 1, transitionTime: 0xffff}, {});
         expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(8);
         expect(mockMQTTPublishAsync).toHaveBeenNthCalledWith(
             1,

test/logger.test.ts

@@ -12,6 +12,14 @@ import Transport from "winston-transport";
 import logger from "../lib/util/logger";
 import * as settings from "../lib/util/settings";
 
+vi.mock("rimraf", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("rimraf")>();
+    return {
+        ...actual,
+        rimrafSync: vi.fn(actual.rimrafSync),
+    };
+});
+
 describe("Logger", () => {
     let consoleWriteSpy: MockInstance;
     const dir = tmp.dirSync();
@@ -43,6 +51,7 @@ describe("Logger", () => {
     it("Create log directory", () => {
         const dirs = fs.readdirSync(dir.name);
         expect(dirs.length).toBe(1);
+        expect(dirs[0]).toMatch(/^[0-9]{4}-[0-9]{2}-[0-9]{2}\.[0-9]{2}-[0-9]{2}-[0-9]{2}$/);
     });
 
     it("Should cleanup (default setting)", () => {
@@ -59,6 +68,24 @@ describe("Logger", () => {
         expect(fs.readdirSync(dir.name).length).toBe(10);
     });
 
+    it("Should handle cleanup error", () => {
+        for (const d of fs.readdirSync(dir.name)) {
+            rimrafSync(path.join(dir.name, d));
+        }
+
+        for (let i = 0; i < 20; i++) {
+            fs.mkdirSync(path.join(dir.name, `log_${i}`));
+        }
+
+        vi.mocked(rimrafSync).mockImplementationOnce(() => {
+            throw new Error("EACCES: permission denied");
+        });
+
+        const errorSpy = vi.spyOn(logger, "error");
+        logger.init();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Failed to remove old log directory '.*': Error: EACCES: permission denied/));
+    });
+
     it("Should cleanup (15 folders setting)", () => {
         for (const d of fs.readdirSync(dir.name)) {
             rimrafSync(path.join(dir.name, d));

test/mocks/data.ts

@@ -26,6 +26,9 @@ export const DEFAULT_CONFIGURATION = {
         "0x18fc2600000d7ae2": {
             friendly_name: "bosch_radiator",
         },
+        "0x18fc2600000d7ae3": {
+            friendly_name: "bosch_rm230z",
+        },
         "0x000b57fffec6a5b2": {
             retain: true,
             friendly_name: "bulb",

test/mocks/zigbeeHerdsman.ts

@@ -1,9 +1,9 @@
 import assert from "node:assert";
-import type {Mock} from "vitest";
+import {type Mock, vi} from "vitest";
 import type {AdapterTypes} from "zigbee-herdsman";
-
 import {Zcl} from "zigbee-herdsman";
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
+import type {BindingTableEntry, LQITableEntry, RoutingTableEntry} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
 import {DEFAULT_BIND_GROUP_ID} from "../../lib/util/utils";
 import type {EventHandler} from "./utils";
 
@@ -104,6 +104,7 @@ export class Endpoint {
     unbind: Mock;
     save: Mock;
     configureReporting: Mock;
+    readReportingConfig: Mock;
     meta: Record<string, unknown>;
     binds: ZHBind[];
     profileID: number | undefined;
@@ -138,6 +139,7 @@ export class Endpoint {
         this.unbind = vi.fn();
         this.save = vi.fn();
         this.configureReporting = vi.fn();
+        this.readReportingConfig = vi.fn();
         this.meta = meta;
         this.binds = binds;
         this.profileID = profileID;
@@ -218,6 +220,7 @@ export class Endpoint {
         this.unbind.mockClear();
         this.save.mockClear();
         this.configureReporting.mockClear();
+        this.readReportingConfig.mockClear();
         this.addToGroup.mockClear();
         this.removeFromGroup.mockClear();
         this.getClusterAttributeValue.mockClear();
@@ -247,8 +250,10 @@ export class Device {
     lastSeen: number | undefined;
     isDeleted: boolean;
     linkquality?: number;
-    lqi: Mock;
-    routingTable: Mock;
+    lqi: Mock<() => Promise<LQITableEntry[]>>;
+    routingTable: Mock<() => Promise<RoutingTableEntry[]>>;
+    bindingTable: Mock<() => Promise<BindingTableEntry[]>>;
+    clearAllBindings: Mock<() => Promise<void>>;
 
     constructor(
         type: string,
@@ -285,8 +290,10 @@ export class Device {
         this.manufacturerName = manufacturerName;
         this.lastSeen = 1000;
         this.isDeleted = false;
-        this.lqi = vi.fn(() => ({neighbors: []}));
-        this.routingTable = vi.fn(() => ({table: []}));
+        this.lqi = vi.fn(() => Promise.resolve([] as LQITableEntry[]));
+        this.routingTable = vi.fn(() => Promise.resolve([] as RoutingTableEntry[]));
+        this.bindingTable = vi.fn(() => Promise.resolve([] as BindingTableEntry[]));
+        this.clearAllBindings = vi.fn(() => {});
     }
 
     getEndpoint(ID: number): Endpoint | undefined {
@@ -302,6 +309,8 @@ export class Device {
         this.save.mockClear();
         this.lqi.mockClear();
         this.routingTable.mockClear();
+        this.bindingTable.mockClear();
+        this.clearAllBindings.mockClear();
         this.meta = {};
 
         for (const ep of this.endpoints) {
@@ -1128,6 +1137,20 @@ export const devices = {
         "DC Source",
         "FanBee1",
     ),
+    BTH_RM230Z: new Device(
+        "Router",
+        "0x18fc2600000d7ae3",
+        35902,
+        4617,
+        [new Endpoint(1, [0, 3, 513, 516, 1029, 2821], [10, 25], "0x18fc2600000d7ae3")],
+        InterviewState.Successful,
+        "Mains (single phase)",
+        "RBSH-RTH0-ZB-EU",
+        undefined,
+        undefined,
+        undefined,
+        CUSTOM_CLUSTER_BTHRA,
+    ),
 };
 
 export const mockController = {
@@ -1136,10 +1159,7 @@ export const mockController = {
     },
     start: vi.fn((): Promise<AdapterTypes.StartResult> => Promise.resolve("reset")),
     stop: vi.fn(),
-    touchlinkIdentify: vi.fn(),
-    touchlinkScan: vi.fn(),
-    touchlinkFactoryReset: vi.fn(),
-    touchlinkFactoryResetFirst: vi.fn(),
+    touchlink: {identify: vi.fn(), scan: vi.fn(), factoryReset: vi.fn(), factoryResetFirst: vi.fn()},
     addInstallCode: vi.fn(),
     permitJoin: vi.fn(),
     getPermitJoin: vi.fn((): boolean => false),
@@ -1195,6 +1215,9 @@ export const mockController = {
         groups[`group_${groupID}` as keyof typeof groups] = group;
         return group;
     }),
+    sendRaw: vi.fn(async (/*rawPayload: RawPayload, customClusters: CustomClusters = {}*/) =>
+        Promise.resolve([0x00, {nwkAddress: 0x1234, eui64: "", startIndex: 0, assocDevList: []}]),
+    ),
 };
 
 vi.mock("zigbee-herdsman", async (importOriginal) => ({

test/onboarding.test.ts

@@ -293,7 +293,7 @@ describe("Onboarding", () => {
         }
 
         const serverUrl = new URL(process.env.Z2M_ONBOARD_URL ?? "http://0.0.0.0:8080");
-        expect(mockHttpListen).toHaveBeenCalledWith(Number.parseInt(serverUrl.port), serverUrl.hostname, expect.any(Function));
+        expect(mockHttpListen).toHaveBeenCalledWith(Number.parseInt(serverUrl.port, 10), serverUrl.hostname, expect.any(Function));
 
         return [resEnd.mock.calls[0][0], resEnd.mock.calls[1][0]];
     };
@@ -351,7 +351,7 @@ describe("Onboarding", () => {
         expect(resEnd).toHaveBeenCalledTimes(2);
 
         const serverUrl = new URL(process.env.Z2M_ONBOARD_URL ?? "http://0.0.0.0:8080");
-        expect(mockHttpListen).toHaveBeenCalledWith(Number.parseInt(serverUrl.port), serverUrl.hostname, expect.any(Function));
+        expect(mockHttpListen).toHaveBeenCalledWith(Number.parseInt(serverUrl.port, 10), serverUrl.hostname, expect.any(Function));
 
         return resEnd.mock.calls[0][0];
     };