@switchbot/homebridge-switchbot 5.0.0-beta.32 → 5.0.0-beta.34

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, safeStringify, sleep } from './utils.js'
+import { ApiRequestTracker, cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, isBlindTiltDevice, isCurtainDevice, isSuccessfulStatusCode, logStatusCode, mergeByDeviceId, safeStringify, sleep } from './utils.js'
 
 /**
  * HomebridgePlatform
@@ -543,8 +543,12 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     }
   }
 
+  /**
+   * Check if an API status code indicates success
+   * @deprecated Use shared isSuccessfulStatusCode from utils.js instead
+   */
   private isSuccessfulResponse(apiStatusCode: number): boolean {
-    return (apiStatusCode === 200 || apiStatusCode === 100)
+    return isSuccessfulStatusCode(apiStatusCode)
   }
 
   private async handleDevices(deviceLists: any[]) {
@@ -640,12 +644,12 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
     }
   }
 
+  /**
+   * Merge two arrays by deviceId
+   * @deprecated Use shared mergeByDeviceId from utils.js instead
+   */
   private mergeByDeviceId(a1: { deviceId: string }[], a2: any[]) {
-    const normalizeDeviceId = (deviceId: string) => deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '')
-    return a1.map((itm) => {
-      const matchingItem = a2.find(item => normalizeDeviceId(item.deviceId) === normalizeDeviceId(itm.deviceId))
-      return { ...matchingItem, ...itm }
-    })
+    return mergeByDeviceId(a1, a2, false)
   }
 
   private async handleErrorResponse(apiStatusCode: number, retryCount: number, maxRetries: number, delayBetweenRetries: number) {
@@ -2772,41 +2776,13 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
    *
    * @param statusCode - The status code returned by the device.
    * @returns A promise that resolves when the logging is complete.
+   * @deprecated Use shared logStatusCode from utils.js instead
    */
   async statusCode(statusCode: number): Promise<void> {
-    const messages: { [key: number]: string } = {
-      151: `Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: 
-            https://tinyurl.com/SwitchBotFeatureRequest`,
-      152: `Device not found, statusCode: ${statusCode}`,
-      160: `Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`,
-      161: `Device is offline, statusCode: ${statusCode}`,
-      171: `is offline, statusCode: ${statusCode}`,
-      190: `Requests reached the daily limit, statusCode: ${statusCode}`,
-      100: `Command successfully sent, statusCode: ${statusCode}`,
-      200: `Request successful, statusCode: ${statusCode}`,
-      400: `Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request payload, 
-            statusCode: ${statusCode}`,
-      401: `Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`,
-      403: `Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found, 
-            statusCode: ${statusCode}`,
-      404: `Not Found, Specifies the requested path does not exist, statusCode: ${statusCode}`,
-      406: `Not Acceptable, The client has requested a MIME type via the Accept header for a value not supported by the server, 
-            statusCode: ${statusCode}`,
-      415: `Unsupported Media Type, The client has defined a contentType header that is not supported by the server, statusCode: ${statusCode}`,
-      422: `Unprocessable Entity, The client has made a valid request, but the server cannot process it. This is often used for APIs for which 
-            certain limits have been exceeded, statusCode: ${statusCode}`,
-      429: `Too Many Requests, The client has exceeded the number of requests allowed for a given time window, statusCode: ${statusCode}`,
-      500: `Internal Server Error, An unexpected error on the SmartThings servers has occurred. These errors should be rare, 
-            statusCode: ${statusCode}`,
-    }
-
-    const message = messages[statusCode] ?? `Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`
-
-    if ([100, 200].includes(statusCode)) {
-      this.debugLog(message)
-    } else {
-      this.errorLog(message)
-    }
+    await logStatusCode(statusCode, {
+      debugLog: this.debugLog.bind(this),
+      errorLog: this.errorLog.bind(this),
+    })
   }
 
   async retryRequest(device: (device & devicesConfig) | (irdevice & irDevicesConfig), deviceMaxRetries: number, deviceDelayBetweenRetries: number): Promise<{ response: any, statusCode: deviceStatusRequest['statusCode'] }> {

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, makeBLESender, makeOpenAPISender, rgb2hs, sleep } from './utils.js'
+import { ApiRequestTracker, cleanDeviceConfig, 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)
@@ -365,9 +365,10 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
 
   /**
    * Normalize a deviceId for matching (uppercase alphanumerics only)
+   * @deprecated Use shared normalizeDeviceId from utils.js instead
    */
   private normalizeDeviceId(deviceId: string) {
-    return (deviceId ?? '').toUpperCase().replace(/[^A-Z0-9]+/g, '')
+    return normalizeDeviceId(deviceId)
   }
 
   /** Determine the platform-level batch interval in seconds */
@@ -420,21 +421,11 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   /**
    * 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.
+   * @deprecated Use shared mergeByDeviceId from utils.js instead
    */
   private mergeByDeviceId(a1: { deviceId: string }[], a2: any[]) {
     const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
-    const result: any[] = []
-    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
+    return mergeByDeviceId(a1, a2, allowConfigOnly)
   }
 
   /**
@@ -993,7 +984,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
           } catch (e) {
             this.debugLog(`OpenAPI getDeviceStatus for ${dev.deviceId} returned statusCode=${statusCode} (body not stringifiable)`)
           }
-          if (!(statusCode === 100 || statusCode === 200)) {
+          if (!isSuccessfulStatusCode(statusCode)) {
             return
           }
           const status = body?.status ?? body
@@ -1035,7 +1026,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
             } catch (e) {
               this.debugLog(`Initial OpenAPI refresh for ${dev.deviceId} returned statusCode=${statusCode} (body not stringifiable)`)
             }
-            if (statusCode === 100 || statusCode === 200) {
+            if (isSuccessfulStatusCode(statusCode)) {
               const status = body?.status ?? body
               await this.applyStatusToAccessory(uuid, dev, status)
               this.infoLog(`Initial OpenAPI refresh succeeded for ${dev.deviceId}`)
@@ -1091,7 +1082,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
       this.apiTracker?.track()
       const { response, statusCode } = await this.switchBotAPI.getDevices()
       this.debugLog(`SwitchBot getDevices response status: ${statusCode}`)
-      if (statusCode === 100 || statusCode === 200) {
+      if (isSuccessfulStatusCode(statusCode)) {
         const deviceList = Array.isArray(response?.body?.deviceList) ? response.body.deviceList : []
         this.discoveredDevices = deviceList
         this.infoLog(`Discovered ${deviceList.length} SwitchBot device(s) from OpenAPI`)
@@ -2300,7 +2291,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
         const { response, statusCode } = await this.switchBotAPI!.getDeviceStatus(deviceId, this.config.credentials?.token, this.config.credentials?.secret)
         const respAny: any = response
         const body = respAny?.body ?? respAny
-        if (statusCode === 100 || statusCode === 200) {
+        if (isSuccessfulStatusCode(statusCode)) {
           const status = body?.status ?? body
           this.deviceStatusCache.set(this.normalizeDeviceId(deviceId), { status, timestamp: Date.now() })
           this.debugLog(`OpenAPI refresh succeeded for ${deviceId} (attempt ${attempt + 1})`)

package/src/utils.ts

@@ -1132,3 +1132,158 @@ export class ApiRequestTracker {
     return this.date
   }
 }
+
+/**
+ * Normalize a deviceId for matching (uppercase alphanumerics only)
+ */
+export function normalizeDeviceId(deviceId: string): string {
+  return (deviceId ?? '').toUpperCase().replace(/[^A-Z0-9]+/g, '')
+}
+
+/**
+ * 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.
+ */
+export function mergeByDeviceId(a1: { deviceId: string }[], a2: any[], allowConfigOnly = false): any[] {
+  const result: any[] = []
+  for (const itm of (a1 || [])) {
+    const matchingItem = (a2 || []).find(item => normalizeDeviceId(item.deviceId) === normalizeDeviceId(itm.deviceId))
+    if (matchingItem) {
+      result.push({ ...matchingItem, ...itm })
+    } else if (allowConfigOnly) {
+      result.push(itm)
+    }
+  }
+  return result
+}
+
+/**
+ * Check if an API status code indicates success
+ */
+export function isSuccessfulStatusCode(statusCode: number): boolean {
+  return statusCode === 200 || statusCode === 100
+}
+
+/**
+ * Log status code messages with appropriate log level
+ */
+export async function logStatusCode(statusCode: number, log: {
+  debugLog: (...args: any[]) => void | Promise<void>
+  errorLog: (...args: any[]) => void | Promise<void>
+}): Promise<void> {
+  const messages: { [key: number]: string } = {
+    151: `Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: 
+          https://tinyurl.com/SwitchBotFeatureRequest`,
+    152: `Device not found, statusCode: ${statusCode}`,
+    160: `Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`,
+    161: `Device is offline, statusCode: ${statusCode}`,
+    171: `is offline, statusCode: ${statusCode}`,
+    190: `Requests reached the daily limit, statusCode: ${statusCode}`,
+    100: `Command successfully sent, statusCode: ${statusCode}`,
+    200: `Request successful, statusCode: ${statusCode}`,
+    400: `Bad Request, The client has issued an invalid request. This is commonly used to specify validation errors in a request payload, 
+          statusCode: ${statusCode}`,
+    401: `Unauthorized, Authorization for the API is required, but the request has not been authenticated, statusCode: ${statusCode}`,
+    403: `Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found, 
+          statusCode: ${statusCode}`,
+    404: `Not Found, Specifies the requested path does not exist, statusCode: ${statusCode}`,
+    406: `Not Acceptable, The client has requested a MIME type via the Accept header for a value not supported by the server, 
+          statusCode: ${statusCode}`,
+    415: `Unsupported Media Type, The client has defined a contentType header that is not supported by the server, statusCode: ${statusCode}`,
+    422: `Unprocessable Entity, The client has made a valid request, but the server cannot process it. This is often used for APIs for which 
+          certain limits have been exceeded, statusCode: ${statusCode}`,
+    429: `Too Many Requests, The client has exceeded the number of requests allowed for a given time window, statusCode: ${statusCode}`,
+    500: `Internal Server Error, An unexpected error on the SmartThings servers has occurred. These errors should be rare, 
+          statusCode: ${statusCode}`,
+  }
+
+  const message = messages[statusCode] ?? `Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`
+
+  if ([100, 200].includes(statusCode)) {
+    await log.debugLog(message)
+  } else {
+    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)
+  }
+}