tsvesync 1.0.96 → 1.0.98

package/README.md

@@ -2,6 +2,13 @@
 
 A TypeScript library for interacting with VeSync smart home devices. This library provides a modern, type-safe interface for controlling VeSync devices including air purifiers, outlets, and switches.
 
+## 🆕 Recent Updates
+
+- **Enhanced Authentication**: Now supports the new VeSync authentication flow (pyvesync PR #340) with automatic fallback to legacy authentication
+- **Regional API Support**: Automatic detection and routing for US (`smartapi.vesync.com`) and EU (`smartapi.vesync.eu`) endpoints
+- **Improved Error Handling**: Better recovery from API changes and authentication errors
+- **Cross-Region Support**: Handles cross-region authentication errors automatically
+
 ## Features
 
 - Full TypeScript support with type definitions

package/dist/lib/helpers.d.ts

@@ -4,16 +4,32 @@
 import { VeSync } from './vesync';
 export declare function getApiBaseUrl(): string;
 export declare function setApiBaseUrl(url: string): void;
+export declare function getCurrentRegion(): string;
+export declare function setCurrentRegion(region: string): void;
+export declare function getRegionFromCountryCode(countryCode: string): string;
 export declare const API_RATE_LIMIT = 30;
 export declare const API_TIMEOUT = 15000;
-export declare const APP_VERSION = "2.8.6";
+export declare const APP_VERSION = "5.6.60";
 export declare const PHONE_BRAND = "SM N9005";
 export declare const PHONE_OS = "Android";
+export declare const CLIENT_INFO = "SM N9005";
 export declare const USER_TYPE = "1";
 export declare const DEFAULT_TZ = "America/New_York";
 export declare const DEFAULT_REGION = "US";
 export declare const MOBILE_ID = "1234567890123456";
 export declare const BYPASS_HEADER_UA = "okhttp/3.12.1";
+export declare const CLIENT_VERSION = "VeSync 5.6.60";
+export declare const REGION_ENDPOINTS: {
+    US: string;
+    CA: string;
+    MX: string;
+    JP: string;
+    EU: string;
+};
+export declare const CROSS_REGION_ERROR_CODE = -11260022;
+export declare const APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
+export declare function generateAppId(): string;
+export declare function generateTerminalId(): string;
 export interface RequestBody {
     acceptLanguage?: string;
     accountID?: string;
@@ -33,8 +49,37 @@ export interface RequestBody {
     userType?: string;
     uuid?: string;
     status?: string;
+    authorizeCode?: string;
+    bizToken?: string;
+    regionChange?: string;
+    userCountryCode?: string;
+    authProtocolType?: string;
+    clientType?: string;
+    sourceAppID?: string;
+    appID?: string;
+    clientVersion?: string;
     [key: string]: any;
 }
+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 declare class Helpers {
     static shouldRedact: boolean;
     /**
@@ -49,6 +94,10 @@ export declare class Helpers {
      * Build header for api requests on 'bypass' endpoint
      */
     static reqHeaderBypass(): Record<string, string>;
+    /**
+     * Build header for new authentication endpoints
+     */
+    static reqHeaderAuth(): Record<string, string>;
     /**
      * Return universal keys for body of api requests
      */
@@ -61,6 +110,14 @@ export declare class Helpers {
      * Detail keys for api requests
      */
     static reqBodyDetails(): Record<string, string>;
+    /**
+     * Build request body for initial authentication step
+     */
+    static reqBodyAuthStep1(manager: VeSync, appId: string, terminalId: string): Record<string, any>;
+    /**
+     * Build request body for second authentication step (login with authorize code)
+     */
+    static reqBodyAuthStep2(authorizeCode: string, bizToken: string | null, appId: string, terminalId: string, userCountryCode?: string): Record<string, any>;
     /**
      * Builder for body of api requests
      */
@@ -85,4 +142,12 @@ export declare class Helpers {
      * Calculate MD5 hash
      */
     static md5(text: string): string;
+    /**
+     * Perform new two-step authentication flow
+     */
+    static authNewFlow(manager: VeSync, appId: string, region?: string): Promise<[boolean, string | null, string | null, string | null]>;
+    /**
+     * Perform legacy authentication (fallback)
+     */
+    static authLegacyFlow(manager: VeSync): Promise<[boolean, string | null, string | null, string | null]>;
 }

package/dist/lib/helpers.js

@@ -6,30 +6,90 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Helpers = exports.BYPASS_HEADER_UA = exports.MOBILE_ID = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_TYPE = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.API_TIMEOUT = exports.API_RATE_LIMIT = void 0;
+exports.Helpers = exports.APP_VERSION_TOO_LOW_ERROR_CODE = exports.CROSS_REGION_ERROR_CODE = exports.REGION_ENDPOINTS = exports.CLIENT_VERSION = exports.BYPASS_HEADER_UA = exports.MOBILE_ID = exports.DEFAULT_REGION = exports.DEFAULT_TZ = exports.USER_TYPE = exports.CLIENT_INFO = exports.PHONE_OS = exports.PHONE_BRAND = exports.APP_VERSION = exports.API_TIMEOUT = exports.API_RATE_LIMIT = void 0;
 exports.getApiBaseUrl = getApiBaseUrl;
 exports.setApiBaseUrl = setApiBaseUrl;
+exports.getCurrentRegion = getCurrentRegion;
+exports.setCurrentRegion = setCurrentRegion;
+exports.getRegionFromCountryCode = getRegionFromCountryCode;
+exports.generateAppId = generateAppId;
+exports.generateTerminalId = generateTerminalId;
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importDefault(require("crypto"));
 const logger_1 = require("./logger");
-// API configuration - Always use US endpoint
+// API configuration - Support regional endpoints
 let _apiBaseUrl = 'https://smartapi.vesync.com';
+let _currentRegion = 'US';
 function getApiBaseUrl() {
     return _apiBaseUrl;
 }
 function setApiBaseUrl(url) {
     _apiBaseUrl = url;
 }
+function getCurrentRegion() {
+    return _currentRegion;
+}
+function setCurrentRegion(region) {
+    _currentRegion = region;
+    if (region in exports.REGION_ENDPOINTS) {
+        _apiBaseUrl = exports.REGION_ENDPOINTS[region];
+    }
+}
+// Determine region from country code
+function getRegionFromCountryCode(countryCode) {
+    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';
+}
 exports.API_RATE_LIMIT = 30;
 exports.API_TIMEOUT = 15000;
-exports.APP_VERSION = '2.8.6';
+exports.APP_VERSION = '5.6.60';
 exports.PHONE_BRAND = 'SM N9005';
 exports.PHONE_OS = 'Android';
+exports.CLIENT_INFO = 'SM N9005';
 exports.USER_TYPE = '1';
 exports.DEFAULT_TZ = 'America/New_York';
 exports.DEFAULT_REGION = 'US';
 exports.MOBILE_ID = '1234567890123456';
 exports.BYPASS_HEADER_UA = 'okhttp/3.12.1';
+exports.CLIENT_VERSION = 'VeSync 5.6.60';
+// Regional API endpoints
+exports.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
+exports.CROSS_REGION_ERROR_CODE = -11260022;
+exports.APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
+// Generate unique APP_ID for each session
+function generateAppId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < 8; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+// Generate unique terminal ID for authentication
+function generateTerminalId() {
+    const chars = 'abcdef0123456789';
+    let result = '';
+    for (let i = 0; i < 16; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
 class Helpers {
     /**
      * Calculate MD5 hash
@@ -64,6 +124,16 @@ class Helpers {
             'User-Agent': exports.BYPASS_HEADER_UA
         };
     }
+    /**
+     * Build header for new authentication endpoints
+     */
+    static reqHeaderAuth() {
+        return {
+            'Content-Type': 'application/json; charset=UTF-8',
+            'User-Agent': exports.BYPASS_HEADER_UA,
+            'accept-language': 'en'
+        };
+    }
     /**
      * Return universal keys for body of api requests
      */
@@ -96,6 +166,56 @@ class Helpers {
             'traceId': Date.now().toString()
         };
     }
+    /**
+     * Build request body for initial authentication step
+     */
+    static reqBodyAuthStep1(manager, appId, terminalId) {
+        return {
+            'email': manager.username,
+            'method': 'authByPWDOrOTM',
+            'password': this.hashPassword(manager.password),
+            'acceptLanguage': 'en',
+            'accountID': '',
+            'authProtocolType': 'generic',
+            'clientInfo': exports.CLIENT_INFO,
+            'clientType': 'vesyncApp',
+            'clientVersion': exports.CLIENT_VERSION,
+            'debugMode': false,
+            'osInfo': exports.PHONE_OS,
+            'terminalId': terminalId,
+            'timeZone': manager.timeZone || exports.DEFAULT_TZ,
+            'token': '',
+            'userCountryCode': 'US',
+            'appID': appId,
+            'sourceAppID': appId,
+            'traceId': `APP${appId}${Math.floor(Date.now() / 1000)}`
+        };
+    }
+    /**
+     * Build request body for second authentication step (login with authorize code)
+     */
+    static reqBodyAuthStep2(authorizeCode, bizToken, appId, terminalId, userCountryCode) {
+        const body = {
+            'method': 'loginByAuthorizeCode4Vesync',
+            'authorizeCode': authorizeCode,
+            'acceptLanguage': 'en',
+            'clientInfo': exports.CLIENT_INFO,
+            'clientType': 'vesyncApp',
+            'clientVersion': exports.CLIENT_VERSION,
+            'debugMode': false,
+            'emailSubscriptions': false,
+            'osInfo': exports.PHONE_OS,
+            'terminalId': terminalId,
+            'timeZone': exports.DEFAULT_TZ,
+            'userCountryCode': userCountryCode || 'US',
+            'traceId': `APP${appId}${Math.floor(Date.now() / 1000)}`
+        };
+        // Only include bizToken if it's not null
+        if (bizToken) {
+            body.bizToken = bizToken;
+        }
+        return body;
+    }
     /**
      * Builder for body of api requests
      */
@@ -270,6 +390,108 @@ class Helpers {
     static md5(text) {
         return crypto_1.default.createHash('md5').update(text).digest('hex');
     }
+    /**
+     * Perform new two-step authentication flow
+     */
+    static async authNewFlow(manager, appId, region = 'US') {
+        try {
+            // Generate terminal ID to be used in both steps
+            const terminalId = generateTerminalId();
+            // Step 1: Get authorization code
+            const step1Body = this.reqBodyAuthStep1(manager, appId, terminalId);
+            const step1Headers = this.reqHeaderAuth();
+            // Set the correct regional endpoint
+            const originalUrl = getApiBaseUrl();
+            if (region in exports.REGION_ENDPOINTS) {
+                setApiBaseUrl(exports.REGION_ENDPOINTS[region]);
+            }
+            logger_1.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_1.logger.error('Step 1 failed:', authResponse);
+                setApiBaseUrl(originalUrl); // Restore original URL
+                return [false, null, null, null];
+            }
+            if (authResponse.code !== 0) {
+                logger_1.logger.error('Step 1 error code:', authResponse.code, 'message:', authResponse.msg);
+                // Handle cross-region error
+                if (authResponse.code === exports.CROSS_REGION_ERROR_CODE) {
+                    logger_1.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) {
+                logger_1.logger.error('Missing authorization code in step 1 response:', authResponse.result);
+                setApiBaseUrl(originalUrl); // Restore original URL
+                return [false, null, null, null];
+            }
+            logger_1.logger.debug('Step 1 successful, got authorization code');
+            // Step 2: Login with authorization code
+            const step2Body = this.reqBodyAuthStep2(authorizeCode, bizToken, appId, terminalId, userCountryCode);
+            logger_1.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_1.logger.error('Step 2 failed:', loginResponse);
+                return [false, null, null, null];
+            }
+            if (loginResponse.code !== 0) {
+                logger_1.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_1.logger.error('Missing required fields in step 2 response:', loginResponse.result);
+                return [false, null, null, null];
+            }
+            logger_1.logger.debug('Step 2 successful, got token and accountID');
+            return [true, token, accountID, countryCode || userCountryCode];
+        }
+        catch (error) {
+            logger_1.logger.error('New authentication flow error:', error);
+            return [false, null, null, null];
+        }
+    }
+    /**
+     * Perform legacy authentication (fallback)
+     */
+    static async authLegacyFlow(manager) {
+        try {
+            const body = this.reqBody(manager, 'login');
+            logger_1.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_1.logger.error('Legacy login failed:', response);
+                return [false, null, null, null];
+            }
+            if (response.code && response.code !== 0) {
+                logger_1.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_1.logger.error('Missing required fields in legacy login response:', response.result);
+                return [false, null, null, null];
+            }
+            logger_1.logger.debug('Legacy login successful');
+            return [true, token, accountID, countryCode];
+        }
+        catch (error) {
+            logger_1.logger.error('Legacy authentication flow error:', error);
+            return [false, null, null, null];
+        }
+    }
 }
 exports.Helpers = Helpers;
 Helpers.shouldRedact = true;

package/dist/lib/vesync.d.ts

@@ -25,6 +25,8 @@ export declare class VeSync {
     private _lastUpdateTs;
     private _inProcess;
     private _excludeConfig;
+    private _appId;
+    private _region;
     username: string;
     password: string;
     token: string | null;
@@ -66,6 +68,18 @@ export declare class VeSync {
      */
     get energyUpdateInterval(): number;
     set energyUpdateInterval(interval: number);
+    /**
+     * Get current App ID
+     */
+    get appId(): string;
+    /**
+     * Get current region
+     */
+    get region(): string;
+    /**
+     * Set region and update API endpoint
+     */
+    set region(region: string);
     /**
      * Test if device should be removed
      */
@@ -91,7 +105,7 @@ export declare class VeSync {
      */
     getDevices(): Promise<boolean>;
     /**
-     * Login to VeSync server
+     * Login to VeSync server with new authentication flow and backwards compatibility
      */
     login(retryAttempts?: number, initialDelayMs?: number): Promise<boolean>;
     /**

package/dist/lib/vesync.js

@@ -139,6 +139,8 @@ class VeSync {
         this._lastUpdateTs = null;
         this._inProcess = false;
         this._excludeConfig = excludeConfig || null;
+        this._appId = (0, helpers_1.generateAppId)();
+        this._region = 'US';
         this.username = username;
         this.password = password;
         this.token = null;
@@ -178,8 +180,9 @@ class VeSync {
             (0, helpers_1.setApiBaseUrl)(apiUrl);
         }
         else {
-            // Always use US endpoint
+            // Start with US endpoint as default
             (0, helpers_1.setApiBaseUrl)('https://smartapi.vesync.com');
+            (0, helpers_1.setCurrentRegion)('US');
         }
         // Set custom logger if provided
         if (customLogger) {
@@ -222,6 +225,27 @@ class VeSync {
             this._energyUpdateInterval = interval;
         }
     }
+    /**
+     * Get current App ID
+     */
+    get appId() {
+        return this._appId;
+    }
+    /**
+     * Get current region
+     */
+    get region() {
+        return this._region;
+    }
+    /**
+     * Set region and update API endpoint
+     */
+    set region(region) {
+        if (region in helpers_1.REGION_ENDPOINTS) {
+            this._region = region;
+            (0, helpers_1.setCurrentRegion)(region);
+        }
+    }
     /**
      * Test if device should be removed
      */
@@ -408,62 +432,71 @@ class VeSync {
         return success;
     }
     /**
-     * Login to VeSync server
+     * Login to VeSync server with new authentication flow and backwards compatibility
      */
     async login(retryAttempts = 3, initialDelayMs = 1000) {
-        var _a;
-        const body = helpers_1.Helpers.reqBody(this, 'login');
+        logger_1.logger.debug('Starting VeSync authentication...', {
+            username: this.username,
+            appId: this._appId,
+            region: this._region
+        });
         for (let attempt = 0; attempt < retryAttempts; attempt++) {
             try {
-                logger_1.logger.debug('Login attempt', {
-                    attempt: attempt + 1,
-                    apiUrl: (0, helpers_1.getApiBaseUrl)(),
-                    timeZone: this.timeZone,
-                    appVersion: body.appVersion
-                });
-                const [response, status] = await helpers_1.Helpers.callApi('/cloud/v1/user/login', 'post', body, {}, this);
-                logger_1.logger.debug('Login response:', { status, response });
-                // Handle specific error codes
-                if (response && response.code) {
-                    switch (response.code) {
-                        case -11012022:
-                            logger_1.logger.error('App version too low error. Current version:', body.appVersion);
-                            logger_1.logger.error('This typically indicates an API version compatibility issue.');
-                            break;
-                        case -11003:
-                            logger_1.logger.error('Authentication failed - check credentials');
-                            break;
-                        case -11001:
-                            logger_1.logger.error('Invalid request format');
-                            break;
-                        default:
-                            logger_1.logger.error('API error code:', response.code, 'message:', response.msg);
+                logger_1.logger.debug(`Authentication attempt ${attempt + 1} of ${retryAttempts}`);
+                // Try new authentication flow first
+                let [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, this._region);
+                if (!success) {
+                    // Check if we need to try a different region
+                    if (countryCode === 'cross_region') {
+                        logger_1.logger.debug('Cross-region error detected, trying EU region...');
+                        this._region = 'EU';
+                        (0, helpers_1.setCurrentRegion)('EU');
+                        [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, 'EU');
+                    }
+                    // If new flow still fails, try legacy authentication as fallback
+                    if (!success) {
+                        logger_1.logger.debug('New authentication flow failed, trying legacy flow...');
+                        [success, token, accountId, countryCode] = await helpers_1.Helpers.authLegacyFlow(this);
                     }
                 }
-                if ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.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_1.logger.debug('Login successful for region:', this.countryCode);
+                    // Set region based on country code if we got one
+                    if (countryCode) {
+                        const detectedRegion = (0, helpers_1.getRegionFromCountryCode)(countryCode);
+                        if (detectedRegion !== this._region) {
+                            logger_1.logger.debug(`Updating region from ${this._region} to ${detectedRegion} based on country code: ${countryCode}`);
+                            this._region = detectedRegion;
+                            (0, helpers_1.setCurrentRegion)(detectedRegion);
+                        }
+                    }
+                    logger_1.logger.debug('Authentication successful!', {
+                        region: this._region,
+                        countryCode: countryCode,
+                        endpoint: (0, helpers_1.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_1.logger.debug(`Login attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                logger_1.logger.debug(`Authentication attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
             catch (error) {
+                logger_1.logger.error(`Authentication attempt ${attempt + 1} error:`, error);
                 if (attempt === retryAttempts - 1) {
-                    logger_1.logger.error('Login error after all retry attempts:', error);
+                    logger_1.logger.error('Authentication failed after all retry attempts');
                     return false;
                 }
                 const delay = initialDelayMs * Math.pow(2, attempt);
-                logger_1.logger.debug(`Login attempt ${attempt + 1} failed with error, retrying in ${delay}ms...`, error);
+                logger_1.logger.debug(`Retrying authentication in ${delay}ms...`);
                 await new Promise(resolve => setTimeout(resolve, delay));
             }
         }
-        logger_1.logger.error('Unable to login with supplied credentials after all retry attempts');
+        logger_1.logger.error('Unable to authenticate with supplied credentials after all retry attempts');
         return false;
     }
     /**

package/package.json

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