1.7.1

Fail gracefully when state retrieval fails after device reconnects. #2318
Fix typo.
2026-08-29 15:18:41 +00:00 · 2019-11-12 18:47:59 +01:00 · 2019-11-11 19:25:11 +01:00 · 2019-11-11 17:45:11 +01:00 · 2019-11-11 17:36:33 +01:00 · 2019-11-11 17:27:26 +01:00
78 changed files with 21538 additions and 4010 deletions
@@ -1,7 +1,15 @@
-node_modules
-.travis*
+.eslintignore
+.eslintrc.json
 .git
+.github
 .gitignore
-*.png
-firmware
-docker/Dockerfile*
+.npmrc
+.travis*
+.travis.yml
+README.md
+docker/Dockerfile*
+images
+node_modules
+scripts
+test
+update.sh
@@ -1,2 +1,2 @@
 node_modules/*
-support/*
+test/
@@ -1,17 +1,21 @@
 {
    "env": {
+        "jest/globals": true,
+        "es6": true,
        "node": true
    },
-    "extends": ["eslint:recommended", "google"],
+    "extends": ["eslint:recommended", "google", "plugin:jest/recommended", "plugin:jest/style"],
    "parserOptions": {
-        "ecmaFeatures": {
-            "experimentalObjectRestSpread": true
-        },
+        "ecmaVersion": 2018,
        "sourceType": "module"
    },
    "rules": {
        "require-jsdoc": "off",
        "indent": ["error", 4],
-        "max-len": ["error", { "code": 120 }]
-    }
+        "max-len": ["error", { "code": 120 }],
+        "no-prototype-builtins": "off"
+    },
+    "plugins": [
+        "jest"
+    ]
 }
@@ -0,0 +1,2 @@
+github: [koenkk]
+custom: https://www.paypal.me/koenkk
@@ -0,0 +1,30 @@
+<!--
+Did you read the FAQ?
+https://www.zigbee2mqtt.io/information/FAQ.html
+
+Unsupported device?
+https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html
+
+A question?
+Read the documentation: https://www.zigbee2mqtt.io/
+
+Bug report:
+- First make sure you are on the latest version of zigbee2mqtt.
+- Make sure you are running the latest CC253X firmware from https://github.com/koenkk/z-stack-firmware.
+- Provide a clear description of the problem.
+- If applicable, provide steps how to reproduce the problem.
+- Provide a log with `log_level` set to `debug`, see https://www.zigbee2mqtt.io/configuration/configuration.html
+- DON'T copy logs directly here, post a link to https://hastebin.com/ or https://pastebin.com/.
+-->
+
+<!--Start your bug report below this line-->
+# Bug Report
+## What happened
+
+## What did you expect to happen
+
+## How to reproduce it (minimal and precise)
+
+## Debug Info
+zigbee2mqtt version:
+CC253X firmware version:
@@ -2,10 +2,6 @@
 daysUntilStale: 60
 # Number of days of inactivity before a stale issue is closed
 daysUntilClose: 7
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - enhancement
-  - bug
 # Label to use when marking an issue as stale
 staleLabel: stale
 # Comment to post when marking an issue as stale. Set to `false` to disable
@@ -60,4 +60,9 @@ typings/
 # data
 data/database.db
 data/config.json
-data/log*.txt
+data/log*.txt
+data/state.json
+data/log
+data-backup/
+data/coordinator_backup.json
+data/.storage
@@ -1,28 +0,0 @@
-language: node_js
-
-sudo: required
-
-services:
-  - docker
-
-node_js:
-  - "8"
-
-install:
-  - npm install
-
-script:
-  - npm run verify-homeassistant-mapping
-  - npm run eslint
-
-after_success:
-  - ".travis/docker.sh"
-  - ".travis/wiki.sh"
-  - ".travis/trigger-downstream.sh"
-
-env:
-  global:
-    - DOCKER_USERNAME=koenkk
-    - secure: q5W9+mHz13PslLkTxuYNXivOau+N5OyB53sqgb+krOCPlbN9+gvi2Av9SribVd5jp2yx2O9rV/mr8eS0M2ykvBJ3UsIsCXiFL1dEPmsz1wlFAnW3kbD2EGhGFEV0dWRflSlA+5iQtcMPvbYu2PAOChUUoY7NNlhcz2EC+XXUapvvvaDwA1oSdtX+m61qyREshZb8B57DyXhziy6i/xjhFa84C0mR/iGFRWpZgcxmrNFH+/XDhSIpdq2KshhDWhjyag3ukAsTxTpqzLh1rFRlczjJEn0CcHG4WHsWHUFn9KK2lvT/YCDP8w0URnR1bCr8nyxGZJ2DLW6AzxZtJfWjvbeZYjO2R3WeHpzp6Jw6Qz5pG3gmu2FgeFpZ3FTEGtJ/Ev0/pjkY2Msx9mItzUJ7D8hY2noQZMPASar6oXEDYlkomx7gHHla0MPv3PKSJg5LX6Ybl137GIa6MLYYyz6SEKfyRUQhy3Itqrb/ID/ZP0UuLgyyDfShb8A6XOnsVqwZAsOPtU2UPnD1vsVXhjkpflK9+7QjL5m9MSqfAhg6qtwNsswl1KSiyhmdldGhZW5OfUasDxZKHyx7bsS1BhNnLi/iy4ifDh6KSr64aUW4iM0X99gkU+662Hgf73QpIG+oP41r30iEN0unTcRrFQDIbTSSapbA95bwUCBF1CgQC20=
-    - secure: em3lBVXvZ3kOVI4ipVlh93NIU6guLvyzHMmsLDuxhc92VFURqlYu3iXTTNEnknwyE31mziAkVFnmj+3OENd/VfzP01d4KKaYAQrbn2AnOMvcIIExLfaFU5QqbW1RMwRBIifhvrmboKt07pFsUy3Rghs80SwNSFDfLFoMhFMz+NdIZfJGW8LJy+gUPmz10YGzqh/chreowqOemgBBoswCGwIh1xB1KNejew3bQllnwQYGXcGuTDwDT4Wz+ObxlFt7YR/4n4oJY8jQYRPolM9qHQAGyn/Cn0TL3c8JqiBpVc1hm2OhYSDqvK0xf5IKsD+kIfFJPGa7nF2cwmhKdUNYR47oue3KB5tdrtDhwqUooTglvBOSXUIbthUR9Xu40ziyd5tHy0ixaLnDRGuKIIvEnXlcE6CgApoe3y2kHYa5dY+eUKxWwvH7b5hG+u82dYvw3VYpCHAnDQVgUzz4F63qZ2WZhcH0W3PF3/ytVAHyMu2vAMSrSXGi5xgM6el7Gp7SFVTFXBurbOaoJ3ZwwSEDP5d8mDyk1d8thmkQFL9P6iWtNnXOzjv4GIliEDWQg76BX6MLD3n3fnP0aq+RVmv+ev2Lp4xZZDfgGPek7g35IsaiohH6YvHloxE+ETQ0Ttb1lCQos9fj7LlI+ud6ExjwyRuEnzCOzr/qC/3Leg85Wc8=
-    - secure: GbJVFFY4nmQovp8i2VoQ1AOV8h9QoAcleBV9Mg5TItA8U2Y+6t9wx0iWbaclxOrzI727XZOk5HquMTKKTI430lT6OjU01+YJqwyq+k650YiX5PImsgJXGhFzBKeUcB3A53kKijfr9aEV00YiXRsKoKAn+Bl09m/9O+melBbTwO/YAQyt6EoUt21Yk0BoqpW2CTMPAgsU5tm6Ra3bbJ+IaUYVMYBtuHqtGiKg8jgTHqRhwKejDyV7+1dDxX8q51bK2Kb6PujbI1SS5wsJEpkU/eoPs7MuprmlYarYtBt1fDXSK1EOjcfpyEFRlrNLewIKiFEo3dkTOEtW2a4t3tcAiXOj8Hcvp+6RsjTfnjYmZweHVh/JKDhujjHBMviyTjwp4RnPaQSFou0iVIB5+Mo34hUhFDXc30SBzaux+lyR3rGoEu5pubZNjG5CkKIpw3IyduNKtIrlbCnfg+WDU3jrXmk0fzmwyriyXhx9BAzM+hyFiElZ+3xoXAlmDlwvaRZyJuQQNslwGPbZyX9EByIUkECjYPf92QPyD0mjbn8C32IphgQ515Up+15g2meDniugzowLJkDe3W86M5fB1kPQiDq5oT4M6TgAPRElLN6/ibyfOzDAtOdZgUiQvFnUQb1s9LunZqrc57AKzuzl2xG9Ok/cUkZFSOjrFr40jXgS2Lw=
@@ -1,43 +0,0 @@
-#!/bin/bash -e
-
-login() {
-  echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
-}
-
-tag_push() {
-  docker tag $DOCKER_USERNAME/zigbee2mqtt:$1 $DOCKER_USERNAME/zigbee2mqtt:$2
-  docker push $DOCKER_USERNAME/zigbee2mqtt:$2
-}
-
-build_and_push() {
-  docker build --build-arg COMMIT=$(git rev-parse --short HEAD) -t $DOCKER_USERNAME/zigbee2mqtt:$1 -f $2 .
-  docker push $DOCKER_USERNAME/zigbee2mqtt:$1
-}
-
-# Only update Docker images for:
-# - dev branch
-# - version release
-if [ "$TRAVIS_PULL_REQUEST" = "false" ] && [ ! -z ${TRAVIS_TAG+x} ] && [ ! "$TRAVIS_TAG" = "" ]
-then
-  echo "Updating docker images for master branch!"
-  login
-
-  # Push versioned images
-  build_and_push "$TRAVIS_TAG" docker/Dockerfile.amd64
-  build_and_push "$TRAVIS_TAG-arm32v6" docker/Dockerfile.arm32v6
-  build_and_push "$TRAVIS_TAG-arm64v8" docker/Dockerfile.arm64v8
-
-  # Push latest images.
-  tag_push "$TRAVIS_TAG-arm32v6" "arm32v6"
-  tag_push "$TRAVIS_TAG-arm64v8" "arm64v8"
-  tag_push "$TRAVIS_TAG" latest
-elif [ "$TRAVIS_BRANCH" = "dev" -a "$TRAVIS_PULL_REQUEST" = "false" ]
-then
-  echo "Updating docker images for dev branch!"
-  login
-  build_and_push latest-dev docker/Dockerfile.amd64
-  build_and_push arm32v6-dev docker/Dockerfile.arm32v6
-  build_and_push arm64v8-dev docker/Dockerfile.arm64v8
-else
-  echo "Not updating docker images, triggered by pull request or not on master/dev branch"
-fi
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-function travis_trigger() {
-     local org=$1 && shift
-     local repo=$1 && shift
-     local branch=${1:-master} && shift
-
-     body="{
-             \"request\": {
-               \"branch\": \"${branch}\"
-              }
-           }"
-
-     curl -s -X POST \
-          -H "Content-Type: application/json" \
-          -H "Accept: application/json" \
-          -H "Travis-API-Version: 3" \
-          -H "Authorization: token $TRAVIS_TOKEN" \
-          -d "$body" \
-          "https://api.travis-ci.org/repo/${org}%2F${repo}/requests"
-}
-
-# Only trigger downstream if on master branch and not pull request
-if [ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" ]
-then
-  echo "Triggering build of downstream projects!"
-  travis_trigger "danielwelch" "hassio-zigbee2mqtt" "master"
-else
-  echo "Not triggering build of downstream projects, triggered by pull request or not on master branch"
-fi
@@ -1,28 +0,0 @@
-#!/bin/sh -e
-
-setup_git() {
-  git config --global user.email "travis@travis-ci.org"
-  git config --global user.name "Travis CI"
-}
-
-update_wiki() {
-  rm -rf zigbee2mqtt.wiki
-  git clone https://${GH_TOKEN}@github.com/Koenkk/zigbee2mqtt.wiki.git
-  npm run docgen zigbee2mqtt.wiki
-  cd zigbee2mqtt.wiki
-  git add -A
-  git diff-index --quiet HEAD || git commit -m "Travis CI: update wiki"
-  git push origin
-  cd ..
-  rm -rf zigbee2mqtt.wiki
-}
-
-# Only update wiki if on master branch and not pull request
-if [ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" ]
-then
-  echo "Updating wiki!"
-  setup_git
-  update_wiki
-else
-  echo "Not updating wiki, triggered by pull request or not on master branch"
-fi
@@ -1,44 +1,72 @@
-[![Travis](https://img.shields.io/travis/Koenkk/zigbee2mqtt.svg)](https://api.travis-ci.org/Koenkk/zigbee2mqtt.svg)
+<div align="center">
+    <a href="https://github.com/koenkk/zigbee2mqtt">
+        <img width="150" height="150" src="images/logo.png">
+    </a>
+    <br>
+    <br>
+    <div style="display: flex;">
+        <a href="https://dev.azure.com/koenkk/zigbee/_build?definitionId=5">
+            <img src="https://dev.azure.com/koenkk/zigbee/_apis/build/status/Koenkk.zigbee2mqtt?branchName=dev">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/releases">
+            <img src="https://img.shields.io/github/release/koenkk/zigbee2mqtt.svg">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/stargazers">
+            <img src="https://img.shields.io/github/stars/koenkk/zigbee2mqtt.svg">
+        </a>
+        <a href="https://www.paypal.me/koenkk">
+            <img src="https://img.shields.io/badge/donate-PayPal-blue.svg">
+        </a>
+        <a href="https://discord.gg/dadfWYE">
+            <img src="https://img.shields.io/discord/556563650429583360.svg">
+        </a>
+        <a href="http://zigbee2mqtt.discourse.group/">
+            <img src="https://img.shields.io/discourse/https/zigbee2mqtt.discourse.group/status.svg">
+        </a>
+        <a>
+            <img src="https://img.shields.io/badge/Coverage-100%25-brightgreen.svg">
+        </a>
+        <a href="https://www.codacy.com/manual/Koenkk/zigbee2mqtt?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Koenkk/zigbee2mqtt&amp;utm_campaign=Badge_Grade">
+            <img src="https://api.codacy.com/project/badge/Grade/24f1e0fe39f04daa810e8a1416693d3f">
+        </a>
+    </div>
+    <h1>Zigbee2mqtt  🌉 🐝</h1>
+    <p>
+        Allows you to use your Zigbee devices <b>without</b> the vendors bridge or gateway.
+    </p>
+    <p>
+        It bridges events and allows you to control your Zigbee devices via MQTT. In this way you can integrate your Zigbee devices with whatever smart home infrastructure you are using.
+    </p>
+</div>

-# zigbee2mqtt :bridge_at_night: :honeybee:
-![Thumbs up or down?](header.png)
-<img align="right" height="40px" src="https://user-images.githubusercontent.com/7738048/40915536-1993dd32-6805-11e8-9f22-4dfca52133c0.png">
+## [Getting started](https://www.zigbee2mqtt.io/#getting-started)
+The [documentation](https://www.zigbee2mqtt.io/) provides you all the information needed to get up and running! Make sure you don't skip sections if this is your first visit, as there might be important details in there for you.

-Allows you to use your Zigbee devices **without** the vendors (Xiaomi/TRADFRI/Hue) bridge or gateway.
+If you aren't familiar with **Zigbee** terminology make sure you [read this](https://www.zigbee2mqtt.io/information/zigbee_network.html) to help you out.

-It bridges events and allows you to control your Zigbee devices via MQTT. In this way you can integrate your Zigbee devices with whatever smart home infrastructure you are using. 
-
-## [Getting started](https://github.com/Koenkk/zigbee2mqtt/wiki/Getting-started)
-The [wiki](https://github.com/Koenkk/zigbee2mqtt/wiki) provides you all the information needed to get up and running! Make sure you don't skip sections if this is your first visit, as there might be important details in there for you.
-
-[The documentation](https://github.com/Koenkk/zigbee2mqtt/wiki) will provide information on how to prepare, configure and start **zigbee2mqtt**, but also on how to customize the setup to fit your needs. 
-
-If you aren't familiar with **zigbee** terminology make sure you [read this](https://github.com/Koenkk/zigbee2mqtt/wiki/ZigBee-network) to help you out.
-
-## Integrations
+## [Integrations](https://www.zigbee2mqtt.io/#integration)
 Zigbee2mqtt integrates well with (almost) every home automation solution because it uses MQTT. However the following integrations are worth mentioning:

 <img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/7738048/40914297-49e6e560-6800-11e8-8904-36cce896e5a8.png">

 ### [Home Assistant](https://www.home-assistant.io/)
 - [Hassio](https://www.home-assistant.io/hassio/): Using [the official addon](https://github.com/danielwelch/hassio-zigbee2mqtt) from [danielwelch](https://github.com/danielwelch)
- Generic install or Hassbian: Using instructions [here](https://github.com/Koenkk/zigbee2mqtt/wiki/Integrating-with-Home-Assistant)
+- Generic install or Hassbian: Using instructions [here](https://www.zigbee2mqtt.io/integration/home_assistant.html)

-## Architecture 
-![Architecture](architecture.png)
+<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">
+
+### [Domoticz](https://www.domoticz.com/)
+- Integration implemented in [domoticz-zigbee2mqtt-plugin](https://github.com/stas-demydiuk/domoticz-zigbee2mqtt-plugin)
+
+<br>
+
+## Architecture
+![Architecture](images/architecture.png)

 ## Supported devices
-See [Supported devices](https://github.com/Koenkk/zigbee2mqtt/wiki/Supported-devices) to check whether your device is supported. There is quite an extensive list, including devices from vendors like Xiaomi, Ikea, Philips, OSRAM and more. 
+See [Supported devices](https://www.zigbee2mqtt.io/information/supported_devices.html) to check whether your device is supported. There is quite an extensive list, including devices from vendors like Xiaomi, Ikea, Philips, OSRAM and more.

-If it's not listed in [Supported devices](https://github.com/Koenkk/zigbee2mqtt/wiki/Supported-devices), support can be added (fairly) easy, see [How to support new devices](https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices).
+If it's not listed in [Supported devices](https://www.zigbee2mqtt.io/information/supported_devices.html), support can be added (fairly) easy, see [How to support new devices](https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html).

 ## Support & help
-If you need assistance you can check [opened issues](https://github.com/Koenkk/zigbee2mqtt/issues). Feel free to help with Pull Requests when you were able to fix things or add new devices or just share the love on social media. 
-
-## Contributors
-* [AndrewLinden](https://github.com/AndrewLinden)
-* [oskarn97](https://github.com/oskarn97)
-* [dgomes](https://github.com/dgomes)
-* [Koenkk](https://github.com/Koenk)
-* [kirovilya](https://github.com/kirovilya)
-* [ciotlosm](https://github.com/ciotlosm)
+If you need assistance you can check [opened issues](https://github.com/Koenkk/zigbee2mqtt/issues). Feel free to help with Pull Requests when you were able to fix things or add new devices or just share the love on social media.
@@ -0,0 +1,82 @@
+trigger:
+  tags:
+    include:
+    - '*'
+  branches:
+    include:
+    - '*'
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+steps:
+
+# Prepare
+- task: NodeTool@0
+  inputs:
+    versionSpec: '10.x'
+  displayName: 'Install Node.js'
+- bash: npm install
+  displayName: 'Install dependencies'
+
+# Verify
+- bash: npm run test-with-coverage
+  displayName: 'Test'
+- bash: npm run eslint
+  displayName: 'Lint'
+
+# Docker
+- task: DockerInstaller@0
+  displayName: Docker install
+  condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
+  inputs:
+    dockerVersion: 19.03.2
+    releaseType: stable
+- task: Docker@2
+  displayName: Docker registry login
+  condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
+  inputs:
+    command: login
+    containerRegistry: docker_registry
+- bash: |
+    sudo wget -O /usr/local/bin/buildx https://github.com/docker/buildx/releases/download/v0.3.1/buildx-v0.3.1.linux-amd64
+    sudo chmod a+x /usr/local/bin/buildx
+    docker run --rm --privileged hypriot/qemu-register
+    buildx create --use
+    buildx ls
+  displayName: 'Docker setup'
+  condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
+- bash: |
+    buildx build \
+      --build-arg COMMIT=$(git rev-parse --short HEAD) \
+      --platform linux/arm64/v8,linux/amd64,linux/arm/v6,linux/arm/v7,linux/386 \
+      -f docker/Dockerfile \
+      --push \
+      -t koenkk/zigbee2mqtt:latest-dev \
+      .
+  displayName: 'Docker build dev'
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/dev'), ne(variables['Build.Reason'], 'PullRequest'))
+- bash: |
+    TAG="$(git describe --tags)"
+    buildx build \
+      --build-arg COMMIT=$(git rev-parse --short HEAD) \
+      --platform linux/arm64/v8,linux/amd64,linux/arm/v6,linux/arm/v7,linux/386 \
+      -f docker/Dockerfile \
+      --push \
+      -t koenkk/zigbee2mqtt:latest -t "koenkk/zigbee2mqtt:$TAG" \
+      .
+  displayName: 'Docker build release'
+  condition: and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/tags/'), ne(variables['Build.Reason'], 'PullRequest'))
+
+# Trigger downstream
+- bash: |
+    BODY="{\"request\": {\"branch\": \"master\"}}"
+    curl -s -X POST \
+        -H "Content-Type: application/json" \
+        -H "Accept: application/json" \
+        -H "Travis-API-Version: 3" \
+        -H "Authorization: token $(TRAVIS_TOKEN)" \
+        -d "$BODY" \
+        "https://api.travis-ci.org/repo/danielwelch%2Fhassio-zigbee2mqtt/requests"
+  displayName: 'Trigger Hass.io build'
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/dev'), ne(variables['Build.Reason'], 'PullRequest'))
@@ -1,4 +1,4 @@
-FROM alpine:3.7
+FROM node:10-alpine

 # Copy files
 ADD . /app
@@ -12,9 +12,10 @@ ARG COMMIT
 RUN echo "{\"hash\": \"$COMMIT\"}" > .hash.json

 # Install dependencies
-RUN apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
-    npm install --unsafe-perm && \
-    apk del make gcc g++ python linux-headers udev git
+RUN apk add --update --no-cache tzdata udev eudev && \
+    apk add --update --no-cache --virtual .buildtools make gcc g++ python linux-headers udev git && \
+    npm install --unsafe-perm --production && \
+    apk del .buildtools

 # Entrypoint
 ENTRYPOINT ["./run.sh"]
@@ -1,22 +0,0 @@
-FROM arm32v6/alpine:3.7
-
-# Setup cross-build
-ENV QEMU_EXECVE 1
-COPY docker/qemu-arm-static /usr/bin
-WORKDIR /app
-
-# Write .hash.json
-ARG COMMIT
-RUN [ "qemu-arm-static", "/bin/sh", "-c", "echo {\\\"hash\\\": \\\"$COMMIT\\\"} > .hash.json" ]
-
-# Copy files & install dependencies
-ADD . /app
-RUN [ "qemu-arm-static", "/bin/sh", "-c", \
-      "cp /app/data/configuration.yaml /app && \
-       cp /app/docker/run.sh /app && chmod +x /app/run.sh && \
-       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
-       npm install --unsafe-perm && \
-       apk del make gcc g++ python linux-headers udev git"]
-
-# Entrypoint
-ENTRYPOINT ["./run.sh"]
@@ -1,22 +0,0 @@
-FROM arm64v8/alpine:3.7
-
-# Setup cross-build
-ENV QEMU_EXECVE 1
-COPY docker/qemu-aarch64-static /usr/bin
-WORKDIR /app
-
-# Write .hash.json
-ARG COMMIT
-RUN [ "qemu-aarch64-static", "/bin/sh", "-c", "echo {\\\"hash\\\": \\\"$COMMIT\\\"} > .hash.json" ]
-
-# Copy files & install dependencies
-ADD . /app
-RUN [ "qemu-aarch64-static", "/bin/sh", "-c", \
-      "cp /app/data/configuration.yaml /app && \
-       cp /app/docker/run.sh /app && chmod +x /app/run.sh && \
-       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
-       npm install --unsafe-perm && \
-       apk del make gcc g++ python linux-headers udev git"]
-
-# Entrypoint
-ENTRYPOINT ["./run.sh"]
@@ -0,0 +1,14 @@
+  version: '3'
+  services:
+    zigbee2mqtt:
+      container_name: zigbee2mqtt
+      image: koenkk/zigbee2mqtt
+      volumes:
+        - ./data:/app/data
+      devices:
+        # CC251
+        #- /dev/ttyUSB_cc2531:/dev/ttyACM0
+        # CC2530 / GBAN GB2530S
+        #- /dev/ttyUSB_cc2530:/dev/ttyACM0
+      restart: always
+      network_mode: host
@@ -13,8 +13,4 @@ if [ ! -f "$DATA/configuration.yaml" ]; then
    cp /app/configuration.yaml "$DATA/configuration.yaml"
 fi

-if [ ! -z "$DEBUG" ]; then
-    npm start
-else
-    DEBUG="$DEBUG" npm start
-fi
+exec npm start
@@ -0,0 +1,146 @@
+<svg class="thumb" width="1000" height="1000" viewBox="0,0,600,600" xmlns="http://www.w3.org/2000/svg" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ns1="http://www.inkscape.org/namespaces/inkscape" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+  <defs></defs>
+  <g transform="matrix(1.8288,0,0,1.8288,-76.3478,13.5303)">
+    <g transform="matrix(1.6652,0,0,1.6704,50.2843,0.6537)">
+      <svg width="186.77" height="186.769" viewBox="-5,-5,186.77,186.769">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vk4">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g>
+          <polygon points="51.774,176.769 0,124.995 0,51.774 51.774,0 124.995,0 176.77,51.774 176.77,124.995   124.995,176.769 " fill="url('#linearGradientSk1zes2vk4')"></polygon>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6204,0,0,1.6204,53.946,5.3)">
+      <svg width="186.77" height="186.769" viewBox="-5,-5,186.77,186.769">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vka">
+            <stop offset="0%" stop-color="#ffc038"></stop>
+            <stop offset="100%" stop-color="#ffc038"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g>
+          <polygon points="51.774,176.769 0,124.995 0,51.774 51.774,0 124.995,0 176.77,51.774 176.77,124.995   124.995,176.769 " fill="url('#linearGradientSk1zes2vka')"></polygon>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6146,0,0,1.6146,185.8484,123.0829)">
+      <svg width="27.265" height="16.606891038197716" viewBox="36.308,71.828,27.265,16.606891038197716">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vkg">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g>
+          <path d="M41.308,76.828c1.197,2.07,2.931,3.953,5.371,5.497c0,0,1.453,1.163,3.373,1.108c1.918,0.051,3.375-1.107,3.375-1.107   c2.289-1.446,3.958-3.192,5.146-5.112c-2.274,0.496-4.875,0.754-7.556,0.754C47.714,77.968,44.316,77.583,41.308,76.828z" fill="url('#linearGradientSk1zes2vkg')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6146,0,0,1.6146,182.6191,109.0829)">
+      <svg width="31.991999999999997" height="16.800092191011956" viewBox="34.051,63.36,31.991999999999997,16.800092191011956">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vkm">
+            <stop offset="0%" stop-color="#ffffff"></stop>
+            <stop offset="100%" stop-color="#ffffff"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g>
+          <path d="M39.051,68.36c0.055,1.736,0.307,3.47,0.818,5.141c5.94,2.063,15.1,2.206,20.244,0.407c0.563-1.692,0.85-3.453,0.93-5.221   c-2.995,0.938-6.551,1.364-10.114,1.364C46.659,70.052,42.394,69.434,39.051,68.36z" fill="url('#linearGradientSk1zes2vkm')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6146,0,0,1.6146,182.6191,96.0829)">
+      <svg width="31.867999999999995" height="16.630912092367097" viewBox="34.128,55.641000000000005,31.867999999999995,16.630912092367097">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vks">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g>
+          <path d="M50.929,62.06c-3.902,0-7.81-0.511-11.006-1.419c-0.373,1.537-0.658,3.156-0.795,4.812   c5.78,2.114,15.619,2.598,21.868,0.309c-0.119-1.662-0.384-3.297-0.745-4.846C57.427,61.692,54.187,62.06,50.929,62.06z" fill="url('#linearGradientSk1zes2vks')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6146,0,0,1.6146,185.041,84.8902)">
+      <svg width="28.836000000000006" height="15.788046460420631" viewBox="35.678,48.491,28.836000000000006,15.788046460420631">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vky">
+            <stop offset="0%" stop-color="#ffffff"></stop>
+            <stop offset="100%" stop-color="#ffffff"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g>
+          <path d="M59.514,58.241c-0.571-1.815-1.232-3.435-1.862-4.75c-2.599,0.543-5.42,0.809-8.212,0.809   c-2.458,0-4.881-0.204-7.097-0.579c-0.564,1.205-1.146,2.646-1.665,4.246C46.062,59.501,53.848,59.813,59.514,58.241z" fill="url('#linearGradientSk1zes2vky')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(1.6146,0,0,1.6146,120.4554,23.9828)">
+      <svg width="108.32981691822947" height="57.54144295152284" viewBox="-4.359346882061053,10.889,108.32981691822947,57.54144295152284">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vk14">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g></g>
+        <g>
+          <path d="M58.786,38.047c-0.651-1.481-1.406-2.589-1.406-2.589c-0.11-0.123-0.253-0.232-0.394-0.342  c0.422-1.017,0.659-2.14,0.659-3.324c0-3.374-1.896-6.271-4.6-7.523l2.116-7.369l6.143-0.228c0.215-0.007,0.382-0.188,0.378-0.405  c-0.008-0.215-0.19-0.375-0.406-0.378l-6.396,0.238c-0.152,0.006-0.287,0.095-0.346,0.239l-3.563,7.305  c-0.302-0.039-0.607-0.065-0.92-0.065c-0.314,0-0.621,0.026-0.924,0.066l-3.565-7.308c-0.058-0.138-0.193-0.23-0.349-0.237  l-6.393-0.236c-0.216-0.001-0.396,0.161-0.407,0.376c-0.006,0.218,0.163,0.398,0.38,0.405l6.143,0.23l2.118,7.368  c-2.703,1.252-4.598,4.147-4.597,7.52c0,1.184,0.239,2.307,0.659,3.323c-0.148,0.11-0.288,0.223-0.393,0.344  c0,0-0.739,1.108-1.38,2.663C29.184,41.662-2.639,46.12,0.916,55.936c3.944,10.877,25.455,7.546,29.052,4.598  c5.007-4.104,9.231-7.95,11.843-11c0.224,0.512,0.459,0.979,0.694,1.396c4.583,0.822,10.289,0.82,14.998-0.245  c0.166-0.346,0.332-0.731,0.496-1.137c2.625,3.011,6.768,6.769,11.648,10.77c3.596,2.949,25.106,6.275,29.048-4.599  C102.202,46.038,71.295,41.566,58.786,38.047z" fill="url('#linearGradientSk1zes2vk14')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(0.5515,-0.0096,0.0096,0.5515,184.0296,161.5473)">
+      <svg width="91.9" height="160" style="overflow: visible;">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vk1g">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g transform="matrix(1,0,0,1,0,75)">
+          <path d="M 28.2-77.4L 28.2-77.4L 28.2 5.4Q 28.2 7.3  27.35 8.15Q 26.5 9  24.6 9L 24.6 9L 10.1 9Q 8.2 9  7.35 8.15Q 6.5 7.3  6.5 5.4L 6.5 5.4L 6.5-77.4Q 6.5-79.3  7.35-80.15Q 8.2-81  10.1-81L 10.1-81L 24.6-81Q 26.5-81  27.35-80.15Q 28.2-79.3  28.2-77.4ZM 85.39999999999998-77.4L 85.39999999999998-77.4L 85.39999999999998 5.4Q 85.39999999999998 7.3  84.54999999999998 8.15Q 83.69999999999999 9  81.79999999999998 9L 81.79999999999998 9L 67.29999999999998 9Q 65.39999999999998 9  64.54999999999998 8.15Q 63.69999999999998 7.3  63.69999999999998 5.4L 63.69999999999998 5.4L 63.69999999999998-77.4Q 63.69999999999998-79.3  64.54999999999998-80.15Q 65.39999999999998-81  67.29999999999998-81L 67.29999999999998-81L 81.79999999999998-81Q 83.69999999999999-81  84.54999999999998-80.15Q 85.39999999999998-79.3  85.39999999999998-77.4Z" data-textpath="| |" data-text-anchor="middle" data-font-size="100" data-letterspacing="0" data-side="left" data-offset="0.5" data-dx="0" data-dy="0" data-xmlspace="preserve" data-href="" data-font="Bungee" data-font-src="/Content/clientfonts/bungee.woff" data-font-scale="contain" transform="translate(0,0)" data-x="0" data-y="0" fill="url('#linearGradientSk1zes2vk1g')"></path>
+        </g>
+      </svg>
+    </g>
+    <g transform="matrix(0.5,0,0,0.5,136.759,231)">
+      <svg width="289.30000000000007" height="160" style="overflow: visible;">
+        <defs>
+          <linearGradient x1="0" y1="0.5" x2="1" y2="0.5" id="linearGradientSk1zes2vk1j">
+            <stop offset="0%" stop-color="#000000"></stop>
+            <stop offset="100%" stop-color="#000000"></stop>
+          </linearGradient>
+        </defs>
+        <g transform="matrix(1,0,0,1,0,75)">
+          <path d="M 25.4 0L 25.4 0L 10.5 0Q 8.6 0  7.75-0.85Q 6.9-1.7  6.9-3.6L 6.9-3.6L 6.9-68.4Q 6.9-70.3  7.75-71.15Q 8.6-72  10.5-72L 10.5-72L 26.6-72Q 28.2-72  29.25-71.3Q 30.3-70.6  31.2-69L 31.2-69L 40.2-52.7Q 40.7-51.8  41.05-51.4Q 41.4-51  42-51L 42-51L 42.9-51Q 43.5-51  43.85-51.4Q 44.2-51.8  44.7-52.7L 44.7-52.7L 53.6-69Q 54.5-70.6  55.55-71.3Q 56.6-72  58.2-72L 58.2-72L 74.4-72Q 76.3-72  77.15-71.15Q 78-70.3  78-68.4L 78-68.4L 78-3.6Q 78-1.7  77.15-0.85Q 76.3 0  74.4 0L 74.4 0L 59 0Q 57.1 0  56.25-0.85Q 55.4-1.7  55.4-3.6L 55.4-3.6L 55.4-38.8L 49.5-27.9Q 48.6-26.2  47.35-25.45Q 46.1-24.7  44.2-24.7L 44.2-24.7L 40.2-24.7Q 38.3-24.7  37.05-25.45Q 35.8-26.2  34.9-27.9L 34.9-27.9L 29-38.8L 29-3.6Q 29-1.7  28.15-0.85Q 27.3 0  25.4 0ZM 129.4 9L 129.4 9L 114 9Q 112.10000000000001 9  111.25 8.15Q 110.4 7.3  110.4 5.4L 110.4 5.4L 110.4-0.1Q 98.80000000000001-1.8  94.75-7.05Q 90.7-12.3  90.7-19.8L 90.7-19.8L 90.7-53Q 90.7-57.6  92.05000000000001-61.35Q 93.4-65.1  96.85000000000001-67.8Q 100.30000000000001-70.5  106.4-72Q 112.5-73.5  121.80000000000001-73.5L 121.80000000000001-73.5Q 131.10000000000002-73.5  137.15-72Q 143.2-70.5  146.65-67.8Q 150.10000000000002-65.1  151.45-61.35Q 152.8-57.6  152.8-53L 152.8-53L 152.8-19.8Q 152.8-16  151.9-12.75Q 151-9.5  148.8-7Q 146.60000000000002-4.5  142.75-2.7Q 138.9-0.9  133-0.1L 133-0.1L 133 5.4Q 133 7.3  132.15 8.15Q 131.3 9  129.4 9ZM 113.4-49.3L 113.4-22Q 113.4-20  114.9-18.65Q 116.4-17.3  121.80000000000001-17.3L 121.80000000000001-17.3Q 127.2-17.3  128.7-18.65Q 130.2-20  130.2-22L 130.2-22L 130.2-49.3Q 130.2-51.2  128.7-52.55Q 127.2-53.9  121.80000000000001-53.9L 121.80000000000001-53.9Q 116.4-53.9  114.9-52.55Q 113.4-51.2  113.4-49.3L 113.4-49.3ZM 199 0L 199 0L 182.79999999999998 0Q 180.9 0  180.04999999999998-0.85Q 179.2-1.7  179.2-3.6L 179.2-3.6L 179.2-52.7L 164.5-52.7Q 162.6-52.7  161.75-53.55Q 160.9-54.4  160.9-56.3L 160.9-56.3L 160.9-68.4Q 160.9-70.3  161.75-71.15Q 162.6-72  164.5-72L 164.5-72L 217.3-72Q 219.2-72  220.05-71.15Q 220.89999999999998-70.3  220.89999999999998-68.4L 220.89999999999998-68.4L 220.89999999999998-56.3Q 220.89999999999998-54.4  220.05-53.55Q 219.2-52.7  217.3-52.7L 217.3-52.7L 202.6-52.7L 202.6-3.6Q 202.6-1.7  201.75-0.85Q 200.89999999999998 0  199 0ZM 264.6 0L 264.6 0L 248.40000000000003 0Q 246.50000000000006 0  245.65000000000003-0.85Q 244.80000000000004-1.7  244.80000000000004-3.6L 244.80000000000004-3.6L 244.80000000000004-52.7L 230.10000000000005-52.7Q 228.20000000000005-52.7  227.35000000000005-53.55Q 226.50000000000006-54.4  226.50000000000006-56.3L 226.50000000000006-56.3L 226.50000000000006-68.4Q 226.50000000000006-70.3  227.35000000000005-71.15Q 228.20000000000005-72  230.10000000000005-72L 230.10000000000005-72L 282.90000000000003-72Q 284.80000000000007-72  285.65000000000003-71.15Q 286.50000000000006-70.3  286.50000000000006-68.4L 286.50000000000006-68.4L 286.50000000000006-56.3Q 286.50000000000006-54.4  285.65000000000003-53.55Q 284.80000000000007-52.7  282.90000000000003-52.7L 282.90000000000003-52.7L 268.20000000000005-52.7L 268.20000000000005-3.6Q 268.20000000000005-1.7  267.35-0.85Q 266.50000000000006 0  264.6 0Z" data-textpath="MQTT" data-text-anchor="middle" data-font-size="100" data-letterspacing="0" data-side="left" data-offset="0.5" data-dx="0" data-dy="0" data-xmlspace="preserve" data-href="" data-font="Bungee" data-font-src="/Content/clientfonts/bungee.woff" data-font-scale="contain" transform="translate(0,0)" data-x="0" data-y="0" fill="url('#linearGradientSk1zes2vk1j')"></path>
+        </g>
+      </svg>
+    </g>
+  </g>
+</svg>
@@ -1,10 +1,23 @@
-const Controller = require('./lib/controller');
+const semver = require('semver');
+const engines = require('./package.json').engines;

+const version = engines.node;
+if (!semver.satisfies(process.version, version)) {
+    console.log(`\t\tZigbee2mqtt requires node version ${version}, you are running ${process.version}!\n`); // eslint-disable-line
+}
+
+const Controller = require('./lib/controller');
 const controller = new Controller();
 controller.start();

 process.on('SIGINT', handleQuit);
+process.on('SIGTERM', handleQuit);
+
+let stopping = false;

 function handleQuit() {
-    controller.stop(() => process.exit());
+    if (!stopping) {
+        stopping = true;
+        controller.stop();
+    }
 }
@@ -1,590 +1,333 @@
 const MQTT = require('./mqtt');
 const Zigbee = require('./zigbee');
+const State = require('./state');
 const logger = require('./util/logger');
 const settings = require('./util/settings');
-const zigbeeShepherdConverters = require('zigbee-shepherd-converters');
-const homeassistant = require('./homeassistant');
-const objectAssignDeep = require(`object-assign-deep`);
+const objectAssignDeep = require('object-assign-deep');
+const utils = require('./util/utils');

-const mqttConfigRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/config/\\w+`, 'g');
-const mqttDeviceRegex = new RegExp(`${settings.get().mqtt.base_topic}/[\\w\\s\\d]+/set`, 'g');
-const mqttDevicePrefixRegex = new RegExp(`${settings.get().mqtt.base_topic}/[\\w\\s\\d]+/[\\w\\s\\d]+/set`, 'g');
-
-const pollInterval = 60 * 1000; // seconds * 1000.
-const softResetTimeout = 3600 * 1000; // seconds * 1000.
-
-const allowedLogLevels = ['error', 'warn', 'info', 'debug'];
-
-/**
- * Home Assistant requires ALL attributes to be present in ALL MQTT messages send by the device.
- * https://community.home-assistant.io/t/missing-value-with-mqtt-only-last-data-set-is-shown/47070/9
- *
- * Therefore zigbee2mqtt BY DEFAULT caches all values and resend it with every message.
- * advanced.cache_state in configuration.yaml allows to configure this.
- * https://github.com/Koenkk/zigbee2mqtt/wiki/Configuration
- */
-const cacheState = settings.get().advanced && settings.get().advanced.cache_state === false ? false : true;
-if (settings.get().homeassistant && !cacheState) {
-    logger.warn('In order for Home Assistant integration to work properly set `cache_state: true');
-}
+// Extensions
+const ExtensionEntityPublish = require('./extension/entityPublish');
+const ExtensionDeviceReceive = require('./extension/deviceReceive');
+const ExtensionNetworkMap = require('./extension/networkMap');
+const ExtensionSoftReset = require('./extension/softReset');
+const ExtensionHomeAssistant = require('./extension/homeassistant');
+const ExtensionDeviceConfigure = require('./extension/deviceConfigure');
+const ExtensionDeviceGroupMembership = require('./extension/deviceGroupMembership');
+const ExtensionBridgeConfig = require('./extension/bridgeConfig');
+const ExtensionGroups = require('./extension/groups');
+const ExtensionDeviceAvailability = require('./extension/deviceAvailability');
+const ExtensionDeviceBind = require('./extension/deviceBind');
+const ExtensionDeviceReport = require('./extension/deviceReport');
+const ExtensionDeviceEvent = require('./extension/deviceEvent');

 class Controller {
    constructor() {
        this.zigbee = new Zigbee();
        this.mqtt = new MQTT();
-        this.stateCache = {};
-        this.configured = [];
-        this.handleZigbeeMessage = this.handleZigbeeMessage.bind(this);
-        this.handleMQTTMessage = this.handleMQTTMessage.bind(this);
-    }
+        this.state = new State();

-    start() {
-        this.startupLogVersion(() => {
-            this.zigbee.start(this.handleZigbeeMessage, (error) => {
-                if (error) {
-                    logger.error('Failed to start', error);
-                } else {
-                    // Log zigbee clients on startup and configure.
-                    const devices = this.zigbee.getAllClients();
-                    logger.info(`Currently ${devices.length} devices are joined:`);
-                    devices.forEach((device) => {
-                        logger.info(this.getDeviceStartupLogMessage(device));
-                        this.configureDevice(device);
-                    });
+        this.publishEntityState = this.publishEntityState.bind(this);
+        this.onZigbeeAdapterDisconnected = this.onZigbeeAdapterDisconnected.bind(this);

-                    // Enable zigbee join.
-                    if (settings.get().permit_join) {
-                        logger.warn('`permit_join` set to  `true` in configuration.yaml.');
-                        logger.warn('Allowing new devices to join.');
-                        logger.warn('Set `permit_join` to `false` once you joined all devices.');
-                        this.zigbee.permitJoin(true);
-                    }
+        // Initialize extensions.
+        this.extensions = [
+            new ExtensionEntityPublish(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionDeviceReceive(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionDeviceGroupMembership(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionDeviceConfigure(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionNetworkMap(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionBridgeConfig(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionGroups(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionDeviceBind(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionDeviceEvent(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+        ];

-                    // Start timers.
-                    this.pollTimer(true);
-                    this.softResetTimeout(true);
+        if (settings.get().advanced.report) {
+            this.extensions.push(new ExtensionDeviceReport(
+                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+            ));
+        }

-                    // Connect to MQTT broker
-                    const subscriptions = [
-                        `${settings.get().mqtt.base_topic}/+/set`,
-                        `${settings.get().mqtt.base_topic}/+/+/set`,
-                        `${settings.get().mqtt.base_topic}/bridge/config/+`,
-                    ];
-
-                    if (settings.get().homeassistant) {
-                        subscriptions.push('hass/status');
-                    }
-
-                    this.mqtt.connect(this.handleMQTTMessage, subscriptions, () => this.handleMQTTConnected());
-                }
-            });
-        });
-    }
-
-    handleMQTTConnected() {
-        // Home Assistant MQTT discovery on MQTT connected.
        if (settings.get().homeassistant) {
-            // MQTT discovery of all paired devices on startup.
-            this.zigbee.getAllClients().forEach((device) => {
-                const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-                if (mappedModel) {
-                    homeassistant.discover(device.ieeeAddr, mappedModel.model, this.mqtt, true);
-                }
-            });
+            this.extensions.push(new ExtensionHomeAssistant(
+                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+            ));
        }

-        // Resend all cached states.
-        this.sendAllCachedStates();
-    }
-
-    sendAllCachedStates() {
-        this.zigbee.getAllClients().forEach((device) => {
-            if (this.stateCache.hasOwnProperty(device.ieeeAddr)) {
-                this.mqttPublishDeviceState(device.ieeeAddr, this.stateCache[device.ieeeAddr], false);
-            }
-        });
-    }
-
-    softResetTimeout(start) {
-        if (this._softResetTimer) {
-            clearTimeout(this._softResetTimer);
-            this._softResetTimer = null;
+        /* istanbul ignore next */
+        if (settings.get().advanced.soft_reset_timeout !== 0) {
+            this.extensions.push(new ExtensionSoftReset(
+                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+            ));
        }

-        if (start) {
-            this._softResetTimer = setTimeout(() => {
-                this.zigbee.softReset((error) => {
-                    if (error) {
-                        logger.warn('Soft reset error', error);
-                        this.zigbee.stop((error) => {
-                            logger.warn('Zigbee stopped');
-                            this.zigbee.start(this.handleZigbeeMessage, (error) => {
-                                if (error) {
-                                    logger.error('Failed to restart!');
-                                }
-                            });
-                        });
-                    } else {
-                        logger.warn('Soft resetted zigbee');
-                    }
-
-                    this.softResetTimeout(true);
-                });
-            }, softResetTimeout);
+        if (settings.get().advanced.availability_timeout) {
+            this.extensions.push(new ExtensionDeviceAvailability(
+                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+            ));
        }
    }

-    pollTimer(start) {
-        // Some routers need polling to prevent them from sleeping.
-        if (start && !this._pollTimer) {
-            this._pollTimer = setInterval(() => {
-                const devices = this.zigbee.getAllClients().filter((d) => {
-                    const power = d.powerSource ? d.powerSource.toLowerCase().split(' ')[0] : 'unknown';
-                    return power !== 'battery' && power !== 'unknown' && d.type === 'Router';
-                });
-
-                devices.forEach((d) => this.zigbee.ping(d.ieeeAddr));
-            }, pollInterval);
-        } else if (!start && this._pollTimer) {
-            clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-        }
-    }
-
-    stop(callback) {
-        this.mqtt.disconnect();
-        this.pollTimer(false);
-        this.softResetTimeout(false);
-        this.zigbee.stop(callback);
-    }
-
-    configureDevice(device) {
-        const ieeeAddr = device.ieeeAddr;
-        if (ieeeAddr && device.modelId && !this.configured.includes(ieeeAddr)) {
-            const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-
-            // Call configure function of device.
-            if (mappedModel && mappedModel.configure) {
-                mappedModel.configure(ieeeAddr, this.zigbee.shepherd, this.zigbee.getCoordinator(), (ok, msg) => {
-                    if (ok) {
-                        logger.info(`Succesfully configured ${ieeeAddr}`);
-                    } else {
-                        logger.error(`Failed to configure ${ieeeAddr}`);
-                    }
-                });
+    async start() {
+        const settingsErrors = settings.validate();
+        if (settingsErrors) {
+            logger.error(`Refusing to start, configuration.yaml is not valid, found the following errors:`);
+            for (const error of settingsErrors) {
+                logger.error(`\t - ${error}`);
            }
-
-            // Setup an OnAfIncomingMsg handler if needed.
-            if (mappedModel && mappedModel.onAfIncomingMsg) {
-                mappedModel.onAfIncomingMsg.forEach((ep) => this.zigbee.registerOnAfIncomingMsg(ieeeAddr, ep));
-            }
-
-            this.configured.push(ieeeAddr);
-        }
-    }
-
-    getDeviceStartupLogMessage(device) {
-        let friendlyName = 'unknown';
-        let type = 'unknown';
-        let friendlyDevice = {model: 'unkown', description: 'unknown'};
-        const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-        if (mappedModel) {
-            friendlyDevice = mappedModel;
+            logger.error(
+                `If you don't know how to solve this, read https://www.zigbee2mqtt.io/configuration/configuration.html`,
+            );
+            process.exit(1);
        }

-        if (settings.getDevice(device.ieeeAddr)) {
-            friendlyName = settings.getDevice(device.ieeeAddr).friendly_name;
-        }
+        logger.info(`Logging to directory: '${logger.directory}'`);
+        logger.cleanup();
+        this.state.start();

-        if (device.type) {
-            type = device.type;
-        }
+        const info = await utils.getZigbee2mqttVersion();
+        logger.info(`Starting zigbee2mqtt version ${info.version} (commit #${info.commitHash})`);

-        return `${friendlyName} (${device.ieeeAddr}): ${friendlyDevice.model} - ` +
-            `${friendlyDevice.vendor} ${friendlyDevice.description} (${type})`;
-    }
-
-    handleZigbeeMessage(message) {
-        // Zigbee message receieved, reset soft reset timeout.
-        this.softResetTimeout(true);
-
-        logger.debug('Recieved zigbee message with data', JSON.stringify(message.data));
-        if (message.type == 'devInterview' && !settings.getDevice(message.data)) {
-            logger.info('Connecting with device...');
-            this.mqtt.log('pairing', 'connecting with device');
-        }
-
-        if (message.type == 'devIncoming') {
-            logger.info('Device incoming...');
-            this.mqtt.log('pairing', 'device incoming');
-        }
-
-        // We dont handle messages without endpoints.
-        if (!message.endpoints) {
-            return;
-        }
-
-        const device = message.endpoints[0].device;
-
-        if (!device) {
-            logger.warn('Message without device!');
-            return;
-        }
-
-        // Check if this is a new device.
-        if (!settings.getDevice(device.ieeeAddr)) {
-            logger.info(`New device with address ${device.ieeeAddr} connected!`);
-            settings.addDevice(device.ieeeAddr);
-            this.mqtt.log('device_connected', device.ieeeAddr);
-        }
-
-        // We can't handle devices without modelId.
-        if (!device.modelId) {
-            return;
-        }
-
-        // Map Zigbee modelID to vendor modelID.
-        const modelID = message.endpoints[0].device.modelId;
-        const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(modelID);
-
-        if (!mappedModel) {
-            logger.warn(`Device with modelID '${modelID}' is not supported.`);
-            logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices`);
-            return;
-        }
-
-        // Configure device.
-        this.configureDevice(device);
-
-        // Home Assistant MQTT discovery
-        if (settings.get().homeassistant) {
-            homeassistant.discover(device.ieeeAddr, mappedModel.model, this.mqtt, false);
-        }
-
-        // After this point we cant handle message withoud cid anymore.
-        if (!message.data || (!message.data.cid && !message.data.cmdId)) {
-            return;
-        }
-
-        // Find a conveter for this message.
-        const cid = message.data.cid;
-        const cmdId = message.data.cmdId;
-        const converters = mappedModel.fromZigbee.filter((c) => {
-            if (cid) {
-                return c.cid === cid && c.type === message.type;
-            } else if (cmdId) {
-                return c.cmd === cmdId;
-            }
-
-            return false;
-        });
-
-        if (!converters.length) {
-            if (cid) {
-                logger.warn(
-                    `No converter available for '${mappedModel.model}' with cid '${cid}', ` +
-                    `type '${message.type}' and data '${JSON.stringify(message.data)}'`
-                );
-            } else if (cmdId) {
-                logger.warn(
-                    `No converter available for '${mappedModel.model}' with cmd '${cmdId}' ` +
-                    `and data '${JSON.stringify(message.data)}'`
-                );
-            }
-
-            logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices.`);
-            return;
-        }
-
-        // Convert this Zigbee message to a MQTT message.
-        // Get payload for the message.
-        // - If a payload is returned publish it to the MQTT broker
-        // - If NO payload is returned do nothing. This is for non-standard behaviour
-        //   for e.g. click switches where we need to count number of clicks and detect long presses.
-        converters.forEach((converter) => {
-            const publish = (payload) => {
-                // Don't cache messages with following properties:
-                const dontCacheProperties = ['click', 'action', 'button', 'button_left', 'button_right'];
-                let cache = true;
-                dontCacheProperties.forEach((property) => {
-                    if (payload.hasOwnProperty(property)) {
-                        cache = false;
-                    }
-                });
-
-                this.mqttPublishDeviceState(device.ieeeAddr, payload, cache);
-            };
-
-            const payload = converter.convert(mappedModel, message, publish, settings.getDevice(device.ieeeAddr));
-
-            if (payload) {
-                publish(payload);
-            }
-        });
-    }
-
-    handleMQTTMessage(topic, message) {
-        logger.debug(`Recieved mqtt message on topic '${topic}' with data '${message}'`);
-
-        if (topic.match(mqttConfigRegex)) {
-            this.handleMQTTMessageConfig(topic, message);
-        } else if (topic.match(mqttDeviceRegex) || topic.match(mqttDevicePrefixRegex)) {
-            this.handleMQTTMessageDevice(topic, message, topic.match(mqttDevicePrefixRegex));
-        } else if (topic === 'hass/status') {
-            if (message.toString().toLowerCase() === 'online') {
-                const timer = setTimeout(() => {
-                    this.sendAllCachedStates();
-                    clearTimeout(timer);
-                }, 20000);
-            }
-        } else {
-            logger.warn(`Cannot handle MQTT message with topic '${topic}' and message '${message}'`);
-        }
-    }
-
-    handleMQTTMessageConfig(topic, message) {
-        const option = topic.split('/')[3];
-
-        if (option === 'permit_join') {
-            this.zigbee.permitJoin(message.toString().toLowerCase() === 'true');
-        } else if (option === 'log_level') {
-            const level = message.toString().toLowerCase();
-            if (allowedLogLevels.includes(level)) {
-                logger.info(`Switching log level to '${level}'`);
-                logger.transports.console.level = level;
-                logger.transports.file.level = level;
-            } else {
-                logger.error(`Could not set log level to '${level}'. Allowed level: '${allowedLogLevels.join(',')}'`);
-            }
-        } else if (option === 'devices') {
-            const devices = this.zigbee.getAllClients().map((device) => {
-                const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-                const friendlyDevice = settings.getDevice(device.ieeeAddr);
-
-                return {
-                    ieeeAddr: device.ieeeAddr,
-                    type: device.type,
-                    model: mappedModel ? mappedModel.model : device.modelId,
-                    friendly_name: friendlyDevice ? friendlyDevice.friendly_name : device.ieeeAddr,
-                };
-            });
-
-            this.mqtt.log('devices', devices);
-        } else if (option === 'remove') {
-            message = message.toString();
-            const IDByFriendlyName = settings.getIDByFriendlyName(message);
-            const deviceID = IDByFriendlyName ? IDByFriendlyName : message;
-            const device = this.zigbee.getDevice(deviceID);
-
-            const cleanup = () => {
-                // Clear Home Assistant MQTT discovery message
-                if (settings.get().homeassistant && device) {
-                    const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-                    if (mappedModel) {
-                        homeassistant.clear(deviceID, mappedModel.model, this.mqtt);
-                    }
-                }
-
-                // Remove from configuration.yaml
-                settings.removeDevice(deviceID);
-
-                logger.info(`Successfully removed ${deviceID}`);
-                this.mqtt.log('device_removed', message);
-            };
-
-            // Remove from zigbee network.
-            if (device) {
-                this.zigbee.removeDevice(deviceID, (error) => {
-                    if (!error) {
-                        cleanup();
-                    } else {
-                        logger.error(`Failed to remove ${deviceID}`);
-                    }
-                });
-            } else {
-                cleanup();
-            }
-        } else if (option === 'rename') {
-            const invalid = `Invalid rename message format expected {old: 'friendly_name', new: 'new_name} ` +
-                            `got ${message.toString()}`;
-
-            let json = null;
-            try {
-                json = JSON.parse(message.toString());
-            } catch (e) {
-                logger.error(invalid);
-                return;
-            }
-
-            // Validate message
-            if (!json.new || !json.old) {
-                logger.error(invalid);
-                return;
-            }
-
-            if (settings.changeFriendlyName(json.old, json.new)) {
-                logger.info(`Successfully renamed - ${json.old} to ${json.new} `);
-            } else {
-                logger.error(`Failed to renamed - ${json.old} to ${json.new}`);
-                return;
-            }
-
-            // Homeassistant rediscover
-            if (settings.get().homeassistant) {
-                const ID = settings.getIDByFriendlyName(json.new);
-                const device = this.zigbee.getDevice(ID);
-                const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-                if (mappedModel) {
-                    homeassistant.discover(device.ieeeAddr, mappedModel.model, this.mqtt, true);
-                }
-            }
-        } else {
-            logger.warn(`Cannot handle MQTT config option '${option}' with message '${message}'`);
-        }
-    }
-
-    handleMQTTMessageDevice(topic, message, withPrefix) {
-        const friendlyName = topic.split('/')[1];
-        const topicPrefix = withPrefix ? topic.split('/')[2] : '';
-
-        // Map friendlyName to deviceID.
-        const deviceID = settings.getIDByFriendlyName(friendlyName);
-
-        if (!deviceID) {
-            logger.error(`Cannot handle '${topic}' because deviceID of '${friendlyName}' cannot be found`);
-            return;
-        }
-
-        // Convert the MQTT message to a Zigbee message.
-        let json = null;
+        // Start zigbee
        try {
-            json = JSON.parse(message);
-        } catch (e) {
-            // Cannot be parsed to JSON, assume state message.
-            json = {state: message.toString()};
+            this.zigbee.on('event', this.onZigbeeEvent.bind(this));
+            this.zigbee.on('adapterDisconnected', this.onZigbeeAdapterDisconnected);
+            await this.zigbee.start();
+        } catch (error) {
+            logger.error('Failed to start zigbee');
+            logger.error('Exiting...');
+            logger.error(error.stack);
+            process.exit(1);
        }

-        // Find ep for this device
-        const device = this.zigbee.getDevice(deviceID);
-        if (!device) {
-            logger.error(`Failed to find device with deviceID ${deviceID}`);
-            return;
+        // Log zigbee clients on startup
+        const devices = this.zigbee.getClients();
+        logger.info(`Currently ${devices.length} devices are joined:`);
+        for (const device of devices) {
+            const entity = this.zigbee.resolveEntity(device);
+            logger.info(
+                (entity.settings ? entity.settings.friendlyName : entity.device.ieeeAddr) +
+                ` (${entity.device.ieeeAddr}): ` +
+                (entity.mapped ?
+                    `${entity.mapped.model} - ${entity.mapped.vendor} ${entity.mapped.description} ` :
+                    'Not supported ') +
+                `(${entity.device.type})`,
+            );
        }

-        const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-        if (!mappedModel) {
-            logger.warn(`Device with modelID '${device.modelId}' is not supported.`);
-            logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices`);
-            return;
+        // Enable zigbee join.
+        if (settings.get().permit_join) {
+            logger.warn('`permit_join` set to  `true` in configuration.yaml.');
+            logger.warn('Allowing new devices to join.');
+            logger.warn('Set `permit_join` to `false` once you joined all devices.');
        }

-        const ep = mappedModel.ep && mappedModel.ep[topicPrefix] ? mappedModel.ep[topicPrefix] : null;
-        const published = [];
+        this.zigbee.permitJoin(settings.get().permit_join);

-        Object.keys(json).forEach((key) => {
-            // Find converter for this key.
-            const converter = mappedModel.toZigbee.find((c) => c.key === key);
+        // Call extensions
+        this.callExtensionMethod('onZigbeeStarted', []);

-            if (!converter) {
-                logger.error(`No converter available for '${key}' (${json[key]})`);
-                return;
-            }
+        // MQTT
+        this.mqtt.on('message', this.onMQTTMessage.bind(this));
+        await this.mqtt.connect();

-            const message = converter.convert(json[key], json);
-
-            if (!message) {
-                return;
-            }
-
-            const callback = (error) => {
-                // Devices do not report when they go off, this ensures state (on/off) is always in sync.
-                if (!error && key.startsWith('state')) {
-                    const msg = {};
-                    const _key = topicPrefix ? `${key}_${topicPrefix}` : key;
-                    msg[_key] = json[key];
-                    this.mqttPublishDeviceState(deviceID, msg, true);
+        // Send all cached states.
+        if (settings.get().advanced.cache_state) {
+            for (const device of this.zigbee.getClients()) {
+                if (this.state.exists(device.ieeeAddr)) {
+                    this.publishEntityState(device.ieeeAddr, this.state.get(device.ieeeAddr));
                }
-            };
-
-            this.zigbee.publish(deviceID, message.cid, message.cmd, message.zclData, ep, callback);
-
-            published.push({message: message, converter: converter});
-        });
-
-        /**
-         * After publishing a command to a zigbee device we want to monitor the changed attribute(s) so that
-         * everything stays in sync.
-         */
-        published.forEach((p) => {
-            let counter = 0;
-            let secondsToMonitor = 1;
-
-            // In case of a transition we need to monitor for the whole transition time.
-            if (p.message.zclData.hasOwnProperty('transtime')) {
-                // Note that: transtime 10 = 0.1 seconds, 100 = 1 seconds, etc.
-                secondsToMonitor = (p.message.zclData.transtime / 10) + 1;
            }
+        }

-            const timer = setInterval(() => {
-                counter++;
-
-                // Doing a 'read' will result in the device sending a zigbee message with the current attribute value.
-                // which will be handled by this.handleZigbeeMessage.
-                p.converter.attr.forEach((attribute) => {
-                    this.zigbee.read(deviceID, p.message.cid, attribute, ep, () => null);
-                });
-
-                if (counter >= secondsToMonitor) {
-                    clearTimeout(timer);
-                }
-            }, 1000);
-        });
+        // Call extensions
+        await this.callExtensionMethod('onMQTTConnected', []);
    }

-    mqttPublishDeviceState(deviceID, payload, cache) {
-        if (cacheState) {
-            // Add cached state to payload
-            if (this.stateCache[deviceID]) {
-                payload = objectAssignDeep.noMutate(this.stateCache[deviceID], payload);
-            }
+    async stop() {
+        // Call extensions
+        await this.callExtensionMethod('stop', []);

-            // Update state cache with new state.
-            if (cache) {
-                this.stateCache[deviceID] = payload;
+        // Wrap-up
+        this.state.stop();
+        await this.mqtt.disconnect();
+
+        try {
+            await this.zigbee.stop();
+            process.exit(0);
+        } catch (error) {
+            logger.error('Failed to stop zigbee');
+            process.exit(1);
+        }
+    }
+
+    async onZigbeeAdapterDisconnected() {
+        logger.error('Adapter disconnected, stopping');
+        await this.stop();
+    }
+
+    async onZigbeeEvent(type, data) {
+        const entity = this.zigbee.resolveEntity(data.device || data.ieeeAddr);
+        if (data.device && !entity.settings) {
+            // Only deviceLeave doesn't have a device (not interesting to add to settings)
+            entity.settings = settings.addDevice(data.device.ieeeAddr);
+        }
+
+        const name = entity && entity.settings ? entity.settings.friendlyName : null;
+
+        if (type === 'message') {
+            logger.debug(
+                `Received Zigbee message from '${name}', type '${data.type}', cluster '${data.cluster}'` +
+                `, data '${JSON.stringify(data.data)}' from endpoint ${data.endpoint.ID}` +
+                (data.hasOwnProperty('groupID') ? ` with groupID ${data.groupID}` : ``),
+            );
+        } else if (type === 'deviceJoined') {
+            logger.info(`Device '${name}' joined`);
+            this.mqtt.log('device_connected', {friendly_name: name});
+        } else if (type === 'deviceInterview') {
+            if (data.status === 'successful') {
+                logger.info(`Successfully interviewed '${name}', device has successfully been paired`);
+
+                if (entity.mapped) {
+                    const {vendor, description, model} = entity.mapped;
+                    logger.info(
+                        `Device '${name}' is supported, identified as: ${vendor} ${description} (${model})`,
+                    );
+
+                    const log = {friendly_name: name, model, vendor, description, supported: true};
+                    this.mqtt.log('pairing', 'interview_successful', log);
+                } else {
+                    logger.warn(
+                        `Device '${name}' with Zigbee model '${data.device.modelID}' is NOT supported, ` +
+                        `please follow https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`,
+                    );
+                    this.mqtt.log('pairing', 'interview_successful', {friendly_name: name, supported: false});
+                }
+            } else if (data.status === 'failed') {
+                logger.error(`Failed to interview '${name}', device has not successfully been paired`);
+                this.mqtt.log('pairing', 'interview_failed', {friendly_name: name});
+            } else {
+                /* istanbul ignore else */
+                if (data.status === 'started') {
+                    logger.info(`Starting interview of '${name}'`);
+                    this.mqtt.log('pairing', 'interview_started', {friendly_name: name});
+                }
+            }
+        } else if (type === 'deviceAnnounce') {
+            logger.debug(`Device '${name}' announced itself`);
+        } else {
+            /* istanbul ignore else */
+            if (type === 'deviceLeave') {
+                logger.warn(`Device '${name || data.ieeeAddr}' left the network`);
+                this.mqtt.log('device_removed', 'left_network', {friendly_name: name || data.ieeeAddr});
            }
        }

-        const deviceSettings = settings.getDevice(deviceID);
+        // Call extensions
+        this.callExtensionMethod(
+            'onZigbeeEvent',
+            [type, data, entity ? entity.mapped : null, entity ? entity.settings : null],
+        );
+    }
+
+    onMQTTMessage(payload) {
+        const {topic, message} = payload;
+        logger.debug(`Received MQTT message on '${topic}' with data '${message}'`);
+
+        // Call extensions
+        this.callExtensionMethod('onMQTTMessage', [topic, message]);
+    }
+
+    async publishEntityState(IDorName, payload, stateChangeReason=null) {
+        const entity = this.zigbee.resolveEntity(IDorName);
+        if (!entity || !entity.settings) {
+            logger.error(`'${IDorName}' does not exist, skipping publish`);
+            return;
+        }
+
+        if (entity.type === 'device' && settings.get().advanced.last_seen !== 'disable' && entity.device.lastSeen) {
+            payload.last_seen = utils.formatDate(entity.device.lastSeen, settings.get().advanced.last_seen);
+        }
+
+        let messagePayload = {...payload};
+        const currentState = this.state.exists(entity.settings.ID) ? this.state.get(entity.settings.ID) : {};
+        const newState = objectAssignDeep.noMutate(currentState, payload);
+
+        // Update state cache with new state.
+        this.state.set(entity.settings.ID, newState, stateChangeReason);
+
+        if (settings.get().advanced.cache_state) {
+            // Add cached state to payload
+            messagePayload = newState;
+        }
+
        const options = {
-            retain: deviceSettings.retain,
-            qos: deviceSettings.qos ? deviceSettings.qos : 0,
+            retain: entity.settings.hasOwnProperty('retain') ? entity.settings.retain : false,
+            qos: entity.settings.hasOwnProperty('qos') ? entity.settings.qos : 0,
        };

-        this.mqtt.publish(deviceSettings.friendly_name, JSON.stringify(payload), options);
+        if (entity.type === 'device' && settings.get().mqtt.include_device_information) {
+            const device = this.zigbee.getDeviceByIeeeAddr(entity.device.ieeeAddr);
+            const attributes = [
+                'ieeeAddr', 'networkAddress', 'type', 'manufacturerID', 'manufacturerName', 'powerSource',
+                'applicationVersion', 'stackVersion', 'zclVersion', 'hardwareVersion', 'dateCode', 'softwareBuildID',
+            ];
+
+            messagePayload.device = {friendlyName: entity.name};
+            attributes.forEach((a) => messagePayload.device[a] = device[a]);
+        }
+
+        if (Object.entries(messagePayload).length) {
+            if (settings.get().experimental.output === 'json') {
+                await this.mqtt.publish(entity.name, JSON.stringify(messagePayload), options);
+            } else {
+                /* istanbul ignore else */
+                if (settings.get().experimental.output === 'attribute') {
+                    await this.iteratePayloadAttributeOutput(`${entity.name}/`, messagePayload, options);
+                }
+            }
+        }
    }

-    startupLogVersion(callback) {
-        const git = require('git-last-commit');
-        const packageJSON = require('../package.json');
-        const version = packageJSON.version;
+    async iteratePayloadAttributeOutput(topicRoot, payload, options) {
+        for (const [key, value] of Object.entries(payload)) {
+            let subPayload = value;
+            let message;

-        git.getLastCommit((err, commit) => {
-            let commitHash = null;
-
-            if (err) {
-                try {
-                    commitHash = require('../.hash.json').hash;
-                } catch (error) {
-                    commitHash = 'unknown';
-                }
-            } else {
-                commitHash = commit.shortHash;
+            // Special cases
+            if (key === 'color' && utils.objectHasProperties(subPayload, ['r', 'g', 'b'])) {
+                subPayload = [subPayload.r, subPayload.g, subPayload.b];
            }

-            logger.info(`Starting zigbee2mqtt version ${version} (commit #${commitHash})`);
+            // Check Array first, since it is also an Object
+            if (Array.isArray(subPayload)) {
+                message = subPayload.map((x) => `${x}`).join(',');
+            } else if (typeof subPayload === 'object') {
+                return this.iteratePayloadAttributeOutput(`${topicRoot}${key}-`, subPayload, options);
+            } else {
+                message = typeof subPayload === 'string' ? subPayload : JSON.stringify(subPayload);
+            }

-            callback();
-        });
+            await this.mqtt.publish(`${topicRoot}${key}`, message, options);
+        }
+    }
+
+    async callExtensionMethod(method, parameters) {
+        for (const extension of this.extensions) {
+            if (extension[method]) {
+                try {
+                    await extension[method](...parameters);
+                } catch (error) {
+                    /* istanbul ignore next */
+                    logger.error(`Failed to call '${extension.constructor.name}' '${method}' (${error.stack})`);
+                    /* istanbul ignore next */
+                    if (process.env.JEST_WORKER_ID !== undefined) {
+                        throw error;
+                    }
+                }
+            }
+        }
    }
 }

@@ -0,0 +1,50 @@
+class BaseExtension {
+    /**
+     * Besides intializing variables, the constructor should do nothing!
+     *
+     * @param {Zigbee} zigbee Zigbee controller
+     * @param {MQTT} mqtt MQTT controller
+     * @param {State} state State controller
+     * @param {Function} publishEntityState Method to publish device state to MQTT.
+     */
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        this.zigbee = zigbee;
+        this.mqtt = mqtt;
+        this.state = state;
+        this.publishEntityState = publishEntityState;
+    }
+
+    /**
+     * This method is called by the controller once Zigbee has been started.
+     */
+    // onZigbeeStarted() {}
+
+    /**
+     * This method is called by the controller once connected to the MQTT server.
+     */
+    // onMQTTConnected() {}
+
+    /**
+     * Is called when a Zigbee message from a device is received.
+     * @param {string} type Type of the message
+     * @param {Object} data Data of the message
+     * @param {Object?} mappedDevice The mapped device
+     * @param {Object?} settingsDevice Device settings
+     */
+    // onZigbeeEvent(type, data, mappedDevice, settingsDevice) {}
+
+    /**
+     * Is called when a MQTT message is received
+     * @param {string} topic Topic on which the message was received
+     * @param {Object} message The received message
+     * @return {boolean} if the message was handled
+     */
+    // onMQTTMessage(topic, message) {}
+
+    /**
+     * Is called once the extension has to stop
+     */
+    // stop() {}
+}
+
+module.exports = BaseExtension;
@@ -0,0 +1,331 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const utils = require('../util/utils');
+const assert = require('assert');
+const BaseExtension = require('./baseExtension');
+
+const configRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/config/((?:\\w+/get)|(?:\\w+))`);
+const allowedLogLevels = ['error', 'warn', 'info', 'debug'];
+
+class BridgeConfig extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+
+        // Bind functions
+        this.permitJoin = this.permitJoin.bind(this);
+        this.lastSeen = this.lastSeen.bind(this);
+        this.elapsed = this.elapsed.bind(this);
+        this.reset = this.reset.bind(this);
+        this.logLevel = this.logLevel.bind(this);
+        this.devices = this.devices.bind(this);
+        this.groups = this.groups.bind(this);
+        this.rename = this.rename.bind(this);
+        this.remove = this.remove.bind(this);
+        this.forceRemove = this.forceRemove.bind(this);
+        this.ban = this.ban.bind(this);
+        this.deviceOptions = this.deviceOptions.bind(this);
+        this.addGroup = this.addGroup.bind(this);
+        this.removeGroup = this.removeGroup.bind(this);
+        this.whitelist= this.whitelist.bind(this);
+
+        // Set supported options
+        this.supportedOptions = {
+            'permit_join': this.permitJoin,
+            'last_seen': this.lastSeen,
+            'elapsed': this.elapsed,
+            'reset': this.reset,
+            'log_level': this.logLevel,
+            'devices': this.devices,
+            'groups': this.groups,
+            'devices/get': this.devices,
+            'rename': this.rename,
+            'remove': this.remove,
+            'force_remove': this.forceRemove,
+            'ban': this.ban,
+            'device_options': this.deviceOptions,
+            'add_group': this.addGroup,
+            'remove_group': this.removeGroup,
+            'whitelist': this.whitelist,
+        };
+    }
+
+    whitelist(topic, message) {
+        try {
+            const entity = settings.getEntity(message);
+            assert(entity, `Entity '${message}' does not exist`);
+            settings.whitelistDevice(entity.ID);
+            logger.info(`Whitelisted '${entity.friendlyName}'`);
+            this.mqtt.log('device_whitelisted', {friendly_name: entity.friendlyName});
+        } catch (error) {
+            logger.error(`Failed to whitelist '${message}' '${error}'`);
+        }
+    }
+
+    deviceOptions(topic, message) {
+        let json = null;
+        try {
+            json = JSON.parse(message);
+        } catch (e) {
+            logger.error('Failed to parse message as JSON');
+            return;
+        }
+
+        if (!json.hasOwnProperty('friendly_name') || !json.hasOwnProperty('options')) {
+            logger.error('Invalid JSON message, should contain "friendly_name" and "options"');
+            return;
+        }
+
+        const entity = settings.getEntity(json.friendly_name);
+        assert(entity, `Entity '${json.friendly_name}' does not exist`);
+        settings.changeDeviceOptions(entity.ID, json.options);
+        logger.info(`Changed device specific options of '${json.friendly_name}' (${JSON.stringify(json.options)})`);
+    }
+
+    async permitJoin(topic, message) {
+        await this.zigbee.permitJoin(message.toLowerCase() === 'true');
+        this.publish();
+    }
+
+    async reset(topic, message) {
+        try {
+            await this.zigbee.reset('soft');
+            logger.info('Soft resetted ZNP');
+        } catch (error) {
+            logger.error('Soft reset failed');
+        }
+    }
+
+    lastSeen(topic, message) {
+        const allowed = ['disable', 'ISO_8601', 'epoch', 'ISO_8601_local'];
+        if (!allowed.includes(message)) {
+            logger.error(`${message} is not an allowed value, possible: ${allowed}`);
+            return;
+        }
+
+        settings.set(['advanced', 'last_seen'], message);
+        logger.info(`Set last_seen to ${message}`);
+    }
+
+    elapsed(topic, message) {
+        const allowed = ['true', 'false'];
+        if (!allowed.includes(message)) {
+            logger.error(`${message} is not an allowed value, possible: ${allowed}`);
+            return;
+        }
+
+        settings.set(['advanced', 'elapsed'], message === 'true');
+        logger.info(`Set elapsed to ${message}`);
+    }
+
+    logLevel(topic, message) {
+        const level = message.toLowerCase();
+        if (allowedLogLevels.includes(level)) {
+            logger.info(`Switching log level to '${level}'`);
+            logger.setLevel(level);
+        } else {
+            logger.error(`Could not set log level to '${level}'. Allowed level: '${allowedLogLevels.join(',')}'`);
+        }
+
+        this.publish();
+    }
+
+    async devices(topic, message) {
+        const coordinator = await this.zigbee.getCoordinatorVersion();
+        const devices = this.zigbee.getDevices().map((device) => {
+            const payload = {
+                ieeeAddr: device.ieeeAddr,
+                type: device.type,
+                networkAddress: device.networkAddress,
+            };
+
+            if (device.type !== 'Coordinator') {
+                const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+                const friendlyDevice = settings.getDevice(device.ieeeAddr);
+                payload.model = mappedDevice ? mappedDevice.model : device.modelID;
+                payload.friendly_name = friendlyDevice ? friendlyDevice.friendly_name : device.ieeeAddr;
+                payload.manufacturerID = device.manufacturerID;
+                payload.manufacturerName = device.manufacturerName;
+                payload.powerSource = device.powerSource;
+                payload.modelID = device.modelID;
+                payload.hardwareVersion = device.hardwareVersion;
+                payload.softwareBuildID = device.softwareBuildID;
+                payload.dateCode = device.dateCode;
+                payload.lastSeen = device.lastSeen;
+            } else {
+                payload.friendly_name = 'Coordinator';
+                payload.softwareBuildID = coordinator.type;
+                payload.dateCode = coordinator.meta.revision.toString();
+                payload.lastSeen = Date.now();
+            }
+
+            return payload;
+        });
+
+        if (topic.split('/').pop() == 'get') {
+            this.mqtt.publish(`bridge/config/devices`, JSON.stringify(devices), {});
+        } else {
+            this.mqtt.log('devices', devices);
+        }
+    }
+
+    groups(topic, message) {
+        this.mqtt.log('groups', settings.getGroups().map((g) => {
+            const group = {...g};
+            delete group.friendlyName;
+            return group;
+        }));
+    }
+
+    rename(topic, message) {
+        const invalid = `Invalid rename message format expected {old: 'friendly_name', new: 'new_name} got ${message}`;
+
+        let json = null;
+        try {
+            json = JSON.parse(message);
+        } catch (e) {
+            logger.error(invalid);
+            return;
+        }
+
+        // Validate message
+        if (!json.new || !json.old) {
+            logger.error(invalid);
+            return;
+        }
+
+        try {
+            settings.changeFriendlyName(json.old, json.new);
+            logger.info(`Successfully renamed - ${json.old} to ${json.new} `);
+            this.mqtt.log('device_renamed', {from: json.old, to: json.new});
+        } catch (error) {
+            logger.error(`Failed to rename - ${json.old} to ${json.new}`);
+        }
+    }
+
+    addGroup(topic, message) {
+        let id = null;
+        let name = null;
+        try {
+            // json payload with id and friendly_name
+            const json = JSON.parse(message);
+            if (json.hasOwnProperty('id')) {
+                id = json.id;
+                name = `group_${id}`;
+            }
+            if (json.hasOwnProperty('friendly_name')) {
+                name = json.friendly_name;
+            }
+        } catch (e) {
+            // just friendly_name
+            name = message;
+        }
+
+        if (name == null) {
+            logger.error('Failed to add group, missing friendly_name!');
+            return;
+        }
+
+        const group = settings.addGroup(name, id);
+        this.zigbee.createGroup(group.ID);
+        logger.info(`Added group '${name}'`);
+    }
+
+    removeGroup(topic, message) {
+        const name = message;
+        settings.removeGroup(name);
+        logger.info(`Removed group '${name}'`);
+    }
+
+    async forceRemove(topic, message) {
+        await this.removeForceRemoveOrBan('force_remove', message);
+    }
+
+    async remove(topic, message) {
+        await this.removeForceRemoveOrBan('remove', message);
+    }
+
+    async ban(topic, message) {
+        await this.removeForceRemoveOrBan('ban', message);
+    }
+
+    async removeForceRemoveOrBan(action, message) {
+        const entity = this.zigbee.resolveEntity(message.trim());
+        const lookup = {
+            ban: ['banned', 'Banning', 'ban'],
+            force_remove: ['force_removed', 'Force removing', 'force remove'],
+            remove: ['removed', 'Removing', 'remove'],
+        };
+
+        if (!entity) {
+            logger.error(`Cannot ${lookup[action][2]}, device '${message}' does not exist`);
+            return;
+        }
+
+        const cleanup = () => {
+            // Remove from configuration.yaml
+            settings.removeDevice(entity.settings.ID);
+
+            // Remove from state
+            this.state.remove(entity.settings.ID);
+
+            logger.info(`Successfully ${lookup[action][0]} ${entity.settings.friendlyName}`);
+            this.mqtt.log(`device_${lookup[action][0]}`, message);
+        };
+
+        try {
+            logger.info(`${lookup[action][1]} '${entity.settings.friendlyName}'`);
+            if (action === 'force_remove') {
+                await entity.device.removeFromDatabase();
+            } else {
+                await entity.device.removeFromNetwork();
+            }
+
+            cleanup();
+        } catch (error) {
+            logger.error(`Failed to ${lookup[action][2]} ${entity.settings.friendlyName} (${error})`);
+        }
+
+        if (action === 'ban') {
+            settings.banDevice(entity.settings.ID);
+        }
+    }
+
+    async onMQTTConnected() {
+        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/config/+`);
+        await this.publish();
+    }
+
+    async onMQTTMessage(topic, message) {
+        if (!topic.match(configRegex)) {
+            return false;
+        }
+
+        const option = topic.match(configRegex)[1];
+
+        if (!this.supportedOptions.hasOwnProperty(option)) {
+            return false;
+        }
+
+        await this.supportedOptions[option](topic, message);
+
+        return true;
+    }
+
+    async publish() {
+        const info = await utils.getZigbee2mqttVersion();
+        const coordinator = await this.zigbee.getCoordinatorVersion();
+        const topic = `bridge/config`;
+        const payload = {
+            version: info.version,
+            commit: info.commitHash,
+            coordinator,
+            log_level: logger.getLevel(),
+            permit_join: await this.zigbee.getPermitJoin(),
+        };
+
+        await this.mqtt.publish(topic, JSON.stringify(payload), {retain: true, qos: 0});
+    }
+}
+
+module.exports = BridgeConfig;
@@ -0,0 +1,170 @@
+const logger = require('../util/logger');
+const settings = require('../util/settings');
+const utils = require('../util/utils');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const BaseExtension = require('./baseExtension');
+
+// Some EndDevices should be pinged
+// e.g. E11-G13 https://github.com/Koenkk/zigbee2mqtt/issues/775#issuecomment-453683846
+const forcedPingable = [
+    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'E11-G13'),
+];
+
+const toZigbeeCandidates = ['state', 'brightness', 'color', 'color_temp'];
+
+/**
+ * This extensions pings devices to check if they are online.
+ */
+class DeviceAvailability extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+
+        this.availability_timeout = settings.get().advanced.availability_timeout;
+        this.timers = {};
+        this.state = {};
+
+        // Initialize blacklist
+        this.blacklist = settings.get().advanced.availability_blacklist.map((e) => {
+            return settings.getEntity(e).ID;
+        });
+    }
+
+    isPingable(device) {
+        if (this.blacklist.includes(device.ieeeAddr)) {
+            return false;
+        }
+
+        if (forcedPingable.find((d) => d.zigbeeModel.includes(device.modelID))) {
+            return true;
+        }
+
+        const result = utils.isRouter(device) && !utils.isBatteryPowered(device);
+        return result;
+    }
+
+    getAllPingableDevices() {
+        return this.zigbee.getClients().filter((d) => this.isPingable(d));
+    }
+
+    onMQTTConnected() {
+        // As some devices are not checked for availability (e.g. battery powered devices)
+        // we mark all device as online by default.
+        this.zigbee.getClients().forEach((device) => this.publishAvailability(device, true));
+
+        // Start timers for all devices
+        this.getAllPingableDevices().forEach((device) => this.setTimer(device));
+    }
+
+    async handleInterval(device) {
+        // When a device is already unavailable, log the ping failed on 'debug' instead of 'error'.
+        const ieeeAddr = device.ieeeAddr;
+        const level = this.state.hasOwnProperty(ieeeAddr) && !this.state[ieeeAddr] ? 'debug' : 'error';
+        const entity = this.zigbee.resolveEntity(device.ieeeAddr);
+        try {
+            await device.ping();
+            this.publishAvailability(device, true);
+            logger.debug(`Successfully pinged '${entity.name}'`);
+        } catch (error) {
+            this.publishAvailability(device, false);
+            logger[level](`Failed to ping '${entity.name}'`);
+        } finally {
+            this.setTimer(device);
+        }
+    }
+
+    setTimer(device) {
+        if (this.timers[device.ieeeAddr]) {
+            clearTimeout(this.timers[device.ieeeAddr]);
+        }
+
+        this.timers[device.ieeeAddr] = setTimeout(async () => {
+            await this.handleInterval(device);
+        }, utils.secondsToMilliseconds(this.availability_timeout));
+    }
+
+    async stop() {
+        for (const timer of Object.values(this.timers)) {
+            clearTimeout(timer);
+        }
+
+        this.zigbee.getClients().forEach((device) => this.publishAvailability(device, false));
+    }
+
+    async onReconnect(device) {
+        if (device && device.modelID) {
+            const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+
+            if (mappedDevice) {
+                const used = [];
+                try {
+                    for (const key of toZigbeeCandidates) {
+                        const converter = mappedDevice.toZigbee.find((tz) => tz.key.includes(key));
+                        if (converter && !used.includes(converter)) {
+                            await converter.convertGet(device.endpoints[0], key, {});
+                            used.push(converter);
+                        }
+                    }
+                } catch (error) {
+                    const entity = this.zigbee.resolveEntity(device.ieeeAddr);
+                    logger.error(`Failed to read state of '${entity.name}' after reconnect`);
+                }
+            }
+        }
+    }
+
+    publishAvailability(device, available) {
+        const ieeeAddr = device.ieeeAddr;
+        if (this.state.hasOwnProperty(ieeeAddr) && !this.state[ieeeAddr] && available) {
+            this.onReconnect(device);
+        }
+
+        const deviceSettings = settings.getDevice(ieeeAddr);
+        const name = deviceSettings ? deviceSettings.friendly_name : ieeeAddr;
+        const topic = `${name}/availability`;
+        const payload = available ? 'online' : 'offline';
+        if (this.state[ieeeAddr] !== available) {
+            this.state[ieeeAddr] = available;
+            this.mqtt.publish(topic, payload, {retain: true, qos: 0});
+        }
+    }
+
+    onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        const device = data.device;
+        if (!device) {
+            return;
+        }
+
+        if (this.isPingable(device)) {
+            // When a zigbee message from a device is received we know the device is still alive.
+            // => reset the timer.
+            this.setTimer(device);
+
+            const online = this.state.hasOwnProperty(device.ieeeAddr) && this.state[device.ieeeAddr];
+            const offline = this.state.hasOwnProperty(device.ieeeAddr) && !this.state[device.ieeeAddr];
+
+            if (!online && !offline) {
+                // A new device has been connected
+                this.publishAvailability(device, true);
+            } else if (offline) {
+                // When a message is received and the device is marked as offline, mark it online.
+                this.publishAvailability(device, true);
+            } else {
+                /* istanbul ignore else */
+                if (online && type === 'deviceAnnounce' && !utils.isIkeaTradfriDevice(device)) {
+                    /**
+                     * In case the device is powered off AND on within the availability timeout,
+                     * zigbee2qmtt does not detect the device as offline (device is still marked online).
+                     * When a device is turned on again the state could be out of sync.
+                     * https://github.com/Koenkk/zigbee2mqtt/issues/1383#issuecomment-489412168
+                     * endDeviceAnnce is typically send when a device comes online.
+                     *
+                     * This isn't needed for TRADFRI devices as they already send the state themself.
+                     */
+                    this.onReconnect(device);
+                }
+            }
+        }
+    }
+}
+
+module.exports = DeviceAvailability;
@@ -0,0 +1,72 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const assert = require('assert');
+const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/(bind|unbind)/.+$`);
+const BaseExtension = require('./baseExtension');
+
+const clusters = ['genScenes', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl'];
+
+class DeviceBind extends BaseExtension {
+    onMQTTConnected() {
+        for (let step = 1; step < 20; step++) {
+            this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/bind${'/+'.repeat(step)}`);
+            this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/unbind${'/+'.repeat(step)}`);
+        }
+    }
+
+    async onMQTTMessage(topic, message) {
+        if (!topic.match(topicRegex)) {
+            return null;
+        }
+
+        // Parse topic, retrieve type (bind or unbind) and source
+        topic = topic.replace(`${settings.get().mqtt.base_topic}/bridge/`, '');
+        const type = topic.split('/')[0];
+        const sourceKey = topic.replace(`${type}/`, '');
+        const targetKey = message;
+
+        // Find source; can only be a device and target
+        const source = this.zigbee.resolveEntity(sourceKey);
+        assert(source != null && source.type === 'device', 'Source undefined or not a device');
+        const target = this.zigbee.resolveEntity(targetKey);
+        assert(target != null, 'Target is unknown');
+
+        const sourceName = source.settings.friendlyName;
+        const targetName = target.settings.friendlyName;
+
+        // Find which clusters are supported by both the source and target.
+        // Groups are assumed to support all clusters.
+        for (const cluster of clusters) {
+            const targetValid = target.type === 'group' ||
+                target.device.type === 'Coordinator' || target.endpoint.supportsInputCluster(cluster);
+
+            if (source.endpoint.supportsOutputCluster(cluster) && targetValid) {
+                logger.debug(`${type}ing cluster '${cluster}' from '${sourceName}' to '${targetName}'`);
+                try {
+                    const bindTarget = target.type === 'group' ? target.group : target.endpoint;
+                    if (type === 'bind') {
+                        await source.endpoint.bind(cluster, bindTarget);
+                    } else {
+                        await source.endpoint.unbind(cluster, bindTarget);
+                    }
+
+                    logger.info(
+                        `Successfully ${type === 'bind' ? 'bound' : 'unbound'} cluster '${cluster}' from ` +
+                        `'${sourceName}' to '${targetName}'`,
+                    );
+                    this.mqtt.log(
+                        `device_${type}`,
+                        {from: sourceName, to: targetName, cluster},
+                    );
+                } catch (error) {
+                    logger.error(
+                        `Failed to ${type} cluster '${cluster}' from '${sourceName}' to ` +
+                        `'${targetName}' (${error})`,
+                    );
+                }
+            }
+        }
+    }
+}
+
+module.exports = DeviceBind;
@@ -0,0 +1,83 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const BaseExtension = require('./baseExtension');
+
+class DeviceConfigure extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+
+        this.configuring = new Set();
+        this.attempts = {};
+    }
+
+    shouldConfigure(device, mappedDevice) {
+        if (!device) {
+            return false;
+        }
+
+        if (device.meta.hasOwnProperty('configured') && device.meta.configured === mappedDevice.meta.configureKey) {
+            return false;
+        }
+
+        if (!mappedDevice || !mappedDevice.configure) {
+            return false;
+        }
+
+        if (device.interviewing === true) {
+            return false;
+        }
+
+        return true;
+    }
+
+    async onZigbeeStarted() {
+        this.coordinatorEndpoint = this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
+
+        for (const device of this.zigbee.getClients()) {
+            const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+            const settingsDevice = settings.getDevice(device.ieeeAddr);
+            if (this.shouldConfigure(device, mappedDevice)) {
+                await this.configure(device, mappedDevice, settingsDevice);
+            }
+        }
+    }
+
+    onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        const device = data.device;
+        if (this.shouldConfigure(device, mappedDevice)) {
+            this.configure(device, mappedDevice, settingsDevice);
+        }
+    }
+
+    async configure(device, mappedDevice, settingsDevice) {
+        if (this.configuring.has(device.ieeeAddr) || this.attempts[device.ieeeAddr] >= 3) {
+            return false;
+        }
+
+        this.configuring.add(device.ieeeAddr);
+
+        if (!this.attempts.hasOwnProperty(device.ieeeAddr)) {
+            this.attempts[device.ieeeAddr] = 0;
+        }
+
+        logger.info(`Configuring '${settingsDevice.friendlyName}'`);
+        try {
+            await mappedDevice.configure(device, this.coordinatorEndpoint);
+            logger.info(`Succesfully configured '${settingsDevice.friendlyName}'`);
+            // eslint-disable-next-line
+            device.meta.configured = mappedDevice.meta.configureKey;
+            device.save();
+        } catch (error) {
+            logger.error(
+                `Failed to configure '${settingsDevice.friendlyName}', ` +
+                `attempt ${this.attempts[device.ieeeAddr] + 1} (${error.stack})`,
+            );
+            this.attempts[device.ieeeAddr]++;
+        }
+
+        this.configuring.delete(device.ieeeAddr);
+    }
+}
+
+module.exports = DeviceConfigure;
@@ -0,0 +1,34 @@
+const BaseExtension = require('./baseExtension');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+
+class DeviceEvent extends BaseExtension {
+    async onZigbeeStarted() {
+        for (const device of this.zigbee.getClients()) {
+            this.callOnEvent(device, 'start', {});
+        }
+    }
+
+    onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        if (data.device) {
+            this.callOnEvent(data.device, type, data, mappedDevice);
+        }
+    }
+
+    async stop() {
+        for (const device of this.zigbee.getClients()) {
+            this.callOnEvent(device, 'stop', {});
+        }
+    }
+
+    callOnEvent(device, type, data, mappedDevice) {
+        if (!mappedDevice) {
+            mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+        }
+
+        if (mappedDevice && mappedDevice.onEvent) {
+            mappedDevice.onEvent(type, data, device);
+        }
+    }
+}
+
+module.exports = DeviceEvent;
@@ -0,0 +1,43 @@
+/* istanbul ignore file */
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const BaseExtension = require('./baseExtension');
+
+const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/device/(.+)/get_group_membership$`);
+
+class DeviceGroupMembership extends BaseExtension {
+    onMQTTConnected() {
+        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/device/+/get_group_membership`);
+    }
+
+    async onMQTTMessage(topic, message) {
+        const match = topic.match(topicRegex);
+        if (!match) {
+            return null;
+        }
+
+        const entity = this.zigbee.resolveEntity(match[1]);
+        if (!entity || entity.type !== 'device') {
+            logger.error(`Device '${match[1]}' does not exist`);
+            return;
+        }
+
+        const response = await entity.endpoint.command(
+            `genGroups`, 'getMembership', {groupcount: 0, grouplist: []}, {}, true,
+        );
+
+        const {grouplist, capacity} = response;
+        const msgGroupList = `${entity.device.ieeeAddr} is in groups [${grouplist}]`;
+        let msgCapacity;
+        if (capacity === 254) {
+            msgCapacity = 'it can be a part of at least 1 more group';
+        } else {
+            msgCapacity = `its remaining group capacity is ${capacity === 255 ? 'unknown' : capacity}`;
+        }
+        logger.info(`${msgGroupList} and ${msgCapacity}`);
+
+        this.publishEntityState(entity.device.ieeeAddr, {group_list: grouplist, group_capacity: capacity});
+    }
+}
+
+module.exports = DeviceGroupMembership;
@@ -0,0 +1,156 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const utils = require('../util/utils');
+const debounce = require('debounce');
+const BaseExtension = require('./baseExtension');
+
+class DeviceReceive extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+        this.coordinator = null;
+        this.elapsed = {};
+        this.debouncers = {};
+    }
+
+    async onZigbeeStarted() {
+        this.coordinator = this.zigbee.getDevicesByType('Coordinator')[0];
+    }
+
+    publishDebounce(ieeeAddr, payload, time) {
+        if (!this.debouncers[ieeeAddr]) {
+            this.debouncers[ieeeAddr] = {
+                payload: {},
+                publish: debounce(() => {
+                    this.publishEntityState(ieeeAddr, this.debouncers[ieeeAddr].payload);
+                    this.debouncers[ieeeAddr].payload = {};
+                }, time * 1000),
+            };
+        }
+
+        this.debouncers[ieeeAddr].payload = {...this.debouncers[ieeeAddr].payload, ...payload};
+        this.debouncers[ieeeAddr].publish();
+    }
+
+    canHandleEvent(type, data, mappedDevice) {
+        if (type !== 'message') {
+            return false;
+        }
+
+        if (data.device.ieeeAddr === this.coordinator.ieeeAddr) {
+            logger.debug('Ignoring message from coordinator');
+            return false;
+        }
+
+        /**
+         * Don't handle re-transmitted Xiaomi messages.
+         * https://github.com/Koenkk/zigbee2mqtt/issues/1238
+         *
+         * Some Xiaomi router devices re-transmit messages from Xiaomi end devices.
+         * The source address of these message is set to the one of the Xiaomi router.
+         * Therefore it looks like if the message came from the Xiaomi router, while in
+         * fact it came from the end device.
+         * Handling these message would result in false state updates.
+         * The group ID attribute of these message defines the source address of the end device.
+         * As the same message is also received directly from the end device, it makes no sense
+         * to handle these messages.
+         */
+        const hasGroupID = data.hasOwnProperty('groupID') && data.groupID != 0;
+        if (utils.isXiaomiDevice(data.device) && utils.isRouter(data.device) && hasGroupID) {
+            logger.debug('Skipping re-transmitted Xiaomi message');
+            return false;
+        }
+
+        if (data.device.modelID === null && data.device.interviewing) {
+            logger.debug(`Skipping message, modelID is undefined and still interviewing`);
+            return false;
+        }
+
+        if (!mappedDevice) {
+            logger.warn(`Received message from unsupported device with Zigbee model '${data.device.modelID}'`);
+            logger.warn(`Please see: https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html.`);
+            return false;
+        }
+
+        return true;
+    }
+
+    onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        if (!this.canHandleEvent(type, data, mappedDevice)) {
+            return;
+        }
+
+        const converters = mappedDevice.fromZigbee.filter((c) => {
+            const type = Array.isArray(c.type) ? c.type.includes(data.type) : c.type === data.type;
+            return c.cluster === data.cluster && type;
+        });
+
+        // Check if there is an available converter
+        if (!converters.length) {
+            // Don't log readRsp and raw as warn messages, they are not interesting most of the time.
+            const level = ['readResponse', 'raw'].includes(data.type) ? 'debug' : 'warn';
+            logger[level](
+                `No converter available for '${mappedDevice.model}' with cluster '${data.cluster}' ` +
+                `and type '${data.type}' and data '${JSON.stringify(data.data)}'`,
+            );
+            return;
+        }
+
+        // Convert this Zigbee message to a MQTT message.
+        // Get payload for the message.
+        // - If a payload is returned publish it to the MQTT broker
+        // - If NO payload is returned do nothing. This is for non-standard behaviour
+        //   for e.g. click switches where we need to count number of clicks and detect long presses.
+        const publish = (payload) => {
+            // Add device linkquality.
+            if (data.hasOwnProperty('linkquality')) {
+                payload.linkquality = data.linkquality;
+            }
+
+            if (settings.get().advanced.elapsed) {
+                const now = Date.now();
+                if (this.elapsed[data.device.ieeeAddr]) {
+                    payload.elapsed = now - this.elapsed[data.device.ieeeAddr];
+                }
+
+                this.elapsed[data.device.ieeeAddr] = now;
+            }
+
+            // Check if we have to debounce
+            if (settingsDevice && settingsDevice.hasOwnProperty('debounce')) {
+                this.publishDebounce(data.device.ieeeAddr, payload, settingsDevice.debounce);
+            } else {
+                this.publishEntityState(data.device.ieeeAddr, payload);
+
+                if (settings.get().homeassistant) {
+                    /**
+                     * Publish an empty value for click and action payload, in this way Home Assistant
+                     * can use Home Assistant entities in automations.
+                     * https://github.com/Koenkk/zigbee2mqtt/issues/959#issuecomment-480341347
+                     */
+                    Object.keys(payload).forEach((key) => {
+                        if (['action', 'click'].includes(key)) {
+                            const counterPayload = {};
+                            counterPayload[key] = '';
+                            this.publishEntityState(data.device.ieeeAddr, counterPayload);
+                        }
+                    });
+                }
+            }
+        };
+
+        let payload = {};
+        converters.forEach((converter) => {
+            const options = {...settings.get().device_options, ...settings.getDevice(data.device.ieeeAddr)};
+            const converted = converter.convert(mappedDevice, data, publish, options);
+            if (converted) {
+                payload = {...payload, ...converted};
+            }
+        });
+
+        if (Object.keys(payload).length) {
+            publish(payload);
+        }
+    }
+}
+
+module.exports = DeviceReceive;
@@ -0,0 +1,188 @@
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const logger = require('../util/logger');
+const CC2530Router = zigbeeHerdsmanConverters.devices.find((d) => d.model === 'CC2530.ROUTER');
+const utils = require('../util/utils');
+const BaseExtension = require('./baseExtension');
+const debounce = require('debounce');
+const ZigbeeHerdsman = require('zigbee-herdsman');
+
+const defaultConfiguration = {
+    minimumReportInterval: 3, maximumReportInterval: 300, reportableChange: 0,
+};
+
+const reportKey = 1;
+
+const clusters = {
+    'genOnOff': [
+        {attribute: 'onOff', ...defaultConfiguration, minimumReportInterval: 0, reportableChange: 0},
+    ],
+    'genLevelCtrl': [
+        {attribute: 'currentLevel', ...defaultConfiguration},
+    ],
+    'lightingColorCtrl': [
+        {attribute: 'colorTemperature', ...defaultConfiguration},
+        {attribute: 'currentX', ...defaultConfiguration},
+        {attribute: 'currentY', ...defaultConfiguration},
+    ],
+    'closuresWindowCovering': [
+        {attribute: 'currentPositionLiftPercentage', ...defaultConfiguration},
+        {attribute: 'currentPositionTiltPercentage', ...defaultConfiguration},
+    ],
+};
+
+const pollOnMessage = [
+    {
+        // Key is used this.pollDebouncers uniqueness
+        key: 1,
+        // On messages that have the cluster and type of below
+        cluster: {
+            manuSpecificPhilips: [
+                {type: 'commandHueNotification', data: {button: 2}},
+                {type: 'commandHueNotification', data: {button: 3}},
+            ],
+            genLevelCtrl: [
+                {type: 'commandStep', data: {}},
+                {type: 'commandStepWithOnOff', data: {}},
+                {type: 'commandStop', data: {}},
+                {type: 'commandMoveWithOnOff', data: {}},
+                {type: 'commandStopWithOnOff', data: {}},
+                {type: 'commandMove', data: {}},
+            ],
+        },
+        // Read the following attributes
+        read: {cluster: 'genLevelCtrl', attributes: ['currentLevel']},
+        // When the bound devices/members of group have the following manufacturerID
+        manufacturerID: ZigbeeHerdsman.Zcl.ManufacturerCode.Philips,
+    },
+];
+
+class DeviceReport extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+        this.configuring = new Set();
+        this.failed = new Set();
+        this.pollDebouncers = {};
+    }
+
+    async setupReporting(device) {
+        if (this.configuring.has(device.ieeeAddr) || this.failed.has(device.ieeeAddr)) return;
+        this.configuring.add(device.ieeeAddr);
+
+        try {
+            for (const endpoint of device.endpoints) {
+                for (const [cluster, configuration] of Object.entries(clusters)) {
+                    if (endpoint.supportsInputCluster(cluster)) {
+                        logger.debug(`Setup reporting for '${device.ieeeAddr}' - ${endpoint.ID} - ${cluster}`);
+                        await endpoint.bind(cluster, this.coordinatorEndpoint);
+                        await endpoint.configureReporting(cluster, configuration);
+                        logger.info(
+                            `Succesfully setup reporting for '${device.ieeeAddr}' - ${endpoint.ID} - ${cluster}`,
+                        );
+                    }
+                }
+            }
+
+            // eslint-disable-next-line
+            device.meta.reporting = reportKey;
+        } catch (error) {
+            logger.error(
+                `Failed to setup reporting for '${device.ieeeAddr}' - ${error.stack}`,
+            );
+
+            this.failed.add(device.ieeeAddr);
+        }
+
+        device.save();
+        this.configuring.delete(device.ieeeAddr);
+    }
+
+    shouldSetupReporting(mappedDevice, device, messageType) {
+        if (!device) return false;
+
+        // Handle messages of type endDeviceAnnce and devIncoming.
+        // This message is typically send when a device comes online after being powered off
+        // Ikea TRADFRI tend to forget their reporting after powered off.
+        // Re-setup reporting.
+        // https://github.com/Koenkk/zigbee2mqtt/issues/966
+        if (messageType === 'deviceAnnounce' && utils.isIkeaTradfriDevice(device)) return true;
+
+        if (device.meta.hasOwnProperty('reporting') && device.meta.reporting === reportKey) return false;
+        if (!utils.isRouter(device) || utils.isBatteryPowered(device)) return false;
+        // Gledopto devices don't support reporting.
+        if (mappedDevice === CC2530Router || mappedDevice.vendor === 'Gledopto') return false;
+        return true;
+    }
+
+    async onZigbeeStarted() {
+        this.coordinatorEndpoint = this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
+
+        for (const device of this.zigbee.getClients()) {
+            const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+            if (this.shouldSetupReporting(mappedDevice, device, null)) {
+                this.setupReporting(device);
+            }
+        }
+    }
+
+    onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        if (this.shouldSetupReporting(mappedDevice, data.device, type)) {
+            this.setupReporting(data.device);
+        }
+
+        if (type === 'message') {
+            this.poll(data);
+        }
+    }
+
+    poll(message) {
+        /**
+         * This method poll bound endpoints and group members for state changes.
+         *
+         * A use case is e.g. a Hue Dimmer switch bound to a Hue bulb.
+         * Hue bulbs only report their on/off state.
+         * When dimming the bulb via the dimmer switch the state is therefore not reported.
+         * When we receive a message from a Hue dimmer we read the brightness from the bulb (if bound).
+         */
+        const polls = pollOnMessage.filter((p) =>
+            p.cluster[message.cluster] && p.cluster[message.cluster].find((c) => c.type === message.type &&
+            utils.equalsPartial(message.data, c.data)),
+        );
+
+        if (polls.length) {
+            let toPoll = [];
+
+            // Add bound devices
+            toPoll = toPoll.concat([].concat(...message.device.endpoints.map((e) => e.binds.map((e) => e))));
+            toPoll = toPoll.filter((e) => e.target.constructor.name === 'Endpoint');
+            toPoll = toPoll.filter((e) => e.target.getDevice().type !== 'Coordinator');
+            toPoll = toPoll.map((e) => e.target);
+
+            // If message is published to a group, add members of the group
+            const group = message.groupID !== 0 ? this.zigbee.getGroupByID(message.groupID) : null;
+            if (group) {
+                toPoll = toPoll.concat(group.members);
+            }
+
+            toPoll = new Set(toPoll);
+
+            for (const endpoint of toPoll) {
+                for (const poll of polls) {
+                    if (poll.manufacturerID !== endpoint.getDevice().manufacturerID) {
+                        continue;
+                    }
+
+                    const key = `${endpoint.deviceIeeeAddress}_${endpoint.ID}_${poll.key}`;
+                    if (!this.pollDebouncers[key]) {
+                        this.pollDebouncers[key] = debounce(async () => {
+                            await endpoint.read(poll.read.cluster, poll.read.attributes);
+                        }, 1000);
+                    }
+
+                    this.pollDebouncers[key]();
+                }
+            }
+        }
+    }
+}
+
+module.exports = DeviceReport;
@@ -0,0 +1,200 @@
+
+const settings = require('../util/settings');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const logger = require('../util/logger');
+const utils = require('../util/utils');
+const assert = require('assert');
+const BaseExtension = require('./baseExtension');
+
+const postfixes = utils.getPostfixes();
+const topicRegex = new RegExp(`^(.+?)(?:/(${postfixes.join('|')}))?/(get|set)(?:/(.+))?`);
+
+const groupConverters = [
+    zigbeeHerdsmanConverters.toZigbeeConverters.light_onoff_brightness,
+    zigbeeHerdsmanConverters.toZigbeeConverters.light_colortemp,
+    zigbeeHerdsmanConverters.toZigbeeConverters.light_color,
+    zigbeeHerdsmanConverters.toZigbeeConverters.light_alert,
+    zigbeeHerdsmanConverters.toZigbeeConverters.ignore_transition,
+];
+
+class EntityPublish extends BaseExtension {
+    onMQTTConnected() {
+        // Subscribe to topics.
+        const baseTopic = settings.get().mqtt.base_topic;
+        for (let step = 1; step < 20; step++) {
+            const topic = `${baseTopic}/${'+/'.repeat(step)}`;
+            this.mqtt.subscribe(`${topic}set`);
+            this.mqtt.subscribe(`${topic}set/+`);
+            this.mqtt.subscribe(`${topic}get`);
+            this.mqtt.subscribe(`${topic}get/+`);
+        }
+    }
+
+    parseTopic(topic) {
+        const match = topic.match(topicRegex);
+        if (!match) {
+            return null;
+        }
+
+        const ID = match[1].replace(`${settings.get().mqtt.base_topic}/`, '');
+        // If we didn't replace base_topic we received something we don't care about
+        if (ID === match[1] || ID.match(/bridge/)) {
+            return null;
+        }
+
+        return {ID: ID, postfix: match[2] || '', type: match[3], attribute: match[4]};
+    }
+
+    async onMQTTMessage(topic, message) {
+        topic = this.parseTopic(topic);
+        if (!topic) {
+            return false;
+        }
+
+        const entityName = `${topic.ID}` + (topic.postfix ? `/${topic.postfix}` : '');
+        const entity = this.zigbee.resolveEntity(entityName);
+
+        if (!entity) {
+            this.mqtt.log('entity_not_found', {friendly_name: entityName});
+            logger.error(`Entity '${entityName}' is unknown`);
+            return;
+        }
+
+        // Get entity details
+        let converters = null;
+        let target = null;
+        let options = {};
+        let device = null;
+        let mapped = null;
+
+        assert(entity.type === 'device' || entity.type === 'group');
+        if (entity.type === 'device') {
+            // Map device to a model
+            if (!entity.mapped) {
+                logger.warn(`Device with modelID '${entity.device.modelID}' is not supported.`);
+                logger.warn(`Please see: https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`);
+                return;
+            }
+
+            device = entity.device;
+            mapped = entity.mapped;
+            target = entity.endpoint;
+            converters = entity.mapped.toZigbee;
+            options = entity.mapped.meta && entity.mapped.meta.options ? entity.mapped.meta.options : {};
+            options = {...options, ...entity.settings};
+        } else {
+            converters = groupConverters;
+            target = entity.group;
+            options = entity.settings;
+        }
+
+        // Convert the MQTT message to a Zigbee message.
+        let json = {};
+        if (topic.hasOwnProperty('attribute') && topic.attribute) {
+            json[topic.attribute] = message;
+        } else {
+            try {
+                json = JSON.parse(message);
+            } catch (e) {
+                // Cannot be parsed to JSON, assume state message.
+                json = {state: message};
+            }
+        }
+
+        /**
+         * Home Assistant always publishes 'state', even when e.g. only setting
+         * the color temperature. This would lead to 2 zigbee publishes, where the first one
+         * (state) is probably unecessary.
+         */
+        const deviceState = this.state.get(entity.settings.ID) || {};
+        if (settings.get().homeassistant) {
+            const hasColorTemp = json.hasOwnProperty('color_temp');
+            const hasColor = json.hasOwnProperty('color');
+            const hasBrightness = json.hasOwnProperty('brightness');
+            const isOn = deviceState && deviceState.state === 'ON' ? true : false;
+            if (isOn && (hasColorTemp || hasColor) && !hasBrightness) {
+                delete json.state;
+                logger.debug('Skipping state because of Home Assistant');
+            }
+        }
+
+        // Ensure that state and brightness are executed before other commands.
+        const entries = Object.entries(json);
+        entries.sort((a, b) => (['state', 'brightness'].includes(a[0]) ? -1 : 1));
+
+        // For each attribute call the corresponding converter
+        const usedConverters = [];
+        for (const [key, value] of entries) {
+            const converter = converters.find((c) => c.key.includes(key));
+
+            if (usedConverters.includes(converter)) {
+                // Use a converter only once (e.g. light_onoff_brightness converters can convert state and brightness)
+                continue;
+            }
+
+            if (!converter) {
+                logger.error(`No converter available for '${key}' (${json[key]})`);
+                continue;
+            }
+
+            // Converter didn't return a result, skip
+            const meta = {
+                endpoint_name: topic.postfix,
+                options,
+                message: json,
+                logger,
+                device,
+                state: deviceState,
+                mapped,
+            };
+
+            try {
+                if (topic.type === 'set' && converter && converter.convertSet) {
+                    logger.debug(`Publishing '${topic.type}' '${key}' to '${entity.name}'`);
+                    const result = await converter.convertSet(target, key, value, meta);
+                    if (result && result.hasOwnProperty('state')) {
+                        const msg = result.state;
+
+                        if (topic.postfix) {
+                            msg[`state_${topic.postfix}`] = msg.state;
+                            delete msg.state;
+                        }
+
+                        this.publishEntityState(entity.settings.ID, msg);
+                    }
+
+                    // It's possible for devices to get out of sync when writing an attribute that's not reportable.
+                    // So here we re-read the value after a specified timeout, this timeout could for example be the
+                    // transition time of a color change or for forcing a state read for devices that don't
+                    // automatically report a new state when set.
+                    // When reporting is requested for a device (report: true in device-specific settings) we won't
+                    // ever issue a read here, as we assume the device will properly report changes.
+                    // Only do this when the retrieve_state option is enabled for this device.
+                    if (
+                        entity.type === 'device' && result && result.hasOwnProperty('readAfterWriteTime') &&
+                        entity.settings.retrieve_state
+                    ) {
+                        setTimeout(() => converter.convertGet(target, key, meta), result.readAfterWriteTime);
+                    }
+                } else if (topic.type === 'get' && converter && converter.convertGet) {
+                    logger.debug(`Publishing get '${topic.type}' '${key}' to '${entity.name}'`);
+                    await converter.convertGet(target, key, meta);
+                } else {
+                    logger.error(`No converter available for '${topic.type}' '${key}' (${json[key]})`);
+                    continue;
+                }
+            } catch (error) {
+                const message =
+                    `Publish '${topic.type}' '${key}' to '${entity.name}' failed: '${error}'`;
+                logger.error(message);
+                this.mqtt.log('zigbee_publish_error', message, {friendly_name: entity.name});
+            }
+
+            usedConverters.push(converter);
+        }
+
+        return true;
+    }
+}
+
+module.exports = EntityPublish;
@@ -0,0 +1,195 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const BaseExtension = require('./baseExtension');
+
+const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/(.+)/(remove|add|remove_all)$`);
+const topicRegexRemoveAll = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/remove_all$`);
+
+class Groups extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+        this.onStateChange = this.onStateChange.bind(this);
+    }
+
+    onMQTTConnected() {
+        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/group/remove_all`);
+
+        for (let step = 1; step < 20; step++) {
+            const topic = `${settings.get().mqtt.base_topic}/bridge/group/${'+/'.repeat(step)}`;
+            this.mqtt.subscribe(`${topic}remove`);
+            this.mqtt.subscribe(`${topic}add`);
+            this.mqtt.subscribe(`${topic}remove_all`); // DEPRECATED
+        }
+    }
+
+    async onZigbeeStarted() {
+        await this.syncGroupsWithSettings();
+        this.state.on('stateChange', this.onStateChange);
+    }
+
+    async syncGroupsWithSettings() {
+        const settingsGroups = settings.getGroups();
+        const zigbeeGroups = this.zigbee.getGroups();
+        for (const settingGroup of settingsGroups) {
+            const groupID = settingGroup.ID;
+            const zigbeeGroup = zigbeeGroups.find((g) => g.groupID === groupID) || this.zigbee.createGroup(groupID);
+            const settingsEntity = settingGroup.devices.map((d) => {
+                const entity = this.zigbee.resolveEntity(d);
+                if (!entity) logger.error(`Cannot find '${d}' of group '${settingGroup.friendlyName}'`);
+                return entity;
+            }).filter((e) => e != null);
+
+            // In settings but not in zigbee
+            for (const entity of settingsEntity) {
+                if (!zigbeeGroup.hasMember(entity.endpoint)) {
+                    logger.info(`Adding '${entity.name}' to group '${settingGroup.friendlyName}'`);
+                    await entity.endpoint.addToGroup(zigbeeGroup);
+                }
+            }
+
+            // In zigbee but not in settings
+            for (const endpoint of zigbeeGroup.members) {
+                if (!settingsEntity.find((e) => e.endpoint === endpoint)) {
+                    const deviceSettings = settings.getDevice(endpoint.getDevice().ieeeAddr);
+                    logger.info(`Removing '${deviceSettings.friendlyName}' from group '${settingGroup.friendlyName}'`);
+                    await endpoint.removeFromGroup(zigbeeGroup);
+                }
+            }
+        }
+
+        // eslint-disable-next-line
+        for (const zigbeeGroup of zigbeeGroups) {
+            if (!settingsGroups.find((g) => g.ID === zigbeeGroup.groupID)) {
+                for (const endpoint of zigbeeGroup.members) {
+                    const deviceSettings = settings.getDevice(endpoint.getDevice().ieeeAddr);
+                    logger.info(`Removing '${deviceSettings.friendlyName}' from group ${zigbeeGroup.groupID}`);
+                    await endpoint.removeFromGroup(zigbeeGroup);
+                }
+            }
+        }
+    }
+
+    async onStateChange(data) {
+        const reason = 'group_optimistic';
+        if (data.reason === reason) {
+            return;
+        }
+
+        const properties = ['state', 'brightness', 'color_temp', 'color'];
+        const payload = {};
+
+        properties.forEach((prop) => {
+            if (data.to.hasOwnProperty(prop)) {
+                payload[prop] = data.to[prop];
+            }
+        });
+
+        if (Object.keys(payload).length) {
+            const entity = this.zigbee.resolveEntity(data.ID);
+            const zigbeeGroups = this.zigbee.getGroups().filter((zigbeeGroup) => {
+                const settingsGroup = settings.getGroup(zigbeeGroup.groupID);
+                return settingsGroup && settingsGroup.optimistic;
+            });
+
+            if (entity.type === 'device') {
+                for (const zigbeeGroup of zigbeeGroups) {
+                    if (zigbeeGroup.hasMember(entity.endpoint)) {
+                        if (!payload || payload.state !== 'OFF' || this.allMembersOff(zigbeeGroup)) {
+                            await this.publishEntityState(zigbeeGroup.groupID, payload, reason);
+                        }
+                    }
+                }
+            } else {
+                const groupIDsToPublish = new Set();
+                for (const member of entity.group.members) {
+                    await this.publishEntityState(member.getDevice().ieeeAddr, payload, reason);
+                    for (const zigbeeGroup of zigbeeGroups) {
+                        if (zigbeeGroup.hasMember(member)) {
+                            if (!payload || payload.state !== 'OFF' || this.allMembersOff(zigbeeGroup)) {
+                                groupIDsToPublish.add(zigbeeGroup.groupID);
+                            }
+                        }
+                    }
+                }
+                groupIDsToPublish.delete(entity.group.groupID);
+                for (const groupID of groupIDsToPublish) {
+                    await this.publishEntityState(groupID, payload, reason);
+                }
+            }
+        }
+    }
+
+    allMembersOff(zigbeeGroup) {
+        for (const member of zigbeeGroup.members) {
+            const device = member.getDevice();
+            if (this.state.exists(device.ieeeAddr)) {
+                const state = this.state.get(device.ieeeAddr);
+                if (state && state.state === 'ON') {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    async onMQTTMessage(topic, message) {
+        let type;
+        let group;
+        const topicMatch = topic.match(topicRegex);
+        if (topicMatch) {
+            group = this.zigbee.resolveEntity(topicMatch[1]);
+            type = topicMatch[2];
+
+            if (!group || group.type !== 'group') {
+                logger.error(`Group '${topicMatch[1]}' does not exist`);
+                return;
+            }
+        } else if (topic.match(topicRegexRemoveAll)) {
+            type = 'remove_all';
+        } else {
+            return;
+        }
+
+        const entity = this.zigbee.resolveEntity(message);
+        if (!entity || !entity.type === 'device') {
+            logger.error(`Device '${message}' does not exist`);
+            return;
+        }
+
+        const keys = [
+            `${entity.device.ieeeAddr}/${entity.endpoint.ID}`,
+            `${entity.name}/${entity.endpoint.ID}`,
+        ];
+
+        if (entity.endpointName) {
+            keys.push(`${entity.device.ieeeAddr}/${entity.endpointName}`);
+            keys.push(`${entity.name}/${entity.endpointName}`);
+        }
+
+        if (entity.isDefaultEndpoint) {
+            keys.push(entity.name);
+            keys.push(entity.device.ieeeAddr);
+        }
+
+        if (type === 'add') {
+            logger.info(`Adding '${entity.name}' to '${group.name}'`);
+            await entity.endpoint.addToGroup(group.group);
+            settings.addDeviceToGroup(group.settings.ID, keys);
+            this.mqtt.log('device_group_add', {friendly_name: entity.name, group: group.name});
+        } else if (type === 'remove') {
+            logger.info(`Removing '${entity.name}' from '${group.name}'`);
+            await entity.endpoint.removeFromGroup(group.group);
+            settings.removeDeviceFromGroup(group.settings.ID, keys);
+            this.mqtt.log('device_group_remove', {friendly_name: entity.name, group: group.name});
+        } else { // remove_all
+            logger.info(`Removing '${entity.name}' from all groups`);
+            await entity.endpoint.removeFromAllGroups();
+            for (const settingsGroup of settings.getGroups()) {
+                settings.removeDeviceFromGroup(settingsGroup.ID, keys);
+                this.mqtt.log('device_group_remove_all', {friendly_name: entity.name});
+            }
+        }
+    }
+}
+
+module.exports = Groups;
@@ -0,0 +1,196 @@
+const settings = require('../util/settings');
+const utils = require('../util/utils');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const logger = require('../util/logger');
+const BaseExtension = require('./baseExtension');
+
+class NetworkMap extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+
+        // Subscribe to topic.
+        this.topic = `${settings.get().mqtt.base_topic}/bridge/networkmap`;
+        this.topicRoutes = `${settings.get().mqtt.base_topic}/bridge/networkmap/routes`;
+
+        // Bind
+        this.raw = this.raw.bind(this);
+        this.graphviz = this.graphviz.bind(this);
+
+        // Set supported formats
+        this.supportedFormats = {
+            'raw': this.raw,
+            'graphviz': this.graphviz,
+        };
+    }
+
+    onMQTTConnected() {
+        this.mqtt.subscribe(this.topic);
+        this.mqtt.subscribe(this.topicRoutes);
+    }
+
+    async onMQTTMessage(topic, message) {
+        if ((topic === this.topic || topic === this.topicRoutes) && this.supportedFormats.hasOwnProperty(message)) {
+            const includeRoutes = topic === this.topicRoutes;
+            const topology = await this.networkScan(includeRoutes);
+            const converted = this.supportedFormats[message](topology);
+            this.mqtt.publish(`bridge/networkmap/${message}`, converted, {});
+        }
+    }
+
+    raw(topology) {
+        return JSON.stringify(topology);
+    }
+
+    graphviz(topology) {
+        const colors = settings.get().map_options.graphviz.colors;
+
+        let text = 'digraph G {\nnode[shape=record];\n';
+        let style = '';
+
+        topology.nodes.forEach((device) => {
+            const labels = [];
+
+            // Add friendly name
+            labels.push(`${device.friendlyName}`);
+
+            // Add the device short network address, ieeaddr and scan note (if any)
+            labels.push(
+                `${device.ieeeAddr} (${device.networkAddress})` +
+                ((device.failed && device.failed.length) ? `failed: ${device.failed.join(',')}` : ''),
+            );
+
+            // Add the device model
+            if (device.type !== 'Coordinator') {
+                const mappedModel = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+                if (mappedModel) {
+                    labels.push(`${mappedModel.vendor} ${mappedModel.description} (${mappedModel.model})`);
+                } else {
+                    // This model is not supported by zigbee-herdsman-converters, add zigbee model information
+                    labels.push(`${device.manufacturerName} ${device.modelID}`);
+                }
+            }
+
+            // Add the device last_seen timestamp
+            let lastSeen = 'unknown';
+            const date = device.type === 'Coordinator' ? Date.now() : device.lastSeen;
+            if (date) {
+                lastSeen = utils.formatDate(date, 'ISO_8601_local');
+            }
+
+            labels.push(lastSeen);
+
+            // Shape the record according to device type
+            if (device.type == 'Coordinator') {
+                style = `style="bold, filled", fillcolor="${colors.fill.coordinator}", ` +
+                    `fontcolor="${colors.font.coordinator}"`;
+            } else if (device.type == 'Router') {
+                style = `style="rounded, filled", fillcolor="${colors.fill.router}", ` +
+                    `fontcolor="${colors.font.router}"`;
+            } else {
+                style = `style="rounded, dashed, filled", fillcolor="${colors.fill.enddevice}", ` +
+                    `fontcolor="${colors.font.enddevice}"`;
+            }
+
+            // Add the device with its labels to the graph as a node.
+            text += `  "${device.ieeeAddr}" [`+style+`, label="{${labels.join('|')}}"];\n`;
+
+            /**
+             * Add an edge between the device and its child to the graph
+             * NOTE: There are situations where a device is NOT in the topology, this can be e.g.
+             * due to not responded to the lqi scan. In that case we do not add an edge for this device.
+             */
+            topology.links.filter((e) => (e.source.ieeeAddr === device.ieeeAddr)).forEach((e) => {
+                const lineStyle = (device.type=='EndDevice') ? 'penwidth=1, ' :
+                    (!e.routes.length) ? 'penwidth=0.5, ' : 'penwidth=2, ';
+                const lineWeight = (!e.routes.length) ? `weight=0, color="${colors.line.inactive}", ` :
+                    `weight=1, color="${colors.line.active}", `;
+                const textRoutes = e.routes.map((r) => r.destinationAddress);
+                const lineLabels = (!e.routes.length) ? `label="${e.linkquality}"` :
+                    `label="${e.linkquality} (routes: ${textRoutes.join(',')})"`;
+                text += `  "${device.ieeeAddr}" -> "${e.target.ieeeAddr}"`;
+                text += ` [${lineStyle}${lineWeight}${lineLabels}]\n`;
+            });
+        });
+
+        text += '}';
+
+        return text.replace(/\0/g, '');
+    }
+
+    async networkScan(includeRoutes) {
+        logger.info(`Starting network scan (includeRoutes '${includeRoutes}')`);
+        const devices = this.zigbee.getDevices();
+        const lqis = new Map();
+        const routingTables = new Map();
+        const failed = new Map();
+
+        for (const device of devices.filter((d) => d.type != 'EndDevice')) {
+            failed.set(device, []);
+            const resolved = this.zigbee.resolveEntity(device);
+            try {
+                const result = await device.lqi();
+                lqis.set(device, result);
+                logger.debug(`LQI succeeded for '${resolved.name}'`);
+            } catch (error) {
+                failed.get(device).push('lqi');
+                logger.error(`Failed to execute LQI for '${resolved.name}'`);
+            }
+
+            if (includeRoutes) {
+                try {
+                    const result = await device.routingTable();
+                    routingTables.set(device, result);
+                    logger.debug(`Routing table succeeded for '${resolved.name}'`);
+                } catch (error) {
+                    failed.get(device).push('routingTable');
+                    logger.error(`Failed to execute routing table for '${resolved.name}'`);
+                }
+            }
+        }
+
+        logger.info(`Network scan finished`);
+
+        const networkMap = {nodes: [], links: []};
+        // Add nodes
+        for (const device of devices) {
+            const resolved = this.zigbee.resolveEntity(device);
+            networkMap.nodes.push({
+                ieeeAddr: device.ieeeAddr, friendlyName: resolved.name, type: device.type,
+                networkAddress: device.networkAddress, manufacturerName: device.manufacturerName,
+                modelID: device.modelID, failed: failed.get(device), lastSeen: device.lastSeen,
+            });
+        }
+
+        // Add links
+        lqis.forEach((lqi, device) => {
+            for (const neighbor of lqi.neighbors) {
+                if (neighbor.relationship > 3) {
+                    // Relationship is not active, skip it
+                    continue;
+                }
+
+                const link = {
+                    source: {ieeeAddr: neighbor.ieeeAddr, networkAddress: neighbor.networkAddress},
+                    target: {ieeeAddr: device.ieeeAddr, networkAddress: device.networkAddress},
+                    linkquality: neighbor.linkquality, depth: neighbor.depth, routes: [],
+                    // DEPRECATED:
+                    sourceIeeeAddr: neighbor.ieeeAddr, targetIeeeAddr: device.ieeeAddr,
+                    sourceNwkAddr: neighbor.networkAddress, lqi: neighbor.linkquality,
+                    relationship: neighbor.relationship,
+                };
+
+                const routingTable = routingTables.get(device);
+                if (routingTable) {
+                    link.routes = routingTable.table
+                        .filter((t) => t.status === 'ACTIVE' && t.nextHop === neighbor.networkAddress);
+                }
+
+                networkMap.links.push(link);
+            }
+        });
+
+        return networkMap;
+    }
+}
+
+module.exports = NetworkMap;
@@ -0,0 +1,66 @@
+/* istanbul ignore file */
+// DEPRECATED
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const utils = require('../util/utils');
+const BaseExtension = require('./baseExtension');
+
+/**
+ * This extensions soft resets the ZNP after a certain timeout.
+ */
+class SoftReset extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState) {
+        super(zigbee, mqtt, state, publishEntityState);
+        this.timer = null;
+        this.timeout = utils.secondsToMilliseconds(settings.get().advanced.soft_reset_timeout);
+    }
+
+    onZigbeeStarted() {
+        logger.debug(`Soft reset timeout set to ${utils.millisecondsToSeconds(this.timeout)} seconds`);
+        this.resetTimer();
+    }
+
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+
+    resetTimer() {
+        if (this.timeout === 0) {
+            return;
+        }
+
+        this.clearTimer();
+        this.timer = setTimeout(() => this.handleTimeout(), this.timeout);
+    }
+
+    async handleTimeout() {
+        logger.warn('Soft reset timeout triggered');
+
+        try {
+            await this.zigbee.reset('soft');
+            logger.warn('Soft resetted ZNP due to timeout');
+        } catch (error) {
+            logger.warn('Soft reset failed, trying stop/start');
+
+            await this.zigbee.stop();
+            logger.warn('Zigbee stopped');
+
+            try {
+                await this.zigbee.start();
+            } catch (error) {
+                logger.error('Failed to restart!');
+            }
+        }
+
+        this.resetTimer();
+    }
+
+    onZigbeeEvent() {
+        this.resetTimer();
+    }
+}
+
+module.exports = SoftReset;
@@ -1,365 +0,0 @@
-const settings = require('./util/settings');
-
-const configurations = {
-    // Binary sensor
-    'binary_sensor_occupancy': {
-        type: 'binary_sensor',
-        object_id: 'occupancy',
-        discovery_payload: {
-            payload_on: true,
-            payload_off: false,
-            value_template: '{{ value_json.occupancy }}',
-            device_class: 'motion',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'binary_sensor_contact': {
-        type: 'binary_sensor',
-        object_id: 'contact',
-        discovery_payload: {
-            payload_on: false,
-            payload_off: true,
-            value_template: '{{ value_json.contact }}',
-            device_class: 'door',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'binary_sensor_water_leak': {
-        type: 'binary_sensor',
-        object_id: 'water_leak',
-        discovery_payload: {
-            payload_on: true,
-            payload_off: false,
-            value_template: '{{ value_json.water_leak }}',
-            device_class: 'moisture',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'binary_sensor_smoke': {
-        type: 'binary_sensor',
-        object_id: 'smoke',
-        discovery_payload: {
-            payload_on: true,
-            payload_off: false,
-            value_template: '{{ value_json.smoke }}',
-            device_class: 'smoke',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'binary_sensor_router': {
-        type: 'binary_sensor',
-        object_id: 'router',
-        discovery_payload: {
-            payload_on: true,
-            payload_off: false,
-            value_template: '{{ value_json.state }}',
-            device_class: 'connectivity',
-            json_attributes: ['description', 'type', 'rssi'],
-        },
-    },
-
-    // Sensor
-    'sensor_illuminance': {
-        type: 'sensor',
-        object_id: 'illuminance',
-        discovery_payload: {
-            unit_of_measurement: 'lx',
-            icon: 'mdi:theme-light-dark',
-            value_template: '{{ value_json.illuminance }}',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'sensor_humidity': {
-        type: 'sensor',
-        object_id: 'humidity',
-        discovery_payload: {
-            unit_of_measurement: '%',
-            icon: 'mdi:water-percent',
-            value_template: '{{ value_json.humidity }}',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'sensor_temperature': {
-        type: 'sensor',
-        object_id: 'temperature',
-        discovery_payload: {
-            unit_of_measurement: '°C',
-            icon: 'mdi:temperature-celsius',
-            value_template: '{{ value_json.temperature }}',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'sensor_pressure': {
-        type: 'sensor',
-        object_id: 'pressure',
-        discovery_payload: {
-            unit_of_measurement: 'Pa',
-            icon: 'mdi:speedometer',
-            value_template: '{{ value_json.pressure }}',
-            json_attributes: ['battery', 'voltage'],
-        },
-    },
-    'sensor_click': {
-        type: 'sensor',
-        object_id: 'click',
-        discovery_payload: {
-            icon: 'mdi:toggle-switch',
-            value_template: '{{ value_json.click }}',
-            json_attributes: ['battery', 'voltage', 'action', 'duration'],
-        },
-    },
-    'sensor_power': {
-        type: 'sensor',
-        object_id: 'power',
-        discovery_payload: {
-            unit_of_measurement: 'Watt',
-            icon: 'mdi:flash',
-            value_template: '{{ value_json.power }}',
-            json_attributes: ['voltage', 'temperature', 'consumption', 'current', 'power_factor'],
-        },
-    },
-    'sensor_action': {
-        type: 'sensor',
-        object_id: 'action',
-        discovery_payload: {
-            icon: 'mdi:gesture-double-tap',
-            value_template: '{{ value_json.action }}',
-            json_attributes: ['battery', 'voltage', 'angle', 'side', 'from_side', 'to_side', 'brightness'],
-        },
-    },
-    'sensor_brightness': {
-        type: 'sensor',
-        object_id: 'brightness',
-        discovery_payload: {
-            unit_of_measurement: 'brightness',
-            icon: 'mdi:brightness-5',
-            value_template: '{{ value_json.brightness }}',
-            json_attributes: [],
-        },
-    },
-
-    // Light
-    'light_brightness_colortemp_xy': {
-        type: 'light',
-        object_id: 'light',
-        discovery_payload: {
-            brightness: true,
-            color_temp: true,
-            xy: true,
-            platform: 'mqtt_json',
-            command_topic: true,
-        },
-    },
-    'light_brightness_xy': {
-        type: 'light',
-        object_id: 'light',
-        discovery_payload: {
-            brightness: true,
-            xy: true,
-            platform: 'mqtt_json',
-            command_topic: true,
-        },
-    },
-    'light_brightness_colortemp': {
-        type: 'light',
-        object_id: 'light',
-        discovery_payload: {
-            brightness: true,
-            color_temp: true,
-            platform: 'mqtt_json',
-            command_topic: true,
-        },
-    },
-    'light_brightness': {
-        type: 'light',
-        object_id: 'light',
-        discovery_payload: {
-            brightness: true,
-            platform: 'mqtt_json',
-            command_topic: true,
-        },
-    },
-
-    // Switch
-    'switch': {
-        type: 'switch',
-        object_id: 'switch',
-        discovery_payload: {
-            payload_off: 'OFF',
-            payload_on: 'ON',
-            value_template: '{{ value_json.state }}',
-            command_topic: true,
-        },
-    },
-    'switch_left': {
-        type: 'switch',
-        object_id: 'switch_left',
-        discovery_payload: {
-            payload_off: 'OFF',
-            payload_on: 'ON',
-            value_template: '{{ value_json.state_left }}',
-            command_topic: true,
-            command_topic_prefix: 'left',
-        },
-    },
-    'switch_right': {
-        type: 'switch',
-        object_id: 'switch_right',
-        discovery_payload: {
-            payload_off: 'OFF',
-            payload_on: 'ON',
-            value_template: '{{ value_json.state_right }}',
-            command_topic: true,
-            command_topic_prefix: 'right',
-        },
-    },
-};
-
-// Map homeassitant configurations to devices.
-const mapping = {
-    'WXKG01LM': [configurations.sensor_click],
-    'WXKG11LM': [configurations.sensor_click],
-    'WXKG12LM': [configurations.sensor_click],
-    'WXKG03LM': [configurations.sensor_click],
-    'WXKG02LM': [configurations.sensor_click],
-    'QBKG04LM': [configurations.switch],
-    'QBKG03LM': [configurations.switch_left, configurations.switch_right],
-    'WSDCGQ01LM': [configurations.sensor_temperature, configurations.sensor_humidity],
-    'WSDCGQ11LM': [configurations.sensor_temperature, configurations.sensor_humidity, configurations.sensor_pressure],
-    'RTCGQ01LM': [configurations.binary_sensor_occupancy],
-    'RTCGQ11LM': [configurations.binary_sensor_occupancy, configurations.sensor_illuminance],
-    'MCCGQ01LM': [configurations.binary_sensor_contact],
-    'MCCGQ11LM': [configurations.binary_sensor_contact],
-    'SJCGQ11LM': [configurations.binary_sensor_water_leak],
-    'MFKZQ01LM': [configurations.sensor_action],
-    'ZNCZ02LM': [configurations.switch, configurations.sensor_power],
-    'QBCZ11LM': [configurations.switch, configurations.sensor_power],
-    'LED1545G12': [configurations.light_brightness_colortemp],
-    'LED1623G12': [configurations.light_brightness],
-    'LED1622G12': [configurations.light_brightness],
-    'LED1537R6': [configurations.light_brightness_colortemp],
-    'LED1650R5': [configurations.light_brightness],
-    'LED1536G5': [configurations.light_brightness_colortemp],
-    '7299760PH': [configurations.light_brightness_xy],
-    '7146060PH': [configurations.light_brightness_colortemp_xy],
-    'F7C033': [configurations.light_brightness],
-    'JTYJ-GD-01LM/BW': [configurations.binary_sensor_smoke],
-    'PLUG EDP RE:DY': [configurations.switch, configurations.sensor_power],
-    'CC2530.ROUTER': [configurations.binary_sensor_router],
-    'AA70155': [configurations.light_brightness_colortemp],
-    'AA69697': [configurations.light_brightness_colortemp_xy],
-    'HALIGHTDIMWWE27': [configurations.light_brightness],
-    'AB3257001NJ': [configurations.switch],
-    '8718696449691': [configurations.light_brightness],
-    'RB 185 C': [configurations.light_brightness_colortemp_xy],
-    '9290012573A': [configurations.light_brightness_colortemp_xy],
-    'LED1624G9': [configurations.light_brightness_xy],
-    '73742': [configurations.light_brightness_colortemp],
-    '73740': [configurations.light_brightness_colortemp],
-    '22670': [configurations.light_brightness],
-    'ICTC-G-1': [configurations.sensor_brightness],
-    'ICPSHC24-30EU-IL-1': [configurations.light_brightness],
-    '45852GE': [configurations.light_brightness],
-    'E11-G13': [configurations.light_brightness],
-    'LED1649C5': [configurations.light_brightness],
-    'ICPSHC24-10EU-IL-1': [configurations.light_brightness],
-    'LED1546G12': [configurations.light_brightness_colortemp],
-    'L1527': [configurations.light_brightness_colortemp],
-    'L1529': [configurations.light_brightness_colortemp],
-    'L1528': [configurations.light_brightness_colortemp],
-    'RB 165': [configurations.light_brightness],
-    'RB 175 W': [configurations.light_brightness],
-    'RS 125': [configurations.light_brightness],
-    'RB 145': [configurations.light_brightness],
-    'PL 110': [configurations.light_brightness],
-    'ST 110': [configurations.light_brightness],
-    'UC 110': [configurations.light_brightness],
-    'DL 110 N': [configurations.light_brightness],
-    'DL 110 W': [configurations.light_brightness],
-    'SL 110 N': [configurations.light_brightness],
-    'SL 110 M': [configurations.light_brightness],
-    'SL 110 W': [configurations.light_brightness],
-    'AA68199': [configurations.light_brightness_colortemp],
-    'QBKG11LM': [configurations.switch, configurations.sensor_power],
-    'QBKG12LM': [configurations.switch_left, configurations.switch_right, configurations.sensor_power],
-    'K2RGBW01': [configurations.light_brightness_colortemp_xy],
-    '9290011370': [configurations.light_brightness],
-    'DNCKATSW001': [configurations.switch],
-    'Z809A': [configurations.switch, configurations.sensor_power],
-    'NL08-0800': [configurations.light_brightness],
-    '915005106701': [configurations.light_brightness_colortemp_xy],
-    'AB32840': [configurations.light_brightness_colortemp],
-    '8718696485880': [configurations.light_brightness_colortemp_xy],
-    '8718696598283': [configurations.light_brightness_colortemp],
-    '73693': [configurations.light_brightness_colortemp_xy],
-    '324131092621': [configurations.sensor_action],
-    'GL-C-008': [configurations.light_brightness_colortemp_xy],
-    'STSS-MULT-001': [configurations.binary_sensor_contact],
-    'E11-G23': [configurations.light_brightness],
-    'AC03845': [configurations.light_brightness_colortemp_xy],
-    'AC03641': [configurations.light_brightness],
-};
-
-// A map of all discoverd devices
-const discovered = {};
-
-function discover(deviceID, model, mqtt, force) {
-    // Check if already discoverd and check if there are configs.
-    const discover = force || !discovered[deviceID];
-    if (!discover || !mapping[model] || !settings.getDevice(deviceID)) {
-        return;
-    }
-
-    const friendlyName = settings.getDevice(deviceID).friendly_name;
-
-    mapping[model].forEach((config) => {
-        const topic = `${config.type}/${deviceID}/${config.object_id}/config`;
-        const payload = config.discovery_payload;
-        payload.state_topic = `${settings.get().mqtt.base_topic}/${friendlyName}`;
-        payload.availability_topic = `${settings.get().mqtt.base_topic}/bridge/state`;
-
-        // Set unique names in cases this device produces multiple entities in homeassistant.
-        payload.name = mapping[model].length > 1 ? `${friendlyName}_${config.object_id}` : friendlyName;
-
-        // Only set unique_id when user did not set a friendly_name yet,
-        // see https://github.com/Koenkk/zigbee2mqtt/issues/138
-        if (deviceID === friendlyName) {
-            payload.unique_id = `${deviceID}_${config.object_id}_${settings.get().mqtt.base_topic}`;
-        }
-
-        if (payload.command_topic) {
-            payload.command_topic = `${settings.get().mqtt.base_topic}/${friendlyName}/`;
-
-            if (payload.command_topic_prefix) {
-                payload.command_topic += `${payload.command_topic_prefix}/`;
-            }
-
-            payload.command_topic += 'set';
-        }
-
-        mqtt.publish(topic, JSON.stringify(payload), {retain: true, qos: 0}, null, 'homeassistant');
-    });
-
-    discovered[deviceID] = true;
-}
-
-function clear(deviceID, model, mqtt) {
-    // Check if there are configs.
-    if (!mapping[model]) {
-        return;
-    }
-
-    mapping[model].forEach((config) => {
-        const topic = `${config.type}/${deviceID}/${config.object_id}/config`;
-        const payload = '';
-        mqtt.publish(topic, payload, {retain: true, qos: 0}, null, 'homeassistant');
-    });
-
-    discovered[deviceID] = false;
-}
-
-module.exports = {
-    mapping: mapping,
-    discover: (deviceID, model, mqtt, force) => discover(deviceID, model, mqtt, force),
-    clear: (deviceID, model, mqtt) => clear(deviceID, model, mqtt),
-};
@@ -1,18 +1,39 @@
 const mqtt = require('mqtt');
 const logger = require('./util/logger');
 const settings = require('./util/settings');
+const fs = require('fs');
+const events = require('events');

-class MQTT {
+class MQTT extends events.EventEmitter {
    constructor() {
-        this.handleConnect = this.handleConnect.bind(this);
-        this.handleMessage = this.handleMessage.bind(this);
+        super();
+        this.onMessage = this.onMessage.bind(this);
    }

-    connect(onMessage, subscriptions, callback) {
+    async connect() {
        const mqttSettings = settings.get().mqtt;
        logger.info(`Connecting to MQTT server at ${mqttSettings.server}`);

-        const options = {};
+        const options = {
+            will: {
+                topic: `${settings.get().mqtt.base_topic}/bridge/state`,
+                payload: 'offline',
+                retain: true,
+            },
+        };
+
+        if (mqttSettings.ca) {
+            logger.debug(`MQTT SSL/TLS: Path to CA certificate = ${mqttSettings.ca}`);
+            options.ca = fs.readFileSync(mqttSettings.ca);
+        }
+
+        if (mqttSettings.key && mqttSettings.cert) {
+            logger.debug(`MQTT SSL/TLS: Path to client key = ${mqttSettings.key}`);
+            logger.debug(`MQTT SSL/TLS: Path to client certificate = ${mqttSettings.cert}`);
+            options.key = fs.readFileSync(mqttSettings.key);
+            options.cert = fs.readFileSync(mqttSettings.cert);
+        }
+
        if (mqttSettings.user && mqttSettings.password) {
            options.username = mqttSettings.user;
            options.password = mqttSettings.password;
@@ -23,15 +44,10 @@ class MQTT {
            options.clientId = mqttSettings.client_id;
        }

-        this.client = mqtt.connect(mqttSettings.server, options);
-
-        // Register callbacks.
-        this.client.on('connect', () => {
-            this.handleConnect();
-            callback();
-        });
-
-        this.client.on('message', this.handleMessage);
+        if (mqttSettings.hasOwnProperty('reject_unauthorized') && !mqttSettings.reject_unauthorized) {
+            logger.debug(`MQTT reject_unauthorized set false, ignoring certificate warnings.`);
+            options.rejectUnauthorized = false;
+        }

        // Set timer at interval to check if connected to MQTT server.
        const interval = 10 * 1000; // seconds * 1000.
@@ -41,35 +57,38 @@ class MQTT {
            }
        }, interval);

-        this.onMessage = onMessage;
-        this.subscriptions = subscriptions;
-    }
+        return new Promise((resolve) => {
+            this.client = mqtt.connect(mqttSettings.server, options);

-    disconnect() {
-        clearTimeout(this.connectionTimer);
-        this.connectionTimer = null;
+            this.client.on('connect', () => {
+                logger.info('Connected to MQTT server');
+                this.publish('bridge/state', 'online', {retain: true, qos: 0});
+                resolve();
+            });

-        this.publish('bridge/state', 'offline', {retain: true, qos: 0}, () => {
-            logger.info('Disconnecting from MQTT server');
-            this.client.end();
+            this.client.on('message', this.onMessage);
        });
    }

-    handleConnect() {
-        logger.info('Connected to MQTT server');
-        this.publish('bridge/state', 'online', {retain: true, qos: 0});
-        this.subscriptions.forEach((topic) => this.client.subscribe(topic));
+    async disconnect() {
+        clearTimeout(this.connectionTimer);
+        this.connectionTimer = null;
+        await this.publish('bridge/state', 'offline', {retain: true, qos: 0});
+        logger.info('Disconnecting from MQTT server');
+        this.client.end();
    }

-    handleMessage(topic, message) {
-        if (this.onMessage) {
-            this.onMessage(topic, message);
-        }
+    subscribe(topic) {
+        this.client.subscribe(topic);
    }

-    publish(topic, payload, options, callback, baseTopic) {
-        baseTopic = baseTopic ? baseTopic : settings.get().mqtt.base_topic;
-        topic = `${baseTopic}/${topic}`;
+    onMessage(topic, message) {
+        this.emit('message', {topic, message: message.toString()});
+    }
+
+    async publish(topic, payload, options, base=settings.get().mqtt.base_topic) {
+        topic = `${base}/${topic}`;
+        options = {qos: 0, retain: false, ...options};

        if (!this.client || this.client.reconnecting) {
            logger.error(`Not connected to MQTT server!`);
@@ -77,12 +96,20 @@ class MQTT {
            return;
        }

-        logger.info(`MQTT publish, topic: '${topic}', payload: '${payload}'`);
-        this.client.publish(topic, payload, options, callback);
+        logger.info(`MQTT publish: topic '${topic}', payload '${payload}'`);
+
+        return new Promise((resolve) => {
+            this.client.publish(topic, payload, options, () => resolve());
+        });
    }

-    log(type, message) {
-        const payload = {type: type, message: message};
+    log(type, message, meta=null) {
+        const payload = {type, message};
+
+        if (meta) {
+            payload.meta = meta;
+        }
+
        this.publish('bridge/log', JSON.stringify(payload), {retain: false});
    }
 }
@@ -0,0 +1,93 @@
+const logger = require('./util/logger');
+const data = require('./util/data');
+const fs = require('fs');
+const objectAssignDeep = require('object-assign-deep');
+const events = require('events');
+
+const saveInterval = 1000 * 60 * 5; // 5 minutes
+
+const dontCacheProperties = [
+    'action', 'button', 'button_left', 'button_right', 'click', 'forgotten', 'keyerror',
+    'step_size', 'transition_time', 'action_color_temperature', 'action_color',
+    'action_group', 'group_list', 'group_capacity', 'no_occupancy_since',
+    'step_mode', 'transition_time', 'duration', 'elapsed', 'from_side', 'to_side',
+];
+
+class State extends events.EventEmitter {
+    constructor() {
+        super();
+        this.state = {};
+        this.file = data.joinPath('state.json');
+        this.timer = null;
+    }
+
+    start() {
+        this._load();
+
+        // Save the state on every interval
+        this.clearTimer();
+        this.timer = setInterval(() => this.save(), saveInterval);
+    }
+
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+
+    stop() {
+        this.clearTimer();
+        this.save();
+    }
+
+    _load() {
+        if (fs.existsSync(this.file)) {
+            try {
+                this.state = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+                logger.debug(`Loaded state from file ${this.file}`);
+            } catch (e) {
+                logger.debug(`Failed to load state from file ${this.file} (corrupt file?)`);
+            }
+        } else {
+            logger.debug(`Can't load state from file ${this.file} (doesn't exist)`);
+        }
+    }
+
+    save() {
+        logger.debug(`Saving state to file ${this.file}`);
+        const json = JSON.stringify(this.state, null, 4);
+        fs.writeFileSync(this.file, json, 'utf8');
+    }
+
+    exists(ID) {
+        return this.state.hasOwnProperty(ID);
+    }
+
+    get(ID) {
+        return this.state[ID];
+    }
+
+    set(ID, state, reason=null) {
+        const toState = objectAssignDeep.noMutate(state);
+        dontCacheProperties.forEach((property) => {
+            if (toState.hasOwnProperty(property)) {
+                delete toState[property];
+            }
+        });
+
+        const fromState = this.state[ID];
+
+        this.state[ID] = toState;
+
+        this.emit('stateChange', {ID, from: fromState, to: toState, reason});
+    }
+
+    remove(ID) {
+        if (this.exists(ID)) {
+            delete this.state[ID];
+        }
+    }
+}
+
+module.exports = State;
@@ -2,13 +2,21 @@ const path = require('path');

 let dataPath = null;

-if (process.env.ZIGBEE2MQTT_DATA) {
-    dataPath = process.env.ZIGBEE2MQTT_DATA;
-} else {
-    dataPath = path.join(__dirname, '..', '..', 'data');
-    dataPath = path.normalize(dataPath);
+function load() {
+    if (process.env.ZIGBEE2MQTT_DATA) {
+        dataPath = process.env.ZIGBEE2MQTT_DATA;
+    } else {
+        dataPath = path.join(__dirname, '..', '..', 'data');
+        dataPath = path.normalize(dataPath);
+    }
 }

+load();
+
 module.exports = {
    joinPath: (file) => path.join(dataPath, file),
+    getPath: () => dataPath,
+
+    // For test only.
+    _reload: () => load(),
 };
@@ -1,37 +1,90 @@
 const winston = require('winston');
-const data = require('./data');
+const moment = require('moment');
 const settings = require('./settings');
+const path = require('path');
+const fs = require('fs');
+const fx = require('mkdir-recursive');
+const rimraf = require('rimraf');
+const colorizer = winston.format.colorize();

-let logLevel = '';
-if (process.env.DEBUG) {
-    logLevel = 'debug';
-} else if (settings.get().advanced && settings.get().advanced.log_level) {
-    logLevel = settings.get().advanced.log_level;
-} else {
-    logLevel = winston.level.info;
-}
+// Directoy to log to
+const timestamp = moment(Date.now()).format('YYYY-MM-DD.HH-mm-ss');
+const directory = settings.get().advanced.log_directory.replace('%TIMESTAMP%', timestamp);

-const logger = new (winston.Logger)({
+// Make sure that log directoy exsists
+fx.mkdirSync(directory);
+
+// Determine the log level.
+const level = settings.get().advanced.log_level;
+
+const levelWithCompensatedLength = {
+    'info': 'info ',
+    'error': 'error',
+    'warn': 'warn ',
+    'debug': 'debug',
+};
+
+// Create logger
+const transports = {
+    file: new winston.transports.File({
+        filename: path.join(directory, 'log.txt'),
+        json: false,
+        level,
+        maxFiles: 3, // Keep last 3 files
+        maxsize: 10000000, // 10MB
+        format: winston.format.combine(
+            winston.format.timestamp(),
+            winston.format.printf(/* istanbul ignore next */(info) => {
+                const {timestamp, level, message} = info;
+                return `${levelWithCompensatedLength[level]} ${timestamp.split('.')[0]}: ${message}`;
+            }),
+        ),
+    }),
+    console: new winston.transports.Console({
+        level,
+        format: winston.format.combine(
+            winston.format.timestamp(),
+            winston.format.printf(/* istanbul ignore next */(info) => {
+                const {timestamp, level, message} = info;
+                const prefix = colorizer.colorize(level, `zigbee2mqtt:${levelWithCompensatedLength[level]}`);
+                return `${prefix} ${timestamp.split('.')[0]}: ${message}`;
+            }),
+        ),
+    }),
+};
+
+const logger = winston.createLogger({
    transports: [
-        new (winston.transports.File)({
-            filename: data.joinPath('log.txt'),
-            json: false,
-            level: logLevel,
-            maxFiles: 3,
-            maxsize: 10000000, // 10MB
-        }),
-        new (winston.transports.Console)({
-            timestamp: () => new Date().toLocaleString(),
-            formatter: function(options) {
-                return options.timestamp() + ' ' +
-                        winston.config.colorize(options.level, options.level.toUpperCase()) + ' ' +
-                        (options.message ? options.message : '') +
-                        (options.meta && Object.keys(options.meta).length ? '\n\t'+ JSON.stringify(options.meta) : '' );
-            },
-        }),
+        transports.console,
+        transports.file,
    ],
 });

-logger.transports.console.level = logLevel;
+// Cleanup any old log directory.
+function cleanup() {
+    if (settings.get().advanced.log_directory.includes('%TIMESTAMP%')) {
+        const rootDirectory = path.join(directory, '..');
+
+        let directories = fs.readdirSync(rootDirectory).map((d) => {
+            d = path.join(rootDirectory, d);
+            return {path: d, birth: fs.statSync(d).mtime};
+        });
+
+        directories.sort((a, b) => b.birth - a.birth);
+        directories = directories.slice(10, directories.length);
+        directories.forEach((dir) => {
+            logger.debug(`Removing old log directory '${dir.path}'`);
+            rimraf.sync(dir.path);
+        });
+    }
+}
+
+logger.cleanup = cleanup;
+logger.directory = directory;
+logger.getLevel = () => transports.console.level;
+logger.setLevel = (level) => {
+    transports.console.level = level;
+    transports.file.level = level;
+};

 module.exports = logger;
@@ -1,67 +1,612 @@
-const yaml = require('js-yaml');
-const fs = require('fs');
 const data = require('./data');
 const file = data.joinPath('configuration.yaml');
+const objectAssignDeep = require(`object-assign-deep`);
+const path = require('path');
+const yaml = require('./yaml');
+const Ajv = require('ajv');
+const ajv = new Ajv({allErrors: true});

-let settings = read();
+const defaults = {
+    whitelist: [],
+    ban: [],
+    permit_join: false,
+    mqtt: {
+        include_device_information: false,
+    },
+    serial: {
+        disable_led: false,
+    },
+    device_options: {},
+    map_options: {
+        graphviz: {
+            colors: {
+                fill: {
+                    enddevice: '#fff8ce',
+                    coordinator: '#e04e5d',
+                    router: '#4ea3e0',
+                },
+                font: {
+                    coordinator: '#ffffff',
+                    router: '#ffffff',
+                    enddevice: '#000000',
+                },
+                line: {
+                    active: '#009900',
+                    inactive: '#994444',
+                },
+            },
+        },
+    },
+    experimental: {
+        // json or attribute
+        output: 'json',
+    },
+    advanced: {
+        log_directory: path.join(data.getPath(), 'log', '%TIMESTAMP%'),
+        log_level: /* istanbul ignore next */ process.env.DEBUG ? 'debug' : 'info',
+        soft_reset_timeout: 0,
+        pan_id: 0x1a62,
+        ext_pan_id: [0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD],
+        channel: 11,
+        baudrate: 115200,
+        rtscts: true,

-function writeRead() {
-    write();
-    settings = read();
-}
+        // Availability timeout in seconds, disabled by default.
+        availability_timeout: 0,
+        availability_blacklist: [],
+
+        /**
+         * Home Assistant requires ALL attributes to be present in ALL MQTT messages send by the device.
+         * https://community.home-assistant.io/t/missing-value-with-mqtt-only-last-data-set-is-shown/47070/9
+         *
+         * Therefore zigbee2mqtt BY DEFAULT caches all values and resend it with every message.
+         * advanced.cache_state in configuration.yaml allows to configure this.
+         * https://www.zigbee2mqtt.io/configuration/configuration.html
+         */
+        cache_state: true,
+
+        /**
+         * Add a last_seen attribute to mqtt messages, contains date/time of zigbee message arrival
+         * "ISO_8601": ISO 8601 format
+         * "ISO_8601_local": Local ISO 8601 format (instead of UTC-based)
+         * "epoch": milliseconds elapsed since the UNIX epoch
+         * "disable": no last_seen attribute (default)
+         */
+        last_seen: 'disable',
+
+        // Optional: Add an elapsed attribute to MQTT messages, contains milliseconds since the previous msg
+        elapsed: false,
+
+        /**
+         * https://github.com/Koenkk/zigbee2mqtt/issues/685#issuecomment-449112250
+         *
+         * Network key will serve as the encryption key of your network.
+         * Changing this will require you to repair your devices.
+         */
+        network_key: [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13],
+
+        /**
+         * Enables reporting feature
+         */
+        report: false,
+
+        /**
+         * Home Assistant discovery topic
+         */
+        homeassistant_discovery_topic: 'homeassistant',
+
+        /**
+         * Home Assistant status topic
+         */
+        homeassistant_status_topic: 'hass/status',
+    },
+};
+
+const schema = {
+    type: 'object',
+    properties: {
+        homeassistant: {type: 'boolean'},
+        permit_join: {type: 'boolean'},
+        mqtt: {
+            type: 'object',
+            properties: {
+                base_topic: {type: 'string'},
+                server: {type: 'string'},
+                ca: {type: 'string'},
+                key: {type: 'string'},
+                cert: {type: 'string'},
+                user: {type: 'string'},
+                password: {type: 'string'},
+                client_id: {type: 'string'},
+                reject_unauthorized: {type: 'boolean'},
+                include_device_information: {type: 'boolean'},
+            },
+            required: ['base_topic', 'server'],
+        },
+        serial: {
+            type: 'object',
+            properties: {
+                port: {type: ['string', 'null']},
+                disable_led: {type: 'boolean'},
+            },
+        },
+        ban: {type: 'array', items: {type: 'string'}},
+        whitelist: {type: 'array', items: {type: 'string'}},
+        advanced: {
+            type: 'object',
+            properties: {
+                pan_id: {type: 'number'},
+                ext_pan_id: {type: 'array', items: {type: 'number'}},
+                channel: {type: 'number', minimum: 11, maximum: 26},
+                cache_state: {type: 'boolean'},
+                log_level: {type: 'string', enum: ['info', 'warn', 'error', 'debug']},
+                log_directory: {type: 'string'},
+                baudrate: {type: 'number'},
+                rtscts: {type: 'boolean'},
+                soft_reset_timeout: {type: 'number', minimum: 0},
+                network_key: {type: 'array', items: {type: 'number'}},
+                last_seen: {type: 'string', enum: ['disable', 'ISO_8601', 'ISO_8601_local', 'epoch']},
+                elapsed: {type: 'boolean'},
+                availability_timeout: {type: 'number', minimum: 0},
+                availability_blacklist: {type: 'array', items: {type: 'string'}},
+                report: {type: 'boolean'},
+                homeassistant_discovery_topic: {type: 'string'},
+                homeassistant_status_topic: {type: 'string'},
+            },
+        },
+        map_options: {
+            type: 'object',
+            properties: {
+                graphviz: {
+                    type: 'object',
+                    properties: {
+                        colors: {
+                            type: 'object',
+                            properties: {
+                                fill: {
+                                    type: 'object',
+                                    properties: {
+                                        enddevice: {type: 'string'},
+                                        coordinator: {type: 'string'},
+                                        router: {type: 'string'},
+                                    },
+                                },
+                                font: {
+                                    type: 'object',
+                                    properties: {
+                                        enddevice: {type: 'string'},
+                                        coordinator: {type: 'string'},
+                                        router: {type: 'string'},
+                                    },
+                                },
+                                line: {
+                                    type: 'object',
+                                    properties: {
+                                        active: {type: 'string'},
+                                        inactive: {type: 'string'},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        devices: {
+            type: 'object',
+            propertyNames: {
+                pattern: '^0x[\\d\\w]{16}$',
+            },
+            patternProperties: {
+                '^.*$': {
+                    type: 'object',
+                    properties: {
+                        friendly_name: {type: 'string'},
+                        retain: {type: 'boolean'},
+                        qos: {type: 'number'},
+                    },
+                    required: ['friendly_name'],
+                },
+            },
+        },
+        groups: {
+            type: 'object',
+            propertyNames: {
+                pattern: '^[\\w].*$',
+            },
+            patternProperties: {
+                '^.*$': {
+                    type: 'object',
+                    properties: {
+                        friendly_name: {type: 'string'},
+                        retain: {type: 'boolean'},
+                        devices: {type: 'array', items: {type: 'string'}},
+                        optimistic: {type: 'boolean'},
+                        qos: {type: 'number'},
+                    },
+                    required: ['friendly_name'],
+                },
+            },
+        },
+    },
+    required: ['homeassistant', 'permit_join', 'mqtt'],
+};
+
+
+let _settings;
+let _settingsWithDefaults;

 function write() {
-    fs.writeFileSync(file, yaml.safeDump(settings));
+    const settings = get();
+    const toWrite = objectAssignDeep.noMutate(settings);
+
+    // Read settings to check if we have to split devices/groups into separate file.
+    const actual = yaml.read(file);
+    if (actual.mqtt && actual.mqtt.password && actual.mqtt.user) {
+        toWrite.mqtt.user = actual.mqtt.user;
+        toWrite.mqtt.password = actual.mqtt.password;
+    }
+
+    if (actual.advanced && actual.advanced.network_key) {
+        toWrite.advanced.network_key = actual.advanced.network_key;
+    }
+
+    if (typeof actual.devices === 'string') {
+        yaml.writeIfChanged(data.joinPath(actual.devices), settings.devices);
+        toWrite.devices = actual.devices;
+    }
+
+    if (typeof actual.groups === 'string') {
+        yaml.writeIfChanged(data.joinPath(actual.groups), settings.groups);
+        toWrite.groups = actual.groups;
+    }
+
+    yaml.writeIfChanged(file, toWrite);
+
+    _settings = read();
+    _settingsWithDefaults = objectAssignDeep.noMutate(defaults, get());
+}
+
+function validate() {
+    const validate = ajv.compile(schema);
+    const valid = validate(_settings);
+
+    // Verify that all friendly names are unique
+    const names = [];
+    const check = (name) => {
+        if (names.includes(name)) throw new Error(`Duplicate friendly_name '${name}' found`);
+        names.push(name);
+    };
+    Object.values(_settingsWithDefaults.devices).forEach((d) => check(d.friendly_name));
+    Object.values(_settingsWithDefaults.groups).forEach((g) => check(g.friendly_name));
+
+    return !valid ? validate.errors.map((v) => `${v.dataPath.substring(1)} ${v.message}`) : null;
 }

 function read() {
-    return yaml.safeLoad(fs.readFileSync(file, 'utf8'));
+    const s = yaml.read(file);
+
+    // Read !secret MQTT username and password if set
+    const interpetValue = (value) => {
+        const re = /!(.*) (.*)/g;
+        const match = re.exec(value);
+        if (match) {
+            const file = data.joinPath(`${match[1]}.yaml`);
+            const key = match[2];
+            return yaml.read(file)[key];
+        } else {
+            return value;
+        }
+    };
+
+    if (s.mqtt && s.mqtt.user && s.mqtt.password) {
+        s.mqtt.user = interpetValue(s.mqtt.user);
+        s.mqtt.password = interpetValue(s.mqtt.password);
+    }
+
+    if (s.advanced && s.advanced.network_key) {
+        s.advanced.network_key = interpetValue(s.advanced.network_key);
+    }
+
+    // Read devices/groups configuration from separate file.
+    if (typeof s.devices === 'string') {
+        const file = data.joinPath(s.devices);
+        s.devices = yaml.readIfExists(file) || {};
+    }
+
+    if (typeof s.groups === 'string') {
+        const file = data.joinPath(s.groups);
+        s.groups = yaml.readIfExists(file) || {};
+    }
+
+    return s;
 }

-function addDevice(id) {
+function get() {
+    if (!_settings) {
+        _settings = read();
+    }
+
+    return _settings;
+}
+
+function getWithDefaults() {
+    if (!_settingsWithDefaults) {
+        _settingsWithDefaults = objectAssignDeep.noMutate(defaults, get());
+    }
+
+    if (!_settingsWithDefaults.devices) {
+        _settingsWithDefaults.devices = {};
+    }
+
+    if (!_settingsWithDefaults.groups) {
+        _settingsWithDefaults.groups = {};
+    }
+
+    return _settingsWithDefaults;
+}
+
+function set(path, value) {
+    let settings = get();
+
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+        if (i === path.length - 1) {
+            settings[key] = value;
+        } else {
+            if (!settings[key]) {
+                settings[key] = {};
+            }
+
+            settings = settings[key];
+        }
+    }
+
+    write();
+}
+
+function getGroup(IDorName) {
+    const settings = getWithDefaults();
+    const byID = settings.groups[IDorName];
+    if (byID) {
+        return {optimistic: true, devices: [], ...byID, ID: Number(IDorName), friendlyName: byID.friendly_name};
+    }
+
+    for (const [ID, group] of Object.entries(settings.groups)) {
+        if (group.friendly_name === IDorName) {
+            return {optimistic: true, devices: [], ...group, ID: Number(ID), friendlyName: group.friendly_name};
+        }
+    }
+
+    return null;
+}
+
+function getGroups() {
+    const settings = getWithDefaults();
+    return Object.entries(settings.groups).map(([ID, group]) => {
+        return {optimistic: true, devices: [], ...group, ID: Number(ID), friendlyName: group.friendly_name};
+    });
+}
+
+function getGroupThrowIfNotExists(IDorName) {
+    const group = getGroup(IDorName);
+    if (!group) {
+        throw new Error(`Group '${IDorName}' does not exist`);
+    }
+
+    return group;
+}
+
+function getDevice(IDorName) {
+    const settings = getWithDefaults();
+    const byID = settings.devices[IDorName];
+    if (byID) {
+        return {...byID, ID: IDorName, friendlyName: byID.friendly_name};
+    }
+
+    for (const [ID, device] of Object.entries(settings.devices)) {
+        if (device.friendly_name === IDorName) {
+            return {...device, ID, friendlyName: device.friendly_name};
+        }
+    }
+
+    return null;
+}
+
+function getDeviceThrowIfNotExists(IDorName) {
+    const device = getDevice(IDorName);
+    if (!device) {
+        throw new Error(`Device '${IDorName}' does not exist`);
+    }
+
+    return device;
+}
+
+function getEntity(IDorName) {
+    const device = getDevice(IDorName);
+    if (device) {
+        return {...device, type: 'device'};
+    }
+
+    const group = getGroup(IDorName);
+    if (group) {
+        return {...group, type: 'group'};
+    }
+
+    return null;
+}
+
+function addDevice(ID) {
+    if (getDevice(ID)) {
+        throw new Error(`Device '${ID}' already exists`);
+    }
+
+    const settings = get();
+
    if (!settings.devices) {
        settings.devices = {};
    }

-    settings.devices[id] = {friendly_name: id, retain: false};
-    writeRead();
+    settings.devices[ID] = {friendly_name: ID};
+    write();
+    return getDevice(ID);
 }

-function removeDevice(id) {
-    if (settings.devices && settings.devices[id]) {
-        delete settings.devices[id];
-        writeRead();
+function whitelistDevice(ID) {
+    const settings = get();
+    if (!settings.whitelist) {
+        settings.whitelist = [];
+    }
+
+    if (settings.whitelist.includes(ID)) {
+        throw new Error(`Device '${ID}' already whitelisted`);
+    }
+
+    settings.whitelist.push(ID);
+    write();
+}
+
+function banDevice(ID) {
+    const settings = get();
+    if (!settings.ban) {
+        settings.ban = [];
+    }
+
+    settings.ban.push(ID);
+    write();
+}
+
+function removeDevice(IDorName) {
+    const device = getDeviceThrowIfNotExists(IDorName);
+    const settings = get();
+    delete settings.devices[device.ID];
+    write();
+}
+
+function addGroup(name, ID=null) {
+    if (getGroup(name) || getDevice(name)) {
+        throw new Error(`friendly_name '${name}' is already in use`);
+    }
+
+    const settings = get();
+    if (!settings.groups) {
+        settings.groups = {};
+    }
+
+    if (ID == null) {
+        // look for free ID
+        ID = '1';
+        while (settings.groups.hasOwnProperty(ID)) {
+            ID = (Number.parseInt(ID) + 1).toString();
+        }
+    } else {
+        // ensure provided ID is not in use
+        ID = ID.toString();
+        if (settings.groups.hasOwnProperty(ID)) {
+            throw new Error(`group id '${ID}' is already in use`);
+        }
+    }
+
+    settings.groups[ID] = {friendly_name: name};
+    write();
+
+    return getGroup(ID);
+}
+
+function groupHasDevice(group, keys) {
+    for (const device of group.devices) {
+        const index = keys.indexOf(device);
+        if (index != -1) {
+            return keys[index];
+        }
+    }
+
+    return false;
+}
+
+function addDeviceToGroup(groupIDorName, keys) {
+    const groupID = getGroupThrowIfNotExists(groupIDorName).ID;
+    const settings = get();
+
+    const group = settings.groups[groupID];
+    if (!group.devices) {
+        group.devices = [];
+    }
+
+    if (!groupHasDevice(group, keys)) {
+        group.devices.push(keys[0]);
+        write();
    }
 }

-function getIDByFriendlyName(friendlyName) {
-    if (!settings.devices) {
-        return null;
-    }
+function removeDeviceFromGroup(groupIDorName, keys) {
+    const groupID = getGroupThrowIfNotExists(groupIDorName).ID;
+    const settings = get();
+    const group = settings.groups[groupID];

-    return Object.keys(settings.devices).find((id) =>
-        settings.devices[id].friendly_name === friendlyName
-    );
+    const key = groupHasDevice(group, keys);
+    if (key) {
+        group.devices = group.devices.filter((d) => d != key);
+        write();
+    }
 }

-function changeFriendlyName(old, new_) {
-    const ID = getIDByFriendlyName(old);
+function removeGroup(groupIDorName) {
+    const groupID = getGroupThrowIfNotExists(groupIDorName).ID;
+    const settings = get();
+    delete settings.groups[groupID];
+    write();
+}

-    if (!ID) {
-        return false;
+function changeDeviceOptions(IDorName, newOptions) {
+    const device = getDeviceThrowIfNotExists(IDorName);
+    const settings = get();
+    const currentOptions = settings.devices[device.ID];
+
+    Object.keys(currentOptions).forEach((key) => {
+        if (newOptions[key]) {
+            currentOptions[key] = newOptions[key];
+        }
+    });
+
+    write();
+}
+
+function changeFriendlyName(IDorName, newName) {
+    if (getGroup(newName) || getDevice(newName)) {
+        throw new Error(`friendly_name '${newName}' is already in use`);
    }

-    settings.devices[ID].friendly_name = new_;
-    writeRead();
-    return true;
+    const device = getDeviceThrowIfNotExists(IDorName);
+    const settings = get();
+    settings.devices[device.ID].friendly_name = newName;
+    write();
 }

 module.exports = {
-    get: () => settings,
-    write: () => write(),
-    getDevice: (id) => settings.devices ? settings.devices[id] : null,
-    addDevice: (id) => addDevice(id),
-    removeDevice: (id) => removeDevice(id),
-    getIDByFriendlyName: (friendlyName) => getIDByFriendlyName(friendlyName),
-    changeFriendlyName: (old, new_) => changeFriendlyName(old, new_),
+    validate,
+    get: getWithDefaults,
+    set,
+    getDevice,
+    getGroup,
+    getGroups,
+    getEntity,
+    whitelistDevice,
+    banDevice,
+    addDevice,
+    removeDevice,
+    addGroup,
+    removeGroup,
+    addDeviceToGroup,
+    removeDeviceFromGroup,
+    changeDeviceOptions,
+    changeFriendlyName,
+
+    // For tests only
+    _write: write,
+    _reRead: () => {
+        _settings = read();
+        _settingsWithDefaults = objectAssignDeep.noMutate(defaults, get());
+    },
+    _getDefaults: () => defaults,
 };
@@ -0,0 +1,126 @@
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const equals = require('fast-deep-equal');
+
+// Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.
+const xiaomiManufacturerID = [4151, 4447];
+const ikeaTradfriManufacturerID = [4476];
+
+// construct a local ISO8601 string (instead of UTC-based)
+// Example:
+//  - ISO8601 (UTC) = 2019-03-01T15:32:45.941+0000
+//  - ISO8601 (local) = 2019-03-01T16:32:45.941+0100 (for timezone GMT+1)
+function toLocalISOString(dDate) {
+    const tzOffset = -dDate.getTimezoneOffset();
+    const plusOrMinus = tzOffset >= 0 ? '+' : '-';
+    const pad = function(num) {
+        const norm = Math.floor(Math.abs(num));
+        return (norm < 10 ? '0' : '') + norm;
+    };
+
+    return dDate.getFullYear() +
+        '-' + pad(dDate.getMonth() + 1) +
+        '-' + pad(dDate.getDate()) +
+        'T' + pad(dDate.getHours()) +
+        ':' + pad(dDate.getMinutes()) +
+        ':' + pad(dDate.getSeconds()) +
+        plusOrMinus + pad(tzOffset / 60) +
+        ':' + pad(tzOffset % 60);
+}
+
+const postfixes = [
+    'left', 'right', 'center', 'bottom_left', 'bottom_right', 'l1', 'l2', 'default',
+    'top_left', 'top_right', 'white', 'rgb', 'system', 'top', 'bottom', 'center_left', 'center_right',
+    'ep1', 'ep2',
+];
+
+function flatten(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
+    }, []);
+}
+
+const forceEndDevice = flatten(
+    ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM']
+        .map((model) => zigbeeHerdsmanConverters.devices.find((d) => d.model === model))
+        .map((mappedModel) => mappedModel.zigbeeModel));
+
+async function getZigbee2mqttVersion() {
+    return new Promise((resolve, reject) => {
+        const git = require('git-last-commit');
+        const packageJSON = require('../../package.json');
+        const version = packageJSON.version;
+
+        git.getLastCommit((err, commit) => {
+            let commitHash = null;
+
+            if (err) {
+                try {
+                    commitHash = require('../../.hash.json').hash;
+                } catch (error) {
+                    commitHash = 'unknown';
+                }
+            } else {
+                commitHash = commit.shortHash;
+            }
+
+            resolve({commitHash, version});
+        });
+    });
+}
+
+function formatDate(date, type) {
+    let result;
+
+    switch (type) {
+    case 'ISO_8601':
+        result = new Date(date).toISOString();
+        break;
+    case 'ISO_8601_local':
+        result = toLocalISOString(new Date(date));
+        break;
+    case 'epoch':
+        result = date;
+        break;
+    default:
+        throw new Error(`Unsupported type '${type}'`);
+    }
+
+    return result;
+}
+
+function objectHasProperties(object, properties) {
+    for (const property of properties) {
+        if (!object.hasOwnProperty(property)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function equalsPartial(object, expected) {
+    for (const [key, value] of Object.entries(expected)) {
+        if (!equals(object[key], value)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+module.exports = {
+    millisecondsToSeconds: (milliseconds) => milliseconds / 1000,
+    secondsToMilliseconds: (seconds) => seconds * 1000,
+    getZigbee2mqttVersion,
+    objectHasProperties,
+    getPostfixes: () => postfixes,
+    isXiaomiDevice: (device) => {
+        return device.modelID !== 'lumi.router' && xiaomiManufacturerID.includes(device.manufacturerID) &&
+            (!device.manufacturerName || !device.manufacturerName.startsWith('Trust'));
+    },
+    isIkeaTradfriDevice: (device) => ikeaTradfriManufacturerID.includes(device.manufacturerID),
+    isRouter: (device) => device.type === 'Router' && !forceEndDevice.includes(device.modelID),
+    isBatteryPowered: (device) => device.powerSource && device.powerSource === 'Battery',
+    formatDate: (date, type) => formatDate(date, type),
+    equalsPartial,
+};
@@ -0,0 +1,36 @@
+const yaml = require('js-yaml');
+const fs = require('fs');
+const equals = require('fast-deep-equal');
+
+function read(file) {
+    try {
+        return yaml.safeLoad(fs.readFileSync(file, 'utf8'));
+    } catch (error) {
+        if (error.name === 'YAMLException') {
+            error.message =
+                `\n\n\n` +
+                `\t====================================================================\n` +
+                `\tYour YAML file '${file}' is invalid\n` +
+                `\tUse e.g. https://jsonformatter.org/yaml-validator to find and fix the issue.\n` +
+                `\t====================================================================\n` +
+                `\n\n` +
+                error.message;
+        }
+
+
+        throw error;
+    }
+}
+
+function readIfExists(file) {
+    return fs.existsSync(file) ? read(file) : null;
+}
+
+function writeIfChanged(file, content) {
+    const before = readIfExists(file);
+    if (!equals(before, content)) {
+        fs.writeFileSync(file, yaml.safeDump(content));
+    }
+}
+
+module.exports = {read, readIfExists, writeIfChanged};
@@ -1,229 +1,241 @@
-const ZShepherd = require('zigbee-shepherd');
+const ZigbeeHerdsman = require('zigbee-herdsman');
 const logger = require('./util/logger');
 const settings = require('./util/settings');
 const data = require('./util/data');
-const zclPacket = require('zcl-packet');
+const assert = require('assert');
+const utils = require('./util/utils');
+const events = require('events');
+const objectAssignDeep = require('object-assign-deep');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');

-const advancedSettings = settings.get().advanced;
+const postfixes = utils.getPostfixes();
+const keyEndpointByNumber = new RegExp(`.*/([0-9]*)$`);

-const shepherdSettings = {
-    net: {
-        panId: advancedSettings && advancedSettings.pan_id ? advancedSettings.pan_id : 0x1a62,
-        channelList: [advancedSettings && advancedSettings.channel ? advancedSettings.channel : 11],
+const herdsmanSettings = {
+    network: {
+        panID: settings.get().advanced.pan_id,
+        extendedPanID: settings.get().advanced.ext_pan_id,
+        channelList: [settings.get().advanced.channel],
+        networkKey: settings.get().advanced.network_key,
    },
-    dbPath: data.joinPath('database.db'),
-    sp: {
-        baudrate: advancedSettings && advancedSettings.baudrate ? advancedSettings.baudrate : 115200,
-        rtscts: advancedSettings && (typeof(advancedSettings.rtscts) === 'boolean') ? advancedSettings.rtscts : true,
+    databasePath: data.joinPath('database.db'),
+    databaseBackupPath: data.joinPath('database.db.backup'),
+    backupPath: data.joinPath('coordinator_backup.json'),
+    serialPort: {
+        baudRate: settings.get().advanced.baudrate,
+        rtscts: settings.get().advanced.rtscts,
+        path: settings.get().serial.port,
    },
 };

-logger.debug(`Using zigbee-shepherd with settings: '${JSON.stringify(shepherdSettings)}'`);
-
-class Zigbee {
+class Zigbee extends events.EventEmitter {
    constructor() {
-        this.handleReady = this.handleReady.bind(this);
-        this.handleMessage = this.handleMessage.bind(this);
-        this.handleError = this.handleError.bind(this);
+        super();
+        this.acceptJoiningDeviceHandler = this.acceptJoiningDeviceHandler.bind(this);
    }

-    start(onMessage, callback) {
-        logger.info(`Starting zigbee-shepherd`);
+    async start() {
+        logger.info(`Starting zigbee-herdsman...`);
+        const herdsmanSettingsLog = objectAssignDeep.noMutate(herdsmanSettings);
+        herdsmanSettingsLog.network.networkKey = 'HIDDEN';
+        logger.debug(`Using zigbee-herdsman with settings: '${JSON.stringify(herdsmanSettingsLog)}'`);

-        this.shepherd = new ZShepherd(settings.get().serial.port, shepherdSettings);
+        try {
+            herdsmanSettings.acceptJoiningDeviceHandler = this.acceptJoiningDeviceHandler;
+            this.herdsman = new ZigbeeHerdsman.Controller(herdsmanSettings);
+            await this.herdsman.start();
+        } catch (error) {
+            logger.error(`Error while starting zigbee-herdsman`);
+            throw error;
+        }

-        this.shepherd.start((error) => {
-            if (error) {
-                logger.info('Error while starting zigbee-shepherd, attemping to fix... (takes 60 seconds)');
-                this.shepherd.controller._znp.close((() => null));
+        this.herdsman.on('adapterDisconnected', () => this.emit('adapterDisconnected'));
+        this.herdsman.on('deviceAnnounce', (data) => this.emit('event', 'deviceAnnounce', data));
+        this.herdsman.on('deviceInterview', (data) => this.emit('event', 'deviceInterview', data));
+        this.herdsman.on('deviceJoined', (data) => this.emit('event', 'deviceJoined', data));
+        this.herdsman.on('deviceLeave', (data) => this.emit('event', 'deviceLeave', data));
+        this.herdsman.on('message', (data) => this.emit('event', 'message', data));

-                setTimeout(() => {
-                    logger.info(`Starting zigbee-shepherd`);
-                    this.shepherd.start((error) => {
-                        if (error) {
-                            logger.error('Error while starting zigbee-shepherd!');
-                            logger.error(
-                                'Press the reset button on the stick (the one closest to the USB) and start again'
-                            );
-                            callback(error);
-                        } else {
-                            this._logStartupInfo();
-                            callback(null);
-                        }
-                    });
-                }, 60 * 1000);
-            } else {
-                this._logStartupInfo();
-                callback(null);
-            }
-        });
+        logger.info('zigbee-herdsman started');
+        logger.info(`Coordinator firmware version: '${JSON.stringify(await this.getCoordinatorVersion())}'`);
+        logger.debug(`Zigbee network parameters: ${JSON.stringify(await this.herdsman.getNetworkParameters())}`);

-        // Register callbacks.
-        this.shepherd.on('ready', this.handleReady);
-        this.shepherd.on('ind', this.handleMessage);
-        this.shepherd.on('error', this.handleError);
-
-        this.onMessage = onMessage;
-    }
-
-    _logStartupInfo() {
-        logger.info('zigbee-shepherd started');
-        logger.debug(`zigbee-shepherd info: ${JSON.stringify(this.shepherd.info())}`);
-    }
-
-    softReset(callback) {
-        this.shepherd.reset('soft', callback);
-    }
-
-    stop(callback) {
-        this.shepherd.stop((error) => {
-            logger.info('zigbee-shepherd stopped');
-            callback(error);
-        });
-    }
-
-    handleReady() {
-        // Set all Xiaomi devices (manufId === 4151) to be online, so shepherd won't try
-        // to query info from devices (which would fail because they go tosleep).
-        // Xiaomi lumi.plug has manufId === 4447 and can be in the sleep mode too
-        const devices = this.getAllClients();
-        devices.forEach((d) => {
-            if ((d.manufId === 4151) || (d.manufId === 4447)) {
-                const device = this.shepherd.find(d.ieeeAddr, 1);
-                if (device) {
-                    device.getDevice().update({
-                        status: 'online',
-                        joinTime: Math.floor(Date.now() / 1000),
-                    });
+        for (const device of this.getClients()) {
+            // If a whitelist is used, all other device will be removed from the network.
+            if (settings.get().whitelist.length > 0) {
+                if (!settings.get().whitelist.includes(device.ieeeAddr)) {
+                    logger.warn(`Blacklisted device is connected (${device.ieeeAddr}), removing...`);
+                    device.removeFromNetwork();
                }
+            } else if (settings.get().ban.includes(device.ieeeAddr)) {
+                logger.warn(`Banned device is connected (${device.ieeeAddr}), removing...`);
+                device.removeFromNetwork();
            }
-        });
+        }

-        // Check if we have to turn of the led
+        // Check if we have to turn off the led
        if (settings.get().serial.disable_led) {
-            this.shepherd.controller.request('UTIL', 'ledControl', {ledid: 3, mode: 0});
+            this.herdsman.setLED(false);
        }
-
-        logger.info('zigbee-shepherd ready');
    }

-    handleError(message) {
-        // This event may appear if zigbee-shepherd cannot decode bad packets (invalid checksum).
-        logger.error(message);
+    async getCoordinatorVersion() {
+        return this.herdsman.getCoordinatorVersion();
    }

-    permitJoin(permit) {
-        if (permit) {
-            logger.info('Zigbee: allowing new devices to join.');
-        } else {
+    async reset(type) {
+        await this.herdsman.reset(type);
+    }
+
+    async stop() {
+        await this.herdsman.stop();
+        logger.info('zigbee-herdsman stopped');
+    }
+
+    async permitJoin(permit) {
+        permit ?
+            logger.info('Zigbee: allowing new devices to join.') :
            logger.info('Zigbee: disabling joining new devices.');
-        }

-        this.shepherd.permitJoin(permit ? 255 : 0, (error) => {
-            if (error) {
-                logger.info(error);
+        await this.herdsman.permitJoin(permit);
+    }
+
+    async getPermitJoin() {
+        return this.herdsman.getPermitJoin();
+    }
+
+    getClients() {
+        return this.herdsman.getDevices().filter((device) => device.type !== 'Coordinator');
+    }
+
+    getDevices() {
+        return this.herdsman.getDevices();
+    }
+
+    getDeviceByIeeeAddr(ieeeAddr) {
+        return this.herdsman.getDeviceByIeeeAddr(ieeeAddr);
+    }
+
+    getDevicesByType(type) {
+        return this.herdsman.getDevicesByType(type);
+    }
+
+    resolveEntity(key) {
+        assert(
+            typeof key === 'string' || typeof key === 'number' ||
+            key.constructor.name === 'Device', `Wrong type '${typeof key}'`,
+        );
+
+        if (typeof key === 'string' || typeof key === 'number') {
+            if (typeof key === 'number') {
+                key = key.toString();
            }
-        });
-    }

-    getAllClients() {
-        return this.shepherd.list().filter((device) => device.type !== 'Coordinator');
-    }
-
-    removeDevice(deviceID, callback) {
-        this.shepherd.remove(deviceID, (error) => {
-            if (error) {
-                logger.warn(`Failed to remove '${deviceID}', trying force remove...`);
-                this._forceRemove(deviceID, callback);
-            } else {
-                callback(null);
-            }
-        });
-    }
-
-    _forceRemove(deviceID, callback) {
-        const device = this.shepherd._findDevByAddr(deviceID);
-
-        if (device) {
-            return this.shepherd._unregisterDev(device, (error) => callback(error));
-        } else {
-            logger.warn(`Could not find ${deviceID} for force removal`);
-            callback(true);
-        }
-    }
-
-    ping(deviceID) {
-        const device = this.shepherd._findDevByAddr(deviceID);
-
-        if (device) {
-            // Note: checkOnline has the callback argument but does not call callback
-            logger.debug(`Check online ${deviceID}`);
-            this.shepherd.controller.checkOnline(device);
-        }
-    }
-
-    handleMessage(message) {
-        if (this.onMessage) {
-            this.onMessage(message);
-        }
-    }
-
-    getDevice(deviceID) {
-        return this.shepherd.list().find((d) => d.ieeeAddr === deviceID);
-    }
-
-    getCoordinator() {
-        const device = this.shepherd.list().find((d) => d.type === 'Coordinator');
-        return this.shepherd.find(device.ieeeAddr, 1);
-    }
-
-    publish(deviceID, cid, cmd, zclData, ep, callback) {
-        const device = this._findDevice(deviceID, ep);
-        if (!device) {
-            logger.error(`Zigbee cannot publish message to device because '${deviceID}' not known by zigbee-shepherd`);
-            return;
-        }
-
-        logger.info(`Zigbee publish to '${deviceID}', ${cid} - ${cmd} - ${JSON.stringify(zclData)} - ${ep}`);
-        device.functional(cid, cmd, zclData, callback);
-    }
-
-    read(deviceID, cid, attr, ep, callback) {
-        const device = this._findDevice(deviceID, ep);
-        if (!device) {
-            logger.error(`Zigbee cannot read attribute from device because '${deviceID}' not known by zigbee-shepherd`);
-            return;
-        }
-
-        device.read(cid, attr, callback);
-    }
-
-    registerOnAfIncomingMsg(ieeeAddr, ep) {
-        const device = this._findDevice(ieeeAddr, ep);
-        device.onAfIncomingMsg = (message) => {
-            // Parse the message
-            zclPacket.parse(message.data, message.clusterid, (error, zclData) => {
-                const message = {
-                    endpoints: [device],
-                    data: zclData,
+            if (typeof key === 'string' && key.toLowerCase() === 'coordinator') {
+                const coordinator = this.getDevicesByType('Coordinator')[0];
+                return {
+                    type: 'device',
+                    device: coordinator,
+                    endpoint: coordinator.getEndpoint(1),
+                    settings: {friendlyName: 'Coordinator'},
+                    name: 'Coordinator',
                };
+            }

-                this.handleMessage(message);
-            });
-        };
+            let postfix = postfixes.find((p) => key.endsWith(`/${p}`));
+            const postfixByNumber = key.match(keyEndpointByNumber);
+            if (!postfix && postfixByNumber) {
+                postfix = Number(postfixByNumber[1]);
+            }
+            if (postfix) {
+                key = key.replace(`/${postfix}`, '');
+            }
+
+            const entity = settings.getEntity(key);
+            if (!entity) {
+                return null;
+            } else if (entity.type === 'device') {
+                const device = this.getDeviceByIeeeAddr(entity.ID);
+                if (!device) {
+                    return null;
+                }
+
+                const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+                const endpoints = mapped && mapped.endpoint ? mapped.endpoint(device) : null;
+                let isDefaultEndpoint = true;
+                let endpoint;
+                if (postfix) {
+                    isDefaultEndpoint = false;
+                    if (postfixByNumber) {
+                        endpoint = device.getEndpoint(postfix);
+                    } else {
+                        assert(mapped != null, `Postfix '${postfix}' is given but device is unsupported`);
+                        assert(endpoints != null, `Postfix '${postfix}' is given but device defines no endpoints`);
+                        const endpointID = endpoints[postfix];
+                        assert(endpointID, `Postfix '${postfix}' is given but device has no such endpoint`);
+                        endpoint = device.getEndpoint(endpointID);
+                    }
+                } else if (endpoints && endpoints['default']) {
+                    endpoint = device.getEndpoint(endpoints['default']);
+                } else {
+                    endpoint = device.endpoints[0];
+                }
+
+                const endpointName = endpoints ? Object.entries(endpoints).find((e) => e[1] === endpoint.ID)[0] : null;
+                return {
+                    type: 'device', device, settings: entity, mapped, endpoint, name: entity.friendlyName,
+                    isDefaultEndpoint, endpointName,
+                };
+            } else {
+                let group = this.getGroupByID(entity.ID);
+                if (!group) group = this.createGroup(entity.ID);
+                return {type: 'group', group, settings: entity, name: entity.friendlyName};
+            }
+        } else {
+            const setting = settings.getEntity(key.ieeeAddr);
+            return {
+                type: 'device',
+                device: key,
+                settings: setting,
+                mapped: zigbeeHerdsmanConverters.findByZigbeeModel(key.modelID),
+                name: setting ? setting.friendlyName : (key.type === 'Coordinator' ? 'Coordinator' : key.ieeeAddr),
+            };
+        }
    }

-    _findDevice(deviceID, ep) {
-        // Find device in zigbee-shepherd
-        let device = this.getDevice(deviceID);
-        if (!device || !device.epList || !device.epList.length) {
-            logger.error(`Zigbee cannot determine endpoint for '${deviceID}'`);
-            return null;
-        }
+    getGroupByID(ID) {
+        return this.herdsman.getGroupByID(ID);
+    }

-        ep = ep ? ep : device.epList[0];
-        device = this.shepherd.find(deviceID, ep);
-        return device;
+    getGroups() {
+        return this.herdsman.getGroups();
+    }
+
+    createGroup(groupID) {
+        return this.herdsman.createGroup(groupID);
+    }
+
+    acceptJoiningDeviceHandler(ieeeAddr) {
+        // If set whitelist devices, all other device will be rejected to join the network
+        if (settings.get().whitelist.length > 0) {
+            if (settings.get().whitelist.includes(ieeeAddr)) {
+                logger.info(`Accepting joining whitelisted device '${ieeeAddr}'`);
+                return true;
+            } else {
+                logger.info(`Rejecting joining non-whitelisted device '${ieeeAddr}'`);
+                return false;
+            }
+        } else if (settings.get().ban.length > 0) {
+            if (settings.get().ban.includes(ieeeAddr)) {
+                logger.info(`Rejecting joining banned device '${ieeeAddr}'`);
+                return false;
+            } else {
+                logger.info(`Accepting joining non-banned device '${ieeeAddr}'`);
+                return true;
+            }
+        } else {
+            return true;
+        }
    }
 }

@@ -1,12 +1,15 @@
 {
  "name": "zigbee2mqtt",
-  "version": "0.1.1",
-  "description": "Zigbee to MQTT bridge using zigbee-shepherd",
+  "version": "1.7.1",
+  "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
  "main": "index.js",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
  },
+  "engines": {
+    "node": "10"
+  },
  "keywords": [
    "xiaomi",
    "tradfri",
@@ -17,30 +20,52 @@
    "cc2531"
  ],
  "scripts": {
+    "test-with-coverage": "jest test --coverage",
+    "eslint": "node_modules/.bin/eslint lib/",
    "start": "node index.js",
-    "docgen": "node support/docgen.js",
-    "verify-homeassistant-mapping": "node support/verify-homeassistant-mapping.js",
-    "eslint": "node_modules/.bin/eslint ."
+    "test": "jest test",
+    "test-watch": "jest test --watch"
  },
  "author": "Koen Kanters",
  "license": "GPL-3.0",
  "bugs": {
    "url": "https://github.com/Koenkk/zigbee2mqtt/issues"
  },
-  "homepage": "https://github.com/Koenkk/zigbee2mqtt/wiki",
+  "homepage": "https://koenkk.github.io/zigbee2mqtt",
  "dependencies": {
-    "object-assign-deep": "*",
-    "mqtt": "*",
-    "winston": "2.4.2",
-    "zigbee-shepherd": "git+https://github.com/Koenkk/zigbee-shepherd.git",
-    "zigbee-shepherd-converters": "*",
-    "json2yaml": "*",
-    "zcl-packet": "git+https://github.com/Koenkk/zcl-packet.git#3ea8912f9d228b59fad554064d15ed9be7897a7f",
+    "ajv": "*",
+    "debounce": "*",
+    "fast-deep-equal": "*",
+    "git-last-commit": "*",
    "js-yaml": "*",
-    "git-last-commit": "*"
+    "mkdir-recursive": "*",
+    "moment": "*",
+    "mqtt": "*",
+    "object-assign-deep": "*",
+    "rimraf": "*",
+    "semver": "*",
+    "winston": "*",
+    "zigbee-herdsman": "0.12.4",
+    "zigbee-herdsman-converters": "11.1.41"
  },
  "devDependencies": {
    "eslint": "*",
-    "eslint-config-google": "*"
+    "eslint-config-google": "*",
+    "eslint-plugin-jest": "*",
+    "jest": "*",
+    "tmp": "*"
+  },
+  "jest": {
+    "coverageThreshold": {
+      "global": {
+        "branches": 100,
+        "functions": 100,
+        "lines": 100,
+        "statements": 100
+      }
+    },
+    "collectCoverageFrom": [
+      "lib/**"
+    ]
  }
 }
@@ -0,0 +1,10 @@
+const fs = require('fs');
+const filename = process.argv[2];
+const text = fs.readFileSync(filename, 'utf8');
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+
+
+for (const line of text.split('\n')) {
+    const model = zigbeeHerdsmanConverters.devices.find((d) => d.model === line);
+    console.log(`- \`${line}\` ${model.vendor} ${model.description}`);
+}
@@ -0,0 +1,73 @@
+#!/bin/bash
+function zigbee2mqtt-show-short-info {
+  echo "Setup for Zigbee2mqtt bridge."
+}
+
+function zigbee2mqtt-show-long-info {
+  echo "This script installs the Zigbee2mqtt bridge"
+}
+
+function zigbee2mqtt-show-copyright-info {
+  echo "Original concept by Landrash <https://github.com/landrash>."
+}
+
+function zigbee2mqtt-install-package {
+echo -n "Installing dependencies : "
+node=$(which npm)
+if [ -z "${node}" ]; then #Installing NodeJS if not already installed.
+  printf "Downloading and installing NodeJS...\\n"
+  curl -sL https://deb.nodesource.com/setup_10.x | bash -
+  apt install -y nodejs
+fi
+
+echo "Cloning Zigbee2mqtt git repository"
+git clone https://github.com/Koenkk/zigbee2mqtt.git /opt/zigbee2mqtt
+chown -R pi:pi /opt/zigbee2mqtt
+
+echo "Running install. This might take a while and can produce som expected errors"
+cd /opt/zigbee2mqtt || exit
+su pi -c "npm install"
+
+echo "Creating service file zigbee2mqtt.service"
+service_path="/etc/systemd/system/zigbee2mqtt.service"
+
+echo "[Unit]
+Description=zigbee2mqtt
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/npm start
+WorkingDirectory=/opt/zigbee2mqtt
+StandardOutput=inherit
+StandardError=inherit
+Restart=always
+User=pi
+
+[Install]
+WantedBy=multi-user.target" > $service_path
+
+echo "Checking the installation..."
+if [ ! -f /opt/zigbee2mqtt/data/configuration.yaml ]; then
+  validation=""
+else
+  validation="ok"
+fi
+
+if [ ! -z "${validation}" ]; then
+  echo
+  echo -e "\\e[32mInstallation done..\\e[0m"
+  echo -e "Update of configuration.yaml is required found at /opt/zigbee2mqtt/data/"
+  echo -e "Some further configuration is required and details can be found here https://www.zigbee2mqtt.io"
+  echo
+  echo -e "Service can be started after configuration but running sudo systemctl start zigbee2mqtt"
+  echo
+else
+  echo
+  echo -e "\\e[31mInstallation failed..."
+  echo
+  return 1
+fi
+return 0
+}
+
+[[ "$_" == "$0" ]] && zigbee2mqtt-install-package 
@@ -0,0 +1,181 @@
+#!/bin/bash
+
+######################################
+##  INITIALIZE                      ##
+######################################
+
+set -o errexit -o pipefail -o noclobber -o nounset
+
+! getopt --test > /dev/null
+if [[ ${PIPESTATUS[0]} -ne 4 ]]; then
+    echo "Unfortunately getopt failed in this environment."
+    exit 2
+fi
+
+
+PROGRAM_NAME="zigbee2socat_installer"
+VERSION="1.0"
+
+
+######################################
+##  PARSE ARGUMENTS                 ##
+######################################
+
+OPTS="a:p:uvmhV"
+LONG="addr:,port:,uninstall,verbose,man,help,version"
+
+# Concern: possible to escape getopt and execute commands as root?
+! PARSED=$(getopt -n $PROGRAM_NAME \
+                  -o $OPTS \
+                  -l $LONG \
+                  -- "$@")
+if [[ ${PIPESTATUS[0]} -ne 0 ]]; then
+    printf "Error parsing arguments. Try %s --help\n" "$PROGRAM_NAME"
+    exit 3
+fi
+eval set -- "$PARSED" # Use remaining arguments that weren't parsed
+
+
+function handle_opts {
+    if [[ $# = 1 ]]; then
+        usage
+    fi
+    while true; do
+    case $1 in
+        -a|--addr)
+            ip=$2; shift 2; continue ;;
+
+        -p|--port)
+            port=$2; shift 2; continue ;;
+
+        -u|--uninstall)
+            uninstall ;;
+
+        -v|--verbose)
+            verbose=1; shift; continue ;;
+        
+        -m|--man)
+            makemanual ;;
+
+        -h|--help)
+            usage ;;
+
+        -V|--version)
+            version ;;
+
+        --) # No more arguments to parse
+            shift; break ;;
+
+        *)
+            printf "Programming error! Option: %s\n" "$1"
+            exit 4 ;;
+    esac;done
+}
+
+
+######################################
+##  START OF MAIN                   ##
+######################################
+
+verbose=0
+ip=""
+port=""
+
+function main {
+    handle_opts "$@"
+
+    # TODO: Check IP-address valid?
+    if [[ "$ip" = "" ]]; then
+        echo "IP-address not specified"
+        exit 5
+    fi
+
+    # Is the port valid?
+    if [[ $port -lt 1 || $port -gt 65535 ]]; then
+        printf "Port %s, is outside range: [1-65535]\n" "$port"
+        exit 6
+    fi
+
+    zigbee-socatvusb-install-package
+}
+
+
+######################################
+##  FUNCTIONS BELOW                 ##
+######################################
+
+function zigbee-socatvusb-install-package {
+    echo "Installing socat:"
+    sudo apt-get install socat
+    echo
+
+    echo "Make dir for zigbee vusb"
+    sudo mkdir -p /opt/zigbee2mqtt/vusb/ || die "Couldn't mkdir /opt/zigbee2mqtt/vusb/"
+    sudo chown -R pi:pi /opt/zigbee2mqtt/vusb/ || die "Couldn't chown /opt/zigbee2mqtt/vusb/"
+
+    echo "Creating service file zigbee-socatvusb.service"
+    service_path="/etc/systemd/system/zigbee-socatvusb.service"
+
+    [[ -f $service_path ]] && sudo rm $service_path
+    echo "[Unit]
+    Description=socat-vusb
+    After=network-online.target
+
+    [Service]
+    User=pi
+    ExecStart=/usr/bin/socat -d -d pty,raw,echo=0,link=/opt/zigbee2mqtt/vusb/zigbee_cc2530 tcp:$ip:$port,reuseaddr
+    Restart=always
+    RestartSec=10
+
+    [Install]
+    WantedBy=multi-user.target" > $service_path || die "Couldn't create service /etc/systemd/system/zigbee-socatvusb.service"
+
+    sudo systemctl --system daemon-reload
+
+    echo "Installation is now complete"
+    echo
+    echo "Service can be started after configuration by running: sudo systemctl start zigbee-socatvusb"
+}
+
+function uninstall {
+    service_path="systemctl status socat-vusb.service"
+    [[ -f $service_path ]] && sudo rm $service_path
+    sudo systemctl --system daemon-reload
+    echo "Uninstalled successfully"
+    exit 0
+}
+
+function makemanual {
+    [[ -f "$PROGRAM_NAME.man" ]] && sudo rm $PROGRAM_NAME.man
+    help2man -N ./$PROGRAM_NAME.sh > $PROGRAM_NAME.man ; man ./$PROGRAM_NAME.man
+    exit 0
+}
+
+function usage {
+    echo -e "\
+    \rSetup for development version of Zigbee2Socat
+
+    -a, --addr IP       Listen on this IP-address
+    -p, --port PORT     Listen on this port
+    -u, --uninstall     Uninstall zigbee-socatvusb.service
+    -v, --verbose       Print more information
+    -m, --man           Make and display manual
+    -h, --help          Display this help message
+    
+    \rOriginal concept by JFLN\
+    "
+    exit 0
+}
+
+function version {
+    echo "$PROGRAM_NAME $VERSION"
+    exit 0
+}
+
+function die {
+    printf "%s\n" "$1"
+    exit 1
+}
+
+
+main "$@" # Call main-function last
@@ -1,127 +0,0 @@
-/**
- * This script generates the supported devices page.
- * Run by executing: npm run docs
- */
-
-const deviceMapping = require('zigbee-shepherd-converters').devices;
-const fs = require('fs');
-const YAML = require('json2yaml');
-const homeassistant = require('../lib/homeassistant');
-
-const outputdir = process.argv[2];
-
-if (!outputdir) {
-    console.error("Please specify an output directory");
-}
-
-let file = 'Supported-devices.md';
-let text = '*NOTE: Automatically generated by `npm run docgen`*\n';
-text += `
-In case you own a Zigbee device which is **NOT** listed here, please see [How to support new devices](https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices).
-\n`;
-
-const logDevices = (devices) => {
-    let result = '';
-    result += '| Model | Description | Picture |\n';
-    result += '| ------------- | ------------- | -------------------------- |\n';
-    devices = new Map(devices.map((d) => [d.model, d]));
-    devices.forEach((device) => {
-        const pathFriendly = device.model.replace(new RegExp("/", "g"), '-').replace(new RegExp(":", "g"), '-').replace(new RegExp(" ", "g"), '-');
-        result += `| ${device.model} | ${device.vendor} ${device.description} (${device.supports}) | ![${pathFriendly}](images/devices/${pathFriendly}.jpg) |\n`;
-    });
-
-    return result;
-}
-
-const vendors = Array.from(new Set(deviceMapping.map((d) => d.vendor)));
-vendors.sort();
-vendors.forEach((vendor) => {
-    text += `### ${vendor}\n`;
-    text += logDevices(deviceMapping.filter((d) => d.vendor === vendor));
-    text += '\n';
-})
-
-fs.writeFileSync(outputdir + '/' + file, text);
-
-
-file = 'Integrating-with-Home-Assistant.md';
-text = '*NOTE: Automatically generated by `npm run docgen`*\n\n';
-text += 'If you\'re hosting zigbee2mqtt using [this hassio addon-on](https://github.com/danielwelch/hassio-zigbee2mqtt) use their documentation on how to configure.\n\n'
-text += 'The easiest way to integrate zigbee2mqtt with Home Assistant is by using [MQTT discovery](https://www.home-assistant.io/docs/mqtt/discovery/).\n\n'
-text += 'To achieve the best possible integration (including MQTT discovery):\n';
-text += '- In your **zigbee2mqtt** `configuration.yaml` set `homeassistant: true`\n'
-text += '- In your **Home Assistant** `configuration.yaml`:\n';
-
-text += '```yaml\n';
-text += 'mqtt:\n';
-text += '  discovery: true\n';
-text += '  broker: [YOUR MQTT BROKER]  # Remove if you want to use builtin-in MQTT broker\n';
-text += '  birth_message:\n';
-text += `    topic: 'hass/status'\n`;
-text += `    payload: 'online'\n`;
-text += '  will_message:\n';
-text += `    topic: 'hass/status'\n`;
-text += `    payload: 'offline'\n`;
-text += '```';
-
-text += '\n\n'
-
-text += 'To respond to button clicks (e.g. WXKG01LM) you can use the following Home Assistant configuration:\n'
-text += '```yaml'
-text += `
-automation:
-  - alias: Respond to button clicks
-    trigger:
-      platform: mqtt
-      topic: 'zigbee2mqtt/<FRIENDLY_NAME'
-    condition:
-      condition: template
-      value_template: "{{ 'single' == trigger.payload_json.click }}"
-    action:
-      entity_id: light.bedroom
-      service: light.toggle
-`
-text += '```\n'
-text += '**When changing a `friendly_name` for a device you first have to start zigbee2mqtt and after that restart Home Assistant in order to discover the new device ID.**\n\n';
-text += 'In case you **dont** want to use Home Assistant MQTT discovery you can use the configuration below.\n\n'
-
-const homeassistantConfig = (device) => {
-    const payload = {
-        platform: 'mqtt',
-        state_topic: "zigbee2mqtt/<FRIENDLY_NAME>",
-        availability_topic: "zigbee2mqtt/bridge/state",
-        ...device.discovery_payload,
-    };
-
-    if (payload.command_topic) {
-        if (payload.command_topic_prefix) {
-            payload.command_topic = `zigbee2mqtt/<FRIENDLY_NAME>/${payload.command_topic_prefix}/set`;
-        } else {
-            payload.command_topic = `zigbee2mqtt/<FRIENDLY_NAME>/set`;
-        }
-    }
-
-    delete payload.command_topic_prefix;
-
-    let yml = YAML.stringify([payload]);
-    yml = yml.replace(/(-) \n    /g, '- ');
-    yml = yml.replace('---', `${device.type}:`)
-    return yml;
-}
-
-deviceMapping.forEach((device) => {
-    text += `### ${device.model}\n`;
-    text += '```yaml\n'
-
-    const configurations = homeassistant.mapping[device.model]
-    configurations.forEach((d, i) => {
-        text += homeassistantConfig(d);
-        if (configurations.length > 1 && i < configurations.length - 1) {
-            text += '\n';
-        }
-    })
-
-    text += '```\n\n';
-});
-
-fs.writeFileSync(outputdir + '/' + file, text);
@@ -1,13 +0,0 @@
-// Verify that there are homeassistant mappings for every device.
-const devices = require('zigbee-shepherd-converters').devices;
-const homeassistant = require('../lib/homeassistant');
-
-let failed = false;
-devices.forEach((d) => {
-    if (!homeassistant.mapping[d.model]) {
-        console.error(`Missing homeassistant mapping for '${d.model}'`);
-        failed = true;
-    }
-});
-
-process.exit(failed ? 1 : 0);
@@ -0,0 +1,358 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const path = require('path');
+const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+
+
+describe('Bridge config', () => {
+    let controller;
+
+    beforeAll(async () => {
+        this.version = await require('../lib/util/utils').getZigbee2mqttVersion();
+        controller = new Controller();
+        await controller.start();
+    })
+
+    beforeEach(() => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeDefaultState();
+    });
+
+    it('Should publish bridge configuration on startup', async () => {
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/config',
+          JSON.stringify({"version":this.version.version,"commit":this.version.commitHash,"coordinator":{"type":"z-Stack","meta":{"version":1, "revision": 20190425}},"log_level":'info',"permit_join":false}),
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+    });
+
+    it('Should allow to set elapsed', async () => {
+        MQTT.events.message('zigbee2mqtt/bridge/config/elapsed', 'true');
+        await flushPromises();
+        expect(settings.get().advanced.elapsed).toBe(true);
+        MQTT.events.message('zigbee2mqtt/bridge/config/elapsed', 'false');
+        await flushPromises();
+        expect(settings.get().advanced.elapsed).toBe(false);
+        MQTT.events.message('zigbee2mqtt/bridge/config/elapsed', 'wrong');
+        await flushPromises();
+        expect(settings.get().advanced.elapsed).toBe(false);
+    });
+
+    it('Should allow whitelist', async () => {
+        const bulb_color = zigbeeHerdsman.devices.bulb_color;
+        const bulb = zigbeeHerdsman.devices.bulb;
+        expect(settings.get().whitelist).toStrictEqual([]);
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/whitelist', 'bulb_color');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+          JSON.stringify({type: "device_whitelisted", "message": {friendly_name: "bulb_color"}}),
+          { retain: false, qos: 0 },
+          expect.any(Function)
+        );
+
+        MQTT.publish.mockClear()
+        expect(settings.get().whitelist).toStrictEqual([bulb_color.ieeeAddr]);
+        MQTT.events.message('zigbee2mqtt/bridge/config/whitelist', 'bulb');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+          JSON.stringify({type: "device_whitelisted", "message": {friendly_name: "bulb"}}),
+          { retain: false, qos: 0 },
+          expect.any(Function)
+        );
+
+        MQTT.publish.mockClear()
+        expect(settings.get().whitelist).toStrictEqual([bulb_color.ieeeAddr, bulb.ieeeAddr]);
+        MQTT.events.message('zigbee2mqtt/bridge/config/whitelist', 'bulb');
+        await flushPromises();
+        expect(settings.get().whitelist).toStrictEqual([bulb_color.ieeeAddr, bulb.ieeeAddr]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should allow changing device options', async () => {
+        const bulb_color = zigbeeHerdsman.devices.bulb_color;
+        expect(settings.getDevice('bulb_color')).toStrictEqual(
+            {"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false}
+        );
+        MQTT.events.message('zigbee2mqtt/bridge/config/device_options', JSON.stringify({friendly_name: 'bulb_color', options: {retain: true}}));
+        await flushPromises();
+        expect(settings.getDevice('bulb_color')).toStrictEqual(
+            {"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": true}
+        );
+        MQTT.events.message('zigbee2mqtt/bridge/config/device_options', JSON.stringify({friendly_name: 'bulb_color', optionswrong: {retain: true}}));
+        await flushPromises();
+        expect(settings.getDevice('bulb_color')).toStrictEqual(
+            {"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": true}
+        );
+        MQTT.events.message('zigbee2mqtt/bridge/config/device_options', "{friendly_name: 'bulb_color'malformed: {retain: true}}");
+        await flushPromises();
+        expect(settings.getDevice('bulb_color')).toStrictEqual(
+            {"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": true}
+        );
+    });
+
+    it('Should allow permit join', async () => {
+        zigbeeHerdsman.permitJoin.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/permit_join', 'true');
+        await flushPromises();
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledWith(true);
+        zigbeeHerdsman.permitJoin.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/permit_join', 'false');
+        await flushPromises();
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledWith(false);
+    });
+
+    it('Should allow to reset', async () => {
+        zigbeeHerdsman.reset.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/reset', '');
+        await flushPromises();
+        expect(zigbeeHerdsman.reset).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.reset).toHaveBeenCalledWith('soft');
+        zigbeeHerdsman.reset.mockImplementationOnce(() => {throw new Error('')});
+        MQTT.events.message('zigbee2mqtt/bridge/config/reset', '');
+        await flushPromises();
+        expect(zigbeeHerdsman.reset).toHaveBeenCalledTimes(2);
+        expect(zigbeeHerdsman.reset.mock.calls[1][0]).toBe('soft');
+    });
+
+    it('Should allow to set last_seen', async () => {
+        MQTT.events.message('zigbee2mqtt/bridge/config/last_seen', 'ISO_8601');
+        await flushPromises();
+        expect(settings.get().advanced.last_seen).toBe('ISO_8601');
+        MQTT.events.message('zigbee2mqtt/bridge/config/last_seen', 'disable');
+        await flushPromises();
+        expect(settings.get().advanced.last_seen).toBe('disable');
+        MQTT.events.message('zigbee2mqtt/bridge/config/last_seen', 'notvalid');
+        await flushPromises();
+        expect(settings.get().advanced.last_seen).toBe('disable');
+    });
+
+    it('Should allow to set log_level', async () => {
+        MQTT.events.message('zigbee2mqtt/bridge/config/log_level', 'debug');
+        await flushPromises();
+        expect(logger.getLevel()).toBe('debug');
+        MQTT.events.message('zigbee2mqtt/bridge/config/log_level', 'error');
+        await flushPromises();
+        expect(logger.getLevel()).toBe('error');
+        MQTT.events.message('zigbee2mqtt/bridge/config/log_level', 'notvalid');
+        await flushPromises();
+        expect(logger.getLevel()).toBe('error');
+    });
+
+    it('Should allow to get devices', async () => {
+        const now = Date.now;
+        Date.now = () => 100;
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/devices/get', '');
+        await flushPromises();
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/config/devices');
+        const payload = JSON.parse(MQTT.publish.mock.calls[0][1]);
+        expect(payload.length).toStrictEqual(Object.values(zigbeeHerdsman.devices).length);
+        expect(payload[0]).toStrictEqual({"ieeeAddr": "0x00124b00120144ae", "type": "Coordinator", "dateCode": "20190425", "friendly_name": "Coordinator", networkAddress: 0, softwareBuildID: "z-Stack", lastSeen: 100});
+        expect(payload[1]).toStrictEqual({"friendly_name": "bulb", "ieeeAddr": "0x000b57fffec6a5b2", "lastSeen": 1000, "manufacturerID": 4476, "model": "LED1545G12", "modelID": "TRADFRI bulb E27 WS opal 980lm", "networkAddress": 40369, "powerSource": "Mains (single phase)", "type": "Router"});
+        Date.now = now;
+    });
+
+    it('Should allow to get groups', async () => {
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/groups', '');
+        await flushPromises();
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        const payload = JSON.parse(MQTT.publish.mock.calls[0][1]);
+        expect(payload).toStrictEqual({"message": [{"ID": 1, "friendly_name": "group_1", "retain": false, 'devices': [], optimistic: true}, {"ID": 2, "friendly_name": "group_2", "retain": false, "devices": [], optimistic: true}, {"ID": 11, "friendly_name": "group_with_tradfri", "retain": false, "devices": ['bulb_2'], optimistic: true}, {"ID": 15071, "friendly_name": "group_tradfri_remote", "retain": false, "devices": ['bulb_color_2', 'bulb_2'], optimistic: true}], "type": "groups"});
+    });
+
+    it('Should allow rename devices', async () => {
+        const bulb_color2 = {"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color2", "friendly_name": "bulb_color2", "retain": false};
+        MQTT.publish.mockClear();
+        expect(settings.getDevice('bulb_color')).toStrictEqual({"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false});
+        MQTT.events.message('zigbee2mqtt/bridge/config/rename', JSON.stringify({old: 'bulb_color', new: 'bulb_color2'}));
+        await flushPromises();
+        expect(settings.getDevice('bulb_color')).toStrictEqual(null);
+        expect(settings.getDevice('bulb_color2')).toStrictEqual(bulb_color2);
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+            JSON.stringify({type: 'device_renamed', message: {from: 'bulb_color', to: 'bulb_color2'}}),
+            {qos: 0, retain: false},
+            expect.any(Function)
+        );
+
+        MQTT.events.message('zigbee2mqtt/bridge/config/rename', JSON.stringify({old: 'bulb_color2', newmalformed: 'bulb_color3'}));
+        await flushPromises();
+        expect(settings.getDevice('bulb_color2')).toStrictEqual(bulb_color2);
+
+        MQTT.events.message('zigbee2mqtt/bridge/config/rename', "{old: 'bulb_color2'newmalformed: 'bulb_color3'}");
+        await flushPromises();
+        expect(settings.getDevice('bulb_color2')).toStrictEqual(bulb_color2);
+
+        MQTT.events.message('zigbee2mqtt/bridge/config/rename', JSON.stringify({old: 'bulb_color', new: 'bulb_color3'}));
+        await flushPromises();
+        expect(settings.getDevice('bulb_color2')).toStrictEqual(bulb_color2);
+    });
+
+    it('Should allow to add groups', async () => {
+        zigbeeHerdsman.createGroup.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/add_group', 'new_group');
+        await flushPromises();
+        expect(settings.getGroup('new_group')).toStrictEqual({"ID": 3, "friendlyName": "new_group", "friendly_name": "new_group", devices: [], optimistic: true});
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledWith(3)
+    });
+
+    it('Should allow to add groups with json', async () => {
+        zigbeeHerdsman.createGroup.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/add_group', '{"friendly_name": "new_group"}');
+        await flushPromises();
+        expect(settings.getGroup('new_group')).toStrictEqual({"ID": 3, "friendlyName": "new_group", "friendly_name": "new_group", devices: [], optimistic: true});
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledWith(3)
+    });
+
+    it('Should allow to add groups with json specifying id', async () => {
+        zigbeeHerdsman.createGroup.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/add_group', '{"friendly_name": "new_group", "id": 42}');
+        await flushPromises();
+        expect(settings.getGroup('new_group')).toStrictEqual({"ID": 42, "friendlyName": "new_group", "friendly_name": "new_group", devices: [], optimistic: true});
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledWith(42)
+    });
+
+    it('Should allow to add groups with json specifying only id', async () => {
+        zigbeeHerdsman.createGroup.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/add_group', '{"id": 42}');
+        await flushPromises();
+        expect(settings.getGroup('group_42')).toStrictEqual({"ID": 42, "friendlyName": "group_42", "friendly_name": "group_42", devices: [], optimistic: true});
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.createGroup).toHaveBeenCalledWith(42)
+    });
+
+    it('Should allow to remove groups', async () => {
+        settings.addGroup('to_be_removed')
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove_group', 'to_be_removed');
+        await flushPromises();
+        expect(settings.getGroup('to_be_removed')).toStrictEqual(null);
+    });
+
+    it('Shouldnt allow add groups without id or friendly_name in json', async () => {
+        zigbeeHerdsman.createGroup.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/add_group', '{}');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledWith('Failed to add group, missing friendly_name!');
+    });
+
+    it('Shouldnt do anything on unsupported topic', async () => {
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/not_supported', 'to_be_removed');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should allow to remove device', async () => {
+        controller.state.state = {'0x000b57fffec6a5b3': {brightness: 100}};
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.removeFromNetwork.mockClear();
+        expect(settings.get().ban.length).toBe(0);
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'bulb_color');
+        await flushPromises();
+        expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(controller.state[device.ieeeAddr]).toBeUndefined();
+        expect(settings.getDevice('bulb_color')).toBeNull();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+            JSON.stringify({type: 'device_removed', message: 'bulb_color'}),
+            {qos: 0, retain: false},
+            expect.any(Function)
+        );
+        expect(controller.state.state).toStrictEqual({});
+        expect(settings.get().ban.length).toBe(0);
+    });
+
+    it('Should allow to force remove device', async () => {
+        controller.state.state = {'0x000b57fffec6a5b3': {brightness: 100}};
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.removeFromDatabase.mockClear();
+        expect(settings.get().ban.length).toBe(0);
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/force_remove', 'bulb_color');
+        await flushPromises();
+        expect(device.removeFromDatabase).toHaveBeenCalledTimes(1);
+        expect(controller.state[device.ieeeAddr]).toBeUndefined();
+        expect(settings.getDevice('bulb_color')).toBeNull();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+            JSON.stringify({type: 'device_force_removed', message: 'bulb_color'}),
+            {qos: 0, retain: false},
+            expect.any(Function)
+        );
+        expect(controller.state.state).toStrictEqual({});
+        expect(settings.get().ban.length).toBe(0);
+    });
+
+    it('Should allow to ban device', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.removeFromNetwork.mockClear();
+        expect(settings.get().ban.length).toBe(0);
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/ban', 'bulb_color');
+        await flushPromises();
+        expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(controller.state[device.ieeeAddr]).toBeUndefined();
+        expect(settings.getDevice('bulb_color')).toBeNull();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+            JSON.stringify({type: 'device_banned', message: 'bulb_color'}),
+            {qos: 0, retain: false},
+            expect.any(Function)
+        );
+        expect(settings.get().ban).toStrictEqual(['0x000b57fffec6a5b3']);
+    });
+
+    it('Shouldnt crash when removing non-existing device', async () => {
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'not_existing_123');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledWith(`Cannot remove, device 'not_existing_123' does not exist`);
+    });
+
+    it('Should handle when remove fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.removeFromNetwork.mockClear();
+        device.removeFromNetwork.mockImplementationOnce(() => {throw new Error('')})
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'bulb_color');
+        await flushPromises();
+        expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(settings.getDevice('bulb_color')).toStrictEqual({"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false})
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should handle when ban fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.removeFromNetwork.mockClear();
+        device.removeFromNetwork.mockImplementationOnce(() => {throw new Error('')})
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/ban', 'bulb_color');
+        await flushPromises();
+        expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(settings.getDevice('bulb_color')).toStrictEqual({"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false})
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+});
@@ -0,0 +1,438 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const path = require('path');
+const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const tmp = require('tmp');
+const mocksClear = [
+    zigbeeHerdsman.permitJoin, mockExit, MQTT.end, zigbeeHerdsman.stop, logger.debug,
+    MQTT.publish, MQTT.connect, zigbeeHerdsman.devices.bulb_color.removeFromNetwork,
+    zigbeeHerdsman.devices.bulb.removeFromNetwork, logger.error,
+];
+
+const fs = require('fs');
+
+describe('Controller', () => {
+    let controller;
+
+    beforeEach(() => {
+        zigbeeHerdsman.returnDevices.splice(0);
+        controller = new Controller();
+        mocksClear.forEach((m) => m.mockClear());
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeDefaultState();
+    });
+
+    it('Start controller', async () => {
+        await controller.start();
+        expect(logger.cleanup).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.constructor).toHaveBeenCalledWith({"network":{"panID":6754,"extendedPanID":[221,221,221,221,221,221,221,221],"channelList":[11],"networkKey":[1,3,5,7,9,11,13,15,0,2,4,6,8,10,12,13]},"databasePath":path.join(data.mockDir, "database.db"), "databaseBackupPath":path.join(data.mockDir, "database.db.backup"),"backupPath":path.join(data.mockDir, "coordinator_backup.json"),"acceptJoiningDeviceHandler": expect.any(Function),"serialPort":{"baudRate":115200,"rtscts":true,"path":"/dev/dummy"}});
+        expect(zigbeeHerdsman.start).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.setLED).toHaveBeenCalledTimes(0);
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledWith(true);
+        expect(logger.info).toHaveBeenCalledWith(`Currently ${Object.values(zigbeeHerdsman.devices).length - 1} devices are joined:`)
+        expect(logger.info).toHaveBeenCalledWith('bulb (0x000b57fffec6a5b2): LED1545G12 - IKEA TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (Router)');
+        expect(logger.info).toHaveBeenCalledWith('remote (0x0017880104e45517): 324131092621 - Philips Hue dimmer switch (EndDevice)');
+        expect(logger.info).toHaveBeenCalledWith('0x0017880104e45518 (0x0017880104e45518): Not supported (EndDevice)');
+        expect(MQTT.connect).toHaveBeenCalledTimes(1);
+        expect(MQTT.connect).toHaveBeenCalledWith("mqtt://localhost", {"will": {"payload": "offline", "retain": true, "topic": "zigbee2mqtt/bridge/state"}});
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bulb', '{"state":"ON","brightness":50,"color_temp":370,"linkquality":99}',{ retain: true, qos: 0 }, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/remote', '{"brightness":255}', { retain: true, qos: 0 }, expect.any(Function));
+    });
+
+    it('Start controller with specific MQTT settings', async () => {
+        const ca = tmp.fileSync().name;
+        fs.writeFileSync(ca, "ca");
+        const key = tmp.fileSync().name;
+        fs.writeFileSync(key, "key");
+        const cert = tmp.fileSync().name;
+        fs.writeFileSync(cert, "cert");
+
+        const configuration = {
+            base_topic: "zigbee2mqtt",
+            server: "mqtt://localhost",
+            ca, cert, key,
+            password: 'pass',
+            user: 'user1',
+            client_id: 'my_client_id',
+            reject_unauthorized: false,
+        }
+        settings.set(['mqtt'], configuration)
+        await controller.start();
+        await flushPromises();
+        expect(MQTT.connect).toHaveBeenCalledTimes(1);
+        const expected = {
+            "will": {"payload": "offline", "retain": true, "topic": "zigbee2mqtt/bridge/state"},
+            ca: Buffer.from([99, 97]),
+            key: Buffer.from([107, 101, 121]),
+            cert: Buffer.from([99, 101, 114, 116]),
+            password: 'pass',
+            username: 'user1',
+            clientId: 'my_client_id',
+            rejectUnauthorized: false,
+
+        }
+        expect(MQTT.connect).toHaveBeenCalledWith("mqtt://localhost", expected);
+    });
+
+    it('Start controller should publish cached states', async () => {
+        data.writeDefaultState();
+        await controller.start();
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb", `{"state":"ON","brightness":50,"color_temp":370,"linkquality":99}`, {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/remote", `{"brightness":255}`, {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
+    it('Start controller should not publish cached states when cache_state is false', async () => {
+        settings.set(['advanced', 'cache_state'], false);
+        data.writeDefaultState();
+        await controller.start();
+        await flushPromises();
+        expect(MQTT.publish).not.toHaveBeenCalledWith("zigbee2mqtt/bulb", `{"state":"ON","brightness":50,"color_temp":370,"linkquality":99}`, {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).not.toHaveBeenCalledWith("zigbee2mqtt/remote", `{"brightness":255}`, {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
+    it('Log when MQTT client is unavailable', async () => {
+        jest.useFakeTimers();
+        await controller.start();
+        await flushPromises();
+        logger.error.mockClear();
+        controller.mqtt.client.reconnecting = true;
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith("Not connected to MQTT server!");
+        controller.mqtt.client.reconnecting = false;
+    });
+
+    it('Dont publish to mqtt when client is unavailable', async () => {
+        await controller.start();
+        await flushPromises();
+        logger.error.mockClear();
+        controller.mqtt.client.reconnecting = true;
+        await controller.publishEntityState('bulb', {state: 'ON', brightness: 50, color_temp: 370, color: {r: 100, g: 50, b: 10}, dummy: {1: 'yes', 2: 'no'}});
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledTimes(2);
+        expect(logger.error).toHaveBeenCalledWith("Not connected to MQTT server!");
+        expect(logger.error).toHaveBeenCalledWith("Cannot send message: topic: 'zigbee2mqtt/bulb', payload: '{\"state\":\"ON\",\"brightness\":50,\"color_temp\":370,\"linkquality\":99,\"color\":{\"r\":100,\"g\":50,\"b\":10},\"dummy\":{\"1\":\"yes\",\"2\":\"no\"}}");
+        controller.mqtt.client.reconnecting = false;
+    });
+
+    it('Load empty state when state file does not exist', async () => {
+        data.removeState();
+        await controller.start();
+        await flushPromises();
+        expect(controller.state.state).toStrictEqual({});
+    });
+
+    it('Should remove non whitelisted devices on startup', async () => {
+        settings.set(['whitelist'], [zigbeeHerdsman.devices.bulb_color.ieeeAddr]);
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.devices.bulb_color.removeFromNetwork).toHaveBeenCalledTimes(0);
+        expect(zigbeeHerdsman.devices.bulb.removeFromNetwork).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should remove banned devices on startup', async () => {
+        settings.set(['ban'], [zigbeeHerdsman.devices.bulb_color.ieeeAddr]);
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.devices.bulb_color.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.devices.bulb.removeFromNetwork).toHaveBeenCalledTimes(0);
+    });
+
+    it('Start controller fails', async () => {
+        zigbeeHerdsman.start.mockImplementationOnce(() => {throw new Error('failed')});
+        await controller.start();
+        expect(mockExit).toHaveBeenCalledTimes(1);
+    });
+
+    it('Start controller with permit join true', async () => {
+        settings.set(['permit_join'], false);
+        await controller.start();
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.permitJoin).toHaveBeenCalledWith(false);
+    });
+
+    it('Refuse to start when configuration.yaml is invalid', async () => {
+        settings.set(['permit_join'], 'invalid');
+        await controller.start();
+        expect(logger.error).toHaveBeenCalledWith('Refusing to start, configuration.yaml is not valid, found the following errors:');
+        expect(logger.error).toHaveBeenCalledWith('\t - permit_join should be boolean');
+        expect(mockExit).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('Start controller with disable_led', async () => {
+        settings.set(['serial', 'disable_led'], true);
+        await controller.start();
+        expect(zigbeeHerdsman.setLED).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.setLED).toHaveBeenCalledWith(false);
+    });
+
+    it('Start controller and stop', async () => {
+        await controller.start();
+        await controller.stop();
+        expect(MQTT.end).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.stop).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('Start controller and stop', async () => {
+        zigbeeHerdsman.stop.mockImplementationOnce(() => {throw new Error('failed')})
+        await controller.start();
+        await controller.stop();
+        expect(MQTT.end).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.stop).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('Start controller adapter disconnects', async () => {
+        zigbeeHerdsman.stop.mockImplementationOnce(() => {throw new Error('failed')})
+        await controller.start();
+        await zigbeeHerdsman.events.adapterDisconnected();
+        await flushPromises();
+        expect(MQTT.end).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.stop).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledTimes(1);
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('Handle mqtt message', async () => {
+        await controller.start();
+        logger.debug.mockClear();
+        await MQTT.events.message('dummytopic', 'dummymessage');
+        expect(logger.debug).toHaveBeenCalledWith("Received MQTT message on 'dummytopic' with data 'dummymessage'")
+    });
+
+    it('On zigbee event message', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10, cluster: 'genBasic', data: {modelId: device.modelID}};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(logger.debug).toHaveBeenCalledWith(`Received Zigbee message from 'bulb', type 'attributeReport', cluster 'genBasic', data '{"modelId":"TRADFRI bulb E27 WS opal 980lm"}' from endpoint 1`);
+    });
+
+    it('On zigbee event message with group ID', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10, groupID: 0, cluster: 'genBasic', data: {modelId: device.modelID}};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(logger.debug).toHaveBeenCalledWith(`Received Zigbee message from 'bulb', type 'attributeReport', cluster 'genBasic', data '{"modelId":"TRADFRI bulb E27 WS opal 980lm"}' from endpoint 1 with groupID 0`);
+    });
+
+    it('On zigbee event message from unkown device should create it', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.notInSettings;
+        expect(settings.getDevice(device.ieeeAddr)).toBeNull();
+        const payload = {device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10, groupID: 0, cluster: 'genBasic', data: {modelId: device.modelID}};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(settings.getDevice(device.ieeeAddr)).toStrictEqual({"ID": "0x0017880104e45519", "friendlyName": "0x0017880104e45519", "friendly_name": "0x0017880104e45519"});
+    });
+
+    it('On zigbee deviceJoined', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device};
+        await zigbeeHerdsman.events.deviceJoined(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_connected","message":{"friendly_name":"bulb"}}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('acceptJoiningDeviceHandler reject banned device', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        settings.set(['ban'], [device.ieeeAddr]);
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(false);
+    });
+
+    it('acceptJoiningDeviceHandler accept not banned device', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        settings.set(['ban'], ['123']);
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(true);
+    });
+
+    it('acceptJoiningDeviceHandler accept whitelisted device', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        settings.set(['whitelist'], [device.ieeeAddr]);
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(true);
+    });
+
+    it('acceptJoiningDeviceHandler reject non-whitelisted device', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        settings.set(['whitelist'], ['123']);
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(false);
+    });
+
+    it('acceptJoiningDeviceHandler should prefer whitelist above ban', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        settings.set(['whitelist'], [device.ieeeAddr]);
+        settings.set(['ban'], [device.ieeeAddr]);
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(true);
+    });
+
+    it('acceptJoiningDeviceHandler accept when no ban and whitelist', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const handler = zigbeeHerdsman.constructor.mock.calls[0][0].acceptJoiningDeviceHandler;
+        expect(await handler(device.ieeeAddr)).toBe(true);
+    });
+
+    it('Shouldnt crash when two device join events are received', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device};
+        zigbeeHerdsman.events.deviceJoined(payload);
+        zigbeeHerdsman.events.deviceJoined(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_connected","message":{"friendly_name":"bulb"}}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('On zigbee deviceInterview started', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device, status: 'started'};
+        await zigbeeHerdsman.events.deviceInterview(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"pairing","message":"interview_started","meta":{"friendly_name":"bulb"}}', { retain: false, qos: 0 }, expect.any(Function));
+    });
+
+    it('On zigbee deviceInterview failed', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device, status: 'failed'};
+        await zigbeeHerdsman.events.deviceInterview(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"pairing","message":"interview_failed","meta":{"friendly_name":"bulb"}}', { retain: false, qos: 0 }, expect.any(Function));
+    });
+
+    it('On zigbee deviceInterview successful supported', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device, status: 'successful'};
+        await zigbeeHerdsman.events.deviceInterview(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"pairing","message":"interview_successful","meta":{"friendly_name":"bulb","model":"LED1545G12","vendor":"IKEA","description":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white","supported":true}}', { retain: false, qos: 0 }, expect.any(Function));
+    });
+
+    it('On zigbee deviceInterview successful not supported', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.unsupported;
+        const payload = {device, status: 'successful'};
+        await zigbeeHerdsman.events.deviceInterview(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"pairing","message":"interview_successful","meta":{"friendly_name":"0x0017880104e45518","supported":false}}', { retain: false, qos: 0 }, expect.any(Function));
+    });
+
+    it('On zigbee event device announce', async () => {
+        await controller.start();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {device};
+        await zigbeeHerdsman.events.deviceAnnounce(payload);
+        await flushPromises();
+        expect(logger.debug).toHaveBeenCalledWith(`Device 'bulb' announced itself`);
+    });
+
+    it('On zigbee event device leave (removed from database and settings)', async () => {
+        await controller.start();
+        zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+        settings.set(['devices'], {})
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {ieeeAddr: device.ieeeAddr};
+        await zigbeeHerdsman.events.deviceLeave(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"device_removed","message":"left_network","meta":{"friendly_name":"0x000b57fffec6a5b2"}}', { retain: false, qos: 0}, expect.any(Function));
+    });
+
+    it('On zigbee event device leave (removed from database and NOT settings)', async () => {
+        await controller.start();
+        zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+        const device = zigbeeHerdsman.devices.bulb;
+        MQTT.publish.mockClear();
+        const payload = {ieeeAddr: device.ieeeAddr};
+        await zigbeeHerdsman.events.deviceLeave(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bridge/log', '{"type":"device_removed","message":"left_network","meta":{"friendly_name":"0x000b57fffec6a5b2"}}', { retain: false, qos: 0}, expect.any(Function));
+    });
+
+    it('Publish entity state attribute output', async () => {
+        await controller.start();
+        settings.set(['experimental', 'output'], 'attribute');
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb', {state: 'ON', brightness: 50, color_temp: 370, color: {r: 100, g: 50, b: 10}, dummy: {1: 'yes', 2: 'no'}});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/state", "ON", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/brightness", "50", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/color_temp", "370", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/color", '100,50,10', {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/dummy-1", 'yes', {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/dummy-2", 'no', {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
+    it('Publish entity state with device information', async () => {
+        await controller.start();
+        settings.set(['mqtt', 'include_device_information'], true);
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb', {state: 'ON'});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bulb', '{"state":"ON","brightness":50,"color_temp":370,"linkquality":99,"device":{"friendlyName":"bulb","ieeeAddr":"0x000b57fffec6a5b2","networkAddress":40369,"type":"Router","manufacturerID":4476,"powerSource":"Mains (single phase)"}}', {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
+    it('Publish entity state no empty messages', async () => {
+        data.writeEmptyState();
+        await controller.start();
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb', {});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Publish should not cache when set', async () => {
+        settings.set(['advanced', 'cache_state'], false);
+        data.writeEmptyState();
+        await controller.start();
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb', {state: 'ON'});
+        await controller.publishEntityState('bulb', {brightness: 200});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb", "{\"state\":\"ON\"}", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb", "{\"brightness\":200}", {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
+    it('Publish should not do anything for unknown entity', async () => {
+        await controller.start();
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb-unknown', {brightness: 200});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should start when state is corrupted', async () => {
+        fs.writeFileSync(path.join(data.mockDir, 'state.json'), 'corrupted');
+        await controller.start();
+        await flushPromises();
+        expect(controller.state.state).toStrictEqual({});
+    });
+});
@@ -0,0 +1,26 @@
+const logger = require('./stub/logger');
+const data = require('../lib/util/data.js');
+const path = require('path');
+const tmp = require('tmp');
+const fs = require('fs');
+
+describe('Data', () => {
+    describe('Get path', () => {
+        it('Should return correct path', () => {
+            const expected = path.normalize(path.join(__dirname, '..', 'data'));
+            const actual = data.getPath();
+            expect(actual).toBe(expected);
+        });
+
+        it('Should return correct path when ZIGBEE2MQTT_DATA set', () => {
+            const expected = tmp.dirSync().name;
+            process.env.ZIGBEE2MQTT_DATA = expected;
+            data._reload();
+            const actual = data.getPath();
+            expect(actual).toBe(expected);
+            expect(data.joinPath('test')).toStrictEqual(path.join(expected, 'test'));
+            delete process.env.ZIGBEE2MQTT_DATA;
+            data._reload();
+        });
+    });
+});
@@ -0,0 +1,251 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b3');
+zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+zigbeeHerdsman.returnDevices.push('0x0017880104e45553');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+describe('Device availability', () => {
+    let controller;
+
+    function getExtension() {
+        return controller.extensions.find((e) => e.constructor.name === 'DeviceAvailability');
+    }
+
+    beforeEach(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        jest.useFakeTimers();
+        settings.set(['advanced', 'availability_timeout'], 10)
+        controller = new Controller();
+        mocksClear.forEach((m) => m.mockClear());
+        await controller.start();
+        await flushPromises();
+    });
+
+    afterEach(async () => {
+        await controller.stop();
+        await flushPromises();
+    })
+
+    it('Should publish availabilty on startup', async () => {
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bulb_color/availability',
+          'online',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+    });
+
+    it('Should publish availabilty offline when ping fails', async () => {
+        MQTT.publish.mockClear();
+        logger.error.mockClear();
+        logger.debug.mockClear();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.ping.mockImplementationOnce(() => {throw new Error('failed')});
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenNthCalledWith(1,
+            'zigbee2mqtt/bulb_color/availability',
+          'offline',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+        expect(logger.error).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith("Failed to ping 'bulb_color'");
+        device.ping.mockImplementationOnce(() => {throw new Error('failed')});
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(logger.debug).toHaveBeenCalledTimes(3);
+        expect(logger.debug).toHaveBeenCalledWith("Failed to ping 'bulb_color'");
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenNthCalledWith(1,
+            'zigbee2mqtt/bulb_color/availability',
+          'offline',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+    });
+
+    it('Should publish availabilty online and query state on reconnect', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        device.ping.mockImplementationOnce(() => {throw new Error('failed')});
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        MQTT.publish.mockClear();
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bulb_color/availability',
+          'online',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+
+        expect(endpoint.read).toHaveBeenCalledTimes(3);
+        expect(endpoint.read).toHaveBeenCalledWith('genLevelCtrl', ['currentLevel']);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+        expect(endpoint.read).toHaveBeenCalledWith('lightingColorCtrl', ['currentX', 'currentY', 'colorTemperature']);
+    });
+
+    it('Should fail gracefully when quering state after reconnect fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        endpoint.read.mockClear();
+        endpoint.read.mockImplementationOnce(() => {throw new Error('Device timedout')});
+        device.ping.mockImplementationOnce(() => {throw new Error('failed')});
+        logger.debug.mockClear();
+        jest.advanceTimersByTime(11 * 2000);
+        await flushPromises();
+
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+        expect(logger.error).toHaveBeenCalledWith(`Failed to read state of 'bulb_color' after reconnect`);
+    });
+
+    it('Shouldnt ping again when still pinging', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.ping.mockClear();
+        device.ping.mockImplementationOnce(async () => {await wait(100000000)});
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should mark device online when receiving message while offline', async () => {
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        device.ping.mockImplementationOnce(() => {throw new Error('failed')});
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+
+        MQTT.publish.mockClear();
+        const data = {modelID: 'test'}
+        const payload = {data, cluster: 'genOnOff', device, endpoint, type: 'readResponse', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenNthCalledWith(1,
+            'zigbee2mqtt/bulb_color/availability',
+          'online',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+    });
+
+    it('Should retrieve the state when device is turned on/off within availability timeout', async () => {
+        MQTT.publish.mockClear();
+        getExtension().state = {};
+        const payload = {device: zigbeeHerdsman.devices.bulb_color};
+        await zigbeeHerdsman.events.deviceJoined(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bulb_color/availability',
+          'online',
+          { retain: true, qos: 0 },
+          expect.any(Function)
+        );
+    });
+
+    it('Should retrieve the state when device is turned on/off within availability timeout on deviceAnnounce', async () => {
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        endpoint.read.mockClear();
+        await zigbeeHerdsman.events.deviceAnnounce({device});
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(3);
+        expect(endpoint.read).toHaveBeenCalledWith('genLevelCtrl', ['currentLevel']);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+        expect(endpoint.read).toHaveBeenCalledWith('lightingColorCtrl', ['currentX', 'currentY', 'colorTemperature']);
+    });
+
+    it('Should not retrieve the state when device is turned on/off within availability timeout on deviceJoined', async () => {
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        endpoint.read.mockClear();
+        await zigbeeHerdsman.events.deviceJoined({device});
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should do nothing when receiving message from non-pingable device', async () => {
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.WXKG11LM;
+        const payload = {device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10, cluster: 'genBasic', data: {modelId: device.modelID}};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not do anything when message has no device', async () => {
+        MQTT.publish.mockClear();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const payload = {ieeeAddr: device.ieeeAddr};
+        await zigbeeHerdsman.events.deviceLeave(payload);
+        await flushPromises();
+        expect(MQTT.publish.mock.calls.find((c) => c[0].includes('availability'))).toBeUndefined();
+    });
+
+    it('Should not ping blacklisted devices', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['advanced', 'availability_blacklist'], [device.ieeeAddr])
+        await controller.stop();
+        await flushPromises();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        device.ping.mockClear();
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should ping forced pingable devices', async () => {
+        const device = zigbeeHerdsman.devices.E11_G13;
+        const endpoint = device.getEndpoint(1);
+        const data = {modelID: 'test'}
+        const payload = {data, cluster: 'genOnOff', device, endpoint, type: 'readResponse', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        device.ping.mockClear();
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should not read when device has no modelID and reconnects', async () => {
+        const device = zigbeeHerdsman.devices.nomodel;
+        getExtension().state[device.ieeeAddr] = true;
+        const endpoint = device.getEndpoint(1);
+        await zigbeeHerdsman.events.deviceAnnounce({device});
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not read when device has is unsupported', async () => {
+        const device = zigbeeHerdsman.devices.unsupported_router;
+        getExtension().state[device.ieeeAddr] = true;
+        const endpoint = device.getEndpoint(1);
+        await zigbeeHerdsman.events.deviceAnnounce({device});
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(0);
+    });
+});
@@ -0,0 +1,174 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+
+describe('Device bind', () => {
+    let controller;
+
+    mockClear = (device) => {
+        for (const endpoint of device.endpoints) {
+            endpoint.read.mockClear();
+            endpoint.write.mockClear();
+            endpoint.configureReporting.mockClear();
+            endpoint.bind.mockClear();
+        }
+    }
+
+    beforeEach(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        this.coordinatorEndoint = zigbeeHerdsman.devices.coordinator.getEndpoint(1);
+        MQTT.publish.mockClear();
+    });
+
+    it('Should subscribe to nested topics', async () => {
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/bind/+');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/bind/+/+');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/bind/+/+/+');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/bind/+/+/+/+/+');
+    });
+
+    it('Should bind', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote', 'bulb_color');
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+        expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genLevelCtrl", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genScenes", target);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'bulb_color', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'bulb_color', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'bulb_color', cluster: 'genLevelCtrl'}});
+    });
+
+    it('Should unbind', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/unbind/remote', 'bulb_color');
+        await flushPromises();
+        expect(endpoint.unbind).toHaveBeenCalledTimes(3);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genOnOff", target);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genLevelCtrl", target);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genScenes", target);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'bulb_color', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'bulb_color', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'bulb_color', cluster: 'genLevelCtrl'}});
+    });
+
+    it('Should unbind coordinator', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.devices.coordinator.getEndpoint(1);
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        endpoint.unbind.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/unbind/remote', 'Coordinator');
+        await flushPromises();
+        expect(endpoint.unbind).toHaveBeenCalledTimes(3);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genOnOff", target);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genLevelCtrl", target);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genScenes", target);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'Coordinator', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'Coordinator', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'Coordinator', cluster: 'genLevelCtrl'}});
+    });
+
+    it('Should bind to groups', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.groups.group_1;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote', 'group_1');
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+        expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genLevelCtrl", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genScenes", target);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genLevelCtrl'}});
+    });
+
+    it('Should bind to group by number', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.groups.group_1;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote', '1');
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+        expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genLevelCtrl", target);
+        expect(endpoint.bind).toHaveBeenCalledWith("genScenes", target);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_bind', message: {from: 'remote', to: 'group_1', cluster: 'genLevelCtrl'}});
+    });
+
+    it('Should log when bind fails', async () => {
+        logger.error.mockClear();
+        const device = zigbeeHerdsman.devices.remote;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        endpoint.bind.mockImplementationOnce(() => {throw new Error('failed')});
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote', 'bulb_color');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith("Failed to bind cluster 'genScenes' from 'remote' to 'bulb_color' (Error: failed)");
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+    });
+
+    it('Should bind from non default endpoints', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.devices.QBKG03LM.getEndpoint(3);
+        const endpoint = device.getEndpoint(2);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote/ep2', 'wall_switch_double/right');
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+        expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
+    });
+
+    it('Should bind to default endpoint returned by endpoints()', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = zigbeeHerdsman.devices.QBKG04LM.getEndpoint(2);
+        const endpoint = device.getEndpoint(2);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/bind/remote/ep2', 'wall_switch');
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+        expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
+    });
+});
@@ -0,0 +1,144 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+describe('Device receive', () => {
+    let controller;
+
+    expectRemoteConfigured = () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const endpoint1 = device.getEndpoint(1);
+        expect(endpoint1.bind).toHaveBeenCalledTimes(2);
+        expect(endpoint1.bind).toHaveBeenCalledWith('genOnOff', this.coordinatorEndoint);
+        const endpoint2 = device.getEndpoint(2);
+        expect(endpoint2.write).toHaveBeenCalledTimes(1);
+        expect(endpoint2.write).toHaveBeenCalledWith("genBasic", {"49": {"type": 25, "value": 11}}, {"disableDefaultResponse": true, "manufacturerCode": 4107});
+        expect(device.meta.configured).toBe(1);
+    }
+
+    expectRemoteNotConfigured = () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const endpoint1 = device.getEndpoint(1);
+        expect(endpoint1.bind).toHaveBeenCalledTimes(0);
+    }
+
+    mockClear = (device) => {
+        for (const endpoint of device.endpoints) {
+            endpoint.read.mockClear();
+            endpoint.write.mockClear();
+            endpoint.configureReporting.mockClear();
+            endpoint.bind.mockClear();
+        }
+    }
+
+    beforeEach(async () => {
+        jest.useRealTimers();
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        mocksClear.forEach((m) => m.mockClear());
+        await flushPromises();
+        this.coordinatorEndoint = zigbeeHerdsman.devices.coordinator.getEndpoint(1);
+    });
+
+    it('Should configure on startup', async () => {
+        expectRemoteConfigured();
+    });
+
+    it('Should not configure twice', async () => {
+        expectRemoteConfigured();
+        const device = zigbeeHerdsman.devices.remote;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should configure on zigbee message when not configured yet', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        delete device.meta.configured;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expectRemoteConfigured();
+    });
+
+    it('Should not configure when interviewing', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        delete device.meta.configured;
+        device.interviewing = true;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expectRemoteNotConfigured();
+        device.interviewing = false;
+    });
+
+    it('Should configure when not interviewCompleted', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        delete device.meta.configured;
+        device.interviewCompleted = false;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expectRemoteConfigured();
+        device.interviewCompleted = true;
+    });
+
+    it('Should not configure when already configuring', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        delete device.meta.configured;
+        const endpoint = device.getEndpoint(1);
+        endpoint.bind.mockImplementationOnce(async () => await wait(500));
+        mockClear(device);
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should configure max 3 times when fails', async () => {
+        controller.extensions.find((e) => e.constructor.name === 'DeviceConfigure').attempts = {};
+        const device = zigbeeHerdsman.devices.remote;
+        delete device.meta.configured;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('BLA')});
+        const payload = {data: {zclVersion: 1}, cluster: 'genBasic', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('BLA')});
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('BLA')});
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('BLA')});
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('BLA')});
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+    });
+});
@@ -0,0 +1,62 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+zigbeeHerdsman.returnDevices.push('0x0017880104e45560');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+const mockOnEvent = jest.fn();
+const mappedLivolo = zigbeeHerdsmanConverters.findByZigbeeModel(zigbeeHerdsman.devices.LIVOLO.modelID);
+mappedLivolo.onEvent = mockOnEvent;
+
+describe('Device event', () => {
+    let controller;
+    const device = zigbeeHerdsman.devices.LIVOLO;
+
+    beforeEach(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        mocksClear.forEach((m) => m.mockClear());
+        await flushPromises();
+    });
+
+    it('Should call with start event', async () => {
+        expect(mockOnEvent).toHaveBeenCalledTimes(1);
+        const call = mockOnEvent.mock.calls[0];
+        expect(call[0]).toBe('start')
+        expect(call[1]).toStrictEqual({})
+        expect(call[2]).toBe(device);
+    });
+
+    it('Should call with stop event', async () => {
+        mockOnEvent.mockClear();
+        await controller.stop();
+        await flushPromises();
+        expect(mockOnEvent).toHaveBeenCalledTimes(1);
+        const call = mockOnEvent.mock.calls[0];
+        expect(call[0]).toBe('stop')
+        expect(call[1]).toStrictEqual({})
+        expect(call[2]).toBe(device);
+    });
+
+    it('Should call with zigbee event', async () => {
+        mockOnEvent.mockClear();
+        await zigbeeHerdsman.events.deviceAnnounce({device});
+        await flushPromises();
+        expect(mockOnEvent).toHaveBeenCalledTimes(1);
+        const call = mockOnEvent.mock.calls[0];
+        expect(call[0]).toBe('deviceAnnounce')
+        expect(call[1]).toStrictEqual({device})
+        expect(call[2]).toBe(device);
+    });
+});
@@ -0,0 +1,390 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+describe('Device receive', () => {
+    let controller;
+
+    beforeEach(async () => {
+        jest.useRealTimers();
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        mocksClear.forEach((m) => m.mockClear());
+    });
+
+    it('Should handle a zigbee message', async () => {
+        const device = zigbeeHerdsman.devices.WXKG11LM;
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({click: 'single', linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+
+    it('Should handle a zigbee message and counter it when Home Assistant integration is enabled', async () => {
+        settings.set(['homeassistant'], true);
+        const device = zigbeeHerdsman.devices.WXKG11LM;
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({click: 'single', linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/button');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({click: '', linkquality: 10});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message which uses ep (left)', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({click: 'left', linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message which uses ep (right)', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(2), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({click: 'right', linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message with default precision', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: -0.85, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should debounce messages', async () => {
+        jest.useFakeTimers();
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['devices', device.ieeeAddr, 'debounce'], 0.1);
+        const data1 = {measuredValue: 8}
+        const payload1 = {data: data1, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload1);
+        const data2 = {measuredValue: 1}
+        const payload2 = {data: data2, cluster: 'msRelativeHumidity', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload2);
+        const data3 = {measuredValue: 2}
+        const payload3 = {data: data3, cluster: 'msPressureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload3);
+        await flushPromises();
+        jest.advanceTimersByTime(50);
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        jest.runAllTimers();
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: 0.08, humidity: 0.01, pressure: 2, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should handle a zigbee message with 1 precision', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['devices', device.ieeeAddr, 'temperature_precision'], 1);
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: -0.8, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should handle a zigbee message with 0 precision', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['devices', device.ieeeAddr, 'temperature_precision'], 0);
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: -1, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should handle a zigbee message with 1 precision when set via device_options', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['device_options', 'temperature_precision'], 1);
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: -0.8, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should handle a zigbee message with 2 precision when overrides device_options', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['device_options', 'temperature_precision'], 1);
+        settings.set(['devices', device.ieeeAddr, 'temperature_precision'], 0);
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: -1, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+
+    it('Should handle a zigbee message with voltage 3010', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {'65281': {'1': 3010}}
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({battery: 100, voltage: 3010, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message with voltage 2850', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {'65281': {'1': 2850}}
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({battery: 35, voltage: 2850, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message with voltage 2650', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {'65281': {'1': 2650}}
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({battery: 14, voltage: 2650, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should handle a zigbee message with voltage 2000', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        const data = {'65281': {'1': 2000}}
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({battery: 0, voltage: 2000, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish 1 message when converted twice', async () => {
+        const device = zigbeeHerdsman.devices.RTCGQ11LM;
+        const data = {'65281': {'1': 3045, '3': 19, '4': 17320, '5': 35, '6': [0, 3], '10': 51107, '11': 381, '100': 0}}
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/occupancy_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'battery': 100, 'illuminance': 381, 'voltage': 3045, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish 1 message when converted twice', async () => {
+        const device = zigbeeHerdsman.devices.RTCGQ11LM;
+        const data = {'9999': {'1': 3045}};
+        const payload = {data, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should publish last_seen epoch', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        settings.set(['advanced', 'last_seen'], 'epoch');
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(typeof JSON.parse(MQTT.publish.mock.calls[0][1]).last_seen).toBe('number')
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish last_seen ISO_8601', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        settings.set(['advanced', 'last_seen'], 'ISO_8601');
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(typeof JSON.parse(MQTT.publish.mock.calls[0][1]).last_seen).toBe('string')
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish last_seen ISO_8601_local', async () => {
+        const device = zigbeeHerdsman.devices.WXKG02LM;
+        settings.set(['advanced', 'last_seen'], 'ISO_8601_local');
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button_double_key');
+        expect(typeof JSON.parse(MQTT.publish.mock.calls[0][1]).last_seen).toBe('string')
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should not handle messages forwarded Xiaomi messages', async () => {
+        const device = zigbeeHerdsman.devices.ZNCZ02LM;
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10, groupID: 599};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should handle messages from Xiaomi router devices', async () => {
+        const device = zigbeeHerdsman.devices.ZNCZ02LM;
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 20};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/power_plug');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'state': 'ON', linkquality: 20});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should not handle messages from coordinator', async () => {
+        const device = zigbeeHerdsman.devices.coordinator;
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not handle messages from unsupported devices', async () => {
+        const device = zigbeeHerdsman.devices.unsupported;
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not handle messages from still interviewing devices with unknown modelID', async () => {
+        const device = zigbeeHerdsman.devices.interviewing;
+        const data = {onOff: 1};
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(logger.debug).toHaveBeenCalledWith(`Skipping message, modelID is undefined and still interviewing`);
+    });
+
+    it('Should handle a command', async () => {
+        const device = zigbeeHerdsman.devices.E1743;
+        const data = {};
+        const payload = {data, cluster: 'genLevelCtrl', device, endpoint: device.getEndpoint(1), type: 'commandStopWithOnOff', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/ikea_onoff');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'click': 'brightness_stop', linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should add elapsed', async () => {
+        settings.set(['advanced', 'elapsed'], true);
+        const device = zigbeeHerdsman.devices.E1743;
+        const payload = {data: {}, cluster: 'genLevelCtrl', device, endpoint: device.getEndpoint(1), type: 'commandStopWithOnOff'};
+        const oldNow = Date.now;
+        Date.now = jest.fn()
+        Date.now.mockReturnValue(new Date(150));
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        Date.now.mockReturnValue(new Date(200));
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/ikea_onoff');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'click': 'brightness_stop'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/ikea_onoff');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toMatchObject({'click': 'brightness_stop'});
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1]).elapsed).toBe(50);
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+        Date.now = oldNow;
+    });
+
+    it('Should log when message is from supported device but has no converters', async () => {
+        const device = zigbeeHerdsman.devices.ZNCZ02LM;
+        const data = {inactiveText: 'hello'};
+        const payload = {data, cluster: 'genBinaryOutput', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 20};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(logger.warn).toHaveBeenCalledWith('No converter available for \'ZNCZ02LM\' with cluster \'genBinaryOutput\' and type \'attributeReport\' and data \'{"inactiveText":"hello"}\'');
+    });
+
+    it('Should not log when message is from supported device but has no converters is readResponse', async () => {
+        const device = zigbeeHerdsman.devices.ZNCZ02LM;
+        const data = {inactiveText: 'hello'};
+        const payload = {data, cluster: 'genBinaryOutput', device, endpoint: device.getEndpoint(1), type: 'readResponse', linkquality: 20};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(logger.warn).toBeCalledTimes(0);
+    });
+
+    it('Should allow to calibrate temperature values', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['devices', device.ieeeAddr, 'temperature_calibration'], 2);
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: 1.15, linkquality: 10});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+    });
+});
@@ -0,0 +1,200 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b3');
+zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b2');
+zigbeeHerdsman.returnDevices.push('0x0017880104e45553');
+zigbeeHerdsman.returnDevices.push('0x0017880104e45559');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b4');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b7');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+jest.mock('debounce', () => jest.fn(fn => fn));
+const debounce = require('debounce');
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug, debounce];
+
+describe('Device report', () => {
+    let controller;
+
+    function expectOnOffBrightnessColorReport(endpoint) {
+        const coordinatorEndpoint = zigbeeHerdsman.devices.coordinator.getEndpoint(1);
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+        expect(endpoint.bind).toHaveBeenCalledWith('genOnOff', coordinatorEndpoint);
+        expect(endpoint.bind).toHaveBeenCalledWith('genLevelCtrl', coordinatorEndpoint);
+        expect(endpoint.bind).toHaveBeenCalledWith('lightingColorCtrl', coordinatorEndpoint);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(3);
+        expect(endpoint.configureReporting).toHaveBeenCalledWith('genOnOff', [{"attribute": "onOff", "maximumReportInterval": 300, "minimumReportInterval": 0, "reportableChange": 0}]);
+        expect(endpoint.configureReporting).toHaveBeenCalledWith('genLevelCtrl', [{"attribute": "currentLevel", "maximumReportInterval": 300, "minimumReportInterval": 3, "reportableChange": 0}]);
+        expect(endpoint.configureReporting).toHaveBeenCalledWith('lightingColorCtrl', [{"attribute": "colorTemperature", "maximumReportInterval": 300, "minimumReportInterval": 3, "reportableChange": 0}, {"attribute": "currentX", "maximumReportInterval": 300, "minimumReportInterval": 3, "reportableChange": 0}, {"attribute": "currentY", "maximumReportInterval": 300, "minimumReportInterval": 3, "reportableChange": 0}]);
+    }
+
+    mockClear = (device) => {
+        for (const endpoint of device.endpoints) {
+            endpoint.read.mockClear();
+            endpoint.write.mockClear();
+            endpoint.configureReporting.mockClear();
+            endpoint.bind.mockClear();
+        }
+    }
+
+    beforeEach(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        settings.set(['advanced', 'report'], true);
+        controller = new Controller();
+        await controller.start();
+        mocksClear.forEach((m) => m.mockClear());
+        await flushPromises();
+    });
+
+    it('Should configure reporting on startup', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        expectOnOffBrightnessColorReport(endpoint);
+    });
+
+    it('Should configure reporting when receicing message from device which has not been setup yet', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        device.save.mockClear();
+        mockClear(device);
+        delete device.meta.reporting;
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expectOnOffBrightnessColorReport(endpoint);
+        expect(device.save).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should not configure reporting when still configuring', async () => {
+        jest.useFakeTimers();
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        endpoint.bind.mockImplementationOnce(async () => await wait(1000));
+        delete device.meta.reporting;
+        mockClear(device);
+        const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+        jest.runAllTimers();
+        jest.useRealTimers();
+    });
+
+    it('Should not mark as configured when reporting setup fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('failed')});
+        delete device.meta.reporting;
+        mockClear(device);
+        const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+        expect(device.meta.reporting).toBeUndefined();
+    });
+
+    it('Should not configure reporting when receicing message from device which has already been setup yet', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const data = {onOff: 1}
+        const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(0);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not configure reporting for end devices', async () => {
+        const device = zigbeeHerdsman.devices.E11_G13;
+        const endpoint = device.getEndpoint(1);
+        expect(endpoint.bind).toHaveBeenCalledTimes(0);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should configure reporting when deviceAnnounce message from IKEA device', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        const payload = {device};
+        await zigbeeHerdsman.events.deviceAnnounce(payload);
+        await flushPromises();
+        expectOnOffBrightnessColorReport(endpoint);
+    });
+
+    it('Should not configure reporting on device leave', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        delete device.meta.reporting;
+        mockClear(device);
+        await zigbeeHerdsman.events.deviceLeave({ieeeAddr: device.ieeeAddr});
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(0);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not configure reporting for the CC2530 router', async () => {
+        const device = zigbeeHerdsman.devices.CC2530_ROUTER;
+        const endpoint = device.getEndpoint(1);
+        delete device.meta.reporting;
+        mockClear(device);
+        await zigbeeHerdsman.events.deviceLeave({ieeeAddr: device.ieeeAddr});
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(0);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not configure reporting again when it already failed once', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        endpoint.bind.mockImplementationOnce(async () => {throw new Error('failed')});
+        delete device.meta.reporting;
+        mockClear(device);
+        const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should poll bounded Hue bulb when receiving message from Hue dimmer', async () => {
+        const remote = zigbeeHerdsman.devices.remote;
+        const data = {"button":3,"unknown1":3145728,"type":2,"unknown2":0,"time":1};
+        const payload = {data, cluster: 'manuSpecificPhilips', device: remote, endpoint: remote.getEndpoint(2), type: 'commandHueNotification', linkquality: 10, groupID: 0};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(debounce).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.devices.bulb_color.getEndpoint(1).read).toHaveBeenCalledWith("genLevelCtrl", ["currentLevel"]);
+    });
+
+    it('Should poll grouped Hue bulb when receiving message from TRADFRI remote and should', async () => {
+        const remote = zigbeeHerdsman.devices.tradfri_remote;
+        const data = {"stepmode":0,"stepsize":43,"transtime":5};
+        const payload = {data, cluster: 'genLevelCtrl', device: remote, endpoint: remote.getEndpoint(1), type: 'commandStepWithOnOff', linkquality: 10, groupID: 15071};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(debounce).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.devices.bulb_color_2.getEndpoint(1).read).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.devices.bulb_color_2.getEndpoint(1).read).toHaveBeenCalledWith("genLevelCtrl", ["currentLevel"]);
+
+        // Should also only debounce once
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(debounce).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.devices.bulb_color_2.getEndpoint(1).read).toHaveBeenCalledTimes(2);
+
+        // Should only call Hue bulb, not e.g. tradfri
+        expect(zigbeeHerdsman.devices.bulb.getEndpoint(1).read).toHaveBeenCalledTimes(0);
+    });
+});
@@ -0,0 +1,855 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+const expectNothingPublished = () => {
+    Object.values(zigbeeHerdsman.devices).forEach((d) => {
+        d.endpoints.forEach((e) => {
+            expect(e.command).toHaveBeenCalledTimes(0);
+            expect(e.read).toHaveBeenCalledTimes(0);
+            expect(e.write).toHaveBeenCalledTimes(0);
+        });
+    })
+    Object.values(zigbeeHerdsman.groups).forEach((g) => {
+        expect(g.command).toHaveBeenCalledTimes(0);
+    })
+}
+
+describe('Entity publish', () => {
+    let controller;
+
+    beforeAll(async () => {
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        await wait(50);
+    });
+
+    beforeEach(async () => {
+        jest.useRealTimers();
+        await flushPromises();
+        data.writeDefaultConfiguration();
+        controller.state.state = {};
+        settings._reRead();
+        mocksClear.forEach((m) => m.mockClear());
+        Object.values(zigbeeHerdsman.devices).forEach((d) => {
+            d.endpoints.forEach((e) => {
+                e.command.mockClear();
+                e.read.mockClear();
+                e.write.mockClear();
+            })
+        })
+        Object.values(zigbeeHerdsman.groups).forEach((g) => {
+            g.command.mockClear();
+        });
+    });
+
+    it('Should publish messages to zigbee devices', async () => {
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness: '200'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {"level": 200, "transtime": 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({brightness: 200, state: 'ON'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices when there is no converters', async () => {
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness_no: '200'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should publish messages to zigbee devices when there is a get converter but no set', async () => {
+        await MQTT.events.message('zigbee2mqtt/thermostat/set', JSON.stringify({relay_status_log_rsp: '200'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should publish messages to zigbee devices with complicated topic', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'friendly_name'], 'wohnzimmer.light.wall.right')
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/wohnzimmer.light.wall.right/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/wohnzimmer.light.wall.right');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices when brightness is in %', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness_percent: '92'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 235, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 235});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices when brightness is in number', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness: 230}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 230, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 230});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color_temp', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({color_temp: '222'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 222, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 222, color: {x: 0.360786471097048, y: 0.363543544699483}});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color_temp in %', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({color_temp_percent: '100'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 500, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 500, color: {x: 0.526676280311873, y: 0.41329727450763}});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with non-default ep', async () => {
+        const device = zigbeeHerdsman.devices.QBKG04LM;
+        const endpoint = device.getEndpoint(2);
+        await MQTT.events.message('zigbee2mqtt/wall_switch/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "off", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/wall_switch');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with non-default ep and postfix', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        const endpoint = device.getEndpoint(3);
+        await MQTT.events.message('zigbee2mqtt/wall_switch_double/right/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "off", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/wall_switch_double');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state_right: 'OFF'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color xy', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 62, color: {x: 100, y: 50}});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color xy and state', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({color: {x: 100, y: 50}, state: 'ON'}));
+        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(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({color: {x: 100, y: 50}, color_temp: 62, state: 'ON'});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color xy and brightness', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 20});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({color: {x: 100, y: 50}, state: 'ON', color_temp: 62, brightness: 20});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color xy, brightness and state on', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 20});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({color: {x: 100, y: 50}, state: 'ON', color_temp: 62, brightness: 20});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color xy, brightness and state off', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({color: {x: 100, y: 50}, brightness: 20, state: 'OFF'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(2);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "off", {}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColor", {colorx: 6553500, colory: 3276750, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({color: {x: 100, y: 50}, color_temp: 62, state: 'OFF'});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices with color rgb', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 156, color: {x: 0.2717, y: 0.6585}});
+    });
+
+    it('Should publish messages to zigbee devices with color rgb', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 156, color: {x: 0.2717, y: 0.6585}});
+    });
+
+    it('Should publish messages to zigbee devices with color rgb', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'ON', brightness: '50'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 50});
+    });
+
+    it('Should publish messages groups', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON'});
+    });
+
+    it('Should publish messages to groups with brightness_percent', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({brightness_percent: 50}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 127, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 127});
+    });
+
+    it('Should publish messages to groups with on and brightness', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON', brightness: 50}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 50, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 50});
+    });
+
+    it('Should publish messages to groups with off and brightness', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'OFF', brightness: 50}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("genOnOff", "off", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
+    });
+
+    it('Should publish messages to groups color', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color: {x: 0.37, y: 0.28}});
+    });
+
+    it('Should publish messages to groups color temperature', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({color_temp: 100}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("lightingColorCtrl", "moveToColorTemp", {colortemp: 100, transtime: 0}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color_temp: 100});
+    });
+
+    it('Should create and publish to group which is in configuration.yaml but not in zigbee-herdsman', async () => {
+        delete zigbeeHerdsman.groups.group_2;
+        expect(Object.values(zigbeeHerdsman.groups).length).toBe(4);
+        await MQTT.events.message('zigbee2mqtt/group_2/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(Object.values(zigbeeHerdsman.groups).length).toBe(5);
+        expect(zigbeeHerdsman.groups.group_2.command).toHaveBeenCalledTimes(1);
+        expect(zigbeeHerdsman.groups.group_2.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should handle non-valid topics', async () => {
+        await MQTT.events.message('zigbee2mqtt1/bulb_color/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should handle non-valid topics', async () => {
+        await MQTT.events.message('zigbee2mqtt1/bulb_color/sett', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should handle non-valid topics', async () => {
+        await MQTT.events.message('zigbee2mqtt/bulb_color/write', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should handle non-valid topics', async () => {
+        await MQTT.events.message('zigbee2mqtt/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should handle non-valid topics', async () => {
+        await MQTT.events.message('set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should handle get', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/get', JSON.stringify({state: ''}));
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+    });
+
+    it('Should not respond to bridge/config/devices/get', async () => {
+        await MQTT.events.message('zigbee2mqtt/bridge/config/devices/get', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should not respond to bridge/config/devices/set', async () => {
+        await MQTT.events.message('zigbee2mqtt/bridge/config/devices/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should not respond to bridge/config/devices', async () => {
+        await MQTT.events.message('zigbee2mqtt/bridge/config/devices', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should parse topic with when base topic has multiple slashes', async () => {
+        settings.set(['mqtt', 'base_topic'], 'zigbee2mqtt/at/my/home');
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/at/my/home/bulb_color/get', JSON.stringify({state: ''}));
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+    });
+
+    it('Should parse topic with when deviceID has multiple slashes', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'friendly_name'], 'floor0/basement/my_device_id2');
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/floor0/basement/my_device_id2/get', JSON.stringify({state: ''}));
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+    });
+
+    it('Should parse topic with when base and deviceID have multiple slashes', async () => {
+        settings.set(['mqtt', 'base_topic'], 'zigbee2mqtt/at/my/basement');
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'friendly_name'], 'floor0/basement/my_device_id2');
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/at/my/basement/floor0/basement/my_device_id2/get', JSON.stringify({state: ''}));
+        await flushPromises();
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
+        expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
+    });
+
+    it('Should parse set with attribute topic', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set/state', 'ON');
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should parse set with ieeeAddr topic', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/0x000b57fffec6a5b3/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should parse set with non-existing postfix', async () => {
+        await MQTT.events.message('zigbee2mqtt/wall_switch_double/invalid/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should parse set with postfix topic and attribute', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        const endpoint = device.getEndpoint(2);
+        await MQTT.events.message('zigbee2mqtt/wall_switch_double/left/set', 'ON');
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should parse set with and slashes in base and deviceID postfix topic', async () => {
+        settings.set(['mqtt', 'base_topic'], 'zigbee2mqtt/at/my/home')
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        settings.set(['devices', device.ieeeAddr, 'friendly_name'], 'in/basement/wall_switch_double');
+        const endpoint = device.getEndpoint(2);
+        await MQTT.events.message('zigbee2mqtt/at/my/home/in/basement/wall_switch_double/left/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should parse set with number at the end of friendly_name and postfix', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        settings.set(['devices', device.ieeeAddr, 'friendly_name'], 'ground_floor/kitchen/wall_switch/2');
+        const endpoint = device.getEndpoint(2);
+        await MQTT.events.message('zigbee2mqtt/ground_floor/kitchen/wall_switch/2/left/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "on", {}, {});
+    });
+
+    it('Should not publish messages to zigbee devices when payload is invalid', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        const endpoint = device.getEndpoint(2);
+        await MQTT.events.message('zigbee2mqtt/wall_switch_double/left/set', JSON.stringify({state: true}));
+        await MQTT.events.message('zigbee2mqtt/wall_switch_double/left/set', JSON.stringify({state: 1}));
+        await flushPromises();
+        expectNothingPublished();
+    });
+
+    it('Should set state before color', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'ON', 'color': {'x': 0.701, 'y': 0.299}};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        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}, {}]);
+    });
+
+    it('Should read after write when enabled', async () => {
+        jest.useFakeTimers();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'retrieve_state'], true);
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'ON', 'color': {'x': 0.701, 'y': 0.299}};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        jest.runAllTimers();
+        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.read).toHaveBeenCalledTimes(2);
+        expect(endpoint.read.mock.calls[0]).toEqual(["genOnOff", ["onOff"]]);
+        expect(endpoint.read.mock.calls[1]).toEqual(["lightingColorCtrl", ["currentX", "currentY", "colorTemperature"]]);
+    });
+
+    it('Should use transition when brightness with group', async () => {
+        const group = zigbeeHerdsman.groups.group_1;
+        settings.set(['groups', '1', 'transition'], 20);
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({brightness: 100}));
+        await flushPromises();
+        expect(group.command).toHaveBeenCalledTimes(1);
+        expect(group.command).toHaveBeenCalledWith("genLevelCtrl", "moveToLevelWithOnOff", {level: 100, transtime: 200}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/group_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', brightness: 100});
+    });
+
+    it('Should use transition when brightness', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'transition'], 20);
+        const endpoint = device.getEndpoint(1);
+        const payload = {brightness: 20};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 20, transtime: 200}, {}]);
+    });
+
+    it('Should use transition when color temp', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'transition'], 20);
+        const endpoint = device.getEndpoint(1);
+        const payload = {color_temp: 200};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 200, transtime: 200}, {}]);
+    });
+
+    it('Should use transition only once when setting brightness and color temperature for TRADFRI', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', brightness: 20, color_temp: 200, transition: 20};
+        await MQTT.events.message('zigbee2mqtt/bulb/set', JSON.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}, {}]);
+    });
+
+    it('Should use transition only once when setting brightness and color temperature for group which contains TRADFRI', async () => {
+        const group = zigbeeHerdsman.groups.group_with_tradfri;
+        await MQTT.events.message('zigbee2mqtt/group_with_tradfri/set', JSON.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}, {}]);
+    });
+
+    it('Message transition should overrule options transition', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['devices', device.ieeeAddr, 'transition'], 20);
+        const endpoint = device.getEndpoint(1);
+        const payload = {brightness: 200, transition: 10};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 100}, {}]);
+    });
+
+    it('Should set state with brightness before color', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'ON', 'color': {'x': 0.701, 'y': 0.299}, 'transition': 3, 'brightness': 100};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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}, {}]);
+    });
+
+    it('Should turn device off when brightness 0 is send', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'brightness': 0};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "off", {}, {}]);
+    });
+
+    it('Should turn device off when brightness 0 is send with light_brightness converter', async () => {
+        const device = zigbeeHerdsman.devices.HGZB04D;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'brightness': 0};
+        await MQTT.events.message('zigbee2mqtt/dimmer_wall_switch/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "off", {}, {}]);
+    });
+
+    it('ZNCLDJ11LM open', async () => {
+        const device = zigbeeHerdsman.devices.ZNCLDJ11LM;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'OPEN'};
+        await MQTT.events.message('zigbee2mqtt/curtain/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.write).toHaveBeenCalledTimes(1);
+        expect(endpoint.write).toHaveBeenCalledWith("genAnalogOutput", {"85": {"type": 57, "value": 100}});
+    });
+
+    it('ZNCLDJ11LM position', async () => {
+        const device = zigbeeHerdsman.devices.ZNCLDJ11LM;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'position': 10};
+        await MQTT.events.message('zigbee2mqtt/curtain/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.write).toHaveBeenCalledTimes(1);
+        expect(endpoint.write).toHaveBeenCalledWith("genAnalogOutput", {"85": {"type": 57, "value": 10}});
+    });
+
+    it('ZNCLDJ11LM position', async () => {
+        const device = zigbeeHerdsman.devices.ZNCLDJ11LM;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'CLOSE'};
+        await MQTT.events.message('zigbee2mqtt/curtain/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.write).toHaveBeenCalledTimes(1);
+        expect(endpoint.write).toHaveBeenCalledWith("genAnalogOutput", {"85": {"type": 57, "value": 0}});
+    });
+
+    it('ZNCLDJ11LM position', async () => {
+        const device = zigbeeHerdsman.devices.ZNCLDJ11LM;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'state': 'STOP'};
+        await MQTT.events.message('zigbee2mqtt/curtain/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("closuresWindowCovering", "stop", {}, {});
+    });
+
+
+    it('Should turn device on with on/off when transition is provided', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', transition: 1};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
+    });
+
+    it('Should turn device off with onOff on off with transition', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'OFF', transition: 1};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "off", {}, {}]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
+    });
+
+    it('Home Assistant: should set state', async () => {
+        settings.set(['homeassistant'], true);
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON'};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON'});
+    });
+
+    it('Home Assistant: should not set state when color temperature is also set and device is already on', async () => {
+        settings.set(['homeassistant'], true);
+        const device = zigbeeHerdsman.devices.bulb_color;
+        controller.state.set(device.ieeeAddr, {state: 'ON'})
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', color_temp: 100};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "moveToColorTemp", {colortemp: 100, transtime: 0}, {}]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON', color: {x: 0.280632719756407, y: 0.288286029784579}, color_temp: 100});
+    });
+
+    it('Home Assistant: should set state when color temperature is also set and device is off', async () => {
+        settings.set(['homeassistant'], true);
+        const device = zigbeeHerdsman.devices.bulb_color;
+        controller.state.set(device.ieeeAddr, {state: 'OFF'})
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', color_temp: 100};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        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(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'ON'});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({state: 'ON', color: {x: 0.280632719756407, y: 0.288286029784579}, color_temp: 100});
+    });
+
+    it('Home Assistant: should not set state when color is also set', async () => {
+        settings.set(['homeassistant'], true);
+        const device = zigbeeHerdsman.devices.bulb_color;
+        controller.state.set(device.ieeeAddr, {state: 'ON'})
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', color: {x: 0.41, y: 0.25}};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.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(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({color: {x: 0.41, y: 0.25}, color_temp: 150, state: 'ON'});
+    });
+
+    it('Should publish correct state on toggle command to zigbee bulb', async () => {
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'TOGGLE'}));
+        await flushPromises();
+
+        // At this point the bulb has no state yet, so we cannot determine the next state and therefore shouldn't publish it to MQTT.
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "toggle", {}, {});
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+
+        // Turn bulb off so that the bulb gets a state.
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+
+        // Toggle again, now that we have state it should publish state ON
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'TOGGLE'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({state: 'ON'});
+        expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages with options disableDefaultResponse', async () => {
+        const device = zigbeeHerdsman.devices.GLEDOPTO1112;
+        const endpoint = device.getEndpoint(11);
+        await MQTT.events.message('zigbee2mqtt/led_controller_1/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genOnOff", "off", {}, {disableDefaultResponse: true});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/led_controller_1');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish messages to zigbee devices', async () => {
+        settings.set(['advanced', 'last_seen'], 'ISO_8601')
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness: '200'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(typeof JSON.parse(MQTT.publish.mock.calls[0][1]).last_seen).toStrictEqual('string');
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('HS2WD-E burglar warning', async () => {
+        const endpoint = zigbeeHerdsman.devices.HS2WD.getEndpoint(1);
+        const payload = {warning: {duration: 100, mode: 'burglar', strobe: true, level: 'high'}};
+        await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 22, "warningduration": 100}, {});
+    });
+
+    it('HS2WD-E emergency warning', async () => {
+        const endpoint = zigbeeHerdsman.devices.HS2WD.getEndpoint(1);
+        const payload = {warning: {duration: 10, mode: 'emergency', strobe: false, level: 'very_high'}};
+        await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 51, "warningduration": 10}, {});
+    });
+
+    it('HS2WD-E emergency without level', async () => {
+        const endpoint = zigbeeHerdsman.devices.HS2WD.getEndpoint(1);
+        const payload = {warning: {duration: 10, mode: 'emergency', strobe: false}};
+        await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 49, "warningduration": 10}, {});
+    });
+
+    it('HS2WD-E wrong payload (should use defaults)', async () => {
+        const endpoint = zigbeeHerdsman.devices.HS2WD.getEndpoint(1);
+        const payload = {warning: 'wrong'};
+        await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 53, "warningduration": 10}, {});
+    });
+
+    it('Shouldnt do anythign when device is not supported', async () => {
+        const payload = {state: 'ON'};
+        await MQTT.events.message('zigbee2mqtt/unsupported2/set', JSON.stringify(payload));
+        await flushPromises();
+        expectNothingPublished();
+    });
+});
@@ -0,0 +1,443 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+zigbeeHerdsman.returnDevices.push('0x00124b00120144ae');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b3');
+zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b2');
+zigbeeHerdsman.returnDevices.push('0x0017880104e45542');
+const MQTT = require('./stub/mqtt');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const settings = require('../lib/util/settings');
+
+describe('Groups', () => {
+    let controller;
+
+    beforeEach(() => {
+        controller = new Controller();
+        Object.values(zigbeeHerdsman.groups).forEach((g) => g.members = []);
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        MQTT.publish.mockClear();
+    })
+
+    it('Apply group updates add', async () => {
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: ['bulb', 'bulb_color']}});
+        zigbeeHerdsman.groups.group_1.members.push(zigbeeHerdsman.devices.bulb.getEndpoint(1))
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([
+            zigbeeHerdsman.devices.bulb.getEndpoint(1),
+            zigbeeHerdsman.devices.bulb_color.getEndpoint(1)
+        ]);
+    });
+
+    it('Apply group updates remove', async () => {
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false,}});
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([]);
+    });
+
+    it('Move to non existing group', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'3': {friendly_name: 'group_3', retain: false, devices: [device.ieeeAddr]}});
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([]);
+    });
+
+    it('Add non standard endpoint to group with name', async () => {
+        const QBKG03LM = zigbeeHerdsman.devices.QBKG03LM;
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: ['0x0017880104e45542/right']}});
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([QBKG03LM.getEndpoint(3)]);
+    });
+
+    it('Add non standard endpoint to group with number', async () => {
+        const QBKG03LM = zigbeeHerdsman.devices.QBKG03LM;
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: ['wall_switch_double/2']}});
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([QBKG03LM.getEndpoint(2)]);
+    });
+
+    it('Shouldnt crash on non-existing devices', async () => {
+        logger.error.mockClear();
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: ['not_existing_bla']}});
+        await controller.start();
+        await flushPromises();
+        expect(zigbeeHerdsman.groups.group_1.members).toStrictEqual([]);
+        expect(logger.error).toHaveBeenCalledWith("Cannot find 'not_existing_bla' of group 'group_1'");
+    });
+
+    it('Add to group via MQTT', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: []}});
+        expect(group.members.length).toBe(0);
+        await controller.start();
+        await flushPromises();
+        MQTT.events.message('zigbee2mqtt/bridge/group/group_1/add', 'bulb_color');
+        await flushPromises();
+        expect(group.members).toStrictEqual([endpoint]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([`${device.ieeeAddr}/1`]);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_group_add","message":{"friendly_name":"bulb_color","group":"group_1"}}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Add to group with slashes via MQTT', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups["group/with/slashes"];
+        settings.set(['groups'], {'99': {friendly_name: 'group/with/slashes', retain: false, devices: []}});
+        expect(group.members.length).toBe(0);
+        await controller.start();
+        await flushPromises();
+        MQTT.events.message('zigbee2mqtt/bridge/group/group/with/slashes/add', 'bulb_color');
+        await flushPromises();
+        expect(group.members).toStrictEqual([endpoint]);
+        expect(settings.getGroup('group/with/slashes').devices).toStrictEqual([`${device.ieeeAddr}/1`]);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_group_add","message":{"friendly_name":"bulb_color","group":"group/with/slashes"}}', {"retain": false, qos: 0}, expect.any(Function));
+
+        // Test if subscribed to topics with slashes
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/group/+/remove');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/group/+/+/remove');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/group/+/+/+/+/+/remove');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/group/+/+/+/+/+/add');
+    });
+
+    it('Add to group via MQTT with postfix', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        const endpoint = device.getEndpoint(3);
+        const group = zigbeeHerdsman.groups.group_1;
+        expect(group.members.length).toBe(0);
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/add', 'wall_switch_double/right');
+        await flushPromises();
+        expect(group.members).toStrictEqual([endpoint]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([`${device.ieeeAddr}/${endpoint.ID}`]);
+    });
+
+    it('Add to group via MQTT with postfix shouldnt add it twice', async () => {
+        const device = zigbeeHerdsman.devices.QBKG03LM;
+        const endpoint = device.getEndpoint(3);
+        const group = zigbeeHerdsman.groups.group_1;
+        expect(group.members.length).toBe(0);
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/add', 'wall_switch_double/right');
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/add', '0x0017880104e45542/3');
+        await flushPromises();
+        expect(group.members).toStrictEqual([endpoint]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([`${device.ieeeAddr}/${endpoint.ID}`]);
+    });
+
+    it('Remove from group via MQTT', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [device.ieeeAddr]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove', 'bulb_color');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_group_remove","message":{"friendly_name":"bulb_color","group":"group_1"}}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Remove from group via MQTT when in zigbee but not in settings', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: ['dummy']}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove', 'bulb_color');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual(['dummy']);
+    });
+
+    it('Remove from group via MQTT with postfix variant 1', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [`wall_switch_double/right`]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove', '0x0017880104e45542/3');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+    });
+
+    it('Remove from group via MQTT with postfix variant 2', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [`0x0017880104e45542/right`]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove', 'wall_switch_double/3');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+    });
+
+    it('Remove from group via MQTT with postfix variant 3', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [`wall_switch_double/3`]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove', '0x0017880104e45542/right');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+    });
+
+    it('Remove from group all', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [`wall_switch_double/3`]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/remove_all', '0x0017880104e45542/right');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bridge/log", '{"type":"device_group_remove_all","message":{"friendly_name":"wall_switch_double"}}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Remove from group all deprecated', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [`wall_switch_double/3`]}});
+        await controller.start();
+        await flushPromises();
+        await MQTT.events.message('zigbee2mqtt/bridge/group/group_1/remove_all', '0x0017880104e45542/right');
+        await flushPromises();
+        expect(group.members).toStrictEqual([]);
+        expect(settings.getGroup('group_1').devices).toStrictEqual([]);
+    });
+
+    it('Log when adding to non-existing group', async () => {
+        await controller.start();
+        await flushPromises();
+        logger.error.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/group/group_1_not_existing/add', 'bulb_color');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledWith("Group 'group_1_not_existing' does not exist");
+    });
+
+    it('Log when adding to non-existing device', async () => {
+        await controller.start();
+        await flushPromises();
+        logger.error.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/group/group_1/add', 'bulb_color_not_existing');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledWith("Device 'bulb_color_not_existing' does not exist");
+    });
+
+    it('Should publish group state change when a device in it changes state', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [device.ieeeAddr]}});
+        await controller.start();
+        await flushPromises();
+
+        MQTT.publish.mockClear();
+        const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"ON","linkquality":10}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_1", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should publish state change of all members when a group changes its state', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', retain: false, devices: [device.ieeeAddr]}});
+        await controller.start();
+        await flushPromises();
+
+        MQTT.publish.mockClear();
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_1", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Shouldnt publish group state change when a group is not optimistic', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {'1': {friendly_name: 'group_1', devices: [device.ieeeAddr], optimistic: false, retain: false}});
+        await controller.start();
+        await flushPromises();
+
+        MQTT.publish.mockClear();
+        controller.state.state = {};
+        const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint, type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"ON","linkquality":10}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should publish state change of another group with shared device when a group changes its state', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint);
+        settings.set(['groups'], {
+            '1': {friendly_name: 'group_1', retain: false, devices: [device.ieeeAddr]},
+            '2': {friendly_name: 'group_2', retain: false, devices: [device.ieeeAddr]},
+            '3': {friendly_name: 'group_3', retain: false, devices: []}
+        });
+        await controller.start();
+        await flushPromises();
+
+        MQTT.publish.mockClear();
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_1", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_2", '{"state":"ON"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should not publish state change off if any lights within are still on when changed via device', async () => {
+        const device_1 = zigbeeHerdsman.devices.bulb_color;
+        const device_2 = zigbeeHerdsman.devices.bulb;
+        const endpoint_1 = device_1.getEndpoint(1);
+        const endpoint_2 = device_2.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint_1);
+        group.members.push(endpoint_2);
+        settings.set(['groups'], {
+            '1': {friendly_name: 'group_1', devices: [device_1.ieeeAddr, device_2.ieeeAddr], retain: false}
+        });
+        await controller.start();
+        await flushPromises();
+
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        MQTT.publish.mockClear();
+
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should not publish state change off if any lights within are still on when changed via shared group', async () => {
+        const device_1 = zigbeeHerdsman.devices.bulb_color;
+        const device_2 = zigbeeHerdsman.devices.bulb;
+        const endpoint_1 = device_1.getEndpoint(1);
+        const endpoint_2 = device_2.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint_1);
+        group.members.push(endpoint_2);
+        settings.set(['groups'], {
+            '1': {friendly_name: 'group_1', devices: [device_1.ieeeAddr, device_2.ieeeAddr], retain: false},
+            '2': {friendly_name: 'group_2', retain: false, devices: [device_1.ieeeAddr]},
+        });
+        await controller.start();
+        await flushPromises();
+
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        MQTT.publish.mockClear();
+
+        await MQTT.events.message('zigbee2mqtt/group_2/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_2", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should publish state change off if all lights within turn off', async () => {
+        const device_1 = zigbeeHerdsman.devices.bulb_color;
+        const device_2 = zigbeeHerdsman.devices.bulb;
+        const endpoint_1 = device_1.getEndpoint(1);
+        const endpoint_2 = device_2.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint_1);
+        group.members.push(endpoint_2);
+        settings.set(['groups'], {
+            '1': {friendly_name: 'group_1', devices: [device_1.ieeeAddr, device_2.ieeeAddr], retain: false}
+        });
+        await controller.start();
+        await flushPromises();
+
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        MQTT.publish.mockClear();
+
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'OFF'}));
+        await MQTT.events.message('zigbee2mqtt/bulb/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb", '{"state":"OFF","brightness":50,"color_temp":370,"linkquality":99}', {"retain": true, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_1", '{"state":"OFF","brightness":50,"color_temp":370}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+
+    it('Should publish state change off even when missing current state', async () => {
+        const device_1 = zigbeeHerdsman.devices.bulb_color;
+        const device_2 = zigbeeHerdsman.devices.bulb;
+        const endpoint_1 = device_1.getEndpoint(1);
+        const endpoint_2 = device_2.getEndpoint(1);
+        const group = zigbeeHerdsman.groups.group_1;
+        group.members.push(endpoint_1);
+        group.members.push(endpoint_2);
+        settings.set(['groups'], {
+            '1': {friendly_name: 'group_1', devices: [device_1.ieeeAddr, device_2.ieeeAddr], retain: false}
+        });
+        await controller.start();
+        await flushPromises();
+
+        await MQTT.events.message('zigbee2mqtt/group_1/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        MQTT.publish.mockClear();
+        controller.state.state = {};
+
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'OFF'}));
+        await flushPromises();
+
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb_color", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/group_1", '{"state":"OFF"}', {"retain": false, qos: 0}, expect.any(Function));
+    });
+});
@@ -0,0 +1,639 @@
+const data = require('./stub/data');
+const settings = require('../lib/util/settings');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const flushPromises = () => new Promise(setImmediate);
+const MQTT = require('./stub/mqtt');
+const Controller = require('../lib/controller');
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe('HomeAssistant extension', () => {
+    beforeEach(async () => {
+        this.version = await require('../lib/util/utils').getZigbee2mqttVersion();
+        this.version = `Zigbee2mqtt ${this.version.version}`;
+        jest.useRealTimers();
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        MQTT.publish.mockClear();
+        settings.set(['homeassistant'], true);
+    });
+
+    it('Should have mapping for all devices supported by zigbee-herdsman-converters', () => {
+        const missing = [];
+        const HomeAssistant = require('../lib/extension/homeassistant');
+        const ha = new HomeAssistant(null, null, null, null);
+
+        require('zigbee-herdsman-converters').devices.forEach((d) => {
+            if (!ha._getMapping()[d.model]) {
+                missing.push(d.model);
+            }
+        });
+
+        expect(missing).toHaveLength(0);
+    });
+
+    it('Should discover devices', async () => {
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': '{{ value_json.temperature }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': '%',
+            'device_class': 'humidity',
+            'value_template': '{{ value_json.humidity }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_humidity',
+            'unique_id': '0x0017880104e45522_humidity_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/humidity/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': 'hPa',
+            'device_class': 'pressure',
+            'value_template': '{{ value_json.pressure }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_pressure',
+            'unique_id': '0x0017880104e45522_pressure_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/pressure/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': '%',
+            'device_class': 'battery',
+            'value_template': '{{ value_json.battery }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_battery',
+            'unique_id': '0x0017880104e45522_battery_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/battery/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': '-',
+            'value_template': '{{ value_json.linkquality }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_linkquality',
+            'unique_id': '0x0017880104e45522_linkquality_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/linkquality/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should discover devices with precision', async () => {
+        settings.set(['devices', '0x0017880104e45522'], {
+            humidity_precision: 0,
+            temperature_precision: 1,
+            pressure_precision: 2,
+            friendly_name: 'weather_sensor',
+            retain: false,
+        })
+
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': "{{ (value_json.temperature | float) | round(1) }}",
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': '%',
+            'device_class': 'humidity',
+            'value_template': '{{ (value_json.humidity | float) | round(0) }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_humidity',
+            'unique_id': '0x0017880104e45522_humidity_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/humidity/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': 'hPa',
+            'device_class': 'pressure',
+            'value_template': '{{ (value_json.pressure | float) | round(2) }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_pressure',
+            'unique_id': '0x0017880104e45522_pressure_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/pressure/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should discover devices with overriden user configuration', async () => {
+        settings.set(['devices', '0x0017880104e45522'], {
+            homeassistant: {
+                expire_after: 30,
+                icon: 'mdi:test',
+                temperature: {
+                    expire_after: 90,
+                    device: {
+                        manufacturer: 'From Xiaomi',
+                        sw_version: 'test'
+                    }
+                },
+                humidity: {
+                    unique_id: null,
+                },
+                device: {
+                    manufacturer: 'Not from Xiaomi',
+                    model: 'custom model',
+                }
+            },
+            friendly_name: 'weather_sensor',
+            retain: false,
+        })
+
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': '{{ value_json.temperature }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': 'test',
+                'model': 'custom model',
+                'manufacturer': 'From Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+            'expire_after': 90,
+            'icon': 'mdi:test',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+
+        payload = {
+            'unit_of_measurement': '%',
+            'device_class': 'humidity',
+            'value_template': '{{ value_json.humidity }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_humidity',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'custom model',
+                'manufacturer': 'Not from Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+            'expire_after': 30,
+            'icon': 'mdi:test',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/humidity/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Shouldnt discover devices when homeassistant null is set in device options', async () => {
+        settings.set(['devices', '0x0017880104e45522'], {
+            homeassistant: null,
+            friendly_name: 'weather_sensor',
+            retain: false,
+        })
+
+        controller = new Controller(false);
+        await controller.start();
+
+        await flushPromises();
+
+        const topics = MQTT.publish.mock.calls.map((c) => c[0]);
+        expect(topics).not.toContain('homeassistant/sensor/0x0017880104e45522/humidity/config')
+        expect(topics).not.toContain('homeassistant/sensor/0x0017880104e45522/temperature/config')
+    });
+
+    it('Should discover devices with fan', async () => {
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            "state_topic":"zigbee2mqtt/fan",
+            "state_value_template":"{{ value_json.fan_state }}",
+            "command_topic":"zigbee2mqtt/fan/set/fan_state",
+            "speed_state_topic":"zigbee2mqtt/fan",
+            "speed_command_topic":"zigbee2mqtt/fan/set/fan_mode",
+            "speed_value_template":"{{ value_json.fan_mode }}",
+            "speeds":[
+               "off",
+               "low",
+               "medium",
+               "high",
+               "on",
+               "auto",
+               "smart"
+            ],
+            "json_attributes_topic":"zigbee2mqtt/fan",
+            "name":"fan_fan",
+            "unique_id":"0x0017880104e45548_fan_zigbee2mqtt",
+            "device":{
+               "identifiers":[
+                  "zigbee2mqtt_0x0017880104e45548"
+               ],
+               "name":"fan",
+               "sw_version":this.version,
+               "model":"Universal wink enabled white ceiling fan premier remote control (99432)",
+               "manufacturer":"Hampton Bay"
+            },
+            "availability_topic":"zigbee2mqtt/bridge/state"
+         };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/fan/0x0017880104e45548/fan/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should discover devices with cover_position', async () => {
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            command_topic: 'zigbee2mqtt/smart_vent/set',
+            position_topic: 'zigbee2mqtt/smart_vent',
+            set_position_topic: 'zigbee2mqtt/smart_vent/set',
+            set_position_template: '{ "position": {{ position }} }',
+            value_template: '{{ value_json.position }}',
+            name: 'smart_vent_cover',
+            unique_id: '0x0017880104e45551_cover_zigbee2mqtt',
+            device:
+            {
+                identifiers: [ 'zigbee2mqtt_0x0017880104e45551' ],
+                name: 'smart_vent',
+                sw_version: this.version,
+                model: 'Smart vent (SV01)',
+                manufacturer: 'Keen Home'
+            },
+            availability_topic: 'zigbee2mqtt/bridge/state'
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/cover/0x0017880104e45551/cover/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should discover devices with custom homeassistant_discovery_topic', async () => {
+        settings.set(['advanced', 'homeassistant_discovery_topic'], 'my_custom_discovery_topic')
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': '{{ value_json.temperature }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'my_custom_discovery_topic/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should throw error when starting with attributes output', async () => {
+        settings.set(['experimental', 'output'], 'attribute')
+        expect(() => {
+            controller = new Controller(false);
+        }).toThrowError('Home Assitant integration is not possible with attribute output!');
+    });
+
+    it('Should warn when starting with cache_state false', async () => {
+        settings.set(['advanced', 'cache_state'], false);
+        logger.warn.mockClear();
+        controller = new Controller(false);
+        expect(logger.warn).toHaveBeenCalledWith("In order for HomeAssistant integration to work properly set `cache_state: true");
+    });
+
+    it('Shouldt discover when already discovered', async () => {
+        controller = new Controller(false);
+        await controller.start();
+        await flushPromises();
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        MQTT.publish.mockClear();
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        // 1 publish is the publish from deviceReceive
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should discover when not discovered yet', async () => {
+        controller = new Controller(false);
+        await controller.start();
+        await flushPromises();
+        controller.extensions.find((e) => e.constructor.name === 'HomeAssistant').discovered = {};
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        const data = {measuredValue: -85}
+        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        MQTT.publish.mockClear();
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        const payloadHA = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': '{{ value_json.temperature }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/bridge/state',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payloadHA),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Shouldnt discover when message has no device yet', async () => {
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        controller.extensions.find((e) => e.constructor.name === 'HomeAssistant').discovered = {};
+        const device = zigbeeHerdsman.devices.bulb;
+        const payload = {ieeeAddr: device.ieeeAddr};
+        MQTT.publish.mockClear();
+        await zigbeeHerdsman.events.deviceLeave(payload);
+        await flushPromises();
+        // 1 publish is from device_removed
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should send all status when home assistant comes online', async () => {
+        jest.useFakeTimers();
+        data.writeDefaultState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+        await MQTT.events.message('hass/status', 'online');
+        await flushPromises();
+        jest.runOnlyPendingTimers();
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bulb',
+            '{"state":"ON","brightness":50,"color_temp":370,"linkquality":99}',
+            { retain: true, qos: 0 },
+            expect.any(Function)
+        );
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/remote',
+            '{"brightness":255}',
+            { retain: true, qos: 0 },
+            expect.any(Function)
+        );
+    });
+
+    it('Shouldnt send all status when home assistant comes offline', async () => {
+        jest.useFakeTimers();
+        data.writeDefaultState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+        await MQTT.events.message('hass/status', 'offline');
+        await flushPromises();
+        jest.runOnlyPendingTimers();
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Shouldnt send all status when home assistant comes online with different topic', async () => {
+        jest.useFakeTimers();
+        data.writeDefaultState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+        await MQTT.events.message('hass/status_different', 'offline');
+        await flushPromises();
+        jest.runOnlyPendingTimers();
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should discover devices with availability', async () => {
+        settings.set(['advanced', 'availability_timeout'], 1)
+        controller = new Controller(false);
+        await controller.start();
+
+        let payload;
+        await flushPromises();
+
+        payload = {
+            'unit_of_measurement': '°C',
+            'device_class': 'temperature',
+            'value_template': '{{ value_json.temperature }}',
+            'state_topic': 'zigbee2mqtt/weather_sensor',
+            'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
+            'name': 'weather_sensor_temperature',
+            'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
+            'device': {
+                'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
+                'name': 'weather_sensor',
+                'sw_version': this.version,
+                'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
+                'manufacturer': 'Xiaomi',
+            },
+            'availability_topic': 'zigbee2mqtt/weather_sensor/availability',
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+});
@@ -0,0 +1,41 @@
+const tmp = require('tmp');
+const data = require('./stub/data');
+const dir = tmp.dirSync();
+const settings = require('../lib/util/settings');
+settings.set(['advanced', 'log_directory'], dir.name + '/%TIMESTAMP%');
+const logger = require('../lib/util/logger.js');
+const fs = require('fs');
+const path = require('path');
+
+describe('Logger', () => {
+    it('Create log directory', () => {
+        const dirs = fs.readdirSync(dir.name);
+        expect(dirs.length).toBe(1);
+    });
+
+    it('Should cleanup', () => {
+        for (let i = 0; i < 20; i++) {
+            fs.mkdirSync(path.join(dir.name, `log_${i}`));
+        }
+
+        expect(fs.readdirSync(dir.name).length).toBe(21);
+        logger.cleanup();
+        expect(fs.readdirSync(dir.name).length).toBe(10);
+    })
+
+    it('Should not cleanup when there is no timestamp set', () => {
+        for (let i = 30; i < 40; i++) {
+            fs.mkdirSync(path.join(dir.name, `log_${i}`));
+        }
+
+        settings.set(['advanced', 'log_directory'], dir.name + '/bla');
+        expect(fs.readdirSync(dir.name).length).toBe(20);
+        logger.cleanup();
+        expect(fs.readdirSync(dir.name).length).toBe(20);
+    })
+
+    it('Set and get log level', () => {
+        logger.setLevel('debug');
+        expect(logger.getLevel()).toBe('debug');
+    });
+});
@@ -0,0 +1,171 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+
+const {coordinator, bulb, bulb_color, WXKG02LM, CC2530_ROUTER, unsupported_router} = zigbeeHerdsman.devices;
+
+zigbeeHerdsman.returnDevices.push(coordinator.ieeeAddr);
+zigbeeHerdsman.returnDevices.push(bulb.ieeeAddr);
+zigbeeHerdsman.returnDevices.push(bulb_color.ieeeAddr);
+zigbeeHerdsman.returnDevices.push(WXKG02LM.ieeeAddr);
+zigbeeHerdsman.returnDevices.push(CC2530_ROUTER.ieeeAddr);
+zigbeeHerdsman.returnDevices.push(unsupported_router.ieeeAddr);
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+Date.now = jest.fn()
+Date.now.mockReturnValue(10000);
+const mocksClear = [MQTT.publish, logger.warn, logger.debug];
+
+describe('Networkmap', () => {
+    let controller;
+
+    beforeAll(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        mocksClear.forEach((m) => m.mockClear());
+        await flushPromises();
+    });
+
+    beforeEach(async () => {
+        mocksClear.forEach((m) => m.mockClear());
+        await flushPromises();
+    });
+
+    function mock() {
+        /**
+         * Topology
+         *
+         *             | -> bulb_color -> unsupported_router (offline)
+         * coordinator |      ^     ^
+         *             |      |     | (not valid)
+         *             | -> bulb    |
+         *                    |  -> CC2530_ROUTER -> WXKG02LM
+         *
+         */
+        coordinator.lqi = () => {return {neighbors: [
+            {ieeeAddr: bulb_color.ieeeAddr, networkAddress: bulb_color.networkAddress, relationship: 2, depth: 1, linkquality: 120},
+            {ieeeAddr: bulb.ieeeAddr, networkAddress: bulb.networkAddress, relationship: 2, depth: 1, linkquality: 92}
+        ]}};
+        coordinator.routingTable = () => {return {table: [
+            {destinationAddress: CC2530_ROUTER.networkAddress, status: 'ACTIVE', nextHop: bulb.networkAddress},
+        ]}};
+
+        bulb.lqi = () => {return {neighbors: [
+            {ieeeAddr: bulb_color.ieeeAddr, networkAddress: bulb_color.networkAddress, relationship: 1, depth: 2, linkquality: 110},
+            {ieeeAddr: CC2530_ROUTER.ieeeAddr, networkAddress: CC2530_ROUTER.networkAddress, relationship: 1, depth: 2, linkquality: 100}
+        ]}};
+        bulb.routingTable = () => {return {table: []}};
+
+        bulb_color.lqi = () => {return {neighbors: []}}
+        bulb_color.routingTable = () => {return {table: []}};
+
+        CC2530_ROUTER.lqi = () => {return {neighbors: [
+            {ieeeAddr: WXKG02LM.ieeeAddr, networkAddress: WXKG02LM.networkAddress, relationship: 1, depth: 2, linkquality: 130},
+            {ieeeAddr: bulb_color.ieeeAddr, networkAddress: bulb_color.networkAddress, relationship: 4, depth: 2, linkquality: 130},
+        ]}};
+        CC2530_ROUTER.routingTable = () => {return {table: []}};
+
+        unsupported_router.lqi = () => {throw new Error('failed')};
+        unsupported_router.routingTable = () => {throw new Error('failed')};
+    }
+
+    it('Output raw networkmap', async () => {
+        mock();
+        MQTT.events.message('zigbee2mqtt/bridge/networkmap/routes', 'raw');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        let call = MQTT.publish.mock.calls[0];
+        expect(call[0]).toStrictEqual('zigbee2mqtt/bridge/networkmap/raw');
+
+        const conv = (device) => {return {ieeeAddr: device.ieeeAddr, networkAddress: device.networkAddress}};
+
+        const expected = {
+            "nodes":[
+                {"lastSeen": 1000,"ieeeAddr":coordinator.ieeeAddr,"friendlyName":"Coordinator","type":"Coordinator","networkAddress":0,"modelID":null,"failed":[]},
+                {"lastSeen": 1000,"ieeeAddr":bulb.ieeeAddr,"friendlyName":"bulb","type":"Router","networkAddress":40369,"modelID":"TRADFRI bulb E27 WS opal 980lm","failed":[]},
+                {"lastSeen": 1000,"ieeeAddr":bulb_color.ieeeAddr,"friendlyName":"bulb_color","type":"Router","networkAddress":40399,"modelID":"LLC020","failed":[]},
+                {"lastSeen": 1000,"ieeeAddr":WXKG02LM.ieeeAddr,"friendlyName":"button_double_key","type":"EndDevice","networkAddress":6538,"modelID":"lumi.sensor_86sw2.es1"},
+                {"lastSeen": 1000,"ieeeAddr":unsupported_router.ieeeAddr,"friendlyName":"0x0017880104e45525","type":"Router","networkAddress":6536,"modelID":"notSupportedModelID","manufacturerName": "Boef","failed":['lqi', 'routingTable']},
+                {"lastSeen": 1000,"ieeeAddr":CC2530_ROUTER.ieeeAddr,"friendlyName":"cc2530_router","type":"Router","networkAddress":6540,"modelID":"lumi.router","failed":[]},
+            ],
+            "links":[
+                {depth: 1, linkquality: 120, routes: [], source: conv(bulb_color), target: conv(coordinator), sourceIeeeAddr: bulb_color.ieeeAddr, sourceNwkAddr: bulb_color.networkAddress, targetIeeeAddr: coordinator.ieeeAddr, lqi: 120, relationship: 2},
+                {depth: 1, linkquality: 92, routes: [{destinationAddress: CC2530_ROUTER.networkAddress, status: 'ACTIVE', nextHop: bulb.networkAddress}], source: conv(bulb), target: conv(coordinator), sourceIeeeAddr: bulb.ieeeAddr, sourceNwkAddr: bulb.networkAddress, targetIeeeAddr: coordinator.ieeeAddr, lqi: 92, relationship: 2},
+                {depth: 2, linkquality: 110, routes: [], source: conv(bulb_color), target: conv(bulb), sourceIeeeAddr: bulb_color.ieeeAddr, sourceNwkAddr: bulb_color.networkAddress, targetIeeeAddr: bulb.ieeeAddr, lqi: 110, relationship: 1},
+                {depth: 2, linkquality: 100, routes: [], source: conv(CC2530_ROUTER), target: conv(bulb), sourceIeeeAddr: CC2530_ROUTER.ieeeAddr, sourceNwkAddr: CC2530_ROUTER.networkAddress, targetIeeeAddr: bulb.ieeeAddr, lqi: 100, relationship: 1},
+                {depth: 2, linkquality: 130, routes: [], source: conv(WXKG02LM), target: conv(CC2530_ROUTER), sourceIeeeAddr: WXKG02LM.ieeeAddr, sourceNwkAddr: WXKG02LM.networkAddress, targetIeeeAddr: CC2530_ROUTER.ieeeAddr, lqi: 130, relationship: 1}
+            ]
+        };
+
+        expect(JSON.parse(call[1])).toStrictEqual(expected);
+
+        /**
+         * Check again without routes
+         */
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/networkmap', 'raw');
+        await flushPromises();
+        call = MQTT.publish.mock.calls[0];
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(call[0]).toStrictEqual('zigbee2mqtt/bridge/networkmap/raw');
+
+        // Remove routing information
+        expected.nodes.forEach((n) => {
+            if (n.failed && n.failed.includes('routingTable')) {
+                n.failed.splice(n.failed.indexOf('routingTable'), 1);
+            }
+        });
+
+        expected.links.forEach((l) => l.routes = [])
+        expect(JSON.parse(call[1])).toStrictEqual(expected);
+    });
+
+    it('Output graphviz networkmap', async () => {
+        const getTimezoneOffset = Date.prototype.getTimezoneOffset;
+        const getHours = Date.prototype.getHours;
+        Date.prototype.getTimezoneOffset = () => -60;
+        Date.prototype.getHours = () => 1;
+        mock();
+        const device = zigbeeHerdsman.devices.bulb_color;
+        device.lastSeen = null;
+        const endpoint = device.getEndpoint(1);
+        const data = {modelID: 'test'}
+        const payload = {data, cluster: 'genOnOff', device, endpoint, type: 'readResponse', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        MQTT.events.message('zigbee2mqtt/bridge/networkmap/routes', 'graphviz');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        let call = MQTT.publish.mock.calls[0];
+        expect(call[0]).toStrictEqual('zigbee2mqtt/bridge/networkmap/graphviz');
+
+        const expected = `digraph G {
+            node[shape=record];
+              "0x00124b00120144ae" [style="bold, filled", fillcolor="#e04e5d", fontcolor="#ffffff", label="{Coordinator|0x00124b00120144ae (0)|1970-01-01T01:00:10+01:00}"];
+              "0x000b57fffec6a5b2" [style="rounded, filled", fillcolor="#4ea3e0", fontcolor="#ffffff", label="{bulb|0x000b57fffec6a5b2 (40369)|IKEA TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)|1970-01-01T01:00:01+01:00}"];
+              "0x000b57fffec6a5b2" -> "0x00124b00120144ae" [penwidth=2, weight=1, color="#009900", label="92 (routes: 6540)"]
+              "0x000b57fffec6a5b3" [style="rounded, filled", fillcolor="#4ea3e0", fontcolor="#ffffff", label="{bulb_color|0x000b57fffec6a5b3 (40399)|Philips Hue Go (7146060PH)|unknown}"];
+              "0x000b57fffec6a5b3" -> "0x00124b00120144ae" [penwidth=0.5, weight=0, color="#994444", label="120"]
+              "0x000b57fffec6a5b3" -> "0x000b57fffec6a5b2" [penwidth=0.5, weight=0, color="#994444", label="110"]
+              "0x0017880104e45521" [style="rounded, dashed, filled", fillcolor="#fff8ce", fontcolor="#000000", label="{button_double_key|0x0017880104e45521 (6538)|Xiaomi Aqara double key wireless wall switch (WXKG02LM)|1970-01-01T01:00:01+01:00}"];
+              "0x0017880104e45521" -> "0x0017880104e45559" [penwidth=1, weight=0, color="#994444", label="130"]
+              "0x0017880104e45525" [style="rounded, filled", fillcolor="#4ea3e0", fontcolor="#ffffff", label="{0x0017880104e45525|0x0017880104e45525 (6536)failed: lqi,routingTable|Boef notSupportedModelID|1970-01-01T01:00:01+01:00}"];
+              "0x0017880104e45559" [style="rounded, filled", fillcolor="#4ea3e0", fontcolor="#ffffff", label="{cc2530_router|0x0017880104e45559 (6540)|Custom devices (DiY) [CC2530 router](http://ptvo.info/cc2530-based-zigbee-coordinator-and-router-112/) (CC2530.ROUTER)|1970-01-01T01:00:01+01:00}"];
+              "0x0017880104e45559" -> "0x000b57fffec6a5b2" [penwidth=0.5, weight=0, color="#994444", label="100"]
+            }`;
+
+        const expectedLines = expected.split('\n');
+        const actualLines = call[1].split('\n');
+
+        for (let i = 0; i < expectedLines.length; i++) {
+            expect(actualLines[i].trim()).toStrictEqual(expectedLines[i].trim());
+        }
+        Date.prototype.getTimezoneOffset = getTimezoneOffset;
+        Date.prototype.getHours = getHours;
+    });
+});
@@ -0,0 +1,539 @@
+require('./stub/logger');
+require('./stub/data');
+const data = require('../lib/util/data.js');
+const settings = require('../lib/util/settings.js');
+const fs = require('fs');
+const configurationFile = data.joinPath('configuration.yaml');
+const devicesFile = data.joinPath('devices.yaml');
+const groupsFile = data.joinPath('groups.yaml');
+const secretFile = data.joinPath('secret.yaml');
+const yaml = require('js-yaml');
+
+describe('Settings', () => {
+    const write = (file, json, reread=true) => {
+        fs.writeFileSync(file, yaml.safeDump(json))
+        if (reread) {
+            settings._reRead();
+        }
+    };
+    const read = (file) => yaml.safeLoad(fs.readFileSync(file, 'utf8'));
+    const remove = (file) => {
+        if (fs.existsSync(file)) fs.unlinkSync(file);
+    }
+
+    beforeEach(() => {
+        remove(configurationFile);
+        remove(devicesFile);
+        remove(groupsFile);
+    });
+
+    it('Should return default settings', () => {
+        write(configurationFile, {});
+        const s = settings.get();
+        const expected = settings._getDefaults();
+        expected.devices = {};
+        expected.groups = {};
+        expect(s).toStrictEqual(expected);
+    });
+
+    it('Should return settings', () => {
+        write(configurationFile, {permit_join: true});
+        const s = settings.get();
+        const expected = settings._getDefaults();
+        expected.devices = {};
+        expected.groups = {};
+        expected.permit_join = true;
+        expect(s).toStrictEqual(expected);
+    });
+
+    it('Should add devices', () => {
+        write(configurationFile, {});
+        settings.addDevice('0x12345678');
+
+        const actual = read(configurationFile);
+        const expected = {
+            devices: {
+                '0x12345678': {
+                    friendly_name: '0x12345678',
+                },
+            },
+        };
+
+        expect(actual).toStrictEqual(expected);
+    });
+
+    it('Should read devices', () => {
+        const content = {
+            devices: {
+                '0x12345678': {
+                    friendly_name: '0x12345678',
+                    retain: false,
+                },
+            },
+        };
+
+        write(configurationFile, content);
+
+        const device = settings.getDevice('0x12345678');
+        const expected = {
+            ID: "0x12345678",
+            friendlyName: "0x12345678",
+            friendly_name: '0x12345678',
+            retain: false,
+        };
+
+        expect(device).toStrictEqual(expected);
+    });
+
+    it('Should not throw error when devices is null', () => {
+        const content = {devices: null};
+        write(configurationFile, content);
+        settings.getDevice('0x12345678');
+    });
+
+    it('Should read MQTT username and password form a separate file', () => {
+        const contentConfiguration = {
+            mqtt: {
+                server: 'my.mqtt.server',
+                user: '!secret username',
+                password: '!secret password',
+            },
+            advanced: {
+                network_key: '!secret network_key'
+            }
+        };
+
+        const contentSecret = {
+            username: 'mysecretusername',
+            password: 'mysecretpassword',
+            network_key: [1,2,3],
+        };
+
+        write(secretFile, contentSecret, false);
+        write(configurationFile, contentConfiguration);
+
+        const expected = {
+            include_device_information: false,
+            password: "mysecretpassword",
+            server: "my.mqtt.server",
+            user: "mysecretusername",
+        };
+
+        expect(settings.get().mqtt).toStrictEqual(expected);
+        expect(settings.get().advanced.network_key).toStrictEqual([1,2,3]);
+
+        settings._write();
+        expect(read(configurationFile)).toStrictEqual(contentConfiguration);
+    });
+
+    it('Should read devices form a separate file', () => {
+        const contentConfiguration = {
+            devices: 'devices.yaml',
+        };
+
+        const contentDevices = {
+            '0x12345678': {
+                friendly_name: '0x12345678',
+                retain: false,
+            },
+        };
+
+        write(configurationFile, contentConfiguration);
+        write(devicesFile, contentDevices);
+        const device = settings.getDevice('0x12345678');
+        const expected = {
+            ID: "0x12345678",
+            friendlyName: "0x12345678",
+            friendly_name: '0x12345678',
+            retain: false,
+        };
+
+        expect(device).toStrictEqual(expected);
+    });
+
+    it('Should add devices to a separate file', () => {
+        const contentConfiguration = {
+            devices: 'devices.yaml',
+        };
+
+        const contentDevices = {
+            '0x12345678': {
+                friendly_name: '0x12345678',
+                retain: false,
+            },
+        };
+
+        write(configurationFile, contentConfiguration);
+        write(devicesFile, contentDevices);
+
+        settings.addDevice('0x1234');
+
+        expect(read(configurationFile)).toStrictEqual({devices: 'devices.yaml'});
+
+        const expected = {
+            '0x12345678': {
+                friendly_name: '0x12345678',
+                retain: false,
+            },
+            '0x1234': {
+                friendly_name: '0x1234',
+            },
+        };
+
+        expect(read(devicesFile)).toStrictEqual(expected);
+    });
+
+    it('Should add devices to a separate file if devices.yaml doesnt exist', () => {
+        const contentConfiguration = {
+            devices: 'devices.yaml',
+        };
+
+        write(configurationFile, contentConfiguration);
+
+        settings.addDevice('0x1234');
+
+        expect(read(configurationFile)).toStrictEqual({devices: 'devices.yaml'});
+
+        const expected = {
+            '0x1234': {
+                friendly_name: '0x1234',
+            },
+        };
+
+        expect(read(devicesFile)).toStrictEqual(expected);
+    }
+    );
+
+    it('Should add and remove devices to a separate file if devices.yaml doesnt exist', () => {
+        const contentConfiguration = {
+            devices: 'devices.yaml',
+        };
+
+        write(configurationFile, contentConfiguration);
+
+        settings.addDevice('0x1234');
+        expect(read(configurationFile)).toStrictEqual({devices: 'devices.yaml'});
+
+        settings.removeDevice('0x1234');
+        expect(read(configurationFile)).toStrictEqual({devices: 'devices.yaml'});
+
+        expect(read(devicesFile)).toStrictEqual({});
+    }
+    );
+
+    it('Should read groups', () => {
+        const content = {
+            groups: {
+                '1': {
+                    friendly_name: '123',
+                },
+            },
+        };
+
+        write(configurationFile, content);
+
+        const group = settings.getGroup('1');
+        const expected = {
+            ID: 1,
+            friendlyName: '123',
+            friendly_name: '123',
+            devices: [],
+            optimistic: true,
+        };
+
+        expect(group).toStrictEqual(expected);
+    });
+
+    it('Should read groups from a separate file', () => {
+        const contentConfiguration = {
+            groups: 'groups.yaml',
+        };
+
+        const contentGroups = {
+            '1': {
+                friendly_name: '123',
+            },
+        };
+
+        write(configurationFile, contentConfiguration);
+        write(groupsFile, contentGroups);
+
+        const group = settings.getGroup('1');
+        const expected = {
+            ID: 1,
+            friendlyName: '123',
+            friendly_name: '123',
+            devices: [],
+            optimistic: true,
+        };
+
+        expect(group).toStrictEqual(expected);
+    });
+
+    it('Combine everything! groups and devices from separate file :)', () => {
+        const contentConfiguration = {
+            devices: 'devices.yaml',
+            groups: 'groups.yaml',
+        };
+
+        const contentGroups = {
+            '1': {
+                friendly_name: '123',
+                devices: [],
+            },
+        };
+        write(configurationFile, contentConfiguration);
+        write(groupsFile, contentGroups);
+
+        const expectedConfiguration = {
+            devices: 'devices.yaml',
+            groups: 'groups.yaml',
+        };
+
+        expect(read(configurationFile)).toStrictEqual(expectedConfiguration);
+
+        settings.addDevice('0x1234');
+
+        expect(read(configurationFile)).toStrictEqual(expectedConfiguration);
+
+        const expectedDevice = {
+            '0x1234': {
+                friendly_name: '0x1234',
+            },
+        };
+
+        expect(read(devicesFile)).toStrictEqual(expectedDevice);
+
+        const group = settings.getGroup('1');
+        const expectedGroup = {
+            optimistic: true,
+            ID: 1,
+            friendlyName: '123',
+            friendly_name: '123',
+            devices: [],
+        };
+
+        expect(group).toStrictEqual(expectedGroup);
+
+        expect(read(configurationFile)).toStrictEqual(expectedConfiguration);
+
+        const expectedDevice2 = {
+            ID: '0x1234',
+            friendlyName: '0x1234',
+            friendly_name: '0x1234',
+        };
+
+        expect(settings.getDevice('0x1234')).toStrictEqual(expectedDevice2);
+    });
+
+    it('Should add groups', () => {
+        write(configurationFile, {});
+
+        const added = settings.addGroup('test123');
+        const expected = {
+            '1': {
+                friendly_name: 'test123',
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should add groups with specific ID', () => {
+        write(configurationFile, {});
+
+        const added = settings.addGroup('test123', 123);
+        const expected = {
+            '123': {
+                friendly_name: 'test123',
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should not add duplicate groups', () => {
+        write(configurationFile, {});
+
+        settings.addGroup('test123');
+        expect(() => {
+            settings.addGroup('test123');
+        }).toThrow(new Error("friendly_name 'test123' is already in use"));
+        const expected = {
+            '1': {
+                friendly_name: 'test123',
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should not add duplicate groups with specific ID', () => {
+        write(configurationFile, {});
+
+        settings.addGroup('test123', 123);
+        expect(() => {
+            settings.addGroup('test_id_123', 123);
+        }).toThrow(new Error("group id '123' is already in use"));
+        const expected = {
+            '123': {
+                friendly_name: 'test123',
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should add devices to groups', () => {
+        write(configurationFile, {
+            devices: {
+                '0x123': {
+                    friendly_name: 'bulb',
+                    retain: true,
+                }
+            }
+        });
+
+        settings.addGroup('test123');
+        settings.addDeviceToGroup('test123', ['0x123']);
+        const expected = {
+            '1': {
+                friendly_name: 'test123',
+                devices: ['0x123'],
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should remove devices from groups', () => {
+        write(configurationFile, {
+            devices: {
+                '0x123': {
+                    friendly_name: 'bulb',
+                    retain: true,
+                }
+            },
+            groups: {
+                '1': {
+                    friendly_name: 'test123',
+                    devices: ['0x123'],
+                }
+            }
+        });
+
+        settings.removeDeviceFromGroup('test123', ['0x123']);
+        const expected = {
+            '1': {
+                friendly_name: 'test123',
+                devices: [],
+            },
+        };
+
+        expect(settings.get().groups).toStrictEqual(expected);
+    });
+
+    it('Should throw when adding device to non-existing group', () => {
+        write(configurationFile, {
+            devices: {
+                '0x123': {
+                    friendly_name: 'bulb',
+                    retain: true,
+                }
+            },
+        });
+
+        expect(() => {
+            settings.removeDeviceFromGroup('test123', 'bulb')
+        }).toThrow(new Error("Group 'test123' does not exist"));
+    });
+
+    it('Should throw when adding device which already exists', () => {
+        write(configurationFile, {
+            devices: {
+                '0x123': {
+                    friendly_name: 'bulb',
+                    retain: true,
+                }
+            },
+        });
+
+        expect(() => {
+            settings.addDevice('0x123')
+        }).toThrow(new Error("Device '0x123' already exists"));
+    });
+
+    it('Should ban devices', () => {
+        write(configurationFile, {});
+        settings.banDevice('0x123');
+        expect(settings.get().ban).toStrictEqual(['0x123']);
+        settings.banDevice('0x1234');
+        expect(settings.get().ban).toStrictEqual(['0x123', '0x1234']);
+    });
+
+    it('Should throw error when yaml file is invalid', () => {
+        fs.writeFileSync(configurationFile, `
+             good: 9
+             \t wrong
+        `)
+
+        let error;
+        try {
+            settings._reRead();
+        } catch (e) {
+            error = e;
+        }
+
+        expect(error.message).toContain(`Your YAML file '${configurationFile}' is invalid`);
+    });
+
+    it('Should throw error when yaml file does not exist', () => {
+        let error;
+        try {
+            settings._reRead();
+        } catch (e) {
+            error = e;
+        }
+
+        expect(error.message).toContain(`no such file or directory, open`);
+    });
+
+    it('Configuration shouldnt be valid when duplicate friendly_name are used', async () => {
+        write(configurationFile, {
+            devices: {'0x0017880104e45519': {friendly_name: 'myname', retain: false}},
+            groups: {'1': {friendly_name: 'myname', retain: false}},
+        });
+
+        settings._reRead();
+
+        expect(() => {
+            settings.validate();
+        }).toThrowError(`Duplicate friendly_name 'myname' found`);
+    });
+
+    it('Configuration shouldnt be valid when duplicate friendly_name are used', async () => {
+        write(configurationFile, {
+            devices: {
+                '0x0017880104e45519': {friendly_name: 'myname', retain: false},
+                '0x0017880104e45511': {friendly_name: 'myname1', retain: false}
+            },
+        });
+
+        settings._reRead();
+
+        expect(() => {
+            settings.changeFriendlyName('myname1', 'myname');
+        }).toThrowError(`friendly_name 'myname' is already in use`);
+    });
+
+    it('Shouldnt write to configuration.yaml when there are no changes in it', () => {
+        const contentConfiguration = {devices: 'devices.yaml'};
+        const contentDevices = {};
+        write(configurationFile, contentConfiguration);
+        const before = fs.statSync(configurationFile).mtimeMs;
+        write(devicesFile, contentDevices);
+        settings.addDevice('0x1234');
+        const after = fs.statSync(configurationFile).mtimeMs;
+        expect(before).toBe(after);
+    });
+});
@@ -0,0 +1,197 @@
+const tmp = require('tmp');
+const yaml = require('../../lib/util/yaml');
+const path = require('path');
+const fs = require('fs');
+
+const mockDir = tmp.dirSync().name;
+const mockDirStorage = tmp.dirSync().name;
+
+function writeDefaultConfiguration() {
+    const config = {
+        homeassistant: false,
+        permit_join: true,
+        mqtt: {
+            base_topic: "zigbee2mqtt",
+            server: "mqtt://localhost",
+        },
+        serial: {
+            "port": "/dev/dummy",
+        },
+        devices: {
+            "0x000b57fffec6a5b2": {
+                retain: true,
+                friendly_name: "bulb"
+            },
+            "0x0017880104e45517": {
+                retain: true,
+                friendly_name: "remote"
+            },
+            "0x0017880104e45520": {
+                retain: false,
+                friendly_name: "button"
+            },
+            "0x0017880104e45521": {
+                retain: false,
+                friendly_name: "button_double_key"
+            },
+            "0x0017880104e45522": {
+                qos: 1,
+                retain: false,
+                friendly_name: "weather_sensor"
+            },
+            "0x0017880104e45523": {
+                retain: false,
+                friendly_name: "occupancy_sensor"
+            },
+            "0x0017880104e45524": {
+                retain: false,
+                friendly_name: "power_plug"
+            },
+            "0x0017880104e45530": {
+                retain: false,
+                friendly_name: "button_double_key_interviewing"
+            },
+            "0x0017880104e45540": {
+                friendly_name: "ikea_onoff"
+            },
+            '0x000b57fffec6a5b7': {
+                retain: false,
+                friendly_name: "bulb_2"
+            },
+            "0x000b57fffec6a5b3": {
+                retain: false,
+                friendly_name: "bulb_color"
+            },
+            '0x000b57fffec6a5b4': {
+                retain: false,
+                friendly_name: "bulb_color_2"
+            },
+            "0x0017880104e45541": {
+                retain: false,
+                friendly_name: "wall_switch"
+            },
+            "0x0017880104e45542": {
+                retain: false,
+                friendly_name: "wall_switch_double"
+            },
+            "0x0017880104e45543": {
+                retain: false,
+                friendly_name: "led_controller_1"
+            },
+            "0x0017880104e45544": {
+                retain: false,
+                friendly_name: "led_controller_2"
+            },
+            '0x0017880104e45545': {
+                retain: false,
+                friendly_name: "dimmer_wall_switch"
+            },
+            '0x0017880104e45547': {
+                retain: false,
+                friendly_name: "curtain"
+            },
+            '0x0017880104e45548': {
+                retain: false,
+                friendly_name: 'fan'
+            },
+            '0x0017880104e45549': {
+                retain: false,
+                friendly_name: 'siren'
+            },
+            '0x0017880104e45529': {
+                retain: false,
+                friendly_name: 'unsupported2'
+            },
+            '0x0017880104e45550': {
+                retain: false,
+                friendly_name: 'thermostat'
+            },
+            '0x0017880104e45551': {
+                retain: false,
+                friendly_name: 'smart_vent'
+            },
+            '0x0017880104e45552': {
+                retain: false,
+                friendly_name: 'j1'
+            },
+            '0x0017880104e45553': {
+                retain: false,
+                friendly_name: 'bulb_enddevice'
+            },
+            '0x0017880104e45559': {
+                retain: false,
+                friendly_name: 'cc2530_router'
+            },
+            '0x0017880104e45560': {
+                retain: false,
+                friendly_name: 'livolo'
+            },
+            '0x90fd9ffffe4b64ae': {
+                retain: false,
+                friendly_name: 'tradfri_remote',
+            }
+        },
+        groups: {
+            '1': {
+                friendly_name: 'group_1',
+                retain: false,
+            },
+            '2': {
+                friendly_name: 'group_2',
+                retain: false,
+            },
+            '15071': {
+                friendly_name: 'group_tradfri_remote',
+                retain: false,
+                devices: ['bulb_color_2', 'bulb_2']
+            },
+            '11': {
+                friendly_name: 'group_with_tradfri',
+                retain: false,
+                devices: ['bulb_2']
+            },
+        }
+    };
+
+    yaml.writeIfChanged(path.join(mockDir, 'configuration.yaml'), config);
+}
+
+function writeEmptyState() {
+    fs.writeFileSync(path.join(mockDir, 'state.json'), JSON.stringify({}));
+}
+
+function writeDefaultState() {
+    const state = {
+        "0x000b57fffec6a5b2": {
+            "state": "ON",
+            "brightness": 50,
+            "color_temp": 370,
+            "linkquality": 99,
+        },
+        "0x0017880104e45517": {
+            "brightness": 255
+        },
+    }
+
+    fs.writeFileSync(path.join(mockDir, 'state.json'), JSON.stringify(state));
+}
+
+function removeState() {
+    fs.unlinkSync(path.join(mockDir, 'state.json'))
+}
+
+jest.mock('../../lib/util/data', () => ({
+    joinPath: (file) => require('path').join(mockDir, file),
+    getPath: () => mockDir,
+}));
+
+writeDefaultConfiguration();
+writeDefaultState();
+
+module.exports = {
+    mockDir,
+    writeDefaultConfiguration,
+    writeDefaultState,
+    removeState,
+    writeEmptyState,
+};
@@ -0,0 +1,16 @@
+let level = 'info';
+
+const mock = {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+    trace: jest.fn(),
+    cleanup: jest.fn(),
+    setLevel: (newLevel) => {level = newLevel},
+    getLevel: () => level,
+};
+
+jest.mock('../../lib/util/logger', () => (mock));
+
+module.exports = {...mock};
@@ -0,0 +1,24 @@
+const events = {};
+
+const mock = {
+    publish: jest.fn().mockImplementation((topic, payload, options, cb) => cb()),
+    end: jest.fn(),
+    subscribe: jest.fn(),
+    on: (type, handler) => {
+        if (type === 'connect') {
+            handler();
+        }
+
+        events[type] = handler
+    },
+};
+
+const mockConnect = jest.fn().mockReturnValue(mock);
+
+jest.mock('mqtt', () => {
+  return {connect: mockConnect};
+});
+
+module.exports = {
+    events, ...mock, connect: mockConnect,
+};
@@ -0,0 +1,183 @@
+const events = {};
+const assert = require('assert');
+
+class Group {
+    constructor(groupID, members) {
+        this.groupID = groupID;
+        this.command = jest.fn();
+        this.meta = {};
+        this.members = members;
+        this.hasMember = (endpoint) => this.members.includes(endpoint);
+    }
+}
+
+const clusters = {
+    'genScenes': 5,
+    'genOnOff': 6,
+    'genLevelCtrl': 8,
+    'lightingColorCtrl': 768,
+    'closuresWindowCovering': 258,
+}
+
+class Endpoint {
+    constructor(ID, inputClusters, outputClusters, deviceIeeeAddress, binds=[]) {
+        this.deviceIeeeAddress = deviceIeeeAddress;
+        this.ID = ID;
+        this.inputClusters = inputClusters;
+        this.outputClusters = outputClusters;
+        this.command = jest.fn();
+        this.read = jest.fn();
+        this.write = jest.fn();
+        this.bind = jest.fn();
+        this.unbind = jest.fn();
+        this.configureReporting = jest.fn();
+        this.binds = binds;
+        this.supportsInputCluster = (cluster) => {
+            assert(clusters[cluster], `Undefined '${cluster}'`);
+            return this.inputClusters.includes(clusters[cluster]);
+        }
+
+        this.supportsOutputCluster = (cluster) => {
+            assert(clusters[cluster], `Undefined '${cluster}'`);
+            return this.outputClusters.includes(clusters[cluster]);
+        }
+
+        this.addToGroup = (group) => {
+            if (!group.members.includes(this)) group.members.push(this);
+        }
+
+        this.getDevice = () => {
+            return Object.values(devices).find(d => d.ieeeAddr === deviceIeeeAddress);
+        }
+
+        this.removeFromGroup = (group) => {
+            const index = group.members.indexOf(this);
+            if (index != -1) {
+                group.members.splice(index, 1);
+            }
+        }
+
+        this.removeFromAllGroups = () => {
+            Object.values(groups).forEach((g) => this.removeFromGroup(g))
+        }
+    }
+}
+
+class Device {
+    constructor(type, ieeeAddr, networkAddress, manufacturerID, endpoints, interviewCompleted, powerSource = null, modelID = null, interviewing=false, manufacturerName) {
+        this.type = type;
+        this.ieeeAddr = ieeeAddr;
+        this.networkAddress = networkAddress;
+        this.manufacturerID = manufacturerID;
+        this.endpoints = endpoints;
+        this.powerSource = powerSource;
+        this.interviewCompleted = interviewCompleted;
+        this.modelID = modelID;
+        this.interviewing = interviewing;
+        this.meta = {};
+        this.ping = jest.fn();
+        this.removeFromNetwork = jest.fn();
+        this.removeFromDatabase = jest.fn();
+        this.save = jest.fn();
+        this.manufacturerName = manufacturerName;
+        this.lastSeen = 1000;
+    }
+
+    getEndpoint(ID) {
+        return this.endpoints.find((e) => e.ID === ID);
+    }
+}
+
+const returnDevices = [];
+
+const bulb_color = new Device('Router', '0x000b57fffec6a5b3', 40399, 4107, [new Endpoint(1, [0,3,4,5,6,8,768,2821,4096], [5,25,32,4096], '0x000b57fffec6a5b3')], true, "Mains (single phase)", "LLC020");
+const bulb_color_2 = new Device('Router', '0x000b57fffec6a5b4', 401292, 4107, [new Endpoint(1, [0,3,4,5,6,8,768,2821,4096], [5,25,32,4096], '0x000b57fffec6a5b4')], true, "Mains (single phase)", "LLC020");
+const bulb_2 =  new Device('Router', '0x000b57fffec6a5b7', 40369, 4476, [new Endpoint(1, [0,3,4,5,6,8,768,2821,4096], [5,25,32,4096], '0x000b57fffec6a5b7')], true, "Mains (single phase)", "TRADFRI bulb E27 WS opal 980lm");
+
+const devices = {
+    'coordinator': new Device('Coordinator', '0x00124b00120144ae', 0, 0, [new Endpoint(1, [], [])], false),
+    'bulb': new Device('Router', '0x000b57fffec6a5b2', 40369, 4476, [new Endpoint(1, [0,3,4,5,6,8,768,2821,4096], [5,25,32,4096], '0x000b57fffec6a5b2')], true, "Mains (single phase)", "TRADFRI bulb E27 WS opal 980lm"),
+    'bulb_color': bulb_color,
+    'bulb_2': bulb_2,
+    'bulb_color_2': bulb_color_2,
+    'remote': new Device('EndDevice', '0x0017880104e45517', 6535, 4107, [new Endpoint(1, [0], [0,3,4,6,8,5], '0x0017880104e45517', [{target: bulb_color.endpoints[0]}]), new Endpoint(2, [0,1,3,15,64512], [25, 6])], true, "Battery", "RWL021"),
+    'unsupported': new Device('EndDevice', '0x0017880104e45518', 6536, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Battery", "notSupportedModelID"),
+    'unsupported2': new Device('EndDevice', '0x0017880104e45529', 6536, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Battery", "notSupportedModelID"),
+    'interviewing': new Device('EndDevice', '0x0017880104e45530', 6536, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Battery", undefined, true),
+    'notInSettings': new Device('EndDevice', '0x0017880104e45519', 6537, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Battery", "lumi.sensor_switch.aq2"),
+    'WXKG11LM': new Device('EndDevice', '0x0017880104e45520', 6537,4151, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Battery", "lumi.sensor_switch.aq2"),
+    'WXKG02LM': new Device('EndDevice', '0x0017880104e45521', 6538,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0], [])], true, "Battery", "lumi.sensor_86sw2.es1"),
+    'WSDCGQ11LM': new Device('EndDevice', '0x0017880104e45522', 6539,4151, [new Endpoint(1, [0], [])], true, "Battery", "lumi.weather"),
+    'RTCGQ11LM': new Device('EndDevice', '0x0017880104e45523', 6540,4151, [new Endpoint(1, [0], [])], true, "Battery", "lumi.sensor_motion.aq2"),
+    'ZNCZ02LM': new Device('Router', '0x0017880104e45524', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", "lumi.plug"),
+    'E1743': new Device('Router', '0x0017880104e45540', 6540,4476, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'TRADFRI on/off switch'),
+    'QBKG04LM': new Device('Router', '0x0017880104e45541', 6549,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0, 6], [])], true, "Mains (single phase)", 'lumi.ctrl_neutral1'),
+    'QBKG03LM':new Device('Router', '0x0017880104e45542', 6540,4151, [new Endpoint(1, [0], [], '0x0017880104e45542'), new Endpoint(2, [0, 6], [], '0x0017880104e45542'), new Endpoint(3, [0, 6], [], '0x0017880104e45542')], true, "Mains (single phase)", 'lumi.ctrl_neutral2'),
+    'GLEDOPTO1112': new Device('Router', '0x0017880104e45543', 6540,4151, [new Endpoint(11, [0], []), new Endpoint(13, [0], [])], true, "Mains (single phase)", 'GL-C-008'),
+    'GLEDOPTO111213': new Device('Router', '0x0017880104e45544', 6540,4151, [new Endpoint(11, [0], []), new Endpoint(13, [0], []), new Endpoint(12, [0], [])], true, "Mains (single phase)", 'GL-C-008'),
+    'HGZB04D': new Device('Router', '0x0017880104e45545', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'FB56+ZSC05HG1.0'),
+    'ZNCLDJ11LM': new Device('Router', '0x0017880104e45547', 6540,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0], [])], true, "Mains (single phase)", 'lumi.curtain'),
+    'HAMPTON99432':  new Device('Router', '0x0017880104e45548', 6540,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0], [])], true, "Mains (single phase)", 'HDC52EastwindFan'),
+    'HS2WD': new Device('Router', '0x0017880104e45549', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'WarningDevice'),
+    '1TST_EU': new Device('Router', '0x0017880104e45550', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'Thermostat'),
+    'SV01': new Device('Router', '0x0017880104e45551', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'SV01-410-MP-1.0'),
+    'J1': new Device('Router', '0x0017880104e45552', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'J1 (5502)'),
+    'E11_G13': new Device('EndDevice', '0x0017880104e45553', 6540,4151, [new Endpoint(1, [0, 6], [])], true, "Mains (single phase)", 'E11-G13'),
+    'nomodel': new Device('Router', '0x0017880104e45535', 6536, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Mains (single phase)", undefined, true),
+    'unsupported_router': new Device('Router', '0x0017880104e45525', 6536, 0, [new Endpoint(1, [0], [0,3,4,6,8,5])], true, "Mains (single phase)", "notSupportedModelID", false, "Boef"),
+    'CC2530_ROUTER': new Device('Router', '0x0017880104e45559', 6540,4151, [new Endpoint(1, [0, 6], [])], true, "Mains (single phase)", 'lumi.router'),
+    'LIVOLO': new Device('Router', '0x0017880104e45560', 6541,4152, [new Endpoint(6, [0, 6], [])], true, "Mains (single phase)", 'TI0001          '),
+    'tradfri_remote': new Device('EndDevice', '0x90fd9ffffe4b64ae', 33906, 4476, [new Endpoint(1, [0], [0,3,4,6,8,5], '0x90fd9ffffe4b64ae')], true, "Battery", "TRADFRI remote control"),
+}
+
+const groups = {
+    'group_1': new Group(1, []),
+    'group_tradfri_remote': new Group(15071, [bulb_color_2.endpoints[0], bulb_2.endpoints[0]]),
+    'group/with/slashes': new Group(99, []),
+    'group_with_tradfri': new Group(11, [bulb_2.endpoints[0]])
+}
+
+const mock = {
+    start: jest.fn(),
+    permitJoin: jest.fn(),
+    getCoordinatorVersion: jest.fn().mockReturnValue({type: 'z-Stack', meta: {version: 1, revision: 20190425}}),
+    getNetworkParameters: jest.fn().mockReturnValue({panID: 0x162a, extendedPanID: [0, 11, 22], channel: 15}),
+    on: (type, handler) => {
+        events[type] = handler;
+    },
+    stop: jest.fn(),
+    setLED: jest.fn(),
+    getDevices: jest.fn().mockImplementation(() => {
+        return Object.values(devices).filter((d) => returnDevices.length === 0 || returnDevices.includes(d.ieeeAddr));
+    }),
+    getDevicesByType: jest.fn().mockImplementation((type) => {
+        return Object.values(devices).filter((d) => returnDevices.length === 0 || returnDevices.includes(d.ieeeAddr)).filter((d) => d.type === type);
+    }),
+    getDeviceByIeeeAddr: jest.fn().mockImplementation((ieeeAddr) => {
+        return Object.values(devices).filter((d) => returnDevices.length === 0 || returnDevices.includes(d.ieeeAddr)).find((d) => d.ieeeAddr === ieeeAddr);
+    }),
+    getGroups: jest.fn().mockImplementation((query) => {
+        return Object.values(groups);
+    }),
+    getGroupByID: jest.fn().mockImplementation((groupID) => {
+        return Object.values(groups).find((d) => d.groupID === groupID);
+    }),
+    getPermitJoin: jest.fn().mockReturnValue(false),
+    reset: jest.fn(),
+    createGroup: jest.fn().mockImplementation((groupID) => {
+        const group = new Group(groupID, []);
+        groups[`group_${groupID}`] = group
+        return group;
+    })
+};
+
+const mockConstructor = jest.fn().mockImplementation(() => mock);
+
+jest.mock('zigbee-herdsman', () => ({
+    Controller: mockConstructor,
+    Zcl: {ManufacturerCode: {Philips: 4107}},
+}));
+
+module.exports = {
+    events, ...mock, constructor: mockConstructor, devices, groups, returnDevices
+};
@@ -0,0 +1,58 @@
+const utils = require('../lib/util/utils.js');
+const version = require('../package.json').version;
+
+describe('Utils', () => {
+    describe('Is xiaomi device', () => {
+        it('Identify xiaomi device', () => {
+            const device = {type: 'Router', manufacturerID: 4151, manufacturerName: 'Xiaomi'};
+            expect(true).toBe(utils.isXiaomiDevice(device));
+        });
+
+        it('Identify xiaomi device without manufacturerName', () => {
+            const device = {type: 'Router', manufacturerID: 4447};
+            expect(true).toBe(utils.isXiaomiDevice(device));
+        });
+
+        it('Identify xiaomi device with different manufacturerName', () => {
+            const device = {type: 'Router', manufacturerID: 4151, manufacturerName: 'Trust International B.V.\u0000'};
+            expect(false).toBe(utils.isXiaomiDevice(device));
+        });
+    });
+
+    it('Convert milliseconds to seconds', () => {
+        expect(utils.millisecondsToSeconds(2000)).toBe(2);
+    })
+
+    it('Object has properties', () => {
+        expect(utils.objectHasProperties({a: 1, b: 2, c: 3}, ['a', 'b'])).toBeTruthy();
+        expect(utils.objectHasProperties({a: 1, b: 2, c: 3}, ['a', 'b', 'd'])).toBeFalsy();
+    })
+
+    it('git last commit', async () => {
+        let mockReturnValue = [];
+        jest.mock('git-last-commit', () => ({
+            getLastCommit: (cb) => cb(mockReturnValue[0], mockReturnValue[1])
+        }));
+
+        mockReturnValue = [false, {shortHash: '123'}]
+        expect(await utils.getZigbee2mqttVersion()).toStrictEqual({"commitHash": "123", "version": version});
+
+        mockReturnValue = [true, null]
+        expect(await utils.getZigbee2mqttVersion()).toStrictEqual({"commitHash": "unknown", "version": version});
+    })
+
+    it('To local iso string', async () => {
+        var date = new Date('August 19, 1975 23:15:30 UTC+00:00');
+        var getTimezoneOffset = Date.prototype.getTimezoneOffset;
+        Date.prototype.getTimezoneOffset = () => 60;
+        expect(utils.formatDate(date, 'ISO_8601_local').endsWith('-01:00')).toBeTruthy();
+        Date.prototype.getTimezoneOffset = () => -60;
+        expect(utils.formatDate(date, 'ISO_8601_local').endsWith('+01:00')).toBeTruthy();
+        Date.prototype.getTimezoneOffset = getTimezoneOffset;
+    })
+
+    it('Throw exception when formating with invalid date', async () => {
+        var date = new Date('August 19, 1975 23:15:30 UTC+00:00');
+        expect(() => utils.formatDate(date, 'invalid', 1)).toThrowError("Unsupported type 'invalid'")
+    })
+});
@@ -0,0 +1,24 @@
+#!/bin/bash -e
+
+echo "Stopping zigbee2mqtt..."
+sudo systemctl stop zigbee2mqtt
+
+echo "Creating backup of configuration..."
+cp -R data data-backup
+
+echo "Updating..."
+git checkout HEAD -- npm-shrinkwrap.json
+git pull
+
+echo "Installing dependencies..."
+rm -rf node_modules
+npm install
+
+echo "Restore configuration..."
+cp -R data-backup/* data
+rm -rf data-backup
+
+echo "Starting zigbee2mqtt..."
+sudo systemctl start zigbee2mqtt
+
+echo "Done!"