tsvesync 1.3.9 → 1.3.10

package/src/lib/vesyncBulbImpl.ts

@@ -2,7 +2,7 @@
  * VeSync Bulb Implementations
  */
 
-import { VeSyncBulb, bulbConfig } from './vesyncBulb';
+import { VeSyncBulb } from './vesyncBulb';
 import { VeSync } from './vesync';
 import { Helpers } from './helpers';
 import { logger } from './logger';
@@ -15,6 +15,122 @@ export class VeSyncBulbESL100 extends VeSyncBulb {
         super(details, manager);
     }
 
+    async getDetails(): Promise<boolean> {
+        logger.debug(`[${this.deviceName}] Fetching ESL100 details`);
+        const body = {
+            ...Helpers.reqBody(this.manager, 'devicedetail'),
+            uuid: this.uuid
+        };
+
+        const [response, statusCode] = await this.callApi(
+            '/SmartBulb/v1/device/devicedetail',
+            'post',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        const success = this.checkResponse([response, statusCode], 'getDetails');
+        if (success && response?.result) {
+            const result = response.result;
+            if (result.deviceStatus) {
+                this.deviceStatus = result.deviceStatus;
+            }
+            if (result.connectionStatus) {
+                this.connectionStatus = result.connectionStatus;
+            }
+            if (result.brightNess !== undefined) {
+                this.brightness = Number(result.brightNess);
+            } else if (result.brightness !== undefined) {
+                this.brightness = Number(result.brightness);
+            }
+            logger.debug(`[${this.deviceName}] Updated details: status=${this.deviceStatus}, brightness=${this.brightness}`);
+        }
+
+        return success;
+    }
+
+    async turnOn(): Promise<boolean> {
+        const body = {
+            ...Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.uuid,
+            status: 'on'
+        };
+
+        const [response] = await this.callApi(
+            '/SmartBulb/v1/device/devicestatus',
+            'put',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
+            logger.info(`[${this.deviceName}] Turned on successfully`);
+            return true;
+        }
+
+        logger.error(`[${this.deviceName}] Failed to turn on: ${JSON.stringify(response)}`);
+        return false;
+    }
+
+    async turnOff(): Promise<boolean> {
+        const body = {
+            ...Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.uuid,
+            status: 'off'
+        };
+
+        const [response] = await this.callApi(
+            '/SmartBulb/v1/device/devicestatus',
+            'put',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.deviceStatus = 'off';
+            logger.info(`[${this.deviceName}] Turned off successfully`);
+            return true;
+        }
+
+        logger.error(`[${this.deviceName}] Failed to turn off: ${JSON.stringify(response)}`);
+        return false;
+    }
+
+    async setBrightness(brightness: number): Promise<boolean> {
+        if (!this.features.includes('dimmable')) {
+            logger.error(`[${this.deviceName}] Dimming not supported`);
+            return false;
+        }
+
+        const brightnessUpdate = VeSyncBulb.clamp(Math.round(brightness), 0, 100);
+        const body = {
+            ...Helpers.reqBody(this.manager, 'devicestatus'),
+            uuid: this.uuid,
+            status: 'on',
+            brightNess: String(brightnessUpdate)
+        };
+
+        const [response] = await this.callApi(
+            '/SmartBulb/v1/device/updateBrightness',
+            'put',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.brightness = brightnessUpdate;
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
+            logger.info(`[${this.deviceName}] Brightness set to ${brightnessUpdate}`);
+            return true;
+        }
+
+        logger.error(`[${this.deviceName}] Failed to set brightness: ${JSON.stringify(response)}`);
+        return false;
+    }
+
     async setColorTemp(colorTemp: number): Promise<boolean> {
         logger.error(`[${this.deviceName}] Color temperature control not supported`);
         return false;
@@ -29,36 +145,153 @@ export class VeSyncBulbESL100CW extends VeSyncBulb {
         super(details, manager);
     }
 
-    async setColorTemp(colorTemp: number): Promise<boolean> {
-        if (!this.features.includes('color_temp')) {
-            logger.error(`[${this.deviceName}] Color temperature control not supported`);
-            return false;
-        }
+    private buildBypassBody(lightPayload: Record<string, unknown>): Record<string, unknown> {
+        return {
+            ...Helpers.reqBody(this.manager, 'bypass'),
+            cid: this.cid,
+            configModule: this.configModule,
+            jsonCmd: {
+                light: lightPayload
+            }
+        };
+    }
 
-        logger.debug(`[${this.deviceName}] Setting color temperature to ${colorTemp}`);
+    async getDetails(): Promise<boolean> {
+        logger.debug(`[${this.deviceName}] Fetching ESL100CW status`);
         const body = {
             ...Helpers.reqBody(this.manager, 'bypass'),
             cid: this.cid,
             configModule: this.configModule,
             jsonCmd: {
-                light: {
-                    colorTempe: colorTemp
+                getLightStatus: 'get'
+            }
+        };
+
+        const [response, statusCode] = await this.callApi(
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        const success = this.checkResponse([response, statusCode], 'getDetails');
+        if (success) {
+            const inner = response?.result?.result || response?.result;
+            const light = inner?.light;
+            if (light) {
+                this.deviceStatus = light.action === 'on' ? 'on' : 'off';
+                if (light.brightness !== undefined) {
+                    this.brightness = Number(light.brightness);
+                }
+                if (light.colorTempe !== undefined) {
+                    this.colorTemp = Number(light.colorTempe);
                 }
             }
+        }
+
+        return success;
+    }
+
+    async turnOn(): Promise<boolean> {
+        const [response] = await this.callApi(
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
+            this.buildBypassBody({ action: 'on' }),
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
+            logger.info(`[${this.deviceName}] Turned on successfully`);
+            return true;
+        }
+
+        logger.error(`[${this.deviceName}] Failed to turn on: ${JSON.stringify(response)}`);
+        return false;
+    }
+
+    async turnOff(): Promise<boolean> {
+        const [response] = await this.callApi(
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
+            this.buildBypassBody({ action: 'off' }),
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.deviceStatus = 'off';
+            logger.info(`[${this.deviceName}] Turned off successfully`);
+            return true;
+        }
+
+        logger.error(`[${this.deviceName}] Failed to turn off: ${JSON.stringify(response)}`);
+        return false;
+    }
+
+    async setBrightness(brightness: number): Promise<boolean> {
+        if (!this.features.includes('dimmable')) {
+            logger.error(`[${this.deviceName}] Dimming not supported`);
+            return false;
+        }
+
+        const brightnessUpdate = VeSyncBulb.clamp(Math.round(brightness), 0, 100);
+        const light: Record<string, unknown> = {
+            action: 'on',
+            brightness: brightnessUpdate
         };
 
+        if (this.features.includes('color_temp')) {
+            light.colorTempe = this.colorTemp;
+        }
+
         const [response] = await this.callApi(
             '/cloud/v1/deviceManaged/bypass',
             'post',
-            body,
+            this.buildBypassBody(light),
             Helpers.reqHeaders(this.manager)
         );
 
         if (response?.code === 0) {
-            this.colorTemp = colorTemp;
-            logger.info(`[${this.deviceName}] Successfully set color temperature to ${colorTemp}`);
+            this.brightness = brightnessUpdate;
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
+            logger.info(`[${this.deviceName}] Brightness set to ${brightnessUpdate}`);
             return true;
         }
+
+        logger.error(`[${this.deviceName}] Failed to set brightness: ${JSON.stringify(response)}`);
+        return false;
+    }
+
+    async setColorTemp(colorTemp: number): Promise<boolean> {
+        if (!this.features.includes('color_temp')) {
+            logger.error(`[${this.deviceName}] Color temperature control not supported`);
+            return false;
+        }
+
+        const colorTempUpdate = VeSyncBulb.clamp(Math.round(colorTemp), 0, 100);
+        const light = {
+            action: 'on',
+            brightness: this.brightness,
+            colorTempe: colorTempUpdate
+        };
+
+        const [response] = await this.callApi(
+            '/cloud/v1/deviceManaged/bypass',
+            'post',
+            this.buildBypassBody(light),
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (response?.code === 0) {
+            this.colorTemp = colorTempUpdate;
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
+            logger.info(`[${this.deviceName}] Color temperature set to ${colorTempUpdate}`);
+            return true;
+        }
+
         logger.error(`[${this.deviceName}] Failed to set color temperature: ${JSON.stringify(response)}`);
         return false;
     }
@@ -204,73 +437,192 @@ export class VeSyncBulbESL100MC extends VeSyncBulb {
         super(details, manager);
     }
 
-    async setColorTemp(colorTemp: number): Promise<boolean> {
-        logger.error(`[${this.deviceName}] Color temperature control not supported`);
-        return false;
+    private buildBypassV2Payload(method: string, data: Record<string, unknown>): Record<string, unknown> {
+        return {
+            ...Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data
+            }
+        };
     }
 
-    async setRgb(red: number, green: number, blue: number): Promise<boolean> {
-        if (!this.features.includes('rgb_shift')) {
-            logger.error(`[${this.deviceName}] Color control not supported`);
+    private handleBypassV2Response(response: any, context: string): boolean {
+        if (!response) {
+            logger.error(`[${this.deviceName}] ${context} returned empty response`);
             return false;
         }
 
-        logger.debug(`[${this.deviceName}] Setting RGB color to R:${red} G:${green} B:${blue}`);
-        const body = {
-            ...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)
-                }
+        if (response.code !== 0) {
+            logger.error(`[${this.deviceName}] ${context} failed: ${JSON.stringify(response)}`);
+            return false;
+        }
+
+        const inner = response.result;
+        if (inner?.code !== undefined && inner.code !== 0) {
+            logger.error(`[${this.deviceName}] ${context} inner error: ${JSON.stringify(response)}`);
+            return false;
+        }
+
+        return true;
+    }
+
+    async getDetails(): Promise<boolean> {
+        logger.debug(`[${this.deviceName}] Fetching ESL100MC status`);
+        const body = this.buildBypassV2Payload('getLightStatus', {});
+        const [response, statusCode] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        const success = this.checkResponse([response, statusCode], 'getDetails');
+        if (!success) {
+            return false;
+        }
+
+        const inner = response?.result?.result || response?.result;
+        if (inner) {
+            if (inner.action) {
+                this.deviceStatus = inner.action === 'on' ? 'on' : 'off';
             }
-        };
+            if (inner.brightness !== undefined) {
+                this.brightness = Number(inner.brightness);
+            }
+            this.rgbValues = {
+                red: Number(inner.red ?? this.rgbValues.red),
+                green: Number(inner.green ?? this.rgbValues.green),
+                blue: Number(inner.blue ?? this.rgbValues.blue)
+            };
+            this.colorMode = inner.colorMode || this.colorMode;
+        }
+
+        return true;
+    }
+
+    async turnOn(): Promise<boolean> {
+        const body = this.buildBypassV2Payload('setSwitch', {
+            id: 0,
+            enabled: true
+        });
 
         const [response] = await this.callApi(
-            '/cloud/v1/deviceManaged/bypass',
+            '/cloud/v2/deviceManaged/bypassV2',
             'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
-        if (response?.code === 0) {
-            this.rgbValues = { red, green, blue };
-            logger.info(`[${this.deviceName}] Successfully set RGB color`);
+        if (this.handleBypassV2Response(response, 'turn on')) {
+            this.deviceStatus = 'on';
+            this.connectionStatus = 'online';
             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, 'bypass'),
-            cid: this.cid,
-            configModule: this.configModule,
-            jsonCmd: {
-                light: {
-                    mode: 'white'
-                }
-            }
-        };
+    async turnOff(): Promise<boolean> {
+        const body = this.buildBypassV2Payload('setSwitch', {
+            id: 0,
+            enabled: false
+        });
 
         const [response] = await this.callApi(
-            '/cloud/v1/deviceManaged/bypass',
+            '/cloud/v2/deviceManaged/bypassV2',
             'post',
             body,
             Helpers.reqHeaders(this.manager)
         );
 
-        if (response?.code === 0) {
+        if (this.handleBypassV2Response(response, 'turn off')) {
+            this.deviceStatus = 'off';
+            return true;
+        }
+        return false;
+    }
+
+    async setBrightness(brightness: number): Promise<boolean> {
+        const brightnessUpdate = VeSyncBulb.clamp(Math.round(brightness), 0, 100);
+        const body = this.buildBypassV2Payload('setLightStatus', {
+            action: 'on',
+            speed: 0,
+            brightness: brightnessUpdate,
+            red: 0,
+            green: 0,
+            blue: 0,
+            colorMode: 'white'
+        });
+
+        const [response] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (this.handleBypassV2Response(response, 'set brightness')) {
+            this.brightness = brightnessUpdate;
+            this.deviceStatus = 'on';
             this.colorMode = 'white';
-            logger.info(`[${this.deviceName}] Successfully enabled white mode`);
+            this.connectionStatus = 'online';
             return true;
         }
-        logger.error(`[${this.deviceName}] Failed to enable white mode: ${JSON.stringify(response)}`);
+        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;
+        }
+
+        const body = this.buildBypassV2Payload('setLightStatus', {
+            action: 'on',
+            speed: 0,
+            brightness: 100,
+            red: VeSyncBulb.clamp(Math.round(red), 0, 255),
+            green: VeSyncBulb.clamp(Math.round(green), 0, 255),
+            blue: VeSyncBulb.clamp(Math.round(blue), 0, 255),
+            colorMode: 'color'
+        });
+
+        const [response] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            Helpers.reqHeaders(this.manager)
+        );
+
+        if (this.handleBypassV2Response(response, 'set RGB color')) {
+            this.rgbValues = {
+                red: VeSyncBulb.clamp(Math.round(red), 0, 255),
+                green: VeSyncBulb.clamp(Math.round(green), 0, 255),
+                blue: VeSyncBulb.clamp(Math.round(blue), 0, 255)
+            };
+            this.brightness = 100;
+            this.deviceStatus = 'on';
+            this.colorMode = 'color';
+            this.connectionStatus = 'online';
+            return true;
+        }
+        return false;
+    }
+
+    async enableWhiteMode(): Promise<boolean> {
+        const targetBrightness = this.brightness > 0 ? this.brightness : 100;
+        const success = await this.setBrightness(targetBrightness);
+        if (success) {
+            this.colorMode = 'white';
+        }
+        return success;
+    }
+
+    async setColorTemp(colorTemp: number): Promise<boolean> {
+        logger.error(`[${this.deviceName}] Color temperature control not supported`);
         return false;
     }
 }
@@ -281,4 +633,4 @@ export const bulbModules: Record<string, new (details: Record<string, any>, mana
     'ESL100CW': VeSyncBulbESL100CW,
     'XYD0001': VeSyncBulbXYD0001,
     'ESL100MC': VeSyncBulbESL100MC
-}; 
+};