@switchbot/homebridge-switchbot 5.0.0-beta.11 → 5.0.0-beta.111

package/src/homebridge-ui/utils/config-parser.ts

@@ -0,0 +1,108 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import fs from 'node:fs/promises'
+
+import { uiLog } from './logger.js'
+
+// Module-scope regex pattern to avoid recompilation
+export const SWITCHBOT_PLATFORM_REGEX = /switchbot/i
+
+/**
+ * Get reference to the devices array in platform config
+ */
+export function getDevicesRef(platform: any): any[] {
+  if (!platform || typeof platform !== 'object') {
+    return []
+  }
+
+  if (Array.isArray(platform.devices)) {
+    return platform.devices
+  }
+
+  platform.devices = []
+  return platform.devices
+}
+
+/**
+ * Get all device arrays from platform config
+ */
+export function getDeviceArrays(platform: any): any[][] {
+  const rootDevices = getDevicesRef(platform)
+  return [rootDevices]
+}
+
+/**
+ * Get all unique devices from platform config
+ */
+export function getAllDevices(platform: any): any[] {
+  const all = getDevicesRef(platform)
+  const seen = new Set<string>()
+
+  return all.filter((d: any) => {
+    const id = String(d?.deviceId ?? d?.id ?? '').trim().toLowerCase()
+    if (!id || seen.has(id)) {
+      return false
+    }
+    seen.add(id)
+    return true
+  })
+}
+
+/**
+ * Get credential from platform config
+ */
+export function getCredential(platform: any, key: 'openApiToken' | 'openApiSecret'): string | undefined {
+  return platform?.[key]
+}
+
+/**
+ * Set credential in platform config
+ */
+export function setCredential(platform: any, key: 'openApiToken' | 'openApiSecret', value: string): void {
+  if (!platform || typeof platform !== 'object') {
+    return
+  }
+
+  platform[key] = value
+}
+
+/**
+ * Find and parse the SwitchBot platform config from Homebridge config file
+ */
+export async function getSwitchBotPlatformConfig(server: HomebridgePluginUiServer) {
+  const cfgPath = server.homebridgeConfigPath
+  if (!cfgPath) {
+    throw new Error('HOMEBRIDGE_CONFIG_PATH not set')
+  }
+
+  const raw = await fs.readFile(cfgPath, 'utf-8')
+  const cfg = JSON.parse(raw)
+
+  const platforms = Array.isArray(cfg.platforms) ? cfg.platforms : []
+
+  const candidates = platforms.filter((p: any) => {
+    const platformName = p.platform || p.name || ''
+    return !!platformName && (SWITCHBOT_PLATFORM_REGEX.test(String(platformName)) || String(platformName).toLowerCase() === '@switchbot/homebridge-switchbot')
+  })
+
+  uiLog.info(`Found ${candidates.length} SwitchBot candidate(s)`)
+
+  const platform = candidates.find((p: any) => {
+    const name = String(p.platform || '').toLowerCase()
+    return name === 'switchbot' || name.includes('switchbot')
+  })
+
+  if (!platform) {
+    throw new Error('SwitchBot platform not found in config. Please add the plugin configuration first.')
+  }
+
+  uiLog.info(`Using SwitchBot platform: ${platform.name || platform.platform || 'SwitchBot'}`)
+  return { platform, cfg, cfgPath }
+}
+
+/**
+ * Save the Homebridge config file
+ */
+export async function saveConfig(cfgPath: string, cfg: any): Promise<void> {
+  await fs.writeFile(cfgPath, JSON.stringify(cfg, null, 2), 'utf-8')
+}

package/src/homebridge-ui/utils/device-migration.ts

@@ -0,0 +1,144 @@
+import { DEVICE_TYPES, isValidDeviceType, normalizeDeviceType } from '../../device-types.js'
+
+export interface DeviceMigrationResult {
+  migrated: boolean
+  originalType: string | undefined
+  correctedType: string | null
+  message: string
+}
+
+/**
+ * Validate and optionally correct a device's configDeviceType
+ * @param device Device object from config
+ * @param autoCorrect Whether to auto-correct invalid types
+ * @returns Migration result with details
+ */
+export function validateAndMigrateDeviceType(
+  device: any,
+  autoCorrect = false,
+): DeviceMigrationResult {
+  const originalType = device.configDeviceType
+  const deviceId = device.deviceId || device.id || 'unknown'
+
+  // Check if type is valid
+  if (isValidDeviceType(originalType)) {
+    return {
+      migrated: false,
+      originalType,
+      correctedType: originalType,
+      message: `Device "${device.configDeviceName || deviceId}" type is valid`,
+    }
+  }
+
+  // Try to find a valid mapping
+  const correctedType = normalizeDeviceType(originalType)
+
+  if (!correctedType) {
+    return {
+      migrated: false,
+      originalType,
+      correctedType: null,
+      message: `Device "${device.configDeviceName || deviceId}" has invalid type "${originalType}" with no valid mapping`,
+    }
+  }
+
+  // Found a valid mapping
+  if (autoCorrect) {
+    device.configDeviceType = correctedType
+    return {
+      migrated: true,
+      originalType,
+      correctedType,
+      message: `Device "${device.configDeviceName || deviceId}" type auto-corrected: "${originalType}" → "${correctedType}"`,
+    }
+  } else {
+    return {
+      migrated: false,
+      originalType,
+      correctedType,
+      message: `Device "${device.configDeviceName || deviceId}" requires migration: "${originalType}" → "${correctedType}"`,
+    }
+  }
+}
+
+/**
+ * Validate all devices in config and optionally auto-correct invalid types
+ * @param config Configuration object containing devices array
+ * @param autoCorrect Whether to auto-correct invalid types
+ * @returns Array of migration results with statistics
+ */
+export function validateAndMigrateConfig(
+  config: any,
+  autoCorrect = false,
+): {
+  results: DeviceMigrationResult[]
+  statistics: {
+    total: number
+    valid: number
+    corrected: number
+    invalid: number
+  }
+  warnings: string[]
+} {
+  const results: DeviceMigrationResult[] = []
+  const warnings: string[] = []
+  let validCount = 0
+  let correctedCount = 0
+  let invalidCount = 0
+
+  if (!config?.devices || !Array.isArray(config.devices)) {
+    return {
+      results,
+      statistics: {
+        total: 0,
+        valid: 0,
+        corrected: 0,
+        invalid: 0,
+      },
+      warnings: ['No devices found in config'],
+    }
+  }
+
+  for (const device of config.devices) {
+    const result = validateAndMigrateDeviceType(device, autoCorrect)
+    results.push(result)
+
+    if (!result.originalType || isValidDeviceType(result.originalType)) {
+      validCount++
+    } else if (result.migrated) {
+      correctedCount++
+    } else if (result.correctedType) {
+      warnings.push(
+        `Device "${device.configDeviceName || device.deviceId}" needs correction: "${result.originalType}" → "${result.correctedType}"`,
+      )
+      invalidCount++
+    } else {
+      invalidCount++
+      warnings.push(
+        `Device "${device.configDeviceName || device.deviceId}" has INVALID type "${result.originalType}" with no mapping`,
+      )
+    }
+  }
+
+  // Validation complete - results and warnings are returned via return value
+  // Caller (config endpoint) will handle logging/reporting
+
+  return {
+    results,
+    statistics: {
+      total: config.devices.length,
+      valid: validCount,
+      corrected: correctedCount,
+      invalid: invalidCount,
+    },
+    warnings,
+  }
+}
+
+/**
+ * Get list of all valid device types for error messages
+ * @returns Array of valid device types grouped by category
+ */
+export function getValidDeviceTypesList(): Record<string, readonly string[]> {
+  return DEVICE_TYPES
+}

package/src/homebridge-ui/utils/logger.ts

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+const PREFIX = '[SwitchBot UI]'
+
+export const uiLog = {
+  info: (message: string, ...parameters: any[]) => {
+    console.log(PREFIX, message, ...parameters)
+  },
+  warn: (message: string, ...parameters: any[]) => {
+    console.warn(PREFIX, message, ...parameters)
+  },
+  error: (message: string, ...parameters: any[]) => {
+    console.error(PREFIX, message, ...parameters)
+  },
+  debug: (message: string, ...parameters: any[]) => {
+    console.debug(PREFIX, message, ...parameters)
+  },
+}

package/src/index.ts

@@ -4,74 +4,12 @@
  */
 import type { API } from 'homebridge'
 
-import { SwitchBotHAPPlatform } from './platform-hap.js'
-import { SwitchBotMatterPlatform } from './platform-matter.js'
+import { SwitchBotHAPPlatform, SwitchBotMatterPlatform } from './platform.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
+import { createPlatformProxy } from './utils.js'
 
 // Register our platform with homebridge.
 export default (api: API): void => {
-  // Register a single proxy platform class. Homebridge will instantiate this class
-  // with (log, config, api) and we delegate to the appropriate actual platform
-  // implementation (HAP or Matter) based on runtime detection. This avoids
-  // registering two platforms and possible conflicts.
-  // Compact helper to determine if Matter should be used.
-  const detectMatter = (apiObj: API): boolean => {
-    try {
-      const maybe = (apiObj as any).isMatterEnabled
-      if (typeof maybe === 'function') {
-        return Boolean(maybe.call(apiObj))
-      }
-      if (typeof maybe !== 'undefined') {
-        return Boolean(maybe)
-      }
-
-      const server = (apiObj as any).server ?? (apiObj as any).homebridgeServer ?? (apiObj as any).homebridge_server
-      const serverMaybe = server?.isMatterEnabled
-      if (typeof serverMaybe === 'function') {
-        return Boolean(serverMaybe.call(server))
-      }
-      if (typeof server?.isMatterEnabled !== 'undefined') {
-        return Boolean(server.isMatterEnabled)
-      }
-    } catch (e) {
-      // ignore
-    }
-    return false
-  }
-
-  class SwitchBotPlatformProxy {
-    private delegate: any
-
-    constructor(public readonly log: any, public readonly config: any, public readonly api: API) {
-      const isMatter = detectMatter(this.api)
-      this.log.info?.(`Homebridge SwitchBot Plugin initializing in ${isMatter ? 'Matter' : 'HAP'} mode.`)
-      const PlatformCtor = isMatter ? SwitchBotMatterPlatform : SwitchBotHAPPlatform
-      this.delegate = new PlatformCtor(this.log, this.config, this.api)
-    }
-
-    // Homebridge lifecycle hooks we expect to be called — delegate if available.
-    configureAccessory(accessory: any): void {
-      if (typeof this.delegate.configureAccessory === 'function') {
-        return this.delegate.configureAccessory(accessory)
-      }
-    }
-
-    configureMatterAccessory?(accessory: any): void {
-      if (typeof this.delegate.configureMatterAccessory === 'function') {
-        return this.delegate.configureMatterAccessory(accessory)
-      }
-    }
-
-    // Expose common properties via getters for external access
-    get accessories(): any {
-      return this.delegate?.accessories
-    }
-
-    get matterAccessories(): any {
-      return this.delegate?.matterAccessories
-    }
-  }
-
-  // Register the proxy class with Homebridge. Homebridge will call `new SwitchBotPlatformProxy(log, config, api)`
-  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, SwitchBotPlatformProxy as any)
+  const ProxyCtor = createPlatformProxy(SwitchBotHAPPlatform, SwitchBotMatterPlatform)
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, ProxyCtor as any)
 }