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

package/lib/ValveAccessory.js

@@ -55,7 +55,7 @@ class ValveAccessory extends BaseAccessory {
             service.getCharacteristic(Characteristic.SetDuration)
                 .onGet(() => { if (!this.device.connected) throw this._commError(); return this.setDuration; })
                 .on('change', (data) => {
-                    this.log.info('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
+                    this.log.debug('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
                     this.setDuration = data.newValue;
 
                     if (service.getCharacteristic(Characteristic.InUse).value) {
@@ -65,7 +65,7 @@ class ValveAccessory extends BaseAccessory {
 
                         clearTimeout(this.timer);
                         this.timer = setTimeout(() => {
-                            this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
+                            this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
                             this.setStateInBackground(this.dpPower, 0);
                             service.getCharacteristic(Characteristic.Active).updateValue(0);
                             service.getCharacteristic(Characteristic.InUse).updateValue(0);
@@ -89,16 +89,16 @@ class ValveAccessory extends BaseAccessory {
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(0);
                             service.getCharacteristic(Characteristic.Active).updateValue(0);
                             clearTimeout(this.timer);
-                            this.log.info('Water Valve is OFF!');
+                            this.log.debug('Water Valve is OFF!');
                             break;
                         case 1:
                             this.lastActivationTime = (new Date()).getTime();
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                             service.getCharacteristic(Characteristic.Active).updateValue(1);
-                            this.log.info('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
+                            this.log.debug('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
                             clearTimeout(this.timer);
                             this.timer = setTimeout(() => {
-                                this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
+                                this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
                                 this.setStateInBackground(this.dpPower, 0);
                                 service.getCharacteristic(Characteristic.Active).updateValue(0);
                                 service.getCharacteristic(Characteristic.InUse).updateValue(0);
@@ -113,10 +113,10 @@ class ValveAccessory extends BaseAccessory {
                 service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                 service.getCharacteristic(Characteristic.Active).updateValue(1);
                 service.getCharacteristic(Characteristic.InUse).updateValue(1);
-                this.log.info('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
+                this.log.debug('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
                 clearTimeout(this.timer);
                 this.timer = setTimeout(() => {
-                    this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
+                    this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
                     this.setStateInBackground(this.dpPower, 0);
                     service.getCharacteristic(Characteristic.Active).updateValue(0);
                     this.lastActivationTime = null;

package/lib/WledDimmerAccessory.js

@@ -1,4 +1,4 @@
-const BaseAccessory = require('./BaseAccessory');
+const SimpleDimmerAccessory = require('./SimpleDimmerAccessory');
 const http = require('http');
 const maxWledBrightness = 255;
 
@@ -6,30 +6,14 @@ const maxWledBrightness = 255;
 const wledDebounceMs = 50;
 const wledWarmupMs = 8000;
 
-class WledDimmerAccessory extends BaseAccessory {
-    static getCategory(Categories) {
-        return Categories.LIGHTBULB;
-    }
-
-    constructor(...props) {
-        super(...props);
-    }
-
-    _registerPlatformAccessory() {
-        const {Service} = this.hap;
-
-        this.accessory.addService(Service.Lightbulb, this.device.context.name);
-
-        super._registerPlatformAccessory();
-    }
-
+class WledDimmerAccessory extends SimpleDimmerAccessory {
     _registerCharacteristics(dps) {
-        const {Service, Characteristic} = this.hap;
-        const service = this.accessory.getService(Service.Lightbulb);
-        this._checkServiceName(service, this.device.context.name);
-
-        this.dpPower = this._getCustomDP(this.device.context.dpPower) || '1';
-        this.dpBrightness = this._getCustomDP(this.device.context.dpBrightness) || this._getCustomDP(this.device.context.dp) || '2';
+        // The Lightbulb service, On/Brightness characteristics, default DPs and
+        // the device 'change' listener are all set up by SimpleDimmerAccessory.
+        // WLED only layers optional brightness sync and preset-effect switches
+        // on top, so without syncBrightnessToWled configured this behaves
+        // exactly like a plain SimpleDimmer.
+        super._registerCharacteristics(dps);
 
         // State for debounced / delayed WLED updates
         this._wledPendingBri = null;
@@ -47,32 +31,20 @@ class WledDimmerAccessory extends BaseAccessory {
             null;
         this.syncBrightnessToWled = (syncCfg && ('' + syncCfg).trim()) || null;
 
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: syncBrightnessToWled=%s',
             this.device.context.name,
             this.syncBrightnessToWled || 'disabled'
         );
 
-        const characteristicOn = service.getCharacteristic(Characteristic.On)
-            .updateValue(dps[this.dpPower])
-            .onGet(() => this.getStateAsync(this.dpPower))
-            .onSet(value => this.setStateAsync(this.dpPower, value));
-
-        const characteristicBrightness = service.getCharacteristic(Characteristic.Brightness);
-        // Keep a reference so we can update brightness from background WLED calls
-        this._characteristicBrightness = characteristicBrightness;
-
         if (this.syncBrightnessToWled) {
             // Start with 100% locally while we fetch the actual WLED brightness
-            characteristicBrightness
-                .updateValue(100)
-                .onGet(() => this.getBrightness())
-                .onSet(value => this.setBrightness(value));
+            this._characteristicBrightness.updateValue(100);
 
             // Force Tuya dimmer brightness to 100% on startup
             const maxTuyaBrightness = this.convertBrightnessFromHomeKitToTuya(100);
             if (dps[this.dpBrightness] !== maxTuyaBrightness) {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: setting Tuya brightness DP%s to max (%s)',
                     this.device.context.name,
                     this.dpBrightness,
@@ -80,19 +52,6 @@ class WledDimmerAccessory extends BaseAccessory {
                 );
                 this.setState(this.dpBrightness, maxTuyaBrightness, () => {});
             }
-        } else {
-            const initial = this.convertBrightnessFromTuyaToHomeKit(dps[this.dpBrightness]);
-            this.log.debug(
-                '%s: initial Tuya brightness DP%s=%s -> HomeKit %s%%',
-                this.device.context.name,
-                this.dpBrightness,
-                dps[this.dpBrightness],
-                initial
-            );
-            characteristicBrightness
-                .updateValue(initial)
-                .onGet(() => this.getBrightness())
-                .onSet(value => this.setBrightness(value));
         }
 
         // Optional: create one HomeKit Switch per configured WLED preset effect.
@@ -148,7 +107,7 @@ class WledDimmerAccessory extends BaseAccessory {
                             return callback();
                         }
 
-                        this.log.info(
+                        this.log.debug(
                             '[WLED Sync] %s: setting preset effect "%s" (id=%s, index=%s)',
                             this.device.context.name,
                             effectName,
@@ -212,15 +171,17 @@ class WledDimmerAccessory extends BaseAccessory {
                 .filter(service => service.UUID === HapService.Switch.UUID && service.subtype && service.subtype.startsWith('wledEffect '))
                 .forEach(service => {
                     if (!validEffectServices.includes(service)) {
-                        this.log.info('Removing', service.displayName);
+                        this.log.debug('Removing', service.displayName);
                         this.accessory.removeService(service);
                     }
                 });
         }
+    }
 
+    _registerChangeListener() {
         this.device.on('change', changes => {
             // Log full DPS changes so we can see exactly what Tuya reported
-            this.log.info(
+            this.log.debug(
                 '%s DPS changes: %s %s was:',
                 this.device.context.name,
                 JSON.stringify(changes),
@@ -229,10 +190,10 @@ class WledDimmerAccessory extends BaseAccessory {
             );
 
             if (changes.hasOwnProperty(this.dpPower)) {
-                const oldPower = !!characteristicOn.value;
+                const oldPower = !!this._characteristicOn.value;
                 const newPower = !!changes[this.dpPower];
 
-                this.log.info(
+                this.log.debug(
                     '%s power change detected on DP%s: %s -> %s',
                     this.device.context.name,
                     this.dpPower,
@@ -241,13 +202,13 @@ class WledDimmerAccessory extends BaseAccessory {
                 );
 
                 if (oldPower !== newPower) {
-                    characteristicOn.updateValue(newPower);
+                    this._characteristicOn.updateValue(newPower);
                 }
 
                 // Track warmup window for WLED after power ON
                 if (this.syncBrightnessToWled && newPower) {
                     this._wledReadyAt = Date.now() + wledWarmupMs;
-                    this.log.info(
+                    this.log.debug(
                         '[WLED Sync] %s: power ON -> delaying WLED API calls for %sms',
                         this.device.context.name,
                         wledWarmupMs
@@ -271,7 +232,7 @@ class WledDimmerAccessory extends BaseAccessory {
 
                 // Ignore the "forced back to 100%" update to avoid feedback loops
                 if (tuyaValue === maxTuyaBrightness) {
-                    this.log.info(
+                    this.log.debug(
                         '[WLED Sync] %s: Tuya DP%s reported max brightness (%s), ignoring',
                         this.device.context.name,
                         this.dpBrightness,
@@ -283,7 +244,7 @@ class WledDimmerAccessory extends BaseAccessory {
                 const percent = this.convertBrightnessFromTuyaToHomeKit(tuyaValue);
                 const bri = Math.max(0, Math.min(maxWledBrightness, Math.round((percent / 100) * maxWledBrightness)));
 
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: Tuya DP%s changed to %s -> %s%% -> WLED bri=%s (debounced)',
                     this.device.context.name,
                     this.dpBrightness,
@@ -304,14 +265,14 @@ class WledDimmerAccessory extends BaseAccessory {
                     }
 
                     // Reflect that brightness back into HomeKit
-                    characteristicBrightness.updateValue(percent);
+                    this._characteristicBrightness.updateValue(percent);
 
                     // After a short delay, force Tuya brightness back to 100% so it stops dimming the strip
                     if (this._wledForceMaxTimeout) {
                         clearTimeout(this._wledForceMaxTimeout);
                     }
                     this._wledForceMaxTimeout = setTimeout(() => {
-                        this.log.info(
+                        this.log.debug(
                             '[WLED Sync] %s: forcing Tuya DP%s back to max (%s) after Tuya app change',
                             this.device.context.name,
                             this.dpBrightness,
@@ -320,8 +281,8 @@ class WledDimmerAccessory extends BaseAccessory {
                         this.setState(this.dpBrightness, maxTuyaBrightness, () => {});
                     }, 5000);
                 });
-            } else if (!this.syncBrightnessToWled && changes.hasOwnProperty(this.dpBrightness) && this.convertBrightnessFromHomeKitToTuya(characteristicBrightness.value) !== changes[this.dpBrightness]) {
-                characteristicBrightness.updateValue(this.convertBrightnessFromTuyaToHomeKit(changes[this.dpBrightness]));
+            } else if (!this.syncBrightnessToWled && changes.hasOwnProperty(this.dpBrightness) && this.convertBrightnessFromHomeKitToTuya(this._characteristicBrightness.value) !== changes[this.dpBrightness]) {
+                this._characteristicBrightness.updateValue(this.convertBrightnessFromTuyaToHomeKit(changes[this.dpBrightness]));
             }
         });
     }
@@ -331,7 +292,7 @@ class WledDimmerAccessory extends BaseAccessory {
         if (this.syncBrightnessToWled) {
             // If we already have a cached WLED brightness, return it immediately.
             if (this._lastWledPercent != null) {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: getBrightness() -> using cached %s%%',
                     this.device.context.name,
                     this._lastWledPercent
@@ -340,13 +301,14 @@ class WledDimmerAccessory extends BaseAccessory {
             }
             return 50;
         } else {
-            return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
+            // No WLED sync: behave as a plain SimpleDimmer.
+            return super.getBrightness();
         }
     }
 
     setBrightness(value) {
         if (this.syncBrightnessToWled) {
-            this.log.info(
+            this.log.debug(
                 '[WLED Sync] %s: setBrightness(%s%%)',
                 this.device.context.name,
                 value
@@ -358,7 +320,7 @@ class WledDimmerAccessory extends BaseAccessory {
             // Ensure Tuya stays at 100% so it doesn't interfere with WLED.
             const maxTuyaBrightness = this.convertBrightnessFromHomeKitToTuya(100);
             if (this.device.state[this.dpBrightness] !== maxTuyaBrightness) {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: ensuring Tuya DP%s=%s (max)',
                     this.device.context.name,
                     this.dpBrightness,
@@ -370,7 +332,7 @@ class WledDimmerAccessory extends BaseAccessory {
 
             // Compute desired WLED brightness once.
             const bri = Math.max(0, Math.min(maxWledBrightness, Math.round((value / 100) * maxWledBrightness)));
-            this.log.info(
+            this.log.debug(
                 '[WLED Sync] %s: mapped HomeKit %s%% -> WLED bri=%s (debounced background)',
                 this.device.context.name,
                 value,
@@ -383,7 +345,8 @@ class WledDimmerAccessory extends BaseAccessory {
             // Return to HomeKit immediately; don't wait for network I/O.
             return null;
         } else {
-            return this.setStateAsync(this.dpBrightness, this.convertBrightnessFromHomeKitToTuya(value));
+            // No WLED sync: behave as a plain SimpleDimmer.
+            return super.setBrightness(value);
         }
     }
 
@@ -392,7 +355,7 @@ class WledDimmerAccessory extends BaseAccessory {
         const parts = String(this.syncBrightnessToWled).split(':');
         const host = parts[0];
         const port = parts[1] ? parseInt(parts[1], 10) || 80 : 80;
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: target host=%s port=%s',
             this.device.context.name,
             host,
@@ -426,7 +389,7 @@ class WledDimmerAccessory extends BaseAccessory {
             timeout: 1000
         };
 
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: GET http://%s:%s/json/state',
             this.device.context.name,
             target.host,
@@ -449,7 +412,7 @@ class WledDimmerAccessory extends BaseAccessory {
                         );
                         return done(true);
                     }
-                    this.log.info(
+                    this.log.debug(
                         '[WLED Sync] %s: /json/state -> bri=%s',
                         this.device.context.name,
                         bri
@@ -508,7 +471,7 @@ class WledDimmerAccessory extends BaseAccessory {
             timeout: 1000
         };
 
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: POST http://%s:%s/json/state body=%s',
             this.device.context.name,
             target.host,
@@ -520,7 +483,7 @@ class WledDimmerAccessory extends BaseAccessory {
             // Consume response and ignore body
             res.on('data', () => {});
             res.on('end', () => {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: WLED brightness set, HTTP %s',
                     this.device.context.name,
                     res.statusCode
@@ -583,7 +546,7 @@ class WledDimmerAccessory extends BaseAccessory {
             timeout: 1000
         };
 
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: POST http://%s:%s/json/state body=%s (preset effect)',
             this.device.context.name,
             target.host,
@@ -595,7 +558,7 @@ class WledDimmerAccessory extends BaseAccessory {
             // Consume response and ignore body
             res.on('data', () => {});
             res.on('end', () => {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: WLED effect set to %s, HTTP %s',
                     this.device.context.name,
                     effectId,
@@ -659,7 +622,7 @@ class WledDimmerAccessory extends BaseAccessory {
         const warmupDelay = this._wledReadyAt && now < this._wledReadyAt ? (this._wledReadyAt - now) : 0;
         const delay = warmupDelay + wledDebounceMs;
 
-        this.log.info(
+        this.log.debug(
             '[WLED Sync] %s: scheduling WLED bri=%s in %sms (%s)',
             this.device.context.name,
             brightness,
@@ -672,7 +635,7 @@ class WledDimmerAccessory extends BaseAccessory {
 
             // If the light is now off, skip the call.
             if (!this.device.state[this.dpPower]) {
-                this.log.info(
+                this.log.debug(
                     '[WLED Sync] %s: skipping scheduled WLED bri=%s because power is OFF',
                     this.device.context.name,
                     this._wledPendingBri

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.14.0-dev.18",
-  "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN. Includes new features, fixes, and updated device support.",
+  "version": "3.14.0-dev.20",
+  "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": {
     "test": "jest",

package/test/IrrigationSystemAccessory.test.js

@@ -473,46 +473,19 @@ describe('IrrigationSystemAccessory — charging state', () => {
     });
 });
 
-describe('IrrigationSystemAccessory — cloud mode (data-points keyed by code)', () => {
-    // Mirrors a real Tuya "sfkzq" watering controller reached over the cloud:
-    // valves are switch_1..4 and battery is battery_percentage.
-    const cloudState = () => ({ switch_1: false, switch_2: false, switch_3: false, switch_4: false, battery_percentage: 99 });
-    const cloudCtx = { cloud: true };
-
+describe('IrrigationSystemAccessory — data-points addressed by code', () => {
+    // The accessory is transport-agnostic: a data-point may be a numeric id or a
+    // Tuya "code". The LAN+cloud TuyaDevice keeps state dual-keyed and translates
+    // writes, so irrigation has no cloud-specific logic — it just uses the dp
+    // strings it's given. A device reached over the cloud commonly addresses its
+    // zones as switch_1.. and battery as battery_percentage.
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => { jest.clearAllTimers(); jest.useRealTimers(); });
 
-    test('default valves use Tuya codes switch_1..switch_4 (not numeric ids)', () => {
-        const { accessory } = makeHarness(cloudState(), cloudCtx);
-        ['switch_1', 'switch_2', 'switch_3', 'switch_4'].forEach(code => {
-            expect(valve(accessory, code)).toBeTruthy();
-        });
-        expect(valve(accessory, '1')).toBeFalsy();
-    });
-
-    test('turning a zone on writes the code/value to the device', () => {
-        const { accessory, device } = makeHarness(cloudState(), cloudCtx);
-        valve(accessory, 'switch_1').getCharacteristic(Characteristic.Active).triggerSet(1);
-        jest.advanceTimersByTime(500);
-        expect(device.update).toHaveBeenCalledWith({ switch_1: true });
-    });
-
-    test('battery is read from the battery_percentage code', () => {
-        const { accessory } = makeHarness(cloudState(), cloudCtx);
-        const battery = accessory.getService(Service.Battery);
-        expect(battery.getCharacteristic(Characteristic.BatteryLevel).value).toBe(99);
-    });
-
-    test('a realtime change keyed by code is reflected in HomeKit', () => {
-        const { accessory, device } = makeHarness(cloudState(), cloudCtx);
-        device.emitChange({ switch_2: true });
-        expect(valve(accessory, 'switch_2').getCharacteristic(Characteristic.Active).value).toBe(Characteristic.Active.ACTIVE);
-    });
-
-    test('an explicit valve list may use custom codes', () => {
+    test('an explicit valve list may use string codes', () => {
         const { accessory, device } = makeHarness(
             { zone_a: false, zone_b: false, battery_percentage: 50 },
-            { cloud: true, valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }] }
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], dpBattery: 'battery_percentage' }
         );
         expect(valve(accessory, 'zone_a')).toBeTruthy();
         valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).triggerSet(1);
@@ -520,35 +493,57 @@ describe('IrrigationSystemAccessory — cloud mode (data-points keyed by code)',
         expect(device.update).toHaveBeenCalledWith({ zone_b: true });
     });
 
-    test('turning a zone off still writes false when the cloud never echoed the "on"', () => {
-        // The real cloud device never optimistically advances `state`; it only
-        // moves when the realtime stream confirms the device. Emulate that by
-        // making update() a no-op on state. A follow-up "off" must STILL be sent
-        // — otherwise the valve stays open while HomeKit shows it closed (the
+    test('battery can be read from a code data-point', () => {
+        const { accessory } = makeHarness(
+            { zone_a: false, battery_percentage: 99 },
+            { valves: [{ name: 'A', dp: 'zone_a' }], dpBattery: 'battery_percentage' }
+        );
+        expect(accessory.getService(Service.Battery).getCharacteristic(Characteristic.BatteryLevel).value).toBe(99);
+    });
+
+    test('a device-side change keyed by code is reflected in HomeKit', () => {
+        const { accessory, device } = makeHarness(
+            { zone_a: false, zone_b: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], noBattery: true }
+        );
+        device.emitChange({ zone_b: true });
+        expect(valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).value).toBe(Characteristic.Active.ACTIVE);
+    });
+
+    test('turning a zone off still writes false when the device never echoed the "on"', () => {
+        // A device (notably over the cloud) may not optimistically advance `state`;
+        // it only moves when the device confirms. A follow-up "off" must STILL be
+        // sent — otherwise the valve stays open while HomeKit shows it closed (the
         // exact "can turn on but not off" report).
-        const { accessory, device } = makeHarness(cloudState(), { ...cloudCtx, defaultDuration: 0 });
+        const { accessory, device } = makeHarness(
+            { zone_a: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }], noBattery: true, defaultDuration: 0 }
+        );
         device.update.mockImplementation(() => true); // writes never touch state
-        const v = valve(accessory, 'switch_1');
+        const v = valve(accessory, 'zone_a');
 
         v.getCharacteristic(Characteristic.Active).triggerSet(1);
         jest.advanceTimersByTime(500);
-        expect(device.update).toHaveBeenLastCalledWith({ switch_1: true });
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: true });
 
         v.getCharacteristic(Characteristic.Active).triggerSet(0);
         jest.advanceTimersByTime(500);
-        expect(device.update).toHaveBeenLastCalledWith({ switch_1: false });
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: false });
     });
 
-    test('master OFF closes zones the cloud has not echoed as open', () => {
-        const { accessory, device } = makeHarness(cloudState(), { ...cloudCtx, defaultDuration: 0 });
+    test('master OFF closes zones the device has not echoed as open', () => {
+        const { accessory, device } = makeHarness(
+            { zone_a: false, zone_b: false },
+            { valves: [{ name: 'A', dp: 'zone_a' }, { name: 'B', dp: 'zone_b' }], noBattery: true, defaultDuration: 0 }
+        );
         device.update.mockImplementation(() => true); // writes never touch state
 
-        valve(accessory, 'switch_1').getCharacteristic(Characteristic.Active).triggerSet(1);
-        valve(accessory, 'switch_2').getCharacteristic(Characteristic.Active).triggerSet(1);
+        valve(accessory, 'zone_a').getCharacteristic(Characteristic.Active).triggerSet(1);
+        valve(accessory, 'zone_b').getCharacteristic(Characteristic.Active).triggerSet(1);
         jest.advanceTimersByTime(500);
 
         irrigation(accessory).getCharacteristic(Characteristic.Active).triggerSet(0);
         jest.advanceTimersByTime(500);
-        expect(device.update).toHaveBeenLastCalledWith({ switch_1: false, switch_2: false });
+        expect(device.update).toHaveBeenLastCalledWith({ zone_a: false, zone_b: false });
     });
 });

package/test/TuyaCloudApi.test.js

@@ -138,6 +138,23 @@ describe('TuyaCloudApi — endpoints', () => {
         await expect(api.getStatus('dev')).resolves.toEqual([{code: 'switch_1', value: true}]);
     });
 
+    test('getShadowProperties returns the properties array (code + dp_id)', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => {
+            path = p;
+            return {success: true, result: {properties: [{code: 'switch_led', dp_id: 20, value: true}]}};
+        };
+        await expect(api.getShadowProperties('dev')).resolves.toEqual([{code: 'switch_led', dp_id: 20, value: true}]);
+        expect(path).toBe('/v2.0/cloud/thing/dev/shadow/properties');
+    });
+
+    test('getShadowProperties returns null (never throws) when the shadow API is unavailable', async () => {
+        const api = ready();
+        api._httpsRequest = async () => ({success: false, code: 1106, msg: 'permission deny'});
+        await expect(api.getShadowProperties('dev')).resolves.toBeNull();
+    });
+
     test('getDeviceInfo returns the device record (with online status)', async () => {
         const api = ready();
         let path;

package/test/TuyaCloudDevice.test.js

@@ -127,6 +127,55 @@ describe('TuyaCloudDevice', () => {
         expect(dev.connected).toBe(false);
     });
 
+    test('builds the code<->dp_id map and dual-keys state from the shadow', async () => {
+        const props = [{code: 'switch_1', dp_id: 1, value: false}, {code: 'battery_percentage', dp_id: 46, value: 99}];
+        const api = makeApi();
+        api.getShadowProperties = jest.fn().mockResolvedValue(props);
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        expect(api.getShadowProperties).toHaveBeenCalledWith('dev1');
+        expect(dev.codeByDpId).toEqual({'1': 'switch_1', '46': 'battery_percentage'});
+        expect(dev.dpIdByCode).toEqual({'switch_1': '1', 'battery_percentage': '46'});
+        // state is addressable by BOTH the cloud code and the numeric LAN dp id
+        expect(dev.state).toEqual({switch_1: false, '1': false, battery_percentage: 99, '46': 99});
+    });
+
+    test('update translates a numeric dp id to its cloud code', async () => {
+        const api = makeApi();
+        api.getShadowProperties = jest.fn().mockResolvedValue([{code: 'switch_1', dp_id: 1, value: false}]);
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        dev.update({'1': true}); // a LAN-style numeric write
+        expect(api.sendCommands).toHaveBeenCalledWith('dev1', [{code: 'switch_1', value: true}]);
+    });
+
+    test('realtime code-only deltas are mirrored to numeric ids via the learned map', async () => {
+        const api = makeApi();
+        api.getShadowProperties = jest.fn().mockResolvedValue([{code: 'switch_1', dp_id: 1, value: false}]);
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        const changes = [];
+        dev.on('change', c => changes.push(c));
+        dev._applyStatus([{code: 'switch_1', value: true}]); // code-only (as MQTT delivers)
+        expect(dev.state.switch_1).toBe(true);
+        expect(dev.state['1']).toBe(true);
+        expect(changes[0]).toEqual({switch_1: true, '1': true});
+    });
+
+    test('falls back to /status (code-only) when the shadow is unavailable', async () => {
+        const api = makeApi();
+        api.getShadowProperties = jest.fn().mockResolvedValue(null);
+        const dev = makeDevice(api);
+        await dev._connect();
+
+        expect(dev.codeByDpId).toEqual({});
+        expect(dev.state).toEqual({switch_1: false, battery_percentage: 99}); // code-only, no numeric mirror
+        expect(api.getStatus).toHaveBeenCalledWith('dev1');
+    });
+
     test('subscribes to realtime and re-reads state when the stream (re)connects', async () => {
         const api = makeApi();
         const messaging = Object.assign(new EventEmitter(), {