@switchbot/homebridge-switchbot 5.0.0-beta.7 → 5.0.0-beta.70

package/src/devices-matter/VenetianBlindAccessory.ts

@@ -58,7 +58,7 @@ export class VenetianBlindAccessory extends BaseMatterAccessory {
     this.logInfo('initialized.')
   }
 
-  private async handleGoToLift(request: MatterRequests.GoToLiftPercentage): Promise<void> {
+  public async handleGoToLift(request: MatterRequests.GoToLiftPercentage): Promise<void> {
     this.logInfo(`GoToLiftPercentage request: ${JSON.stringify(request)}`)
 
     // Matter uses 0=open, 10000=closed, so invert to get open percentage
@@ -68,7 +68,7 @@ export class VenetianBlindAccessory extends BaseMatterAccessory {
     // TODO: await myBlindAPI.setPosition(openPercent)
   }
 
-  private async handleGoToTilt(request: MatterRequests.GoToTiltPercentage): Promise<void> {
+  public async handleGoToTilt(request: MatterRequests.GoToTiltPercentage): Promise<void> {
     this.logInfo(`GoToTiltPercentage request: ${JSON.stringify(request)}`)
 
     // Matter tilt: 0=horizontal/open (0deg), 10000=vertical/closed (90deg)
@@ -77,17 +77,17 @@ export class VenetianBlindAccessory extends BaseMatterAccessory {
     // TODO: await myBlindAPI.setTiltAngle(degrees)
   }
 
-  private async handleUpOrOpen(): Promise<void> {
+  public async handleUpOrOpen(): Promise<void> {
     this.logInfo('opened blind.')
     // TODO: await myBlindAPI.open()
   }
 
-  private async handleDownOrClose(): Promise<void> {
+  public async handleDownOrClose(): Promise<void> {
     this.logInfo('closed blind.')
     // TODO: await myBlindAPI.close()
   }
 
-  private async handleStop(): Promise<void> {
+  public async handleStop(): Promise<void> {
     this.logInfo('stopped blind.')
     // TODO: await myBlindAPI.stop()
   }

package/src/devices-matter/WindowBlindAccessory.ts

@@ -55,28 +55,71 @@ export class WindowBlindAccessory extends BaseMatterAccessory {
     this.logInfo('initialized.')
   }
 
-  private async handleGoToLift(request: MatterRequests.GoToLiftPercentage): Promise<void> {
+  public async handleGoToLift(request: MatterRequests.GoToLiftPercentage): Promise<void> {
     this.logInfo(`GoToLiftPercentage request: ${JSON.stringify(request)}`)
     // Matter uses 0=open, 10000=closed, so invert to get open percentage
     const closedPercent = request.liftPercent100thsValue / 100
-    const openPercent = (100 - closedPercent).toFixed(0)
-    this.logInfo(`moved to ${openPercent}% open.`)
-    // TODO: await myBlindAPI.setPosition(openPercent)
+    // SwitchBot API expects position: 0=open, 100=closed
+    const position = Math.max(0, Math.min(100, closedPercent))
+    // Default to performance mode (ff), index is always 0
+    const mode = 'ff' // or '01' for silent mode if needed
+    const parameter = `0,${mode},${position}`
+    this.logInfo(`Sending setPosition to OpenAPI: parameter=${parameter}`)
+    try {
+      if (this.context?.sendOpenAPI) {
+        await this.sendOpenAPICommand('setPosition', parameter)
+        this.logInfo('OpenAPI setPosition command sent.')
+      } else {
+        this.logWarn('OpenAPI sender not available in context.')
+      }
+    } catch (e: any) {
+      this.logWarn(`OpenAPI setPosition failed: ${String(e?.message ?? e)}`)
+    }
   }
 
-  private async handleUpOrOpen(): Promise<void> {
+  public async handleUpOrOpen(): Promise<void> {
     this.logInfo('opened blind.')
-    // TODO: await myBlindAPI.open()
+    try {
+      // Send open command to SwitchBot OpenAPI
+      if (this.context?.sendOpenAPI) {
+        await this.sendOpenAPICommand('turnOn')
+        this.logInfo('OpenAPI open command sent.')
+      } else {
+        this.logWarn('OpenAPI sender not available in context.')
+      }
+    } catch (e: any) {
+      this.logWarn(`OpenAPI open failed: ${String(e?.message ?? e)}`)
+    }
   }
 
-  private async handleDownOrClose(): Promise<void> {
+  public async handleDownOrClose(): Promise<void> {
     this.logInfo('closed blind.')
-    // TODO: await myBlindAPI.close()
+    try {
+      // Send close command to SwitchBot OpenAPI
+      if (this.context?.sendOpenAPI) {
+        await this.sendOpenAPICommand('turnOff')
+        this.logInfo('OpenAPI close command sent.')
+      } else {
+        this.logWarn('OpenAPI sender not available in context.')
+      }
+    } catch (e: any) {
+      this.logWarn(`OpenAPI close failed: ${String(e?.message ?? e)}`)
+    }
   }
 
-  private async handleStop(): Promise<void> {
+  public async handleStop(): Promise<void> {
     this.logInfo('stopped blind.')
-    // TODO: await myBlindAPI.stop()
+    try {
+      // Send pause command to SwitchBot OpenAPI
+      if (this.context?.sendOpenAPI) {
+        await this.sendOpenAPICommand('pause')
+        this.logInfo('OpenAPI pause command sent.')
+      } else {
+        this.logWarn('OpenAPI sender not available in context.')
+      }
+    } catch (e: any) {
+      this.logWarn(`OpenAPI pause failed: ${String(e?.message ?? e)}`)
+    }
   }
 
   public updateLiftPosition(openPercent: number): void {

package/src/homebridge-ui/public/index.html

@@ -28,7 +28,8 @@
 <div id="menuWrapper" class="btn-group w-100 mb-0" role="group" aria-label="UI Menu" style="display: none">
   <button type="button" class="btn btn-primary" id="menuSettings">Settings</button>
   <button type="button" class="btn btn-primary" id="menuDevices">Devices</button>
-  <button type="button" class="btn btn-primary mr-0" id="menuHome">Support</button>
+  <button type="button" class="btn btn-primary" id="menuHome">Support</button>
+  <button type="button" class="btn btn-primary mr-0" id="dynamic-config-tab">Dynamic Config</button>
 </div>
 <div id="disabledBanner" class="alert alert-secondary mb-0 mt-3" role="alert" style="display: none">
   Plugin is currently disabled
@@ -43,7 +44,7 @@
     </form>
     <table class="table w-100" id="deviceTable" style="display: none">
       <thead>
-        <tr class="table-active">
+        <tr>
           <th scope="col" style="width: 40%">Device Name</th>
           <th scope="col" style="width: 60%" id="displayName"></th>
         </tr>
@@ -69,8 +70,22 @@
           <th scope="row">Connection Type</th>
           <td id="connectionType"></td>
         </tr>
+        <tr>
+          <th scope="row">Refresh Rate</th>
+          <td id="refreshRate"></td>
+        </tr>
+        <tr>
+          <th scope="row">Update Rate</th>
+          <td id="updateRate"></td>
+        </tr>
+        <tr>
+          <th scope="row">Push Rate</th>
+          <td id="pushRate"></td>
+        </tr>
       </tbody>
     </table>
+    <h5 class="mt-4">Cached Accessories</h5>
+    <ul id="cachedAccessoriesList"></ul>
     <p class="text-center">External accessories will not be displayed here.</p>
   </div>
 </div>
@@ -118,10 +133,50 @@
     </li>
   </ul>
 </div>
+<div id="dynamic-config-content" class="tab-content" style="display: none;">
+  <h2>Dynamic Config</h2>
+  <p>Discover and configure devices dynamically.</p>
+  <!-- Placeholder for dynamic content -->
+</div>
 <script>
   (async () => {
     try {
       const currentConfig = await homebridge.getPluginConfig();
+
+      // Defensive wrapper: ensure token/secret aren't accidentally cleared by
+      // the UI/schema form. Some versions of config UI can omit sensitive
+      // fields from the submitted payload; when that happens we copy the
+      // existing values from `currentConfig` into the outgoing payload so
+      // saved config does not inadvertently remove credentials.
+      try {
+        if (typeof homebridge.updatePluginConfig === 'function') {
+          const _origUpdatePluginConfig = homebridge.updatePluginConfig.bind(homebridge)
+          homebridge.updatePluginConfig = async (cfg) => {
+            try {
+              if (Array.isArray(cfg) && cfg.length > 0 && Array.isArray(currentConfig) && currentConfig.length > 0) {
+                const incoming = cfg[0] || {}
+                const existing = currentConfig[0] || {}
+                incoming.credentials = incoming.credentials || {}
+                // Preserve token/secret when incoming payload leaves them blank/undefined
+                if ((incoming.credentials.token === undefined || String(incoming.credentials.token).trim() === '') && existing.credentials && existing.credentials.token) {
+                  incoming.credentials.token = existing.credentials.token
+                }
+                if ((incoming.credentials.secret === undefined || String(incoming.credentials.secret).trim() === '') && existing.credentials && existing.credentials.secret) {
+                  incoming.credentials.secret = existing.credentials.secret
+                }
+                cfg[0] = incoming
+              }
+            } catch (e) {
+              // Swallow any wrapper errors but log to console for debugging
+              // (do not expose secrets).
+              console.error('updatePluginConfig wrapper error', e)
+            }
+            return await _origUpdatePluginConfig(cfg)
+          }
+        }
+      } catch (e) {
+        console.error('Failed to attach updatePluginConfig wrapper', e)
+      }
       showIntro = () => {
         const introLink = document.getElementById('introLink');
         introLink.addEventListener('click', () => {
@@ -144,13 +199,33 @@
         document.getElementById('menuSettings').classList.add('btn-primary');
         document.getElementById('pageSupport').style.display = 'none';
         document.getElementById('pageDevices').style.display = 'block';
-        const cachedAccessories =
+        let cachedAccessories =
           typeof homebridge.getCachedAccessories === 'function'
             ? await homebridge.getCachedAccessories()
             : await homebridge.request('/getCachedAccessories');
+
+        // If no HAP cached accessories were returned, try the Matter cached list using the new native method
+        if ((!cachedAccessories || cachedAccessories.length === 0)) {
+          try {
+            // Use the new native getCachedMatterAccessories() method from @homebridge/plugin-ui-utils v2.1.1-beta.0+
+            const matter = typeof homebridge.getCachedMatterAccessories === 'function'
+              ? await homebridge.getCachedMatterAccessories()
+              : await homebridge.request('/getCachedMatterAccessories'); // Fallback to custom handler for older UI versions
+            if (Array.isArray(matter) && matter.length > 0) {
+              cachedAccessories = matter
+            }
+          } catch (e) {
+            // ignore
+          }
+        }
+        console.log('Cached Accessories:', cachedAccessories); // Log cached accessories for debugging
         if (cachedAccessories.length > 0) {
           cachedAccessories.sort((a, b) => {
-            return a.displayName.toLowerCase() > b.displayName.toLowerCase() ? 1 : b.displayName.toLowerCase() > a.displayName.toLowerCase() ? -1 : 0;
+            return a.displayName.toLowerCase() > b.displayName.toLowerCase()
+              ? 1
+              : b.displayName.toLowerCase() > a.displayName.toLowerCase()
+              ? -1
+              : 0;
           });
         }
         const deviceSelect = document.getElementById('deviceSelect');
@@ -158,24 +233,141 @@
         cachedAccessories.forEach((a) => {
           const option = document.createElement('option');
           option.text = a.displayName;
-          option.value = a.UUID;
+          option.value = a.UUID || a.uuid; // Handle both HAP and Matter UUID formats
           deviceSelect.add(option);
         });
+        const cachedAccessoriesList = document.getElementById('cachedAccessoriesList');
+        cachedAccessoriesList.innerHTML = ''; // Clear previous entries
+        cachedAccessories.forEach((a) => {
+          const listItem = document.createElement('li');
+          listItem.textContent = `${a.displayName} (${a.UUID || a.uuid})`;
+          cachedAccessoriesList.appendChild(listItem);
+        });
+        const validateConfig = (config) => {
+          const deviceIds = new Set();
+          const isValid = config[0].options.devices.every((device) => {
+            if (!device.deviceId || typeof device.deviceId !== 'string') {
+              homebridge.toast.error(`Invalid device ID: ${device.deviceId}`, 'Error');
+              return false;
+            }
+            if (deviceIds.has(device.deviceId)) {
+              homebridge.toast.error(`Duplicate device ID found: ${device.deviceId}`, 'Error');
+              return false;
+            }
+            deviceIds.add(device.deviceId);
+            return true;
+          });
+          return isValid;
+        };
+
+        const addDeviceToConfig = async (deviceId) => {
+          try {
+            homebridge.showSpinner();
+            const currentConfig = await homebridge.getPluginConfig();
+            if (!currentConfig[0].options.devices) {
+              currentConfig[0].options.devices = [];
+            }
+            currentConfig[0].options.devices.push({
+              deviceId: deviceId.replace(/:/g, ''),
+              hide_device: false,
+              disablePlatformBLE: false,
+              allowPush: false,
+              disableCaching: false,
+            });
+            if (!validateConfig(currentConfig)) {
+              homebridge.hideSpinner();
+              return;
+            }
+            await homebridge.updatePluginConfig(currentConfig);
+            await homebridge.savePluginConfig();
+            homebridge.toast.success('Device added to config successfully!', 'Success');
+          } catch (error) {
+            homebridge.toast.error('Failed to add device to config!', 'Error');
+          } finally {
+            homebridge.hideSpinner();
+          }
+        };
+
+        const protocolInfo = document.createElement('p');
+        protocolInfo.id = 'protocolInfo';
+        protocolInfo.style.marginTop = '10px';
+        document.getElementById('deviceInfo').appendChild(protocolInfo);
+
+        const addDeviceButton = document.createElement('button');
+        addDeviceButton.textContent = 'Add Device to Config';
+        addDeviceButton.className = 'btn btn-success';
+        addDeviceButton.style.marginTop = '10px';
+        addDeviceButton.addEventListener('click', () => {
+          const deviceId = document.getElementById('deviceId').textContent;
+          if (deviceId) {
+            addDeviceToConfig(deviceId);
+          } else {
+            homebridge.toast.error('No device ID found!', 'Error');
+          }
+        });
+        document.getElementById('deviceInfo').appendChild(addDeviceButton);
+
+        const updateTableWithDetails = (deviceContext) => {
+          const tableBody = document.querySelector('#deviceTable tbody');
+
+          Object.entries(deviceContext).forEach(([key, value]) => {
+            if (/string|number|boolean/.test(typeof value) && (typeof value !== 'string' || value.trim())) {
+              let existingCell = document.getElementById(key);
+              if (existingCell) {
+                existingCell.textContent = value;
+              } else {
+                const row = document.createElement('tr');
+                const keyCell = document.createElement('th');
+                keyCell.scope = 'row';
+                keyCell.textContent = key;
+                const valueCell = document.createElement('td');
+                valueCell.textContent = value;
+                row.appendChild(keyCell);
+                row.appendChild(valueCell);
+                tableBody.appendChild(row);
+              }
+            }
+          });
+        };
+
+        // Ensure the element exists before attempting to set its innerHTML
+        const safeSetInnerHTML = (id, value) => {
+          const element = document.getElementById(id);
+          if (element) {
+            element.innerHTML = value;
+          } else {
+            console.warn(`Element with id '${id}' not found.`);
+          }
+        };
+
         showDeviceInfo = async (UUID) => {
-          homebridge.showSpinner();
-          const thisAcc = cachedAccessories.find((x) => x.UUID === UUID);
-          const context = thisAcc.context;
-          document.getElementById('displayName').innerHTML = thisAcc.displayName;
-          document.getElementById('deviceId').innerHTML = context.deviceId;
-          document.getElementById('model').innerHTML = context.model;
-          document.getElementById('version').innerHTML = context.version;
-          document.getElementById('deviceType').innerHTML = context.deviceType;
-          document.getElementById('connectionType').innerHTML = context.connectionType;
-          document.getElementById('refreshRate').innerHTML = context.refreshRate;
-          document.getElementById('updateRate').innerHTML = context.updateRate;
-          document.getElementById('pushRate').innerHTML = context.pushRate;
-          document.getElementById('deviceTable').style.display = 'inline-table';
-          homebridge.hideSpinner();
+          try {
+            homebridge.showSpinner();
+            const thisAcc = cachedAccessories.find((x) => x.UUID === UUID);
+            if (!thisAcc) {
+              throw new Error('Device not found');
+            }
+            const context = thisAcc.context;
+            const protocol = thisAcc.isMatter ? 'Matter Protocol' : 'HAP Protocol';
+            safeSetInnerHTML('displayName', thisAcc.displayName);
+            safeSetInnerHTML('deviceId', context.deviceId);
+            safeSetInnerHTML('model', context.model);
+            safeSetInnerHTML('version', context.version);
+            safeSetInnerHTML('deviceType', context.deviceType);
+            safeSetInnerHTML('connectionType', context.connectionType);
+            safeSetInnerHTML('refreshRate', context.refreshRate);
+            safeSetInnerHTML('updateRate', context.updateRate);
+            safeSetInnerHTML('pushRate', context.pushRate);
+            safeSetInnerHTML('protocolInfo', protocol);
+            document.getElementById('deviceTable').style.display = 'inline-table';
+
+
+            updateTableWithDetails(context);
+          } catch (error) {
+            homebridge.toast.error(error.message, 'Error');
+          } finally {
+            homebridge.hideSpinner();
+          }
         };
         deviceSelect.addEventListener('change', (event) => showDeviceInfo(event.target.value));
         if (cachedAccessories.length > 0) {
@@ -246,4 +438,12 @@
       homebridge.hideSpinner();
     }
   })();
+
+  document.getElementById('dynamic-config-tab').addEventListener('click', function() {
+    // Hide other tabs
+    document.querySelectorAll('.tab-content').forEach(tab => tab.style.display = 'none');
+
+    // Show Dynamic Config tab
+    document.getElementById('dynamic-config-content').style.display = 'block';
+  });
 </script>

package/src/homebridge-ui/server.ts

@@ -1,42 +1,8 @@
-import fs from 'node:fs'
-
 import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
 
 class PluginUiServer extends HomebridgePluginUiServer {
   constructor() {
     super()
-    /*
-      A native method getCachedAccessories() was introduced in config-ui-x v4.37.0
-      The following is for users who have a lower version of config-ui-x
-    */
-    this.onRequest('getCachedAccessories', () => {
-      try {
-        const plugin = 'homebridge-switchbot'
-        const devicesToReturn = []
-
-        // The path and file of the cached accessories
-        const accFile = `${this.homebridgeStoragePath}/accessories/cachedAccessories`
-
-        // Check the file exists
-        if (fs.existsSync(accFile)) {
-          // read the cached accessories file
-          const cachedAccessories: any[] = JSON.parse(fs.readFileSync(accFile, 'utf8'))
-
-          cachedAccessories.forEach((accessory: any) => {
-            // Check the accessory is from this plugin
-            if (accessory.plugin === plugin) {
-              // Add the cached accessory to the array
-              devicesToReturn.push(accessory.accessory as never)
-            }
-          })
-        }
-        // Return the array
-        return devicesToReturn
-      } catch {
-        // Just return an empty accessory list in case of any errors
-        return []
-      }
-    })
     this.ready()
   }
 }

package/src/index.ts

@@ -7,17 +7,11 @@ import type { API } from 'homebridge'
 import { SwitchBotHAPPlatform } from './platform-hap.js'
 import { SwitchBotMatterPlatform } from './platform-matter.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
+import { createPlatformProxy } from './utils.js'
 
 // Register our platform with homebridge.
 export default (api: API): void => {
-  // Call the instance method on the runtime `api` object (optional chaining in case
-  // older homebridge doesn't provide it). Treat undefined as false.
-  const isMatter = typeof api.isMatterEnabled === 'function'
-    ? Boolean(api.isMatterEnabled())
-    : Boolean((api as any).isMatterEnabled)
-
-  const log = (api as any).logger ?? (api as any).log ?? console
-  log.info?.(`Homebridge SwitchBot Plugin initializing in ${isMatter ? 'Matter' : 'HAP'} mode.`)
-  // If Matter is enabled register the Matter platform, otherwise use HAP platform.
-  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, isMatter ? SwitchBotMatterPlatform : SwitchBotHAPPlatform)
+  // Create and register a small proxy that selects the correct platform (HAP or Matter) at runtime.
+  const ProxyCtor = createPlatformProxy(SwitchBotHAPPlatform, SwitchBotMatterPlatform)
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, ProxyCtor as any)
 }

package/src/irdevice/irdevice.ts

@@ -276,69 +276,108 @@ export abstract class irdeviceBase {
   /**
    * Logging for Device
    */
-  async infoLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.info(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  infoLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    // Delegate to a single helper that prefers platform-provided loggers.
+    this.logWith('info', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async successLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.success(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  successLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('success', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugSuccessLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.success(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugSuccessLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
+    }
+    if (!this.loggingIsDebug()) {
+      return
     }
+    this.logWith('success', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugSuccessLog', String(...log))
   }
 
-  async warnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.warn(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  warnLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('warn', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugWarnLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.warn(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugWarnLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    this.logWith('warn', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugWarnLog', String(...log))
   }
 
-  async errorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      this.log.error(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  errorLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    this.logWith('error', `${this.device.remoteType}: ${this.accessory.displayName}`, undefined, String(...log))
   }
 
-  async debugErrorLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (await this.loggingIsDebug()) {
-        this.log.error(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugErrorLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    this.logWith('error', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugErrorLog', String(...log))
   }
 
-  async debugLog(...log: any[]): Promise<void> {
-    if (await this.enablingDeviceLogging()) {
-      if (this.deviceLogging === 'debug') {
-        this.log.info(`[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
-      } else if (this.deviceLogging === 'debugMode') {
-        this.log.debug(`${this.device.remoteType}: ${this.accessory.displayName}`, String(...log))
+  debugLog(...log: any[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
+    }
+    if (this.deviceLogging === 'debug') {
+      this.logWith('debug', `[DEBUG] ${this.device.remoteType}: ${this.accessory.displayName}`, 'debugLog', String(...log))
+    } else if (this.deviceLogging === 'debugMode') {
+      this.logWith('debug', `${this.device.remoteType}: ${this.accessory.displayName}`, 'debugLog', String(...log))
+    }
+  }
+
+  // Generic platform/local logger delegate
+  protected logWith(level: string, message: string, platformMethodName?: string, payload?: string): void {
+    const method = platformMethodName ?? `${level}Log`
+    const pFn = (this.platform as any)?.[method]
+    if (typeof pFn === 'function') {
+      try {
+        if (payload !== undefined) {
+          pFn(message, payload)
+        } else {
+          pFn(message)
+        }
+        return
+      } catch (_err) {
+        // fallthrough to local logger
+      }
+    }
+    const map: Record<string, string> = {
+      info: 'info',
+      success: 'success',
+      debug: 'debug',
+      warn: 'warn',
+      error: 'error',
+    }
+    const local = (this.log as any)[map[level] ?? level]
+    if (typeof local === 'function') {
+      if (payload !== undefined) {
+        local.call(this.log, message, payload)
+      } else {
+        local.call(this.log, message)
       }
     }
   }
 
-  async loggingIsDebug(): Promise<boolean> {
+  loggingIsDebug(): boolean {
     return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug'
   }
 
-  async enablingDeviceLogging(): Promise<boolean> {
+  enablingDeviceLogging(): boolean {
     return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug' || this.deviceLogging === 'standard'
   }
 }