@switchbot/homebridge-switchbot 5.0.0-beta.38 → 5.0.0-beta.39

package/src/platform-hap.ts

@@ -483,6 +483,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     let retryCount = 0
     const maxRetries = this.platformMaxRetries ?? 5
     const delayBetweenRetries = this.platformDelayBetweenRetries || 5000
+    let rateLimitExceeded = false
 
     this.debugWarnLog(`Retry Count: ${retryCount}`)
     this.debugWarnLog(`Max Retries: ${this.platformMaxRetries}`)
@@ -498,6 +499,13 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
           await this.handleIRDevices(Array.isArray(response.body.infraredRemoteList) ? response.body.infraredRemoteList : [])
           break
         } else {
+          // Check if rate limit exceeded (429)
+          if (statusCode === 429) {
+            rateLimitExceeded = true
+            this.warnLog('OpenAPI rate limit (429) exceeded. Falling back to manual device configuration.')
+            this.warnLog('Webhook functionality will still work if devices are configured manually.')
+            break
+          }
           await this.handleErrorResponse(statusCode, retryCount, maxRetries, delayBetweenRetries)
           retryCount++
         }
@@ -507,9 +515,116 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
         this.debugErrorLog(`Failed to Discover Devices, Error: ${e.message ?? e}`)
       }
     }
+
+    // If rate limit exceeded or retries exhausted, try to load from manual config or cached accessories
+    if (rateLimitExceeded || retryCount >= maxRetries) {
+      const hasCachedAccessories = this.accessories.length > 0
+      const hasManualConfig = this.config.options?.devices || this.config.options?.irdevices
+
+      if (hasManualConfig || hasCachedAccessories) {
+        if (hasCachedAccessories) {
+          this.warnLog(`Found ${this.accessories.length} cached accessories from previous sessions.`)
+          this.warnLog('Reinstantiating device classes to enable webhook handlers...')
+          await this.restoreCachedAccessories()
+        }
+        if (hasManualConfig) {
+          this.warnLog('Attempting to load devices from manual configuration...')
+          await this.handleManualConfig()
+        }
+        if (hasCachedAccessories) {
+          this.infoLog('Cached accessories restored. Webhook functionality is active.')
+          this.infoLog('Device discovery will resume when API rate limit resets.')
+        }
+      } else {
+        this.errorLog('OpenAPI unavailable and no cached accessories or manual device configuration found.')
+        this.errorLog('Please configure devices manually in the plugin settings to use webhook functionality.')
+      }
+    }
+  }
+
+  /**
+   * Restore cached accessories by reinstantiating their device classes
+   * This ensures webhook handlers and other functionality are properly set up
+   */
+  private async restoreCachedAccessories() {
+    this.debugLog('Restoring cached accessories and setting up webhook handlers...')
+
+    for (const accessory of this.accessories) {
+      try {
+        const device = accessory.context.device
+        const deviceType = accessory.context.deviceType || device?.deviceType
+        const deviceId = accessory.context.deviceId || device?.deviceId
+
+        if (!device || !deviceType || !deviceId) {
+          this.debugWarnLog(`Skipping cached accessory ${accessory.displayName} - missing context data`)
+          continue
+        }
+
+        this.debugLog(`Reinstantiating ${deviceType} for cached accessory: ${accessory.displayName}`)
+
+        // Reinstantiate the device class based on deviceType
+        const deviceTypeHandlers: { [key: string]: new (platform: any, accessory: PlatformAccessory, device: any) => any } = {
+          'Humidifier': Humidifier,
+          'Humidifier2': Humidifier,
+          'Hub 2': Hub,
+          'Hub 3': Hub,
+          'Bot': Bot,
+          'Relay Switch 1': RelaySwitch,
+          'Relay Switch 1PM': RelaySwitch,
+          'Meter': Meter,
+          'MeterPlus': MeterPlus,
+          'Meter Plus (JP)': MeterPlus,
+          'MeterPro': MeterPro,
+          'MeterPro(CO2)': MeterPro,
+          'WoIOSensor': IOSensor,
+          'Water Detector': WaterDetector,
+          'Motion Sensor': Motion,
+          'Contact Sensor': Contact,
+          'Curtain': Curtain,
+          'Curtain3': Curtain,
+          'WoRollerShade': Curtain,
+          'Roller Shade': Curtain,
+          'Blind Tilt': BlindTilt,
+          'Plug': Plug,
+          'Plug Mini (US)': Plug,
+          'Plug Mini (JP)': Plug,
+          'Smart Lock': Lock,
+          'Smart Lock Pro': Lock,
+          'Color Bulb': ColorBulb,
+          'K10+': RobotVacuumCleaner,
+          'K10+ Pro': RobotVacuumCleaner,
+          'WoSweeper': RobotVacuumCleaner,
+          'WoSweeperMini': RobotVacuumCleaner,
+          'Robot Vacuum Cleaner S1': RobotVacuumCleaner,
+          'Robot Vacuum Cleaner S1 Plus': RobotVacuumCleaner,
+          'Robot Vacuum Cleaner S10': RobotVacuumCleaner,
+          'Ceiling Light': CeilingLight,
+          'Ceiling Light Pro': CeilingLight,
+          'Strip Light': StripLight,
+          'Battery Circulator Fan': Fan,
+          'Air Purifier PM2.5': AirPurifier,
+          'Air Purifier Table PM2.5': AirPurifier,
+          'Air Purifier VOC': AirPurifier,
+          'Air Purifier Table VOC': AirPurifier,
+        }
+
+        const DeviceClass = deviceTypeHandlers[deviceType]
+        if (DeviceClass) {
+          new DeviceClass(this, accessory, device)
+          this.debugSuccessLog(`Successfully restored ${deviceType}: ${accessory.displayName}`)
+        } else {
+          this.debugLog(`No handler for device type: ${deviceType}`)
+        }
+      } catch (e: any) {
+        this.errorLog(`Failed to restore cached accessory ${accessory.displayName}, Error: ${e.message ?? e}`)
+      }
+    }
+
+    this.infoLog(`Restored ${this.accessories.length} cached accessories with webhook support`)
   }
 
   private async handleManualConfig() {
+    // Handle regular devices
     if (this.config.options?.devices) {
       this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`)
       const devices = this.config.options.devices.map((v: any) => v)
@@ -526,7 +641,27 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
           this.errorLog(`failed to format device ID as MAC, Error: ${error}`)
         }
       }
-    } else {
+    }
+
+    // Handle IR devices
+    if (this.config.options?.irdevices) {
+      this.debugLog(`SwitchBot IR Device Manual Config Set: ${JSON.stringify(this.config.options?.irdevices)}`)
+      const irdevices = this.config.options.irdevices.map((v: any) => v)
+      for (const irdevice of irdevices) {
+        irdevice.remoteType = irdevice.configRemoteType !== undefined ? irdevice.configRemoteType : 'Unknown'
+        irdevice.deviceName = irdevice.configDeviceName !== undefined ? irdevice.configDeviceName : 'Unknown'
+        try {
+          this.debugLog(`IR deviceId: ${irdevice.deviceId}`)
+          if (irdevice.remoteType) {
+            await this.createIRDevice(irdevice)
+          }
+        } catch (error) {
+          this.errorLog(`failed to create IR device, Error: ${error}`)
+        }
+      }
+    }
+
+    if (!this.config.options?.devices && !this.config.options?.irdevices) {
       this.errorLog('Neither SwitchBot Token or Device Config are set.')
     }
   }

package/src/platform-matter.ts

@@ -1076,6 +1076,25 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
       this.debugLog(`Failed to schedule refresh for ${dev.deviceId}: ${e?.message ?? e}`)
     }
 
+    // Register webhook handler for this device
+    try {
+      if (dev.webhook && dev.deviceId) {
+        this.debugLog(`Registering webhook handler for Matter device: ${dev.deviceId}`)
+        this.webhookEventHandler[dev.deviceId] = async (context: any) => {
+          try {
+            this.debugLog(`Received webhook for Matter device ${dev.deviceId}: ${JSON.stringify(context)}`)
+            // Apply webhook status update to the accessory
+            await this.applyStatusToAccessory(uuid, dev, context)
+          } catch (e: any) {
+            this.errorLog(`Failed to handle webhook for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        }
+        this.debugSuccessLog(`Webhook handler registered for ${dev.deviceId}`)
+      }
+    } catch (e: any) {
+      this.debugLog(`Failed to register webhook handler for ${dev.deviceId}: ${e?.message ?? e}`)
+    }
+
     return instance.toAccessory()
   }
 
@@ -1108,6 +1127,12 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
         }
       } else {
         this.warnLog(`SwitchBot getDevices returned status ${statusCode}`)
+        // If rate limit exceeded (429), log specific message
+        if (statusCode === 429) {
+          this.warnLog('OpenAPI rate limit (429) exceeded during discovery.')
+          this.warnLog('Webhook functionality will still work for manually configured devices.')
+          this.warnLog('Device state updates will be limited until rate limit resets.')
+        }
       }
     } catch (e: any) {
       this.errorLog('Failed to discover SwitchBot devices:', e?.message ?? e)
@@ -1865,14 +1890,77 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
       return
     }
 
-    // If no discovered devices are available, do not register example/demo accessories.
-    this.infoLog('No discovered SwitchBot devices found.')
+    // If no discovered devices are available, check for cached Matter accessories
+    const hasCachedAccessories = this.matterAccessories.size > 0
+    if (hasCachedAccessories) {
+      this.infoLog(`No devices discovered via OpenAPI, but found ${this.matterAccessories.size} cached Matter accessories.`)
+      this.infoLog('Cached accessories will continue to function with webhook updates.')
+      this.infoLog('Restoring webhook handlers for cached Matter accessories...')
+      await this.restoreCachedMatterAccessoryWebhooks()
+      this.infoLog('Device discovery will resume when API becomes available.')
+    } else {
+      this.infoLog('No discovered SwitchBot devices found.')
+    }
 
     this.debugLog('═'.repeat(80))
     this.debugLog('Finished registering Matter accessories')
     this.debugLog('═'.repeat(80))
   }
 
+  /**
+   * Restore webhook handlers for cached Matter accessories
+   * This ensures webhook functionality continues to work even when device discovery fails
+   */
+  private async restoreCachedMatterAccessoryWebhooks() {
+    this.debugLog('Restoring webhook handlers for cached Matter accessories...')
+
+    let restoredCount = 0
+    for (const [uuid, accessory] of this.matterAccessories.entries()) {
+      try {
+        const context = (accessory as any)?.context
+        const deviceId = context?.deviceId
+        const webhook = context?.webhook
+
+        if (!deviceId) {
+          this.debugLog(`Skipping cached accessory ${accessory.displayName} - no deviceId in context`)
+          continue
+        }
+
+        // Only register webhook if the device had webhook enabled
+        if (webhook) {
+          this.debugLog(`Restoring webhook handler for Matter device: ${deviceId}`)
+
+          // Create a minimal device object from cached context for webhook handling
+          const dev: any = {
+            deviceId,
+            deviceName: context?.name || accessory.displayName,
+            deviceType: context?.deviceType,
+            webhook: true,
+          }
+
+          this.webhookEventHandler[deviceId] = async (webhookContext: any) => {
+            try {
+              this.debugLog(`Received webhook for cached Matter device ${deviceId}: ${JSON.stringify(webhookContext)}`)
+              // Apply webhook status update to the accessory
+              await this.applyStatusToAccessory(uuid, dev, webhookContext)
+            } catch (e: any) {
+              this.errorLog(`Failed to handle webhook for cached device ${deviceId}: ${e?.message ?? e}`)
+            }
+          }
+
+          restoredCount++
+          this.debugSuccessLog(`Webhook handler restored for ${deviceId}`)
+        } else {
+          this.debugLog(`Device ${deviceId} does not have webhook enabled, skipping`)
+        }
+      } catch (e: any) {
+        this.errorLog(`Failed to restore webhook handler for cached accessory ${accessory.displayName}: ${e?.message ?? e}`)
+      }
+    }
+
+    this.infoLog(`Restored webhook handlers for ${restoredCount} cached Matter accessories`)
+  }
+
   /**
    * Remove accessories that are disabled in config
    */