Bump async from 2.6.3 to 2.6.4

Bumps [async](https://github.com/caolan/async) from 2.6.3 to 2.6.4.
- [Release notes](https://github.com/caolan/async/releases)
- [Changelog](https://github.com/caolan/async/blob/v2.6.4/CHANGELOG.md)
- [Commits](https://github.com/caolan/async/compare/v2.6.3...v2.6.4)

---
updated-dependencies:
- dependency-name: async
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -6,35 +6,35 @@ labels: ''
 assignees: ''
 ---
 
-**!!! Please Read This First !!!**\
+**!!! Please Read This First !!!**
 If you are having difficulty controlling a specific device, please verify that the device works with tuya-cli prior to opening an issue here.  If you are unable to control the device via tuya-cli it will not be possible to control it with tuya-mqtt.  If the device is working with tuya-cli, please post your working commands and the equivalent commands for tuya-mqtt.
 
-**Describe the bug**\
+**Describe the bug**
 A clear and concise description of what the bug is.
 
-**To Reproduce**\
+**To Reproduce**
 Steps to reproduce the behavior:
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
 4. See error
 
-**Expected behavior**\
+**Expected behavior**
 A clear and concise description of what you expected to happen.
 
-**Screenshots**\
+**Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**Desktop (please complete the following information):**\
+**Desktop (please complete the following information):**
  - OS: [e.g. iOS]
  - Browser [e.g. chrome, safari]
  - Version [e.g. 22]
 
-**Smartphone (please complete the following information):**\
+**Smartphone (please complete the following information):**
  - Device: [e.g. iPhone6]
  - OS: [e.g. iOS8.1]
  - Browser [e.g. stock browser, safari]
  - Version [e.g. 22]
 
-**Additional context**\
+**Additional context**
 Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -7,17 +7,5 @@ assignees: ''
 
 ---
 
-**!!! Please Read This First !!!**\
-If this feature request is to support a device that currently doesn't work, please verify that the device works with tuya-cli first.  If the device cannot be used with tuya-cli, then it won't be possible to add support to tuya-mqtt.  If you can query and control your device with tuya-cli, please post the commands and the functions they perform as part of the feature request.
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
+**!!! Please Read This First !!!**
+Feature requiest for this project are not being accepted at this time as this project is in maintainance mode only.

.gitignore

@@ -1,6 +1,8 @@
 old/
 test/
 config.json
+.vscode/
+.bak
 
 # Logs
 logs

CHANGELOG.md

@@ -3,6 +3,22 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [3.0.0]
+The 3.0.0 release is a major refactor of the project with significant changes from previous version.  Only major additions and changes are listed below.
+### Added
+- Added templating engine for mapping device DPS value to friendly topics
+- Added pre-defined template for common devices
+- Command topics for DPS keys
+
+### Changed
+- Configuration for devices is now via devices.conf file (based on output format of 'tuya-cli wizard' command)
+- Default device presents only raw DPS data
+- Commands sent only via MQTT messages to command topics
+- Updates all libraries to latest version
+
+### Removed
+- Topic based configuraiton has been removed
+
 ## [2.1.0]
 ### Added
 - Added ability to update validate communicaton with device and update state topic by issuing { "schema": true } command
@@ -48,4 +64,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 - TuyAPI repository not found
 
-### Removed
+### Removed

README.md

@@ -1,7 +1,14 @@
 # tuya-mqtt
-This project provides a method for locally controlling IOT devices manufactured by Tuya Inc., and sold under many different brands, via MQTT.
 
-Using this script requires obtaining the device ID and local keys for each of your devices after they are configured via the Tuya/Smart Life or other Tuya compatible app (there are many).  With this information it is possible to communicate locally with Tuya devices using Tuya protocol version 3.1 and 3.3 without using the Tuya Cloud service, however, getting the keys requires signing up for a Tuya IOT developer account or using one of several other alternative methods (such as dumping the memory of a Tuya based app running on Andriod).
+# !!!! Important Note !!!!
+This project is currently in maintainance mode.  No further enhancements to this project are planned and will not be planned for the future unless someone out there is interested in becoming the new maintainer.  Please do not open issues to request new features, new device support, etc, as they will likely be closed with no comment.  I will try to support existing functionality, but even this will likely be on a very limited basis.  If you are interested in maintaining this project, please post [here](https://github.com/rospogrigio/localtuya/issues/194).
+
+I have decided to step away from this project as I've made the personal decision to rid myself of any Tuya Wifi based devices (I'm down to only 4 at this point, and they are all easy to replace or at least flash with Tasmota).  This decision was made due to the fact that Tuya continues to make it more and more difficult to control their devices locally.  While I don't blame them for this, these devices were only interesting to me because of this local control and thus I can no longer meet my personal goals with Tuya devices (at least the Wifi ones) so I will no longer be purchasing/using them going forward.
+
+# About
+This project is a bridge that allows locally controlling IOT devices manufactured by Tuya Inc., and sold under many different brands, via simple MQTT topics.  It effectively translate the Tuya protocol to easy to use topics.
+
+Using this script requires obtaining the device ID and local keys for each of your devices after they are configured via the Tuya/Smart Life or other Tuya compatible app (there are many).  With this information it is possible to communicate locally with Tuya devices using Tuya protocol version 3.1 and 3.3 without using the Tuya Cloud service, however, getting the keys requires signing up for a Tuya IOT developer account or using one of several other alternative methods (such as dumping the memory of a Tuya based app running on Android).
 
 To acquire keys for your device please see the instructions at the TuyAPI project (on which this script is based) available at the [TuyAPI GitHub site](https://github.com/codetheweb/tuyapi/blob/master/docs/SETUP.md).
 
@@ -29,7 +36,7 @@ npm install
 ## Configuration
 Tuya-mqtt has two different configuration files.  The first is config.json, a simple file which contains settings for connection to the MQTT broker.  The second is devices.conf, a JSON5 formatted file which defines the Tuya devices that the script should connect to and expose via MQTT.  This file uses the same basic format as the "tuya-cli wizard" outputs when used to acquire the device keys, so it can be used as the basis for your tuya-mqtt device configuration.
 
-### Seting up config.json:
+### Setting up config.json:
 ```
 cp config.json.sample config.json
 ```
@@ -56,7 +63,9 @@ If you use the "tuya-cli wizard" method to acquire your device keys you can leve
 ```
 Note that, because the format is JSON5, which is a superset of JSON, you can use standard, strict JSON syntax, or the more forgiving JSON5 format, or even mix and match in the same file.
 
-While the above syntax is enough to create a working tuya-mqtt install with generic devices, the full power and simplicity of tuya-mqtt 3.0 is only unlocked by configuring device types to get .  Please see the full [DEVICES](docs/DEVICES.md) documenation for details.
+By default tuya-mqtt will attempt to find the device and automatically detect the Tuya protocol version, however, this only works if the system running tuya-mqtt is on the same network/subnet as the devices being controlled.  If this is not the case, or if automatic detection fails for some other reason, it is possible to specify the IP address and protocol manually by adding the "ip:" property to the devices.conf file.  Note that if the IP address is specified manually it is required to also manually specify the protocol version using the "version:" parameter as either "3.1" or "3.3".  The easiest way to determine the protocol version is to try controlling the device with tuya-cli and try each version to see which one works.
+
+While the above syntax may be enough to create a working tuya-mqtt install with raw DPS values accessible via DPS topics, the full functionality of tuya-mqtt 3.0 is only unlocked by configuring device types to get.  Please see the full [DEVICES](docs/DEVICES.md) documentation for details.
 
 ### Starting tuya-mqtt
 ```
@@ -67,13 +76,18 @@ To enable debugging output (required when opening an issue):
 DEBUG=tuya-mqtt:* tuya-mqtt.js
 ```
 
+### Updating devices.conf with new and/or changed devices:
+After adding or changing devices to your Tuya account the devices.conf file can be automatically updated with all new devices and name/key changes by using the merge-devices.js script.  Create a file named new-devices.conf with the new "tuya-cli wizard" output then run ```node merge-devices.js```.  A dated backup of the original devices.conf file will be created automatically before changes are made.  Devices are only added and updated, never removed.  The resulting devices.conf file will be neatly formatted and sorted alphabetically by device name.
+
+To prevent device entries from being updated by the merge script, add property "allowMerge: false" to the device definition in the devices.conf file.
+
 ### Usage Overview
-Tuya devices work by mapping device functions to various values stored in data points (refered to as DPS values) which are referenced via an index number, referred to as the DPS key.  For example, a simple on/off switch may have a single DPS value, stored in DPS kep 1 (DPS1).  This value is likely to have a setting of true/false representing the on/off state of the device.  The device state can be read via DPS1, and, for values that can be changed (some DPS values are read-only), sending true/false to DPS1 will turn the device on/off.  A simple dimmer might have the same DPS1 value, but an additional DPS2 value from 1-255 representing the state of the dimmer.  More complex devices use more DPS keys with various values representing the states and control functions of the device.
+Tuya devices work by mapping device functions to various values stored in data points (referred to as DPS values) which are referenced via an index number, referred to as the DPS key.  For example, a simple on/off switch may have a single DPS value, stored in DPS kep 1 (DPS1).  This value is likely to have a setting of true/false representing the on/off state of the device.  The device state can be read via DPS1, and, for values that can be changed (some DPS values are read-only), sending true/false to DPS1 will turn the device on/off.  A simple dimmer might have the same DPS1 value, but an additional DPS2 value from 1-255 representing the state of the dimmer.  More complex devices use more DPS keys with various values representing the states and control functions of the device.
 
 The tuya-mqtt script provides access to these DPS keys and their values via MQTT, allowing any tool that can use MQTT to monitor and control these devices via a local network connection.  In addition to providing access to the raw DPS data, there is also a template engine that allows those DPS values to be mapped to device specific topics, called "friendly topics", allowing for consistent mapping even between devices that use different DPS keys for the same functions.  These friendly topics also support various transforms and other functions that make it easier for other devices to communicate with Tuya devices without a detailed understanding of the data formats Tuya devices use.
 
 ### MQTT Topic Overview
-The top level topics are created using the device name or ID as the primary identifier.  If the device name is available, it will be converted to lowercase and any spaces replace with underscores('_') characters so, for example, if the device as the name "Kitche Table", the top level topic would be:
+The top level topics are created using the device name or ID as the primary identifier.  If the device name is available, it will be converted to lowercase and any spaces replace with underscores('_') characters so, for example, if the device as the name "Kitchen Table", the top level topic would be:
 ```
 tuya/kitchen_table/
 ```
@@ -83,11 +97,11 @@ tuya/86435357d8b123456789/
 ```
 All additional state/command topics are then built below this level. You can view the connectivity status of the device using the status topic, which reports online/offline based on whether tuya-mqtt has an active connection to the device or not.  The script monitors both the device socket connection for errors and also device heartbeats, to report proper status. 
 ```
-tuya/kitche_table/state --> online/offline
+tuya/kitchen_table/state --> online/offline
 ```
 You can also trigger the device to send an immediate update of all known device DPS topics by sending the message "get-states" to the command topic (this topic exist for all devices):
 ```
-tuya/kitche_table/command <-- get-states
+tuya/kitchen_table/command <-- get-states
 ```
 As noted above, tuya-mqtt supports two distinct topic types for interfacing with and controlling devices. For all devices, the DPS topics are always published and commands are accepted, however, friendly topics are the generally recommended approach but require you to use a pre-defined device template or create a customer template for your device when using the generic device.
 
@@ -96,17 +110,17 @@ If you do create a template for your device, please feel free to share it with t
 If you would like to use the raw DPS topics, please jump to the [DPS topics](#dps-topics) section of this document.
 
 ## Friendly Topics
-Friendly topics are only available when using a pre-defined device template or, for the generic device, when you have defined a custom template for your device.  Friendly topics use the tuyq-mqtt templating engine to map raw Tuya DPS key values to easy to consume topics and transform the data where needed.
+Friendly topics are only available when using a pre-defined device template or, for the generic device, when you have defined a custom template for your device.  Friendly topics use the tuya-mqtt templating engine to map raw Tuya DPS key values to easy to consume topics and transform the data where needed.
 
-Another advantage of friendly topics is that not all devices respond to schema requets (i.e. a request to report all DPS topics the device uses).  Because of this, it's not always possible for tuya-mqtt to know which DPS topics to acquire state information from during initial startup.  With a defined template the required DPS keys for each friendly topic are configured and tuya-mqtt will always query these DPS key values during initial connection to the device and report their state appropriately.
+Another advantage of friendly topics is that not all devices respond to schema requests (i.e. a request to report all DPS topics the device uses).  Because of this, it's not always possible for tuya-mqtt to know which DPS topics to acquire state information from during initial startup.  With a defined template the required DPS keys for each friendly topic are configured and tuya-mqtt will always query these DPS key values during initial connection to the device and report their state appropriately.
 
 For more details on using friendly topics, please read the [DEVICES](docs/DEVICES.md) documentation which discusses how to configure supported devices or define a custom template.
 
 ## DPS Topics
-Controlling devices directly via DPS topics requires enough knowledge of the device to know which topics accept what values.  Described below are two differnt methods for interfacing with DPS values, the JSON DPS topic, and the individual DPS key topics.
+Controlling devices directly via DPS topics requires enough knowledge of the device to know which topics accept what values.  Described below are two different methods for interfacing with DPS values, the JSON DPS topic, and the individual DPS key topics.
 
 ### DPS JSON topic
-The JSON DPS topic allows controlling Tuya devices by sending Tuya native style JSON messages to the command topic, and by monitoring for Tuya style JSON replies on the state topic.  You can get more details on this format by reading the [TuyAPI documentaiton](https://codetheweb.github.io/tuyapi/index.html), but, for example, to turn off a dimmer switch you could issue a MQTT message containing the JSON value ```{dps: 1, set: false}``` to the DPS/command topic for the device.  If you wanted to turn the dimmer on, and set brightness to 50%, you could issue separate messages ```{dps: 1, set: true}``` and then ```{dps: 2, set: 128}```, or, the Tuya JSON protocol also allows setting multiple values in a single set command using the format ```{'multiple': true, 'data': {'1': true, '2': 128}}```.  JSON state and commands should use the DPS/state and DPS/command topics respectively.  Below is an example of the topics:
+The JSON DPS topic allows controlling Tuya devices by sending Tuya native style JSON messages to the command topic, and by monitoring for Tuya style JSON replies on the state topic.  You can get more details on this format by reading the [TuyAPI documentation](https://codetheweb.github.io/tuyapi/index.html), but, for example, to turn off a dimmer switch you could issue a MQTT message containing the JSON value ```{dps: 1, set: false}``` to the DPS/command topic for the device.  If you wanted to turn the dimmer on, and set brightness to 50%, you could issue separate messages ```{dps: 1, set: true}``` and then ```{dps: 2, set: 128}```, or, the Tuya JSON protocol also allows setting multiple values in a single set command using the format ```{'multiple': true, 'data': {'1': true, '2': 128}}```.  JSON state and commands should use the DPS/state and DPS/command topics respectively.  Below is an example of the topics:
 ```
 tuya/dimmer_device/DPS/state
 tuya/dimmer_device/DPS/command
@@ -119,11 +133,11 @@ tuya/dimmer_device/DPS/2/command  <-- 1-255 for brightness state
 tuya/dimmer_device/DPS/1/state    --> accept true/false for turning device on/off
 tuya/dimmer_device/DPS/2/command  <-- accepts 1-255 for controlling brightness level
 ```
-**!!! Important Note !!!**\
-When sending commands directly to DPS values there are no limitation on what values are sent as tuya-mqtt has no way to know what are valid vs invalid for any given DPS key.  Sending values that are out-of-range or of different types than the DPS key expects can cause unpredicatable behavior of your device, from causing timeouts, to reboots, to hanging the device.  While I've never seen a device fail to recover after a restart, please keep this in mind when sending commands to your device.
+**!!! Important Note !!!**
+When sending commands directly to DPS values there are no limitation on what values are sent as tuya-mqtt has no way to know what are valid vs invalid for any given DPS key.  Sending values that are out-of-range or of different types than the DPS key expects can cause unpredictable behavior of your device, from causing timeouts, to reboots, to hanging the device.  While I've never seen a device fail to recover after a restart, please keep this in mind when sending commands to your device.
 
 ## Issues
-Not all Tuya protocols are supported.  For example, some devices use protocol 3.2 which currently remains unsupported by the TuyAPI project due to lack of enough information to reverse engineer the protcol.  If you are unable to control your devices with tuya-mqtt please verify that you can query and control them with tuya-cli first.  If tuya-cli works, then this script should also work, if it doesn't then this script will not work either.
+Not all Tuya protocols are supported.  For example, some devices use protocol 3.2 which currently remains unsupported by the TuyAPI project due to lack of enough information to reverse engineer the protocol.  If you are unable to control your devices with tuya-mqtt please verify that you can query and control them with tuya-cli first.  If tuya-cli works, then this script should also work, if it doesn't then this script will not work either.
 
 ## Integration with other Home Automation tools
 openHAB examples are [here](docs/openHAB.md).
@@ -134,7 +148,7 @@ openHAB examples are [here](docs/openHAB.md).
 - [Tycale](https://github.com/Tycale)
 - [crashdummymch](https://github.com/crashdummymch)
 - [GadgetAngel](https://github.com/GadgetAngel)
-
+- [dkrahmer](https://github.com/dkrahmer)
 
 ## Related Projects:
 - https://github.com/codetheweb/tuyapi

cleanup.js

@@ -1,29 +0,0 @@
-// Object to capture process exits and call app specific cleanup function
-var debug = require('debug')('Cleanup');
-
-function noOp() {};
-
-exports.Cleanup = function Cleanup(callback) {
-
-    // attach user callback to the process event emitter
-    // if no callback, it will still exit gracefully on Ctrl-C
-    callback = callback || noOp;
-    process.on('cleanup', callback);
-
-    // do app specific cleaning before exiting
-    process.on('exit', function () {
-        process.emit('cleanup');
-    });
-
-    // catch ctrl+c event and exit normally
-    process.on('SIGINT', function () {
-        debug('Ctrl-C...');
-        process.exit(2);
-    });
-
-    //catch uncaught exceptions, trace, then exit normally
-    process.on('uncaughtException', function (e) {
-        debug('Uncaught Exception...', e.stack);
-        process.exit(99);
-    });
-};

config.json.sample

@@ -3,6 +3,5 @@
     "port": 1883,
     "topic": "tuya/",
     "mqtt_user": "",
-    "mqtt_pass": "",
-    "qos": 2
+    "mqtt_pass": ""
 }

devices/rgbtw-light.js

@@ -148,7 +148,7 @@ class RGBTWLight extends TuyaDevice {
         const mode2 = await this.device.get({"dps": 2})
         const mode21 = await this.device.get({"dps": 21})
         if (mode2 && (mode2 === 'white' || mode2 === 'colour' || mode2.toString().includes('scene'))) {
-            debug('Detected probably Tuya color bulb at DPS 1-5, checking more details...')
+            debug('Detected likely Tuya color bulb at DPS 1-5, checking more details...')
             this.guess = {'dpsPower': 1, 'dpsMode': 2, 'dpsWhiteValue': 3, 'whiteValueScale': 255, 'dpsColorTemp': 4, 'colorTempScale': 255, 'dpsColor': 5}
         } else if (mode21 && (mode21 === 'white' || mode21 === 'colour' || mode21.toString().includes('scene'))) {
             debug('Detected likely Tuya color bulb at DPS 20-24, checking more details...')
@@ -159,14 +159,18 @@ class RGBTWLight extends TuyaDevice {
             debug('Attempting to detect if bulb supports color temperature...')
             const colorTemp = await this.device.get({"dps": this.guess.dpsColorTemp})
             if (colorTemp !== '' && colorTemp >= 0 && colorTemp <= this.guess.colorTempScale) {
-                debug('Detected likely color temerature support')
+                debug('Detected likely color temperature support')
             } else {
                 debug('No color temperature support detected')
                 this.guess.dpsColorTemp = 0
             }
             debug('Attempting to detect Tuya color format used by device...')
             const color = await this.device.get({"dps": this.guess.dpsColor})
-            this.guess.colorType = (color && color.length === 12) ? 'hsb' : 'hsbhex'
+            if (this.guess.dpsPower === 1) {
+                this.guess.colorType = (color && color.length === 12) ? 'hsb' : 'hsbhex'
+            } else {
+                this.guess.colorType = (color && color.length === 14) ? 'hsbhex' : 'hsb'
+            }
             debug ('Detected Tuya color format '+this.guess.colorType.toUpperCase())
         }
     }

devices/tuya-device.js

@@ -17,7 +17,7 @@ class TuyaDevice {
             id: this.config.id,
             key: this.config.key
         }
-        if (this.config.name) { this.options.name = this.config.name.toLowerCase().replace(/ /g,'_') }
+        if (this.config.name) { this.options.name = this.config.name.toLowerCase().replace(/\s|\+|#|\//g,'_') }
         if (this.config.ip) { 
             this.options.ip = this.config.ip
             if (this.config.version) {
@@ -44,6 +44,7 @@ class TuyaDevice {
 
         // Missed heartbeat monitor
         this.heartbeatsMissed = 0
+        this.reconnecting = false
 
         // Build the MQTT topic for this device (friendly name or device id)
         if (this.options.name) {
@@ -85,19 +86,19 @@ class TuyaDevice {
         })
 
         // On disconnect perform device specific disconnect
-        this.device.on('disconnected', () => {
+        this.device.on('disconnected', async () => {
             this.connected = false
             this.publishMqtt(this.baseTopic+'status', 'offline')
             debug('Disconnected from device ' + this.toString())
+            await utils.sleep(5)
+            this.reconnect()
         })
 
         // On connect error call reconnect
         this.device.on('error', async (err) => {
             debugError(err)
             await utils.sleep(1)
-            if (!this.device.isConnected()) {
-                this.reconnect()
-            }
+            this.reconnect()
         })
 
         // On heartbeat reset heartbeat timer
@@ -112,9 +113,9 @@ class TuyaDevice {
         this.connected = false
         for (let topic in this.deviceTopics) {
             const key = this.deviceTopics[topic].key
+            if (!this.dps[key]) { this.dps[key] = {} }
             try {
-                const result = await this.device.get({"dps": key})
-                this.dps[key].val = result
+                this.dps[key].val = await this.device.get({"dps": key})
                 this.dps[key].updated = true
             } catch {
                 debugError('Could not get value for device DPS key '+key)
@@ -249,10 +250,10 @@ class TuyaDevice {
         // Perform any required math transforms before returing command value
         switch (deviceTopic.type) {
             case 'int':
-                value = (deviceTopic.stateMath) ? parseInt(Math.round(evaluate(value+deviceTopic.stateMath))) : value = parseInt(value)
+                value = (deviceTopic.stateMath) ? parseInt(Math.round(evaluate(value+deviceTopic.stateMath))) : parseInt(value)
                 break;
             case 'float':
-                value = (deviceTopic.stateMath) ? parseFloat(evaluate(value+deviceTopic.stateMath)) : value = parseFloat(value)
+                value = (deviceTopic.stateMath) ? parseFloat(evaluate(value+deviceTopic.stateMath)) : parseFloat(value)
                 break;
             }
 
@@ -596,10 +597,21 @@ class TuyaDevice {
 
     // Retry connection every 10 seconds if unable to connect
     async reconnect() {
-        debugError('Error connecting to device id '+this.options.id+'...retry in 10 seconds.')
-        await utils.sleep(10)
-        if (this.connected) { return }
-        this.connectDevice()
+        if (!this.reconnecting) {
+            this.reconnecting = true
+            debugError('Error connecting to device id '+this.options.id+'...retry in 10 seconds.')
+            await utils.sleep(10)
+            this.connectDevice()
+            this.reconnecting = false
+        }
+    }
+
+    // Republish device discovery/state data (used for Home Assistant state topic)
+    async republish() {
+        const status = (this.device.isConnected()) ? 'online' : 'offline'
+        this.publishMqtt(this.baseTopic+'status', status)
+        await utils.sleep(1)
+        this.init()
     }
     
     // Simple function to monitor heartbeats to determine if 
@@ -612,7 +624,7 @@ class TuyaDevice {
                     await utils.sleep(1)
                     this.connectDevice()
                 } else if (this.heartbeatsMissed > 0) {
-                    const errMessage = this.heartbeatsMissed > 1 ? " consecutive heartbeats" : " heartbeat"
+                    const errMessage = this.heartbeatsMissed > 1 ? " heartbeats" : " heartbeat"
                     debugError('Device id '+this.options.id+' has missed '+this.heartbeatsMissed+errMessage)                
                 }
                 this.heartbeatsMissed++
@@ -627,4 +639,4 @@ class TuyaDevice {
     }
 }
 
-module.exports = TuyaDevice
+module.exports = TuyaDevice

docs/DEVICES.md

@@ -193,7 +193,7 @@ The following tables define the available template value types and their options
 ### String values
 | option | value |
 | --- | --- |
-| type | 'string' |
+| type | 'str' |
 | key | DPS key of the value |
 
 ### Tuya HSB values (newer style Tuya, 12 character color value)
@@ -210,4 +210,4 @@ The following tables define the available template value types and their options
 | key | DPS key of the value |
 | components | Comma separated list of HSB components that should be included in this topic |
 
-Using these value types you can define templates for a wide range of devices.  Additional types and options are likely to be included in future versions of tuya-mqtt.
+Using these value types you can define templates for a wide range of devices.  Additional types and options are likely to be included in future versions of tuya-mqtt.

merge-devices.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const json5 = require('json5');
+const utils = require('./lib/utils');
+
+// Setup Exit Handlers
+process.on('exit', processExit.bind(0));
+process.on('SIGINT', processExit.bind(0));
+process.on('SIGTERM', processExit.bind(0));
+process.on('uncaughtException', processExit.bind(1));
+
+async function processExit(exitCode) {
+    if (exitCode || exitCode === 0)
+        console.error('Exit code: ' + exitCode)
+    process.exit();
+}
+
+// Main code function
+const main = async() => {
+    const date = new Date();
+    const dateTimeStr = date.getFullYear() + '-' + ("0" + (date.getMonth() + 1)).slice(-2) + '-' + ("0" + date.getDate()).slice(-2) + '_' + ("0" + date.getHours()).slice(-2) + ("0" + date.getMinutes()).slice(-2) + ("0" + date.getSeconds()).slice(-2);
+    const configDevicesFilename = 'devices.conf';
+    const configDevicesBackupFilename = `${configDevicesFilename}_${dateTimeStr}.bak`;
+    const configNewDevicesFilename = `new-${configDevicesFilename}`;
+
+    let configDevices;
+    let configNewDevices;
+
+    try {
+        console.log(`Loading ${configNewDevicesFilename}...`);
+        configNewDevices = fs.readFileSync(`./${configNewDevicesFilename}`, 'utf8');
+        configNewDevices = json5.parse(configNewDevices);
+    }
+    catch (e) {
+        console.error(`Could not parse new devices config file [${configNewDevicesFilename}]!`);
+        console.error(e);
+        process.exit(1);
+    }
+
+    try {
+        console.log(`Loading ${configDevicesFilename}...`);
+        configDevices = fs.readFileSync(`./${configDevicesFilename}`, 'utf8');
+        configDevices = json5.parse(configDevices);
+    }
+    catch (e) {
+        console.error(`Could not parse devices config file [${configDevicesFilename}]!`);
+        console.error(e);
+        process.exit(1);
+    }
+
+    try {
+        console.log(`Backing up devices config file [${configDevicesFilename}] to [${configDevicesBackupFilename}]...`);
+        fs.copyFileSync(`./${configDevicesFilename}`, `./${configDevicesBackupFilename}`);
+    }
+    catch (e) {
+        console.error(`Could not make backup of devices config file [${configDevicesFilename}] to [${configDevicesBackupFilename}].`);
+        console.error(e);
+        process.exit(1);
+    }
+
+    console.log('Indexing devices...');
+
+    // Create a dictionary for faster lookups with many devices
+    const configDevicesDictionary = {};
+    for (let configDevice of configDevices) {
+        configDevicesDictionary[configDevice.id] = configDevice;
+    }
+
+    console.log('Merging devices...');
+
+    // Add new devices and update existing devices
+    for (let configNewDevice of configNewDevices) {
+        let configDevice = configDevicesDictionary[configNewDevice.id];
+        if (configDevice == null) {
+            // Add new device
+            console.log(`Adding device: ${configNewDevice.name} (id: ${configNewDevice.id})...`);
+            configDevices.push(configNewDevice);
+            configDevicesDictionary[configNewDevice.id] = configNewDevice;
+            continue;
+        }
+
+        if (configDevice.allowMerge === false)
+            continue; // No merge updates allowed for this device
+        
+        // Update existing device
+        if (configDevice.name !== configNewDevice.name) {
+            console.log(`Updating device name: '${configDevice.name}' to '${configNewDevice.name}' (device id: ${configDevice.key})...`);
+            configDevice.name = configNewDevice.name;
+        }
+        if (configDevice.key !== configNewDevice.key) {
+            console.log(`Updating device key for: '${configDevice.name}' (device id: ${configDevice.key})...`);
+            configDevice.key = configNewDevice.key;
+        }
+    }
+
+    // Sort the devices by name
+    configDevices.sort((a, b) => a.name < b.name ? -1 : 1);
+    const configDevicesJson = json5.stringify(configDevices, { space: '    ', quote: '"' });
+
+    //console.log(configDevicesJson);
+
+    try {
+        console.log(`Saving devices config file [${configDevicesFilename}]...`);
+        fs.writeFileSync(`./${configDevicesFilename}`, configDevicesJson, { encoding: 'utf8' });
+    }
+    catch (e) {
+        console.error(`Could not write devices config file [${configDevicesFilename}]!`)
+        console.error(e)
+        process.exit(1)
+    }
+
+    console.log('Done!');
+}
+
+// Call the main code
+main();

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuya-mqtt",
-  "version": "3.0.0",
+  "version": "3.0.4",
   "description": "Control Tuya devices locally via MQTT",
   "homepage": "https://github.com/TheAgentK/tuya-mqtt#readme",
   "main": "tuya-mqtt.js",
@@ -13,14 +13,14 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@tuyapi/cli": "^1.13.4",
+    "@tuyapi/cli": "^1.15.0",
     "color-convert": "^2.0.1",
-    "debug": "^4.1.1",
+    "debug": "^4.3.1",
     "json5": "^2.1.3",
-    "mqtt": "^4.2.1",
-    "supports-color": "^7.2.0",
-    "tuyapi": "^6.0.1",
-    "mathjs": "7.5.1"
+    "mqtt": "^4.2.6",
+    "supports-color": "^8.1.0",
+    "tuyapi": "^6.1.4",
+    "mathjs": "8.1.1"
   },
   "repository": {
     "type": "git",

tuya-mqtt.js

@@ -64,8 +64,7 @@ async function republishDevices() {
         debug('Resending device config/state in 30 seconds')
         await utils.sleep(30)
         for (let device of tuyaDevices) {
-            device.publishMqtt(device.baseTopic+'status', 'online')
-            device.init()
+            device.republish()
         }
         await utils.sleep(2)
     }