@switchbot/homebridge-switchbot 5.0.0-beta.98 → 5.0.0

package/src/homebridge-ui/endpoints/config.ts

@@ -0,0 +1,110 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { RequestError } from '@homebridge/plugin-ui-utils'
+import fs from 'node:fs/promises'
+
+import { isValidDeviceType } from '../../device-types.js'
+import { getAllDevices, SWITCHBOT_PLATFORM_REGEX } from '../utils/config-parser.js'
+import { validateAndMigrateDeviceType } from '../utils/device-migration.js'
+import { uiLog } from '../utils/logger.js'
+
+export function registerConfigEndpoints(server: HomebridgePluginUiServer) {
+  /**
+   * GET /devices - List all configured devices from Homebridge config
+   */
+
+  server.onRequest('/devices', async () => {
+    try {
+      const cfgPath = server.homebridgeConfigPath
+      if (!cfgPath) {
+        throw new Error('HOMEBRIDGE_CONFIG_PATH not set')
+      }
+
+      const raw = await fs.readFile(cfgPath, 'utf8')
+      const cfg = JSON.parse(raw)
+      const found: Array<{
+        id: string
+        name?: string
+        type?: string
+        connectionPreference?: string
+        room?: string
+        typeValidationWarning?: string
+      }> = []
+      const invalidTypeDevices: Array<{ name: string, type: string, suggestion?: string }> = []
+
+      const platforms = Array.isArray(cfg.platforms) ? cfg.platforms : []
+      for (const p of platforms) {
+        try {
+          const platformName = p.platform || p.name || ''
+          // Match known SwitchBot platform identifiers
+          if (!platformName || !SWITCHBOT_PLATFORM_REGEX.test(String(platformName))) {
+            continue
+          }
+
+          const devices = getAllDevices(p)
+          for (const d of devices) {
+            const id = d.deviceId ?? d.id
+            if (!id) {
+              continue
+            }
+
+            const deviceType = d.configDeviceType ?? d.type ?? d.deviceType
+            const deviceName = d.configDeviceName ?? d.name ?? d.deviceName
+
+            // Validate device type
+            const deviceObj = { configDeviceType: deviceType, configDeviceName: deviceName, deviceId: id }
+            const validationResult = validateAndMigrateDeviceType(deviceObj, false)
+
+            const deviceEntry: typeof found[0] = {
+              id,
+              name: deviceName,
+              type: deviceType,
+              connectionPreference: d.connectionPreference ?? d.connection ?? 'auto',
+              room: d.room || d.location || undefined,
+            }
+
+            if (!isValidDeviceType(deviceType)) {
+              deviceEntry.typeValidationWarning = `Invalid type "${deviceType}"`
+              if (validationResult.correctedType) {
+                deviceEntry.typeValidationWarning += ` - should be "${validationResult.correctedType}"`
+                invalidTypeDevices.push({
+                  name: deviceName,
+                  type: deviceType,
+                  suggestion: validationResult.correctedType,
+                })
+              } else {
+                invalidTypeDevices.push({
+                  name: deviceName,
+                  type: deviceType,
+                })
+              }
+            }
+
+            found.push(deviceEntry)
+          }
+        } catch (e) {
+          // ignore malformed platform entries
+        }
+      }
+
+      // Log validation issues
+      if (invalidTypeDevices.length > 0) {
+        uiLog.warn(
+          `Found ${invalidTypeDevices.length} device(s) with invalid types:\n${invalidTypeDevices.map(d => `  - "${d.name}": "${d.type}"${d.suggestion ? ` → should be "${d.suggestion}"` : ''}`).join('\n')}`,
+        )
+      }
+
+      uiLog.info(`GET /devices - Found ${found.length} devices in ${cfgPath}${invalidTypeDevices.length > 0 ? ` (${invalidTypeDevices.length} with validation warnings)` : ''}`)
+      return {
+        success: true,
+        data: found,
+        ...(invalidTypeDevices.length > 0 && { validationWarnings: invalidTypeDevices }),
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      uiLog.error(`Error in /devices: ${msg}`)
+      // Pass the real error message to the frontend for better diagnostics
+      throw new RequestError(msg || 'Failed to read Homebridge config', e)
+    }
+  })
+}

package/src/homebridge-ui/endpoints/devices.ts

@@ -0,0 +1,153 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { SwitchBotClient } from '../../switchbotClient.js'
+import { getAllDevices, getDevicesRef, getSwitchBotPlatformConfig } from '../utils/config-parser.js'
+import { uiLog } from '../utils/logger.js'
+
+/**
+ * Register device CRUD endpoints
+ */
+export function registerDeviceEndpoints(server: HomebridgePluginUiServer) {
+  /**
+   * POST /add-devices - Add or update multiple devices in the Homebridge config
+   * Expects: { devices: Array<{ deviceId, configDeviceType, configDeviceName, ... }> }
+   */
+  server.onRequest('/add-devices', async (body: any) => {
+    try {
+      if (!body || !Array.isArray(body.devices) || body.devices.length === 0) {
+        throw new Error('No devices provided')
+      }
+
+      const { platform, cfg, cfgPath } = await getSwitchBotPlatformConfig(server)
+      const devicesRef = getDevicesRef(platform)
+      const incomingDevices = body.devices
+      let added = 0
+      let updated = 0
+
+      for (const newDev of incomingDevices) {
+        const id = String(newDev.deviceId || newDev.id || '').trim().toLowerCase()
+        if (!id) {
+          continue
+        }
+        const idx = devicesRef.findIndex((d: any) => String(d.deviceId || d.id || '').trim().toLowerCase() === id)
+        if (idx >= 0) {
+          // Update existing device
+          devicesRef[idx] = { ...devicesRef[idx], ...newDev }
+          updated++
+        } else {
+          // Add new device
+          devicesRef.push({ ...newDev })
+          added++
+        }
+      }
+
+      // Log devicesRef and cfgPath before saving
+      uiLog.info(`[DEBUG] devicesRef before save:`, JSON.stringify(devicesRef, null, 2))
+      uiLog.info(`[DEBUG] cfgPath:`, cfgPath)
+      await import('../utils/config-parser.js').then(m => m.saveConfig(cfgPath, cfg))
+
+      // Log the config file contents after saving for debugging
+      try {
+        const fs = await import('node:fs/promises')
+        const raw = await fs.readFile(cfgPath, 'utf-8')
+        uiLog.info(`[DEBUG] Config after add-devices save:`, raw)
+      } catch (e) {
+        uiLog.warn(`[DEBUG] Could not read config after save:`, e)
+      }
+
+      uiLog.info(`POST /add-devices - Added: ${added}, Updated: ${updated}`)
+      return {
+        success: true,
+        data: {
+          added,
+          updated,
+          total: devicesRef.length,
+        },
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      uiLog.error(`POST /add-devices failed: ${msg}`)
+      return {
+        success: false,
+        error: msg,
+      }
+    }
+  })
+  /**
+   * POST /test-connection - Test connectivity and basic read for a device
+   */
+  server.onRequest('/test-connection', async (body: any) => {
+    let client: SwitchBotClient | null = null
+
+    try {
+      const deviceId = String(body?.deviceId || '').trim()
+      if (!deviceId) {
+        throw new Error('Device ID is required')
+      }
+
+      const { platform } = await getSwitchBotPlatformConfig(server)
+      const allDevices = getAllDevices(platform)
+      const normalizedDeviceId = deviceId.toLowerCase()
+      const configuredDevice = allDevices.find((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+
+      const startedAt = Date.now()
+
+      client = new SwitchBotClient({
+        ...(platform as any),
+        logger: uiLog,
+      } as any)
+
+      await client.init()
+      const raw = await client.getDevice(deviceId)
+      const latencyMs = Date.now() - startedAt
+
+      const state = raw?.body ?? raw
+      const stateConnection = String(state?.connectionType || state?.source || body?.connectionType || '').toLowerCase()
+      const method = stateConnection.includes('ble')
+        ? 'BLE'
+        : stateConnection.includes('api')
+          ? 'OpenAPI'
+          : 'Auto'
+
+      return {
+        success: true,
+        data: {
+          success: true,
+          deviceId,
+          method,
+          latencyMs,
+          message: configuredDevice
+            ? `Connected to "${configuredDevice.configDeviceName || configuredDevice.deviceId || deviceId}"`
+            : 'Connected successfully',
+          state: {
+            online: state?.online,
+            power: state?.power,
+            battery: state?.battery,
+            version: state?.version,
+            deviceType: state?.deviceType,
+          },
+        },
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e)
+      uiLog.warn(`POST /test-connection failed: ${message}`)
+
+      return {
+        success: true,
+        data: {
+          success: false,
+          deviceId: String(body?.deviceId || ''),
+          method: 'Auto',
+          latencyMs: 0,
+          message,
+        },
+      }
+    } finally {
+      try {
+        await client?.destroy()
+      } catch (_e) {
+        // Ignore client shutdown errors
+      }
+    }
+  })
+}

package/src/homebridge-ui/endpoints/discovery.ts

@@ -0,0 +1,240 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { RequestError } from '@homebridge/plugin-ui-utils'
+
+import { getCredential, getSwitchBotPlatformConfig } from '../utils/config-parser.js'
+import { uiLog } from '../utils/logger.js'
+
+/**
+ * Register discovery endpoint
+ * Discovers SwitchBot devices via BLE and OpenAPI
+ */
+export function registerDiscoveryEndpoint(server: HomebridgePluginUiServer) {
+  server.onRequest('/ble-status', async () => {
+    try {
+      const { platform } = await getSwitchBotPlatformConfig(server)
+      const token = getCredential(platform, 'openApiToken') || platform.token
+      const secret = getCredential(platform, 'openApiSecret') || platform.secret
+      const { SwitchBot } = await import('node-switchbot')
+      const switchbot = new SwitchBot({
+        token: token || undefined,
+        secret: secret || undefined,
+        enableBLE: true,
+        enableFallback: true,
+        enableRetry: true,
+        enableCircuitBreaker: true,
+        enableConnectionIntelligence: true,
+      })
+
+      await switchbot.discover({ timeout: 1000 })
+      return { success: true, data: { available: true, message: 'adapter ready' } }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e)
+      uiLog.warn(`GET /ble-status failed: ${message}`)
+      return { success: true, data: { available: false, message } }
+    }
+  })
+
+  server.onRequest('/discover', async (payload?: any) => {
+      uiLog.debug(`[SwitchBot UI/Server] /discover incoming payload: ${JSON.stringify(payload)}`)
+    try {
+      const { platform } = await getSwitchBotPlatformConfig(server)
+      const mode = String(payload?.mode || 'all').toLowerCase()
+      // Only run BLE if mode is all/ble AND bleEnabled is not false (default true if missing)
+      const bleEnabled = payload?.bleEnabled !== false;
+      const runBle = (mode === 'all' || mode === 'ble') && bleEnabled;
+      const runOpenApi = mode === 'all' || mode === 'openapi'
+      const bleScanDurationSeconds = Math.max(3, Math.min(15, Number(payload?.bleScanDurationSeconds || 5)))
+      const bleTimeoutSeconds = Math.max(3, Math.min(30, Number(payload?.bleTimeoutSeconds || 8)))
+
+      uiLog.debug(`GET /discover - Platform config keys: ${Object.keys(platform).join(', ')}`)
+
+      const token = getCredential(platform, 'openApiToken') || platform.token
+      const secret = getCredential(platform, 'openApiSecret') || platform.secret
+
+      const hasOpenAPICredentials = !!(token && secret)
+
+      if (!hasOpenAPICredentials) {
+        uiLog.warn('GET /discover - No OpenAPI credentials found, will attempt BLE-only discovery')
+      } else {
+        uiLog.info('GET /discover - Using OpenAPI credentials for discovery')
+      }
+
+      // Import and initialize node-switchbot
+      const { SwitchBot } = await import('node-switchbot')
+      const switchbot = new SwitchBot({
+        token: token || undefined,
+        secret: secret || undefined,
+        enableBLE: true,
+        enableFallback: true,
+        enableRetry: true,
+        enableCircuitBreaker: true,
+        enableConnectionIntelligence: true,
+      })
+
+      const deviceMap = new Map<string, any>()
+
+      // 1. Try BLE discovery first (with timeout)
+      if (runBle) {
+        uiLog.info('GET /discover - Starting BLE scan...')
+        try {
+          const bleTimeout = bleTimeoutSeconds * 1000
+          const bleDiscoveryPromise = switchbot.discover({ timeout: bleScanDurationSeconds * 1000 })
+          const bleDevices = await Promise.race([
+            bleDiscoveryPromise,
+            new Promise<any[]>(resolve => setTimeout(resolve, bleTimeout, [])),
+          ])
+
+          if (Array.isArray(bleDevices) && bleDevices.length > 0) {
+            uiLog.info(`GET /discover - Found ${bleDevices.length} BLE devices`)
+            for (const [index, d] of bleDevices.entries()) {
+              const info = typeof d?.getInfo === 'function' ? d.getInfo() : undefined
+              const id = d?.id
+                || (typeof d?.getId === 'function' ? d.getId() : undefined)
+                || info?.id
+
+              const mac = d?.mac
+                || (typeof d?.getMAC === 'function' ? d.getMAC() : undefined)
+                || info?.mac
+
+              if (!id) {
+                uiLog.warn(`GET /discover - BLE device at index ${index} has no id, skipping`)
+                continue
+              }
+
+              const connectionTypes = Array.isArray(info?.connectionTypes) ? info.connectionTypes : []
+              const isHybrid = connectionTypes.includes('api')
+
+              deviceMap.set(id, {
+                id,
+                name: d?.name || (typeof d?.getName === 'function' ? d.getName() : undefined) || info?.name || d?.deviceName || id,
+                type: d?.deviceType || (typeof d?.getDeviceType === 'function' ? d.getDeviceType() : undefined) || info?.deviceType || d?.type || d?.model || 'unknown',
+                model: info?.model || d?.model || d?.deviceModel,
+                address: mac,
+                connectionType: isHybrid ? 'Both' : 'BLE',
+                rssi: info?.rssi || d?.rssi,
+              })
+            }
+          } else {
+            uiLog.info('GET /discover - No BLE devices found or scan timed out')
+          }
+        } catch (bleErr) {
+          uiLog.warn(`GET /discover - BLE discovery failed: ${bleErr instanceof Error ? bleErr.message : String(bleErr)}`)
+          // Continue with OpenAPI even if BLE fails
+        }
+      }
+
+      // 2. Get devices from OpenAPI (only if credentials are available)
+      if (runOpenApi && hasOpenAPICredentials) {
+        uiLog.info('GET /discover - Fetching devices from OpenAPI...')
+        try {
+          const apiClient = switchbot.getAPIClient()
+          if (!apiClient) {
+            throw new Error('API client not available - token/secret may be missing')
+          }
+          const apiData = await apiClient.getDevices()
+          uiLog.debug(`GET /discover - OpenAPI response: ${JSON.stringify(apiData)}`)
+
+          // Parse physical devices - apiData is DeviceListResponse with deviceList and infraredRemoteList
+          const devices = apiData.deviceList || []
+          const irDevices = apiData.infraredRemoteList || []
+
+          uiLog.info(`GET /discover - Found ${devices.length} OpenAPI physical devices and ${irDevices.length} IR devices`)
+
+          // Process physical devices from OpenAPI
+          for (const d of devices) {
+            const id = d.deviceId
+            if (!id) {
+              continue
+            }
+
+            const existing = deviceMap.get(id)
+            if (existing) {
+              // Device found via both BLE and OpenAPI
+              existing.connectionType = 'Both'
+              existing.name = d.deviceName || existing.name
+              existing.type = d.deviceType || existing.type
+              // Note: APIDevice doesn't have a model property
+              existing.enabled = d.enableCloudService !== false
+              existing.hubDeviceId = d.hubDeviceId
+            } else {
+              // Device only found via OpenAPI
+              deviceMap.set(id, {
+                id,
+                name: d.deviceName || id,
+                type: d.deviceType || 'unknown',
+                enabled: d.enableCloudService !== false,
+                hubDeviceId: d.hubDeviceId,
+                connectionType: 'OpenAPI',
+              })
+            }
+          }
+
+          // Process IR devices (OpenAPI only)
+          for (const d of irDevices) {
+            const id = d.deviceId
+            if (!id) {
+              continue
+            }
+
+            deviceMap.set(id, {
+              id,
+              name: d.deviceName || id,
+              type: d.remoteType || 'unknown',
+              enabled: true,
+              hubDeviceId: d.hubDeviceId,
+              connectionType: 'OpenAPI',
+              isIR: true,
+            })
+          }
+        } catch (apiErr) {
+          uiLog.error(`GET /discover - OpenAPI discovery failed: ${apiErr instanceof Error ? apiErr.message : String(apiErr)}`)
+          // If we have BLE devices, we can still return those
+          if (deviceMap.size === 0) {
+            throw apiErr
+          }
+        }
+      } else if (runOpenApi) {
+        uiLog.info('GET /discover - Skipping OpenAPI discovery (no credentials configured)')
+      }
+
+      const normalizedBleDevices = [...deviceMap.values()].filter(d => d.connectionType === 'BLE' || d.connectionType === 'Both')
+      const firstNormalizedBleId = normalizedBleDevices[0]?.id || 'none'
+      uiLog.info(`GET /discover - Normalized BLE devices: ${normalizedBleDevices.length} (firstId: ${firstNormalizedBleId})`)
+
+      // Check if we found any devices
+      if (deviceMap.size === 0 && mode === 'openapi' && !hasOpenAPICredentials) {
+        return { success: true, data: [] }
+      }
+
+      if (deviceMap.size === 0) {
+        const errorMsg = hasOpenAPICredentials
+          ? 'No devices found via BLE or OpenAPI. Make sure devices are powered on and in range.'
+          : 'No devices found via BLE. OpenAPI credentials not configured. Please save your credentials in settings to discover cloud-connected devices, or ensure BLE devices are powered on and in range.'
+        uiLog.error(`GET /discover - ${errorMsg}`)
+        throw new Error(errorMsg)
+      }
+
+      // Convert map to array
+      const allDiscovered = [...deviceMap.values()]
+
+      const bleCount = allDiscovered.filter(d => d.connectionType === 'BLE').length
+      const apiCount = allDiscovered.filter(d => d.connectionType === 'OpenAPI').length
+      const bothCount = allDiscovered.filter(d => d.connectionType === 'Both').length
+
+      uiLog.info(`GET /discover - Total: ${allDiscovered.length} devices (BLE: ${bleCount}, OpenAPI: ${apiCount}, Both: ${bothCount})`)
+      return { success: true, data: allDiscovered }
+    } catch (e) {
+      if (e instanceof Error) {
+        uiLog.error(`Error in /discover: ${e.message}`)
+        if (e.stack) {
+          uiLog.error(`[Stack] ${e.stack}`)
+        }
+        uiLog.error(`[Object]`, e)
+      } else {
+        uiLog.error(`Error in /discover: ${String(e)}`)
+      }
+      throw new RequestError(`Failed to discover devices: ${e instanceof Error ? e.message : String(e)}`, e)
+    }
+  })
+}