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

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

@@ -0,0 +1,123 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { RequestError } from '@homebridge/plugin-ui-utils'
+import fs from 'node:fs/promises'
+
+import { getAllDevices, getSwitchBotPlatformConfig, SWITCHBOT_PLATFORM_REGEX } from '../utils/config-parser.js'
+import { uiLog } from '../utils/logger.js'
+import { validateAndMigrateDeviceType } from '../utils/device-migration.js'
+import { isValidDeviceType } from '../../device-types.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) {
+      uiLog.error(`Error in /devices: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError('Failed to read Homebridge config', e)
+    }
+  })
+
+  /**
+   * GET /platform-config - Get SwitchBot platform configuration
+   */
+  server.onRequest('/platform-config', async () => {
+    try {
+      const { platform } = await getSwitchBotPlatformConfig(server)
+      return {
+        success: true,
+        data: JSON.parse(JSON.stringify(platform)),
+      }
+    } catch (e) {
+      uiLog.error(`Error in /platform-config: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError('Failed to read platform config', e)
+    }
+  })
+}

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

@@ -0,0 +1,74 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { RequestError } from '@homebridge/plugin-ui-utils'
+import fs from 'node:fs/promises'
+
+import { getCredential, getSwitchBotPlatformConfig, setCredential } from '../utils/config-parser.js'
+import { uiLog } from '../utils/logger.js'
+
+/**
+ * Register credentials endpoint
+ */
+export function registerCredentialsEndpoint(server: HomebridgePluginUiServer) {
+  server.onRequest('/credentials', async (body: any) => {
+    try {
+      // Handle both GET and POST requests
+      if (!body || Object.keys(body).length === 0) {
+        // GET request - return current status
+        const { platform } = await getSwitchBotPlatformConfig(server)
+
+        const token = getCredential(platform, 'openApiToken')
+        const secret = getCredential(platform, 'openApiSecret')
+        const status = {
+          hasToken: !!token,
+          hasSecret: !!secret,
+          tokenLength: token ? String(token).length : 0,
+          secretLength: secret ? String(secret).length : 0,
+        }
+
+        uiLog.info(`GET /credentials - Status hasToken=${status.hasToken} hasSecret=${status.hasSecret}`)
+        return { success: true, data: status }
+      } else {
+        // POST request - save credentials
+        const { token, secret } = body
+
+        if (!token || !secret) {
+          throw new Error('Token and secret are required')
+        }
+
+        const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+
+        uiLog.info(`POST /credentials - Saving to platform: ${platform.platform || platform.name}`)
+        uiLog.debug(`POST /credentials - Config path: ${cfgPath}`)
+        uiLog.debug(`POST /credentials - Token length: ${token.length}, Secret length: ${secret.length}`)
+
+        // Save token and secret
+        setCredential(platform, 'openApiToken', token)
+        setCredential(platform, 'openApiSecret', secret)
+
+        // Write config with fsync
+        const configJson = JSON.stringify(cfg, null, 2)
+        const fileHandle = await fs.open(cfgPath, 'w')
+        try {
+          await fileHandle.writeFile(configJson, 'utf8')
+          await fileHandle.sync()
+          uiLog.info('POST /credentials - Credentials saved and synced to disk')
+        } finally {
+          await fileHandle.close()
+        }
+
+        // Notify Homebridge UI that config changed
+        server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+        uiLog.debug('POST /credentials - Sent configChanged event to UI')
+
+        return {
+          success: true,
+          data: { message: 'Credentials saved successfully' },
+        }
+      }
+    } catch (e) {
+      uiLog.error(`Error in /credentials: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError('Failed to handle credentials request', e)
+    }
+  })
+}

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

@@ -0,0 +1,383 @@
+import type { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils'
+
+import { RequestError } from '@homebridge/plugin-ui-utils'
+import fs from 'node:fs/promises'
+
+import { getAllDevices, getDeviceArrays, getSwitchBotPlatformConfig } from '../utils/config-parser.js'
+import { uiLog } from '../utils/logger.js'
+
+/**
+ * Register device CRUD endpoints
+ */
+export function registerDeviceEndpoints(server: HomebridgePluginUiServer) {
+  /**
+   * POST /add-device - Add a single device to config
+   */
+  server.onRequest('/add-device', async (body: any) => {
+    try {
+      const { deviceId, name, type, address, model, rssi } = body
+
+      if (!deviceId) {
+        throw new Error('Device ID is required')
+      }
+
+      const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+
+      uiLog.info('POST /add-device - Request received')
+      uiLog.debug(`POST /add-device - Request body: ${JSON.stringify(body)}`)
+      uiLog.debug(`POST /add-device - Config file path: ${cfgPath}`)
+
+      const deviceArrays = getDeviceArrays(platform)
+      const allDevices = getAllDevices(platform)
+
+      const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+      const exists = allDevices.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+      if (exists) {
+        uiLog.info(`POST /add-device - Device already exists: ${deviceId}`)
+        return {
+          success: true,
+          data: {
+            message: 'Device already in config',
+            alreadyExists: true,
+          },
+        }
+      }
+
+      let addCount = 0
+      for (const ref of deviceArrays) {
+        const refHasDevice = ref.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+        if (!refHasDevice) {
+          const newDevice: any = {
+            deviceId,
+            configDeviceName: name,
+            configDeviceType: type,
+          }
+          if (address) { newDevice.address = address }
+          if (model) { newDevice.model = model }
+          if (rssi !== undefined && rssi !== null && rssi !== 0) { newDevice.rssi = rssi }
+          ref.push(newDevice)
+          addCount++
+        }
+      }
+
+      if (!addCount) {
+        return {
+          success: false,
+          data: { message: 'Failed to add device to config' },
+        }
+      }
+
+      const configJson = JSON.stringify(cfg, null, 2)
+      const fileHandle = await fs.open(cfgPath, 'w')
+      try {
+        await fileHandle.writeFile(configJson, 'utf8')
+        await fileHandle.sync()
+      } finally {
+        await fileHandle.close()
+      }
+
+      // Notify Homebridge UI that config changed
+      server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+      uiLog.debug('POST /add-device - Sent configChanged event to UI')
+
+      return {
+        success: true,
+        data: {
+          message: `Device "${name}" added successfully`,
+          alreadyExists: false,
+          added: true,
+        },
+      }
+    } catch (e) {
+      uiLog.error(`Error in /add-device: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError(`Failed to add device: ${e instanceof Error ? e.message : String(e)}`, e)
+    }
+  })
+
+  /**
+   * POST /add-devices - Add multiple devices to config (bulk add)
+   */
+  server.onRequest('/add-devices', async (body: any) => {
+    try {
+      const { devices } = body
+
+      if (!Array.isArray(devices) || devices.length === 0) {
+        throw new Error('Devices array is required and must not be empty')
+      }
+
+      const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+      uiLog.debug(`POST /add-devices - Received ${devices.length} device(s) to add`)
+      uiLog.debug(`POST /add-devices - Config path: ${cfgPath}`)
+      
+      const deviceArrays = getDeviceArrays(platform)
+      const allDevices = getAllDevices(platform)
+      
+      uiLog.debug(`POST /add-devices - Device arrays count: ${deviceArrays.length}, existing devices: ${allDevices.length}`)
+      uiLog.debug(`POST /add-devices - Platform.devices exists: ${!!platform.devices}, length: ${platform.devices?.length || 0}`)
+
+      let addedCount = 0
+      let skippedCount = 0
+      const results: Array<Record<string, any>> = []
+
+      for (const { deviceId, name, type, rssi, address, model } of devices) {
+        if (!deviceId) {
+          results.push({ deviceId: '?', success: false, message: 'Device ID is required' })
+          skippedCount++
+          continue
+        }
+
+        const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+        const exists = allDevices.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+
+        if (exists) {
+          uiLog.debug(`POST /add-devices - Device already exists: ${deviceId}`)
+          results.push({ deviceId, success: true, message: 'Already in config', alreadyExists: true })
+          skippedCount++
+          continue
+        }
+
+        let addedToArray = false
+        for (const ref of deviceArrays) {
+          const refHasDevice = ref.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+          if (!refHasDevice) {
+            const newDevice: any = {
+              deviceId,
+              configDeviceName: name,
+              configDeviceType: type,
+            }
+            // Store RSSI, address, and model if available
+            if (rssi !== undefined && rssi !== null && rssi !== 0) { newDevice.rssi = rssi }
+            if (address) { newDevice.address = address }
+            if (model) { newDevice.model = model }
+            
+            ref.push(newDevice)
+            addedToArray = true
+            uiLog.debug(`POST /add-devices - Added device to array: ${deviceId} (${name}, ${type}, RSSI: ${rssi})`)
+          }
+        }
+
+        if (addedToArray) {
+          results.push({ deviceId, success: true, message: `Device "${name}" added` })
+          addedCount++
+        } else {
+          uiLog.warn(`POST /add-devices - Failed to add device: ${deviceId}`)
+          results.push({ deviceId, success: false, message: 'Failed to add device' })
+          skippedCount++
+        }
+      }
+
+      uiLog.info(`POST /add-devices - Adding ${addedCount} devices to config: ${cfgPath}`)
+      const configJson = JSON.stringify(cfg, null, 2)
+      const fileHandle = await fs.open(cfgPath, 'w')
+      try {
+        await fileHandle.writeFile(configJson, 'utf8')
+        await fileHandle.sync()
+        uiLog.info(`POST /add-devices - Config file written successfully`)
+      } finally {
+        await fileHandle.close()
+      }
+
+      // Notify Homebridge UI that config changed to prevent cache overwrite
+      server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+      uiLog.debug('POST /add-devices - Sent configChanged event to UI')
+
+      return {
+        success: true,
+        data: {
+          message: `Added ${addedCount} device(s)${skippedCount > 0 ? ` (${skippedCount} skipped)` : ''}`,
+          addedCount,
+          skippedCount,
+          results,
+        },
+      }
+    } catch (e) {
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      uiLog.error(`Error in /add-devices: ${errorMsg}`)
+      if (e instanceof Error && e.stack) {
+        uiLog.debug(`Stack trace: ${e.stack}`)
+      }
+      throw new RequestError(`Failed to add devices: ${errorMsg}`, e)
+    }
+  })
+
+  /**
+   * POST /update-device - Update existing device in config
+   */
+  server.onRequest('/update-device', async (body: any) => {
+    try {
+      const { deviceId, configDeviceName, configDeviceType, connectionPreference, room } = body
+
+      if (!deviceId) {
+        throw new Error('Device ID is required')
+      }
+
+      const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+      const deviceArrays = getDeviceArrays(platform)
+      const devices = getAllDevices(platform)
+
+      const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+      const device = devices.find((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+      if (!device) {
+        throw new Error('Device not found in config')
+      }
+
+      for (const ref of deviceArrays) {
+        for (const entry of ref) {
+          const entryId = String(entry.deviceId ?? entry.id ?? '').trim().toLowerCase()
+          if (entryId !== normalizedDeviceId) {
+            continue
+          }
+
+          if (configDeviceName !== undefined && configDeviceName !== null && String(configDeviceName).trim() !== '') {
+            entry.configDeviceName = configDeviceName
+          }
+          if (configDeviceType !== undefined && configDeviceType !== null && String(configDeviceType).trim() !== '') {
+            entry.configDeviceType = configDeviceType
+          }
+          if (connectionPreference !== undefined) {
+            entry.connectionPreference = connectionPreference
+          }
+          if (room !== undefined) {
+            entry.room = room || undefined
+          }
+        }
+      }
+
+      const configJson = JSON.stringify(cfg, null, 2)
+      const fileHandle = await fs.open(cfgPath, 'w')
+      try {
+        await fileHandle.writeFile(configJson, 'utf8')
+        await fileHandle.sync()
+      } finally {
+        await fileHandle.close()
+      }
+
+      // Notify Homebridge UI that config changed
+      server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+      uiLog.debug('POST /update-device - Sent configChanged event to UI')
+
+      return {
+        success: true,
+        data: { message: `Device updated successfully - type: ${configDeviceType || device.configDeviceType}` },
+      }
+    } catch (e) {
+      uiLog.error(`Error in /update-device: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError(`Failed to update device: ${e instanceof Error ? e.message : String(e)}`, e)
+    }
+  })
+
+  /**
+   * POST /delete-device - Remove device from config
+   */
+  server.onRequest('/delete-device', async (body: any) => {
+    try {
+      const { deviceId } = body
+      uiLog.info(`POST /delete-device - Requested deviceId: ${deviceId ?? 'undefined'}`)
+
+      if (!deviceId) {
+        throw new Error('Device ID is required')
+      }
+
+      const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+      const deviceArrays = getDeviceArrays(platform)
+      const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+      const allDevices = getAllDevices(platform)
+
+      const existing = allDevices.find((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+      if (!existing) {
+        throw new Error('Device not found in config')
+      }
+
+      const deviceName = existing.configDeviceName || deviceId
+      let removedCount = 0
+      for (const ref of deviceArrays) {
+        for (let i = ref.length - 1; i >= 0; i--) {
+          const id = String(ref[i]?.deviceId ?? ref[i]?.id ?? '').trim().toLowerCase()
+          if (id === normalizedDeviceId) {
+            ref.splice(i, 1)
+            removedCount++
+          }
+        }
+      }
+
+      if (!removedCount) {
+        throw new Error('Device not found in config')
+      }
+
+      const configJson = JSON.stringify(cfg, null, 2)
+      const fileHandle = await fs.open(cfgPath, 'w')
+      try {
+        await fileHandle.writeFile(configJson, 'utf8')
+        await fileHandle.sync()
+      } finally {
+        await fileHandle.close()
+      }
+
+      // Notify Homebridge UI that config changed
+      server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+      uiLog.debug('DELETE /delete-device - Sent configChanged event to UI')
+
+      return {
+        success: true,
+        data: { message: `Device "${deviceName}" removed from config` },
+      }
+    } catch (e) {
+      uiLog.error(`Error in /delete-device: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError('Failed to delete device', e)
+    }
+  })
+
+  /**
+   * POST /delete-all-devices - Remove all devices from config
+   */
+  server.onRequest('/delete-all-devices', async () => {
+    try {
+      uiLog.info('POST /delete-all-devices - Request received')
+
+      const { cfg, platform, cfgPath } = await getSwitchBotPlatformConfig(server)
+      const deviceArrays = getDeviceArrays(platform)
+      const allDevices = getAllDevices(platform)
+
+      if (allDevices.length === 0) {
+        return {
+          success: true,
+          data: { message: 'No devices to delete', deletedCount: 0 },
+        }
+      }
+
+      const deviceCount = allDevices.length
+      uiLog.info(`POST /delete-all-devices - Removing ${deviceCount} device(s)`)
+
+      // Clear all device arrays
+      for (const ref of deviceArrays) {
+        ref.length = 0 // Clear array in place
+      }
+
+      const configJson = JSON.stringify(cfg, null, 2)
+      const fileHandle = await fs.open(cfgPath, 'w')
+      try {
+        await fileHandle.writeFile(configJson, 'utf8')
+        await fileHandle.sync()
+        uiLog.info('POST /delete-all-devices - Config file written successfully')
+      } finally {
+        await fileHandle.close()
+      }
+
+      // Notify Homebridge UI that config changed
+      server.pushEvent('configChanged', { source: 'switchbot-plugin' })
+      uiLog.debug('DELETE /delete-all-devices - Sent configChanged event to UI')
+
+      return {
+        success: true,
+        data: {
+          message: `Removed ${deviceCount} device(s) from config`,
+          deletedCount: deviceCount,
+        },
+      }
+    } catch (e) {
+      uiLog.error(`Error in /delete-all-devices: ${e instanceof Error ? e.message : String(e)}`)
+      throw new RequestError(`Failed to delete all devices: ${e instanceof Error ? e.message : String(e)}`, e)
+    }
+  })
+
+}