tsvesync 1.0.100 → 1.0.102

package/dist/lib/helpers.d.ts

@@ -9,7 +9,7 @@ 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 = "5.6.60";
+export declare const APP_VERSION = "5.7.16";
 export declare const PHONE_BRAND = "SM N9005";
 export declare const PHONE_OS = "Android";
 export declare const CLIENT_INFO = "SM N9005";
@@ -18,7 +18,7 @@ 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 CLIENT_VERSION = "VeSync 5.7.16";
 export declare const REGION_ENDPOINTS: {
     US: string;
     CA: string;
@@ -26,8 +26,22 @@ export declare const REGION_ENDPOINTS: {
     JP: string;
     EU: string;
 };
-export declare const CROSS_REGION_ERROR_CODE = -11260022;
+export declare const CROSS_REGION_ERROR_CODES: number[];
 export declare const APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
+export declare const AUTH_ERROR_CODES: {
+    ACCOUNT_PASSWORD_INCORRECT: number;
+    ILLEGAL_ARGUMENT: number;
+    CROSS_REGION: number;
+    CROSS_REGION_ALT: number;
+};
+/**
+ * Detect user's home region from email domain or country hints
+ */
+export declare function detectUserRegion(email: string): string;
+/**
+ * Get country code from region
+ */
+export declare function getCountryCodeFromRegion(region: string, email?: string): string;
 export declare function generateAppId(): string;
 export declare function generateTerminalId(): string;
 export interface RequestBody {
@@ -113,7 +127,7 @@ export declare class Helpers {
     /**
      * Build request body for initial authentication step
      */
-    static reqBodyAuthStep1(manager: VeSync, appId: string, terminalId: string): Record<string, any>;
+    static reqBodyAuthStep1(manager: VeSync, appId: string, terminalId: string, region?: string): Record<string, any>;
     /**
      * Build request body for second authentication step (login with authorize code)
      */

package/dist/lib/helpers.js

@@ -6,12 +6,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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.Helpers = exports.AUTH_ERROR_CODES = exports.APP_VERSION_TOO_LOW_ERROR_CODE = exports.CROSS_REGION_ERROR_CODES = 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.detectUserRegion = detectUserRegion;
+exports.getCountryCodeFromRegion = getCountryCodeFromRegion;
 exports.generateAppId = generateAppId;
 exports.generateTerminalId = generateTerminalId;
 const axios_1 = __importDefault(require("axios"));
@@ -51,7 +53,7 @@ function getRegionFromCountryCode(countryCode) {
 }
 exports.API_RATE_LIMIT = 30;
 exports.API_TIMEOUT = 15000;
-exports.APP_VERSION = '5.6.60';
+exports.APP_VERSION = '5.7.16'; // Updated to newer version
 exports.PHONE_BRAND = 'SM N9005';
 exports.PHONE_OS = 'Android';
 exports.CLIENT_INFO = 'SM N9005';
@@ -60,7 +62,7 @@ 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';
+exports.CLIENT_VERSION = 'VeSync 5.7.16';
 // Regional API endpoints
 exports.REGION_ENDPOINTS = {
     'US': 'https://smartapi.vesync.com',
@@ -69,12 +71,57 @@ exports.REGION_ENDPOINTS = {
     'JP': 'https://smartapi.vesync.com',
     'EU': 'https://smartapi.vesync.eu'
 };
-// Cross-region error code
-exports.CROSS_REGION_ERROR_CODE = -11260022;
+// Cross-region error codes - multiple versions exist
+exports.CROSS_REGION_ERROR_CODES = [-11260022, -11261022];
 exports.APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
+// Authentication error codes
+exports.AUTH_ERROR_CODES = {
+    ACCOUNT_PASSWORD_INCORRECT: -11201129,
+    ILLEGAL_ARGUMENT: -11000022,
+    CROSS_REGION: -11260022,
+    CROSS_REGION_ALT: -11261022
+};
+/**
+ * Detect user's home region from email domain or country hints
+ */
+function detectUserRegion(email) {
+    // Check for common EU email domains
+    const euDomains = ['.de', '.fr', '.it', '.es', '.nl', '.be', '.at', '.dk', '.se', '.no', '.fi', '.eu'];
+    const emailLower = email.toLowerCase();
+    for (const domain of euDomains) {
+        if (emailLower.includes(domain)) {
+            return 'EU';
+        }
+    }
+    // Default to US for unknown domains
+    return 'US';
+}
+/**
+ * Get country code from region
+ */
+function getCountryCodeFromRegion(region, email) {
+    if (region === 'EU') {
+        // Try to detect specific EU country from email
+        if (email) {
+            const emailLower = email.toLowerCase();
+            if (emailLower.includes('.de') || emailLower.includes('german'))
+                return 'DE';
+            if (emailLower.includes('.fr'))
+                return 'FR';
+            if (emailLower.includes('.it'))
+                return 'IT';
+            if (emailLower.includes('.es'))
+                return 'ES';
+            if (emailLower.includes('.nl'))
+                return 'NL';
+        }
+        return 'DE'; // Default to Germany for EU
+    }
+    return 'US'; // Default for non-EU
+}
 // Generate unique APP_ID for each session
 function generateAppId() {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const chars = 'ABCDEFGHIJKLMNOPqRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     let result = '';
     for (let i = 0; i < 8; i++) {
         result += chars.charAt(Math.floor(Math.random() * chars.length));
@@ -131,7 +178,9 @@ class Helpers {
         return {
             'Content-Type': 'application/json; charset=UTF-8',
             'User-Agent': exports.BYPASS_HEADER_UA,
-            'accept-language': 'en'
+            'accept-language': 'en',
+            'appVersion': exports.APP_VERSION,
+            'clientVersion': exports.CLIENT_VERSION
         };
     }
     /**
@@ -169,7 +218,16 @@ class Helpers {
     /**
      * Build request body for initial authentication step
      */
-    static reqBodyAuthStep1(manager, appId, terminalId) {
+    static reqBodyAuthStep1(manager, appId, terminalId, region = 'US') {
+        // Detect user's home region and country code
+        const userRegion = detectUserRegion(manager.username);
+        const userCountryCode = getCountryCodeFromRegion(region === 'EU' ? 'EU' : userRegion, manager.username);
+        logger_1.logger.debug('Authentication Step 1 - Region detection:', {
+            email: manager.username,
+            detectedRegion: userRegion,
+            requestRegion: region,
+            userCountryCode: userCountryCode
+        });
         return {
             'email': manager.username,
             'method': 'authByPWDOrOTM',
@@ -185,7 +243,7 @@ class Helpers {
             'terminalId': terminalId,
             'timeZone': manager.timeZone || exports.DEFAULT_TZ,
             'token': '',
-            'userCountryCode': 'US',
+            'userCountryCode': userCountryCode,
             'appID': appId,
             'sourceAppID': appId,
             'traceId': `APP${appId}${Math.floor(Date.now() / 1000)}`
@@ -402,7 +460,7 @@ class Helpers {
             // 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 step1Body = this.reqBodyAuthStep1(manager, appId, terminalId, region);
             const step1Headers = this.reqHeaderAuth();
             // Set the correct regional endpoint
             const originalUrl = getApiBaseUrl();
@@ -422,16 +480,16 @@ class Helpers {
             }
             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');
+                // Handle cross-region error (multiple error codes possible)
+                if (exports.CROSS_REGION_ERROR_CODES.includes(authResponse.code)) {
+                    logger_1.logger.debug('Cross-region error detected:', authResponse.code, '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 || {};
+            const { authorizeCode, bizToken } = authResponse.result || {};
             if (!authorizeCode) {
                 logger_1.logger.error('Missing authorization code in step 1 response:', authResponse.result);
                 setApiBaseUrl(originalUrl); // Restore original URL
@@ -439,7 +497,9 @@ class Helpers {
             }
             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);
+            // Use the appropriate country code based on the region we're authenticating with
+            const countryCodeForStep2 = region === 'EU' ? 'DE' : 'US';
+            const step2Body = this.reqBodyAuthStep2(authorizeCode, bizToken, appId, terminalId, countryCodeForStep2);
             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);
             if (!loginResponse || loginStatus !== 200) {
@@ -449,31 +509,44 @@ class Helpers {
             }
             if (loginResponse.code !== 0) {
                 // Handle cross-region error with retry (like pyvesync PR #340)
-                if (loginResponse.code === exports.CROSS_REGION_ERROR_CODE) {
+                if (exports.CROSS_REGION_ERROR_CODES.includes(loginResponse.code)) {
                     logger_1.logger.debug('Cross-region error detected in Step 2, retrying with region change token...');
                     const { bizToken: regionChangeToken, countryCode: newCountryCode } = loginResponse.result || {};
-                    if (regionChangeToken) {
-                        // Retry Step 2 with region change token
+                    if (regionChangeToken && newCountryCode) {
+                        // Retry Step 2 with region change token on the SAME endpoint
+                        // The region change token tells the server to handle the cross-region authentication
                         const retryBody = {
-                            ...step2Body,
+                            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: newCountryCode,
+                            traceId: `APP${appId}${Math.floor(Date.now() / 1000)}`,
                             bizToken: regionChangeToken,
-                            regionChange: 'last_region',
-                            userCountryCode: newCountryCode || userCountryCode
+                            regionChange: 'last_region'
                         };
                         logger_1.logger.debug('Retrying Step 2 with region change token...', {
                             newCountryCode,
-                            hasRegionChangeToken: true
+                            currentEndpoint: getApiBaseUrl()
                         });
                         const [retryResponse, retryStatus] = await this.callApi('/user/api/accountManage/v1/loginByAuthorizeCode4Vesync', 'post', retryBody, step1Headers, manager);
-                        setApiBaseUrl(originalUrl); // Restore original URL after retry
                         if (retryResponse && retryResponse.code === 0) {
                             const { token, accountID, countryCode } = retryResponse.result || {};
                             if (token && accountID) {
                                 logger_1.logger.debug('Step 2 retry successful with region change');
+                                setApiBaseUrl(originalUrl); // Restore original URL on success
                                 return [true, token, accountID, countryCode || newCountryCode];
                             }
                         }
                         logger_1.logger.error('Step 2 retry failed:', retryResponse);
+                        setApiBaseUrl(originalUrl); // Restore original URL on failure
                         return [false, null, null, null];
                     }
                     else {
@@ -491,7 +564,7 @@ class Helpers {
                 return [false, null, null, null];
             }
             logger_1.logger.debug('Step 2 successful, got token and accountID');
-            return [true, token, accountID, countryCode || userCountryCode];
+            return [true, token, accountID, countryCode || countryCodeForStep2];
         }
         catch (error) {
             logger_1.logger.error('New authentication flow error:', error);

package/dist/lib/vesync.d.ts

@@ -36,6 +36,8 @@ export declare class VeSync {
     enabled: boolean;
     updateInterval: number;
     timeZone: string;
+    authFlowUsed?: 'legacy' | 'new';
+    apiBaseUrl?: string;
     fans: VeSyncBaseDevice[];
     outlets: VeSyncBaseDevice[];
     switches: VeSyncBaseDevice[];
@@ -46,13 +48,21 @@ export declare class VeSync {
      * @param username - VeSync account username
      * @param password - VeSync account password
      * @param timeZone - Optional timezone for device operations (defaults to America/New_York)
-     * @param debug - Optional debug mode flag
-     * @param redact - Optional redact mode flag
-     * @param apiUrl - Optional API base URL override
-     * @param customLogger - Optional custom logger implementation
-     * @param excludeConfig - Optional device exclusion configuration
-     */
-    constructor(username: string, password: string, timeZone?: string, debug?: boolean, redact?: boolean, apiUrl?: string, customLogger?: Logger, excludeConfig?: ExcludeConfig);
+     * @param optionsOrDebug - Either options object or debug flag for backward compatibility
+     * @param redact - Optional redact mode flag (used when optionsOrDebug is boolean)
+     * @param apiUrl - Optional API base URL override (used when optionsOrDebug is boolean)
+     * @param customLogger - Optional custom logger implementation (used when optionsOrDebug is boolean)
+     * @param excludeConfig - Optional device exclusion configuration (used when optionsOrDebug is boolean)
+     */
+    constructor(username: string, password: string, timeZone?: string, optionsOrDebug?: boolean | {
+        debug?: boolean;
+        redact?: boolean;
+        apiUrl?: string;
+        customLogger?: Logger;
+        excludeConfig?: ExcludeConfig;
+        region?: string;
+        debugMode?: boolean;
+    }, redact?: boolean, apiUrl?: string, customLogger?: Logger, excludeConfig?: ExcludeConfig);
     /**
      * Get/Set debug mode
      */

package/dist/lib/vesync.js

@@ -125,22 +125,37 @@ class VeSync {
      * @param username - VeSync account username
      * @param password - VeSync account password
      * @param timeZone - Optional timezone for device operations (defaults to America/New_York)
-     * @param debug - Optional debug mode flag
-     * @param redact - Optional redact mode flag
-     * @param apiUrl - Optional API base URL override
-     * @param customLogger - Optional custom logger implementation
-     * @param excludeConfig - Optional device exclusion configuration
+     * @param optionsOrDebug - Either options object or debug flag for backward compatibility
+     * @param redact - Optional redact mode flag (used when optionsOrDebug is boolean)
+     * @param apiUrl - Optional API base URL override (used when optionsOrDebug is boolean)
+     * @param customLogger - Optional custom logger implementation (used when optionsOrDebug is boolean)
+     * @param excludeConfig - Optional device exclusion configuration (used when optionsOrDebug is boolean)
      */
-    constructor(username, password, timeZone = helpers_1.DEFAULT_TZ, debug = false, redact = true, apiUrl, customLogger, excludeConfig) {
-        this._debug = debug;
-        this._redact = redact;
+    constructor(username, password, timeZone = helpers_1.DEFAULT_TZ, optionsOrDebug = false, redact = true, apiUrl, customLogger, excludeConfig) {
+        // Handle options object or backward compatible parameters
+        let options = {};
+        if (typeof optionsOrDebug === 'object' && optionsOrDebug !== null) {
+            // Using new options pattern
+            options = optionsOrDebug;
+            this._debug = options.debug || options.debugMode || false;
+            this._redact = options.redact !== undefined ? options.redact : true;
+            this._excludeConfig = options.excludeConfig || null;
+            this._region = options.region || 'US';
+            customLogger = options.customLogger;
+            apiUrl = options.apiUrl;
+        }
+        else {
+            // Using old parameter pattern for backward compatibility
+            this._debug = optionsOrDebug;
+            this._redact = redact;
+            this._excludeConfig = excludeConfig || null;
+            this._region = 'US';
+        }
         this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
         this._energyCheck = true;
         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;
@@ -175,25 +190,28 @@ class VeSync {
             this.timeZone = helpers_1.DEFAULT_TZ;
             logger_1.logger.debug('Time zone is not a string');
         }
-        // Set custom API URL if provided, otherwise use default US endpoint
+        // Set custom API URL if provided, otherwise use region-based endpoint
         if (apiUrl) {
             (0, helpers_1.setApiBaseUrl)(apiUrl);
         }
         else {
-            // Start with US endpoint as default
-            (0, helpers_1.setApiBaseUrl)('https://smartapi.vesync.com');
-            (0, helpers_1.setCurrentRegion)('US');
+            // Set endpoint based on region
+            const regionEndpoints = {
+                'US': 'https://smartapi.vesync.com',
+                'EU': 'https://smartapi.vesync.eu',
+                'CA': 'https://smartapi.vesync.com',
+                'MX': 'https://smartapi.vesync.com',
+                'JP': 'https://smartapi.vesync.com'
+            };
+            const endpoint = regionEndpoints[this._region] || 'https://smartapi.vesync.com';
+            (0, helpers_1.setApiBaseUrl)(endpoint);
+            (0, helpers_1.setCurrentRegion)(this._region);
         }
         // Set custom logger if provided
         if (customLogger) {
             (0, logger_1.setLogger)(customLogger);
         }
-        if (debug) {
-            this.debug = true;
-        }
-        if (redact) {
-            this.redact = true;
-        }
+        // Debug and redact are already set above in the options handling
     }
     /**
      * Get/Set debug mode
@@ -443,20 +461,38 @@ class VeSync {
         for (let attempt = 0; attempt < retryAttempts; attempt++) {
             try {
                 logger_1.logger.debug(`Authentication attempt ${attempt + 1} of ${retryAttempts}`);
-                // Try new authentication flow first
+                // First, try to detect user's region from email
+                const detectedRegion = (0, helpers_1.getRegionFromCountryCode)((0, helpers_1.getCountryCodeFromRegion)(this._region, this.username));
+                if (detectedRegion !== this._region) {
+                    logger_1.logger.debug(`Adjusting region from ${this._region} to ${detectedRegion} based on email domain`);
+                    this._region = detectedRegion;
+                    (0, helpers_1.setCurrentRegion)(detectedRegion);
+                }
+                // Try new authentication flow first with detected region
                 let [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, this._region);
+                // Track if new flow succeeded
+                if (success) {
+                    this.authFlowUsed = 'new';
+                }
                 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');
+                        logger_1.logger.debug('Cross-region error detected, trying opposite region...');
+                        const alternateRegion = this._region === 'US' ? 'EU' : 'US';
+                        this._region = alternateRegion;
+                        (0, helpers_1.setCurrentRegion)(alternateRegion);
+                        [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, alternateRegion);
+                        if (success) {
+                            this.authFlowUsed = 'new';
+                        }
                     }
                     // 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 (success) {
+                            this.authFlowUsed = 'legacy';
+                        }
                     }
                 }
                 if (success && token && accountId) {
@@ -464,6 +500,7 @@ class VeSync {
                     this.accountId = accountId;
                     this.countryCode = countryCode;
                     this.enabled = true;
+                    this.apiBaseUrl = (0, helpers_1.getApiBaseUrl)(); // Track the API endpoint being used
                     // Set region based on country code if we got one
                     if (countryCode) {
                         const detectedRegion = (0, helpers_1.getRegionFromCountryCode)(countryCode);
@@ -474,6 +511,7 @@ class VeSync {
                         }
                     }
                     logger_1.logger.debug('Authentication successful!', {
+                        authFlow: this.authFlowUsed,
                         region: this._region,
                         countryCode: countryCode,
                         endpoint: (0, helpers_1.getApiBaseUrl)()

package/package.json

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

package/src/lib/helpers.ts

@@ -51,7 +51,7 @@ export function getRegionFromCountryCode(countryCode: string): string {
 export const API_RATE_LIMIT = 30;
 export const API_TIMEOUT = 15000;
 
-export const APP_VERSION = '5.6.60';
+export const APP_VERSION = '5.7.16'; // Updated to newer version
 export const PHONE_BRAND = 'SM N9005';
 export const PHONE_OS = 'Android';
 export const CLIENT_INFO = 'SM N9005';
@@ -60,7 +60,7 @@ 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';
+export const CLIENT_VERSION = 'VeSync 5.7.16';
 
 // Regional API endpoints
 export const REGION_ENDPOINTS = {
@@ -71,13 +71,58 @@ export const REGION_ENDPOINTS = {
     'EU': 'https://smartapi.vesync.eu'
 };
 
-// Cross-region error code
-export const CROSS_REGION_ERROR_CODE = -11260022;
+// Cross-region error codes - multiple versions exist
+export const CROSS_REGION_ERROR_CODES = [-11260022, -11261022];
 export const APP_VERSION_TOO_LOW_ERROR_CODE = -11012022;
 
+// Authentication error codes
+export const AUTH_ERROR_CODES = {
+    ACCOUNT_PASSWORD_INCORRECT: -11201129,
+    ILLEGAL_ARGUMENT: -11000022,
+    CROSS_REGION: -11260022,
+    CROSS_REGION_ALT: -11261022
+};
+
+/**
+ * Detect user's home region from email domain or country hints
+ */
+export function detectUserRegion(email: string): string {
+    // Check for common EU email domains
+    const euDomains = ['.de', '.fr', '.it', '.es', '.nl', '.be', '.at', '.dk', '.se', '.no', '.fi', '.eu'];
+    const emailLower = email.toLowerCase();
+    
+    for (const domain of euDomains) {
+        if (emailLower.includes(domain)) {
+            return 'EU';
+        }
+    }
+    
+    // Default to US for unknown domains
+    return 'US';
+}
+
+/**
+ * Get country code from region
+ */
+export function getCountryCodeFromRegion(region: string, email?: string): string {
+    if (region === 'EU') {
+        // Try to detect specific EU country from email
+        if (email) {
+            const emailLower = email.toLowerCase();
+            if (emailLower.includes('.de') || emailLower.includes('german')) return 'DE';
+            if (emailLower.includes('.fr')) return 'FR';
+            if (emailLower.includes('.it')) return 'IT';
+            if (emailLower.includes('.es')) return 'ES';
+            if (emailLower.includes('.nl')) return 'NL';
+        }
+        return 'DE'; // Default to Germany for EU
+    }
+    return 'US'; // Default for non-EU
+}
+
 // Generate unique APP_ID for each session
 export function generateAppId(): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const chars = 'ABCDEFGHIJKLMNOPqRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     let result = '';
     for (let i = 0; i < 8; i++) {
         result += chars.charAt(Math.floor(Math.random() * chars.length));
@@ -196,7 +241,9 @@ export class Helpers {
         return {
             'Content-Type': 'application/json; charset=UTF-8',
             'User-Agent': BYPASS_HEADER_UA,
-            'accept-language': 'en'
+            'accept-language': 'en',
+            'appVersion': APP_VERSION,
+            'clientVersion': CLIENT_VERSION
         };
     }
 
@@ -238,7 +285,18 @@ export class Helpers {
     /**
      * Build request body for initial authentication step
      */
-    static reqBodyAuthStep1(manager: VeSync, appId: string, terminalId: string): Record<string, any> {
+    static reqBodyAuthStep1(manager: VeSync, appId: string, terminalId: string, region: string = 'US'): Record<string, any> {
+        // Detect user's home region and country code
+        const userRegion = detectUserRegion(manager.username);
+        const userCountryCode = getCountryCodeFromRegion(region === 'EU' ? 'EU' : userRegion, manager.username);
+        
+        logger.debug('Authentication Step 1 - Region detection:', {
+            email: manager.username,
+            detectedRegion: userRegion,
+            requestRegion: region,
+            userCountryCode: userCountryCode
+        });
+        
         return {
             'email': manager.username,
             'method': 'authByPWDOrOTM',
@@ -254,7 +312,7 @@ export class Helpers {
             'terminalId': terminalId,
             'timeZone': manager.timeZone || DEFAULT_TZ,
             'token': '',
-            'userCountryCode': 'US',
+            'userCountryCode': userCountryCode,
             'appID': appId,
             'sourceAppID': appId,
             'traceId': `APP${appId}${Math.floor(Date.now() / 1000)}`
@@ -504,7 +562,7 @@ export class Helpers {
             const terminalId = generateTerminalId();
             
             // Step 1: Get authorization code
-            const step1Body = this.reqBodyAuthStep1(manager, appId, terminalId);
+            const step1Body = this.reqBodyAuthStep1(manager, appId, terminalId, region);
             const step1Headers = this.reqHeaderAuth();
             
             // Set the correct regional endpoint
@@ -536,9 +594,9 @@ export class Helpers {
             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');
+                // Handle cross-region error (multiple error codes possible)
+                if (CROSS_REGION_ERROR_CODES.includes(authResponse.code)) {
+                    logger.debug('Cross-region error detected:', authResponse.code, 'will try different region');
                     setApiBaseUrl(originalUrl); // Restore original URL
                     return [false, null, null, 'cross_region'];
                 }
@@ -547,7 +605,7 @@ export class Helpers {
                 return [false, null, null, null];
             }
 
-            const { authorizeCode, bizToken, userCountryCode } = authResponse.result || {};
+            const { authorizeCode, bizToken } = authResponse.result || {};
             
             if (!authorizeCode) {
                 logger.error('Missing authorization code in step 1 response:', authResponse.result);
@@ -558,7 +616,9 @@ export class Helpers {
             logger.debug('Step 1 successful, got authorization code');
 
             // Step 2: Login with authorization code
-            const step2Body = this.reqBodyAuthStep2(authorizeCode, bizToken, appId, terminalId, userCountryCode);
+            // Use the appropriate country code based on the region we're authenticating with
+            const countryCodeForStep2 = region === 'EU' ? 'DE' : 'US';
+            const step2Body = this.reqBodyAuthStep2(authorizeCode, bizToken, appId, terminalId, countryCodeForStep2);
             
             logger.debug('Step 2: Logging in with authorization code...');
 
@@ -578,23 +638,35 @@ export class Helpers {
 
             if (loginResponse.code !== 0) {
                 // Handle cross-region error with retry (like pyvesync PR #340)
-                if (loginResponse.code === CROSS_REGION_ERROR_CODE) {
+                if (CROSS_REGION_ERROR_CODES.includes(loginResponse.code)) {
                     logger.debug('Cross-region error detected in Step 2, retrying with region change token...');
                     
                     const { bizToken: regionChangeToken, countryCode: newCountryCode } = loginResponse.result || {};
                     
-                    if (regionChangeToken) {
-                        // Retry Step 2 with region change token
+                    if (regionChangeToken && newCountryCode) {
+                        // Retry Step 2 with region change token on the SAME endpoint
+                        // The region change token tells the server to handle the cross-region authentication
                         const retryBody = {
-                            ...step2Body,
+                            method: 'loginByAuthorizeCode4Vesync',
+                            authorizeCode: authorizeCode,
+                            acceptLanguage: 'en',
+                            clientInfo: CLIENT_INFO,
+                            clientType: 'vesyncApp',
+                            clientVersion: CLIENT_VERSION,
+                            debugMode: false,
+                            emailSubscriptions: false,
+                            osInfo: PHONE_OS,
+                            terminalId: terminalId,
+                            timeZone: DEFAULT_TZ,
+                            userCountryCode: newCountryCode,
+                            traceId: `APP${appId}${Math.floor(Date.now() / 1000)}`,
                             bizToken: regionChangeToken,
-                            regionChange: 'last_region',
-                            userCountryCode: newCountryCode || userCountryCode
+                            regionChange: 'last_region'
                         };
                         
                         logger.debug('Retrying Step 2 with region change token...', {
                             newCountryCode,
-                            hasRegionChangeToken: true
+                            currentEndpoint: getApiBaseUrl()
                         });
                         
                         const [retryResponse, retryStatus] = await this.callApi(
@@ -605,17 +677,17 @@ export class Helpers {
                             manager
                         );
                         
-                        setApiBaseUrl(originalUrl); // Restore original URL after retry
-                        
                         if (retryResponse && retryResponse.code === 0) {
                             const { token, accountID, countryCode } = retryResponse.result || {};
                             if (token && accountID) {
                                 logger.debug('Step 2 retry successful with region change');
+                                setApiBaseUrl(originalUrl); // Restore original URL on success
                                 return [true, token, accountID, countryCode || newCountryCode];
                             }
                         }
                         
                         logger.error('Step 2 retry failed:', retryResponse);
+                        setApiBaseUrl(originalUrl); // Restore original URL on failure
                         return [false, null, null, null];
                     } else {
                         logger.error('No region change token in cross-region error response');
@@ -637,7 +709,7 @@ export class Helpers {
             }
 
             logger.debug('Step 2 successful, got token and accountID');
-            return [true, token, accountID, countryCode || userCountryCode];
+            return [true, token, accountID, countryCode || countryCodeForStep2];
 
         } catch (error) {
             logger.error('New authentication flow error:', error);

package/src/lib/vesync.ts

@@ -2,7 +2,7 @@
  * VeSync API Device Library
  */
 
-import { Helpers, API_RATE_LIMIT, DEFAULT_TZ, setApiBaseUrl, getApiBaseUrl, generateAppId, getRegionFromCountryCode, setCurrentRegion, getCurrentRegion, REGION_ENDPOINTS } from './helpers';
+import { Helpers, API_RATE_LIMIT, DEFAULT_TZ, setApiBaseUrl, getApiBaseUrl, generateAppId, getRegionFromCountryCode, setCurrentRegion, getCurrentRegion, REGION_ENDPOINTS, getCountryCodeFromRegion } from './helpers';
 import { VeSyncBaseDevice } from './vesyncBaseDevice';
 import { fanModules } from './vesyncFanImpl';
 import { outletModules } from './vesyncOutletImpl';
@@ -171,6 +171,8 @@ export class VeSync {
     enabled: boolean;
     updateInterval: number;
     timeZone: string;
+    authFlowUsed?: 'legacy' | 'new';  // Track which auth flow was used
+    apiBaseUrl?: string;  // Track which API endpoint is being used
 
     fans: VeSyncBaseDevice[];
     outlets: VeSyncBaseDevice[];
@@ -183,31 +185,54 @@ export class VeSync {
      * @param username - VeSync account username
      * @param password - VeSync account password
      * @param timeZone - Optional timezone for device operations (defaults to America/New_York)
-     * @param debug - Optional debug mode flag
-     * @param redact - Optional redact mode flag
-     * @param apiUrl - Optional API base URL override
-     * @param customLogger - Optional custom logger implementation
-     * @param excludeConfig - Optional device exclusion configuration
+     * @param optionsOrDebug - Either options object or debug flag for backward compatibility
+     * @param redact - Optional redact mode flag (used when optionsOrDebug is boolean)
+     * @param apiUrl - Optional API base URL override (used when optionsOrDebug is boolean)
+     * @param customLogger - Optional custom logger implementation (used when optionsOrDebug is boolean)
+     * @param excludeConfig - Optional device exclusion configuration (used when optionsOrDebug is boolean)
      */
     constructor(
         username: string,
         password: string,
         timeZone: string = DEFAULT_TZ,
-        debug = false,
+        optionsOrDebug: boolean | {
+            debug?: boolean;
+            redact?: boolean;
+            apiUrl?: string;
+            customLogger?: Logger;
+            excludeConfig?: ExcludeConfig;
+            region?: string;
+            debugMode?: boolean;  // Alias for debug
+        } = false,
         redact = true,
         apiUrl?: string,
         customLogger?: Logger,
         excludeConfig?: ExcludeConfig
     ) {
-        this._debug = debug;
-        this._redact = redact;
+        // Handle options object or backward compatible parameters
+        let options: any = {};
+        if (typeof optionsOrDebug === 'object' && optionsOrDebug !== null) {
+            // Using new options pattern
+            options = optionsOrDebug;
+            this._debug = options.debug || options.debugMode || false;
+            this._redact = options.redact !== undefined ? options.redact : true;
+            this._excludeConfig = options.excludeConfig || null;
+            this._region = options.region || 'US';
+            customLogger = options.customLogger;
+            apiUrl = options.apiUrl;
+        } else {
+            // Using old parameter pattern for backward compatibility
+            this._debug = optionsOrDebug as boolean;
+            this._redact = redact;
+            this._excludeConfig = excludeConfig || null;
+            this._region = 'US';
+        }
+
         this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
         this._energyCheck = true;
         this._lastUpdateTs = null;
         this._inProcess = false;
-        this._excludeConfig = excludeConfig || null;
         this._appId = generateAppId();
-        this._region = 'US';
 
         this.username = username;
         this.password = password;
@@ -245,13 +270,21 @@ export class VeSync {
             logger.debug('Time zone is not a string');
         }
 
-        // Set custom API URL if provided, otherwise use default US endpoint
+        // Set custom API URL if provided, otherwise use region-based endpoint
         if (apiUrl) {
             setApiBaseUrl(apiUrl);
         } else {
-            // Start with US endpoint as default
-            setApiBaseUrl('https://smartapi.vesync.com');
-            setCurrentRegion('US');
+            // Set endpoint based on region
+            const regionEndpoints: Record<string, string> = {
+                'US': 'https://smartapi.vesync.com',
+                'EU': 'https://smartapi.vesync.eu',
+                'CA': 'https://smartapi.vesync.com',
+                'MX': 'https://smartapi.vesync.com',
+                'JP': 'https://smartapi.vesync.com'
+            };
+            const endpoint = regionEndpoints[this._region] || 'https://smartapi.vesync.com';
+            setApiBaseUrl(endpoint);
+            setCurrentRegion(this._region);
         }
 
         // Set custom logger if provided
@@ -259,13 +292,7 @@ export class VeSync {
             setLogger(customLogger);
         }
 
-        if (debug) {
-            this.debug = true;
-        }
-
-        if (redact) {
-            this.redact = true;
-        }
+        // Debug and redact are already set above in the options handling
     }
 
     /**
@@ -548,22 +575,42 @@ export class VeSync {
             try {
                 logger.debug(`Authentication attempt ${attempt + 1} of ${retryAttempts}`);
 
-                // Try new authentication flow first
+                // First, try to detect user's region from email
+                const detectedRegion = getRegionFromCountryCode(getCountryCodeFromRegion(this._region, this.username));
+                if (detectedRegion !== this._region) {
+                    logger.debug(`Adjusting region from ${this._region} to ${detectedRegion} based on email domain`);
+                    this._region = detectedRegion;
+                    setCurrentRegion(detectedRegion);
+                }
+
+                // Try new authentication flow first with detected region
                 let [success, token, accountId, countryCode] = await Helpers.authNewFlow(this, this._appId, this._region);
+                
+                // Track if new flow succeeded
+                if (success) {
+                    this.authFlowUsed = 'new';
+                }
 
                 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');
+                        logger.debug('Cross-region error detected, trying opposite region...');
+                        const alternateRegion = this._region === 'US' ? 'EU' : 'US';
+                        this._region = alternateRegion;
+                        setCurrentRegion(alternateRegion);
+                        [success, token, accountId, countryCode] = await Helpers.authNewFlow(this, this._appId, alternateRegion);
+                        if (success) {
+                            this.authFlowUsed = 'new';
+                        }
                     }
 
                     // 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 (success) {
+                            this.authFlowUsed = 'legacy';
+                        }
                     }
                 }
 
@@ -572,6 +619,7 @@ export class VeSync {
                     this.accountId = accountId;
                     this.countryCode = countryCode;
                     this.enabled = true;
+                    this.apiBaseUrl = getApiBaseUrl();  // Track the API endpoint being used
 
                     // Set region based on country code if we got one
                     if (countryCode) {
@@ -584,6 +632,7 @@ export class VeSync {
                     }
 
                     logger.debug('Authentication successful!', {
+                        authFlow: this.authFlowUsed,
                         region: this._region,
                         countryCode: countryCode,
                         endpoint: getApiBaseUrl()