@switchbot/homebridge-switchbot 5.0.0-beta.115 → 5.0.0-beta.117

package/src/homebridge-ui/public/js/api.ts

@@ -1,7 +1,32 @@
-// API wrapper functions for communicating with the Homebridge UI server
+import { isValidDeviceType, normalizeDeviceType } from '../../../device-types.js'
 import './types.js'
 import { uiLog } from './logger.js'
 
+/**
+ * Validate and auto-correct device types in the config array before saving.
+ * Returns an array of errors for devices that cannot be fixed.
+ */
+export function validateAndFixDeviceTypes(devices: Array<{ deviceId: string, configDeviceName: string, configDeviceType: string }>) {
+  const errors: Array<{ deviceId: string, name: string, type: string }> = []
+  for (const d of devices) {
+    if (!isValidDeviceType(d.configDeviceType)) {
+      const fixed = normalizeDeviceType(d.configDeviceType)
+      if (fixed) {
+        d.configDeviceType = fixed
+      } else {
+        errors.push({
+          deviceId: d.deviceId,
+          name: d.configDeviceName,
+          type: d.configDeviceType,
+        })
+      }
+    }
+  }
+  return errors
+}
+
+// API wrapper functions for communicating with the Homebridge UI server
+
 function isSwitchBotPlatformConfig(block: any): boolean {
   const platformName = String(block?.platform || block?.name || '').toLowerCase()
   return (
@@ -39,6 +64,12 @@ export async function syncParentPluginConfigFromDisk(autoSave = false): Promise<
       return false
     }
 
+    // Validate and fix device types before saving
+    const errors = validateAndFixDeviceTypes(diskResp.data.devices || [])
+    if (errors.length > 0) {
+      homebridge.toast?.error?.(`Invalid device types found: ${errors.map(e => `${e.name} (${e.type})`).join(', ')}`)
+      return false
+    }
     pluginConfigBlocks[index] = diskResp.data
     await homebridge.updatePluginConfig(pluginConfigBlocks)
 
@@ -74,33 +105,34 @@ export async function fetchCredentialStatus(): Promise<any> {
 }
 
 export async function saveCredentials(token: string, secret: string): Promise<any> {
-  try {
-    uiLog.info('Saving credentials...')
-    const resp = await homebridge.request('/credentials', { token, secret })
-    uiLog.info('Save response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.message || 'Save failed')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  uiLog.info('Saving credentials...')
+  const resp = await homebridge.request('/credentials', { token, secret })
+  uiLog.info('Save response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.message || 'Save failed')
   }
+  return resp.data || resp
 }
 
 export async function fetchDevices(): Promise<any[]> {
   try {
     const resp = await homebridge.request('/devices', {})
-    if (!resp || resp.success === false) { throw new Error(resp?.data?.message || 'request failed') }
+    if (!resp || resp.success === false) {
+      // Prefer backend error message if available
+      const backendMsg = resp?.data?.message || resp?.message
+      throw new Error(backendMsg || 'request failed')
+    }
     return resp.data || []
   } catch (e) {
-    uiLog.error('Error fetching devices:', e)
+    // Show the real error to the user
+    const msg = e instanceof Error ? e.message : String(e)
+    uiLog.error('Error fetching devices:', msg)
+    // Optionally, show a toast or UI error here if needed
     return []
   }
 }
 
-export type DiscoverRequestOptions = {
+export interface DiscoverRequestOptions {
   bleEnabled?: boolean
   bleScanDurationSeconds?: number
   bleTimeoutSeconds?: number
@@ -110,18 +142,12 @@ export async function discoverDevices(
   mode: 'all' | 'ble' | 'openapi' = 'all',
   options?: DiscoverRequestOptions,
 ): Promise<any[]> {
-  try {
-    const resp = await homebridge.request('/discover', { mode, ...options })
-    uiLog.info('Discover response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Discovery failed')
-    }
-
-    return resp.data || []
-  } catch (e) {
-    throw e
+  const resp = await homebridge.request('/discover', { mode, ...options })
+  uiLog.info('Discover response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Discovery failed')
   }
+  return resp.data || []
 }
 
 export async function fetchBluetoothStatus(): Promise<{ available: boolean, message: string }> {
@@ -168,43 +194,40 @@ export async function addDevice(
   type: string,
   options?: { address?: string, model?: string, rssi?: number, encryptionKey?: string, keyId?: string },
 ): Promise<any> {
-  try {
-    const payload: any = { deviceId, name, type }
-    if (options?.address) { payload.address = options.address }
-    if (options?.model) { payload.model = options.model }
-    if (options?.rssi !== undefined && options?.rssi !== null && options?.rssi !== 0) { payload.rssi = options.rssi }
-    if (options?.encryptionKey) { payload.encryptionKey = options.encryptionKey }
-    if (options?.keyId) { payload.keyId = options.keyId }
-
-    uiLog.info('Adding device to config:', payload)
-    const resp = await homebridge.request('/add-device', payload)
-    uiLog.info('Add device response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Failed to add device')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  const payload: any = { deviceId, name, type }
+  if (options?.address) {
+    payload.address = options.address
+  }
+  if (options?.model) {
+    payload.model = options.model
+  }
+  if (options?.rssi !== undefined && options?.rssi !== null && options?.rssi !== 0) {
+    payload.rssi = options.rssi
   }
+  if (options?.encryptionKey) {
+    payload.encryptionKey = options.encryptionKey
+  }
+  if (options?.keyId) {
+    payload.keyId = options.keyId
+  }
+  uiLog.info('Adding device to config:', payload)
+  const resp = await homebridge.request('/add-device', payload)
+  uiLog.info('Add device response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Failed to add device')
+  }
+  return resp.data || resp
 }
 
 export async function addDevicesInBulk(
   devices: Array<{ deviceId: string, name: string, type: string, rssi?: number, address?: string, model?: string }>,
 ): Promise<any> {
-  try {
-    const resp = await homebridge.request('/add-devices', { devices })
-    uiLog.info('Bulk add response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Bulk add failed')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  const resp = await homebridge.request('/add-devices', { devices })
+  uiLog.info('Bulk add response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Bulk add failed')
   }
+  return resp.data || resp
 }
 
 export async function updateDevice(
@@ -212,53 +235,38 @@ export async function updateDevice(
   configDeviceName?: string,
   configDeviceType?: string,
 ): Promise<any> {
-  try {
-    const params: any = { deviceId }
-    if (configDeviceName) { params.configDeviceName = configDeviceName }
-    if (configDeviceType) { params.configDeviceType = configDeviceType }
-
-    uiLog.info('[Update Device] Sending update request with params:', params)
-    const resp = await homebridge.request('/update-device', params)
-    uiLog.info('[Update Device] Update response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Failed to update device')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  const params: any = { deviceId }
+  if (configDeviceName) {
+    params.configDeviceName = configDeviceName
   }
+  if (configDeviceType) {
+    params.configDeviceType = configDeviceType
+  }
+  uiLog.info('[Update Device] Sending update request with params:', params)
+  const resp = await homebridge.request('/update-device', params)
+  uiLog.info('[Update Device] Update response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Failed to update device')
+  }
+  return resp.data || resp
 }
 
 export async function deleteDevice(deviceId: string): Promise<any> {
-  try {
-    uiLog.info('Sending delete request for deviceId:', deviceId)
-    const resp = await homebridge.request('/delete-device', { deviceId })
-    uiLog.info('Delete response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Failed to delete device')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  uiLog.info('Sending delete request for deviceId:', deviceId)
+  const resp = await homebridge.request('/delete-device', { deviceId })
+  uiLog.info('Delete response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Failed to delete device')
   }
+  return resp.data || resp
 }
 
 export async function deleteAllDevices(): Promise<any> {
-  try {
-    uiLog.info('Sending delete all devices request')
-    const resp = await homebridge.request('/delete-all-devices', {})
-    uiLog.info('Delete all response:', resp)
-
-    if (!resp || resp.success === false) {
-      throw new Error(resp?.data?.message || 'Failed to delete all devices')
-    }
-
-    return resp.data || resp
-  } catch (e) {
-    throw e
+  uiLog.info('Sending delete all devices request')
+  const resp = await homebridge.request('/delete-all-devices', {})
+  uiLog.info('Delete all response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Failed to delete all devices')
   }
+  return resp.data || resp
 }

package/src/homebridge-ui/public/js/devices.ts

@@ -81,13 +81,14 @@ export async function addDeviceToConfig(device: any, options: { refresh?: boolea
 
     return { added: !alreadyExists }
   } catch (e) {
-    uiLog.error('Add device error:', e)
+    const msg = e instanceof Error ? e.message : String(e)
+    uiLog.error('Add device error:', msg)
     const status = document.getElementById('discoverStatus')
     if (status) {
-      status.textContent = `✗ Error: ${e instanceof Error ? e.message : 'Failed to add device'}`
+      status.textContent = `✗ Error: ${msg}`
       status.classList.add('error')
     }
-    toastError(e instanceof Error ? e.message : 'Failed to add device')
+    toastError(msg)
     return { added: false }
   } finally {
     hideBusyUi()

package/src/platform.ts

@@ -97,9 +97,7 @@ export const DEVICE_MATTER_CLUSTERS: Record<string, any> = {
   }, // Switch in HAP, RobotVacuumCleaner in Matter
   curtain: {
     windowCovering: {
-      // Use Drapery (4) for lift-only/non-tilt covering to satisfy Matter conformance rules.
-      // Rollershade (0) can fail validation in some stacks when TL (tilt) is not present.
-      type: 4, // Drapery
+      type: 7, // Drapery (valid Matter type for curtains)
     },
   }, // WindowCovering → WindowCovering (includes curtain3, rollershade variants via normalization)
   blindtilt: {
@@ -1052,22 +1050,60 @@ export class SwitchBotHAPPlatform {
 
     // Wait for Homebridge to finish launching to create/register accessories
     if (this.api && typeof (this.api as any).on === 'function') {
-      ;(this.api as any).on('didFinishLaunching', () => {
-        void this.loadDevices()
+      (this.api as any).on('didFinishLaunching', async () => {
+        await this.loadDevicesWithMatterInit()
         // Start periodic config reload to pick up UI changes
         this.configReloadInterval = setInterval(() => {
-          void this.checkAndReloadDevices()
+          void this.loadDevicesWithMatterInit()
         }, 10000) // Check every 10 seconds
       })
     } else {
-      void this.loadDevices()
+      void this.loadDevicesWithMatterInit()
       // Start periodic config reload to pick up UI changes
       this.configReloadInterval = setInterval(() => {
-        void this.checkAndReloadDevices()
+        void this.loadDevicesWithMatterInit()
       }, 10000) // Check every 10 seconds
     }
   }
 
+  /**
+   * Ensures Matter API is loaded before loading devices.
+   */
+  private async loadDevicesWithMatterInit() {
+    // Wait for Matter API to be loaded and available before loading devices
+    const maxAttempts = 20 // Wait up to 10 seconds (20 x 500ms)
+    let attempt = 0
+    let matterLoaded = false
+    if (
+      this.api
+      && typeof (this.api as any).isMatterAvailable === 'function'
+      && typeof (this.api as any).isMatterEnabled === 'function'
+      && typeof (this.api as any).loadMatterAPI === 'function'
+    ) {
+      if ((this.api as any).isMatterAvailable() && (this.api as any).isMatterEnabled()) {
+        try {
+          await (this.api as any).loadMatterAPI()
+          this.log.info('Homebridge Matter API loaded successfully')
+        } catch (e) {
+          this.log.warn('Failed to load Homebridge Matter API', e)
+        }
+        // Wait for api.matter to be available
+        while (attempt < maxAttempts) {
+          if ((this.api as any).matter) {
+            matterLoaded = true
+            break
+          }
+          await new Promise(res => setTimeout(res, 500))
+          attempt++
+        }
+        if (!matterLoaded) {
+          this.log.warn('Matter API did not become available after loadMatterAPI()')
+        }
+      }
+    }
+    await this.loadDevices()
+  }
+
   private getConfigHash(): string {
     // Create a simple hash of current device config to detect changes
     const devices = (this.config as any)?.devices ?? []
@@ -1078,16 +1114,6 @@ export class SwitchBotHAPPlatform {
     })))
   }
 
-  private async checkAndReloadDevices() {
-    const currentHash = this.getConfigHash()
-    if (currentHash !== this.lastConfigHash) {
-      this.log.info('[SwitchBot] Detected config changes, reloading devices...')
-      // Clear existing devices
-      this.devices = []
-      await this.loadDevices()
-    }
-  }
-
   async loadDevices() {
     const devices = (this.config as any)?.devices ?? []
     for (const raw of devices) {
@@ -1115,11 +1141,11 @@ export class SwitchBotHAPPlatform {
         // Prefer Matter: try registering to the Matter child bridge first.
         let matterRegistered = false
         if (useMatter) {
-          this.log.info(`Attempting Matter registration for ${d.id} (${type})`)
-          // If Homebridge Matter APIs are available, register the accessory
-          try {
-            const matterApi = (this.api as any)?.matter
-            if (this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.() && matterApi && typeof matterApi.registerPlatformAccessories === 'function') {
+          // Only attempt Matter registration if api.matter is truly available
+          const matterApi = (this.api as any)?.matter
+          if (this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.() && matterApi && typeof matterApi.registerPlatformAccessories === 'function') {
+            this.log.info(`Attempting Matter registration for ${d.id} (${type})`)
+            try {
               const createdDesc = created.createAccessory?.(this.api) || { id: d.id, name: d.name || type }
               const uuid = matterApi.uuid.generate(`${d.id}`)
               const defaultClusters = DEVICE_MATTER_CLUSTERS[type.toLowerCase()] || { onOff: { onOff: false } }
@@ -1139,19 +1165,15 @@ export class SwitchBotHAPPlatform {
                 handlers: createdDesc.handlers || createMatterHandlers(this.log, d.id, type, (this.config as any)?._client) || undefined,
                 context: { deviceId: d.id, type, _created: true },
               }
-              try {
-                await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory])
-                this.accessories.set(uuid, accessory)
-                matterRegistered = true
-                this.log.info(`Registered Matter accessory ${d.id} (${type}) with uuid=${uuid}`)
-              } catch (e) {
-                this.log.warn('Failed to register Matter accessory with Homebridge matter API', e)
-              }
-            } else {
-              this.log.info('Homebridge Matter API not available or not enabled; will fallback to HAP')
+              await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory])
+              this.accessories.set(uuid, accessory)
+              matterRegistered = true
+              this.log.info(`Registered Matter accessory ${d.id} (${type}) with uuid=${uuid}`)
+            } catch (e) {
+              this.log.warn('Failed to register Matter accessory with Homebridge matter API', e)
             }
-          } catch (e) {
-            this.log.warn('Matter registration attempt failed', e)
+          } else {
+            this.log.info(`Matter API not available for ${d.id} (${type}); skipping Matter registration and falling back to HAP`)
           }
         }
 

package/test/matter-integration.spec.ts

@@ -43,7 +43,7 @@ describe('Matter integration harness', () => {
     const regs = matterApi.getRegistered()
     expect(regs.length).toBeGreaterThanOrEqual(1)
     const wcType = regs[0]?.clusters?.windowCovering?.type
-    expect(wcType).toBe(4)
+    expect(wcType).toBe(7) // 7 = Drapery (Matter spec)
     expect(wcType).not.toBe(0)
   })