@switchbot/homebridge-switchbot 5.0.0-beta.1 → 5.0.0-beta.100

package/src/homebridge-ui/server.ts

@@ -1,48 +1,559 @@
-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', () => {
+/* eslint-disable no-console */
+import { HomebridgePluginUiServer, RequestError } from '@homebridge/plugin-ui-utils'
+import fs from 'node:fs/promises'
+
+const server = new HomebridgePluginUiServer()
+
+function getDevicesRef(platform: any): any[] {
+  if (!platform || typeof platform !== 'object') {
+    return []
+  }
+
+  if (Array.isArray(platform.devices)) {
+    return platform.devices
+  }
+
+  platform.devices = []
+  return platform.devices
+}
+
+function getDeviceArrays(platform: any): any[][] {
+  const rootDevices = getDevicesRef(platform)
+  return [rootDevices]
+}
+
+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
+  })
+}
+
+function getCredential(platform: any, key: 'openApiToken' | 'openApiSecret') {
+  return platform?.[key]
+}
+
+function setCredential(platform: any, key: 'openApiToken' | 'openApiSecret', value: string) {
+  if (!platform || typeof platform !== 'object') {
+    return
+  }
+
+  platform[key] = value
+}
+
+// Helper function to find the SwitchBot platform config
+async function getSwitchBotPlatformConfig() {
+  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 platforms = Array.isArray(cfg.platforms) ? cfg.platforms : []
+
+  console.log('[SwitchBot UI] getSwitchBotPlatformConfig - Found', platforms.length, 'platform(s)')
+  platforms.forEach((p: any, i: number) => {
+    console.log(`[SwitchBot UI]   Platform ${i}:`, p.platform || p.name)
+  })
+
+  const candidates = platforms.filter((p: any) => {
+    const platformName = p.platform || p.name || ''
+    return !!platformName && (/switchbot/i.test(String(platformName)) || String(platformName).toLowerCase() === '@switchbot/homebridge-switchbot')
+  })
+
+  console.log('[SwitchBot UI] Found', candidates.length, 'SwitchBot candidate(s)')
+
+  const platform = candidates.find((p: any) => {
+    const name = String(p.platform || '').toLowerCase()
+    return name === 'switchbot' || name === '@switchbot/homebridge-switchbot'
+  }) ?? candidates[0]
+
+  if (platform) {
+    console.log('[SwitchBot UI] Selected platform:', platform.platform || platform.name)
+    return { config: cfg, platform, cfgPath }
+  }
+
+  throw new Error('SwitchBot platform not found in 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 }> = []
+
+    const platforms = Array.isArray(cfg.platforms) ? cfg.platforms : []
+    for (const p of platforms) {
       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'))
-
-          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)
-            }
+        const platformName = p.platform || p.name || ''
+        // Match known SwitchBot platform identifiers
+        if (!platformName || !/switchbot/i.test(String(platformName))) {
+          continue
+        }
+
+        const devices = getAllDevices(p)
+        for (const d of devices) {
+          const id = d.deviceId ?? d.id
+          if (!id) {
+            continue
+          }
+
+          found.push({
+            id,
+            name: d.configDeviceName ?? d.name ?? d.deviceName,
+            type: d.configDeviceType ?? d.type ?? d.deviceType,
+            connectionPreference: d.connectionPreference ?? d.connection ?? 'auto',
+            room: d.room || d.location || undefined,
           })
         }
-        // Return the array
-        return devicesToReturn
-      } catch {
-        // Just return an empty accessory list in case of any errors
-        return []
+      } catch (e) {
+        // ignore malformed platform entries
       }
-    })
-    this.ready()
+    }
+
+    console.log('[SwitchBot UI] GET /devices - Found', found.length, 'devices in', cfgPath)
+    return { success: true, data: found }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /devices:', e)
+    throw new RequestError('Failed to read Homebridge config', e)
   }
-}
+})
 
-function startPluginUiServer(): PluginUiServer {
-  return new PluginUiServer()
-}
+server.onRequest('/discover', async () => {
+  try {
+    const { platform } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] GET /discover - Platform config:', Object.keys(platform))
+
+    const token = getCredential(platform, 'openApiToken') || platform.token
+    if (!token) {
+      console.error('[SwitchBot UI] No API token found in platform config')
+      throw new Error('OpenAPI token not configured. Please save your credentials first.')
+    }
+
+    console.log('[SwitchBot UI] GET /discover - Fetching devices from SwitchBot API')
+
+    const url = 'https://api.switch-bot.com/v1.0/devices'
+    const opts = {
+      headers: {
+        Authorization: token,
+      },
+    }
+
+    console.log('[SwitchBot UI] GET /discover - Making request to', url)
+    const resp = await fetch(url, opts)
+
+    console.log('[SwitchBot UI] GET /discover - API response status:', resp.status)
+
+    if (!resp.ok) {
+      const errorText = await resp.text()
+      console.error('[SwitchBot UI] API error response:', errorText)
+      throw new Error(`SwitchBot API returned ${resp.status}: ${errorText}`)
+    }
+
+    const data = await resp.json()
+    console.log('[SwitchBot UI] GET /discover - Full API response:', JSON.stringify(data, null, 2))
+
+    // Handle different response formats
+    let devices: any[] = []
+    if (Array.isArray(data)) {
+      devices = data
+    } else if (Array.isArray(data.body)) {
+      devices = data.body
+    } else if (Array.isArray(data.devices)) {
+      devices = data.devices
+    } else if (data.body && typeof data.body === 'object') {
+      // Sometimes the response has devices listed within body
+      const bodyKeys = Object.keys(data.body)
+      if (bodyKeys.includes('deviceList')) {
+        devices = Array.isArray(data.body.deviceList) ? data.body.deviceList : []
+      } else if (bodyKeys.includes('devices')) {
+        devices = Array.isArray(data.body.devices) ? data.body.devices : []
+      }
+    }
+
+    if (!Array.isArray(devices)) {
+      console.warn('[SwitchBot UI] Could not find devices array in API response. Response keys:', Object.keys(data), 'Body keys:', data.body ? Object.keys(data.body) : 'N/A')
+      devices = []
+    }
+
+    const discovered = devices.map((d: any) => ({
+      id: d.deviceId || d.id,
+      name: d.deviceName || d.name,
+      type: d.deviceType || d.type || 'unknown',
+      model: d.deviceModel || d.model,
+      enabled: d.enableCloudService !== false,
+    }))
+
+    console.log('[SwitchBot UI] GET /discover - Found', discovered.length, 'devices from API')
+    return { success: true, data: discovered }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /discover:', e instanceof Error ? e.message : String(e))
+    throw new RequestError(`Failed to discover devices: ${e instanceof Error ? e.message : String(e)}`, e)
+  }
+})
+
+server.onRequest('/add-device', async (body: any) => {
+  try {
+    const { deviceId, name, type } = body
+
+    if (!deviceId) {
+      throw new Error('Device ID is required')
+    }
+
+    const { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] POST /add-device - Adding device:', deviceId, 'to', cfgPath)
+    const deviceArrays = getDeviceArrays(platform)
+    const allDevices = getAllDevices(platform)
+
+    // Check if already exists
+    const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+    const exists = allDevices.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+    if (exists) {
+      console.log('[SwitchBot UI] Device already exists:', deviceId)
+      return {
+        success: true,
+        data: {
+          message: 'Device already in config',
+          alreadyExists: true,
+        },
+      }
+    }
+
+    // Add device
+    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 = {
+          deviceId,
+          configDeviceName: name,
+          configDeviceType: type,
+        }
+        ref.push(newDevice)
+        console.log('[SwitchBot UI] Added device to config:', JSON.stringify(newDevice))
+        addCount++
+      }
+    }
+
+    // Save config
+    const configJson = JSON.stringify(config, null, 2)
+    console.log(`[SwitchBot UI] Writing config to file (size: ${configJson.length} bytes)`)
+    await fs.writeFile(cfgPath, configJson, 'utf8')
+
+    console.log('[SwitchBot UI] Device added successfully:', deviceId, 'saved to', cfgPath)
+
+    return {
+      success: true,
+      data: {
+        message: `Device "${name}" added successfully`,
+        alreadyExists: false,
+        added: addCount > 0,
+      },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /add-device:', e)
+    throw new RequestError('Failed to add device', e)
+  }
+})
+
+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')
+    }
+
+    console.log('[SwitchBot UI] POST /add-devices - Starting bulk add for', devices.length, 'device(s)')
+
+    const { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] POST /add-devices - Config path:', cfgPath)
+    console.log('[SwitchBot UI] POST /add-devices - Platform name:', platform.platform || platform.name)
+    console.log('[SwitchBot UI] POST /add-devices - Current device count in platform:', (platform.devices || []).length)
+
+    const deviceArrays = getDeviceArrays(platform)
+    const allDevices = getAllDevices(platform)
+
+    console.log('[SwitchBot UI] POST /add-devices - Existing devices in config:', allDevices.map((d: any) => d.deviceId || d.id).join(', '))
+
+    let addedCount = 0
+    let skippedCount = 0
+    const results: Array<Record<string, any>> = []
+
+    for (const { deviceId, name, type } 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) {
+        console.log('[SwitchBot UI] Device already exists:', deviceId)
+        results.push({ deviceId, success: true, message: 'Already in config', alreadyExists: true })
+        skippedCount++
+        continue
+      }
+
+      // Add device
+      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 = {
+            deviceId,
+            configDeviceName: name,
+            configDeviceType: type,
+          }
+          ref.push(newDevice)
+          console.log('[SwitchBot UI] Pushed device to array:', deviceId, '- Array now has', ref.length, 'devices')
+          addedToArray = true
+        }
+      }
+
+      if (addedToArray) {
+        results.push({ deviceId, success: true, message: `Device "${name}" added` })
+        addedCount++
+      } else {
+        results.push({ deviceId, success: false, message: 'Failed to add device' })
+        skippedCount++
+      }
+    }
+
+    console.log('[SwitchBot UI] POST /add-devices - Processing complete. Added:', addedCount, 'Skipped:', skippedCount)
+    console.log('[SwitchBot UI] POST /add-devices - Platform.devices after additions:', (platform.devices || []).length)
+
+    // Save config once for all devices
+    const configJson = JSON.stringify(config, null, 2)
+    console.log(`[SwitchBot UI] Writing bulk config to file (size: ${configJson.length} bytes, devices: ${addedCount})`)
+    await fs.writeFile(cfgPath, configJson, 'utf8')
+    console.log('[SwitchBot UI] Config file written successfully')
+
+    // Verify file was written
+    const verify = await fs.readFile(cfgPath, 'utf8')
+    const verifyCfg = JSON.parse(verify)
+    const verifyPlatforms = verifyCfg.platforms.filter((p: any) => /switchbot/i.test(String(p.platform || p.name || '')))
+    const verifyDevices = verifyPlatforms[0]?.devices || []
+    console.log('[SwitchBot UI] Verification: File now contains', verifyDevices.length, 'devices in SwitchBot platform')
+
+    console.log('[SwitchBot UI] Bulk device add completed: Added', addedCount, 'Skipped', skippedCount)
+
+    return {
+      success: true,
+      data: {
+        message: `Added ${addedCount} device(s)${skippedCount > 0 ? ` (${skippedCount} skipped)` : ''}`,
+        addedCount,
+        skippedCount,
+        results,
+      },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /add-devices:', e)
+    throw new RequestError(`Failed to add devices: ${e instanceof Error ? e.message : String(e)}`, e)
+  }
+})
+
+server.onRequest('/update-device', async (body: any) => {
+  try {
+    const { deviceId, configDeviceName, configDeviceType, connectionPreference, room } = body
+
+    console.log('[SwitchBot UI] POST /update-device - Full request body:', JSON.stringify(body, null, 2))
+
+    if (!deviceId) {
+      throw new Error('Device ID is required')
+    }
+
+    const { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] POST /update-device - Updating device:', deviceId)
+    console.log('[SwitchBot UI] Parameters - name:', configDeviceName, 'type:', configDeviceType, 'pref:', connectionPreference, 'room:', room)
+
+    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) {
+      console.error('[SwitchBot UI] Device not found. Available devices:', devices.map((d: any) => d.deviceId ?? d.id))
+      throw new Error('Device not found in config')
+    }
+
+    console.log('[SwitchBot UI] Found device before update:', JSON.stringify(device, null, 2))
+
+    // Update properties in all config branches
+    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
+        }
+      }
+    }
+
+    if (configDeviceName !== undefined && configDeviceName !== null && String(configDeviceName).trim() !== '') {
+      console.log('[SwitchBot UI] ✓ Updated configDeviceName to:', configDeviceName)
+    }
+    if (configDeviceType !== undefined && configDeviceType !== null && String(configDeviceType).trim() !== '') {
+      console.log('[SwitchBot UI] ✓ Updated configDeviceType to:', configDeviceType)
+    }
+    if (connectionPreference !== undefined) {
+      console.log('[SwitchBot UI] ✓ Updated connectionPreference to:', connectionPreference)
+    }
+    if (room !== undefined) {
+      console.log('[SwitchBot UI] ✓ Updated room to:', room)
+    }
+
+    console.log('[SwitchBot UI] Device after updates:', JSON.stringify(device, null, 2))
+
+    // Save config
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+    console.log('[SwitchBot UI] ✓ Config file saved successfully:', cfgPath)
+
+    console.log('[SwitchBot UI] Device updated successfully:', deviceId)
+
+    return {
+      success: true,
+      data: { message: `Device updated successfully - type: ${configDeviceType || device.configDeviceType}` },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /update-device:', e instanceof Error ? e.message : String(e), e)
+    throw new RequestError(`Failed to update device: ${e instanceof Error ? e.message : String(e)}`, e)
+  }
+})
+
+server.onRequest('/delete-device', async (body: any) => {
+  try {
+    const { deviceId } = body
+
+    if (!deviceId) {
+      throw new Error('Device ID is required')
+    }
+
+    const { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] POST /delete-device - Deleting:', deviceId)
+
+    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')
+    }
+
+    // Save config
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+
+    console.log('[SwitchBot UI] Device deleted successfully:', deviceId, 'saved to', cfgPath)
+
+    return {
+      success: true,
+      data: { message: `Device "${deviceName}" removed from config` },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /delete-device:', e)
+    throw new RequestError('Failed to delete device', e)
+  }
+})
+
+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()
+
+      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,
+      }
+
+      console.log('[SwitchBot UI] GET /credentials - Status:', status)
+      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 { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+      console.log('[SwitchBot UI] POST /credentials - Saving to platform:', platform.platform || platform.name)
+      console.log('[SwitchBot UI] Config path:', cfgPath)
+      console.log('[SwitchBot UI] Token length:', token.length, 'Secret length:', secret.length)
+
+      // Save token and secret on the same config branch used by this platform
+      setCredential(platform, 'openApiToken', token)
+      setCredential(platform, 'openApiSecret', secret)
+
+      // Write back to config file
+      await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+
+      console.log('[SwitchBot UI] Credentials saved successfully')
+
+      return {
+        success: true,
+        data: { message: 'Credentials saved successfully' },
+      }
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /credentials:', e)
+    throw new RequestError('Failed to handle credentials request', e)
+  }
+})
+
+server.ready()
 
-startPluginUiServer()
+export default server

package/src/index.ts

@@ -4,15 +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 => {
-  // Call the instance method on the runtime `api` object (optional chaining in case
-  // older homebridge doesn't provide it). Treat undefined as false.
-  const isMatter = Boolean(api.isMatterEnabled?.())
-  // If Matter is enabled register the Matter platform, otherwise use HAP platform.
-  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, isMatter ? SwitchBotMatterPlatform : SwitchBotHAPPlatform)
+  const ProxyCtor = createPlatformProxy(SwitchBotHAPPlatform, SwitchBotMatterPlatform)
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, ProxyCtor as any)
 }