@switchbot/homebridge-switchbot 5.0.0-beta.33 → 5.0.0-beta.35

package/src/devices-matter/BaseMatterAccessory.ts

@@ -10,7 +10,7 @@
 
 import type { API, EndpointType, Logger, MatterAccessory } from 'homebridge'
 
-import { rgb2hs } from '../utils.js'
+import { deviceLoggingEnabled, deviceLoggingIsDebug, logDeviceStatusCode, rgb2hs } from '../utils.js'
 
 export interface BaseMatterAccessoryConfig {
   uuid: string
@@ -139,20 +139,28 @@ export abstract class BaseMatterAccessory implements MatterAccessory {
    */
   public async loggingIsDebug(): Promise<boolean> {
     const ctx: any = this.context as any
-    const deviceLogging = ctx?.deviceLogging
-    // deviceLogging may be a string ('debug', 'debugMode', 'standard') or undefined
-    return deviceLogging === 'debugMode' || deviceLogging === 'debug'
+    return deviceLoggingIsDebug(ctx?.deviceLogging)
   }
 
   public async enablingDeviceLogging(): Promise<boolean> {
     const ctx: any = this.context as any
-    const deviceLogging = ctx?.deviceLogging
-    // If deviceLogging isn't provided, fall back to the platform-wide flag
-    // that indicates whether platform logging is enabled.
-    if (deviceLogging === undefined) {
-      return Boolean((ctx as any)?.platformLogging)
-    }
-    return deviceLogging === 'debugMode' || deviceLogging === 'debug' || deviceLogging === 'standard'
+    return deviceLoggingEnabled(ctx?.deviceLogging, ctx?.platformLogging)
+  }
+
+  /**
+   * Status code logging using shared helper
+   */
+  public async statusCode(statusCode: number, deviceId?: string, hubDeviceId?: string): Promise<void> {
+    await logDeviceStatusCode(
+      statusCode,
+      {
+        debugLog: this.logDebug.bind(this),
+        errorLog: this.logError.bind(this),
+        infoLog: this.logInfo.bind(this),
+      },
+      deviceId ?? (this.context as any)?.deviceId,
+      hubDeviceId ?? (this.context as any)?.hubDeviceId,
+    )
   }
 
   /**

package/src/platform-hap.ts

@@ -55,7 +55,7 @@ import { TV } from './irdevice/tv.js'
 import { VacuumCleaner } from './irdevice/vacuumcleaner.js'
 import { WaterHeater } from './irdevice/waterheater.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { ApiRequestTracker, cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, isSuccessfulStatusCode, logStatusCode, mergeByDeviceId, safeStringify, sleep } from './utils.js'
+import { ApiRequestTracker, createPlatformLogger, formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, isSuccessfulStatusCode, logStatusCode, mergeByDeviceId, safeStringify, sleep } from './utils.js'
 
 /**
  * HomebridgePlatform
@@ -161,20 +161,8 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       // swallow any logging errors — diagnostics are best-effort
     }
 
-    // Normalize deviceConfig to remove UI-inserted defaults (lots of false/empty values)
-    try {
-      if ((this.config as any).options) {
-        const cleaned = cleanDeviceConfig((this.config as any).options.deviceConfig)
-        if (cleaned) {
-          ;(this.config as any).options.deviceConfig = cleaned
-        } else {
-          // remove the empty deviceConfig so downstream checks treat it as absent
-          delete (this.config as any).options.deviceConfig
-        }
-      }
-    } catch (e) {
-      this.debugErrorLog(`Failed to clean deviceConfig: ${e}`)
-    }
+    // Note: deviceConfig and irdeviceConfig have been removed from the platform.
+    // All device-specific configuration should be done via options.devices and options.irdevices arrays.
 
     // Plugin Configuration
     this.getPlatformLogSettings()
@@ -552,7 +540,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
   }
 
   private async handleDevices(deviceLists: any[]) {
-    if (!this.config.options?.devices && !this.config.options?.deviceConfig) {
+    if (!this.config.options?.devices) {
       this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`)
       if (deviceLists.length === 0) {
         this.debugLog('SwitchBot API Has No Devices With Cloud Services Enabled')
@@ -566,80 +554,62 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
           }
         }
       }
-    } else if (this.config.options?.devices || this.config.options?.deviceConfig) {
+    } else {
       this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`)
 
-      // Step 1: Check and assign configDeviceType to deviceType if deviceType is not present
-      const devicesWithTypeConfigPromises = deviceLists.map(async (device) => {
+      // Check and assign configDeviceType to deviceType if deviceType is not present
+      const devicesWithTypeAssigned = deviceLists.map((device) => {
         if (!device.deviceType) {
           device.deviceType = device.configDeviceType !== undefined ? device.configDeviceType : 'Unknown'
           this.warnLog(`API is displaying no deviceType: ${device.deviceType}, So using configDeviceType: ${device.configDeviceType}`)
         }
-
-        // Retrieve deviceTypeConfig for each device and merge it
-        const deviceTypeConfig = this.config.options?.deviceConfig?.[device.deviceType] || {}
-        return Object.assign({}, device, deviceTypeConfig)
+        return device
       })
 
-      // Wait for all promises to resolve
-      const devicesWithTypeConfig = (await Promise.all(devicesWithTypeConfigPromises)).filter(device => device !== null) // Filter out skipped devices
-
-      const devices = this.mergeByDeviceId(this.config.options.devices ?? [], devicesWithTypeConfig ?? [])
+      const devices = this.mergeByDeviceId(this.config.options.devices ?? [], devicesWithTypeAssigned ?? [])
 
       this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`)
 
       for (const device of devices) {
-        const deviceIdConfig = this.config.options?.devices?.[device.deviceId] || {}
-        const deviceWithConfig = Object.assign({}, device, deviceIdConfig)
-
         if (device.configDeviceName) {
           device.deviceName = device.configDeviceName
         }
-        // Pass the merged device object to createDevice
-        await this.createDevice(deviceWithConfig)
+        await this.createDevice(device)
       }
     }
   }
 
   private async handleIRDevices(irDeviceLists: any[]) {
-    if (!this.config.options?.irdevices && !this.config.options?.irdeviceConfig) {
+    if (!this.config.options?.irdevices) {
       this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`)
       for (const device of irDeviceLists) {
         if (device.remoteType) {
           await this.createIRDevice(device)
         }
       }
-    } else if (this.config.options?.irdevices || this.config.options?.irdeviceConfig) {
+    } else {
       this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`)
 
-      // Step 1: Check and assign configRemoteType to remoteType if remoteType is not present
-      const devicesWithTypeConfigPromises = irDeviceLists.map(async (device) => {
+      // Check and assign configRemoteType to remoteType if remoteType is not present
+      const devicesWithTypeAssigned = irDeviceLists.map((device) => {
         if (!device.remoteType && device.configRemoteType) {
           device.remoteType = device.configRemoteType
           this.warnLog(`API is displaying no remoteType: ${device.remoteType}, So using configRemoteType: ${device.configRemoteType}`)
         } else if (!device.remoteType && !device.configDeviceName) {
           this.errorLog('No remoteType or configRemoteType for device. No device will be created.')
-          return null // Skip this device
+          return null
         }
+        return device
+      }).filter(device => device !== null) // Filter out skipped devices
 
-        // Retrieve remoteTypeConfig for each device and merge it
-        const remoteTypeConfig = this.config.options?.irdeviceConfig?.[device.remoteType] || {}
-        return Object.assign({}, device, remoteTypeConfig)
-      })
-      // Wait for all promises to resolve
-      const devicesWithRemoteTypeConfig = (await Promise.all(devicesWithTypeConfigPromises)).filter(device => device !== null) // Filter out skipped devices
-
-      const devices = this.mergeByDeviceId(this.config.options.irdevices ?? [], devicesWithRemoteTypeConfig ?? [])
+      const devices = this.mergeByDeviceId(this.config.options.irdevices ?? [], devicesWithTypeAssigned ?? [])
 
       this.debugLog(`IR Devices: ${JSON.stringify(devices)}`)
       for (const device of devices) {
-        const irdeviceIdConfig = this.config.options?.irdevices?.[device.deviceId] || {}
-        const irdeviceWithConfig = Object.assign({}, device, irdeviceIdConfig)
-
         if (device.configDeviceName) {
           device.deviceName = device.configDeviceName
         }
-        await this.createIRDevice(irdeviceWithConfig)
+        await this.createIRDevice(device)
       }
     }
   }

package/src/platform-matter.ts

@@ -42,7 +42,7 @@ import {
   WindowBlindAccessory,
 } from './devices-matter/index.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { ApiRequestTracker, cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, hs2rgb, isSuccessfulStatusCode, makeBLESender, makeOpenAPISender, mergeByDeviceId, normalizeDeviceId, rgb2hs, sleep } from './utils.js'
+import { ApiRequestTracker, createPlatformLogger, formatDeviceIdAsMac, hs2rgb, isSuccessfulStatusCode, makeBLESender, makeOpenAPISender, mergeByDeviceId, normalizeDeviceId, rgb2hs, sleep } from './utils.js'
 
 export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   // Track restored HAP cached accessories (required for DynamicPlatformPlugin)
@@ -130,19 +130,8 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
 
     this.debugLog('Finished initializing platform:', this.config.name)
 
-    // Normalize deviceConfig to remove UI-inserted defaults
-    try {
-      if ((this.config as any).options) {
-        const cleaned = cleanDeviceConfig((this.config as any).options.deviceConfig)
-        if (cleaned) {
-          ;(this.config as any).options.deviceConfig = cleaned
-        } else {
-          delete (this.config as any).options.deviceConfig
-        }
-      }
-    } catch (e) {
-      this.debugLog('Failed to clean deviceConfig: %s', e)
-    }
+    // Note: deviceConfig and irdeviceConfig have been removed from the platform.
+    // All device-specific configuration should be done via options.devices arrays.
 
     // Does the user have a version of Homebridge that is compatible with matter?
     if (!this.api.isMatterAvailable?.()) {
@@ -429,46 +418,27 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   }
 
   /**
-   * Merge discovered devices with deviceConfig (per deviceType) and per-device overrides
-   * from `config.options.devices`, matching the behavior used in platform-hap.
+   * Merge discovered devices with per-device overrides from `config.options.devices`
    */
   private async mergeDiscoveredDevices(discovered: device[]): Promise<any[]> {
-    // If there's no device config or per-device config, return discovered as-is
-    if (!this.config.options?.devices && !this.config.options?.deviceConfig) {
+    // If there's no per-device config, return discovered as-is
+    if (!this.config.options?.devices) {
       return discovered
     }
 
-    // Step 1: Assign missing deviceType from configDeviceType and merge deviceType-level configs
-    const devicesWithTypeConfig = await Promise.all(discovered.map(async (deviceObj) => {
+    // Assign missing deviceType from configDeviceType if needed
+    const devicesWithTypeAssigned = discovered.map((deviceObj) => {
       if (!deviceObj.deviceType) {
         deviceObj.deviceType = (deviceObj as any).configDeviceType !== undefined ? (deviceObj as any).configDeviceType : 'Unknown'
         this.debugLog(`API missing deviceType for ${deviceObj.deviceId}, using configDeviceType: ${(deviceObj as any).configDeviceType}`)
       }
-      const deviceTypeConfig = this.config.options?.deviceConfig?.[deviceObj.deviceType] || {}
-      return Object.assign({}, deviceObj, deviceTypeConfig)
-    }))
+      return deviceObj
+    })
 
     // Merge per-device overrides by matching deviceId
-    const merged = this.mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTypeConfig ?? [])
-
-    // For any entries in merged (which are based on config.options.devices), ensure final per-device merges include deviceId-specific config
-    const final: any[] = []
-    for (const device of merged) {
-      // Find per-device config entry by deviceId (config.options.devices is an array)
-      const deviceIdConfig = (this.config.options?.devices || []).find((d: any) => 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: any) => this.normalizeDeviceId(d.deviceId)))
-    for (const d of devicesWithTypeConfig) {
-      if (!userDeviceIds.has(this.normalizeDeviceId(d.deviceId))) {
-        final.push(d)
-      }
-    }
+    const merged = this.mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTypeAssigned ?? [])
 
-    return final
+    return merged
   }
 
   /**
@@ -1714,10 +1684,6 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Register all Matter accessories
    */
   private async registerMatterAccessories() {
-    this.debugLog('═'.repeat(80))
-    this.infoLog('Homebridge Matter Plugin')
-    this.debugLog('═'.repeat(80))
-
     // Remove accessories that are disabled in config
     await this.removeDisabledAccessories()
 

package/src/settings.ts

@@ -32,9 +32,7 @@ interface credentials {
 
 export interface options {
   devices?: devicesConfig[]
-  deviceConfig?: { [deviceType: string]: devicesConfig }
   irdevices?: irDevicesConfig[]
-  irdeviceConfig?: { [remoteType: string]: irDevicesConfig }
   allowInvalidCharacters?: boolean
   // When true, devices declared in config.options.devices that are not
   // discovered via the SwitchBot OpenAPI will still be included (config-only

package/src/utils.ts

@@ -672,55 +672,6 @@ export function m2hs(m) {
   return [Math.round(toReturn[1]), Math.round(toReturn[0])]
 }
 
-/**
- * Remove deviceConfig entries that contain only default/empty values.
- * Returns undefined if nothing meaningful remains.
- */
-export function cleanDeviceConfig(deviceConfig?: Record<string, Record<string, any>>): Record<string, Record<string, any>> | undefined {
-  if (!deviceConfig || typeof deviceConfig !== 'object') {
-    return undefined
-  }
-
-  const cleaned: Record<string, Record<string, any>> = {}
-
-  for (const [deviceName, cfg] of Object.entries(deviceConfig)) {
-    if (!cfg || typeof cfg !== 'object') {
-      continue
-    }
-
-    const hasMeaningful = Object.values(cfg).some((v) => {
-      if (v === null || v === undefined) {
-        return false
-      }
-      if (typeof v === 'boolean') {
-        return v === true
-      }
-      if (typeof v === 'string') {
-        return v.trim().length > 0
-      }
-      if (typeof v === 'number') {
-        return Number.isFinite(v)
-      }
-      if (Array.isArray(v)) {
-        return v.length > 0
-      }
-      if (typeof v === 'object') {
-        return Object.keys(v).length > 0
-      }
-      return true
-    })
-
-    if (hasMeaningful) {
-      cleaned[deviceName] = cfg
-    }
-  }
-
-  if (Object.keys(cleaned).length > 0) {
-    return cleaned
-  }
-  return undefined
-}
-
 /**
  * Factory that returns a function to send OpenAPI commands using a retry wrapper.
  *
@@ -1205,3 +1156,85 @@ export async function logStatusCode(statusCode: number, log: {
     await log.errorLog(message)
   }
 }
+
+/**
+ * Shared device logging helpers
+ */
+
+/**
+ * Check if device logging is in debug mode
+ */
+export function deviceLoggingIsDebug(deviceLogging?: string): boolean {
+  return deviceLogging === 'debugMode' || deviceLogging === 'debug'
+}
+
+/**
+ * Check if device logging is enabled
+ */
+export function deviceLoggingEnabled(deviceLogging?: string, platformLogging?: string): boolean {
+  // If deviceLogging isn't provided, fall back to platform-wide flag
+  if (deviceLogging === undefined || deviceLogging === '') {
+    return platformLogging === 'debugMode' || platformLogging === 'debug' || platformLogging === 'standard'
+  }
+  return deviceLogging === 'debugMode' || deviceLogging === 'debug' || deviceLogging === 'standard'
+}
+
+/**
+ * Device status code handler with comprehensive messages
+ */
+export interface DeviceStatusCodeLogger {
+  debugLog: (...args: any[]) => void | Promise<void>
+  debugErrorLog?: (...args: any[]) => void | Promise<void>
+  errorLog: (...args: any[]) => void | Promise<void>
+  infoLog?: (...args: any[]) => void | Promise<void>
+}
+
+export async function logDeviceStatusCode(
+  statusCode: number,
+  log: DeviceStatusCodeLogger,
+  deviceId?: string,
+  hubDeviceId?: string,
+): Promise<void> {
+  let adjustedStatusCode = statusCode
+
+  // Handle special case where device is its own hub
+  if (statusCode === 171 && hubDeviceId && deviceId && (hubDeviceId === deviceId || hubDeviceId === '000000000000')) {
+    if (log.debugErrorLog) {
+      log.debugErrorLog(`statusCode 171 changed to 161: hubDeviceId ${hubDeviceId} matches deviceId ${deviceId}, device is its own hub.`)
+    }
+    adjustedStatusCode = 161
+  }
+
+  const statusMessages: { [key: number]: string } = {
+    151: 'Command not supported by this device type',
+    152: 'Device not found',
+    160: 'Command is not supported',
+    161: 'Device is offline',
+    171: hubDeviceId ? `Hub Device is offline. Hub: ${hubDeviceId}` : 'Hub Device is offline',
+    190: 'Device internal error due to device states not synchronized with server, or command format is invalid',
+    100: 'Command successfully sent',
+    200: 'Request successful',
+    400: 'Bad Request, an invalid payload request',
+    401: 'Unauthorized, Authorization for the API is required, but the request has not been authenticated',
+    403: 'Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found',
+    404: 'Not Found, Specifies the requested path does not exist',
+    406: 'Not Acceptable, a MIME type has been requested via the Accept header for a value not supported by the server',
+    415: 'Unsupported Media Type, a contentType header has been defined that is not supported by the server',
+    422: 'Unprocessable Entity: The server cannot process the request, often due to exceeded API limits.',
+    429: 'Too Many Requests, exceeded the number of requests allowed for a given time window',
+    500: 'Internal Server Error, An unexpected error occurred. These errors should be rare',
+  }
+
+  const logMessage = statusMessages[adjustedStatusCode] || `Unknown statusCode: ${adjustedStatusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`
+  const fullMessage = `${logMessage}, statusCode: ${adjustedStatusCode}`
+
+  if ([100, 200].includes(adjustedStatusCode)) {
+    await log.debugLog(fullMessage)
+  } else if (statusMessages[adjustedStatusCode]) {
+    await log.errorLog(fullMessage)
+  } else if (log.infoLog) {
+    await log.infoLog(fullMessage)
+  } else {
+    await log.errorLog(fullMessage)
+  }
+}