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

package/dist/homebridge-ui/public/js/api.ts

@@ -0,0 +1,355 @@
+// Fetch the list of configured devices from the Homebridge UI API
+import { isValidDeviceType, normalizeDeviceType } from '../../../device-types.js'
+import './types.js'
+import { uiLog } from './logger.js'
+import { toastError } from './toast.js'
+
+export async function fetchDevices(): Promise<any[]> {
+  try {
+    if (typeof homebridge.getPluginConfig !== 'function') {
+      throw new TypeError('Homebridge UI API not available')
+    }
+    const configArr = await homebridge.getPluginConfig()
+    const config = Array.isArray(configArr) && configArr.length > 0 ? configArr.find(isSwitchBotPlatformConfig) : null
+    if (!config || !Array.isArray(config.devices)) {
+      return []
+    }
+    return config.devices
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    uiLog.error('Error fetching devices:', msg)
+    return []
+  }
+}
+
+/**
+ * Validate and auto-correct device types in the config array before saving.
+ * Returns an array of errors for devices that cannot be fixed.
+ */
+export function validateAndFixDeviceTypes(devices: Array<{ deviceId: string, configDeviceName: string, configDeviceType: string }>) {
+  const errors: Array<{ deviceId: string, name: string, type: string }> = []
+  for (const d of devices) {
+    if (!isValidDeviceType(d.configDeviceType)) {
+      const fixed = normalizeDeviceType(d.configDeviceType)
+      if (fixed) {
+        d.configDeviceType = fixed
+      } else {
+        errors.push({
+          deviceId: d.deviceId,
+          name: d.configDeviceName,
+          type: d.configDeviceType,
+        })
+      }
+    }
+  }
+  return errors
+}
+
+// API wrapper functions for communicating with the Homebridge UI server
+
+function isSwitchBotPlatformConfig(block: any): boolean {
+  const platformName = String(block?.platform || block?.name || '').toLowerCase()
+  return (
+    platformName === 'switchbot'
+    || platformName === '@switchbot/homebridge-switchbot'
+    || platformName.includes('switchbot')
+  )
+}
+
+export async function syncParentPluginConfigFromDisk(autoSave = false): Promise<boolean> {
+  try {
+    if (
+      typeof homebridge.getPluginConfig !== 'function'
+      || typeof homebridge.updatePluginConfig !== 'function'
+    ) {
+      uiLog.warn('Parent config sync API not available')
+      return false
+    }
+
+    // Use Homebridge UI API to fetch and update config
+    const pluginConfigBlocks = await homebridge.getPluginConfig()
+    if (!Array.isArray(pluginConfigBlocks) || !pluginConfigBlocks.length) {
+      uiLog.warn('No plugin config blocks returned from Homebridge')
+      return false
+    }
+
+    const index = pluginConfigBlocks.findIndex(block => isSwitchBotPlatformConfig(block))
+    if (index < 0) {
+      uiLog.warn('SwitchBot platform block not found in Homebridge plugin config')
+      return false
+    }
+
+    // Validate and fix device types before saving
+    const errors = validateAndFixDeviceTypes(pluginConfigBlocks[index].devices || [])
+    if (errors.length > 0) {
+      toastError(`Invalid device types found: ${errors.map(e => `${e.name} (${e.type})`).join(', ')}`)
+      return false
+    }
+    // pluginConfigBlocks[index] is already up to date
+    await homebridge.updatePluginConfig(pluginConfigBlocks)
+
+    // Auto-save to disk if requested - prevents parent UI from overwriting with stale cache
+    if (autoSave && typeof homebridge.savePluginConfig === 'function') {
+      uiLog.info('Auto-saving config to disk...')
+      await homebridge.savePluginConfig()
+      uiLog.info('Config saved successfully')
+    }
+
+    return true
+  } catch (e) {
+    uiLog.warn('Failed to sync parent plugin config cache:', e)
+    return false
+  }
+}
+
+export async function fetchCredentialStatus(): Promise<any> {
+  try {
+    const resp = await homebridge.request('/credentials', {})
+    uiLog.info('Load credentials response:', resp)
+
+    if (!resp || resp.success === false) {
+      uiLog.error('Failed to load credentials:', resp)
+      return null
+    }
+
+    return resp.data || {}
+  } catch (e) {
+    uiLog.error('Error loading credentials:', e)
+    return null
+  }
+}
+
+export async function saveCredentials(token: string, secret: string): Promise<any> {
+  uiLog.info('Saving credentials...')
+  const resp = await homebridge.request('/credentials', { token, secret })
+  uiLog.info('Save response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.message || 'Save failed')
+  }
+  return resp.data || resp
+}
+
+export interface DiscoverRequestOptions {
+  bleEnabled?: boolean
+  bleScanDurationSeconds?: number
+  bleTimeoutSeconds?: number
+}
+
+export async function discoverDevices(
+  mode: 'all' | 'ble' | 'openapi' = 'all',
+  options?: DiscoverRequestOptions,
+): Promise<any[]> {
+  const resp = await homebridge.request('/discover', { mode, ...options })
+  uiLog.info('Discover response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Discovery failed')
+  }
+  return resp.data || []
+}
+
+export async function fetchBluetoothStatus(): Promise<{ available: boolean, message: string }> {
+  try {
+    const resp = await homebridge.request('/ble-status', {})
+    if (!resp || resp.success === false) {
+      return { available: false, message: 'Bluetooth status unavailable' }
+    }
+    return resp.data || { available: false, message: 'Bluetooth status unavailable' }
+  } catch (_e) {
+    return { available: false, message: 'Bluetooth status unavailable' }
+  }
+}
+
+export async function testDeviceConnection(payload: {
+  deviceId: string
+  connectionType?: string
+  address?: string
+}): Promise<{
+  success: boolean
+  deviceId: string
+  method: string
+  latencyMs: number
+  message: string
+  state?: Record<string, any>
+}> {
+  const resp = await homebridge.request('/test-connection', payload)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Connection test failed')
+  }
+
+  return resp.data || {
+    success: false,
+    deviceId: payload.deviceId,
+    method: 'Auto',
+    latencyMs: 0,
+    message: 'Connection test failed',
+  }
+}
+
+export async function addDevice(
+  deviceId: string,
+  name: string,
+  type: string,
+  options?: { address?: string, model?: string, rssi?: number, encryptionKey?: string, keyId?: string },
+): Promise<any> {
+  if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
+    throw new TypeError('Homebridge UI API not available')
+  }
+  const configArr = await homebridge.getPluginConfig()
+  const idx = Array.isArray(configArr) ? configArr.findIndex(isSwitchBotPlatformConfig) : -1
+  if (idx === -1) {
+    throw new Error('SwitchBot config not found')
+  }
+  const config = configArr[idx]
+  if (!Array.isArray(config.devices)) {
+    config.devices = []
+  }
+  const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+  const exists = config.devices.some((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+  if (exists) {
+    return { alreadyExists: true, message: 'Device already in config' }
+  }
+  const newDevice: any = { deviceId, configDeviceName: name, configDeviceType: type }
+  if (options?.address) {
+    newDevice.address = options.address
+  }
+  if (options?.model) {
+    newDevice.model = options.model
+  }
+  if (options?.rssi !== undefined && options?.rssi !== null && options?.rssi !== 0) {
+    newDevice.rssi = options.rssi
+  }
+  if (options?.encryptionKey) {
+    newDevice.encryptionKey = options.encryptionKey
+  }
+  if (options?.keyId) {
+    newDevice.keyId = options.keyId
+  }
+  config.devices.push(newDevice)
+  await homebridge.updatePluginConfig(configArr)
+  if (typeof homebridge.savePluginConfig === 'function') {
+    await homebridge.savePluginConfig()
+  }
+  return { added: true, message: `Device "${name}" added successfully` }
+}
+
+export async function addDevicesInBulk(
+  devices: Array<{ deviceId: string, name: string, type: string, rssi?: number, address?: string, model?: string }>,
+): Promise<any> {
+  const resp = await homebridge.request('/add-devices', { devices })
+  uiLog.info('Bulk add response:', resp)
+  if (!resp || resp.success === false) {
+    throw new Error(resp?.data?.message || 'Bulk add failed')
+  }
+  return resp.data || resp
+}
+
+export async function updateDevice(
+  deviceId: string,
+  configDeviceName?: string,
+  configDeviceType?: string,
+  options?: {
+    refreshRate?: number
+    connectionPreference?: string
+    encryptionKey?: string
+    keyId?: string
+    room?: string
+    [key: string]: any
+  },
+): Promise<any> {
+  if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
+    throw new TypeError('Homebridge UI API not available')
+  }
+  const configArr = await homebridge.getPluginConfig()
+  const idx = Array.isArray(configArr) ? configArr.findIndex(isSwitchBotPlatformConfig) : -1
+  if (idx === -1) {
+    throw new Error('SwitchBot config not found')
+  }
+  const config = configArr[idx]
+  if (!Array.isArray(config.devices)) {
+    throw new TypeError('No devices array in config')
+  }
+  const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+  const device = config.devices.find((d: any) => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() === normalizedDeviceId)
+  if (!device) {
+    throw new Error('Device not found in config')
+  }
+  if (configDeviceName) {
+    device.configDeviceName = configDeviceName
+  }
+  if (configDeviceType) {
+    device.configDeviceType = configDeviceType
+  }
+  if (options) {
+    Object.assign(device, options)
+  }
+  await homebridge.updatePluginConfig(configArr)
+  if (typeof homebridge.savePluginConfig === 'function') {
+    await homebridge.savePluginConfig()
+  }
+  return { updated: true, message: `Device updated successfully` }
+}
+
+export async function deleteDevice(deviceId: string): Promise<any> {
+  if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
+    throw new TypeError('Homebridge UI API not available')
+  }
+  const configArr = await homebridge.getPluginConfig()
+  const idx = Array.isArray(configArr) ? configArr.findIndex(isSwitchBotPlatformConfig) : -1
+  if (idx === -1) {
+    throw new Error('SwitchBot config not found')
+  }
+  const config = configArr[idx]
+  if (!Array.isArray(config.devices)) {
+    throw new TypeError('No devices array in config')
+  }
+  const normalizedDeviceId = String(deviceId).trim().toLowerCase()
+  const before = config.devices.length
+  // Remove the target device
+  config.devices = config.devices.filter(d => String(d.deviceId ?? d.id ?? '').trim().toLowerCase() !== normalizedDeviceId)
+  // Defensive: filter out any invalid device entries (missing required fields)
+  config.devices = config.devices.filter(d => d && typeof d === 'object' && d.deviceId && d.configDeviceType)
+  if (config.devices.length === before) {
+    throw new Error('Device not found in config')
+  }
+  await homebridge.updatePluginConfig(configArr)
+  if (typeof homebridge.savePluginConfig === 'function') {
+    await homebridge.savePluginConfig()
+  }
+  return { deleted: true, message: `Device removed from config` }
+}
+
+export async function deleteAllDevices(): Promise<any> {
+  if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
+    throw new TypeError('Homebridge UI API not available')
+  }
+  const configArr = await homebridge.getPluginConfig()
+  // Find or create the SwitchBot config block
+  let idx = Array.isArray(configArr) ? configArr.findIndex(isSwitchBotPlatformConfig) : -1
+  if (idx === -1) {
+    // If not found, create a new config block for SwitchBot
+    const newBlock = { platform: 'SwitchBot', devices: [] }
+    configArr.push(newBlock)
+    idx = configArr.length - 1
+  }
+  const config = configArr[idx]
+  // Always ensure devices is an array
+  if (!Array.isArray(config.devices)) {
+    config.devices = []
+  }
+  const deletedCount = config.devices.length
+  config.devices = []
+  // Defensive: ensure required fields for schema compliance
+  if (!config.platform) {
+    config.platform = 'SwitchBot'
+  }
+  // Ensure 'name' property is present (required by schema for Homebridge platform blocks)
+  if (!config.name) {
+    config.name = 'SwitchBot'
+  }
+  // Save updated config
+  await homebridge.updatePluginConfig(configArr)
+  if (typeof homebridge.savePluginConfig === 'function') {
+    await homebridge.savePluginConfig()
+  }
+  return { deleted: true, deletedCount, message: `Removed ${deletedCount} device(s) from config` }
+}

package/dist/homebridge-ui/public/js/app.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.d.ts.map

package/dist/homebridge-ui/public/js/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../../src/homebridge-ui/public/js/app.ts"],"names":[],"mappings":""}