tsvesync 1.0.12 → 1.0.13

package/src/lib/vesyncBaseDevice.ts

@@ -3,6 +3,7 @@
  */
 
 import { VeSync } from './vesync';
+import { logger } from './logger';
 
 export abstract class VeSyncBaseDevice {
     protected manager: VeSync;
@@ -37,11 +38,11 @@ export abstract class VeSyncBaseDevice {
      * Return formatted device info to stdout
      */
     display(): void {
-        console.log(`Device Name: ${this.deviceName}`);
-        console.log(`Status: ${this.deviceStatus}`);
-        console.log(`Device Type: ${this.deviceType}`);
-        console.log(`Connection: ${this.connectionStatus}`);
-        console.log(`Version: ${this.config.current_firmware_version || 'Unknown'}`);
+        logger.info(`Device Name: ${this.deviceName}`);
+        logger.info(`Status: ${this.deviceStatus}`);
+        logger.info(`Device Type: ${this.deviceType}`);
+        logger.info(`Connection: ${this.connectionStatus}`);
+        logger.info(`Version: ${this.config.current_firmware_version || 'Unknown'}`);
     }
 
     /**
@@ -90,13 +91,13 @@ export abstract class VeSyncBaseDevice {
      */
     protected logError(method: string, error: any): void {
         const errorMsg = error?.message || error;
-        console.error(`[${this.deviceName}] ${method}: ${errorMsg}`);
+        logger.error(`[${this.deviceName}] ${method}: ${errorMsg}`);
         
         // Log additional error details if available
         if (error?.response?.data) {
             const responseData = error.response.data;
             const msg = responseData.msg || responseData.message || JSON.stringify(responseData);
-            console.error(`Response: ${msg}`);
+            logger.error(`Response: ${msg}`);
         }
     }
 

package/src/lib/vesyncBulb.ts

@@ -5,22 +5,35 @@
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { VeSync } from './vesync';
 import { Helpers } from './helpers';
+import { logger } from './logger';
 
-// Feature dictionary for bulb types
-const featureDict: Record<string, { features: string[], colorModel: string }> = {
+interface BulbConfig {
+    [key: string]: {
+        module: string;
+        features: string[];
+        colorModel: string;
+    };
+}
+
+// Bulb configuration
+export const bulbConfig: BulbConfig = {
     'ESL100': {
+        module: 'VeSyncBulbESL100',
         features: ['dimmable'],
         colorModel: 'none'
     },
     'ESL100CW': {
+        module: 'VeSyncBulbESL100CW',
         features: ['dimmable', 'color_temp'],
         colorModel: 'none'
     },
     'XYD0001': {
+        module: 'VeSyncBulbXYD0001',
         features: ['dimmable', 'color_temp', 'rgb_shift'],
         colorModel: 'hsv'
     },
     'ESL100MC': {
+        module: 'VeSyncBulbESL100MC',
         features: ['dimmable', 'rgb_shift'],
         colorModel: 'rgb'
     }
@@ -47,7 +60,7 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
         this.colorHue = 0;
         this.colorSaturation = 0;
         this.colorMode = '';
-        this.features = featureDict[this.deviceType]?.features || [];
+        this.features = bulbConfig[this.deviceType]?.features || [];
         this.rgbValues = {
             red: 0,
             green: 0,
@@ -59,27 +72,43 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
      * Get bulb details
      */
     async getDetails(): Promise<void> {
-        const body = {
-            ...Helpers.reqBody(this.manager, 'devicedetail'),
-            uuid: this.cid,
-            method: 'devicedetail'
+        logger.debug(`[${this.deviceName}] Getting bulb details`);
+        
+        const isV2Device = this.deviceType === 'XYD0001';
+        const endpoint = isV2Device ? '/cloud/v2/deviceManaged/bypassV2' : '/cloud/v1/deviceManaged/bypass';
+        const body = isV2Device ? {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {},
+                method: 'getLightStatusV2',
+                source: 'APP'
+            }
+        } : {
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                getLightStatus: 'get'
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/devicedetail',
+            endpoint,
             'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0 && response?.result) {
-            this.deviceStatus = response.result.deviceStatus || this.deviceStatus;
+            this.deviceStatus = response.result.enabled ? 'on' : 'off';
             this.brightness = response.result.brightness || this.brightness;
             if (this.features.includes('color_temp')) {
                 this.colorTemp = response.result.colorTemp || this.colorTemp;
             }
             if (this.features.includes('rgb_shift')) {
-                if (featureDict[this.deviceType].colorModel === 'rgb') {
+                if (bulbConfig[this.deviceType].colorModel === 'rgb') {
                     this.rgbValues = {
                         red: response.result.red || this.rgbValues.red,
                         green: response.result.green || this.rgbValues.green,
@@ -91,6 +120,9 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
                     this.colorValue = response.result.value || this.colorValue;
                 }
             }
+            logger.debug(`[${this.deviceName}] Successfully retrieved bulb details`);
+        } else {
+            logger.error(`[${this.deviceName}] Failed to get bulb details: ${JSON.stringify(response)}`);
         }
     }
 
@@ -98,30 +130,55 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
      * Update bulb status
      */
     async update(): Promise<void> {
+        logger.debug(`[${this.deviceName}] Updating bulb information`);
         await this.getDetails();
+        logger.debug(`[${this.deviceName}] Successfully updated bulb information`);
     }
 
     /**
      * Turn bulb on
      */
     async turnOn(): Promise<boolean> {
-        const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on'
+        logger.debug(`[${this.deviceName}] Turning bulb on`);
+
+        const isV2Device = this.deviceType === 'XYD0001';
+        const endpoint = isV2Device ? '/cloud/v2/deviceManaged/bypassV2' : '/cloud/v1/deviceManaged/bypass';
+        const body = isV2Device ? {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    enabled: true,
+                    id: 0
+                },
+                method: 'setSwitch',
+                source: 'APP'
+            }
+        } : {
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    action: 'on'
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/devicestatus',
-            'put',
+            endpoint,
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.deviceStatus = 'on';
+            logger.debug(`[${this.deviceName}] Successfully turned bulb on`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to turn bulb on: ${JSON.stringify(response)}`);
         return false;
     }
 
@@ -129,23 +186,46 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
      * Turn bulb off
      */
     async turnOff(): Promise<boolean> {
-        const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'off'
+        logger.debug(`[${this.deviceName}] Turning bulb off`);
+
+        const isV2Device = this.deviceType === 'XYD0001';
+        const endpoint = isV2Device ? '/cloud/v2/deviceManaged/bypassV2' : '/cloud/v1/deviceManaged/bypass';
+        const body = isV2Device ? {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    enabled: false,
+                    id: 0
+                },
+                method: 'setSwitch',
+                source: 'APP'
+            }
+        } : {
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    action: 'off'
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/devicestatus',
-            'put',
+            endpoint,
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.deviceStatus = 'off';
+            logger.debug(`[${this.deviceName}] Successfully turned bulb off`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to turn bulb off: ${JSON.stringify(response)}`);
         return false;
     }
 
@@ -154,27 +234,55 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
      */
     async setBrightness(brightness: number): Promise<boolean> {
         if (!this.features.includes('dimmable')) {
+            logger.error(`[${this.deviceName}] Dimming not supported`);
             return false;
         }
 
-        const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            brightNess: brightness.toString()
+        logger.debug(`[${this.deviceName}] Setting brightness to ${brightness}`);
+
+        const isV2Device = this.deviceType === 'XYD0001';
+        const endpoint = isV2Device ? '/cloud/v2/deviceManaged/bypassV2' : '/cloud/v1/deviceManaged/bypass';
+        const body = isV2Device ? {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    brightness: brightness,
+                    colorMode: '',
+                    colorTemp: '',
+                    force: 0,
+                    hue: '',
+                    saturation: '',
+                    value: ''
+                },
+                method: 'setLightStatusV2',
+                source: 'APP'
+            }
+        } : {
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    brightness: brightness
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateBrightness',
-            'put',
+            endpoint,
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.brightness = brightness;
+            logger.debug(`[${this.deviceName}] Successfully set brightness to ${brightness}`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to set brightness: ${JSON.stringify(response)}`);
         return false;
     }
 
@@ -239,7 +347,7 @@ export abstract class VeSyncBulb extends VeSyncBaseDevice {
      * Get RGB values
      */
     getRGBValues(): { red: number, green: number, blue: number } {
-        if (!this.features.includes('rgb_shift') || featureDict[this.deviceType].colorModel !== 'rgb') {
+        if (!this.features.includes('rgb_shift') || bulbConfig[this.deviceType].colorModel !== 'rgb') {
             return { red: 0, green: 0, blue: 0 };
         }
         return this.rgbValues;

package/src/lib/vesyncBulbImpl.ts

@@ -2,9 +2,10 @@
  * VeSync Bulb Implementations
  */
 
-import { VeSyncBulb } from './vesyncBulb';
+import { VeSyncBulb, bulbConfig } from './vesyncBulb';
 import { VeSync } from './vesync';
 import { Helpers } from './helpers';
+import { logger } from './logger';
 
 /**
  * ESL100 Bulb Implementation
@@ -15,6 +16,7 @@ export class VeSyncBulbESL100 extends VeSyncBulb {
     }
 
     async setColorTemp(colorTemp: number): Promise<boolean> {
+        logger.error(`[${this.deviceName}] Color temperature control not supported`);
         return false;
     }
 }
@@ -29,27 +31,35 @@ export class VeSyncBulbESL100CW extends VeSyncBulb {
 
     async setColorTemp(colorTemp: number): Promise<boolean> {
         if (!this.features.includes('color_temp')) {
+            logger.error(`[${this.deviceName}] Color temperature control not supported`);
             return false;
         }
 
+        logger.debug(`[${this.deviceName}] Setting color temperature to ${colorTemp}`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            colorTemp: colorTemp.toString()
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    colorTempe: colorTemp
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColorTemperature',
-            'put',
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.colorTemp = colorTemp;
+            logger.debug(`[${this.deviceName}] Successfully set color temperature to ${colorTemp}`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to set color temperature: ${JSON.stringify(response)}`);
         return false;
     }
 }
@@ -64,48 +74,75 @@ export class VeSyncBulbXYD0001 extends VeSyncBulb {
 
     async setColorTemp(colorTemp: number): Promise<boolean> {
         if (!this.features.includes('color_temp')) {
+            logger.error(`[${this.deviceName}] Color temperature control not supported`);
             return false;
         }
 
+        logger.debug(`[${this.deviceName}] Setting color temperature to ${colorTemp}`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            colorTemp: colorTemp.toString()
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    brightness: '',
+                    colorMode: 'white',
+                    colorTemp: colorTemp,
+                    force: 1,
+                    hue: '',
+                    saturation: '',
+                    value: ''
+                },
+                method: 'setLightStatusV2',
+                source: 'APP'
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColorTemperature',
-            'put',
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.colorTemp = colorTemp;
+            logger.debug(`[${this.deviceName}] Successfully set color temperature to ${colorTemp}`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to set color temperature: ${JSON.stringify(response)}`);
         return false;
     }
 
     async setHsv(hue: number, saturation: number, value: number): Promise<boolean> {
         if (!this.features.includes('rgb_shift')) {
+            logger.error(`[${this.deviceName}] Color control not supported`);
             return false;
         }
 
+        logger.debug(`[${this.deviceName}] Setting HSV color to H:${hue} S:${saturation} V:${value}`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            mode: 'color',
-            hue: Math.round(hue).toString(),
-            saturation: Math.round(saturation).toString(),
-            brightness: Math.round(value).toString()
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    brightness: value,
+                    colorMode: 'hsv',
+                    colorTemp: '',
+                    force: 1,
+                    hue: hue,
+                    saturation: saturation,
+                    value: value
+                },
+                method: 'setLightStatusV2',
+                source: 'APP'
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColor',
-            'put',
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
@@ -114,30 +151,47 @@ export class VeSyncBulbXYD0001 extends VeSyncBulb {
             this.colorHue = hue;
             this.colorSaturation = saturation;
             this.colorValue = value;
+            logger.debug(`[${this.deviceName}] Successfully set HSV color`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to set HSV color: ${JSON.stringify(response)}`);
         return false;
     }
 
     async enableWhiteMode(): Promise<boolean> {
+        logger.debug(`[${this.deviceName}] Enabling white mode`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            colorMode: 'white'
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                data: {
+                    brightness: '',
+                    colorMode: 'white',
+                    colorTemp: '',
+                    force: 1,
+                    red: '',
+                    green: '',
+                    blue: ''
+                },
+                method: 'setLightStatusV2',
+                source: 'APP'
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColorMode',
-            'put',
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.colorMode = 'white';
+            logger.debug(`[${this.deviceName}] Successfully enabled white mode`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to enable white mode: ${JSON.stringify(response)}`);
         return false;
     }
 }
@@ -151,63 +205,78 @@ export class VeSyncBulbESL100MC extends VeSyncBulb {
     }
 
     async setColorTemp(colorTemp: number): Promise<boolean> {
+        logger.error(`[${this.deviceName}] Color temperature control not supported`);
         return false;
     }
 
     async setRgb(red: number, green: number, blue: number): Promise<boolean> {
         if (!this.features.includes('rgb_shift')) {
+            logger.error(`[${this.deviceName}] Color control not supported`);
             return false;
         }
 
+        logger.debug(`[${this.deviceName}] Setting RGB color to R:${red} G:${green} B:${blue}`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            mode: 'color',
-            red: Math.round(red).toString(),
-            green: Math.round(green).toString(),
-            blue: Math.round(blue).toString()
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    red: Math.round(red),
+                    green: Math.round(green),
+                    blue: Math.round(blue)
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColor',
-            'put',
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.rgbValues = { red, green, blue };
+            logger.debug(`[${this.deviceName}] Successfully set RGB color`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to set RGB color: ${JSON.stringify(response)}`);
         return false;
     }
 
     async enableWhiteMode(): Promise<boolean> {
+        logger.debug(`[${this.deviceName}] Enabling white mode`);
         const body = {
-            ...Helpers.reqBody(this.manager, 'devicestatus'),
-            uuid: this.cid,
-            status: 'on',
-            colorMode: 'white'
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: {
+                    mode: 'white'
+                }
+            }
         };
 
         const [response] = await Helpers.callApi(
-            '/SmartBulb/v1/device/updateColorMode',
-            'put',
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
             this.colorMode = 'white';
+            logger.debug(`[${this.deviceName}] Successfully enabled white mode`);
             return true;
         }
+        logger.error(`[${this.deviceName}] Failed to enable white mode: ${JSON.stringify(response)}`);
         return false;
     }
 }
 
 // Export the bulb modules dictionary
-export const bulbModules: Record<string, any> = {
+export const bulbModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncBulb> = {
     'ESL100': VeSyncBulbESL100,
     'ESL100CW': VeSyncBulbESL100CW,
     'XYD0001': VeSyncBulbXYD0001,

package/src/lib/vesyncFan.ts

@@ -4,9 +4,7 @@
 
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { VeSync } from './vesync';
-import { Helpers } from './helpers';
-
-type DeviceConstructor = new (config: Record<string, any>, manager: VeSync) => VeSyncBaseDevice;
+import { logger } from './logger';
 
 interface FanConfig {
     [key: string]: {
@@ -396,7 +394,7 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
         }
 
         for (const [key, value, unit = ''] of info) {
-            console.log(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
+            logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
         }
     }