tsvesync 1.0.95 → 1.0.97

package/src/lib/helpers.ts

@@ -7,8 +7,9 @@ import crypto from 'crypto';
 import { VeSync } from './vesync';
 import { logger } from './logger';
 
-// API configuration - Always use US endpoint
+// API configuration - Support regional endpoints
 let _apiBaseUrl = 'https://smartapi.vesync.com';
+let _currentRegion = 'US';
 
 export function getApiBaseUrl(): string {
     return _apiBaseUrl;
@@ -18,11 +19,39 @@ export function setApiBaseUrl(url: string): void {
     _apiBaseUrl = url;
 }
 
+export function getCurrentRegion(): string {
+    return _currentRegion;
+}
+
+export function setCurrentRegion(region: string): void {
+    _currentRegion = region;
+    if (region in REGION_ENDPOINTS) {
+        _apiBaseUrl = REGION_ENDPOINTS[region as keyof typeof REGION_ENDPOINTS];
+    }
+}
+
+// Determine region from country code
+export function getRegionFromCountryCode(countryCode: string): string {
+    const euCountries = [
+        'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR',
+        'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL',
+        'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'GB', 'IS', 'LI',
+        'NO', 'CH'
+    ];
+    
+    if (euCountries.includes(countryCode)) {
+        return 'EU';
+    }
+    
+    // Default to US for other countries
+    return 'US';
+}
+
 
 export const API_RATE_LIMIT = 30;
 export const API_TIMEOUT = 15000;
 
-export const APP_VERSION = '2.8.6';
+export const APP_VERSION = '5.6.60';
 export const PHONE_BRAND = 'SM N9005';
 export const PHONE_OS = 'Android';
 export const USER_TYPE = '1';
@@ -30,6 +59,30 @@ export const DEFAULT_TZ = 'America/New_York';
 export const DEFAULT_REGION = 'US';
 export const MOBILE_ID = '1234567890123456';
 export const BYPASS_HEADER_UA = 'okhttp/3.12.1';
+export const CLIENT_VERSION = 'VeSync 5.6.60';
+
+// Regional API endpoints
+export const REGION_ENDPOINTS = {
+    'US': 'https://smartapi.vesync.com',
+    'CA': 'https://smartapi.vesync.com',
+    'MX': 'https://smartapi.vesync.com',
+    'JP': 'https://smartapi.vesync.com',
+    'EU': 'https://smartapi.vesync.eu'
+};
+
+// Cross-region error code
+export const CROSS_REGION_ERROR_CODE = -11260022;
+export const APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
+
+// Generate unique APP_ID for each session
+export function generateAppId(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < 8; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
 
 export interface RequestBody {
     acceptLanguage?: string;
@@ -50,9 +103,42 @@ export interface RequestBody {
     userType?: string;
     uuid?: string;
     status?: string;
+    // New authentication parameters
+    authorizeCode?: string;
+    bizToken?: string;
+    regionChange?: string;
+    userCountryCode?: string;
+    authProtocolType?: string;
+    clientType?: string;
+    sourceAppID?: string;
+    appID?: string;
+    clientVersion?: string;
     [key: string]: any;
 }
 
+// New authentication response interfaces
+export interface AuthResponse {
+    code: number;
+    msg: string;
+    result?: {
+        authorizeCode?: string;
+        bizToken?: string;
+        userCountryCode?: string;
+        [key: string]: any;
+    };
+}
+
+export interface LoginResponse {
+    code: number;
+    msg: string;
+    result?: {
+        token?: string;
+        accountID?: string;
+        countryCode?: string;
+        [key: string]: any;
+    };
+}
+
 export class Helpers {
     static shouldRedact = true;
 
@@ -92,6 +178,17 @@ export class Helpers {
         };
     }
 
+    /**
+     * Build header for new authentication endpoints
+     */
+    static reqHeaderAuth(): Record<string, string> {
+        return {
+            'Content-Type': 'application/json; charset=UTF-8',
+            'User-Agent': BYPASS_HEADER_UA,
+            'accept-language': 'en'
+        };
+    }
+
     /**
      * Return universal keys for body of api requests
      */
@@ -127,6 +224,46 @@ export class Helpers {
         };
     }
 
+    /**
+     * Build request body for initial authentication step
+     */
+    static reqBodyAuthStep1(manager: VeSync, appId: string): Record<string, any> {
+        return {
+            'email': manager.username,
+            'password': this.hashPassword(manager.password),
+            'timeZone': manager.timeZone,
+            'acceptLanguage': 'en',
+            'appVersion': APP_VERSION,
+            'phoneBrand': PHONE_BRAND,
+            'phoneOS': PHONE_OS,
+            'traceId': Date.now().toString(),
+            'authProtocolType': 'pwd',
+            'clientType': 'android',
+            'sourceAppID': 'vesync_android',
+            'appID': appId,
+            'clientVersion': CLIENT_VERSION
+        };
+    }
+
+    /**
+     * Build request body for second authentication step (login with authorize code)
+     */
+    static reqBodyAuthStep2(authorizeCode: string, bizToken: string, appId: string, userCountryCode?: string): Record<string, any> {
+        const body: Record<string, any> = {
+            'authorizeCode': authorizeCode,
+            'bizToken': bizToken,
+            'appID': appId,
+            'clientVersion': CLIENT_VERSION,
+            'acceptLanguage': 'en'
+        };
+
+        if (userCountryCode) {
+            body.userCountryCode = userCountryCode;
+        }
+
+        return body;
+    }
+
     /**
      * Builder for body of api requests
      */
@@ -327,4 +464,150 @@ export class Helpers {
     static md5(text: string): string {
         return crypto.createHash('md5').update(text).digest('hex');
     }
+
+    /**
+     * Perform new two-step authentication flow
+     */
+    static async authNewFlow(manager: VeSync, appId: string, region: string = 'US'): Promise<[boolean, string | null, string | null, string | null]> {
+        try {
+            // Step 1: Get authorization code
+            const step1Body = this.reqBodyAuthStep1(manager, appId);
+            const step1Headers = this.reqHeaderAuth();
+            
+            // Set the correct regional endpoint
+            const originalUrl = getApiBaseUrl();
+            if (region in REGION_ENDPOINTS) {
+                setApiBaseUrl(REGION_ENDPOINTS[region as keyof typeof REGION_ENDPOINTS]);
+            }
+
+            logger.debug('Step 1: Getting authorization code...', {
+                region,
+                endpoint: getApiBaseUrl(),
+                body: { ...step1Body, password: '[REDACTED]' }
+            });
+
+            const [authResponse, authStatus] = await this.callApi(
+                '/globalPlatform/api/accountAuth/v1/authByPWDOrOTM',
+                'post',
+                step1Body,
+                step1Headers,
+                manager
+            );
+
+            if (!authResponse || authStatus !== 200) {
+                logger.error('Step 1 failed:', authResponse);
+                setApiBaseUrl(originalUrl); // Restore original URL
+                return [false, null, null, null];
+            }
+
+            if (authResponse.code !== 0) {
+                logger.error('Step 1 error code:', authResponse.code, 'message:', authResponse.msg);
+                
+                // Handle cross-region error
+                if (authResponse.code === CROSS_REGION_ERROR_CODE) {
+                    logger.debug('Cross-region error detected, will try different region');
+                    setApiBaseUrl(originalUrl); // Restore original URL
+                    return [false, null, null, 'cross_region'];
+                }
+                
+                setApiBaseUrl(originalUrl); // Restore original URL
+                return [false, null, null, null];
+            }
+
+            const { authorizeCode, bizToken, userCountryCode } = authResponse.result || {};
+            
+            if (!authorizeCode || !bizToken) {
+                logger.error('Missing required fields in step 1 response:', authResponse.result);
+                setApiBaseUrl(originalUrl); // Restore original URL
+                return [false, null, null, null];
+            }
+
+            logger.debug('Step 1 successful, got authorization code');
+
+            // Step 2: Login with authorization code
+            const step2Body = this.reqBodyAuthStep2(authorizeCode, bizToken, appId, userCountryCode);
+            
+            logger.debug('Step 2: Logging in with authorization code...');
+
+            const [loginResponse, loginStatus] = await this.callApi(
+                '/user/api/accountManage/v1/loginByAuthorizeCode4Vesync',
+                'post',
+                step2Body,
+                step1Headers,
+                manager
+            );
+
+            setApiBaseUrl(originalUrl); // Restore original URL
+
+            if (!loginResponse || loginStatus !== 200) {
+                logger.error('Step 2 failed:', loginResponse);
+                return [false, null, null, null];
+            }
+
+            if (loginResponse.code !== 0) {
+                logger.error('Step 2 error code:', loginResponse.code, 'message:', loginResponse.msg);
+                return [false, null, null, null];
+            }
+
+            const { token, accountID, countryCode } = loginResponse.result || {};
+            
+            if (!token || !accountID) {
+                logger.error('Missing required fields in step 2 response:', loginResponse.result);
+                return [false, null, null, null];
+            }
+
+            logger.debug('Step 2 successful, got token and accountID');
+            return [true, token, accountID, countryCode || userCountryCode];
+
+        } catch (error) {
+            logger.error('New authentication flow error:', error);
+            return [false, null, null, null];
+        }
+    }
+
+    /**
+     * Perform legacy authentication (fallback)
+     */
+    static async authLegacyFlow(manager: VeSync): Promise<[boolean, string | null, string | null, string | null]> {
+        try {
+            const body = this.reqBody(manager, 'login');
+            
+            logger.debug('Legacy login attempt...', {
+                endpoint: getApiBaseUrl(),
+                body: { ...body, password: '[REDACTED]' }
+            });
+
+            const [response, status] = await this.callApi(
+                '/cloud/v1/user/login',
+                'post',
+                body,
+                {},
+                manager
+            );
+
+            if (!response || status !== 200) {
+                logger.error('Legacy login failed:', response);
+                return [false, null, null, null];
+            }
+
+            if (response.code && response.code !== 0) {
+                logger.error('Legacy login error code:', response.code, 'message:', response.msg);
+                return [false, null, null, null];
+            }
+
+            const { token, accountID, countryCode } = response.result || {};
+            
+            if (!token || !accountID) {
+                logger.error('Missing required fields in legacy login response:', response.result);
+                return [false, null, null, null];
+            }
+
+            logger.debug('Legacy login successful');
+            return [true, token, accountID, countryCode];
+
+        } catch (error) {
+            logger.error('Legacy authentication flow error:', error);
+            return [false, null, null, null];
+        }
+    }
 } 

package/src/lib/vesync.ts

@@ -2,7 +2,7 @@
  * VeSync API Device Library
  */
 
-import { Helpers, API_RATE_LIMIT, DEFAULT_TZ, setApiBaseUrl, getApiBaseUrl } from './helpers';
+import { Helpers, API_RATE_LIMIT, DEFAULT_TZ, setApiBaseUrl, getApiBaseUrl, generateAppId, getRegionFromCountryCode, setCurrentRegion, getCurrentRegion, REGION_ENDPOINTS } from './helpers';
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { fanModules } from './vesyncFanImpl';
 import { outletModules } from './vesyncOutletImpl';
@@ -159,6 +159,8 @@ export class VeSync {
     private _lastUpdateTs: number | null;
     private _inProcess: boolean;
     private _excludeConfig: ExcludeConfig | null;
+    private _appId: string;
+    private _region: string;
 
     username: string;
     password: string;
@@ -204,6 +206,8 @@ export class VeSync {
         this._lastUpdateTs = null;
         this._inProcess = false;
         this._excludeConfig = excludeConfig || null;
+        this._appId = generateAppId();
+        this._region = 'US';
 
         this.username = username;
         this.password = password;
@@ -245,8 +249,9 @@ export class VeSync {
         if (apiUrl) {
             setApiBaseUrl(apiUrl);
         } else {
-            // Always use US endpoint
+            // Start with US endpoint as default
             setApiBaseUrl('https://smartapi.vesync.com');
+            setCurrentRegion('US');
         }
 
         // Set custom logger if provided
@@ -299,6 +304,30 @@ export class VeSync {
         }
     }
 
+    /**
+     * Get current App ID
+     */
+    get appId(): string {
+        return this._appId;
+    }
+
+    /**
+     * Get current region
+     */
+    get region(): string {
+        return this._region;
+    }
+
+    /**
+     * Set region and update API endpoint
+     */
+    set region(region: string) {
+        if (region in REGION_ENDPOINTS) {
+            this._region = region;
+            setCurrentRegion(region);
+        }
+    }
+
     /**
      * Test if device should be removed
      */
@@ -506,75 +535,82 @@ export class VeSync {
     }
 
     /**
-     * Login to VeSync server
+     * Login to VeSync server with new authentication flow and backwards compatibility
      */
     async login(retryAttempts: number = 3, initialDelayMs: number = 1000): Promise<boolean> {
-        const body = Helpers.reqBody(this, 'login');
-        
+        logger.debug('Starting VeSync authentication...', {
+            username: this.username,
+            appId: this._appId,
+            region: this._region
+        });
+
         for (let attempt = 0; attempt < retryAttempts; attempt++) {
             try {
-                logger.debug('Login attempt', {
-                    attempt: attempt + 1,
-                    apiUrl: getApiBaseUrl(),
-                    timeZone: this.timeZone,
-                    appVersion: body.appVersion
-                });
-
-                const [response, status] = await Helpers.callApi(
-                    '/cloud/v1/user/login',
-                    'post',
-                    body,
-                    {},
-                    this
-                );
-
-                logger.debug('Login response:', { status, response });
-
-                // Handle specific error codes
-                if (response && response.code) {
-                    switch (response.code) {
-                        case -11012022:
-                            logger.error('App version too low error. Current version:', body.appVersion);
-                            logger.error('This typically indicates an API version compatibility issue.');
-                            break;
-                        case -11003:
-                            logger.error('Authentication failed - check credentials');
-                            break;
-                        case -11001:
-                            logger.error('Invalid request format');
-                            break;
-                        default:
-                            logger.error('API error code:', response.code, 'message:', response.msg);
+                logger.debug(`Authentication attempt ${attempt + 1} of ${retryAttempts}`);
+
+                // Try new authentication flow first
+                let [success, token, accountId, countryCode] = await Helpers.authNewFlow(this, this._appId, this._region);
+
+                if (!success) {
+                    // Check if we need to try a different region
+                    if (countryCode === 'cross_region') {
+                        logger.debug('Cross-region error detected, trying EU region...');
+                        this._region = 'EU';
+                        setCurrentRegion('EU');
+                        [success, token, accountId, countryCode] = await Helpers.authNewFlow(this, this._appId, 'EU');
+                    }
+
+                    // If new flow still fails, try legacy authentication as fallback
+                    if (!success) {
+                        logger.debug('New authentication flow failed, trying legacy flow...');
+                        [success, token, accountId, countryCode] = await Helpers.authLegacyFlow(this);
                     }
                 }
 
-                if (response?.result?.token) {
-                    this.token = response.result.token;
-                    this.accountId = response.result.accountID;
-                    this.countryCode = response.result.countryCode;
+                if (success && token && accountId) {
+                    this.token = token;
+                    this.accountId = accountId;
+                    this.countryCode = countryCode;
                     this.enabled = true;
-                    logger.debug('Login successful for region:', this.countryCode);
+
+                    // Set region based on country code if we got one
+                    if (countryCode) {
+                        const detectedRegion = getRegionFromCountryCode(countryCode);
+                        if (detectedRegion !== this._region) {
+                            logger.debug(`Updating region from ${this._region} to ${detectedRegion} based on country code: ${countryCode}`);
+                            this._region = detectedRegion;
+                            setCurrentRegion(detectedRegion);
+                        }
+                    }
+
+                    logger.debug('Authentication successful!', {
+                        region: this._region,
+                        countryCode: countryCode,
+                        endpoint: getApiBaseUrl()
+                    });
                     return true;
                 }
 
-                // If we reach here, login failed but didn't throw an error
+                // If we reach here, authentication failed
                 const delay = initialDelayMs * Math.pow(2, attempt);
-                logger.debug(`Login attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                logger.debug(`Authentication attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
                 await new Promise(resolve => setTimeout(resolve, delay));
-                
+
             } catch (error) {
+                logger.error(`Authentication attempt ${attempt + 1} error:`, error);
+                
                 if (attempt === retryAttempts - 1) {
-                    logger.error('Login error after all retry attempts:', error);
+                    logger.error('Authentication failed after all retry attempts');
                     return false;
                 }
-                
+
                 const delay = initialDelayMs * Math.pow(2, attempt);
-                logger.debug(`Login attempt ${attempt + 1} failed with error, retrying in ${delay}ms...`, error);
+                logger.debug(`Retrying authentication in ${delay}ms...`);
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
         }
 
-        logger.error('Unable to login with supplied credentials after all retry attempts');
+        logger.error('Unable to authenticate with supplied credentials after all retry attempts');
         return false;
     }
 

package/dist/__tests__/fans/vesyncAir131.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for VeSyncAir131 air quality data parsing and filter life handling
- */
-export {};