@switchbot/homebridge-switchbot 5.0.0-beta.6 → 5.0.0-beta.60

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,6 +70,18 @@
           <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>
     <p class="text-center">External accessories will not be displayed here.</p>
@@ -109,7 +122,7 @@
   <h5>Help/About</h5>
   <ul>
     <li>
-      <a href="https://github.com/OpenWonderLabs/homebridge-switchbot/issues/new/choose" target="_blank">Support
+      <a href="https://
         Request</a>
     </li>
     <li>
@@ -118,10 +131,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,10 +197,25 @@
         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
+          }
+        }
         if (cachedAccessories.length > 0) {
           cachedAccessories.sort((a, b) => {
             return a.displayName.toLowerCase() > b.displayName.toLowerCase() ? 1 : b.displayName.toLowerCase() > a.displayName.toLowerCase() ? -1 : 0;
@@ -161,21 +229,127 @@
           option.value = a.UUID;
           deviceSelect.add(option);
         });
+        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,
+              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 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 protocolInfo = document.createElement('p');
+        protocolInfo.id = 'protocolInfo';
+        protocolInfo.style.marginTop = '10px';
+        document.getElementById('deviceInfo').appendChild(protocolInfo);
+
+        const updateTableWithDetails = (deviceContext) => {
+          const tableBody = document.querySelector('#deviceTable tbody');
+          tableBody.innerHTML = '';
+
+          Object.entries(deviceContext).forEach(([key, value]) => {
+            if (value !== undefined && value !== null && String(value).trim() !== '') {
+              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 +420,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

@@ -9,9 +9,12 @@ class PluginUiServer extends HomebridgePluginUiServer {
       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', () => {
+    const getCachedAccessoriesHandler = () => {
       try {
-        const plugin = 'homebridge-switchbot'
+        // Some Homebridge versions store cached accessories with the scoped
+        // plugin name ("@switchbot/homebridge-switchbot"); others may use
+        // the unscoped id ("homebridge-switchbot"). Check both.
+        const pluginNames = ['@switchbot/homebridge-switchbot', 'homebridge-switchbot']
         const devicesToReturn = []
 
         // The path and file of the cached accessories
@@ -22,21 +25,94 @@ class PluginUiServer extends HomebridgePluginUiServer {
           // 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)
+          cachedAccessories.forEach((entry: any) => {
+            // entry shape varies by UI version
+            const pluginName = entry.plugin || entry?.accessory?.plugin || entry?.accessory?.pluginName
+            const acc = entry.accessory ?? entry
+            if (pluginNames.includes(pluginName)) {
+              devicesToReturn.push(acc as never)
             }
           })
         }
         // Return the array
+        console.warn(`[Homebridge UI] getCachedAccessories returning ${devicesToReturn.length} device(s)`)
         return devicesToReturn
-      } catch {
+      } catch (e: any) {
         // Just return an empty accessory list in case of any errors
+        console.error(`[Homebridge UI] getCachedAccessories error: ${e?.message ?? e}`)
         return []
       }
-    })
+    }
+    this.onRequest('getCachedAccessories', getCachedAccessoriesHandler)
+    // Also register with a leading slash for compatibility with some UIs
+    this.onRequest('/getCachedAccessories', getCachedAccessoriesHandler)
+    // Provide Matter cached accessories if Homebridge stores them separately.
+    const getCachedMatterAccessoriesHandler = () => {
+      try {
+        const pluginNames = ['@switchbot/homebridge-switchbot', 'homebridge-switchbot']
+        const devicesToReturn: any[] = []
+
+        const accFile = `${this.homebridgeStoragePath}/accessories/cachedAccessories`
+        const matterFile = `${this.homebridgeStoragePath}/accessories/cachedMatterAccessories`
+
+        // Log all files in the accessories directory for debugging
+        try {
+          const accessoriesDir = `${this.homebridgeStoragePath}/accessories`
+          if (fs.existsSync(accessoriesDir)) {
+            const files = fs.readdirSync(accessoriesDir)
+            console.warn(`[Homebridge UI] Files in accessories directory: ${files.join(', ')}`)
+          }
+        } catch (e: any) {
+          console.error(`[Homebridge UI] Error listing accessories directory: ${e?.message ?? e}`)
+        }
+
+        console.warn(`[Homebridge UI] Checking for cached files:`)
+        console.warn(`[Homebridge UI]   - cachedAccessories: ${fs.existsSync(accFile)}`)
+        console.warn(`[Homebridge UI]   - cachedMatterAccessories: ${fs.existsSync(matterFile)}`)
+        console.warn(`[Homebridge UI] Matter cached accessories file exists: ${fs.existsSync(matterFile)}`)
+        if (fs.existsSync(matterFile)) {
+          const matterAccessories: any[] = JSON.parse(fs.readFileSync(matterFile, 'utf8'))
+          console.warn(`[Homebridge UI] Matter Cached Accessories:`, matterAccessories)
+        }
+
+        const readAndCollect = (filePath: string) => {
+          if (!fs.existsSync(filePath)) {
+            return
+          }
+          try {
+            const parsed: any[] = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+            console.warn(`[Homebridge UI]   - ${filePath}: found ${parsed.length} total entries`)
+            let matchCount = 0
+            parsed.forEach((entry: any) => {
+              // Entry shape varies between Homebridge versions; try common locations
+              const pluginName = entry.plugin || entry?.accessory?.plugin || entry?.accessory?.pluginName
+              const acc = entry.accessory ?? entry
+              if (pluginNames.includes(pluginName)) {
+                devicesToReturn.push(acc as never)
+                matchCount++
+              }
+            })
+            console.warn(`[Homebridge UI]   - ${filePath}: matched ${matchCount} SwitchBot entries`)
+          } catch (e: any) {
+            // ignore parse errors for a single file
+            console.error(`[Homebridge UI]   - ${filePath}: parse error - ${e?.message ?? e}`)
+          }
+        }
+
+        // Read both canonical files (some Homebridge versions use one or the other)
+        readAndCollect(accFile)
+        readAndCollect(matterFile)
+
+        console.warn(`[Homebridge UI] getCachedMatterAccessories returning ${devicesToReturn.length} device(s)`)
+        return devicesToReturn
+      } catch (e: any) {
+        console.error(`[Homebridge UI] getCachedMatterAccessories error: ${e?.message ?? e}`)
+        return []
+      }
+    }
+    this.onRequest('getCachedMatterAccessories', getCachedMatterAccessoriesHandler)
+    // Also register with a leading slash for compatibility with some UIs
+    this.onRequest('/getCachedMatterAccessories', getCachedMatterAccessoriesHandler)
     this.ready()
   }
 }

package/src/index.ts

@@ -7,14 +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 = Boolean(api.isMatterEnabled?.())
-  const log = (api as any).logger ?? 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'
   }
 }