@switchbot/homebridge-switchbot 2.6.0-beta.4 → 2.6.0

package/src/irdevice/waterheater.ts

@@ -1,9 +1,6 @@
-import https from 'https';
-import crypto from 'crypto';
-import { IncomingMessage } from 'http';
-import superStringify from 'super-stringify';
+import { request } from 'undici';
 import { SwitchBotPlatform } from '../platform';
-import { irDevicesConfig, irdevice, HostDomain, DevicePath } from '../settings';
+import { irDevicesConfig, irdevice, Devices } from '../settings';
 import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
@@ -85,87 +82,57 @@ export class WaterHeater {
    */
   async pushWaterHeaterOnChanges(): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOnChanges Active: ${this.Active},`
-    + ` disablePushOn: ${this.disablePushOn}`);
+      + ` disablePushOn: ${this.disablePushOn}`);
     if (this.Active === this.platform.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
-      const body = superStringify({
+      const body = JSON.stringify({
         'command': command,
         'parameter': 'default',
         'commandType': commandType,
       });
-      await this.pushChanges({ body });
+      await this.pushChanges(body);
     }
   }
 
   async pushWaterHeaterOffChanges(): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushWaterHeaterOffChanges Active: ${this.Active},`
-    + ` disablePushOff: ${this.disablePushOff}`);
+      + ` disablePushOff: ${this.disablePushOff}`);
     if (this.Active === this.platform.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
-      const body = superStringify({
+      const body = JSON.stringify({
         'command': command,
         'parameter': 'default',
         'commandType': commandType,
       });
-      await this.pushChanges({ body });
+      await this.pushChanges(body);
     }
   }
 
-  async pushChanges({ body }: { body: any; }): Promise<void> {
+  async pushChanges(body: any): Promise<void> {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
     if (this.device.connectionType === 'OpenAPI') {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${body},`);
       try {
-      // Make Push On request to the API
-        const t = Date.now();
-        const nonce = 'requestID';
-        const data = this.platform.config.credentials?.token + t + nonce;
-        const signTerm = crypto.createHmac('sha256', this.platform.config.credentials?.secret)
-          .update(Buffer.from(data, 'utf-8'))
-          .digest();
-        const sign = signTerm.toString('base64');
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} sign: ${sign}`);
-        this.infoLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API. body: ${body},`] });
-        const options = {
-          hostname: HostDomain,
-          port: 443,
-          path: `${DevicePath}/${this.device.deviceId}/commands`,
+        const { body, statusCode, headers } = await request(`${Devices}/${this.device.deviceId}/commands`, {
           method: 'POST',
-          headers: {
-            'Authorization': this.platform.config.credentials?.token,
-            'sign': sign,
-            'nonce': nonce,
-            't': t,
-            'Content-Type': 'application/json',
-            'Content-Length': body.length,
-          },
-        };
-        const req = https.request(options, res => {
-          this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushchanges statusCode: ${res.statusCode}`);
-          this.statusCode({ res });
-          res.on('data', d => {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} d: ${d}`);
-          });
+          headers: this.platform.generateHeaders(),
         });
-        req.on('error', (e: any) => {
-          this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} error message: ${e.message}`] });
-        });
-        req.write(body);
-        req.end();
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushchanges: ${superStringify(req)}`);
+        const deviceStatus = await body.json();
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Devices: ${JSON.stringify(deviceStatus.body)}`);
+        this.statusCode(statusCode);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Headers: ${JSON.stringify(headers)}`);
         this.updateHomeKitCharacteristics();
       } catch (e: any) {
-        this.apiError({ e });
-        this.errorLog({
-          log: [`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType} Connection,`
-              + ` Error Message: ${superStringify(e.message)}`],
-        });
+        this.apiError(e);
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
+          + ` Connection, Error Message: ${JSON.stringify(e.message)}`,
+        );
       }
     } else {
-      this.warnLog({
-        log: [`${this.device.remoteType}: ${this.accessory.displayName}`
-            + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`],
-      });
+      this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+        + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
     }
   }
 
@@ -225,36 +192,39 @@ export class WaterHeater {
     return command;
   }
 
-  async statusCode({ res }: { res: IncomingMessage }): Promise<void> {
-    switch (res.statusCode) {
+  async statusCode(statusCode: number): Promise<void> {
+    switch (statusCode) {
       case 151:
-        this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this device type.`] });
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
         break;
       case 152:
-        this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Device not found.`] });
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
         break;
       case 160:
-        this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported.`] });
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
         break;
       case 161:
-        this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Device is offline.`] });
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
         break;
       case 171:
-        this.errorLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline. Hub: ${this.device.hubDeviceId}`] });
+        this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. `
+          + `Hub: ${this.device.hubDeviceId}`);
         break;
       case 190:
         this.errorLog(
-          {
-            log: [`${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized` +
-              ` with server, Or command: ${superStringify(res)} format is invalid`],
-          },
+          `${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
+          ` Or command format is invalid, statusCode: ${statusCode}`,
         );
         break;
       case 100:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent.`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
+        break;
+      case 200:
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
         break;
       default:
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode.`);
+        this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: `
+          + `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
     }
   }
 
@@ -265,7 +235,7 @@ export class WaterHeater {
   FirmwareRevision({ accessory, device }: { accessory: PlatformAccessory; device: irdevice & irDevicesConfig; }): string {
     let FirmwareRevision: string;
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-    + ` accessory.context.FirmwareRevision: ${accessory.context.FirmwareRevision}`);
+      + ` accessory.context.FirmwareRevision: ${accessory.context.FirmwareRevision}`);
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} device.firmware: ${device.firmware}`);
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} this.platform.version: ${this.platform.version}`);
     if (accessory.context.FirmwareRevision) {
@@ -316,7 +286,7 @@ export class WaterHeater {
       config['disablePushOff'] = device.disablePushOff;
     }
     if (Object.entries(config).length !== 0) {
-      this.infoLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Config: ${superStringify(config)}`] });
+      this.infoLog({ log: [`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`] });
     }
   }
 
@@ -339,19 +309,19 @@ export class WaterHeater {
   /**
    * Logging for Device
    */
-  infoLog({ log = [] }: { log?: any[]; } = {}): void {
+  infoLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));
     }
   }
 
-  warnLog({ log = [] }: { log?: any[]; } = {}): void {
+  warnLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.warn(String(...log));
     }
   }
 
-  debugWarnLog({ log = [] }: { log?: any[]; } = {}): void {
+  debugWarnLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
         this.platform.log.warn('[DEBUG]', String(...log));
@@ -359,13 +329,13 @@ export class WaterHeater {
     }
   }
 
-  errorLog({ log = [] }: { log?: any[]; } = {}): void {
+  errorLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       this.platform.log.error(String(...log));
     }
   }
 
-  debugErrorLog({ log = [] }: { log?: any[]; } = {}): void {
+  debugErrorLog(...log: any[]): void {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
         this.platform.log.error('[DEBUG]', String(...log));

package/src/platform.ts

@@ -10,7 +10,7 @@ import { IOSensor } from './device/iosensor';
 import { MeterPlus } from './device/meterplus';
 import { ColorBulb } from './device/colorbulb';
 import { CeilingLight } from './device/ceilinglight';
-import { StripLight } from './device/striplight';
+import { StripLight } from './device/lightstrip';
 import { Humidifier } from './device/humidifier';
 import { RobotVacuumCleaner } from './device/robotvacuumcleaner';
 import { TV } from './irdevice/tv';
@@ -23,17 +23,16 @@ import { AirPurifier } from './irdevice/airpurifier';
 import { WaterHeater } from './irdevice/waterheater';
 import { VacuumCleaner } from './irdevice/vacuumcleaner';
 import { AirConditioner } from './irdevice/airconditioner';
-import https from 'https';
-import crypto from 'crypto';
+import {request} from 'undici';
+import crypto, { randomUUID } from 'crypto';
 import { Buffer } from 'buffer';
 import { queueScheduler } from 'rxjs';
 import fakegato from 'fakegato-history';
-import superStringify from 'super-stringify';
+
 import { readFileSync, writeFileSync } from 'fs';
 import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, Service, Characteristic } from 'homebridge';
 import {
-  PLATFORM_NAME, PLUGIN_NAME, irdevice, device, SwitchBotPlatformConfig, devicesConfig, DevicePath, HostDomain, irDevicesConfig } from './settings';
-import { IncomingMessage } from 'http';
+  PLATFORM_NAME, PLUGIN_NAME, irdevice, device, SwitchBotPlatformConfig, devicesConfig, irDevicesConfig, Devices } from './settings';
 
 /**
  * HomebridgePlatform
@@ -131,7 +130,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       platformConfig['pushRate'] = this.config.options.pushRate;
     }
     if (Object.entries(platformConfig).length !== 0) {
-      this.infoLog(`Platform Config: ${superStringify(platformConfig)}`);
+      this.infoLog(`Platform Config: ${JSON.stringify(platformConfig)}`);
     }
 
     if (this.config.options) {
@@ -254,150 +253,139 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
+  generateHeaders = () => {
+    const t = `${Date.now()}`;
+    const nonce = randomUUID();
+    const data = this.config.credentials?.token + t + nonce;
+    const signTerm = crypto.createHmac('sha256', this.config.credentials?.secret).update(Buffer.from(data, 'utf-8')).digest();
+    const sign = signTerm.toString('base64');
+
+    return {
+      'Authorization': this.config.credentials?.token,
+      'sign': sign,
+      'nonce': nonce,
+      't': t,
+      'Content-Type': 'application/json',
+    };
+  };
+
   /**
    * this method discovers devices
+   *
+      const t = `${Date.now()}`;
+      const nonce = 'requestID';
+      const data = this.config.credentials?.token + t + nonce;
+      const signTerm = crypto.createHmac('sha256', this.config.credentials?.secret).update(Buffer.from(data, 'utf-8')).digest();
+      const sign = signTerm.toString('base64');
    */
   async discoverDevices() {
-    try {
-      if (this.config.credentials?.token) {
-        const t = Date.now();
-        const nonce = 'requestID';
-        const data = this.config.credentials?.token + t + nonce;
-        const signTerm = crypto.createHmac('sha256', this.config.credentials?.secret).update(Buffer.from(data, 'utf-8')).digest();
-        const sign = signTerm.toString('base64');
-        this.debugLog(`sing: ${sign}`);
-        const options = {
-          hostname: HostDomain,
-          port: 443,
-          path: DevicePath,
-          method: 'GET',
-          headers: {
-            'Authorization': this.config.credentials?.token,
-            'sign': sign,
-            'nonce': nonce,
-            't': t,
-            'Content-Type': 'application/json',
-          },
-        };
-        const req = https.request(options, async (res) => {
-          this.debugLog(`statusCode: ${res.statusCode}`);
-          await this.statusCode({ res });
-          this.debugLog(`headers: ${superStringify(res.headers)}`);
-          let rawData = '';
-          res.on('data', (d) => {
-            rawData += d;
-            this.debugLog(`d: ${d}`);
-          });
-          res.on('end', () => {
-            try {
-              const devicesAPI = JSON.parse(rawData);
-              this.debugLog(`devicesAPI: ${superStringify(devicesAPI.body)}`);
-              // SwitchBot Devices
-              const deviceLists = devicesAPI.body.deviceList;
-              if (!this.config.options?.devices) {
-                this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
-                const devices = deviceLists.map((v: any) => v);
-                for (const device of devices) {
-                  if (device.deviceType) {
-                    if (device.configDeviceName) {
-                      device.deviceName = device.configDeviceName;
-                    }
-                    this.createDevice(device);
-                  }
-                }
-              } else if (this.config.credentials?.token && this.config.options.devices) {
-                this.debugLog(`SwitchBot Device Config Set: ${superStringify(this.config.options?.devices)}`);
-                const deviceConfigs = this.config.options?.devices;
-
-                const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
-                  a1.map((itm: { deviceId: string }) => ({
-                    ...a2.find(
-                      (item: { deviceId: string }) =>
-                        item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
-                    ),
-                    ...itm,
-                  }));
-
-                const devices = mergeBydeviceId(deviceLists, deviceConfigs);
-                this.debugLog(`SwitchBot Devices: ${superStringify(devices)}`);
-                for (const device of devices) {
-                  if (device.deviceType) {
-                    if (device.configDeviceName) {
-                      device.deviceName = device.configDeviceName;
-                    }
-                    this.createDevice(device);
-                  }
-                }
-              } else {
-                this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
+    if (this.config.credentials?.token) {
+      try {
+        const { body, statusCode, headers } = await request(Devices, {
+          headers: this.generateHeaders(),
+        });
+        const devicesAPI = await body.json();
+        this.debugLog(`Devices: ${JSON.stringify(devicesAPI.body)}`);
+        this.statusCode(statusCode);
+        this.debugLog(`Headers: ${JSON.stringify(headers)}`);
+        // SwitchBot Devices
+        const deviceLists = devicesAPI.body.deviceList;
+        if (!this.config.options?.devices) {
+          this.debugLog(`SwitchBot Device Config Not Set: ${JSON.stringify(this.config.options?.devices)}`);
+          const devices = deviceLists.map((v: any) => v);
+          for (const device of devices) {
+            if (device.deviceType) {
+              if (device.configDeviceName) {
+                device.deviceName = device.configDeviceName;
               }
-              if (devicesAPI.body.deviceList.length !== 0) {
-                this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
-              } else {
-                this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+              this.createDevice(device);
+            }
+          }
+        } else if (this.config.credentials?.token && this.config.options.devices) {
+          this.debugLog(`SwitchBot Device Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+          const deviceConfigs = this.config.options?.devices;
+
+          const mergeBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+            a1.map((itm: { deviceId: string }) => ({
+              ...a2.find(
+                (item: { deviceId: string }) =>
+                  item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
+              ),
+              ...itm,
+            }));
+
+          const devices = mergeBydeviceId(deviceLists, deviceConfigs);
+          this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`);
+          for (const device of devices) {
+            if (device.deviceType) {
+              if (device.configDeviceName) {
+                device.deviceName = device.configDeviceName;
               }
+              this.createDevice(device);
+            }
+          }
+        } else {
+          this.errorLog('SwitchBot Token Supplied, Issue with Auth.');
+        }
+        if (devicesAPI.body.deviceList.length !== 0) {
+          this.infoLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+        } else {
+          this.debugLog(`Total SwitchBot Devices Found: ${devicesAPI.body.deviceList.length}`);
+        }
 
-              // IR Devices
-              const irDeviceLists = devicesAPI.body.infraredRemoteList;
-              if (!this.config.options?.irdevices) {
-                this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
-                const devices = irDeviceLists.map((v: any) => v);
-                for (const device of devices) {
-                  if (device.remoteType) {
-                    this.createIRDevice(device);
-                  }
-                }
-              } else {
-                this.debugLog(`IR Device Config Set: ${superStringify(this.config.options?.irdevices)}`);
-                const irDeviceConfig = this.config.options?.irdevices;
-
-                const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
-                  a1.map((itm: { deviceId: string }) => ({
-                    ...a2.find(
-                      (item: { deviceId: string }) =>
-                        item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
-                    ),
-                    ...itm,
-                  }));
-
-                const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
-                this.debugLog(`IR Devices: ${superStringify(devices)}`);
-                for (const device of devices) {
-                  this.createIRDevice(device);
-                }
-              }
-              if (devicesAPI.body.infraredRemoteList.length !== 0) {
-                this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-              } else {
-                this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
-              }
-            } catch (e:any) {
-              this.errorLog(`API Request: ${e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
+        // IR Devices
+        const irDeviceLists = devicesAPI.body.infraredRemoteList;
+        if (!this.config.options?.irdevices) {
+          this.debugLog(`IR Device Config Not Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+          const devices = irDeviceLists.map((v: any) => v);
+          for (const device of devices) {
+            if (device.remoteType) {
+              this.createIRDevice(device);
             }
-          });
-        });
-        req.on('error', (e: any) => {
-          this.errorLog(`req: ${e}, Submit Bugs Here: ` + 'https://tinyurl.com/SwitchBotBug');
-        });
-        req.end();
-      } else if (!this.config.credentials?.token && this.config.options?.devices) {
-        this.debugLog(`SwitchBot Device Manual Config Set: ${superStringify(this.config.options?.devices)}`);
-        const deviceConfigs = this.config.options?.devices;
-        const devices = deviceConfigs.map((v: any) => v);
-        for (const device of devices) {
-          device.deviceType = device.configDeviceType;
-          device.deviceName = device.configDeviceName;
-          if (device.deviceType) {
-            this.createDevice(device);
+          }
+        } else {
+          this.debugLog(`IR Device Config Set: ${JSON.stringify(this.config.options?.irdevices)}`);
+          const irDeviceConfig = this.config.options?.irdevices;
+
+          const mergeIRBydeviceId = (a1: { deviceId: string }[], a2: any[]) =>
+            a1.map((itm: { deviceId: string }) => ({
+              ...a2.find(
+                (item: { deviceId: string }) =>
+                  item.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') === itm.deviceId.toUpperCase().replace(/[^A-Z0-9]+/g, '') && item,
+              ),
+              ...itm,
+            }));
+
+          const devices = mergeIRBydeviceId(irDeviceLists, irDeviceConfig);
+          this.debugLog(`IR Devices: ${JSON.stringify(devices)}`);
+          for (const device of devices) {
+            this.createIRDevice(device);
           }
         }
-      } else {
-        this.errorLog('Neither SwitchBot Token or Device Config are not set.');
-      }
-    } catch (e: any) {
-      this.debugErrorLog(`Failed to Discover Devices, Error Message: ${superStringify(e.message)}, Submit Bugs Here: `
+        if (devicesAPI.body.infraredRemoteList.length !== 0) {
+          this.infoLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+        } else {
+          this.debugLog(`Total IR Devices Found: ${devicesAPI.body.infraredRemoteList.length}`);
+        }
+
+      } catch (e: any) {
+        this.debugErrorLog(`Failed to Discover Devices, Error Message: ${JSON.stringify(e.message)}, Submit Bugs Here: `
       + 'https://tinyurl.com/SwitchBotBug');
-      this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+        this.debugErrorLog(`Failed to Discover Devices, Error: ${e}`);
+      }
+    } else if (!this.config.credentials?.token && this.config.options?.devices) {
+      this.debugLog(`SwitchBot Device Manual Config Set: ${JSON.stringify(this.config.options?.devices)}`);
+      const deviceConfigs = this.config.options?.devices;
+      const devices = deviceConfigs.map((v: any) => v);
+      for (const device of devices) {
+        device.deviceType = device.configDeviceType;
+        device.deviceName = device.configDeviceName;
+        if (device.deviceType) {
+          this.createDevice(device);
+        }
+      }
+    } else {
+      this.errorLog('Neither SwitchBot Token or Device Config are not set.');
     }
   }
 
@@ -556,7 +544,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
         this.createOthers(device);
         break;
       default:
-        this.debugLog(`Unsupported Device: ${superStringify(device)}`);
+        this.debugLog(`Unsupported Device: ${JSON.stringify(device)}`);
         this.warnLog(`Device: ${device.deviceName} with Device Type: ${device.remoteType}, is currently not supported.`);
         this.warnLog('Submit Feature Requests Here: ' + 'https://tinyurl.com/SwitchBotFeatureRequest');
     }
@@ -732,7 +720,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
-private async createMeterPlus(device: device & devicesConfig) {
+  private async createMeterPlus(device: device & devicesConfig) {
     const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
 
     // see if an accessory with the same uuid has already been registered and restored from
@@ -2124,40 +2112,38 @@ private async createMeterPlus(device: device & devicesConfig) {
     this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
   }
 
-  async statusCode({ res }: { res: IncomingMessage }): Promise<void> {
-    switch (res.statusCode) {
+  async statusCode(statusCode: number): Promise<void> {
+    switch (statusCode) {
       case 151:
-        this.errorLog('Command not supported by this device type, Submit Feature Request Here: ' + 'https://tinyurl.com/SwitchBotFeatureRequest');
+        this.errorLog(`Command not supported by this device type, statusCode: ${statusCode}, Submit Feature Request Here: `
+        + 'https://tinyurl.com/SwitchBotFeatureRequest');
         break;
       case 152:
-        this.errorLog('Device not found.');
+        this.errorLog(`Device not found, statusCode: ${statusCode}`);
         break;
       case 160:
-        this.errorLog('Command is not supported, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug');
+        this.errorLog(`Command is not supported, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
         break;
       case 161:
-        this.errorLog('Device is offline.');
+        this.errorLog(`Device is offline, statusCode: ${statusCode}`);
         break;
       case 171:
-        this.errorLog('is offline');
+        this.errorLog(`is offline, statusCode: ${statusCode}`);
         break;
       case 190:
-        this.errorLog('Requests reached the daily limit');
+        this.errorLog(`Requests reached the daily limit, statusCode: ${statusCode}`);
         break;
       case 100:
-        if (this.debugMode) {
-          this.debugLog('Command successfully sent.');
-        }
+        this.debugLog(`Command successfully sent, statusCode: ${statusCode}`);
+        break;
+      case 200:
+        this.debugLog(`Request successful, statusCode: ${statusCode}`);
         break;
       default:
-        if (this.debugMode) {
-          this.debugLog('Unknown statusCode, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug');
-        }
+        this.infoLog(`Unknown statusCode, statusCode: ${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
     }
   }
 
-
-
   // BLE Connection
   connectBLE() {
     let Switchbot: new () => any;

package/src/settings.ts

@@ -11,6 +11,11 @@ export const PLATFORM_NAME = 'SwitchBot';
  */
 export const PLUGIN_NAME = '@switchbot/homebridge-switchbot';
 
+/**
+ * This is the main url used to access SwitchBot API
+ */
+export const Devices = 'https://api.switch-bot.com/v1.1/devices';
+
 /**
  * This is the main url used to access SwitchBot API
  */