@homebridge-plugins/homebridge-ewelink 12.13.1-beta.0 → 12.13.1-beta.2

package/lib/connection/ws.js

@@ -11,7 +11,7 @@ import { hasProperty, parseError, sleep } from '../utils/functions.js'
 const emitter = new events()
 
 export default class {
-  constructor(platform, authData) {
+  constructor(platform, authData, httpClient) {
     // Set up variables from the platform
     this.appId = platform.config.appId || platformConsts.appId
     this.appSecret = platform.config.appSecret || platformConsts.appSecret
@@ -19,6 +19,9 @@ export default class {
     this.lang = platform.lang
     this.log = platform.log
 
+    // HTTP client used to refresh the bearer token when a 406 invalidates the session
+    this.httpClient = httpClient
+
     // Set up variables from the authData (from HTTP)
     this.httpHost = authData.httpHost
     this.aToken = authData.aToken
@@ -26,6 +29,51 @@ export default class {
 
     // Flag used to determine ws connection status
     this.wsIsConnected = false
+
+    // Retry state — a single counter/timer serialises all reconnection paths
+    this.retryCount = 0
+    this.loginInProgress = false
+    this.reconnectTimer = null
+  }
+
+  scheduleReconnect(reason) {
+    // Another retry is already queued or a login is actively running — nothing to do
+    if (this.reconnectTimer || this.loginInProgress) {
+      return
+    }
+    if (this.retryCount >= 10) {
+      this.log.warn('%s [giving up after %s attempts, reason: %s].', this.lang.wsLoginError, this.retryCount, reason)
+      return
+    }
+    const delay = Math.min(5000 * 2 ** this.retryCount, 300000)
+    this.retryCount += 1
+    // Log recovery at info level — users need to see that retries are happening
+    this.log('WS reconnect scheduled [%s] in %s ms (attempt %s).', reason, delay, this.retryCount)
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.login().catch(() => {
+        // login() schedules its own retry on internal failure — nothing to do here
+      })
+    }, delay)
+  }
+
+  async refreshHttpToken() {
+    // Re-run HTTP login to get a fresh aToken; a 406 means the old one is invalidated.
+    // This does NOT re-fetch homes/devices — only the bearer token changes.
+    if (!this.httpClient) {
+      return false
+    }
+    try {
+      const authData = await this.httpClient.login()
+      this.aToken = authData.aToken
+      this.apiKey = authData.apiKey
+      this.httpHost = authData.httpHost
+      this.log('HTTP token refreshed after 406.')
+      return true
+    } catch (err) {
+      this.log.warn('%s %s.', 'HTTP token refresh failed:', parseError(err))
+      return false
+    }
   }
 
   async getHost(attempt = 0) {
@@ -81,17 +129,21 @@ export default class {
   }
 
   async login() {
-    // Used to create the web socket connection and authenticate
-    try {
-      // This may be called onClose and onError, we just want it to run once
-      if (this.debounce) {
-        return
-      }
-      this.debounce = true
-      setTimeout(() => {
-        this.debounce = false
-      }, 4000)
+    // Used to create the web socket connection and authenticate.
+    // All reconnection paths (onClose, onError, 406, open-fail) funnel through
+    // scheduleReconnect(), which guards against concurrent logins via loginInProgress.
+    if (this.loginInProgress) {
+      return
+    }
+    this.loginInProgress = true
+
+    // Cancel any pending reconnect — we're attempting a login right now
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
 
+    try {
       // Close any existing web socket connection
       await this.closeConnection()
 
@@ -159,22 +211,19 @@ export default class {
               }
             }, (res.config.hbInterval + 7) * 1000)
 
-            // Login was successful and log if appropriate
-            this.authRetries = 0
+            // Login was successful — reset the retry counter and log if appropriate
+            this.retryCount = 0
             if (this.debug) {
               this.log('%s.', this.lang.wsLoginSuccess)
             }
           } else if (res.error === 406) {
-            // Token invalidated (e.g. concurrent session), re-authenticate with backoff
+            // Token invalidated (e.g. concurrent session from the mobile app).
+            // Re-sending userOnline with the same aToken will keep returning 406,
+            // so refresh the HTTP token first, then reconnect with backoff.
             this.log.warn(this.lang.wsLogin406)
-            const delay = Math.min(5000 * 2 ** (this.authRetries || 0), 300000)
-            this.authRetries = (this.authRetries || 0) + 1
-            this.log.error('delay: %s ', delay, 'authRetries: %s', this.authRetries)
-            if (this.authRetries <= 10) {
-              await sleep(delay)
-              this.log.error('retrying login')
-              await this.login()
-            }
+            await this.refreshHttpToken()
+            await this.closeConnection()
+            this.scheduleReconnect('406')
           } else {
             // There was a problem with the authentication response
             const str = JSON.stringify(res, null, 2)
@@ -183,6 +232,8 @@ export default class {
         } catch (err) {
           // Catch any errors authenticating the WS connection
           this.log.warn('%s %s.', this.lang.wsLoginError, parseError(err))
+          await this.closeConnection()
+          this.scheduleReconnect('auth-error')
         }
       })
 
@@ -276,7 +327,7 @@ export default class {
       })
 
       // Add a listener for when the web socket closes for any reason
-      this.wsClient.onClose.addListener(async (e) => {
+      this.wsClient.onClose.addListener((e) => {
         // Don't continue further with logging/reconnection if it's a wanted closure
         if (e === 1005) {
           return
@@ -286,30 +337,23 @@ export default class {
           this.log.warn('%s [%s].', this.lang.wsReconnectError, e)
         }
 
-        // Reconnect with exponential backoff
-        this.reconnectAttempts = (this.reconnectAttempts || 0) + 1
-        const delay = Math.min(5000 * 2 ** (this.reconnectAttempts - 1), 300000)
-        await sleep(delay)
-        await this.login()
+        this.wsIsConnected = false
+        this.scheduleReconnect(`close-${e}`)
       })
 
       // Add a listener for when the web socket throws an error
-      this.wsClient.onError.addListener(async (e) => {
+      this.wsClient.onError.addListener((e) => {
         if (this.debug) {
           this.log.warn('%s [%s].', this.lang.wsReconnectClose, e)
         }
 
-        this.reconnectAttempts = (this.reconnectAttempts || 0) + 1
-        const delay = Math.min(5000 * 2 ** (this.reconnectAttempts - 1), 300000)
-        await sleep(delay)
-        await this.login()
+        this.scheduleReconnect('error')
       })
 
-      // Open the web socket connection
+      // Open the web socket connection.
+      // NB: retryCount is reset only on successful auth, not on TCP handshake —
+      // otherwise a repeated auth-failure loop would reset backoff every cycle.
       await this.wsClient.open()
-
-      // Reset reconnect counter on successful connection
-      this.reconnectAttempts = 0
     } catch (err) {
       const errToShow = parseError(err)
 
@@ -317,10 +361,9 @@ export default class {
         this.log('%s: %s.', this.lang.wsLoginErrRecon, errToShow)
       }
 
-      this.reconnectAttempts = (this.reconnectAttempts || 0) + 1
-      const delay = Math.min(5000 * 2 ** (this.reconnectAttempts - 1), 300000)
-      await sleep(delay)
-      await this.login()
+      this.scheduleReconnect('open-failed')
+    } finally {
+      this.loginInProgress = false
     }
   }
 
@@ -421,7 +464,8 @@ export default class {
   }
 
   async closeConnection() {
-    // This is called when refreshing connection or if Homebridge shuts down
+    // This is called when refreshing connection or if Homebridge shuts down.
+    // Idempotent — safe to call regardless of current connection state.
 
     // Clear any existing ping interval
     if (this.hbInterval) {
@@ -431,21 +475,22 @@ export default class {
 
     // Check the ws client is set up
     if (this.wsClient) {
-      // Remove any existing listeners
-      this.wsClient.removeAllListeners()
+      const wasConnected = this.wsIsConnected
 
-      // Close the web socket connection
-      if (this.wsIsConnected) {
-        // Set the connection flag to false
-        this.wsIsConnected = false
+      // Remove any existing listeners so onClose/onError don't retrigger reconnection
+      this.wsClient.removeAllListeners()
+      this.wsIsConnected = false
 
-        // Close the connection
+      // Always attempt to close the underlying socket — auth-failure paths (e.g. 406)
+      // leave wsIsConnected=false but the TCP/WS socket is still open.
+      try {
         await this.wsClient.close()
+      } catch {
+        // Already closed, never fully opened, or close threw — nothing actionable
+      }
 
-        // Log if appropriate
-        if (this.debug) {
-          this.log('%s.', this.lang.stoppedWS)
-        }
+      if (wasConnected && this.debug) {
+        this.log('%s.', this.lang.stoppedWS)
       }
     }
   }

package/lib/platform.js

@@ -513,7 +513,7 @@ export default class {
 
         // Set up the WS client, get the user WS host and login
         if (this.config.mode !== 'lan') {
-          this.wsClient = new wsClient(this, authData)
+          this.wsClient = new wsClient(this, authData, this.httpClient)
           await this.wsClient.login()
 
           // Refresh the WS connection every 60 minutes

package/package.json

@@ -3,7 +3,7 @@
   "displayName": "Homebridge eWeLink",
   "alias": "eWeLink",
   "type": "module",
-  "version": "12.13.1-beta.0",
+  "version": "12.13.1-beta.2",
   "description": "Homebridge plugin to integrate eWeLink devices into HomeKit.",
   "author": {
     "name": "bwp91",