@switchbot/homebridge-switchbot 5.0.0-beta.13 → 5.0.0-beta.130

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

@@ -0,0 +1,37 @@
+import './types.js'
+import { uiLog } from './logger.js'
+
+function showToast(
+  method: 'success' | 'error' | 'warning' | 'info',
+  message: string,
+  title = 'SwitchBot',
+): void {
+  try {
+    const toast = homebridge?.toast
+    const fn = toast?.[method]
+    if (typeof fn === 'function') {
+      fn(message, title)
+      return
+    }
+
+    uiLog.info(`[Toast:${method}] ${title} - ${message}`)
+  } catch (e) {
+    uiLog.warn(`Toast ${method} failed:`, e)
+  }
+}
+
+export function toastSuccess(message: string, title?: string): void {
+  showToast('success', message, title)
+}
+
+export function toastError(message: string, title?: string): void {
+  showToast('error', message, title)
+}
+
+export function toastWarning(message: string, title?: string): void {
+  showToast('warning', message, title)
+}
+
+export function toastInfo(message: string, title?: string): void {
+  showToast('info', message, title)
+}

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

@@ -0,0 +1,26 @@
+// Global homebridge API type declarations
+declare global {
+  interface HomebridgeToastApi {
+    success?: (message: string, title?: string) => void
+    error?: (message: string, title?: string) => void
+    warning?: (message: string, title?: string) => void
+    info?: (message: string, title?: string) => void
+  }
+
+  interface HomebridgePluginUiAPI {
+    request: (endpoint: string, params?: any) => Promise<any>
+    getPluginConfig?: () => Promise<any[]>
+    updatePluginConfig?: (config: any[]) => Promise<void>
+    savePluginConfig?: () => Promise<void>
+    closeSettings?: () => void
+    showSpinner?: () => void
+    hideSpinner?: () => void
+    disableSaveButton?: () => void
+    enableSaveButton?: () => void
+    toast?: HomebridgeToastApi
+  }
+
+  let homebridge: HomebridgePluginUiAPI
+}
+
+export {}

package/src/homebridge-ui/server.ts

@@ -1,48 +1,16 @@
-import fs from 'node:fs'
-
 import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
 
-class PluginUiServer extends HomebridgePluginUiServer {
-  constructor() {
-    super()
-    /*
-      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', () => {
-      try {
-        const plugin = 'homebridge-switchbot'
-        const devicesToReturn = []
-
-        // The path and file of the cached accessories
-        const accFile = `${this.homebridgeStoragePath}/accessories/cachedAccessories`
-
-        // Check the file exists
-        if (fs.existsSync(accFile)) {
-          // read the cached accessories file
-          const cachedAccessories: any[] = JSON.parse(fs.readFileSync(accFile, 'utf8'))
+import { registerConfigEndpoints } from './endpoints/config.js'
+import { registerCredentialsEndpoint } from './endpoints/credentials.js'
+import { registerDeviceEndpoints } from './endpoints/devices.js'
+import { registerDiscoveryEndpoint } from './endpoints/discovery.js'
 
-          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)
-            }
-          })
-        }
-        // Return the array
-        return devicesToReturn
-      } catch {
-        // Just return an empty accessory list in case of any errors
-        return []
-      }
-    })
-    this.ready()
-  }
-}
+const server = new HomebridgePluginUiServer()
 
-function startPluginUiServer(): PluginUiServer {
-  return new PluginUiServer()
-}
+// Register all endpoints
+registerConfigEndpoints(server)
+registerDiscoveryEndpoint(server)
+registerDeviceEndpoints(server)
+registerCredentialsEndpoint(server)
 
-startPluginUiServer()
+server.ready()

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,14 +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 => {
-  // 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)
 }