homebridge-tuya-plus 3.14.0-dev.42 → 3.14.0-dev.44

package/lib/TuyaCloudApi.js

@@ -87,6 +87,10 @@ class TuyaCloudApi {
         this.uid = null;           // linked app-account uid (needed for realtime MQTT)
         this._tokenExpiry = 0;     // ms epoch when the token must be refreshed
         this._tokenPromise = null; // in-flight token request (de-dupes concurrent callers)
+
+        // Reuse TLS connections across requests instead of a fresh handshake each
+        // time — noticeably cuts per-command latency and the startup read burst.
+        this._agent = new https.Agent({keepAlive: true, maxSockets: 8});
     }
 
     isConfigured() {
@@ -365,7 +369,8 @@ class TuyaCloudApi {
                 port: url.port || 443,
                 path: url.pathname + url.search,
                 method,
-                headers
+                headers,
+                agent: this._agent
             }, resp => {
                 let data = '';
                 resp.setEncoding('utf8');

package/lib/TuyaCloudDevice.js

@@ -76,6 +76,7 @@ class TuyaCloudDevice extends EventEmitter {
         this._propertiesTried = new Set();
         this._announcedProperties = false;
         this._catchupTimers = null; // post-write state re-reads (see _scheduleStateCatchup)
+        this._writeChain = null;    // serializes cloud writes to this device (see update)
 
         // Bidirectional data-point maps, learned from the device's thing-shadow on
         // connect. They let this cloud transport (and the LAN+cloud TuyaDevice that
@@ -214,7 +215,22 @@ class TuyaCloudDevice extends EventEmitter {
         // first 'online' is caught. On any (re)connect we re-read the full state
         // to recover anything missed while the stream was down.
         this.messaging.on('online', () => this._refreshState());
-        this.messaging.subscribeDevice(this.context.id, status => this._applyStatus(status));
+        this.messaging.subscribeDevice(this.context.id, status => this._onRealtime(status));
+    }
+
+    // A realtime (MQTT) update arrived for this device, so it reports its changes
+    // over the stream and the post-write catch-up read is redundant — drop any
+    // pending one. A device whose reports never arrive over MQTT (some custom
+    // controllers — the stream carries nothing for them) gets none of these, so its
+    // catch-up stays armed and remains the only way its state reaches HomeKit. This
+    // makes the catch-up self-cancelling: it costs an HTTP read only on devices that
+    // actually need it.
+    _onRealtime(status) {
+        if (this._catchupTimers) {
+            this._catchupTimers.forEach(t => clearTimeout(t));
+            this._catchupTimers = null;
+        }
+        this._applyStatus(status);
     }
 
     async _refreshState() {
@@ -366,7 +382,16 @@ class TuyaCloudDevice extends EventEmitter {
         if (undeliverable.length) this._reportUndeliverableWrite(undeliverable);
         if (!sendable.length) return false;
 
-        return this._dispatch(sendable);
+        // Serialize writes to this device. HomeKit frequently double-sends a
+        // characteristic write, and rapid changes (dragging a thermostat) fire a
+        // burst; running them concurrently both races the per-code endpoint
+        // learning (a duplicate could see a code "tried" but not yet learned and
+        // fail spuriously) and bursts the cloud's QPS limit (uneven latency). One
+        // at a time keeps learning coherent and the request rate smooth. _dispatch
+        // never rejects, so the chain can't break.
+        const run = () => this._dispatch(sendable);
+        this._writeChain = this._writeChain ? this._writeChain.then(run, run) : run();
+        return this._writeChain;
     }
 
     // Send a write, routing each data-point to the cloud endpoint it accepts. Codes
@@ -418,7 +443,7 @@ class TuyaCloudDevice extends EventEmitter {
         }
         if (!this._announcedProperties) {
             this._announcedProperties = true;
-            this.log.info(`${this.context.name}: controlling some of this device's data-points over the Tuya thing-model property endpoint (they aren't in its standard instruction set).`);
+            this.log.debug(`${this.context.name}: controlling some of this device's data-points over the Tuya thing-model property endpoint (they aren't in its standard instruction set).`);
         }
         return this._learn(fresh, 'properties');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.14.0-dev.42",
+  "version": "3.14.0-dev.44",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices in HomeKit. LAN-first, with an optional Tuya Cloud fallback for any device the LAN can't reach.",
   "main": "index.js",
   "scripts": {

package/test/TuyaCloudDevice.test.js

@@ -240,6 +240,29 @@ describe('TuyaCloudDevice', () => {
             expect(api.sendCommands).toHaveBeenCalledWith('dev1', [{code: 'switch_1', value: false}]);
             expect(api.sendProperties).toHaveBeenCalledWith('dev1', [{code: 'wfh_open', value: true}]);
         });
+
+        // HomeKit often double-sends a write; running the two concurrently used to
+        // race the learning (the 2nd saw the code "tried" but not yet learned and
+        // failed). Serializing writes per device fixes it.
+        test('concurrent duplicate writes of an unknown code are serialized, not raced', async () => {
+            const api = makeApi();
+            api.getShadowProperties = jest.fn().mockResolvedValue([{code: 'Power', dp_id: 1, value: false}]);
+            api.sendCommands.mockImplementation((id, cmds) =>
+                cmds.some(c => c.code === 'Power')
+                    ? Promise.reject(new Error('command or value not support (code 2008)'))
+                    : Promise.resolve(true));
+            const dev = makeDevice(api, null, {key: 'abc'});
+            await dev._connect();
+            const warn = jest.spyOn(log, 'warn');
+
+            const [a, b] = await Promise.all([dev.update({'1': true}), dev.update({'1': true})]);
+
+            expect(a).toBe(true);
+            expect(b).toBe(true);
+            expect(warn).not.toHaveBeenCalled();               // the 2nd write didn't spuriously fail
+            expect(api.sendCommands).toHaveBeenCalledTimes(1);  // only the 1st probed commands
+            jest.restoreAllMocks();
+        });
     });
 
     test('realtime code-only deltas are mirrored to numeric ids via the learned map', async () => {
@@ -319,6 +342,19 @@ describe('TuyaCloudDevice', () => {
             dev.stop();
         });
 
+        test('a realtime update cancels the pending catch-up (no redundant read on MQTT-covered devices)', async () => {
+            const api = makeApi();
+            api.getShadowProperties = jest.fn().mockResolvedValue([{code: 'switch_1', dp_id: 1, value: false}]);
+            const dev = makeDevice(api, null, {key: 'abc'});
+            await dev._connect();
+            await dev.update({'1': true});
+            expect(Array.isArray(dev._catchupTimers)).toBe(true);
+
+            dev._onRealtime([{code: 'switch_1', value: true}]); // MQTT delivers → catch-up not needed
+            expect(dev._catchupTimers).toBeNull();
+            dev.stop();
+        });
+
         test('a refresh reads via the shadow, so a thing-model device whose /status is empty still updates', async () => {
             const api = makeApi();
             let rs = 13;