@switchbot/homebridge-switchbot 5.0.0-beta.8 → 5.0.0-beta.80

package/src/homebridge-ui/server.ts

@@ -1,48 +1,337 @@
-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()
+
+// 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 : []
+
+  for (const p of platforms) {
+    const platformName = p.platform || p.name || ''
+    if (!platformName || !/switchbot/i.test(String(platformName))) {
+      continue
+    }
+    return { config: cfg, platform: p, 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 options = p.options || p
+        const devices = Array.isArray(options.devices) ? options.devices : []
+        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
+      }
+    }
+
+    console.log('[SwitchBot UI] GET /devices - Found', found.length, 'devices')
+    return { success: true, data: found }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /devices:', e)
+    throw new RequestError('Failed to read Homebridge config', e)
+  }
+})
+
+server.onRequest('/discover', async () => {
+  try {
+    const { platform } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] GET /discover - Platform config:', Object.keys(platform))
+
+    const token = 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)
+
+    // Initialize devices array if needed
+    if (!Array.isArray(platform.devices)) {
+      platform.devices = []
+    }
+
+    // Check if already exists
+    const exists = platform.devices.some((d: any) => (d.deviceId ?? d.id) === deviceId)
+    if (exists) {
+      return { success: false, data: { message: 'Device already in config' } }
+    }
+
+    // Add device
+    platform.devices.push({
+      deviceId,
+      configDeviceName: name,
+      configDeviceType: type,
     })
-    this.ready()
+
+    // Save config
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+
+    console.log('[SwitchBot UI] Device added successfully:', deviceId)
+
+    return {
+      success: true,
+      data: { message: `Device "${name}" added successfully` },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /add-device:', e)
+    throw new RequestError('Failed to add device', e)
   }
-}
+})
 
-function startPluginUiServer(): PluginUiServer {
-  return new PluginUiServer()
-}
+server.onRequest('/update-device', async (body: any) => {
+  try {
+    const { deviceId, configDeviceName, connectionPreference, room } = body
+
+    if (!deviceId) {
+      throw new Error('Device ID is required')
+    }
+
+    const { config, platform, cfgPath } = await getSwitchBotPlatformConfig()
+
+    console.log('[SwitchBot UI] POST /update-device - Updating:', deviceId)
+
+    // Find and update device
+    if (!Array.isArray(platform.devices)) {
+      throw new TypeError('No devices found in config')
+    }
+
+    const device = platform.devices.find((d: any) => (d.deviceId ?? d.id) === deviceId)
+    if (!device) {
+      throw new Error('Device not found in config')
+    }
+
+    // Update properties
+    if (configDeviceName !== undefined) {
+      device.configDeviceName = configDeviceName
+    }
+    if (connectionPreference !== undefined) {
+      device.connectionPreference = connectionPreference
+    }
+    if (room !== undefined) {
+      device.room = room || undefined
+    }
+
+    // Save config
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+
+    console.log('[SwitchBot UI] Device updated successfully:', deviceId)
+
+    return {
+      success: true,
+      data: { message: `Device updated successfully` },
+    }
+  } catch (e) {
+    console.error('[SwitchBot UI] Error in /update-device:', e)
+    throw new RequestError('Failed to update device', 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)
+
+    // Remove device from array
+    if (!Array.isArray(platform.devices)) {
+      throw new TypeError('No devices found in config')
+    }
+
+    const index = platform.devices.findIndex((d: any) => (d.deviceId ?? d.id) === deviceId)
+    if (index === -1) {
+      throw new Error('Device not found in config')
+    }
+
+    const deviceName = platform.devices[index].configDeviceName || deviceId
+    platform.devices.splice(index, 1)
+
+    // Save config
+    await fs.writeFile(cfgPath, JSON.stringify(config, null, 2), 'utf8')
+
+    console.log('[SwitchBot UI] Device deleted successfully:', deviceId)
+
+    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 status = {
+        hasToken: !!platform.openApiToken,
+        hasSecret: !!platform.openApiSecret,
+        tokenLength: platform.openApiToken ? String(platform.openApiToken).length : 0,
+        secretLength: platform.openApiSecret ? String(platform.openApiSecret).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 directly on the platform config
+      platform.openApiToken = token
+      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,20 +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 = typeof api.isMatterEnabled === 'function'
-    ? Boolean(api.isMatterEnabled())
-    : Boolean((api as any).isMatterEnabled)
-
-  const log = (api as any).logger ?? (api as any).log ?? console
-  log.info?.(`Homebridge SwitchBot Plugin initializing in ${isMatter ? 'Matter' : 'HAP'} mode.`)
-  // 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)
 }