@switchbot/homebridge-switchbot 5.0.0-beta.107 → 5.0.0-beta.109

package/scripts/build-ui.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import esbuild from 'esbuild'
+import path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const srcDir = path.resolve(__dirname, '../src/homebridge-ui/public/js')
+const outputDir = path.resolve(__dirname, '../dist/homebridge-ui/public/js')
+
+// Ensure output directory exists
+fs.mkdirSync(outputDir, { recursive: true })
+
+// Transpile TypeScript to JavaScript with esbuild
+esbuild
+  .build({
+    entryPoints: [path.join(srcDir, 'app.ts')],
+    outfile: path.join(outputDir, 'app.js'),
+    bundle: true,
+    target: 'es2020',
+    platform: 'browser',
+    format: 'esm',
+    sourcemap: true,
+    external: [],
+    minify: false,
+    logLevel: 'info',
+  })
+  .then(() => {
+    console.log('✓ UI bundling complete')
+  })
+  .catch((error) => {
+    console.error('✗ UI bundling failed:', error)
+    process.exit(1)
+  })

package/scripts/free-dev-ports.mjs

@@ -0,0 +1,105 @@
+import { execSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { resolve } from 'node:path'
+
+function resolvePorts() {
+  let bridgePort = 51829
+  let uiPort = 8581
+
+  try {
+    const configPath = resolve(homedir(), '.homebridge-dev', 'config.json')
+    const config = JSON.parse(readFileSync(configPath, 'utf8'))
+
+    if (typeof config?.bridge?.port === 'number') {
+      bridgePort = config.bridge.port
+    }
+
+    const configUiPlatform = Array.isArray(config?.platforms)
+      ? config.platforms.find(platform => platform?.platform === 'config')
+      : undefined
+
+    if (typeof configUiPlatform?.port === 'number') {
+      uiPort = configUiPlatform.port
+    }
+  } catch {}
+
+  return [...new Set([bridgePort, uiPort])]
+}
+
+function pidsForPort(port) {
+  try {
+    const output = execSync(`lsof -ti tcp:${port}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+    return output ? output.split('\n').filter(Boolean) : []
+  } catch {
+    return []
+  }
+}
+
+function freePort(port) {
+  const initialPids = pidsForPort(port)
+  if (initialPids.length === 0) {
+    return
+  }
+
+  try {
+    execSync(`lsof -ti tcp:${port} | xargs -r kill -TERM`, { stdio: ['ignore', 'ignore', 'ignore'] })
+  } catch {}
+
+  const remainingPids = pidsForPort(port)
+  if (remainingPids.length > 0) {
+    try {
+      execSync(`lsof -ti tcp:${port} | xargs -r kill -KILL`, { stdio: ['ignore', 'ignore', 'ignore'] })
+    } catch {}
+  }
+}
+
+function cleanupDevProcesses() {
+  let output = ''
+  try {
+    output = execSync('ps -axo pid=,command=', { stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+  } catch {
+    return
+  }
+
+  const targetPids = output
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const firstSpace = line.indexOf(' ')
+      if (firstSpace === -1) {
+        return null
+      }
+
+      const pid = Number(line.slice(0, firstSpace).trim())
+      const command = line.slice(firstSpace + 1)
+      return Number.isFinite(pid) ? { pid, command } : null
+    })
+    .filter((entry) => {
+      if (!entry) {
+        return false
+      }
+
+      if (entry.pid === process.pid || entry.pid === process.ppid) {
+        return false
+      }
+
+      const isNodemonProcess = entry.command.includes('homebridge-switchbot/node_modules/.bin/nodemon')
+      const isConfigUiProcess = entry.command.trim().startsWith('homebridge-config-ui-x')
+      return isNodemonProcess || isConfigUiProcess
+    })
+    .map(entry => entry.pid)
+
+  for (const pid of targetPids) {
+    try {
+      process.kill(pid, 'SIGTERM')
+    } catch {}
+  }
+}
+
+cleanupDevProcesses()
+
+for (const port of resolvePorts()) {
+  freePort(port)
+}

package/scripts/sync-device-types.mjs

@@ -0,0 +1,28 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const root = process.cwd()
+const sourcePath = path.join(root, 'src/device-types.ts')
+const schemaPath = path.join(root, 'config.schema.json')
+
+const source = fs.readFileSync(sourcePath, 'utf8')
+const schemaRaw = fs.readFileSync(schemaPath, 'utf8')
+const schema = JSON.parse(schemaRaw)
+
+const match = source.match(/export const DEVICE_TYPES = (\{[\s\S]*?\}) as const/)
+if (!match) {
+  throw new Error('Could not find DEVICE_TYPES in src/device-types.ts')
+}
+
+const deviceTypesByCategory = Function(`return (${match[1]})`)()
+const enumValues = [...new Set(Object.values(deviceTypesByCategory).flat())]
+
+const configDeviceType = schema?.schema?.properties?.devices?.items?.properties?.configDeviceType
+if (!configDeviceType) {
+  throw new Error('Could not locate schema.properties.devices.items.properties.configDeviceType')
+}
+
+configDeviceType.enum = enumValues
+
+fs.writeFileSync(schemaPath, `${JSON.stringify(schema, null, 2)}\n`, 'utf8')
+console.log(`Synchronized ${enumValues.length} device types into config.schema.json`)

package/src/device-types.ts

@@ -0,0 +1,145 @@
+export const DEVICE_TYPES = {
+  'Window Coverings': ['Blind Tilt', 'Curtain', 'Curtain3', 'Roller Shade'],
+  'Locks & Access': [
+    'Keypad',
+    'Keypad Touch',
+    'Keypad Vision',
+    'Keypad Vision Pro',
+    'Lock Lite',
+    'Smart Lock',
+    'Smart Lock Pro',
+    'Smart Lock Ultra',
+    'Video Doorbell',
+  ],
+  'Sensors': ['Contact Sensor', 'Motion Sensor', 'Presence Sensor', 'Water Detector'],
+  'Lighting': [
+    'Candle Warmer Lamp',
+    'Ceiling Light',
+    'Ceiling Light Pro',
+    'Color Bulb',
+    'Floor Lamp',
+    'RGBIC Neon Rope Light',
+    'RGBIC Neon Wire Rope Light',
+    'RGBICWW Floor Lamp',
+    'RGBICWW Strip Light',
+    'Strip Light',
+    'Strip Light 3',
+  ],
+  'Climate Control': [
+    'Air Purifier PM2.5',
+    'Air Purifier Table PM2.5',
+    'Air Purifier VOC',
+    'Air Purifier Table VOC',
+    'Battery Circulator Fan',
+    'Circulator Fan',
+    'Humidifier',
+    'Humidifier2',
+    'Meter',
+    'MeterPlus',
+    'MeterPro',
+    'MeterPro(CO2)',
+    'Smart Radiator Thermostat',
+    'Standing Circulator Fan',
+    'WoIOSensor',
+  ],
+  'Plugs & Switches': [
+    'Garage Door Opener',
+    'Plug',
+    'Plug Mini (EU)',
+    'Plug Mini (JP)',
+    'Plug Mini (US)',
+    'Relay Switch 1',
+    'Relay Switch 1PM',
+    'Relay Switch 2PM',
+  ],
+  'Robot Vacuums': [
+    'K10+',
+    'K10+ Pro',
+    'Robot Vacuum Cleaner K10+ Pro Combo',
+    'Robot Vacuum Cleaner K11+',
+    'Robot Vacuum Cleaner K20 Plus Pro',
+    'Robot Vacuum Cleaner S1',
+    'Robot Vacuum Cleaner S1 Plus',
+    'Robot Vacuum Cleaner S10',
+    'Robot Vacuum Cleaner S20',
+  ],
+  'Hubs': ['AI Hub', 'Hub', 'Hub 2', 'Hub 3', 'Hub Mini', 'Hub Plus'],
+  'Cameras': [
+    'Indoor Cam',
+    'Pan/Tilt Cam',
+    'Pan/Tilt Cam 2K',
+    'Pan/Tilt Cam Plus 2K',
+    'Pan/Tilt Cam Plus 3K',
+  ],
+  'IR Devices': [
+    'Air Conditioner',
+    'Air Purifier',
+    'Camera',
+    'DVD',
+    'Fan',
+    'Light',
+    'Others',
+    'Projector',
+    'Set Top Box',
+    'Speaker',
+    'Streamer',
+    'TV',
+    'Vacuum Cleaner',
+    'Water Heater',
+  ],
+  'Other Devices': ['AI Art Frame', 'Bot', 'Home Climate Panel', 'Remote', 'remote with screen'],
+} as const
+
+export const DEVICE_TYPE_NORMALIZATION_MAP: Record<string, string> = {
+  'motion sensor': 'motion',
+  'contact sensor': 'contact',
+  'presence sensor': 'contact',
+  'water detector': 'water detector',
+  'humidifier2': 'humidifier',
+  'circulator fan': 'fan',
+  'battery circulator fan': 'fan',
+  'standing circulator fan': 'fan',
+  'smart lock': 'lock',
+  'smart lock pro': 'lock',
+  'smart lock ultra': 'lock',
+  'lock lite': 'lock',
+  'keypad': 'lock',
+  'keypad touch': 'lock',
+  'keypad vision': 'lock',
+  'keypad vision pro': 'lock',
+  'color bulb': 'light',
+  'ceiling light': 'light',
+  'ceiling light pro': 'light',
+  'candle warmer lamp': 'light',
+  'floor lamp': 'light',
+  'rgbic neon rope light': 'lightstrip',
+  'rgbic neon wire rope light': 'lightstrip',
+  'rgbicww floor lamp': 'lightstrip',
+  'rgbicww strip light': 'lightstrip',
+  'strip light': 'strip light',
+  'strip light 3': 'strip light',
+  'robot vacuum cleaner s1': 'vacuum',
+  'robot vacuum cleaner s1 plus': 'vacuum',
+  'robot vacuum cleaner s10': 'vacuum',
+  'robot vacuum cleaner s20': 'vacuum',
+  'robot vacuum cleaner k10+ pro combo': 'wosweeper',
+  'robot vacuum cleaner k11+': 'wosweeper',
+  'robot vacuum cleaner k20 plus pro': 'wosweeper',
+  'plug mini (eu)': 'plug mini (eu)',
+  'plug mini (jp)': 'plug mini (jp)',
+  'plug mini (us)': 'plug mini (us)',
+  'relay switch 1': 'relay switch 1',
+  'relay switch 1pm': 'relay switch 1pm',
+  'relay switch 2pm': 'relay switch 2pm',
+  'blind tilt': 'blind tilt',
+  'roller shade': 'roller shade',
+  'curtain3': 'curtain3',
+  'hub 2': 'hub 2',
+  'meterplus': 'meterplus',
+  'meterpro': 'meterpro',
+  'meterpro(co2)': 'meterpro(co2)',
+  'walletfinder': 'walletfinder',
+  'k10+': 'k10+',
+  'k10+ pro': 'k10+ pro',
+  'k10+ pro (wosweeperminipro)': 'k10+ pro (wosweeperminipro)',
+}

package/src/deviceFactory.ts

@@ -1,35 +1,37 @@
-import type { SwitchBotPluginConfig, DeviceType } from './settings.js'
-import { SwitchBotClient } from './switchbotClient.js'
+import type { DeviceType, SwitchBotPluginConfig } from './settings.js'
+
+import { DEVICE_TYPE_NORMALIZATION_MAP } from './device-types.js'
 import {
-  GenericDevice,
+  BlindTiltDevice,
   BotDevice,
+  ContactSensorDevice,
+  Curtain3Device,
   CurtainDevice,
   FanDevice,
+  GenericDevice,
+  Hub2Device,
+  HumidifierDevice,
   LightDevice,
   LightStripDevice,
-  MotionSensorDevice,
-  ContactSensorDevice,
-  VacuumDevice,
   LockDevice,
-  HumidifierDevice,
-  TemperatureSensorDevice,
-  RelaySwitchDevice,
-  RelaySwitch1PMDevice,
+  MeterDevice,
+  MotionSensorDevice,
   PlugDevice,
   PlugMiniDevice,
-  BlindTiltDevice,
-  Curtain3Device,
+  RelaySwitch1PMDevice,
+  RelaySwitchDevice,
   RollerShadeDevice,
-  Hub2Device,
-  MeterDevice,
-  WaterDetectorDevice,
   SmartFanDevice,
   StripLightDevice,
+  TemperatureSensorDevice,
+  VacuumDevice,
   WalletFinderDevice,
+  WaterDetectorDevice,
   WoSweeperDevice,
   WoSweeperMiniDevice,
   WoSweeperMiniProDevice,
 } from './devices/genericDevice.js'
+import { SwitchBotClient } from './switchbotClient.js'
 
 export interface DeviceOptions {
   id: string
@@ -39,30 +41,33 @@ export interface DeviceOptions {
 }
 
 const DEVICE_CLASS_MAP: Record<string, any> = {
-  bot: BotDevice,
-  curtain: CurtainDevice,
-  fan: FanDevice,
-  light: LightDevice,
-  lightstrip: LightStripDevice,
-  motion: MotionSensorDevice,
-  contact: ContactSensorDevice,
-  vacuum: VacuumDevice,
-  lock: LockDevice,
-  humidifier: HumidifierDevice,
-  temperature: TemperatureSensorDevice,
+  // Primary device type keys (lowercase, simplified)
+  'bot': BotDevice,
+  'curtain': CurtainDevice,
+  'fan': FanDevice,
+  'light': LightDevice,
+  'lightstrip': LightStripDevice,
+  'motion': MotionSensorDevice,
+  'contact': ContactSensorDevice,
+  'vacuum': VacuumDevice,
+  'lock': LockDevice,
+  'humidifier': HumidifierDevice,
+  'temperature': TemperatureSensorDevice,
   'relay switch 1': RelaySwitchDevice,
   'relay switch 1pm': RelaySwitch1PMDevice,
-  plug: PlugDevice,
+  'relay switch 2pm': RelaySwitch1PMDevice,
+  'plug': PlugDevice,
   'plug mini (jp)': PlugMiniDevice,
   'plug mini (us)': PlugMiniDevice,
+  'plug mini (eu)': PlugMiniDevice,
   'blind tilt': BlindTiltDevice,
-  curtain3: Curtain3Device,
+  'curtain3': Curtain3Device,
   'worollershade': RollerShadeDevice,
   'wo rollershade': RollerShadeDevice,
   'roller shade': RollerShadeDevice,
   'rollershade': RollerShadeDevice,
   'hub 2': Hub2Device,
-  meter: MeterDevice,
+  'meter': MeterDevice,
   'meterplus': MeterDevice,
   'meter plus (jp)': MeterDevice,
   'meterpro': MeterDevice,
@@ -70,6 +75,7 @@ const DEVICE_CLASS_MAP: Record<string, any> = {
   'water detector': WaterDetectorDevice,
   'smart fan': SmartFanDevice,
   'strip light': StripLightDevice,
+  'strip light 3': StripLightDevice,
   'walletfinder': WalletFinderDevice,
   'wosweeper': WoSweeperDevice,
   'wosweepermini': WoSweeperMiniDevice,
@@ -77,10 +83,42 @@ const DEVICE_CLASS_MAP: Record<string, any> = {
   'k10+': WoSweeperDevice,
   'k10+ pro': WoSweeperDevice,
   'k10+ pro (wosweeperminipro)': WoSweeperMiniProDevice,
+  // API display name aliases (for UI compatibility)
+  'motion sensor': MotionSensorDevice,
+  'contact sensor': ContactSensorDevice,
+  'humidifier2': HumidifierDevice,
+  'circulator fan': FanDevice,
+  'battery circulator fan': FanDevice,
+  'standing circulator fan': FanDevice,
+  'smart lock': LockDevice,
+  'smart lock pro': LockDevice,
+  'smart lock ultra': LockDevice,
+  'lock lite': LockDevice,
+  'keypad': LockDevice,
+  'keypad touch': LockDevice,
+  'keypad vision': LockDevice,
+  'keypad vision pro': LockDevice,
+  'color bulb': LightDevice,
+  'ceiling light': LightDevice,
+  'ceiling light pro': LightDevice,
+  'candle warmer lamp': LightDevice,
+  'floor lamp': LightDevice,
+  'rgbic neon rope light': LightStripDevice,
+  'rgbic neon wire rope light': LightStripDevice,
+  'rgbicww floor lamp': LightStripDevice,
+  'rgbicww strip light': LightStripDevice,
+  'robot vacuum cleaner s1': VacuumDevice,
+  'robot vacuum cleaner s1 plus': VacuumDevice,
+  'robot vacuum cleaner s10': VacuumDevice,
+  'robot vacuum cleaner s20': VacuumDevice,
+  'robot vacuum cleaner k10+ pro combo': WoSweeperDevice,
+  'robot vacuum cleaner k11+': WoSweeperDevice,
+  'robot vacuum cleaner k20 plus pro': WoSweeperDevice,
 }
 
 function classForType(type: string) {
-  const key = (type || '').toLowerCase()
+  const rawKey = (type || '').toLowerCase()
+  const key = DEVICE_TYPE_NORMALIZATION_MAP[rawKey] ?? rawKey
   return DEVICE_CLASS_MAP[key] ?? GenericDevice
 }
 
@@ -106,7 +144,9 @@ export async function createDevice(opts: DeviceOptions, cfg: SwitchBotPluginConf
     try {
       // Prefer client-backed getDevice when available
       const dev = await client.getDevice(opts.id)
-      if (dev) return dev
+      if (dev) {
+        return dev
+      }
     } catch (e) {
       // ignore and fallback to device implementation
     }

package/src/devices/genericDevice.ts

@@ -4,6 +4,9 @@ import type { SwitchBotPluginConfig } from '../settings.js'
 import { MATTER_ATTRIBUTE_IDS, MATTER_CLUSTER_IDS } from '../utils.js'
 import { DeviceBase } from './deviceBase.js'
 
+// Module-scope regex pattern to avoid recompilation
+const HEX_COLOR_REGEX = /^#?[0-9A-F]{6}$/i
+
 export class GenericDevice extends DeviceBase {
   constructor(opts: any, cfg: SwitchBotPluginConfig) {
     super(opts, cfg)
@@ -384,7 +387,7 @@ export class LightDevice extends GenericDevice {
                 if (s && typeof s.hue === 'number') { return s.hue }
                 // try HSV from color hex
                 const hex = s?.color || s?.colorHex || s?.colour
-                if (typeof hex === 'string' && /^#?[0-9A-F]{6}$/i.test(hex)) {
+                if (typeof hex === 'string' && HEX_COLOR_REGEX.test(hex)) {
                   const h = (() => {
                     const hsl = (h: number, s: number, l: number) => ({ h, s, l })
                     // convert hex -> rgb -> hsv
@@ -420,7 +423,7 @@ export class LightDevice extends GenericDevice {
                 if (s && typeof s.saturation === 'number') { return s.saturation }
                 // if color hex is available, derive saturation from rgb
                 const hex = s?.color || s?.colorHex || s?.colour
-                if (typeof hex === 'string' && /^#?[0-9A-F]{6}$/i.test(hex)) {
+                if (typeof hex === 'string' && HEX_COLOR_REGEX.test(hex)) {
                   const cleaned = hex.replace('#', '')
                   const r = Number.parseInt(cleaned.substr(0, 2), 16) / 255
                   const g = Number.parseInt(cleaned.substr(2, 2), 16) / 255

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

@@ -0,0 +1,79 @@
+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'
+
+/**
+ * Register config-related endpoints
+ */
+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 }> = []
+
+      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
+            }
+
+            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,
+            })
+          }
+        } catch (e) {
+          // ignore malformed platform entries
+        }
+      }
+
+      uiLog.info(`GET /devices - Found ${found.length} devices in ${cfgPath}`)
+      return { success: true, data: found }
+    } 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)
+    }
+  })
+}