homebridge-tuya-plus 3.14.0-dev.30 → 3.14.0-dev.32

package/index.js

@@ -228,12 +228,7 @@ class TuyaLan {
       (config) => {
         if (!config || !config.id) return;
         const tuyaDevice = this.tuyaDevices.get(config.id);
-        if (!tuyaDevice)
-          return this.log.warn(
-            'Discovered a device that has not been configured yet (%s@%s).',
-            config.id,
-            config.ip,
-          );
+        if (!tuyaDevice) return this._warnUnconfiguredDevice(config);
         if (connectedDevices.includes(config.id)) return;
 
         connectedDevices.push(config.id);
@@ -284,6 +279,49 @@ class TuyaLan {
     }, this.config.discoverTimeout ?? DEFAULT_DISCOVER_TIMEOUT);
   }
 
+  // A device showed up on the LAN that isn't in the user's config. When the
+  // optional cloud session is available we look the device up there first, so
+  // the warning can name it (and hint at its product/category) and the user
+  // can tell which physical device still needs configuring — far more useful
+  // than a bare id@ip. If there's no cloud session, or the lookup fails (the
+  // device belongs to another account, the device-management API isn't
+  // authorised, the network is down, …), fall back to the plain warning.
+  // Never throws: enrichment is best-effort and must not disrupt discovery.
+  async _warnUnconfiguredDevice(config) {
+    const bareWarning = () =>
+      this.log.warn(
+        'Discovered a device that has not been configured yet (%s@%s).',
+        config.id,
+        config.ip,
+      );
+
+    if (!this.cloudApi) return bareWarning();
+
+    let info;
+    try {
+      info = await this.cloudApi.getDeviceInfo(config.id);
+    } catch (ex) {
+      this.log.debug(
+        'Tuya Cloud lookup for unconfigured device %s failed: %s',
+        config.id,
+        ex.message,
+      );
+    }
+    if (!info || !info.name) return bareWarning();
+
+    const details = [];
+    if (info.product_name) details.push(info.product_name);
+    if (info.category) details.push(`category ${info.category}`);
+
+    this.log.warn(
+      'Discovered a device that has not been configured yet: %s%s (%s@%s).',
+      `"${info.name}"`,
+      details.length ? ` — ${details.join(', ')}` : '',
+      config.id,
+      config.ip,
+    );
+  }
+
   /* ------------------------------------------------------------------ *
    *  Tuya Cloud — a single, global fallback session.
    *

package/lib/BaseAccessory.js

@@ -24,7 +24,7 @@ class BaseAccessory {
         });
 
         this.device.once('change', () => {
-            this.log(`Ready to handle ${this.device.context.name} (${this.device.context.type}:${this.device.context.version}) with signature ${JSON.stringify(this.device.state)}`);
+            this.log.debug(`Ready to handle ${this.device.context.name} (${this.device.context.type}:${this.device.context.version}) with signature ${JSON.stringify(this.device.state)}`);
 
             this._registerCharacteristics(this.device.state);
         });

package/lib/TuyaAccessory.js

@@ -328,8 +328,8 @@ class TuyaAccessory extends EventEmitter {
                     data = JSON.parse(decryptedMsg);
                 } catch (ex) {
                     data = decryptedMsg;
-                    this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, data);
-                    this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                    this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, data);
+                    this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
                     break;
                 }
 
@@ -351,8 +351,8 @@ class TuyaAccessory extends EventEmitter {
                     try {
                         data = JSON.parse(data);
                     } catch (ex) {
-                        this.log.info(`Malformed update from ${this.context.name} with command ${cmd}:`, data);
-                        this.log.info(`Raw update from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                        this.log.debug(`Malformed update from ${this.context.name} with command ${cmd}:`, data);
+                        this.log.debug(`Raw update from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
                         break;
                     }
 
@@ -361,8 +361,8 @@ class TuyaAccessory extends EventEmitter {
                 break;
 
             default:
-                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, data);
-                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, data);
+                this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
         }
 
         callback();
@@ -416,8 +416,8 @@ class TuyaAccessory extends EventEmitter {
         try {
             data = JSON.parse(decryptedMsg);
         } catch(ex) {
-            this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
-            this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+            this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+            this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
             return callback();
         }
 
@@ -429,15 +429,15 @@ class TuyaAccessory extends EventEmitter {
                         //this.log.info(`Heard back from ${this.context.name} with command ${cmd}`);
                         this._change(data.dps);
                     } else {
-                        this.log.info(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
-                        this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                        this.log.debug(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                        this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
                     }
                 }
                 break;
 
             default:
-                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
-                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
         }
 
         callback();
@@ -550,15 +550,15 @@ class TuyaAccessory extends EventEmitter {
                         //this.log.info(`Heard back from ${this.context.name} with command ${cmd}`);
                         this._change(parsedPayload.dps);
                     } else {
-                        this.log.info(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
-                        this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                        this.log.debug(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                        this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
                     }
                 }
                 break;
 
             default:
-                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
-                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                this.log.debug(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
         }
 
         callback();
@@ -674,11 +674,11 @@ class TuyaAccessory extends EventEmitter {
                 if (parsedPayload && parsedPayload.dps) {
                     this._change(parsedPayload.dps);
                 } else {
-                    this.log.info(`Malformed message from ${this.context.name} with command ${cmd}:`, payload.toString('utf8'));
+                    this.log.debug(`Malformed message from ${this.context.name} with command ${cmd}:`, payload.toString('utf8'));
                 }
                 break;
             default:
-                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, payload.toString('utf8'));
+                this.log.debug(`Odd message from ${this.context.name} with command ${cmd}:`, payload.toString('utf8'));
         }
 
         callback();

package/lib/TuyaCloudDevice.js

@@ -39,12 +39,19 @@ class TuyaCloudDevice extends EventEmitter {
         this.api = props.cloudApi;
         this.messaging = props.messaging || null; // shared realtime stream
 
+        // Lets the cloud backend ask its parent TuyaDevice whether the SAME device
+        // is currently reachable over the LAN. A cloud-fallback failure is harmless
+        // when the LAN is up and worth surfacing when it isn't, so the failure log
+        // adapts to it. Null when used standalone (no LAN sibling).
+        this.isLanConnected = typeof props.isLanConnected === 'function' ? props.isLanConnected : null;
+
         // Keep a plain config object on `context`, mirroring TuyaAccessory, but
         // without the live helper objects we were handed.
         this.context = {...props};
         delete this.context.cloudApi;
         delete this.context.messaging;
         delete this.context.log;
+        delete this.context.isLanConnected;
 
         this.state = {};
         this.connected = false;
@@ -118,22 +125,20 @@ class TuyaCloudDevice extends EventEmitter {
     // won't clear without the user changing their Tuya project. Since PR #71 the
     // cloud backs *every* device as a fallback, so a LAN-only device whose cloud
     // project lacks permission would otherwise log an error every 30s forever.
-    // Two things keep that out of the log: a given error is surfaced once and then
+    // Two things keep that out of the log: a given message is surfaced once and then
     // suppressed to debug until it changes (or the device connects), and the retry
     // interval backs off (30s → 30m cap) instead of hammering the OpenAPI.
     _onConnectFailure(ex) {
         const message = ex && ex.message ? ex.message : String(ex);
-
-        if (message !== this._lastConnectError) {
-            // The cloud is only a fallback for a LAN-capable device (one with a
-            // local key); for a cloud-only device it is the sole path, so the same
-            // failure is more serious. Reflect that in the level and the hint.
-            const lanFallback = !!this.context.key;
-            const hint = lanFallback
-                ? ' The cloud is only a fallback here, so this is harmless if the device is reachable over the LAN; otherwise check that it is linked to the cloud project (matching account/home and datacenter region).'
-                : ' This device is cloud-only, so it stays unreachable until this clears — check that it is linked to the cloud project (matching account/home and datacenter region).';
-            this.log[lanFallback ? 'warn' : 'error'](`${this.context.name}: Tuya Cloud connection failed: ${message}.${hint}`);
-            this._lastConnectError = message;
+        const {level, text} = this._describeConnectFailure(message);
+
+        // The full (level + wording) is what the dedup tracks, not just the raw
+        // message: it means a device that flips from "reachable over the LAN"
+        // (harmless, debug) to "not reachable over the LAN either" (warn) re-surfaces
+        // the change, while an unchanged situation stays quiet.
+        if (text !== this._lastConnectError) {
+            this.log[level](text);
+            this._lastConnectError = text;
         } else {
             this.log.debug(`${this.context.name}: Tuya Cloud connection still failing: ${message}`);
         }
@@ -145,6 +150,41 @@ class TuyaCloudDevice extends EventEmitter {
         if (this._retryTimer && this._retryTimer.unref) this._retryTimer.unref();
     }
 
+    // Pick the log level and wording for a connect failure from what we know about
+    // the device: whether the cloud is merely a fallback (the device has a local
+    // key) and, if so, whether that LAN path is reachable right now.
+    _describeConnectFailure(message) {
+        const lanFallback = !!this.context.key;
+        const lanReachable = lanFallback && !!(this.isLanConnected && this.isLanConnected());
+
+        // "permission deny" (1106) is specifically a visibility problem: the cloud
+        // project can't see this device. A device that has been offline for a long
+        // time is a prime candidate for having been removed/unbound/reset, which
+        // produces exactly this — so point at that, but only for this error (a
+        // timeout or token failure is unrelated).
+        const unbound = /permission deny|\b1106\b/i.test(message)
+            ? ' Note: a device left offline for a long time can be removed or unbound from the account (e.g. reset or re-paired), which also produces this "permission deny".'
+            : '';
+
+        let level, hint;
+        if (lanReachable) {
+            // Confirmed reachable over the LAN, so the cloud fallback we couldn't
+            // reach isn't needed. Keep it out of the way at debug.
+            level = 'debug';
+            hint = ' The device is reachable over the LAN, so only the (unused) cloud fallback is affected — harmless.';
+        } else if (lanFallback) {
+            // LAN-capable but not connected right now, so the cloud is currently the
+            // only path and the device may be unresponsive in HomeKit.
+            level = 'warn';
+            hint = ` The cloud is only a fallback, but the device isn't reachable over the LAN right now either, so it may show as unresponsive in HomeKit. Check that it is linked to this cloud project (matching account/home and datacenter region).${unbound}`;
+        } else {
+            level = 'error';
+            hint = ` This device is cloud-only, so it stays unreachable until this clears — check that it is linked to the cloud project (matching account/home and datacenter region).${unbound}`;
+        }
+
+        return {level, text: `${this.context.name}: Tuya Cloud connection failed: ${message}.${hint}`};
+    }
+
     /* ------------------------------------------------------------------ *
      *  Realtime (shared MQTT stream)
      * ------------------------------------------------------------------ */
@@ -259,7 +299,7 @@ class TuyaCloudDevice extends EventEmitter {
                 const dp = i.dp_id != null ? i.dp_id : (i.dpId != null ? i.dpId : this.dpIdByCode[i.code]);
                 return `${i.code}${dp != null ? `(dp ${dp})` : ''}=${JSON.stringify(i.value)}`;
             }).join(', ');
-            this.log.info(`${this.context.name}: Tuya Cloud data-points → ${list || '(none reported)'}`);
+            this.log.debug(`${this.context.name}: Tuya Cloud data-points → ${list || '(none reported)'}`);
         } catch (_) { /* logging must never throw */ }
     }
 

package/lib/TuyaDevice.js

@@ -79,6 +79,9 @@ class TuyaDevice extends EventEmitter {
                 cloudApi: props.cloudApi,
                 messaging: props.messaging,
                 log: this.log,
+                // Let the cloud backend tell a harmless fallback failure (the device
+                // is reachable over the LAN) apart from one that matters (it isn't).
+                isLanConnected: () => !!(this.lan && this.lan.connected),
                 connect: false
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.14.0-dev.30",
+  "version": "3.14.0-dev.32",
   "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

@@ -246,6 +246,59 @@ describe('TuyaCloudDevice', () => {
             }
         });
 
+        test('a device reachable over the LAN logs the fallback failure as harmless (debug, not warn)', () => {
+            jest.useFakeTimers();
+            try {
+                const dev = makeDevice(makeApi(), null, {key: 'abc', isLanConnected: () => true});
+                const warn = jest.spyOn(log, 'warn');
+                const debug = jest.spyOn(log, 'debug');
+
+                dev._onConnectFailure(new Error('permission deny (code 1106)'));
+
+                expect(warn).not.toHaveBeenCalled();
+                expect(debug).toHaveBeenCalledTimes(1);
+                expect(debug.mock.calls[0][0]).toContain('reachable over the LAN');
+            } finally {
+                jest.useRealTimers();
+            }
+        });
+
+        test('the same failure re-surfaces (debug → warn) when the LAN path drops', () => {
+            jest.useFakeTimers();
+            try {
+                let lanUp = true;
+                const dev = makeDevice(makeApi(), null, {key: 'abc', isLanConnected: () => lanUp});
+                const warn = jest.spyOn(log, 'warn');
+                const err = new Error('permission deny (code 1106)');
+
+                dev._onConnectFailure(err);        // LAN up → harmless, debug only
+                expect(warn).not.toHaveBeenCalled();
+
+                lanUp = false;
+                dev._onConnectFailure(err);        // identical error, but LAN now down → surfaced
+                expect(warn).toHaveBeenCalledTimes(1);
+                expect(warn.mock.calls[0][0]).toContain("isn't reachable over the LAN");
+            } finally {
+                jest.useRealTimers();
+            }
+        });
+
+        test('permission-deny adds the offline-unbinding hint; an unrelated error does not', () => {
+            jest.useFakeTimers();
+            try {
+                const dev = makeDevice(makeApi(), null, {key: 'abc'}); // LAN-capable, LAN down
+                const warn = jest.spyOn(log, 'warn');
+
+                dev._onConnectFailure(new Error('permission deny (code 1106)'));
+                expect(warn.mock.calls[0][0]).toContain('offline for a long time');
+
+                dev._onConnectFailure(new Error('request timed out'));
+                expect(warn.mock.calls[1][0]).not.toContain('offline for a long time');
+            } finally {
+                jest.useRealTimers();
+            }
+        });
+
         test('a different error message is surfaced again, not suppressed', () => {
             jest.useFakeTimers();
             try {

package/test/TuyaDevice.test.js

@@ -232,6 +232,20 @@ describe('TuyaDevice — composition', () => {
         expect(dev.cloud).toBeNull();
     });
 
+    test('the cloud backend can see whether the LAN path is currently up', () => {
+        const api = {
+            isConfigured: () => true,
+            getStatus: jest.fn().mockResolvedValue([]),
+            getDeviceInfo: jest.fn().mockResolvedValue({online: true}),
+            sendCommands: jest.fn()
+        };
+        const dev = makeDevice({cloudApi: api});
+
+        expect(dev.cloud.isLanConnected()).toBe(false); // no LAN attached yet
+        dev.lan = {connected: true};
+        expect(dev.cloud.isLanConnected()).toBe(true);  // reflects live LAN state
+    });
+
     test('attachLan builds the LAN backend with the discovered version (forceVersion still wins)', () => {
         const dev = makeDevice({ip: '10.0.0.5'});
         dev.attachLan({ip: '10.0.0.9', version: '3.3'});

package/test/index.test.js

@@ -16,6 +16,7 @@ jest.mock('../lib/TuyaAccessory', () => jest.fn().mockImplementation(function(pr
 jest.mock('../lib/TuyaCloudApi', () => jest.fn().mockImplementation(function(cfg) {
     this.endpoint = 'https://openapi.example.com';
     this.cfg = cfg;
+    this.getDeviceInfo = jest.fn();
 }));
 jest.mock('../lib/TuyaCloudMessaging', () => jest.fn().mockImplementation(function() {}));
 jest.mock('../lib/TuyaDiscovery', () => ({
@@ -135,6 +136,63 @@ describe('TuyaLan — discovery routing', () => {
     });
 });
 
+describe('TuyaLan — unconfigured device discovery', () => {
+    const UNKNOWN = {id: 'bf99999999999999', ip: '10.0.0.9'};
+    const BARE = 'Discovered a device that has not been configured yet (%s@%s).';
+    const ENRICHED = 'Discovered a device that has not been configured yet: %s%s (%s@%s).';
+
+    test('without a cloud session, the bare id@ip warning is logged', async () => {
+        const platform = run({devices: [SW()]});
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+    });
+
+    test('with a cloud session, the warning is enriched with the device name and product', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue({name: 'Living Room Light', product_name: 'Smart Bulb', category: 'dj', online: true});
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.cloudApi.getDeviceInfo).toHaveBeenCalledWith(UNKNOWN.id);
+        const [format, ...args] = platform.log.warn.mock.calls[0];
+        expect(format).toBe(ENRICHED);
+        const text = args.join(' ');
+        expect(text).toContain('"Living Room Light"');
+        expect(text).toContain('Smart Bulb');
+        expect(text).toContain('category dj');
+        expect(text).toContain(UNKNOWN.id);
+    });
+
+    test('a cloud lookup that fails falls back to the bare warning', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockRejectedValue(new Error('device not found'));
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+        expect(platform.log.debug).toHaveBeenCalled();
+    });
+
+    test('a cloud record without a name falls back to the bare warning', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue({online: true});
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+    });
+
+    test('the discover handler routes an unconfigured device through the cloud lookup', () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue(null);
+
+        const onDiscover = TuyaDiscovery.on.mock.calls.find(c => c[0] === 'discover')[1];
+        onDiscover(UNKNOWN);
+
+        expect(platform.cloudApi.getDeviceInfo).toHaveBeenCalledWith(UNKNOWN.id);
+    });
+});
+
 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