tsvesync 1.0.63 → 1.0.65

package/src/lib/fans/index.ts

@@ -0,0 +1,101 @@
+import { VeSyncAirBypass } from './airBypass';
+import { VeSyncAirBaseV2 } from './airBaseV2';
+import { VeSyncTowerFan } from './towerFan';
+import { VeSyncHumidifier } from './humidifier';
+import { VeSyncWarmHumidifier } from './warmHumidifier';
+import { VeSyncHumid200300S } from './humid200300S';
+import { VeSyncFan } from '../vesyncFan';
+import { VeSync } from '../vesync';
+
+// Re-export all classes
+export { VeSyncAirBypass } from './airBypass';
+export { VeSyncAirBaseV2 } from './airBaseV2';
+export { VeSyncTowerFan } from './towerFan';
+export { VeSyncHumidifier } from './humidifier';
+export { VeSyncWarmHumidifier } from './warmHumidifier';
+export { VeSyncHumid200300S } from './humid200300S';
+
+// Export fan modules dictionary
+export const fanModules: Record<string, new (details: Record<string, any>, manager: VeSync) => VeSyncFan> = {
+    // Core Series
+    'Core200S': VeSyncAirBypass,
+    'Core300S': VeSyncAirBypass,
+    'Core400S': VeSyncAirBypass,
+    'Core600S': VeSyncAirBypass,
+    
+    // LAP Series
+    'LAP-C201S-AUSR': VeSyncAirBypass,
+    'LAP-C202S-WUSR': VeSyncAirBypass,
+    'LAP-C301S-WJP': VeSyncAirBypass,
+    'LAP-C302S-WUSB': VeSyncAirBypass,
+    'LAP-C301S-WAAA': VeSyncAirBypass,
+    'LAP-C401S-WJP': VeSyncAirBypass,
+    'LAP-C401S-WUSR': VeSyncAirBypass,
+    'LAP-C401S-WAAA': VeSyncAirBypass,
+    'LAP-C601S-WUS': VeSyncAirBypass,
+    'LAP-C601S-WUSR': VeSyncAirBypass,
+    'LAP-C601S-WEU': 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,
+    'LTF-F422_WJP': VeSyncTowerFan,
+    'LTF-F422S-WUS': VeSyncTowerFan,
+    
+    // Classic Series
+    'Classic300S': VeSyncHumidifier,
+    'Classic200S': VeSyncHumidifier,
+    
+    // Dual Series
+    'Dual200S': VeSyncHumidifier,
+    
+    // LUH Series
+    'LUH-A601S-WUSB': VeSyncHumid200300S,
+    'LUH-A601S-AUSW': VeSyncHumid200300S,
+    'LUH-D301S-WUSR': VeSyncHumid200300S,
+    'LUH-D301S-WJP': VeSyncHumid200300S,
+    'LUH-D301S-WEU': VeSyncHumid200300S,
+    'LUH-A602S-WUSR': VeSyncHumid200300S,
+    'LUH-A602S-WUS': VeSyncHumid200300S,
+    'LUH-A602S-WEUR': VeSyncHumid200300S,
+    'LUH-A602S-WEU': VeSyncHumid200300S,
+    'LUH-A602S-WJP': VeSyncHumid200300S,
+    'LUH-A602S-WUSC': VeSyncHumid200300S,
+    'LUH-O451S-WEU': VeSyncHumid200300S,
+    'LUH-O451S-WUS': VeSyncHumid200300S,
+    'LUH-O451S-WUSR': VeSyncHumid200300S,
+    'LUH-O601S-WUS': VeSyncHumid200300S,
+    'LUH-O601S-KUS': VeSyncHumid200300S,
+    'LUH-M101S-WUS': VeSyncHumid200300S,
+    'LUH-M101S-WEUR': VeSyncHumid200300S,
+    
+    // LEH Series
+    'LEH-S601S-WUS': VeSyncHumid200300S,
+    'LEH-S601S-WUSR': VeSyncHumid200300S,
+    
+    // LV Series
+    'LV-PUR131S': VeSyncAirBypass,
+    'LV-RH131S': VeSyncAirBypass
+};

package/src/lib/fans/towerFan.ts

@@ -0,0 +1,335 @@
+import { VeSyncAirBaseV2 } from './airBaseV2';
+import { VeSync } from '../vesync';
+import { logger } from '../logger';
+
+/**
+ * VeSync Tower Fan Implementation
+ */
+export class VeSyncTowerFan extends VeSyncAirBaseV2 {
+    protected readonly towerModes = ['normal', 'advancedSleep', 'off'] as const;
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
+    }
+
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        logger.debug(`Getting details for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('getTowerFanStatus');
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        if (!this.checkResponse([response, status], 'getDetails') || !response?.result) {
+            logger.debug('Error getting tower fan details');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const innerResponse = response.result;
+        if (innerResponse.code !== 0 || !innerResponse.result) {
+            logger.debug('Error in inner response from tower fan');
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        const deviceData = innerResponse.result;
+        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
+        this.details = {
+            powerSwitch: deviceData.powerSwitch,
+            workMode: deviceData.workMode,
+            manualSpeedLevel: deviceData.manualSpeedLevel,
+            fanSpeedLevel: deviceData.fanSpeedLevel,
+            screenState: deviceData.screenState,
+            screenSwitch: deviceData.screenSwitch,
+            oscillationState: deviceData.oscillationState,
+            oscillationSwitch: deviceData.oscillationSwitch,
+            timerRemain: deviceData.timerRemain,
+            temperature: deviceData.temperature || 0,
+            humidity: deviceData.humidity || 0,
+            thermalComfort: deviceData.thermalComfort,
+            sleepPreference: deviceData.sleepPreference || {},
+            scheduleCount: deviceData.scheduleCount,
+            displayingType: deviceData.displayingType,
+            errorCode: deviceData.errorCode
+        };
+
+        logger.debug(`Successfully got details for device: ${this.deviceName}`);
+        return true;
+    }
+
+    /**
+     * Toggle device power
+     */
+    async toggleSwitch(toggle: boolean): Promise<boolean> {
+        if (typeof toggle !== 'boolean') {
+            logger.debug('Invalid toggle value for tower fan switch');
+            return false;
+        }
+
+        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], 'toggleSwitch');
+        if (success) {
+            this.deviceStatus = toggle ? 'on' : 'off';
+        } else {
+            logger.debug('Error toggling tower fan power');
+        }
+        return success;
+    }
+
+    /**
+     * Turn device on
+     */
+    async turnOn(): Promise<boolean> {
+        logger.debug(`Turning on device: ${this.deviceName}`);
+        return this.toggleSwitch(true);
+    }
+
+    /**
+     * Turn device off
+     */
+    async turnOff(): Promise<boolean> {
+        logger.debug(`Turning off device: ${this.deviceName}`);
+        return this.toggleSwitch(false);
+    }
+
+    /**
+     * Set tower fan mode
+     */
+    async mode_toggle(mode: string): Promise<boolean> {
+        if (!this.towerModes.includes(mode as any)) {
+            logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.towerModes.join(', ')}`);
+            return false;
+        }
+
+        if (mode === 'off') {
+            return this.turnOff();
+        }
+
+        const [head, body] = this.buildApiDict('setTowerFanMode');
+        body.deviceId = this.cid;
+        body.payload.data = {
+            workMode: mode
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'mode_toggle');
+        if (success) {
+            this.details.workMode = mode;
+        } else {
+            logger.error(`Failed to set ${mode} mode for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Change fan speed
+     */
+    async changeFanSpeed(speed: number): Promise<boolean> {
+        // const speeds = this.config.levels ?? [];
+        // if (!speeds.includes(speed)) {
+        //     logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+        //     return false;
+        // }
+
+        const [head, body] = this.buildApiDict('setLevel');
+        body.payload.data = {
+            levelIdx: 0,
+            levelType: 'wind',
+            manualSpeedLevel: speed
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'changeFanSpeed');
+        if (success) {
+            this.details.manualSpeedLevel = speed;
+        } else {
+            logger.debug('Error setting fan speed');
+        }
+        return success;
+    }
+
+    /**
+     * Set normal mode
+     */
+    async normal_mode(): Promise<boolean> {
+        logger.debug(`Setting normal mode for device: ${this.deviceName}`);
+        return this.mode_toggle('normal');
+    }
+
+    /**
+     * Set manual mode - adapter to set mode to normal
+     */
+    async manual_mode(): Promise<boolean> {
+        logger.debug(`Setting manual mode for device: ${this.deviceName}`);
+        return this.normal_mode();
+    }
+
+    /**
+     * Set advanced sleep mode
+     */
+    async advanced_sleep_mode(): Promise<boolean> {
+        logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
+        return this.mode_toggle('advancedSleep');
+    }
+
+    /**
+     * Set sleep mode - adapter for advanced sleep mode
+     */
+    async sleep_mode(): Promise<boolean> {
+        logger.debug(`Setting sleep mode for device: ${this.deviceName}`);
+        return this.advanced_sleep_mode();
+    }
+
+    /**
+     * Override setMode to handle tower fan specific modes
+     */
+    async setMode(mode: string): Promise<boolean> {
+        return this.mode_toggle(mode);
+    }
+
+    /**
+     * Get current speed
+     */
+    get speed(): number {
+        return this.details.manualSpeedLevel || 0;
+    }
+
+    /**
+     * Get display status
+     */
+    get displayState(): boolean {
+        return Boolean(this.details.screenState);
+    }
+
+    /**
+     * Get oscillation status
+     */
+    get oscillationState(): boolean {
+        return Boolean(this.details.oscillationState);
+    }
+
+    /**
+     * Get mute status
+     */
+    get muteState(): boolean {
+        return Boolean(this.details.muteState);
+    }
+
+    /**
+     * Get temperature (in tenths of a degree)
+     */
+    get temperature(): number {
+        return this.details.temperature || 0;
+    }
+
+    /**
+     * Get humidity percentage
+     */
+    get humidity(): number {
+        return this.details.humidity || 0;
+    }
+
+    /**
+     * Get thermal comfort level
+     */
+    get thermalComfort(): number {
+        return this.details.thermalComfort || 0;
+    }
+
+    /**
+     * Get sleep preferences
+     */
+    get sleepPreference(): Record<string, any> {
+        return this.details.sleepPreference || {};
+    }
+
+    /**
+     * Get schedule count
+     */
+    get scheduleCount(): number {
+        return this.details.scheduleCount || 0;
+    }
+
+    /**
+     * Get error code
+     */
+    get errorCode(): number {
+        return this.details.errorCode || 0;
+    }
+
+    /**
+     * Turn oscillation on
+     */
+    async setOscillationOn(): Promise<boolean> {
+        return this.setOscillation(true);
+    }
+
+    /**
+     * Turn oscillation off
+     */
+    async setOscillationOff(): Promise<boolean> {
+        return this.setOscillation(false);
+    }
+
+    /**
+     * Display device info
+     */
+    override display(): void {
+        super.display();
+        const info = [
+            ['Mode: ', this.details.workMode || ''],
+            ['Speed: ', this.speed],
+            ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
+            ['Display: ', this.displayState],
+            ['Display Switch: ', this.details.screenSwitch],
+            ['Oscillation: ', this.oscillationState],
+            ['Oscillation Switch: ', this.details.oscillationSwitch],
+            ['Mute: ', this.muteState],
+            ['Mute Switch: ', this.details.muteSwitch],
+            ['Timer: ', this.timer],
+            ['Temperature: ', this.temperature / 10, '°C'],
+            ['Humidity: ', this.humidity, '%'],
+            ['Thermal Comfort: ', this.thermalComfort],
+            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
+            ['Schedule Count: ', this.scheduleCount],
+            ['Displaying Type: ', this.details.displayingType],
+            ['Error Code: ', this.errorCode]
+        ];
+
+        for (const [key, value, unit = ''] of info) {
+            logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
+        }
+    }
+}

package/src/lib/fans/warmHumidifier.ts

@@ -0,0 +1,202 @@
+import { VeSyncHumidifier } from './humidifier';
+import { VeSync } from '../vesync';
+import { Helpers } from '../helpers';
+import { logger } from '../logger';
+
+/**
+ * VeSync Warm Humidifier Class
+ */
+export class VeSyncWarmHumidifier extends VeSyncHumidifier {
+    protected readonly warmLevels = [1, 2, 3];
+
+    constructor(details: Record<string, any>, manager: VeSync) {
+        super(details, manager);
+        logger.debug(`Initialized VeSyncWarmHumidifier device: ${this.deviceName}`);
+    }
+
+    /**
+     * Get device details
+     */
+    async getDetails(): Promise<Boolean> {
+        const success = await super.getDetails();
+        if (success && this.details) {
+            // Add warm humidifier specific fields
+            this.details = {
+                ...this.details,
+                warm_enabled: Boolean(this.details.warm_level && this.details.warm_level > 0),
+                drying_mode_enabled: this.details.autoDryingSwitch === 1,
+                drying_mode_state: this.details.dryingMode || '',
+                drying_mode_level: this.details.dryingLevel || 0,
+                drying_mode_seconds_remaining: this.details.dryingRemainTime || 0
+            };
+        }
+        return success;
+    }
+
+    /**
+     * Change fan speed - Implemented to satisfy interface but redirects to setMistLevel
+     */
+    async changeFanSpeed(speed: number): Promise<boolean> {
+        logger.debug(`Redirecting fan speed change to mist level for device: ${this.deviceName}`);
+        return this.setMistLevel(speed);
+    }
+
+    /**
+     * Set device mode
+     */
+    async setMode(mode: string): Promise<boolean> {
+        if (!this.modes.includes(mode as any)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        logger.debug(`Setting mode to ${mode} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {
+                        mode
+                    },
+                    method: 'setHumidityMode',
+                    source: 'APP'
+                }
+            },
+            Helpers.reqHeaderBypass()
+        );
+
+        const success = this.checkResponse([response, status], 'setMode');
+        if (success) {
+            this.details.mode = mode;
+        } else {
+            logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Set warm mist level
+     */
+    async setWarmLevel(level: number): Promise<boolean> {
+        if (!this.hasFeature('warm')) {
+            const error = 'Warm mist control not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        if (!this.warmLevels.includes(level)) {
+            const error = `Invalid warm level: ${level}. Must be one of: ${this.warmLevels.join(', ')}`;
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        logger.debug(`Setting warm level to ${level} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {
+                        id: 0,
+                        level: level,
+                        type: 'warm'
+                    },
+                    method: 'setLevel',
+                    source: 'APP'
+                }
+            },
+            Helpers.reqHeaderBypass()
+        );
+
+        const success = this.checkResponse([response, status], 'setWarmLevel');
+        if (success) {
+            this.details.warm_level = level;
+            this.details.warm_enabled = level > 0;
+        } else {
+            logger.error(`Failed to set warm level to ${level} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Set drying mode enabled
+     */
+    async setDryingModeEnabled(enabled: boolean): Promise<boolean> {
+        if (!this.hasFeature('drying')) {
+            const error = 'Drying mode not supported';
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        logger.debug(`Setting drying mode to ${enabled} for device: ${this.deviceName}`);
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            {
+                ...Helpers.reqBody(this.manager, 'bypassV2'),
+                cid: this.cid,
+                configModule: this.configModule,
+                payload: {
+                    data: {
+                        autoDryingSwitch: enabled ? 1 : 0
+                    },
+                    method: 'setDryingMode',
+                    source: 'APP'
+                }
+            },
+            Helpers.reqHeaderBypass()
+        );
+
+        const success = this.checkResponse([response, status], 'setDryingModeEnabled');
+        if (success) {
+            this.details.drying_mode_enabled = enabled;
+            this.details.autoDryingSwitch = enabled ? 1 : 0;
+        } else {
+            logger.error(`Failed to set drying mode to ${enabled} for device: ${this.deviceName}`);
+        }
+        return success;
+    }
+
+    /**
+     * Get warm mist enabled status
+     */
+    get warmMistEnabled(): boolean {
+        return this.details.warm_enabled || false;
+    }
+
+    /**
+     * Get drying mode enabled status
+     */
+    get dryingModeEnabled(): boolean {
+        return this.details.drying_mode_enabled || false;
+    }
+
+    /**
+     * Get drying mode state
+     */
+    get dryingModeState(): string {
+        return this.details.drying_mode_state || '';
+    }
+
+    /**
+     * Get drying mode level
+     */
+    get dryingModeLevel(): number {
+        return this.details.drying_mode_level || 0;
+    }
+
+    /**
+     * Get drying mode seconds remaining
+     */
+    get dryingModeSecondsRemaining(): number {
+        return this.details.drying_mode_seconds_remaining || 0;
+    }
+}

package/src/lib/vesyncFan.ts

@@ -19,7 +19,7 @@ export const fanConfig: FanConfig = {
     // Core Series
     'Core200S': {
         module: 'VeSyncAirBypass',
-        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer'],
+        features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_speed', 'auto_mode'],
         levels: [1, 2, 3]
     },
     'Core300S': {
@@ -318,7 +318,7 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
         mode?: string;
         speed?: number;
         filter_life?: number;
-        screen_status?: string;
+        screen_status?: 'on' | 'off';
         child_lock?: boolean;
         air_quality?: string;
         humidity?: number;
@@ -377,8 +377,8 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
     /**
      * Get screen status
      */
-    get screenStatus(): string {
-        return this.details.screen_status ?? '';
+    get screenStatus(): 'on' | 'off' {
+        return this.details.screen_status ?? 'off';
     }
 
     /**
@@ -519,4 +519,4 @@ export abstract class VeSyncFan extends VeSyncBaseDevice {
     abstract turnOff(): Promise<boolean>;
     abstract changeFanSpeed(speed: number): Promise<boolean>;
     abstract setMode(mode: string): Promise<boolean>;
-} 
+}