homebridge-tuya-plus 3.14.0-dev.20 → 3.14.0-dev.22

package/index.js

@@ -123,6 +123,7 @@ class TuyaLan {
         const lanDeviceIds = [];      // ids we still want to find on the LAN
         const connectedDevices = [];  // ids discovered on the LAN
         const fakeDevices = [];
+        const seenUUIDs = new Set();  // accessory UUIDs already configured this run
 
         this.config.devices.forEach(device => {
             try {
@@ -137,6 +138,15 @@ class TuyaLan {
             if (!device.type) return this.log.error('%s (%s) doesn\'t have a type defined.', device.name || 'Unnamed device', device.id);
             if (!CLASS_DEF[device.type.toLowerCase()]) return this.log.error('%s (%s) doesn\'t have a valid type defined.', device.name || 'Unnamed device', device.id);
 
+            // Two config entries that resolve to the same accessory UUID (the same
+            // Tuya id, real or fake) make addAccessory process that UUID twice. The
+            // second pass reads back the accessory wrapper the first pass cached
+            // instead of a PlatformAccessory and crashes the child bridge while
+            // trying to unregister it. Keep the first entry; skip the rest.
+            const uuid = UUID.generate(UUID_SEED + (device.fake ? ':fake:' : ':') + device.id);
+            if (seenUUIDs.has(uuid)) return this.log.warn('%s (%s) is configured more than once; ignoring the duplicate entry.', device.name || 'Unnamed device', device.id);
+            seenUUIDs.add(uuid);
+
             if (device.fake) {
                 fakeDevices.push({name: device.id.slice(8), ...device});
                 return;
@@ -337,9 +347,17 @@ class TuyaLan {
     removeAccessory(homebridgeAccessory) {
         if (!homebridgeAccessory) return;
 
+        // Only real PlatformAccessory instances can be unregistered. cachedAccessories
+        // also holds accessory wrappers (set by addAccessory), and Homebridge throws a
+        // fatal TypeError when handed anything else, taking down the whole child bridge.
+        // Guard against it rather than trust every caller.
+        if (!(homebridgeAccessory instanceof PlatformAccessory)) {
+            return this.log.warn('Skipped unregistering %s: not a PlatformAccessory.', homebridgeAccessory.displayName);
+        }
+
         this.log.warn('Unregistering', homebridgeAccessory.displayName);
 
-        delete this.cachedAccessories[homebridgeAccessory.UUID];
+        this.cachedAccessories.delete(homebridgeAccessory.UUID);
         this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [homebridgeAccessory]);
     }
 

package/lib/SimpleGarageDoorAccessory.js

@@ -98,6 +98,12 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         // and the close that trails a stop in the stop-before-close path.
         this.partialStopTimer = null;
         this.pendingCloseTimer = null;
+        // A partial open that has fired its open but is still waiting for the
+        // controller to report it's moving before arming the auto-stop.
+        this.partialPending = false;
+        // Bumped whenever a partial open starts or is superseded/cancelled, so a
+        // stale auto-stop (and its re-sends) from an earlier flow bails out.
+        this.partialGeneration = 0;
 
         // Seed the initial state from whatever the device has already reported.
         // If it hasn't reported yet, fall back to the persisted target, then to
@@ -227,6 +233,11 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         if (this.characteristicPartialOpen) {
             this.characteristicPartialOpen.updateValue(isOpen);
         }
+
+        // A partial open fires its open and then waits for the controller to
+        // confirm the gate is actually moving before starting the auto-stop
+        // countdown — see _handlePartialOpen.
+        if (this.partialPending && isOpen) this._armPartialStop();
     }
 
     // onGet helper: a cached/optimistic door value is fine to report while the
@@ -310,33 +321,63 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         }
     }
 
-    // Partial open: fire the open action, then after partialOpenMs fire a stop
-    // so the gate ends up parked part-way. Anchored to the button press (the
-    // controller starts moving and reports state within ~1s), which is all the
-    // user asked for.
+    // Partial open: fire the open action, wait partialOpenMs, then fire a stop
+    // so the gate ends up parked part-way.
+    //
+    // The auto-stop is anchored to the controller *reporting the gate is moving*
+    // (the status DP flipping to OPEN), not to the button press: the open
+    // command takes time to reach the gate, and a stop fired before the gate is
+    // actually moving lands as a no-op the controller drops — letting the gate
+    // run all the way open. If the gate already reads open/opening, no fresh
+    // report is coming, so we arm straight away.
     _handlePartialOpen() {
         const {Characteristic} = this.hap;
         const name = this.device.context.name;
         if (!this.device.connected) throw this._commError();
         if (!this.partialOpenMs) return;
-        if (this.partialStopTimer) {
-            // Re-entrant press while a partial is already armed (e.g. a
+        if (this.partialPending || this.partialStopTimer) {
+            // Re-entrant press while a partial is already in progress (e.g. a
             // HomeKit/iOS WRITE retransmit) — ignore so the stop isn't pushed
             // out, which would let the gate run further than intended.
             this.log.debug(`[SimpleGarageDoor] ${name}: partial press ignored — a partial open is already running`);
             return;
         }
 
-        this.log.debug(`[SimpleGarageDoor] ${name}: partial open — opening, will stop in ${this.partialOpenMs}ms`);
+        this.log.debug(`[SimpleGarageDoor] ${name}: partial open — opening, will stop ${this.partialOpenMs}ms after the gate starts moving`);
+        this.partialGeneration++;
+        this.partialPending = true;
         this._applyTarget(Characteristic.TargetDoorState.OPEN);
+
+        const reported = this.device.state ? this.device.state[this.dpState] : undefined;
+        if (this._mapDpState(reported) === true) this._armPartialStop();
+    }
+
+    _armPartialStop() {
+        if (!this.partialPending || this.partialStopTimer) return;
+        this.partialPending = false;
+        const name = this.device.context.name;
+        const generation = this.partialGeneration;
         this.partialStopTimer = setTimeout(() => {
             this.partialStopTimer = null;
             this.log.debug(`[SimpleGarageDoor] ${name}: partial open — firing stop (dp${this.dpStop})`);
-            this.setMultiStateLegacyInBackground({[this.dpStop]: true});
+            this._sendPartialStop(generation, 1);
         }, this.partialOpenMs);
     }
 
+    // The controller occasionally drops a lone write (its command queue can
+    // coalesce back-to-back writes, and brief Wi-Fi blips lose individual
+    // packets), and a dropped stop here is exactly what lets a partial open run
+    // all the way. Re-send it a few times; a stop on an already-parked gate is a
+    // harmless no-op. Bails out if the flow was superseded mid-way.
+    _sendPartialStop(generation, attempt) {
+        if (generation !== this.partialGeneration) return;
+        this.setMultiStateLegacyInBackground({[this.dpStop]: true});
+        if (attempt < 3) setTimeout(() => this._sendPartialStop(generation, attempt + 1), 300);
+    }
+
     _cancelPartialStop() {
+        this.partialPending = false;
+        this.partialGeneration++;
         if (this.partialStopTimer) {
             clearTimeout(this.partialStopTimer);
             this.partialStopTimer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.14.0-dev.20",
+  "version": "3.14.0-dev.22",
   "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/SimpleGarageDoorAccessory.test.js

@@ -52,6 +52,8 @@ function makeSimpleGarage(initialContext = {}) {
     instance.stopBeforeCloseMs = 1500;
     instance.partialStopTimer = null;
     instance.pendingCloseTimer = null;
+    instance.partialPending = false;
+    instance.partialGeneration = 0;
     instance.currentDoorState = CDS.CLOSED;
     instance.characteristicCurrentDoorState = {
         value: CDS.CLOSED,
@@ -409,35 +411,71 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('Fires open, then fires stop after partialOpenMs', () => {
+    test('Stop is anchored to the gate reporting it is moving, not the button press', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        // Gate starts closed, so the open command needs time to reach it and
+        // get the gate moving before a stop can do anything.
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
 
         instance._handlePartialOpen();
 
-        // Open goes out immediately.
+        // Open goes out immediately, but the auto-stop is NOT armed yet.
         expect(device.update).toHaveBeenCalledTimes(1);
         expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
         expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
+        expect(instance.partialStopTimer).toBeNull();
+        expect(instance.partialPending).toBe(true);
+
+        // No amount of waiting fires a stop until the gate reports it's moving —
+        // this is what stops a too-early stop from being a dropped no-op.
+        jest.advanceTimersByTime(10_000);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        // Controller reports it has started opening: now the countdown arms.
+        emitState(device, STATE_OPENING_OR_OPEN);
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
 
-        // Nothing happens until the timer elapses.
         jest.advanceTimersByTime(2000 - 1);
         expect(device.update).toHaveBeenCalledTimes(1);
 
-        // Then a single stop is fired.
+        // The stop fires, and is re-sent a couple of times to survive a dropped
+        // write (the controller occasionally drops a lone command).
         jest.advanceTimersByTime(1);
         expect(device.update).toHaveBeenCalledTimes(2);
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(4, { '103': true });
 
-        // And nothing more after that.
+        // And nothing more after the re-sends.
         jest.advanceTimersByTime(10_000);
-        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenCalledTimes(4);
         expect(instance.partialStopTimer).toBeNull();
     });
 
-    test('Re-entrant press while armed is ignored (idempotent)', () => {
+    test('Arms straight away when the gate already reports open/opening', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
+
+        instance._handlePartialOpen();
+
+        // Open fired and the countdown armed without waiting for a fresh report.
+        expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
+
+        jest.advanceTimersByTime(2000);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+    });
+
+    test('Re-entrant press while in progress is ignored (idempotent)', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN; // arms immediately
 
         instance._handlePartialOpen();
         expect(device.update).toHaveBeenCalledTimes(1);
@@ -454,6 +492,20 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
     });
 
+    test('Re-entrant press while waiting for movement is ignored', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
+
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1); // open
+        expect(instance.partialPending).toBe(true);
+
+        // A second press before the gate reports moving must not fire another open.
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1);
+    });
+
     test('A direct close cancels the partial auto-stop and runs stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;

package/test/index.test.js

@@ -24,6 +24,7 @@ jest.mock('../lib/TuyaDiscovery', () => ({
 }));
 
 const TuyaDevice = require('../lib/TuyaDevice');
+const TuyaAccessory = require('../lib/TuyaAccessory');
 const TuyaCloudApi = require('../lib/TuyaCloudApi');
 const TuyaCloudMessaging = require('../lib/TuyaCloudMessaging');
 const TuyaDiscovery = require('../lib/TuyaDiscovery');
@@ -56,7 +57,7 @@ function makeLog() {
 }
 
 function makeApi() {
-    return {hap: makeHap(), on: jest.fn(), registerPlatformAccessories: jest.fn()};
+    return {hap: makeHap(), on: jest.fn(), registerPlatformAccessories: jest.fn(), unregisterPlatformAccessories: jest.fn()};
 }
 
 function run(config) {
@@ -139,3 +140,50 @@ describe('TuyaLan — discovery routing', () => {
         expect(TuyaDiscovery.start).not.toHaveBeenCalled();
     });
 });
+
+describe('TuyaLan — duplicate device ids', () => {
+    // Two entries sharing an id resolve to one accessory UUID; configuring it twice
+    // used to crash the child bridge (addAccessory read back its own wrapper and
+    // tried to unregister it). The repeat must be dropped with a warning instead.
+    test('a repeated id is configured once and warns', () => {
+        const platform = run({devices: [SW(), SW()]});
+        expect(TuyaDevice).toHaveBeenCalledTimes(1);
+        expect(platform.addAccessory).toHaveBeenCalledTimes(1);
+        expect(platform.log.warn).toHaveBeenCalled();
+    });
+
+    test('distinct ids are all configured', () => {
+        run({devices: [SW(), SLEEPY()]});
+        expect(TuyaDevice).toHaveBeenCalledTimes(2);
+    });
+
+    test('a repeated fake id is configured once', () => {
+        run({devices: [SW({fake: true}), SW({fake: true})]});
+        expect(TuyaAccessory).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('TuyaLan — removeAccessory hardening', () => {
+    function platformWith(PlatformAccessory) {
+        let cls;
+        factory({platformAccessory: PlatformAccessory, hap: makeHap(), registerPlatform: (n, p, c) => { cls = c; }});
+        return new cls(makeLog(), {devices: [SW()]}, makeApi());
+    }
+    const PlatformAccessoryStub = function(name, uuid) { this.displayName = name; this.UUID = uuid; };
+
+    test('a non-PlatformAccessory (e.g. an accessory wrapper) is never unregistered', () => {
+        const platform = platformWith(PlatformAccessoryStub);
+        expect(() => platform.removeAccessory({accessory: {}})).not.toThrow();
+        expect(platform.api.unregisterPlatformAccessories).not.toHaveBeenCalled();
+        expect(platform.log.warn).toHaveBeenCalled();
+    });
+
+    test('a real PlatformAccessory is unregistered and dropped from the cache', () => {
+        const platform = platformWith(PlatformAccessoryStub);
+        const accessory = new PlatformAccessoryStub('Real', 'uuid:x');
+        platform.cachedAccessories.set('uuid:x', accessory);
+        platform.removeAccessory(accessory);
+        expect(platform.api.unregisterPlatformAccessories).toHaveBeenCalledTimes(1);
+        expect(platform.cachedAccessories.has('uuid:x')).toBe(false);
+    });
+});

package/wiki/Supported-Device-Types.md

@@ -500,9 +500,10 @@ external stop, where close is accepted immediately), a close is sent as
     /* Optional. If set, exposes an extra stateful switch that mirrors
        whether the gate is currently open in HomeKit's view. Tapping it
        ON triggers a partial-open: the gate opens and then stops itself
-       this many milliseconds later, leaving the gate partially open.
-       Tapping it OFF triggers a standard full close. Useful for letting
-       someone pass through briefly. Leave unset to skip the switch. */
+       this many milliseconds after it actually starts moving, leaving the
+       gate partially open. Tapping it OFF triggers a standard full close.
+       Useful for letting someone pass through briefly. Leave unset to skip
+       the switch. */
     "partialOpenMs": 2000,
 
     /* Optional. Exposes extra Force Open and Force Close momentary