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

package/dist/platform-matter.js

@@ -1,12 +1,7 @@
+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 } 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 {
     log;
     config;
@@ -16,11 +11,48 @@ export class SwitchBotMatterPlatform {
     // public readonly accessories: Map<string, PlatformAccessory> = new Map()
     // Track restored Matter cached accessories
     matterAccessories = new Map();
+    // node-switchbot clients
+    switchBotAPI;
+    switchBotBLE;
+    // discovered devices cache
+    discoveredDevices = [];
+    // Registry of created accessory instances keyed by normalized deviceId
+    accessoryInstances = new Map();
+    // Refresh timers keyed by normalized deviceId
+    refreshTimers = new Map();
+    // BLE event handlers keyed by device MAC (formatted)
+    bleEventHandler = {};
+    // Platform logging toggle (can be controlled via UI or config)
+    platformLogging;
+    // Platform-provided logging helpers (attached in constructor)
+    infoLog;
+    successLog;
+    debugSuccessLog;
+    warnLog;
+    debugWarnLog;
+    errorLog;
+    debugErrorLog;
+    debugLog;
+    loggingIsDebug;
+    enablingPlatformLogging;
     constructor(log, config, api) {
         this.log = log;
         this.config = config;
         this.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.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 {
             if (this.config.options) {
@@ -35,11 +67,11 @@ export class SwitchBotMatterPlatform {
             }
         }
         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:
         // - If the plugin is running on the main bridge, then the user must have enabled matter in the Homebridge settings page in the UI
@@ -47,15 +79,1058 @@ export class SwitchBotMatterPlatform {
         // 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) => this.debugLog('[SwitchBot OpenAPI]', l.message));
+                    }
+                }
+                else {
+                    this.debugLog('SwitchBot OpenAPI credentials not provided; cloud devices will be skipped');
+                }
+            }
+            catch (e) {
+                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) => this.debugLog('[SwitchBot BLE]', l.message));
+                }
+            }
+            catch (e) {
+                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) {
+                        this.errorLog(`Failed to start BLE scanning: ${e?.message ?? e}`);
+                    }
+                    // route advertisements to our handlers
+                    ble.onadvertisement = async (ad) => {
+                        try {
+                            const mac = (ad.address || '').toLowerCase();
+                            const handler = this.bleEventHandler[mac];
+                            if (handler) {
+                                await handler(ad.serviceData);
+                            }
+                        }
+                        catch (e) {
+                            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) {
+                            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) {
+                        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) {
+                        this.debugLog(`Failed to clear bleEventHandler: ${e?.message ?? e}`);
+                    }
+                    // Stop BLE scanning if available
+                    try {
+                        if (this.switchBotBLE && typeof this.switchBotBLE.stopScan === 'function') {
+                            await this.switchBotBLE.stopScan();
+                            this.infoLog('Stopped BLE scanning');
+                        }
+                    }
+                    catch (e) {
+                        this.debugLog(`Failed to stop BLE scanning: ${e?.message ?? e}`);
+                    }
+                }
+                catch (e) {
+                    this.debugLog('Shutdown cleanup failed: %s', e?.message ?? e);
+                }
+            });
+            (async () => {
+                try {
+                    await this.discoverDevices();
+                }
+                catch (e) {
+                    this.debugLog('Device discovery failed during startup: %s', e?.message ?? e);
+                }
+                try {
+                    await this.registerMatterAccessories();
+                }
+                catch (e) {
+                    this.errorLog('Failed to register Matter accessories: %s', e?.message ?? e);
+                }
+            })();
         });
     }
+    /**
+     * Normalize a deviceId for matching (uppercase alphanumerics only)
+     */
+    normalizeDeviceId(deviceId) {
+        return (deviceId ?? '').toUpperCase().replace(/[^A-Z0-9]+/g, '');
+    }
+    /**
+     * Clear per-device resources: refresh timers, accessory instance registry, BLE handlers
+     */
+    clearDeviceResources(deviceId) {
+        if (!deviceId) {
+            return;
+        }
+        try {
+            const nid = this.normalizeDeviceId(deviceId);
+            const existing = this.refreshTimers.get(nid);
+            if (existing) {
+                try {
+                    clearInterval(existing);
+                }
+                catch (e) {
+                    this.debugLog(`Failed to clear refresh timer for ${deviceId}: ${e?.message ?? e}`);
+                }
+                this.refreshTimers.delete(nid);
+            }
+            try {
+                this.accessoryInstances.delete(nid);
+            }
+            catch (e) {
+                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) {
+                // formatting failed (not a MAC-like id) — ignore
+                this.debugLog(`clearDeviceResources: failed to remove BLE handler for ${deviceId}: ${e?.message ?? e}`);
+            }
+        }
+        catch (e) {
+            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.
+     */
+    mergeByDeviceId(a1, a2) {
+        const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices);
+        const result = [];
+        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.
+     */
+    async mergeDiscoveredDevices(discovered) {
+        // 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.configDeviceType !== undefined ? deviceObj.configDeviceType : 'Unknown';
+                this.debugLog(`API missing deviceType for ${deviceObj.deviceId}, using configDeviceType: ${deviceObj.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 = [];
+        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) => 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) => 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.
+     */
+    chooseConnectionType(deviceObj) {
+        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`.
+     */
+    async createAccessoryFromDevice(dev) {
+        // 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.firmware ?? dev.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?.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?.bleRetries ?? 2, bleRetryDelay: this.config.options?.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) {
+            // best-effort logging — swallow errors to avoid breaking initialization
+            this.debugLog('Failed to log initializing device:', e?.message ?? e);
+        }
+        const makeOnOffHandlers = (uuid, connectionType) => ({
+            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) {
+                        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) {
+                        this.errorLog(`Failed to turn off device ${dev.deviceId}: ${e?.message ?? e}`);
+                    }
+                },
+            },
+        });
+        // Mapping from SwitchBot deviceType -> constructor (expanded for parity with HAP)
+        const mapping = {
+            // 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 = {};
+        // 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) => {
+                    try {
+                        const level = request.level;
+                        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) {
+                        this.errorLog(`Failed to set brightness for ${dev.deviceId}: ${e?.message ?? e}`);
+                    }
+                },
+            };
+            // colorControl
+            handlers.colorControl = {
+                moveToHueAndSaturationLogic: async (request) => {
+                    try {
+                        const hue = request.hue;
+                        const saturation = request.saturation;
+                        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) {
+                        this.errorLog(`Failed to set hue/sat for ${dev.deviceId}: ${e?.message ?? e}`);
+                    }
+                },
+                moveToColorLogic: async (request) => {
+                    try {
+                        // MoveToColor gives colorX/colorY values; convert to approximate RGB by mapping to 0-255 scale
+                        const colorX = request.colorX;
+                        const colorY = request.colorY;
+                        // 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) {
+                        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) => {
+                    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) {
+                        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.context = Object.assign({}, baseOpts.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) {
+            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) {
+            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) {
+            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) => {
+                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                                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) {
+                    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 = 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) {
+                    this.debugLog(`BLE push handler failed for ${dev.deviceId}: ${e?.message ?? e}`);
+                }
+            };
+        }
+        catch (e) {
+            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 = response;
+                            const body = respAny?.body ?? respAny;
+                            const status = body?.status ?? body;
+                            await this.applyStatusToAccessory(uuid, dev, status);
+                        }
+                    }
+                    catch (e) {
+                        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 = response;
+                            const body = respAny?.body ?? respAny;
+                            const status = body?.status ?? body;
+                            await this.applyStatusToAccessory(uuid, dev, status);
+                        }
+                    }
+                    catch (e) {
+                        this.debugLog(`Periodic OpenAPI refresh failed for ${dev.deviceId}: ${e?.message ?? e}`);
+                    }
+                }, Number(refreshRateSec) * 1000);
+                this.refreshTimers.set(nid, timer);
+            }
+        }
+        catch (e) {
+            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
+     */
+    async discoverDevices() {
+        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) {
+            this.errorLog('Failed to discover SwitchBot devices:', e?.message ?? e);
+        }
+    }
+    /**
+     * Retry wrapper for control commands using SwitchBot OpenAPI
+     */
+    async retryCommand(deviceObj, bodyChange, maxRetries = 1, delayBetweenRetries = 1000) {
+        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, this.config.credentials?.token, this.config.credentials?.secret);
+                return { response, statusCode };
+            }
+            catch (e) {
+                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.
+     */
+    parseAdvertisementForDevice(dev, serviceData) {
+        if (!serviceData) {
+            return null;
+        }
+        try {
+            const sd = serviceData;
+            const result = {};
+            // 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) {
+            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.
+     */
+    async applyStatusToAccessory(uuidLocal, dev, status) {
+        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, attributes, methodName) => {
+            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) {
+                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.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
+            if (status?.battery !== undefined || status?.batt !== undefined) {
+                try {
+                    const percentage = Number(status?.battery ?? status?.batt);
+                    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 safeUpdate('powerSource', { batPercentRemaining, batChargeLevel }, 'updateBatteryPercentage');
+                }
+                catch (e) {
+                    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) {
+                    this.debugLog(`Failed to apply temperature for ${dev.deviceId}: ${e?.message ?? e}`);
+                }
+            }
+            // Humidity
+            if (status?.humidity !== undefined || status?.h !== undefined) {
+                try {
+                    const percent = Number(status?.humidity ?? status?.h);
+                    const measured = Math.round(percent * 100);
+                    await safeUpdate('relativeHumidityMeasurement', { measuredValue: measured }, 'updateHumidity');
+                }
+                catch (e) {
+                    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) {
+                    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) {
+                    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) {
+                    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) {
+                    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) {
+                    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) {
+                    this.debugLog(`Failed to apply rvcRunMode for ${dev.deviceId}: ${e?.message ?? e}`);
+                }
+            }
+            if (status?.rvcOperationalState !== undefined) {
+                try {
+                    await safeUpdate('rvcOperationalState', { operationalState: Number(status.rvcOperationalState) }, 'updateOperationalState');
+                }
+                catch (e) {
+                    this.debugLog(`Failed to apply rvcOperationalState for ${dev.deviceId}: ${e?.message ?? e}`);
+                }
+            }
+        }
+        catch (e) {
+            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
@@ -72,30 +1147,88 @@ export class SwitchBotMatterPlatform {
      * any custom data you stored when the accessory was originally registered.
      */
     configureMatterAccessory(accessory) {
-        this.log.debug('Loading cached Matter accessory:', accessory.displayName);
+        this.debugLog('Loading cached Matter accessory:', accessory.displayName);
         this.matterAccessories.set(accessory.uuid, accessory);
     }
     /**
      * Register all Matter accessories
      */
     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 = [];
+            const roboticAccessories = [];
+            // 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) {
+                    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));
     }
     /**
      * Remove accessories that are disabled in config
@@ -128,7 +1261,17 @@ export class SwitchBotMatterPlatform {
             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?.context?.deviceId;
+                        if (deviceId) {
+                            this.clearDeviceResources(deviceId);
+                        }
+                    }
+                    catch (e) {
+                        this.debugLog(`Failed to clear resources for disabled accessory ${name}: ${e?.message ?? e}`);
+                    }
                     await this.api.matter.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
                     this.matterAccessories.delete(uuid);
                 }
@@ -139,9 +1282,9 @@ export class SwitchBotMatterPlatform {
      * Section 4: Lighting Devices (Matter Spec § 4)
      */
     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 = [];
         // On/Off Light
         if (this.config.enableOnOffLight !== false) {
@@ -169,9 +1312,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -180,9 +1323,9 @@ export class SwitchBotMatterPlatform {
      * Section 5: Smart Plugs/Actuators (Matter Spec § 5)
      */
     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 = [];
         // On/Off Outlet
         if (this.config.enableOnOffOutlet !== false) {
@@ -190,9 +1333,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -201,9 +1344,9 @@ export class SwitchBotMatterPlatform {
      * Section 6: Switches & Controllers (Matter Spec § 6)
      */
     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 = [];
         // On/Off Switch
         if (this.config.enableOnOffSwitch !== false) {
@@ -211,9 +1354,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -222,9 +1365,9 @@ export class SwitchBotMatterPlatform {
      * Section 7: Sensors (Matter Spec § 7)
      */
     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 = [];
         // Contact Sensor
         if (this.config.enableContactSensor !== false) {
@@ -262,9 +1405,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -273,9 +1416,9 @@ export class SwitchBotMatterPlatform {
      * Section 8: Closure Devices (Matter Spec § 8)
      */
     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 = [];
         // Door Lock
         if (this.config.enableDoorLock !== false) {
@@ -293,9 +1436,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -304,9 +1447,9 @@ export class SwitchBotMatterPlatform {
      * Section 9: HVAC (Matter Spec § 9)
      */
     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 = [];
         // Thermostat
         if (this.config.enableThermostat !== false) {
@@ -319,9 +1462,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -333,9 +1476,9 @@ export class SwitchBotMatterPlatform {
      * Use those codes to pair the vacuum as a separate bridge in your Home app.
      */
     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 = [];
         // Robot Vacuum
         if (this.config.enableRobotVacuum !== false) {
@@ -343,9 +1486,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }
@@ -358,9 +1501,9 @@ export class SwitchBotMatterPlatform {
      * like managing multiple logical components within a single device.
      */
     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 = [];
         // Power Strip (4 Outlets)
         if (this.config.enablePowerStrip !== false) {
@@ -368,9 +1511,9 @@ export class SwitchBotMatterPlatform {
             accessories.push(device.toAccessory());
         }
         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);
         }