tsvesync 1.0.43 → 1.0.45

package/dist/lib/vesyncFanImpl.js

@@ -19,6 +19,23 @@ class VeSyncAirBypass extends vesyncFan_1.VeSyncFan {
         this.childLockModes = ['on', 'off'];
         logger_1.logger.debug(`Initialized VeSyncAirBypass device: ${this.deviceName}`);
     }
+    /**
+     * Build API dictionary
+     */
+    buildApiDict(method) {
+        const head = helpers_1.Helpers.reqHeaderBypass();
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data: {}
+            }
+        };
+        return [head, body];
+    }
     /**
      * Get device details
      */
@@ -1035,8 +1052,37 @@ class VeSyncAirBaseV2 extends VeSyncAirBypass {
         super(details, manager);
         this._lightDetection = false;
         this._lightDetectionState = false;
+        this.setSpeedLevel = null;
+        this.autoPreferences = ['default', 'efficient', 'quiet'];
+        this.enabled = false;
+        this._mode = '';
+        this._speed = 0;
+        this._timer = null;
         logger_1.logger.debug(`Initialized VeSyncAirBaseV2 device: ${this.deviceName}`);
     }
+    buildConfigDict(configDict) {
+        if (configDict) {
+            this.config = configDict;
+        }
+    }
+    get mode() {
+        return this._mode;
+    }
+    set mode(value) {
+        this._mode = value;
+    }
+    get speed() {
+        return this._speed;
+    }
+    set speed(value) {
+        this._speed = value;
+    }
+    get timer() {
+        return this._timer;
+    }
+    set timer(value) {
+        this._timer = value;
+    }
     /**
      * Build API dictionary
      */
@@ -1044,7 +1090,7 @@ class VeSyncAirBaseV2 extends VeSyncAirBypass {
         const head = helpers_1.Helpers.reqHeaderBypass();
         const body = {
             ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
-            deviceId: this.cid,
+            cid: this.cid,
             configModule: this.configModule,
             payload: {
                 method,
@@ -1054,74 +1100,355 @@ class VeSyncAirBaseV2 extends VeSyncAirBypass {
         };
         return [head, body];
     }
-    get lightDetection() {
-        return this._lightDetection;
-    }
-    set lightDetection(toggle) {
-        this._lightDetection = toggle;
+    /**
+     * Get device details
+     */
+    async getDetails() {
+        logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getPurifierStatus');
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        if (!this.checkResponse([response, status], 'getDetails') || !(response === null || response === void 0 ? void 0 : response.result)) {
+            logger_1.logger.debug('Error getting purifier details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger_1.logger.debug('Error in inner response from purifier');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        const deviceData = innerResponse.result;
+        this.buildPurifierDict(deviceData);
+        if (deviceData.configuration) {
+            this.buildConfigDict(deviceData.configuration);
+        }
+        return true;
     }
-    get lightDetectionState() {
-        return this._lightDetectionState;
+    /**
+     * Build purifier dictionary
+     */
+    buildPurifierDict(devDict) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        this.connectionStatus = 'online';
+        const powerSwitch = Boolean((_a = devDict.powerSwitch) !== null && _a !== void 0 ? _a : 0);
+        this.enabled = powerSwitch;
+        this.deviceStatus = powerSwitch ? 'on' : 'off';
+        this.mode = (_b = devDict.workMode) !== null && _b !== void 0 ? _b : 'manual';
+        this.speed = (_c = devDict.fanSpeedLevel) !== null && _c !== void 0 ? _c : 0;
+        this.setSpeedLevel = (_d = devDict.manualSpeedLevel) !== null && _d !== void 0 ? _d : 1;
+        this.details = {
+            ...this.details,
+            filter_life: (_e = devDict.filterLifePercent) !== null && _e !== void 0 ? _e : 0,
+            child_lock: Boolean((_f = devDict.childLockSwitch) !== null && _f !== void 0 ? _f : 0),
+            display: Boolean((_g = devDict.screenState) !== null && _g !== void 0 ? _g : 0),
+            light_detection_switch: Boolean((_h = devDict.lightDetectionSwitch) !== null && _h !== void 0 ? _h : 0),
+            environment_light_state: Boolean((_j = devDict.environmentLightState) !== null && _j !== void 0 ? _j : 0),
+            screen_switch: Boolean((_k = devDict.screenSwitch) !== null && _k !== void 0 ? _k : 0)
+        };
+        if (this.hasFeature('air_quality')) {
+            this.details.air_quality_value = (_l = devDict.PM25) !== null && _l !== void 0 ? _l : 0;
+            this.details.air_quality = (_m = devDict.AQLevel) !== null && _m !== void 0 ? _m : 0;
+        }
+        if ('PM1' in devDict)
+            this.details.pm1 = devDict.PM1;
+        if ('PM10' in devDict)
+            this.details.pm10 = devDict.PM10;
+        if ('AQPercent' in devDict)
+            this.details.aq_percent = devDict.AQPercent;
+        if ('fanRotateAngle' in devDict)
+            this.details.fan_rotate_angle = devDict.fanRotateAngle;
+        if ('filterOpenState' in devDict)
+            this.details.filter_open_state = Boolean(devDict.filterOpenState);
+        if (((_o = devDict.timerRemain) !== null && _o !== void 0 ? _o : 0) > 0) {
+            this.timer = { duration: devDict.timerRemain, action: 'off' };
+        }
+        if (typeof devDict.autoPreference === 'object' && devDict.autoPreference) {
+            this.details.auto_preference_type = (_q = (_p = devDict.autoPreference) === null || _p === void 0 ? void 0 : _p.autoPreferenceType) !== null && _q !== void 0 ? _q : 'default';
+        }
+        else {
+            this.details.auto_preference_type = null;
+        }
     }
-    async setLightDetection(toggle) {
-        const [head, body] = this.buildApiDict('setLightDetection');
-        if (!head || !body) {
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle) {
+        if (typeof toggle !== 'boolean') {
+            logger_1.logger.debug('Invalid toggle value for purifier switch');
             return false;
         }
-        body.payload.data = { enabled: toggle };
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            powerSwitch: toggle ? 1 : 0,
+            switchIdx: 0
+        };
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
-        const success = this.checkResponse([response, status], 'setLightDetection');
+        const success = this.checkResponse([response, status], 'toggleSwitch');
         if (success) {
-            this._lightDetection = toggle;
+            this.deviceStatus = toggle ? 'on' : 'off';
         }
         return success;
     }
-    async setLightDetectionOn() {
-        return this.setLightDetection(true);
-    }
-    async setLightDetectionOff() {
-        return this.setLightDetection(false);
-    }
-    async turboMode() {
-        return this.mode_toggle('turbo');
+    /**
+     * Turn device on - compatibility method that proxies to toggleSwitch
+     */
+    async turnOn() {
+        logger_1.logger.info(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
     }
-    async petMode() {
-        return this.mode_toggle('pet');
+    /**
+     * Turn device off - compatibility method that proxies to toggleSwitch
+     */
+    async turnOff() {
+        logger_1.logger.info(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
     }
     /**
-     * Build configuration dictionary
+     * Change fan speed
      */
-    buildConfigDict(configDict) {
-        if (configDict) {
-            this.config = configDict;
+    async changeFanSpeed(speed) {
+        var _a, _b, _c;
+        const speeds = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.levels) !== null && _b !== void 0 ? _b : [];
+        const currentSpeed = (_c = this.setSpeedLevel) !== null && _c !== void 0 ? _c : 0;
+        if (speed !== undefined) {
+            if (!speeds.includes(speed)) {
+                logger_1.logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+                return false;
+            }
+        }
+        else {
+            if (currentSpeed === speeds[speeds.length - 1] || currentSpeed === 0) {
+                speed = speeds[0];
+            }
+            else {
+                const currentIndex = speeds.indexOf(currentSpeed);
+                speed = speeds[currentIndex + 1];
+            }
+        }
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            manualSpeedLevel: speed,
+            levelType: 'wind'
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.setSpeedLevel = speed;
+            this.mode = 'manual';
         }
+        return success;
     }
     /**
      * Set mode
      */
-    async mode_toggle(mode) {
-        const validModes = this.modes.map(m => m.toLowerCase());
-        if (!validModes.includes(mode.toLowerCase())) {
-            logger_1.logger.debug(`Invalid mode used - ${mode}`);
+    async setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            logger_1.logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`);
             return false;
         }
+        if (mode === 'manual') {
+            if (!this.speed || this.speed === 0) {
+                return this.changeFanSpeed(1);
+            }
+            return this.changeFanSpeed(this.speed);
+        }
+        if (mode === 'off') {
+            return this.turnOff();
+        }
         const [head, body] = this.buildApiDict('setPurifierMode');
-        if (!head || !body) {
+        body.payload.data = {
+            workMode: mode
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.mode = mode;
+        }
+        return success;
+    }
+    /**
+     * Set display status
+     */
+    async setDisplay(enabled) {
+        if (!this.hasFeature('display')) {
+            const error = 'Display control not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        const [head, body] = this.buildApiDict('setDisplay');
+        body.payload.data = {
+            screenSwitch: enabled ? 1 : 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setDisplay');
+        if (success) {
+            this.details.screen_switch = enabled;
+        }
+        return success;
+    }
+    /**
+     * Set child lock
+     */
+    async setChildLock(enabled) {
+        if (!this.hasFeature('child_lock')) {
+            const error = 'Child lock not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        const [head, body] = this.buildApiDict('setChildLock');
+        body.payload.data = {
+            childLockSwitch: enabled ? 1 : 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setChildLock');
+        if (success) {
+            this.details.child_lock = enabled;
+        }
+        return success;
+    }
+    /**
+     * Set timer
+     */
+    async setTimer(timerDuration, action = 'off', method = 'powerSwitch') {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        if (!['on', 'off'].includes(action)) {
+            logger_1.logger.debug('Invalid action for timer');
+            return false;
+        }
+        if (method !== 'powerSwitch') {
+            logger_1.logger.debug('Invalid method for timer');
             return false;
         }
+        const [head, body] = this.buildApiDict('addTimerV2');
+        body.payload.subDeviceNo = 0;
         body.payload.data = {
-            mode: mode
+            startAct: [{
+                    type: method,
+                    num: 0,
+                    act: action === 'on' ? 1 : 0
+                }],
+            total: timerDuration,
+            subDeviceNo: 0
         };
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
-        const success = this.checkResponse([response, status], 'mode_toggle');
+        const success = this.checkResponse([response, status], 'setTimer');
         if (success) {
-            this.details.mode = mode;
+            this.timer = { duration: timerDuration, action };
         }
-        else {
-            logger_1.logger.debug('Error setting mode');
+        return success;
+    }
+    /**
+     * Clear timer
+     */
+    async clearTimer() {
+        if (!this.hasFeature('timer')) {
+            const error = 'Timer not supported';
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        const [head, body] = this.buildApiDict('delTimerV2');
+        body.payload.subDeviceNo = 0;
+        body.payload.data = { id: 1, subDeviceNo: 0 };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'clearTimer');
+        if (success) {
+            this.timer = null;
+        }
+        return success;
+    }
+    /**
+     * Set auto preference
+     */
+    async setAutoPreference(preference = 'default', roomSize = 600) {
+        if (!this.autoPreferences.includes(preference)) {
+            logger_1.logger.debug(`Invalid preference: ${preference} - valid preferences are default, efficient, quiet`);
+            return false;
+        }
+        const [head, body] = this.buildApiDict('setAutoPreference');
+        body.payload.data = {
+            autoPreference: preference,
+            roomSize: roomSize
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setAutoPreference');
+        if (success) {
+            this.details.auto_preference = preference;
         }
         return success;
     }
+    /**
+     * Set light detection
+     */
+    async setLightDetection(enabled) {
+        const [head, body] = this.buildApiDict('setLightDetection');
+        body.payload.data = {
+            lightDetectionSwitch: enabled ? 1 : 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setLightDetection');
+        if (success) {
+            this.details.light_detection_switch = enabled;
+        }
+        return success;
+    }
+    /**
+     * Get light detection status
+     */
+    get lightDetection() {
+        return Boolean(this.details.light_detection_switch);
+    }
+    /**
+     * Get light detection state
+     */
+    get lightDetectionState() {
+        return Boolean(this.details.environment_light_state);
+    }
+    /**
+     * Get auto preference type
+     */
+    get autoPreferenceType() {
+        return this.details.auto_preference_type;
+    }
+    /**
+     * Display JSON details
+     */
+    displayJSON() {
+        var _a, _b;
+        const baseInfo = JSON.parse(super.displayJSON());
+        const details = {
+            ...baseInfo,
+            'Mode': this.mode,
+            'Filter Life': this.details.filter_life.toString(),
+            'Fan Level': this.speed.toString(),
+            'Display On': this.details.display.toString(),
+            'Child Lock': this.details.child_lock.toString(),
+            'Display Set On': this.details.screen_switch.toString(),
+            'Light Detection Enabled': this.details.light_detection_switch.toString(),
+            'Environment Light State': this.details.environment_light_state.toString()
+        };
+        if (this.hasFeature('air_quality')) {
+            details['Air Quality Level'] = ((_a = this.details.air_quality) !== null && _a !== void 0 ? _a : '').toString();
+            details['Air Quality Value'] = ((_b = this.details.air_quality_value) !== null && _b !== void 0 ? _b : '').toString();
+        }
+        const everestKeys = {
+            'pm1': 'PM1',
+            'pm10': 'PM10',
+            'fan_rotate_angle': 'Fan Rotate Angle',
+            'filter_open_state': 'Filter Open State'
+        };
+        for (const [key, value] of Object.entries(everestKeys)) {
+            if (key in this.details) {
+                details[value] = this.details[key].toString();
+            }
+        }
+        return JSON.stringify(details, null, 4);
+    }
 }
 exports.VeSyncAirBaseV2 = VeSyncAirBaseV2;
 /**
@@ -1134,20 +1461,35 @@ class VeSyncTowerFan extends VeSyncAirBaseV2 {
         this.speeds = Array.from({ length: 12 }, (_, i) => i + 1);
         logger_1.logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
     }
+    /**
+     * Get timer status (in seconds)
+     */
+    get timer() {
+        const timerRemain = this.details.timerRemain || 0;
+        return timerRemain > 0 ? { duration: timerRemain, action: 'off' } : null;
+    }
+    set timer(value) {
+        if (value) {
+            this.details.timerRemain = value.duration;
+        }
+        else {
+            this.details.timerRemain = 0;
+        }
+    }
     /**
      * Build API dictionary
      */
     buildApiDict(method) {
         const head = helpers_1.Helpers.reqHeaderBypass();
-        const body = helpers_1.Helpers.reqBody(this.manager, 'bypassV2');
-        body.cid = this.cid;
-        body.deviceId = this.cid;
-        body.configModule = this.configModule;
-        body.configModel = this.configModule;
-        body.payload = {
-            method: method,
-            source: 'APP',
-            data: {}
+        const body = {
+            ...helpers_1.Helpers.reqBody(this.manager, 'bypassV2'),
+            cid: this.cid,
+            configModule: this.configModule,
+            payload: {
+                method,
+                source: 'APP',
+                data: {}
+            }
         };
         return [head, body];
     }
@@ -1340,12 +1682,6 @@ class VeSyncTowerFan extends VeSyncAirBaseV2 {
     get muteState() {
         return Boolean(this.details.muteState);
     }
-    /**
-     * Get timer status (in seconds)
-     */
-    get timer() {
-        return this.details.timerRemain || 0;
-    }
     /**
      * Get temperature (in tenths of a degree)
      */
@@ -1455,22 +1791,25 @@ exports.fanModules = {
     'LAP-C601S-WUS': VeSyncAirBypass,
     'LAP-C601S-WUSR': VeSyncAirBypass,
     'LAP-C601S-WEU': VeSyncAirBypass,
-    'LAP-V102S-AASR': VeSyncAirBypass,
-    'LAP-V102S-WUS': VeSyncAirBypass,
-    'LAP-V102S-WEU': VeSyncAirBypass,
-    'LAP-V102S-AUSR': VeSyncAirBypass,
-    'LAP-V102S-WJP': VeSyncAirBypass,
-    'LAP-V201S-AASR': VeSyncAirBypass,
-    'LAP-V201S-WJP': VeSyncAirBypass,
-    'LAP-V201S-WEU': VeSyncAirBypass,
-    'LAP-V201S-WUS': VeSyncAirBypass,
-    'LAP-V201-AUSR': VeSyncAirBypass,
-    'LAP-V201S-AUSR': VeSyncAirBypass,
-    'LAP-V201S-AEUR': VeSyncAirBypass,
-    'LAP-EL551S-AUS': VeSyncAirBypass,
-    'LAP-EL551S-AEUR': VeSyncAirBypass,
-    'LAP-EL551S-WEU': VeSyncAirBypass,
-    'LAP-EL551S-WUS': VeSyncAirBypass,
+    // Vital100S Series - Using VeSyncAirBaseV2
+    'LAP-V102S-AASR': VeSyncAirBaseV2,
+    'LAP-V102S-WUS': VeSyncAirBaseV2,
+    'LAP-V102S-WEU': VeSyncAirBaseV2,
+    'LAP-V102S-AUSR': VeSyncAirBaseV2,
+    'LAP-V102S-WJP': VeSyncAirBaseV2,
+    // Vital200S Series - Using VeSyncAirBaseV2
+    'LAP-V201S-AASR': VeSyncAirBaseV2,
+    'LAP-V201S-WJP': VeSyncAirBaseV2,
+    'LAP-V201S-WEU': VeSyncAirBaseV2,
+    'LAP-V201S-WUS': VeSyncAirBaseV2,
+    'LAP-V201-AUSR': VeSyncAirBaseV2,
+    'LAP-V201S-AUSR': VeSyncAirBaseV2,
+    'LAP-V201S-AEUR': VeSyncAirBaseV2,
+    // EverestAir Series - Using VeSyncAirBaseV2
+    'LAP-EL551S-AUS': VeSyncAirBaseV2,
+    'LAP-EL551S-AEUR': VeSyncAirBaseV2,
+    'LAP-EL551S-WEU': VeSyncAirBaseV2,
+    'LAP-EL551S-WUS': VeSyncAirBaseV2,
     // LTF Series
     'LTF-F422S-KEU': VeSyncTowerFan,
     'LTF-F422S-WUSR': VeSyncTowerFan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/vesync.ts

@@ -419,10 +419,25 @@ export class VeSync {
                 this
             );
 
-            if (response?.result?.list) {
-                const deviceList = response.result.list;
-                success = this.processDevices(deviceList);
+            if (!response) {
+                logger.error('No response received from VeSync API');
+                return false;
+            }
+
+            if (response.error) {
+                logger.error('API error:', response.msg || 'Unknown error');
+                return false;
+            }
 
+            if (!response.result?.list) {
+                logger.error('No device list found in response');
+                return false;
+            }
+
+            const deviceList = response.result.list;
+            success = this.processDevices(deviceList);
+
+            if (success) {
                 // Log device discovery results
                 logger.debug('\n=== Device Discovery Summary ===');
                 logger.debug(`Total devices processed: ${deviceList.length}`);
@@ -455,12 +470,16 @@ export class VeSync {
                 }
 
                 logger.debug('\n=== End of Device Discovery ===\n');
+            }
+        } catch (err) {
+            const error = err as { code?: string; message?: string };
+            if (error.code === 'ECONNABORTED') {
+                logger.error('VeSync API request timed out');
+            } else if (error.code === 'ECONNREFUSED') {
+                logger.error('Unable to connect to VeSync API');
             } else {
-                logger.error('No devices found in response');
-                logger.error(response.code, response.msg);
+                logger.error('Error getting device list:', error.message || 'Unknown error');
             }
-        } catch (error) {
-            logger.error('Unable to get device list:', error);
         }
 
         this._inProcess = false;