@switchbot/homebridge-switchbot 5.0.0-beta.2 → 5.0.0-beta.21

package/src/platform-matter.ts

@@ -5,8 +5,11 @@ import type {
   MatterAccessory,
   SerializedMatterAccessory,
 } from 'homebridge'
+import type { bodyChange, device } from 'node-switchbot'
 
-import type { SwitchBotPlatformConfig } from './settings.js'
+import type { devicesConfig, SwitchBotPlatformConfig } from './settings.js'
+
+import { SwitchBotBLE, SwitchBotOpenAPI } from 'node-switchbot'
 
 import {
   ColorLightAccessory,
@@ -32,14 +35,8 @@ import {
   WindowBlindAccessory,
 } from './devices-matter/index.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { cleanDeviceConfig } from './utils.js'
-
-/**
- * MatterPlatform
- * Demonstrates all available Matter device types in Homebridge
- *
- * Organized by official Matter Specification v1.4.1 categories
- */
+import { cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, hs2rgb, makeBLESender, makeOpenAPISender, rgb2hs, sleep } from './utils.js'
+
 export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   // Track restored HAP cached accessories (required for DynamicPlatformPlugin)
   // This is commented out here as this plugin does not have any HAP accessories
@@ -47,13 +44,52 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
 
   // Track restored Matter cached accessories
   public readonly matterAccessories: Map<string, SerializedMatterAccessory> = new Map()
+  // node-switchbot clients
+  private switchBotAPI?: SwitchBotOpenAPI
+  private switchBotBLE?: SwitchBotBLE
+  // discovered devices cache
+  private discoveredDevices: device[] = []
+  // Registry of created accessory instances keyed by normalized deviceId
+  private accessoryInstances: Map<string, any> = new Map()
+  // Refresh timers keyed by normalized deviceId
+  private refreshTimers: Map<string, NodeJS.Timeout> = new Map()
+  // BLE event handlers keyed by device MAC (formatted)
+  private bleEventHandler: { [x: string]: (context: any) => void } = {}
+  // Platform logging toggle (can be controlled via UI or config)
+  private platformLogging?: boolean
+
+  // Platform-provided logging helpers (attached in constructor)
+  infoLog!: (...args: any[]) => void
+  successLog!: (...args: any[]) => void
+  debugSuccessLog!: (...args: any[]) => void
+  warnLog!: (...args: any[]) => void
+  debugWarnLog!: (...args: any[]) => void
+  errorLog!: (...args: any[]) => void
+  debugErrorLog!: (...args: any[]) => void
+  debugLog!: (...args: any[]) => void
+  loggingIsDebug!: () => Promise<boolean>
+  enablingPlatformLogging!: () => Promise<boolean>
 
   constructor(
     public readonly log: Logging,
     public readonly config: SwitchBotPlatformConfig,
     public readonly api: API,
   ) {
-    this.log.debug('Finished initializing platform:', this.config.name)
+    // Attach platform-wide logging helpers from utils so Matter and device
+    // classes can use consistent logging methods (infoLog/debugLog/etc.)
+    const _pl = createPlatformLogger(async () => (this as any).platformLogging, this.log)
+    this.infoLog = _pl.infoLog
+    this.successLog = _pl.successLog
+    this.debugSuccessLog = _pl.debugSuccessLog
+    this.warnLog = _pl.warnLog
+    this.debugWarnLog = _pl.debugWarnLog
+    this.errorLog = _pl.errorLog
+    this.debugErrorLog = _pl.debugErrorLog
+    this.debugLog = _pl.debugLog
+    this.loggingIsDebug = _pl.loggingIsDebug
+    this.enablingPlatformLogging = _pl.enablingPlatformLogging
+
+    this.debugLog('Finished initializing platform:', this.config.name)
 
     // Normalize deviceConfig to remove UI-inserted defaults
     try {
@@ -66,12 +102,12 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
         }
       }
     } catch (e) {
-      this.log.debug('Failed to clean deviceConfig: %s', e)
+      this.debugLog('Failed to clean deviceConfig: %s', e)
     }
 
     // Does the user have a version of Homebridge that is compatible with matter?
     if (!this.api.isMatterAvailable?.()) {
-      this.log.warn('Matter is not available in this version of Homebridge. Please update Homebridge to use this plugin.')
+      this.warnLog('Matter is not available in this version of Homebridge. Please update Homebridge to use this plugin.')
     }
 
     // Check if the user has matter enabled, this means:
@@ -80,17 +116,1120 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     // In reality, only the below check is needed, but they are both included here for completeness
     // Remember to use a '?.' optional chaining operator in case the user is running an older version of Homebridge that does not have these APIs
     if (!this.api.isMatterEnabled?.()) {
-      this.log.warn('Matter is not enabled in Homebridge. Please enable Matter in the Homebridge settings to use this plugin.')
+      this.warnLog('Matter is not enabled in Homebridge. Please enable Matter in the Homebridge settings to use this plugin.')
       return
     }
 
     // Register Matter accessories when Homebridge has finished launching
     this.api.on('didFinishLaunching', () => {
-      this.log.debug('Executed didFinishLaunching callback')
-      this.registerMatterAccessories()
+      this.debugLog('Executed didFinishLaunching callback')
+      // Initialize SwitchBot API clients
+      try {
+        if (this.config.credentials?.token && this.config.credentials?.secret) {
+          this.switchBotAPI = new SwitchBotOpenAPI(this.config.credentials.token, this.config.credentials.secret, this.config.options?.hostname)
+          // forward basic logs
+          if (!this.config.options?.disableLogsforOpenAPI && this.switchBotAPI?.on) {
+            this.switchBotAPI.on('log', (l: any) => this.debugLog('[SwitchBot OpenAPI]', l.message))
+          }
+        } else {
+          this.debugLog('SwitchBot OpenAPI credentials not provided; cloud devices will be skipped')
+        }
+      } catch (e: any) {
+        this.errorLog('Failed to initialize SwitchBot OpenAPI:', e?.message ?? e)
+      }
+
+      try {
+        this.switchBotBLE = new SwitchBotBLE()
+        if (!this.config.options?.disableLogsforBLE && this.switchBotBLE?.on) {
+          this.switchBotBLE.on('log', (l: any) => this.debugLog('[SwitchBot BLE]', l.message))
+        }
+      } catch (e: any) {
+        this.errorLog('Failed to initialize SwitchBot BLE client:', e?.message ?? e)
+      }
+
+      // If BLE scanning is enabled, start scanning and route advertisements to registered handlers
+      if (this.config.options?.BLE && this.switchBotBLE) {
+        const ble = this.switchBotBLE
+        ;(async () => {
+          try {
+            await ble.startScan()
+          } catch (e: any) {
+            this.errorLog(`Failed to start BLE scanning: ${e?.message ?? e}`)
+          }
+
+          // route advertisements to our handlers
+          ble.onadvertisement = async (ad: any) => {
+            try {
+              const mac = (ad.address || '').toLowerCase()
+              const handler = this.bleEventHandler[mac]
+              if (handler) {
+                await handler(ad.serviceData)
+              }
+            } catch (e: any) {
+              this.errorLog(`Failed to handle BLE advertisement: ${e?.message ?? e}`)
+            }
+          }
+        })()
+      }
+
+      // Ensure we clean up any per-device timers and BLE handlers when Homebridge shuts down
+      this.api.on('shutdown', async () => {
+        try {
+          this.infoLog('Homebridge shutting down: clearing refresh timers and BLE handlers')
+          // Clear all refresh timers
+          for (const [nid, t] of Array.from(this.refreshTimers.entries())) {
+            try {
+              clearInterval(t)
+            } catch (e: any) {
+              this.debugLog(`Failed to clear timer for ${nid}: ${e?.message ?? e}`)
+            }
+            this.refreshTimers.delete(nid)
+          }
+
+          // Clear accessory instances registry
+          try {
+            this.accessoryInstances.clear()
+          } catch (e: any) {
+            this.debugLog(`Failed to clear accessoryInstances: ${e?.message ?? e}`)
+          }
+
+          // Remove BLE handlers
+          try {
+            for (const k of Object.keys(this.bleEventHandler)) {
+              delete this.bleEventHandler[k]
+            }
+          } catch (e: any) {
+            this.debugLog(`Failed to clear bleEventHandler: ${e?.message ?? e}`)
+          }
+
+          // Stop BLE scanning if available
+          try {
+            if (this.switchBotBLE && typeof (this.switchBotBLE as any).stopScan === 'function') {
+              await (this.switchBotBLE as any).stopScan()
+              this.infoLog('Stopped BLE scanning')
+            }
+          } catch (e: any) {
+            this.debugLog(`Failed to stop BLE scanning: ${e?.message ?? e}`)
+          }
+        } catch (e: any) {
+          this.debugLog('Shutdown cleanup failed: %s', e?.message ?? e)
+        }
+      })
+
+      // perform device discovery from SwitchBot OpenAPI (if configured) and
+      // register Matter accessories after discovery completes. Previously we
+      // called discoverDevices() without awaiting it which caused registration
+      // to run before discovery finished and only example accessories were
+      // created. Use an async IIFE to sequentially await discovery then register.
+      ;(async () => {
+        try {
+          await this.discoverDevices()
+        } catch (e: any) {
+          this.debugLog('Device discovery failed during startup: %s', e?.message ?? e)
+        }
+
+        try {
+          await this.registerMatterAccessories()
+        } catch (e: any) {
+          this.errorLog('Failed to register Matter accessories: %s', e?.message ?? e)
+        }
+      })()
     })
   }
 
+  /**
+   * Normalize a deviceId for matching (uppercase alphanumerics only)
+   */
+  private normalizeDeviceId(deviceId: string) {
+    return (deviceId ?? '').toUpperCase().replace(/[^A-Z0-9]+/g, '')
+  }
+
+  /**
+   * Clear per-device resources: refresh timers, accessory instance registry, BLE handlers
+   */
+  private clearDeviceResources(deviceId?: string) {
+    if (!deviceId) {
+      return
+    }
+    try {
+      const nid = this.normalizeDeviceId(deviceId)
+      const existing = this.refreshTimers.get(nid)
+      if (existing) {
+        try {
+          clearInterval(existing)
+        } catch (e: any) {
+          this.debugLog(`Failed to clear refresh timer for ${deviceId}: ${e?.message ?? e}`)
+        }
+        this.refreshTimers.delete(nid)
+      }
+
+      try {
+        this.accessoryInstances.delete(nid)
+      } catch (e: any) {
+        this.debugLog(`Failed to delete accessory instance for ${deviceId}: ${e?.message ?? e}`)
+      }
+
+      try {
+        const mac = formatDeviceIdAsMac(deviceId).toLowerCase()
+        if (this.bleEventHandler[mac]) {
+          delete this.bleEventHandler[mac]
+        }
+      } catch (e: any) {
+        // formatting failed (not a MAC-like id) — ignore
+        this.debugLog(`clearDeviceResources: failed to remove BLE handler for ${deviceId}: ${e?.message ?? e}`)
+      }
+    } catch (e: any) {
+      this.debugLog(`clearDeviceResources top-level error for ${deviceId}: ${e?.message ?? e}`)
+    }
+  }
+
+  /**
+   * Merge two arrays by deviceId. For each item in a1 (user-provided devices list),
+   * find matching item in a2 (discovered devices) and merge them with user overrides last.
+   */
+  private mergeByDeviceId(a1: { deviceId: string }[], a2: any[]) {
+    const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
+    const result: any[] = []
+    for (const itm of (a1 || [])) {
+      const matchingItem = (a2 || []).find(item => this.normalizeDeviceId(item.deviceId) === this.normalizeDeviceId(itm.deviceId))
+      if (matchingItem) {
+        result.push(Object.assign({}, matchingItem, itm))
+      } else if (allowConfigOnly) {
+        // include config-only device as-is when explicitly allowed
+        result.push(Object.assign({}, itm))
+      }
+      // otherwise skip config-only entries
+    }
+    return result
+  }
+
+  /**
+   * Merge discovered devices with deviceConfig (per deviceType) and per-device overrides
+   * from `config.options.devices`, matching the behavior used in platform-hap.
+   */
+  private async mergeDiscoveredDevices(discovered: device[]): Promise<any[]> {
+    // If there's no device config or per-device config, return discovered as-is
+    if (!this.config.options?.devices && !this.config.options?.deviceConfig) {
+      return discovered
+    }
+
+    // Step 1: Assign missing deviceType from configDeviceType and merge deviceType-level configs
+    const devicesWithTypeConfig = await Promise.all(discovered.map(async (deviceObj) => {
+      if (!deviceObj.deviceType) {
+        deviceObj.deviceType = (deviceObj as any).configDeviceType !== undefined ? (deviceObj as any).configDeviceType : 'Unknown'
+        this.debugLog(`API missing deviceType for ${deviceObj.deviceId}, using configDeviceType: ${(deviceObj as any).configDeviceType}`)
+      }
+      const deviceTypeConfig = this.config.options?.deviceConfig?.[deviceObj.deviceType] || {}
+      return Object.assign({}, deviceObj, deviceTypeConfig)
+    }))
+
+    // Merge per-device overrides by matching deviceId
+    const merged = this.mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTypeConfig ?? [])
+
+    // For any entries in merged (which are based on config.options.devices), ensure final per-device merges include deviceId-specific config
+    const final: any[] = []
+    for (const device of merged) {
+      // Find per-device config entry by deviceId (config.options.devices is an array)
+      const deviceIdConfig = (this.config.options?.devices || []).find((d: any) => this.normalizeDeviceId(d.deviceId) === this.normalizeDeviceId(device.deviceId)) || {}
+      const deviceWithConfig = Object.assign({}, device, deviceIdConfig)
+      final.push(deviceWithConfig)
+    }
+
+    // Also include any discovered devices that weren't present in the user devices list
+    const userDeviceIds = new Set((this.config.options?.devices || []).map((d: any) => this.normalizeDeviceId(d.deviceId)))
+    for (const d of devicesWithTypeConfig) {
+      if (!userDeviceIds.has(this.normalizeDeviceId(d.deviceId))) {
+        final.push(d)
+      }
+    }
+
+    return final
+  }
+
+  /**
+   * Select effective connection type for a device: prefer explicit device.connectionType,
+   * otherwise prefer BLE when platform BLE is enabled and device provides a BLE model/id.
+   */
+  private chooseConnectionType(deviceObj: any): 'BLE' | 'OpenAPI' {
+    if (deviceObj?.connectionType) {
+      return deviceObj.connectionType === 'BLE' ? 'BLE' : 'OpenAPI'
+    }
+    // If platform BLE is enabled and we have a bleModel or deviceId that formats to a MAC, prefer BLE
+    if (this.config.options?.BLE && (deviceObj?.bleModel || formatDeviceIdAsMac(deviceObj?.deviceId))) {
+      return 'BLE'
+    }
+    return 'OpenAPI'
+  }
+
+  /**
+   * Map a SwitchBot device object to a MatterAccessory using the device-specific
+   * Matter accessory classes in `src/devices-matter`.
+   */
+  private async createAccessoryFromDevice(dev: device & devicesConfig): Promise<MatterAccessory<Record<string, unknown>> | undefined> {
+    // Basic metadata
+    const displayName = dev.deviceName ?? dev.deviceId ?? 'SwitchBot Device'
+    const serial = dev.deviceId ?? 'unknown'
+    const manufacturer = 'SwitchBot'
+    const model = dev.model ?? dev.deviceType ?? 'SwitchBot'
+    const firmware = (dev as any).firmware ?? (dev as any).version ?? '0.0.0'
+
+    // Helper to build a default opts object consumed by the matter device classes
+    const baseOpts = {
+      uuid: this.api.matter.uuid.generate(serial),
+      displayName,
+      serialNumber: serial,
+      manufacturer,
+      model,
+      firmwareRevision: String(firmware),
+      hardwareRevision: '1.0.0',
+      deviceId: dev.deviceId,
+      // Inject handy platform-side helpers into the accessory `context` so Matter
+      // accessory classes can perform OpenAPI/BLE actions without reaching into
+      // the platform implementation directly.
+      context: {
+        deviceId: dev.deviceId,
+        // Expose the display name so Matter accessory classes can read it from context
+        name: displayName,
+        // Provide device-level logging override (if present) and platform logging flag
+        // so accessories can decide how verbose they should be.
+        deviceLogging: (dev as any)?.logging,
+        platformLogging: this.platformLogging,
+      },
+    }
+
+    // Build platform-side helpers using shared factories so they can be reused/tested
+    const sendOpenAPI = makeOpenAPISender(this.retryCommand.bind(this), dev, { maxRetries: this.config.options?.maxRetries ?? 1, delayBetweenRetries: this.config.options?.delayBetweenRetries ?? 1000 })
+    const sendBLE = makeBLESender(this.switchBotBLE, dev, { bleRetries: (this.config.options as any)?.bleRetries ?? 2, bleRetryDelay: (this.config.options as any)?.bleRetryDelay ?? 500 })
+
+    // Log that we're initializing this device so it's visible in startup logs
+    try {
+      this.infoLog(`Initializing Matter device: ${displayName} (type=${dev.deviceType ?? 'Unknown'}) id=${dev.deviceId}`)
+    } catch (e: any) {
+      // best-effort logging — swallow errors to avoid breaking initialization
+      this.debugLog('Failed to log initializing device:', e?.message ?? e)
+    }
+
+    const makeOnOffHandlers = (uuid: string, connectionType: 'BLE' | 'OpenAPI') => ({
+      onOff: {
+        on: async () => {
+          try {
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('turnOn')
+            } else {
+              await sendOpenAPI('turnOn')
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.OnOff, { onOff: true })
+          } catch (e: any) {
+            this.errorLog(`Failed to turn on device ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+        off: async () => {
+          try {
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('turnOff')
+            } else {
+              await sendOpenAPI('turnOff')
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.OnOff, { onOff: false })
+          } catch (e: any) {
+            this.errorLog(`Failed to turn off device ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+      },
+    })
+
+    // Mapping from SwitchBot deviceType -> constructor (expanded for parity with HAP)
+    const mapping: { [key: string]: any } = {
+      // Plugs / Outlets
+      'Plug': OnOffOutletAccessory,
+      'Plug Mini (US)': OnOffOutletAccessory,
+      'Plug Mini (JP)': OnOffOutletAccessory,
+      'Plug Mini': OnOffOutletAccessory,
+      'WoPlug': OnOffOutletAccessory,
+
+      // Lighting
+      'Color Bulb': ColorLightAccessory,
+      'Color Bulb Mini': ColorLightAccessory,
+      'Ceiling Light': ColorTemperatureLightAccessory,
+      'Ceiling Light Pro': ColorTemperatureLightAccessory,
+      'Strip Light': ExtendedColorLightAccessory,
+      'Light Strip': ExtendedColorLightAccessory,
+      'Light Strip Plus': ExtendedColorLightAccessory,
+      'Strip Light Pro': ExtendedColorLightAccessory,
+      'Dimmable Light': DimmableLightAccessory,
+
+      // Robot Vacuums
+      'K10+': RoboticVacuumAccessory,
+      'K10+ Pro': RoboticVacuumAccessory,
+      'WoSweeper': RoboticVacuumAccessory,
+      'WoSweeperMini': RoboticVacuumAccessory,
+      'Robot Vacuum Cleaner S1': RoboticVacuumAccessory,
+      'Robot Vacuum Cleaner S1 Plus': RoboticVacuumAccessory,
+      'Robot Vacuum Cleaner S10': RoboticVacuumAccessory,
+      'Robot Vacuum Cleaner S1 Pro': RoboticVacuumAccessory,
+      'Robot Vacuum Cleaner S1 Mini': RoboticVacuumAccessory,
+
+      // Locks
+      'Smart Lock': DoorLockAccessory,
+      'Smart Lock Pro': DoorLockAccessory,
+
+      // Sensors
+      'Motion Sensor': OccupancySensorAccessory,
+      'Contact Sensor': ContactSensorAccessory,
+      'Water Detector': LeakSensorAccessory,
+      'Meter': TemperatureSensorAccessory,
+      'MeterPlus': TemperatureSensorAccessory,
+      'MeterPro': TemperatureSensorAccessory,
+      'WoIOSensor': TemperatureSensorAccessory,
+      'Air Purifier PM2.5': HumiditySensorAccessory,
+      'Air Purifier Table PM2.5': HumiditySensorAccessory,
+      'Air Purifier': HumiditySensorAccessory,
+      'Air Purifier VOC': HumiditySensorAccessory,
+      'Air Purifier Table VOC': HumiditySensorAccessory,
+
+      // Fans
+      'Battery Circulator Fan': FanAccessory,
+
+      // Curtains / Blinds
+      'Blind Tilt': VenetianBlindAccessory,
+      'Curtain': WindowBlindAccessory,
+      'Curtain2': WindowBlindAccessory,
+      'Curtain3': WindowBlindAccessory,
+      'Curtain 2': WindowBlindAccessory,
+      'WoRollerShade': WindowBlindAccessory,
+      'Roller Shade': WindowBlindAccessory,
+      'Venetian Blind': VenetianBlindAccessory,
+
+      // Switches / Relays
+      'Relay Switch 1': OnOffSwitchAccessory,
+      'Relay Switch 1PM': OnOffSwitchAccessory,
+      'Relay Switch 2': OnOffSwitchAccessory,
+      'Relay Switch 3': OnOffSwitchAccessory,
+
+      // Misc / hubs / other
+      'Hub 2': undefined,
+      'Hub 3': undefined,
+      'Hub Mini': undefined,
+      'Bot': OnOffSwitchAccessory,
+      'Smart Bot': OnOffSwitchAccessory,
+      'Humidifier': HumiditySensorAccessory,
+      'Humidifier2': HumiditySensorAccessory,
+      'Thermostat': ThermostatAccessory,
+      'Water Heater': ThermostatAccessory,
+    }
+
+    const Ctor = mapping[dev.deviceType ?? '']
+    if (!Ctor) {
+      this.debugLog(`No Matter mapping for deviceType='${dev.deviceType}', deviceId=${dev.deviceId}`)
+      return undefined
+    }
+
+    // Build opts and handlers tailored for basic capabilities
+    const uuid = baseOpts.uuid
+    const handlers: Record<string, any> = {}
+
+    // Choose connection type for this device (BLE vs OpenAPI)
+    const connectionType = this.chooseConnectionType(dev)
+
+    // On/Off common
+    handlers.onOff = makeOnOffHandlers(uuid, connectionType).onOff
+
+    // If this is a light, add brightness and color handlers
+    if (['Color Bulb', 'Ceiling Light', 'Ceiling Light Pro', 'Strip Light', 'Dimmable Light'].includes(dev.deviceType ?? '')) {
+      // levelControl
+      handlers.levelControl = {
+        moveToLevelWithOnOff: async (request: any) => {
+          try {
+            const level = request.level as number
+            const percent = Math.round((level / 254) * 100)
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('setBrightness', percent)
+            } else {
+              await sendOpenAPI('setBrightness', `${percent}`)
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.LevelControl, { currentLevel: level })
+          } catch (e: any) {
+            this.errorLog(`Failed to set brightness for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+      }
+
+      // colorControl
+      handlers.colorControl = {
+        moveToHueAndSaturationLogic: async (request: any) => {
+          try {
+            const hue = request.hue as number
+            const saturation = request.saturation as number
+            const [r, g, b] = hs2rgb(Math.round((hue / 254) * 360), Math.round((saturation / 254) * 100))
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('setRGB', Number(request.level ?? 100), r, g, b)
+            } else {
+              await sendOpenAPI('setColor', `${r}:${g}:${b}`)
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.ColorControl, { currentHue: hue, currentSaturation: saturation })
+          } catch (e: any) {
+            this.errorLog(`Failed to set hue/sat for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+        moveToColorLogic: async (request: any) => {
+          try {
+            // MoveToColor gives colorX/colorY values; convert to approximate RGB by mapping to 0-255 scale
+            const colorX = request.colorX as number
+            const colorY = request.colorY as number
+            // Naive conversion: map X/Y into RGB via hue approximation (not colorimetrically accurate)
+            const hueApprox = Math.round((colorX / 65535) * 360)
+            const satApprox = Math.round((colorY / 65535) * 100)
+            const [r, g, b] = hs2rgb(hueApprox, satApprox)
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('setRGB', Number(request.level ?? 100), r, g, b)
+            } else {
+              await sendOpenAPI('setColor', `${r}:${g}:${b}`)
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.ColorControl, { currentX: colorX, currentY: colorY })
+          } catch (e: any) {
+            this.errorLog(`Failed to set XY color for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+      }
+
+      // color temperature — map to kelvin and send setColorTemperature
+      handlers.colorTemperature = {
+        moveToColorTemperature: async (request: any) => {
+          try {
+            const kelvin = Math.round(1000000 / Number(request.colorTemperature))
+            if (connectionType === 'BLE' && this.switchBotBLE) {
+              await sendBLE('setColorTemperature', kelvin)
+            } else {
+              await sendOpenAPI('setColorTemperature', `${kelvin}`)
+            }
+            await this.api.matter.updateAccessoryState(uuid, this.api.matter.clusterNames.ColorControl, { currentX: request.colorX ?? 0, currentY: request.colorY ?? 0 })
+          } catch (e: any) {
+            this.errorLog(`Failed to set color temperature for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        },
+      }
+    }
+
+    // Expose platform helpers to the accessory via context so accessory
+    // classes can call OpenAPI/BLE actions (sendOpenAPI/sendBLE) and know
+    // the effective connection type.
+    try {
+      /* Inject platform helpers (OpenAPI/BLE senders + logging helpers + connection type)
+         into the accessory context so Matter accessory classes can use them without
+         reaching into the platform implementation directly. */
+      ;(baseOpts as any).context = Object.assign({}, (baseOpts as any).context, {
+        sendOpenAPI,
+        sendBLE,
+        connectionType,
+        // Expose platform logging helpers so accessories can use consistent logging
+        infoLog: this.infoLog,
+        debugLog: this.debugLog,
+        warnLog: this.warnLog,
+        errorLog: this.errorLog,
+        successLog: this.successLog,
+      })
+    } catch (e: any) {
+      this.debugLog('Failed to attach platform helpers to baseOpts.context: %s', e?.message ?? e)
+    }
+
+    const opts = Object.assign({}, baseOpts, { handlers })
+
+    // Instantiate the device class and return its serialized accessory
+    const instance = new Ctor(this.api, this.log, opts)
+    // Save instance in registry so platform can call device-specific update methods if needed
+    try {
+      if (dev?.deviceId) {
+        this.accessoryInstances.set(this.normalizeDeviceId(dev.deviceId), instance)
+      }
+    } catch (e: any) {
+      this.debugLog('Failed to register accessory instance: %s', e?.message ?? e)
+    }
+    try {
+      this.infoLog(`Initialized Matter accessory: ${displayName} (type=${dev.deviceType ?? 'Unknown'}) id=${dev.deviceId}`)
+    } catch (e: any) {
+      this.debugLog('Failed to log initialized accessory:', e?.message ?? e)
+    }
+
+    // Register BLE->Matter push handler for this device's MAC (if BLE scanning is active)
+    try {
+      const mac = formatDeviceIdAsMac(dev.deviceId).toLowerCase()
+      // Handler receives advertisement/serviceData when BLE scan events arrive
+      this.bleEventHandler[mac] = async (serviceData?: any) => {
+        const uuidLocal = baseOpts.uuid
+
+        // First try model-specific / normalized parsing of BLE advertisement
+        try {
+          const parsed = this.parseAdvertisementForDevice(dev, serviceData)
+          if (parsed) {
+            // Power
+            if (parsed.power !== undefined) {
+              await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.OnOff, { onOff: Boolean(parsed.power) })
+            }
+
+            // Brightness
+            if (parsed.brightness !== undefined) {
+              const level = Math.round((Number(parsed.brightness) / 100) * 254)
+              await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.LevelControl, { currentLevel: level })
+            }
+
+            // Color
+            if (parsed.color !== undefined) {
+              const { r, g, b } = parsed.color
+              const [h, s] = rgb2hs(r, g, b)
+              await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.ColorControl, { currentHue: Math.round((h / 360) * 254), currentSaturation: Math.round((s / 100) * 254) })
+            }
+
+            // Battery -> powerSource cluster (common mapping)
+            if (parsed.battery !== undefined) {
+              try {
+                const percentage = Number(parsed.battery)
+                const batPercentRemaining = Math.max(0, Math.min(200, Math.round(percentage * 2)))
+                let batChargeLevel = 0
+                if (percentage < 20) {
+                  batChargeLevel = 2
+                } else if (percentage < 40) {
+                  batChargeLevel = 1
+                }
+                await this.api.matter.updateAccessoryState(uuidLocal, 'powerSource', { batPercentRemaining, batChargeLevel })
+              } catch (e: any) {
+                this.debugLog(`Failed to update battery state for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Temperature -> temperatureMeasurement
+            if (parsed.temperature !== undefined) {
+              try {
+                const c = Number(parsed.temperature)
+                const measured = Math.round(c * 100)
+                await this.api.matter.updateAccessoryState(uuidLocal, 'temperatureMeasurement', { measuredValue: measured })
+              } catch (e: any) {
+                this.debugLog(`Failed to update temperature for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Humidity -> relativeHumidityMeasurement
+            if (parsed.humidity !== undefined) {
+              try {
+                const percent = Number(parsed.humidity)
+                const measured = Math.round(percent * 100)
+                await this.api.matter.updateAccessoryState(uuidLocal, 'relativeHumidityMeasurement', { measuredValue: measured })
+              } catch (e: any) {
+                this.debugLog(`Failed to update humidity for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Contact / Leak -> BooleanState
+            if (parsed.contact !== undefined || parsed.leak !== undefined) {
+              try {
+                // Some devices report contact as true=open; ContactSensor expects inverted value
+                const isContactOpen = parsed.contact === undefined ? undefined : Boolean(parsed.contact)
+                const leakDetected = parsed.leak === undefined ? undefined : Boolean(parsed.leak)
+
+                if (isContactOpen !== undefined) {
+                  // If this is a contact sensor device type, invert; otherwise set conservatively
+                  if ((dev.deviceType || '').includes('Contact')) {
+                    await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.BooleanState, { stateValue: !isContactOpen })
+                  } else {
+                    await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.BooleanState, { stateValue: isContactOpen })
+                  }
+                }
+
+                if (leakDetected !== undefined) {
+                  await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.BooleanState, { stateValue: leakDetected })
+                }
+              } catch (e: any) {
+                this.debugLog(`Failed to update contact/leak for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Motion -> occupancy
+            if (parsed.motion !== undefined) {
+              try {
+                await this.api.matter.updateAccessoryState(uuidLocal, 'occupancySensing', { occupancy: { occupied: Boolean(parsed.motion) } })
+              } catch (e: any) {
+                this.debugLog(`Failed to update occupancy for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Lock state -> doorLock
+            if (parsed.lock !== undefined) {
+              try {
+                const s = String(parsed.lock).toLowerCase()
+                let lockState = 0
+                if (s === 'locked' || s === '1' || s === 'true') {
+                  lockState = 1
+                } else if (s === 'unlocked' || s === '0' || s === 'false') {
+                  lockState = 2
+                }
+                await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.DoorLock, { lockState })
+              } catch (e: any) {
+                this.debugLog(`Failed to update lock for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Position / Cover -> WindowCovering (convert open percent to closed*100)
+            if (parsed.position !== undefined) {
+              try {
+                const openPercent = Number(parsed.position)
+                const closedPercent = 100 - Math.max(0, Math.min(100, openPercent))
+                const value = Math.round(closedPercent * 100)
+                await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.WindowCovering, { currentPositionLiftPercent100ths: value, targetPositionLiftPercent100ths: value })
+              } catch (e: any) {
+                this.debugLog(`Failed to update cover position for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Fan speed -> FanControl
+            if (parsed.fanSpeed !== undefined) {
+              try {
+                const percent = Number(parsed.fanSpeed)
+                await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.FanControl, { percentSetting: percent, percentCurrent: percent })
+              } catch (e: any) {
+                this.debugLog(`Failed to update fan speed for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // Robot vacuum fields (battery already handled) - update run/operational/clean modes when present
+            if (parsed.rvcRunMode !== undefined) {
+              try {
+                await this.api.matter.updateAccessoryState(uuidLocal, 'rvcRunMode', { currentMode: Number(parsed.rvcRunMode) })
+              } catch (e: any) {
+                this.debugLog(`Failed to update rvcRunMode for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            if (parsed.rvcOperationalState !== undefined) {
+              try {
+                await this.api.matter.updateAccessoryState(uuidLocal, 'rvcOperationalState', { operationalState: Number(parsed.rvcOperationalState) })
+              } catch (e: any) {
+                this.debugLog(`Failed to update rvcOperationalState for ${dev.deviceId}: ${e?.message ?? e}`)
+              }
+            }
+
+            // If we parsed something from serviceData prefer it and return early
+            if (serviceData) {
+              return
+            }
+          }
+        } catch (e: any) {
+          this.debugLog(`BLE advertisement parsing failed for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+
+        // Fallback to OpenAPI getDeviceStatus when serviceData is not present or parsing failed
+        if (!this.switchBotAPI) {
+          return
+        }
+        try {
+          const { response, statusCode } = await this.switchBotAPI.getDeviceStatus(dev.deviceId, this.config.credentials?.token, this.config.credentials?.secret)
+          if (!(statusCode === 100 || statusCode === 200)) {
+            return
+          }
+          const respAny: any = response
+          const body = respAny?.body ?? respAny
+          const status = body?.status ?? body
+
+          // Use centralized mapper which prefers accessory instance update helpers
+          await this.applyStatusToAccessory(uuidLocal, dev, status)
+        } catch (e: any) {
+          this.debugLog(`BLE push handler failed for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+    } catch (e: any) {
+      this.debugLog(`Failed to register BLE handler for ${dev.deviceId}: ${e?.message ?? e}`)
+    }
+
+    // Schedule periodic OpenAPI refreshes for this device (if OpenAPI is configured)
+    try {
+      const nid = this.normalizeDeviceId(dev.deviceId)
+      // Clear any existing timer for this device
+      const existing = this.refreshTimers.get(nid)
+      if (existing) {
+        clearInterval(existing)
+        this.refreshTimers.delete(nid)
+      }
+
+      const refreshRateSec = dev.refreshRate ?? this.config.options?.refreshRate ?? 300
+      if (this.switchBotAPI && refreshRateSec && Number(refreshRateSec) > 0) {
+        // Immediate one-shot to populate initial state
+        ;(async () => {
+          try {
+            const { response, statusCode } = await this.switchBotAPI!.getDeviceStatus(dev.deviceId, this.config.credentials?.token, this.config.credentials?.secret)
+            if (statusCode === 100 || statusCode === 200) {
+              const respAny: any = response
+              const body = respAny?.body ?? respAny
+              const status = body?.status ?? body
+              await this.applyStatusToAccessory(uuid, dev, status)
+            }
+          } catch (e: any) {
+            this.debugLog(`Initial OpenAPI refresh failed for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        })()
+
+        const timer = setInterval(async () => {
+          try {
+            const { response, statusCode } = await this.switchBotAPI!.getDeviceStatus(dev.deviceId, this.config.credentials?.token, this.config.credentials?.secret)
+            if (statusCode === 100 || statusCode === 200) {
+              const respAny: any = response
+              const body = respAny?.body ?? respAny
+              const status = body?.status ?? body
+              await this.applyStatusToAccessory(uuid, dev, status)
+            }
+          } catch (e: any) {
+            this.debugLog(`Periodic OpenAPI refresh failed for ${dev.deviceId}: ${e?.message ?? e}`)
+          }
+        }, Number(refreshRateSec) * 1000)
+
+        this.refreshTimers.set(nid, timer)
+      }
+    } catch (e: any) {
+      this.debugLog(`Failed to schedule refresh for ${dev.deviceId}: ${e?.message ?? e}`)
+    }
+
+    return instance.toAccessory()
+  }
+
+  /**
+   * Discover devices via SwitchBot OpenAPI and cache them for later use
+   */
+  private async discoverDevices(): Promise<void> {
+    if (!this.switchBotAPI) {
+      this.debugLog('SwitchBot OpenAPI not configured; skipping discovery')
+      return
+    }
+
+    try {
+      const { response, statusCode } = await this.switchBotAPI.getDevices()
+      this.debugLog(`SwitchBot getDevices response status: ${statusCode}`)
+      if (statusCode === 100 || statusCode === 200) {
+        const deviceList = Array.isArray(response?.body?.deviceList) ? response.body.deviceList : []
+        this.discoveredDevices = deviceList
+        this.infoLog(`Discovered ${deviceList.length} SwitchBot device(s) from OpenAPI`)
+        for (const d of deviceList) {
+          this.debugLog(`  - ${d.deviceName} (${d.deviceType}) id=${d.deviceId}`)
+        }
+      } else {
+        this.warnLog(`SwitchBot getDevices returned status ${statusCode}`)
+      }
+    } catch (e: any) {
+      this.errorLog('Failed to discover SwitchBot devices:', e?.message ?? e)
+    }
+  }
+
+  /**
+   * Retry wrapper for control commands using SwitchBot OpenAPI
+   */
+  async retryCommand(deviceObj: device, bodyChange: bodyChange, maxRetries = 1, delayBetweenRetries = 1000): Promise<{ response: any, statusCode: number }> {
+    let retryCount = 0
+    while (retryCount < maxRetries) {
+      try {
+        if (!this.switchBotAPI) {
+          throw new Error('SwitchBot OpenAPI not initialized')
+        }
+        const { response, statusCode } = await this.switchBotAPI.controlDevice(
+          deviceObj.deviceId,
+          bodyChange.command,
+          bodyChange.parameter,
+          bodyChange.commandType as import('node-switchbot').commandType | undefined,
+          this.config.credentials?.token,
+          this.config.credentials?.secret,
+        )
+        return { response, statusCode }
+      } catch (e: any) {
+        this.debugLog(`retryCommand error: ${e?.message ?? e}`)
+      }
+      retryCount++
+
+      await sleep(delayBetweenRetries)
+    }
+    return { response: {}, statusCode: 500 }
+  }
+
+  /**
+   * Parse BLE advertisement/serviceData into normalized fields for a given device.
+   * Returns null when serviceData is falsy or parsing fails.
+   */
+  private parseAdvertisementForDevice(dev: device, serviceData?: any) {
+    if (!serviceData) {
+      return null
+    }
+    try {
+      const sd = serviceData
+      const result: any = {}
+
+      // Power/on state - supports multiple field names used by different models
+      const power = sd.power ?? sd.on ?? sd.p
+      if (power !== undefined) {
+        result.power = (String(power).toLowerCase() === 'on' || Number(power) === 1)
+      }
+
+      // Brightness (0-100)
+      const brightness = sd.brightness ?? sd.b
+      if (brightness !== undefined) {
+        result.brightness = Number(brightness)
+      }
+
+      // Color - could be 'r:g:b', '#rrggbb' or 'rrggbb'
+      const color = sd.color ?? sd.rgb ?? sd.c
+      if (color !== undefined) {
+        let r = 0
+        let g = 0
+        let b = 0
+        const c = String(color)
+        if (c.includes(':')) {
+          const parts = c.split(':').map(Number)
+          ;[r, g, b] = parts
+        } else if (c.includes(',')) {
+          const parts = c.split(',').map(s => Number(s.trim()))
+          ;[r, g, b] = parts
+        } else if (c.includes(' ')) {
+          const parts = c.split(' ').map(s => Number(s.trim()))
+          ;[r, g, b] = parts
+        } else if (c.startsWith('#')) {
+          const hex = c.replace('#', '')
+          r = Number.parseInt(hex.substring(0, 2), 16)
+          g = Number.parseInt(hex.substring(2, 4), 16)
+          b = Number.parseInt(hex.substring(4, 6), 16)
+        } else if (/^[0-9a-f]{6}$/i.test(c)) {
+          r = Number.parseInt(c.substring(0, 2), 16)
+          g = Number.parseInt(c.substring(2, 4), 16)
+          b = Number.parseInt(c.substring(4, 6), 16)
+        }
+        result.color = { r, g, b }
+      }
+
+      // Battery (some devices use battery or batt)
+      const battery = sd.battery ?? sd.batt
+      if (battery !== undefined) {
+        result.battery = Number(battery)
+      }
+
+      return result
+    } catch (e: any) {
+      this.debugLog(`parseAdvertisementForDevice failed for ${dev.deviceId}: ${e?.message ?? e}`)
+      return null
+    }
+  }
+
+  /**
+   * Central helper to apply a SwitchBot status object to a Matter accessory.
+   * Tries to call accessory instance update helpers when available, otherwise
+   * falls back to calling api.matter.updateAccessoryState directly.
+   */
+  private async applyStatusToAccessory(uuidLocal: string, dev: device & devicesConfig, status: any) {
+    if (!status) {
+      return
+    }
+
+    const instance = dev?.deviceId ? this.accessoryInstances.get(this.normalizeDeviceId(dev.deviceId)) : undefined
+
+    // Helper to safely call instance methods or fallback to api.matter.updateAccessoryState
+    const safeUpdate = async (cluster: string, attributes: Record<string, unknown>, methodName?: string) => {
+      try {
+        if (instance && methodName && typeof instance[methodName] === 'function') {
+          // prefer device-specific update helpers when available
+          await instance[methodName](...(Object.values(attributes)))
+        } else if (instance && typeof instance.updateState === 'function') {
+          // some accessories expose updateState that accepts cluster and attributes
+          await instance.updateState(cluster, attributes)
+        } else {
+          await this.api.matter.updateAccessoryState(uuidLocal, cluster, attributes)
+        }
+      } catch (e: any) {
+        this.debugLog(`safeUpdate failed for ${dev.deviceId} cluster=${cluster}: ${e?.message ?? e}`)
+      }
+    }
+
+    try {
+      // On/Off
+      if (status?.power !== undefined) {
+        const on = (String(status.power).toLowerCase() === 'on' || Number(status.power) === 1 || Boolean(status.power) === true)
+        await safeUpdate(this.api.matter.clusterNames.OnOff, { onOff: on }, 'updateOnOffState')
+      }
+
+      // Brightness
+      if (status?.brightness !== undefined) {
+        const level = Math.round((Number(status.brightness) / 100) * 254)
+        await safeUpdate(this.api.matter.clusterNames.LevelControl, { currentLevel: level }, 'updateBrightness')
+      }
+
+      // Color
+      if (status?.color !== undefined) {
+        const color = String(status.color)
+        let r = 0
+        let g = 0
+        let b = 0
+        if (color.includes(':')) {
+          const parts = color.split(':').map(Number)
+          ;[r, g, b] = parts
+        } else if (color.includes(',')) {
+          const parts = color.split(',').map(s => Number(s.trim()))
+          ;[r, g, b] = parts
+        } else if (color.includes(' ')) {
+          const parts = color.split(' ').map(s => Number(s.trim()))
+          ;[r, g, b] = parts
+        } else if (color.startsWith('#')) {
+          const hex = color.replace('#', '')
+          r = Number.parseInt(hex.substring(0, 2), 16)
+          g = Number.parseInt(hex.substring(2, 4), 16)
+          b = Number.parseInt(hex.substring(4, 6), 16)
+        }
+        const [h, s] = rgb2hs(r, g, b)
+        await safeUpdate(this.api.matter.clusterNames.ColorControl, { currentHue: Math.round((h / 360) * 254), currentSaturation: Math.round((s / 100) * 254) }, 'updateHueSaturation')
+      }
+
+      // Battery/powerSource (support many possible field names)
+      if (status?.battery !== undefined || status?.batt !== undefined || status?.batteryLevel !== undefined || status?.batteryPercentage !== undefined || status?.battery_level !== undefined) {
+        try {
+          const percentage = Number(status?.battery ?? status?.batt ?? status?.batteryPercentage ?? status?.batteryLevel ?? status?.battery_level)
+          const batPercentRemaining = Math.max(0, Math.min(200, Math.round(percentage * 2)))
+          let batChargeLevel = 0
+          if (percentage < 20) {
+            batChargeLevel = 2
+          } else if (percentage < 40) {
+            batChargeLevel = 1
+          }
+          const powerCluster = (this.api.matter?.clusterNames && (this.api.matter.clusterNames as any).PowerSource) ? (this.api.matter.clusterNames as any).PowerSource : 'powerSource'
+          await safeUpdate(powerCluster, { batPercentRemaining, batChargeLevel }, 'updateBatteryPercentage')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply battery status for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Temperature + thermostat
+      if (status?.temperature !== undefined || status?.temp !== undefined) {
+        try {
+          const c = Number(status?.temperature ?? status?.temp)
+          const measured = Math.round(c * 100)
+          await safeUpdate('temperatureMeasurement', { measuredValue: measured }, 'updateTemperature')
+          // Thermostat-specific mapping
+          if (status?.targetTemp !== undefined || status?.targetTemperature !== undefined || status?.heatingSetpoint !== undefined) {
+            const target = Number(status?.targetTemp ?? status?.targetTemperature ?? status?.heatingSetpoint)
+            const val = Math.round(target * 100)
+            await safeUpdate('thermostat', { occupiedHeatingSetpoint: val }, 'updateHeatingSetpoint')
+          }
+        } catch (e: any) {
+          this.debugLog(`Failed to apply temperature for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Humidity (support different keys)
+      if (status?.humidity !== undefined || status?.h !== undefined || status?.humid !== undefined) {
+        try {
+          const percent = Number(status?.humidity ?? status?.h ?? status?.humid)
+          const measured = Math.round(percent * 100)
+          await safeUpdate('relativeHumidityMeasurement', { measuredValue: measured }, 'updateHumidity')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply humidity for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Contact / Leak -> BooleanState
+      if (status?.contact !== undefined || status?.open !== undefined || status?.leak !== undefined || status?.water !== undefined) {
+        try {
+          const isContactOpen = status?.contact ?? status?.open
+          if (isContactOpen !== undefined) {
+            if ((dev.deviceType || '').includes('Contact')) {
+              await safeUpdate(this.api.matter.clusterNames.BooleanState, { stateValue: !(String(isContactOpen).toLowerCase() === 'true' || Number(isContactOpen) === 1) }, 'updateContactState')
+            } else {
+              await safeUpdate(this.api.matter.clusterNames.BooleanState, { stateValue: (String(isContactOpen).toLowerCase() === 'true' || Number(isContactOpen) === 1) }, 'updateContactState')
+            }
+          }
+          const leakDetected = status?.leak ?? status?.water
+          if (leakDetected !== undefined) {
+            await safeUpdate(this.api.matter.clusterNames.BooleanState, { stateValue: Boolean(leakDetected) }, 'updateLeakState')
+          }
+        } catch (e: any) {
+          this.debugLog(`Failed to apply contact/leak for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Motion -> occupancy
+      if (status?.motion !== undefined || status?.m !== undefined) {
+        try {
+          const detected = Boolean(status?.motion ?? status?.m)
+          await safeUpdate('occupancySensing', { occupancy: { occupied: detected } }, 'updateOccupancy')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply motion for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Lock state
+      if (status?.lock !== undefined) {
+        try {
+          const s = String(status.lock).toLowerCase()
+          let lockState = 0
+          if (s === 'locked' || s === '1' || s === 'true') {
+            lockState = 1
+          } else if (s === 'unlocked' || s === '0' || s === 'false') {
+            lockState = 2
+          }
+          await safeUpdate(this.api.matter.clusterNames.DoorLock, { lockState }, 'updateLockState')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply lock for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Cover position
+      if (status?.position !== undefined || status?.percent !== undefined) {
+        try {
+          const openPercent = Number(status?.position ?? status?.percent)
+          const closedPercent = 100 - Math.max(0, Math.min(100, openPercent))
+          const value = Math.round(closedPercent * 100)
+          await safeUpdate(this.api.matter.clusterNames.WindowCovering, { currentPositionLiftPercent100ths: value, targetPositionLiftPercent100ths: value }, 'updateLiftPosition')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply cover position for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Fan
+      if (status?.fanSpeed !== undefined || status?.speed !== undefined) {
+        try {
+          const percent = Number(status?.fanSpeed ?? status?.speed)
+          await safeUpdate(this.api.matter.clusterNames.FanControl, { percentSetting: percent, percentCurrent: percent }, 'updateFanSpeed')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply fan speed for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Robot vacuum: run/operational/clean modes
+      if (status?.rvcRunMode !== undefined) {
+        try {
+          await safeUpdate('rvcRunMode', { currentMode: Number(status.rvcRunMode) }, 'updateRunMode')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply rvcRunMode for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+      // CO2 (carbon dioxide) - support common synonyms
+      if (status?.co2 !== undefined || status?.co2ppm !== undefined || status?.carbonDioxide !== undefined) {
+        try {
+          const val = Number(status?.co2 ?? status?.co2ppm ?? status?.carbonDioxide)
+          await safeUpdate('carbonDioxide', { carbonDioxideLevel: val }, 'updateCO2')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply CO2 for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // PM2.5 / particulate matter
+      if (status?.pm2_5 !== undefined || status?.pm25 !== undefined || status?.pm_2_5 !== undefined) {
+        try {
+          const pm = Number(status?.pm2_5 ?? status?.pm25 ?? status?.pm_2_5)
+          await safeUpdate('pm2_5', { pm25: pm }, 'updatePM25')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply PM2.5 for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+      if (status?.rvcOperationalState !== undefined) {
+        try {
+          await safeUpdate('rvcOperationalState', { operationalState: Number(status.rvcOperationalState) }, 'updateOperationalState')
+        } catch (e: any) {
+          this.debugLog(`Failed to apply rvcOperationalState for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+    } catch (e: any) {
+      this.debugLog(`applyStatusToAccessory top-level failure for ${dev.deviceId}: ${e?.message ?? e}`)
+    }
+  }
+
   /**
    * Required for DynamicPlatformPlugin
    * Called when homebridge restores cached accessories from disk at startup
@@ -108,7 +1247,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * any custom data you stored when the accessory was originally registered.
    */
   configureMatterAccessory(accessory: SerializedMatterAccessory) {
-    this.log.debug('Loading cached Matter accessory:', accessory.displayName)
+    this.debugLog('Loading cached Matter accessory:', accessory.displayName)
     this.matterAccessories.set(accessory.uuid, accessory)
   }
 
@@ -116,26 +1255,91 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Register all Matter accessories
    */
   private async registerMatterAccessories() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Homebridge Matter Plugin')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Homebridge Matter Plugin')
+    this.debugLog('═'.repeat(80))
 
     // Remove accessories that are disabled in config
     await this.removeDisabledAccessories()
 
-    // Register devices by Matter specification sections
-    await this.registerSection4Lighting()
-    await this.registerSection5SmartPlugs()
-    await this.registerSection6Switches()
-    await this.registerSection7Sensors()
-    await this.registerSection8Closure()
-    await this.registerSection9HVAC()
-    await this.registerSection12Robotic()
-    await this.registerCustomDevices()
-
-    this.log.info('═'.repeat(80))
-    this.log.info('Finished registering Matter accessories')
-    this.log.info('═'.repeat(80))
+    // If we discovered real SwitchBot devices via OpenAPI, map and register them
+    if (this.discoveredDevices && this.discoveredDevices.length > 0) {
+      this.infoLog(`Registering ${this.discoveredDevices.length} discovered SwitchBot device(s) as Matter accessories`)
+
+      // Merge device config (deviceConfig per deviceType and per-device overrides) to match HAP behavior
+      const devicesToProcess = await this.mergeDiscoveredDevices(this.discoveredDevices)
+
+      // We'll separate discovered devices into two buckets:
+      // - platformAccessories: accessories that will be hosted under the plugin's Matter bridge
+      // - roboticAccessories: robot vacuum devices which require standalone commissioning behaviour
+      const platformAccessories: Array<MatterAccessory<Record<string, unknown>>> = []
+      const roboticAccessories: Array<MatterAccessory<Record<string, unknown>>> = []
+
+      // Known robot vacuum deviceType names (matches mapping in createAccessoryFromDevice)
+      const robotTypes = new Set([
+        'K10+',
+        'K10+ Pro',
+        'WoSweeper',
+        'WoSweeperMini',
+        'Robot Vacuum Cleaner S1',
+        'Robot Vacuum Cleaner S1 Plus',
+        'Robot Vacuum Cleaner S10',
+        'Robot Vacuum Cleaner S1 Pro',
+        'Robot Vacuum Cleaner S1 Mini',
+      ])
+
+      for (const dev of devicesToProcess) {
+        try {
+          const acc = await this.createAccessoryFromDevice(dev)
+          if (!acc) {
+            continue
+          }
+          if (robotTypes.has(dev.deviceType ?? '')) {
+            roboticAccessories.push(acc)
+          } else {
+            platformAccessories.push(acc)
+          }
+        } catch (e: any) {
+          this.errorLog(`Failed to create Matter accessory for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
+      // Register platform-hosted accessories (most devices)
+      if (platformAccessories.length > 0) {
+        this.infoLog(`✓ Registered ${platformAccessories.length} discovered platform-hosted device(s)`)
+        for (const acc of platformAccessories) {
+          this.infoLog(`  - ${acc.displayName}`)
+        }
+        await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, platformAccessories)
+      }
+
+      // Register robotic accessories (robot vacuums) separately so they can be
+      // commissioned in the way Apple Home expects (these devices often require
+      // standalone commissioning flow). We still call registerPlatformAccessories
+      // because the accessory implementations manage their commissioning behavior.
+      if (roboticAccessories.length > 0) {
+        this.infoLog(`✓ Registered ${roboticAccessories.length} discovered robot vacuum device(s)`)
+        for (const acc of roboticAccessories) {
+          this.infoLog(`  - ${acc.displayName} (standalone for Apple Home compatibility)`)
+        }
+        await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, roboticAccessories)
+      }
+
+      // Debug/info: how many discovered vs example accessories were registered.
+      // Example accessories are disabled — we intentionally do NOT register them.
+      const discoveredRegistered = platformAccessories.length + roboticAccessories.length
+      const exampleRegistered = 0
+      this.debugLog(`Discovered accessories registered: ${discoveredRegistered}; Example accessories registered: ${exampleRegistered}`)
+
+      return
+    }
+
+    // If no discovered devices are available, do not register example/demo accessories.
+    this.infoLog('No discovered SwitchBot devices found; not registering example Matter accessories by default.')
+
+    this.debugLog('═'.repeat(80))
+    this.debugLog('Finished registering Matter accessories')
+    this.debugLog('═'.repeat(80))
   }
 
   /**
@@ -170,7 +1374,16 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
       if (enabled === false) {
         const existingAccessory = this.matterAccessories.get(uuid)
         if (existingAccessory) {
-          this.log.info(`Removing accessory '${name}' (disabled in config)`)
+          this.infoLog(`Removing accessory '${name}' (disabled in config)`)
+          // Attempt to clear any per-device resources (timers, BLE handlers, instances)
+          try {
+            const deviceId = (existingAccessory as any)?.context?.deviceId
+            if (deviceId) {
+              this.clearDeviceResources(deviceId)
+            }
+          } catch (e: any) {
+            this.debugLog(`Failed to clear resources for disabled accessory ${name}: ${e?.message ?? e}`)
+          }
           await this.api.matter.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory as unknown as MatterAccessory])
           this.matterAccessories.delete(uuid)
         }
@@ -182,9 +1395,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 4: Lighting Devices (Matter Spec § 4)
    */
   private async registerSection4Lighting() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 4: Lighting Devices (Matter Spec § 4)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 4: Lighting Devices (Matter Spec § 4)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -219,9 +1432,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} lighting device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} lighting device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -231,9 +1444,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 5: Smart Plugs/Actuators (Matter Spec § 5)
    */
   private async registerSection5SmartPlugs() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 5: Smart Plugs/Actuators (Matter Spec § 5)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 5: Smart Plugs/Actuators (Matter Spec § 5)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -244,9 +1457,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} smart plug/actuator device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} smart plug/actuator device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -256,9 +1469,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 6: Switches & Controllers (Matter Spec § 6)
    */
   private async registerSection6Switches() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 6: Switches & Controllers (Matter Spec § 6)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 6: Switches & Controllers (Matter Spec § 6)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -269,9 +1482,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} switch/controller device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} switch/controller device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -281,9 +1494,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 7: Sensors (Matter Spec § 7)
    */
   private async registerSection7Sensors() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 7: Sensors (Matter Spec § 7)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 7: Sensors (Matter Spec § 7)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -330,9 +1543,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} sensor device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} sensor device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -342,9 +1555,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 8: Closure Devices (Matter Spec § 8)
    */
   private async registerSection8Closure() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 8: Closure Devices (Matter Spec § 8)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 8: Closure Devices (Matter Spec § 8)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -367,9 +1580,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} closure device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} closure device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -379,9 +1592,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Section 9: HVAC (Matter Spec § 9)
    */
   private async registerSection9HVAC() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 9: HVAC (Matter Spec § 9)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 9: HVAC (Matter Spec § 9)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -398,9 +1611,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} HVAC device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} HVAC device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -413,9 +1626,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Use those codes to pair the vacuum as a separate bridge in your Home app.
    */
   private async registerSection12Robotic() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Section 12: Robotic Devices (Matter Spec § 12)')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Section 12: Robotic Devices (Matter Spec § 12)')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -426,9 +1639,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} robot vacuum device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} robot vacuum device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName} (standalone for Apple Home compatibility)`)
+        this.infoLog(`  - ${acc.displayName} (standalone for Apple Home compatibility)`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }
@@ -442,9 +1655,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * like managing multiple logical components within a single device.
    */
   private async registerCustomDevices() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Custom Devices')
-    this.log.info('═'.repeat(80))
+    this.debugLog('═'.repeat(80))
+    this.infoLog('Custom Devices')
+    this.debugLog('═'.repeat(80))
 
     const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
 
@@ -455,9 +1668,9 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     }
 
     if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} custom device(s)`)
+      this.infoLog(`✓ Registered ${accessories.length} custom device(s)`)
       for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
+        this.infoLog(`  - ${acc.displayName}`)
       }
       await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
     }