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

package/src/errors.ts

@@ -0,0 +1,43 @@
+// Error re-exports for node-switchbot v4 error compatibility
+
+let SwitchbotOperationError: any = undefined;
+let SwitchbotAuthenticationError: any = undefined;
+let CharacteristicMissingError: any = undefined;
+
+try {
+  // Dynamically import from node-switchbot if available
+  // (node-switchbot v4+ exports these error classes)
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const mod = require('node-switchbot');
+  SwitchbotOperationError = mod.SwitchbotOperationError;
+  SwitchbotAuthenticationError = mod.SwitchbotAuthenticationError;
+  CharacteristicMissingError = mod.CharacteristicMissingError;
+} catch {}
+
+// Fallbacks (for OpenAPI or legacy code)
+if (!SwitchbotOperationError) {
+  SwitchbotOperationError = class extends Error {
+    code?: string; cause?: Error;
+    constructor(message: string, code?: string, cause?: Error) {
+      super(message); this.name = 'SwitchbotOperationError'; this.code = code; this.cause = cause;
+    }
+  };
+}
+if (!SwitchbotAuthenticationError) {
+  SwitchbotAuthenticationError = class extends Error {
+    code?: string; cause?: Error;
+    constructor(message: string, code?: string, cause?: Error) {
+      super(message); this.name = 'SwitchbotAuthenticationError'; this.code = code; this.cause = cause;
+    }
+  };
+}
+if (!CharacteristicMissingError) {
+  CharacteristicMissingError = class extends Error {
+    characteristic: string;
+    constructor(message: string, characteristic: string) {
+      super(message); this.name = 'CharacteristicMissingError'; this.characteristic = characteristic;
+    }
+  };
+}
+
+export { SwitchbotOperationError, SwitchbotAuthenticationError, CharacteristicMissingError };

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

@@ -0,0 +1,126 @@
+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, getSwitchBotPlatformConfig, 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)
+    }
+  })
+
+  /**
+   * 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) {
+      const msg = e instanceof Error ? e.message : String(e)
+      uiLog.error(`Error in /platform-config: ${msg}`)
+      throw new RequestError(msg || '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)
+    }
+  })
+}