@switchbot/homebridge-switchbot 5.0.0-beta.12 → 5.0.0-beta.121

package/src/platform-matter.ts

@@ -1,1110 +0,0 @@
-import type {
-  API,
-  DynamicPlatformPlugin,
-  Logging,
-  MatterAccessory,
-  SerializedMatterAccessory,
-} from 'homebridge'
-import type { bodyChange, device } from 'node-switchbot'
-
-import type { SwitchBotPlatformConfig } from './settings.js'
-
-import { SwitchBotBLE, SwitchBotOpenAPI } from 'node-switchbot'
-
-import {
-  ColorLightAccessory,
-  ColorTemperatureLightAccessory,
-  ContactSensorAccessory,
-  DimmableLightAccessory,
-  DoorLockAccessory,
-  ExtendedColorLightAccessory,
-  FanAccessory,
-  HumiditySensorAccessory,
-  LeakSensorAccessory,
-  LightSensorAccessory,
-  OccupancySensorAccessory,
-  OnOffLightAccessory,
-  OnOffOutletAccessory,
-  OnOffSwitchAccessory,
-  PowerStripAccessory,
-  RoboticVacuumAccessory,
-  SmokeCOAlarmAccessory,
-  TemperatureSensorAccessory,
-  ThermostatAccessory,
-  VenetianBlindAccessory,
-  WindowBlindAccessory,
-} from './devices-matter/index.js'
-import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { cleanDeviceConfig, formatDeviceIdAsMac, hs2rgb, rgb2hs, sleep } from './utils.js'
-
-/**
- * MatterPlatform
- * Demonstrates all available Matter device types in Homebridge
- *
- * Organized by official Matter Specification v1.4.1 categories
- */
-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
-  // public readonly accessories: Map<string, PlatformAccessory> = new Map()
-
-  // 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[] = []
-  // BLE event handlers keyed by device MAC (formatted)
-  private bleEventHandler: { [x: string]: (context: any) => void } = {}
-
-  constructor(
-    public readonly log: Logging,
-    public readonly config: SwitchBotPlatformConfig,
-    public readonly api: API,
-  ) {
-    this.log.debug('Finished initializing platform:', this.config.name)
-
-    // Normalize deviceConfig to remove UI-inserted defaults
-    try {
-      if ((this.config as any).options) {
-        const cleaned = cleanDeviceConfig((this.config as any).options.deviceConfig)
-        if (cleaned) {
-          ;(this.config as any).options.deviceConfig = cleaned
-        } else {
-          delete (this.config as any).options.deviceConfig
-        }
-      }
-    } catch (e) {
-      this.log.debug('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.')
-    }
-
-    // Check if the user has matter enabled, this means:
-    // - If the plugin is running on the main bridge, then the user must have enabled matter in the Homebridge settings page in the UI
-    // - If the plugin is running on a child bridge, then the user must have enabled matter on the plugin bridge settings section in the UI
-    // 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.')
-      return
-    }
-
-    // Register Matter accessories when Homebridge has finished launching
-    this.api.on('didFinishLaunching', () => {
-      this.log.debug('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.log.debug('[SwitchBot OpenAPI]', l.message))
-          }
-        } else {
-          this.log.debug('SwitchBot OpenAPI credentials not provided; cloud devices will be skipped')
-        }
-      } catch (e: any) {
-        this.log.error('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.log.debug('[SwitchBot BLE]', l.message))
-        }
-      } catch (e: any) {
-        this.log.error('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.log.error(`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.log.error(`Failed to handle BLE advertisement: ${e?.message ?? e}`)
-            }
-          }
-        })()
-      }
-
-      // perform device discovery from SwitchBot OpenAPI (if configured)
-      void this.discoverDevices()
-
-      this.registerMatterAccessories()
-    })
-  }
-
-  /**
-   * Normalize a deviceId for matching (uppercase alphanumerics only)
-   */
-  private normalizeDeviceId(deviceId: string) {
-    return (deviceId ?? '').toUpperCase().replace(/[^A-Z0-9]+/g, '')
-  }
-
-  /**
-   * 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[]) {
-    return a1.map((itm) => {
-      const matchingItem = a2.find(item => this.normalizeDeviceId(item.deviceId) === this.normalizeDeviceId(itm.deviceId))
-      return Object.assign({}, matchingItem, itm)
-    })
-  }
-
-  /**
-   * 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.log.debug(`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) {
-      const deviceIdConfig = this.config.options?.devices?.[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): 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.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,
-      context: { deviceId: dev.deviceId },
-    }
-
-    // Small helper to wrap common OpenAPI on/off commands
-    // Helper to send an OpenAPI command
-    const sendOpenAPI = async (command: string, parameter = 'default') => {
-      const bodyChange: bodyChange = { command, parameter, commandType: 'command' }
-      return this.retryCommand(dev, bodyChange, this.config.options?.maxRetries ?? 1, this.config.options?.delayBetweenRetries ?? 1000)
-    }
-
-    // Helper to send a BLE action if Platform BLE is enabled and switchBotBLE exists
-    const sendBLE = async (methodName: string, ...args: any[]) => {
-      // Provide a small retry loop for flaky BLE operations
-      if (!this.switchBotBLE) {
-        throw new Error('Platform BLE not available')
-      }
-      const id = formatDeviceIdAsMac(dev.deviceId)
-      const maxRetries = (this.config.options as any)?.bleRetries ?? 2
-      const retryDelay = (this.config.options as any)?.bleRetryDelay ?? 500
-      let attempt = 0
-      while (attempt < maxRetries) {
-        try {
-          const list = await this.switchBotBLE.discover({ model: (dev as any).bleModel, id })
-          if (!Array.isArray(list) || list.length === 0) {
-            throw new Error('BLE device not found')
-          }
-          const deviceInst: any = list[0]
-          if (typeof deviceInst[methodName] !== 'function') {
-            throw new TypeError(`BLE method ${methodName} not available on device`)
-          }
-          return await deviceInst[methodName](...args)
-        } catch (e: any) {
-          attempt++
-          if (attempt >= maxRetries) {
-            throw e
-          }
-          this.log.debug(`BLE ${methodName} attempt ${attempt} failed for ${dev.deviceId}: ${e?.message ?? e}, retrying in ${retryDelay}ms`)
-          await sleep(retryDelay)
-        }
-      }
-      throw new Error('BLE operation failed')
-    }
-
-    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.log.error(`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.log.error(`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.log.debug(`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.log.error(`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.log.error(`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.log.error(`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.log.error(`Failed to set color temperature for ${dev.deviceId}: ${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)
-
-    // 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) })
-            }
-
-            // If we parsed something from serviceData prefer it and return early
-            if (serviceData) {
-              return
-            }
-          }
-        } catch (e: any) {
-          this.log.debug(`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
-
-          // On/Off
-          if (status?.power !== undefined) {
-            const on = (String(status.power).toLowerCase() === 'on' || Number(status.power) === 1)
-            await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.OnOff, { onOff: on })
-          }
-
-          // Brightness
-          if (status?.brightness !== undefined) {
-            const level = Math.round((Number(status.brightness) / 100) * 254)
-            await this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.LevelControl, { currentLevel: level })
-          }
-
-          // 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.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 this.api.matter.updateAccessoryState(uuidLocal, this.api.matter.clusterNames.ColorControl, { currentHue: Math.round((h / 360) * 254), currentSaturation: Math.round((s / 100) * 254) })
-          }
-        } catch (e: any) {
-          this.log.debug(`BLE push handler failed for ${dev.deviceId}: ${e?.message ?? e}`)
-        }
-      }
-    } catch (e: any) {
-      this.log.debug(`Failed to register BLE handler 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.log.debug('SwitchBot OpenAPI not configured; skipping discovery')
-      return
-    }
-
-    try {
-      const { response, statusCode } = await this.switchBotAPI.getDevices()
-      this.log.debug(`SwitchBot getDevices response status: ${statusCode}`)
-      if (statusCode === 100 || statusCode === 200) {
-        const deviceList = Array.isArray(response?.body?.deviceList) ? response.body.deviceList : []
-        this.discoveredDevices = deviceList
-        this.log.info(`Discovered ${deviceList.length} SwitchBot device(s) from OpenAPI`)
-        for (const d of deviceList) {
-          this.log.debug(`  - ${d.deviceName} (${d.deviceType}) id=${d.deviceId}`)
-        }
-      } else {
-        this.log.warn(`SwitchBot getDevices returned status ${statusCode}`)
-      }
-    } catch (e: any) {
-      this.log.error('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.log.debug(`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.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.log.debug(`parseAdvertisementForDevice failed for ${dev.deviceId}: ${e?.message ?? e}`)
-      return null
-    }
-  }
-
-  /**
-   * Required for DynamicPlatformPlugin
-   * Called when homebridge restores cached accessories from disk at startup
-   */
-  configureAccessory(/* accessory: PlatformAccessory */) {
-    // Note this is not used for Matter accessories - use configureMatterAccessory instead
-    // This plugin does not have any hap accessories, so here we can comment this out
-    // this.accessories.set(accessory.UUID, accessory)
-  }
-
-  /**
-   * Called when homebridge restores cached Matter accessories from disk at startup.
-   *
-   * This is where you can access the `accessory.context` object to retrieve
-   * any custom data you stored when the accessory was originally registered.
-   */
-  configureMatterAccessory(accessory: SerializedMatterAccessory) {
-    this.log.debug('Loading cached Matter accessory:', accessory.displayName)
-    this.matterAccessories.set(accessory.uuid, accessory)
-  }
-
-  /**
-   * Register all Matter accessories
-   */
-  private async registerMatterAccessories() {
-    this.log.info('═'.repeat(80))
-    this.log.info('Homebridge Matter Plugin')
-    this.log.info('═'.repeat(80))
-
-    // Remove accessories that are disabled in config
-    await this.removeDisabledAccessories()
-
-    // If we discovered real SwitchBot devices via OpenAPI, map and register them
-    if (this.discoveredDevices && this.discoveredDevices.length > 0) {
-      this.log.info(`Registering ${this.discoveredDevices.length} discovered SwitchBot device(s) as Matter accessories`)
-      const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-      // Merge device config (deviceConfig per deviceType and per-device overrides) to match HAP behavior
-      const devicesToProcess = await this.mergeDiscoveredDevices(this.discoveredDevices)
-
-      for (const dev of devicesToProcess) {
-        try {
-          const acc = await this.createAccessoryFromDevice(dev)
-          if (acc) {
-            accessories.push(acc)
-          }
-        } catch (e: any) {
-          this.log.error(`Failed to create Matter accessory for ${dev.deviceId}: ${e?.message ?? e}`)
-        }
-      }
-      if (accessories.length > 0) {
-        this.log.info(`✓ Registered ${accessories.length} discovered device(s)`)
-        for (const acc of accessories) {
-          this.log.info(`  - ${acc.displayName}`)
-        }
-        await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-        return
-      }
-      this.log.info('No discovered devices were mapped to Matter accessories; falling back to example sections')
-    }
-
-    // Register example/demo 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))
-  }
-
-  /**
-   * Remove accessories that are disabled in config
-   */
-  private async removeDisabledAccessories() {
-    const configMap = [
-      { enabled: this.config.enableOnOffLight, uuid: this.api.matter.uuid.generate('matter-onoff-light'), name: 'On/Off Light' },
-      { enabled: this.config.enableDimmableLight, uuid: this.api.matter.uuid.generate('matter-dimmable-light'), name: 'Dimmable Light' },
-      { enabled: this.config.enableColourTemperatureLight, uuid: this.api.matter.uuid.generate('matter-colour-temp-light'), name: 'Colour Temperature Light' },
-      { enabled: this.config.enableColourLight, uuid: this.api.matter.uuid.generate('matter-colour-light'), name: 'Colour Light (HS)' },
-      { enabled: this.config.enableExtendedColourLight, uuid: this.api.matter.uuid.generate('matter-extended-colour-light'), name: 'Extended Colour Light' },
-      { enabled: this.config.enableOnOffOutlet, uuid: this.api.matter.uuid.generate('matter-onoff-outlet'), name: 'On/Off Outlet' },
-      { enabled: this.config.enableOnOffSwitch, uuid: this.api.matter.uuid.generate('matter-onoff-switch'), name: 'On/Off Switch' },
-      { enabled: this.config.enableTemperatureSensor, uuid: this.api.matter.uuid.generate('matter-temperature-sensor'), name: 'Temperature Sensor' },
-      { enabled: this.config.enableHumiditySensor, uuid: this.api.matter.uuid.generate('matter-humidity-sensor'), name: 'Humidity Sensor' },
-      { enabled: this.config.enableLightSensor, uuid: this.api.matter.uuid.generate('matter-light-sensor'), name: 'Light Sensor' },
-      { enabled: this.config.enableOccupancySensor, uuid: this.api.matter.uuid.generate('matter-occupancy-sensor'), name: 'Occupancy Sensor' },
-      { enabled: this.config.enableContactSensor, uuid: this.api.matter.uuid.generate('matter-contact-sensor'), name: 'Contact Sensor' },
-      { enabled: this.config.enableLeakSensor, uuid: this.api.matter.uuid.generate('matter-leak-sensor'), name: 'Leak Sensor' },
-      { enabled: this.config.enableSmokeSensor, uuid: this.api.matter.uuid.generate('matter-smoke-sensor'), name: 'Smoke Sensor' },
-      { enabled: this.config.enableDoorLock, uuid: this.api.matter.uuid.generate('matter-door-lock'), name: 'Door Lock' },
-      { enabled: this.config.enableWindowBlind, uuid: this.api.matter.uuid.generate('matter-window-blind'), name: 'Window Blind' },
-      { enabled: this.config.enableVenetianBlind, uuid: this.api.matter.uuid.generate('matter-venetian-blind'), name: 'Venetian Blind' },
-      { enabled: this.config.enableThermostat, uuid: this.api.matter.uuid.generate('matter-thermostat'), name: 'Thermostat' },
-      { enabled: this.config.enableFan, uuid: this.api.matter.uuid.generate('matter-fan'), name: 'Fan' },
-      { enabled: this.config.enableRobotVacuum, uuid: this.api.matter.uuid.generate('matter-robot-vacuum'), name: 'Robot Vacuum' },
-      { enabled: this.config.enablePowerStrip, uuid: this.api.matter.uuid.generate('matter-power-strip'), name: 'Power Strip' },
-    ]
-
-    for (const { enabled, uuid, name } of configMap) {
-      if (enabled === false) {
-        const existingAccessory = this.matterAccessories.get(uuid)
-        if (existingAccessory) {
-          this.log.info(`Removing accessory '${name}' (disabled in config)`)
-          await this.api.matter.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory as unknown as MatterAccessory])
-          this.matterAccessories.delete(uuid)
-        }
-      }
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // On/Off Light
-    if (this.config.enableOnOffLight !== false) {
-      const device = new OnOffLightAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Dimmable Light
-    if (this.config.enableDimmableLight !== false) {
-      const device = new DimmableLightAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Color Temperature Light
-    if (this.config.enableColourTemperatureLight !== false) {
-      const device = new ColorTemperatureLightAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Color Light (HS only)
-    if (this.config.enableColourLight !== false) {
-      const device = new ColorLightAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Extended Color Light (HS+CCT)
-    if (this.config.enableExtendedColourLight !== false) {
-      const device = new ExtendedColorLightAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} lighting device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // On/Off Outlet
-    if (this.config.enableOnOffOutlet !== false) {
-      const device = new OnOffOutletAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} smart plug/actuator device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // On/Off Switch
-    if (this.config.enableOnOffSwitch !== false) {
-      const device = new OnOffSwitchAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} switch/controller device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // Contact Sensor
-    if (this.config.enableContactSensor !== false) {
-      const device = new ContactSensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Light Sensor
-    if (this.config.enableLightSensor !== false) {
-      const device = new LightSensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Occupancy Sensor
-    if (this.config.enableOccupancySensor !== false) {
-      const device = new OccupancySensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Temperature Sensor
-    if (this.config.enableTemperatureSensor !== false) {
-      const device = new TemperatureSensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Humidity Sensor
-    if (this.config.enableHumiditySensor !== false) {
-      const device = new HumiditySensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Smoke/CO Alarm
-    if (this.config.enableSmokeSensor !== false) {
-      const device = new SmokeCOAlarmAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Leak Sensor
-    if (this.config.enableLeakSensor !== false) {
-      const device = new LeakSensorAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} sensor device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // Door Lock
-    if (this.config.enableDoorLock !== false) {
-      const device = new DoorLockAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Window Blind
-    if (this.config.enableWindowBlind !== false) {
-      const device = new WindowBlindAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Venetian Blind
-    if (this.config.enableVenetianBlind !== false) {
-      const device = new VenetianBlindAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} closure device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // Thermostat
-    if (this.config.enableThermostat !== false) {
-      const device = new ThermostatAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    // Fan
-    if (this.config.enableFan !== false) {
-      const device = new FanAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} HVAC device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * Section 12: Robotic Devices (Matter Spec § 12)
-   * ⚠️ IMPORTANT: RVC devices use a DIFFERENT PROCESS (same code) than other devices!
-   * When this runs, you'll see separate commissioning codes in the logs for the robot vacuum.
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // Robot Vacuum
-    if (this.config.enableRobotVacuum !== false) {
-      const device = new RoboticVacuumAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} robot vacuum device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName} (standalone for Apple Home compatibility)`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-
-  /**
-   * Custom Devices
-   *
-   * This section demonstrates custom device implementations that go beyond
-   * the standard Matter device types. These examples show advanced patterns
-   * 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))
-
-    const accessories: Array<MatterAccessory<Record<string, unknown>>> = []
-
-    // Power Strip (4 Outlets)
-    if (this.config.enablePowerStrip !== false) {
-      const device = new PowerStripAccessory(this.api, this.log)
-      accessories.push(device.toAccessory())
-    }
-
-    if (accessories.length > 0) {
-      this.log.info(`✓ Registered ${accessories.length} custom device(s)`)
-      for (const acc of accessories) {
-        this.log.info(`  - ${acc.displayName}`)
-      }
-      await this.api.matter.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories)
-    }
-  }
-}