@switchbot/homebridge-switchbot 1.15.1-beta.0 → 1.15.1-beta.10

package/src/irdevice/waterheater.ts

@@ -1,6 +1,8 @@
-import { AxiosResponse } from 'axios';
+import https from 'https';
+import crypto from 'crypto';
+import { IncomingMessage } from 'http';
 import { SwitchBotPlatform } from '../platform';
-import { irDevicesConfig, DeviceURL, irdevice, payload } from '../settings';
+import { irDevicesConfig, irdevice, HostDomain, DevicePath } from '../settings';
 import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
@@ -95,7 +97,7 @@ export class WaterHeater {
         commandType: 'command',
         parameter: 'default',
         command: 'turnOn',
-      } as payload;
+      };
       await this.pushChanges(payload);
     }
   }
@@ -106,12 +108,12 @@ export class WaterHeater {
         commandType: 'command',
         parameter: 'default',
         command: 'turnOff',
-      } as payload;
+      };
       await this.pushChanges(payload);
     }
   }
 
-  async pushChanges(payload: payload): Promise<void> {
+  async pushChanges(payload): Promise<void> {
     try {
       this.infoLog(
         `Water Heater: ${this.accessory.displayName} Sending request to SwitchBot API. command: ${payload.command},` +
@@ -119,9 +121,42 @@ export class WaterHeater {
       );
 
       // Make the API request
-      const push = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-      this.debugLog(`Water Heater: ${this.accessory.displayName} pushChanges: ${push.data}`);
-      this.statusCode(push);
+      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(`Water Heater: ${this.accessory.displayName} sign: ${sign}`);
+      const options = {
+        hostname: HostDomain,
+        port: 443,
+        path: `${DevicePath}/${this.device.deviceId}/commands`,
+        method: 'POST',
+        headers: {
+          Authorization: this.platform.config.credentials?.token,
+          sign: sign,
+          nonce: nonce,
+          t: t,
+          'Content-Type': 'application/json',
+        },
+      };
+
+      const req = https.request(options, (res) => {
+        this.debugLog(`Water Heater: ${this.accessory.displayName} statusCode: ${res.statusCode}`);
+        this.statusCode({ res });
+        res.on('data', (d) => {
+          this.debugLog(`Water Heater: ${this.accessory.displayName} d: ${d}`);
+        });
+      });
+
+      req.on('error', (error) => {
+        this.errorLog(`Water Heater: ${this.accessory.displayName} error: ${error}`);
+      });
+
+      req.write(payload);
+      req.end();
+
+      this.debugLog(`Water Heater: ${this.accessory.displayName} pushchanges: ${JSON.stringify(req)}`);
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
       this.errorLog(`Water Heater: ${this.accessory.displayName} failed pushChanges with OpenAPI Connection`);
@@ -134,8 +169,8 @@ export class WaterHeater {
     }
   }
 
-  async statusCode(push: AxiosResponse<{ statusCode: number }>): Promise<void>{
-    switch (push.data.statusCode) {
+  async statusCode({ res }: { res: IncomingMessage }): Promise<void> {
+    switch (res.statusCode) {
       case 151:
         this.errorLog(`Water Heater: ${this.accessory.displayName} Command not supported by this device type.`);
         break;
@@ -154,7 +189,7 @@ export class WaterHeater {
       case 190:
         this.errorLog(
           `Water Heater: ${this.accessory.displayName} Device internal error due to device states not synchronized` +
-            ` with server, Or command: ${JSON.stringify(push.data)} format is invalid`,
+            ` with server, Or command: ${JSON.stringify(res)} format is invalid`,
         );
         break;
       case 100:

package/src/platform.ts

@@ -18,10 +18,13 @@ import { AirPurifier } from './irdevice/airpurifier';
 import { WaterHeater } from './irdevice/waterheater';
 import { VacuumCleaner } from './irdevice/vacuumcleaner';
 import { AirConditioner } from './irdevice/airconditioner';
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, Service, Characteristic } from 'homebridge';
-import { PLATFORM_NAME, PLUGIN_NAME, DeviceURL, irdevice, device, SwitchBotPlatformConfig, deviceResponses, devicesConfig } from './settings';
+import https from 'https';
+import crypto from 'crypto';
+import { Buffer } from 'buffer';
 import fakegato from 'fakegato-history';
+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 } from './settings';
 
 /**
  * HomebridgePlatform
@@ -35,12 +38,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   // this is used to track restored cached accessories
   public readonly accessories: PlatformAccessory[] = [];
 
-  public axios: AxiosInstance = axios.create({
-    responseType: 'json',
-  });
-
   version = require('../package.json').version || '1.12.8'; // eslint-disable-line @typescript-eslint/no-var-requires
-  deviceStatus!: deviceResponses;
+  deviceStatus!: any;
   registeringDevice!: boolean;
   debugMode!: boolean;
   platformLogging?: string;
@@ -49,6 +48,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
 
   constructor(public readonly log: Logger, public readonly config: SwitchBotPlatformConfig, public readonly api: API) {
     this.logs();
+
     this.debugLog('Finished initializing platform:', this.config.name);
     // only load if configured
     if (!this.config) {
@@ -72,13 +72,6 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       return;
     }
 
-    // setup axios interceptor to add headers / api key to each request
-    this.axios.interceptors.request.use((request: AxiosRequestConfig) => {
-      request.headers!.Authorization = this.config.credentials?.openToken;
-      request.headers!['Content-Type'] = 'application/json; charset=utf8';
-      return request;
-    });
-
     // import fakegato-history module
     this.fakegatoAPI = fakegato(api);
 
@@ -90,7 +83,11 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       this.debugLog('Executed didFinishLaunching callback');
       // run the method to discover / register your devices as accessories
       try {
-        this.discoverDevices();
+        if (this.config.credentials?.openToken && !this.config.credentials.token) {
+          await this.updateToken();
+        } else {
+          this.discoverDevices();
+        }
       } catch (e: any) {
         this.errorLog('Failed to Discover Devices.', JSON.stringify(e.message));
         if (this.platformLogging?.includes('debug')) {
@@ -134,7 +131,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   /**
    * Verify the config passed to the plugin is valid
    */
-  verifyConfig() {
+  async verifyConfig() {
     this.config.options = this.config.options || {};
 
     const platformConfig = {};
@@ -181,8 +178,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       }
     }
 
-    if (this.config.options!.refreshRate! < 30) {
-      throw new Error('Refresh Rate must be above 30 (30 seconds).');
+    if (this.config.options!.refreshRate! < 5) {
+      throw new Error('Refresh Rate must be above 5 (5 seconds).');
     }
 
     if (!this.config.options.refreshRate) {
@@ -205,12 +202,71 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
           this.debugLog('Missing Credentials');
         }
       }
-      if (!this.config.credentials?.openToken) {
+      if (!this.config.credentials?.token) {
         if (this.platformLogging?.includes('debug')) {
-          this.errorLog('Missing openToken');
+          this.errorLog('Missing token');
           this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
         }
       }
+      if (this.config.credentials?.token) {
+        if (!this.config.credentials?.secret) {
+          if (this.platformLogging?.includes('debug')) {
+            this.errorLog('Missing secret');
+            this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
+          }
+          throw Error('Missing secret');
+        }
+      }
+    }
+  }
+
+  /**
+   * The openToken was old config.
+   * This method saves the openToken as the token in the config.json file
+   * @param this.config.credentials.openToken
+   */
+  async updateToken() {
+    try {
+      // check the new token was provided
+      if (!this.config.credentials?.openToken) {
+        throw new Error('New token not provided');
+      }
+
+      // load in the current config
+      const currentConfig = JSON.parse(readFileSync(this.api.user.configPath(), 'utf8'));
+
+      // check the platforms section is an array before we do array things on it
+      if (!Array.isArray(currentConfig.platforms)) {
+        throw new Error('Cannot find platforms array in config');
+      }
+
+      // find this plugins current config
+      const pluginConfig = currentConfig.platforms.find((x: { platform: string }) => x.platform === PLATFORM_NAME);
+
+      if (!pluginConfig) {
+        throw new Error(`Cannot find config for ${PLATFORM_NAME} in platforms array`);
+      }
+
+      // check the .credentials is an object before doing object things with it
+      if (typeof pluginConfig.credentials !== 'object') {
+        throw new Error('pluginConfig.credentials is not an object');
+      }
+      // Move openToken to token
+      this.warnLog('This plugin has been updated to use OpenAPI v1.1, config is set with openToken.');
+      this.warnLog('`openToken` config has been moved to the `token` config, Please restart Homebridge.');
+
+      // set the refresh token
+      pluginConfig.credentials.token = this.config.credentials?.openToken;
+      pluginConfig.credentials.openToken = 'Delete';
+
+      if (this.platformLogging?.includes('debug')) {
+        this.warnLog(`Token: ${pluginConfig.credentials.token}`);
+      }
+      // save the config, ensuring we maintain pretty json
+      writeFileSync(this.api.user.configPath(), JSON.stringify(currentConfig, null, 4));
+      this.verifyConfig();
+    } catch (e: any) {
+      this.errorLog(e);
     }
   }
 
@@ -219,92 +275,130 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
    */
   async discoverDevices() {
     try {
-      if (this.config.credentials?.openToken) {
-        const devicesAPI: any = (await this.axios.get(DeviceURL)).data;
-        this.deviceListInfo(devicesAPI);
-        this.debugLog(JSON.stringify(devicesAPI));
-
-        // SwitchBot Devices
-        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}`);
-        }
-        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 (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(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, (res) => {
+          this.debugLog(`statusCode: ${res.statusCode}`);
+          this.debugLog(`headers: ${JSON.stringify(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: ${JSON.stringify(devicesAPI.body)}`);
+
+              // SwitchBot Devices
+              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?.openToken && 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;
+              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: ${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.');
               }
-              this.createDevice(device);
-            }
-          }
-        } else {
-          this.errorLog('Neither SwitchBot OpenToken or Device Config are not set.');
-        }
-        // IR Devices
-        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}`);
-        }
-        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: ${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) {
-            if (device.remoteType) {
-              this.createIRDevice(device);
+
+              // IR Devices
+              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}`);
+              }
+              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: ${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) {
+                  if (device.remoteType) {
+                    this.createIRDevice(device);
+                  }
+                }
+              }
+            } catch (e:any) {
+              this.errorLog(e.message);
             }
-          }
-        }
-      } else if (!this.config.credentials?.openToken && this.config.options?.devices) {
+          });
+        });
+        req.on('error', (error) => {
+          this.errorLog(error);
+        });
+        req.end();
+      } 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);
@@ -316,7 +410,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
           }
         }
       } else {
-        this.errorLog('Neither SwitchBot OpenToken or Device Config are not set.');
+        this.errorLog('Neither SwitchBot Token or Device Config are not set.');
       }
     } catch (e: any) {
       this.deviceError(e);
@@ -1676,7 +1770,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     this.warnLog(`Removing existing accessory from cache: ${existingAccessory.displayName}`);
   }
 
-  public deviceListInfo(devices: deviceResponses) {
+  public deviceListInfo(devices) {
     if (this.platformLogging?.includes('debug')) {
       this.warnLog(`deviceListInfoStatus: ${JSON.stringify(devices)}`);
     }
@@ -1685,7 +1779,38 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
   public async deviceInfo(device: (irdevice & devicesConfig) | (device & devicesConfig)) {
     if (this.platformLogging?.includes('debug')) {
       this.warnLog(JSON.stringify(device));
-      this.deviceStatus = (await this.axios.get(`${DeviceURL}/${device.deviceId}/status`)).data;
+
+      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(sign);
+      const options = {
+        hostname: HostDomain,
+        port: 443,
+        path: `${DevicePath}/${device.deviceId}/status`,
+        method: 'GET',
+        headers: {
+          Authorization: this.config.credentials?.token,
+          sign: sign,
+          nonce: nonce,
+          t: t,
+          'Content-Type': 'application/json',
+        },
+      };
+      const req = https.request(options, (res) => {
+        this.debugLog(`statusCode: ${res.statusCode}`);
+        res.on('data', (d) => {
+          process.stdout.write(d);
+        });
+      });
+      req.on('error', (error) => {
+        this.errorLog(error);
+      });
+      req.end();
+
+      this.deviceStatus = req;
       if (this.deviceStatus.message === 'success') {
         this.warnLog(`${device.deviceName} deviceInfoStatus: ${JSON.stringify(this.deviceStatus)}`);
       } else {

package/src/settings.ts

@@ -13,12 +13,12 @@ export const PLUGIN_NAME = '@switchbot/homebridge-switchbot';
 /**
  * This is the main url used to access SwitchBot API
  */
-export const AuthURL = 'https://api.switch-bot.com';
+export const HostDomain = 'api.switch-bot.com';
 
 /**
  * This is the main url used to access SwitchBot API
  */
-export const DeviceURL = 'https://api.switch-bot.com/v1.0/devices';
+export const DevicePath = '/v1.1/devices';
 
 //Config
 export interface SwitchBotPlatformConfig extends PlatformConfig {
@@ -27,6 +27,8 @@ export interface SwitchBotPlatformConfig extends PlatformConfig {
 }
 
 export type credentials = {
+  token?: any;
+  secret?: any;
   openToken?: any;
 };
 
@@ -175,23 +177,6 @@ export type other = {
   commandOff?: string;
 };
 
-export type payload = {
-  commandType: string;
-  parameter: string;
-  command: string;
-};
-
-export interface AxiosRequestConfig {
-  params?: Record<string, unknown>;
-  headers?: any;
-}
-
-export type deviceResponses = {
-  statusCode: number | string;
-  message: string;
-  body: deviceList | infraredRemoteList;
-};
-
 //a list of physical devices.
 export type deviceList = {
   device: Array<device>;
@@ -234,12 +219,6 @@ export type irdevice = {
   hubDeviceId: string; //remote device's parent Hub ID
 };
 
-export type deviceStatusResponse = {
-  statusCode: number;
-  message: string;
-  body: deviceStatus;
-};
-
 export type deviceStatus = {
   //device ID.
   deviceId: string;