tsvesync 1.4.1 → 1.4.3

package/dist/lib/vesync.js

@@ -11,7 +11,20 @@ const vesyncOutletImpl_1 = require("./vesyncOutletImpl");
 const vesyncSwitchImpl_1 = require("./vesyncSwitchImpl");
 const vesyncBulbImpl_1 = require("./vesyncBulbImpl");
 const logger_1 = require("./logger");
+const constants_1 = require("./constants");
 const DEFAULT_ENERGY_UPDATE_INTERVAL = 21600;
+function normalizeApiBaseUrl(apiBaseUrl) {
+    return apiBaseUrl.trim().replace(/\/+$/, '');
+}
+const KNOWN_API_BASE_URLS = new Set(Object.values(helpers_1.REGION_ENDPOINTS).map(normalizeApiBaseUrl));
+function inferRegionFromApiBaseUrl(apiBaseUrl) {
+    const normalized = normalizeApiBaseUrl(apiBaseUrl).toLowerCase();
+    if (normalized.includes('vesync.eu'))
+        return 'EU';
+    if (normalized.includes('vesync.com'))
+        return 'US';
+    return null;
+}
 /**
  * Create device instance based on type
  */
@@ -157,6 +170,7 @@ class VeSync {
             this._region = 'US';
             this._countryCodeOverride = null;
         }
+        this._apiUrlOverride = apiUrl || null;
         this._energyUpdateInterval = DEFAULT_ENERGY_UPDATE_INTERVAL;
         this._energyCheck = true;
         this._lastUpdateTs = null;
@@ -198,7 +212,7 @@ class VeSync {
         }
         // Set custom API URL if provided, otherwise use region-based endpoint
         if (apiUrl) {
-            (0, helpers_1.setApiBaseUrl)(apiUrl);
+            this.apiBaseUrl = apiUrl;
         }
         else {
             // If country code is provided, use it to determine the endpoint
@@ -208,16 +222,8 @@ class VeSync {
                 logger_1.logger.debug(`Country code ${this._countryCodeOverride} maps to ${endpointRegion} endpoint`);
             }
             // 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);
+            const endpoint = helpers_1.REGION_ENDPOINTS[this._region] || helpers_1.REGION_ENDPOINTS.US;
+            this.apiBaseUrl = endpoint;
         }
         // Set custom logger if provided
         if (customLogger) {
@@ -229,18 +235,56 @@ class VeSync {
      * Hydrate manager from a previously persisted session
      */
     hydrateSession(session) {
+        var _a;
         try {
-            if (session.apiBaseUrl) {
-                (0, helpers_1.setApiBaseUrl)(session.apiBaseUrl);
-                this.apiBaseUrl = session.apiBaseUrl;
-            }
-            if (session.region) {
-                this._region = session.region;
-                (0, helpers_1.setCurrentRegion)(session.region);
+            if (!(session === null || session === void 0 ? void 0 : session.token) || !(session === null || session === void 0 ? void 0 : session.accountId)) {
+                throw new Error('Session missing token/accountId');
             }
+            // Always hydrate core credentials first.
             this.token = session.token;
             this.accountId = session.accountId;
-            this.countryCode = session.countryCode || null;
+            this.countryCode = (_a = session.countryCode) !== null && _a !== void 0 ? _a : null;
+            this.authFlowUsed = session.authFlowUsed;
+            // pyvesync parity:
+            // pyvesync persists `current_region` and derives the API base URL per-request from that region.
+            // It does NOT treat a stored base URL as authoritative. For backwards compatibility with older
+            // sessions, we normalize the fields here:
+            // - Prefer stored `region` when present
+            // - Otherwise derive region from stored `countryCode` (same mapping as pyvesync)
+            // - Otherwise infer region from stored apiBaseUrl (best-effort)
+            const sessionBaseUrl = session.apiBaseUrl ? normalizeApiBaseUrl(session.apiBaseUrl) : null;
+            const sessionBaseUrlIsKnown = !!sessionBaseUrl && KNOWN_API_BASE_URLS.has(sessionBaseUrl);
+            // If the session contains a custom base URL (not a known regional URL) and the caller did not
+            // explicitly set an API override, treat it as an override so region switching doesn't clobber it.
+            if (!this._apiUrlOverride && sessionBaseUrl && !sessionBaseUrlIsKnown) {
+                this._apiUrlOverride = sessionBaseUrl;
+            }
+            // Apply base URL override if present (pyvesync API_BASE_URL-style override).
+            if (this._apiUrlOverride) {
+                this.apiBaseUrl = this._apiUrlOverride;
+            }
+            let hydratedRegion = null;
+            if (typeof session.region === 'string' && session.region in helpers_1.REGION_ENDPOINTS) {
+                hydratedRegion = session.region;
+            }
+            else if (typeof session.countryCode === 'string' && session.countryCode.trim()) {
+                hydratedRegion = (0, helpers_1.getRegionFromCountryCode)(session.countryCode);
+            }
+            else if (sessionBaseUrl) {
+                hydratedRegion = inferRegionFromApiBaseUrl(sessionBaseUrl);
+            }
+            if (hydratedRegion && hydratedRegion in helpers_1.REGION_ENDPOINTS) {
+                this._region = hydratedRegion;
+            }
+            // Derive the API base URL from region unless explicitly overridden.
+            if (!this._apiUrlOverride) {
+                const endpoint = helpers_1.REGION_ENDPOINTS[this._region] || helpers_1.REGION_ENDPOINTS.US;
+                this.apiBaseUrl = endpoint;
+            }
+            else if (!this.apiBaseUrl && sessionBaseUrl) {
+                // Fallback: keep the persisted base URL if we have no other source.
+                this.apiBaseUrl = sessionBaseUrl;
+            }
             this.enabled = true;
         }
         catch (e) {
@@ -312,13 +356,21 @@ class VeSync {
     get region() {
         return this._region;
     }
+    /**
+     * Return the configured API URL override, if any.
+     */
+    get apiUrlOverride() {
+        return this._apiUrlOverride;
+    }
     /**
      * Set region and update API endpoint
      */
     set region(region) {
         if (region in helpers_1.REGION_ENDPOINTS) {
             this._region = region;
-            (0, helpers_1.setCurrentRegion)(region);
+            if (!this._apiUrlOverride) {
+                this.apiBaseUrl = helpers_1.REGION_ENDPOINTS[region];
+            }
         }
     }
     /**
@@ -437,7 +489,7 @@ class VeSync {
      * Get list of VeSync devices
      */
     async getDevices() {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this.enabled) {
             logger_1.logger.error('Not logged in to VeSync');
             return false;
@@ -445,16 +497,96 @@ class VeSync {
         this._inProcess = true;
         let success = false;
         try {
-            const [response] = await helpers_1.Helpers.callApi('/cloud/v2/deviceManaged/devices', 'post', helpers_1.Helpers.reqBody(this, 'devicelist'), helpers_1.Helpers.reqHeaders(this), this);
+            const fetchDeviceList = async () => {
+                return await helpers_1.Helpers.callApi('/cloud/v1/deviceManaged/devices', 'post', helpers_1.Helpers.reqBody(this, 'devicelist'), helpers_1.Helpers.reqHeaderBypass(), this);
+            };
+            const originalRegion = this._region;
+            let didRetryToken = false;
+            let didRetryCrossRegion = false;
+            let response;
+            let status;
+            [response, status] = await fetchDeviceList();
+            // Handle VeSync API codes similarly to pyvesync:
+            // - TOKEN_ERROR triggers a reauth + retry
+            // - CROSS_REGION triggers a region correction + retry
+            //
+            // pyvesync reference:
+            // - Token error retry: `pyvesync/vesync.py:async_call_api` (ErrorTypes.TOKEN_ERROR)
+            // - Region correction: `pyvesync/auth.py:_exchange_authorization_code` (ErrorTypes.CROSS_REGION)
+            while (true) {
+                if (!response || status !== 200) {
+                    break;
+                }
+                const code = response === null || response === void 0 ? void 0 : response.code;
+                if (typeof code === 'number' && code !== 0) {
+                    if (!didRetryToken && (0, constants_1.isTokenError)(code)) {
+                        didRetryToken = true;
+                        logger_1.logger.warn('Device list request returned token error; re-authenticating and retrying (pyvesync parity)', {
+                            code,
+                            msg: response === null || response === void 0 ? void 0 : response.msg,
+                            region: this._region,
+                            endpoint: this.apiBaseUrl
+                        });
+                        const reloginOk = await this.login();
+                        if (!reloginOk) {
+                            this.enabled = false;
+                            return false;
+                        }
+                        [response, status] = await fetchDeviceList();
+                        continue;
+                    }
+                    if (!didRetryCrossRegion && (0, constants_1.isCrossRegionError)(code) && !this.apiUrlOverride) {
+                        didRetryCrossRegion = true;
+                        const serverRegion = (_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.currentRegion;
+                        const normalizedServerRegion = typeof serverRegion === 'string' ? serverRegion.trim().toUpperCase() : null;
+                        const nextRegion = normalizedServerRegion && normalizedServerRegion in helpers_1.REGION_ENDPOINTS
+                            ? normalizedServerRegion
+                            : (this._region === 'US' ? 'EU' : 'US');
+                        logger_1.logger.warn('Device list request returned cross-region error; retrying against corrected endpoint (pyvesync-style)', {
+                            code,
+                            msg: response === null || response === void 0 ? void 0 : response.msg,
+                            region: this._region,
+                            endpoint: this.apiBaseUrl,
+                            serverRegion: normalizedServerRegion,
+                            nextRegion
+                        });
+                        this.region = nextRegion;
+                        [response, status] = await fetchDeviceList();
+                        // If this was a best-effort alternate-region guess (no serverRegion provided) and it
+                        // didn't help, revert so we don't leave the manager stuck on the wrong endpoint.
+                        if (!normalizedServerRegion && (!response || response.code !== 0)) {
+                            this.region = originalRegion;
+                        }
+                        continue;
+                    }
+                }
+                break;
+            }
             if (!response) {
                 logger_1.logger.error('No response received from VeSync API');
                 return false;
             }
-            if (response.error) {
-                logger_1.logger.error('API error:', response.msg || 'Unknown error');
+            if (status !== 200) {
+                logger_1.logger.error('Device list request failed with non-200 status:', {
+                    status,
+                    code: response === null || response === void 0 ? void 0 : response.code,
+                    msg: response === null || response === void 0 ? void 0 : response.msg,
+                    region: this._region,
+                    endpoint: this.apiBaseUrl
+                });
+                return false;
+            }
+            if (typeof response.code === 'number' && response.code !== 0) {
+                logger_1.logger.error('Device list request returned error code:', {
+                    status,
+                    code: response.code,
+                    msg: response === null || response === void 0 ? void 0 : response.msg,
+                    region: this._region,
+                    endpoint: this.apiBaseUrl
+                });
                 return false;
             }
-            if (!((_a = response.result) === null || _a === void 0 ? void 0 : _a.list)) {
+            if (!((_b = response.result) === null || _b === void 0 ? void 0 : _b.list)) {
                 logger_1.logger.error('No device list found in response');
                 return false;
             }
@@ -484,7 +616,7 @@ class VeSync {
                 // Log summary statistics
                 logger_1.logger.debug('\nSummary Statistics:');
                 logger_1.logger.debug('-------------------');
-                logger_1.logger.debug(`Total Devices: ${((_b = this.devices) === null || _b === void 0 ? void 0 : _b.length) || 0}`);
+                logger_1.logger.debug(`Total Devices: ${((_c = this.devices) === null || _c === void 0 ? void 0 : _c.length) || 0}`);
                 for (const [category, devices] of Object.entries(this._devList)) {
                     logger_1.logger.debug(`${category}: ${devices.length} devices`);
                 }
@@ -524,8 +656,12 @@ 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 with detected region
-                    let [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, this._region, this._countryCodeOverride || undefined);
+                    // Try new authentication flow first with detected region.
+                    // NOTE: authNewFlow may temporarily change `this.region` during pyvesync-style
+                    // cross-region Step 2 retry. Capture the attempted region so our fallback logic
+                    // (try opposite endpoint) doesn't get confused by that internal mutation.
+                    const attemptedRegion = this._region;
+                    let [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, attemptedRegion, this._countryCodeOverride || undefined);
                     // Track if new flow succeeded
                     if (success) {
                         this.authFlowUsed = 'new';
@@ -538,10 +674,11 @@ class VeSync {
                         }
                         // Check if we need to try a different region
                         if (countryCode === 'cross_region' || countryCode === 'cross_region_retry') {
-                            // Mark current region as tried
-                            triedRegions.add(this._region);
+                            // Mark attempted region as tried (do not rely on `this._region`, which may have been
+                            // mutated by authNewFlow during pyvesync-style cross-region handling).
+                            triedRegions.add(attemptedRegion);
                             logger_1.logger.debug('Cross-region error detected, trying opposite region...');
-                            const alternateRegion = this._region === 'US' ? 'EU' : 'US';
+                            const alternateRegion = attemptedRegion === 'US' ? 'EU' : 'US';
                             // Check if we've already tried this region to prevent infinite loops
                             if (triedRegions.has(alternateRegion)) {
                                 logger_1.logger.error('═══════════════════════════════════════════════════════════════');
@@ -568,18 +705,9 @@ class VeSync {
                                 logger_1.logger.error('═══════════════════════════════════════════════════════════════');
                                 return false;
                             }
-                            logger_1.logger.debug(`Switching from ${this._region} to ${alternateRegion} region`);
-                            this._region = alternateRegion;
-                            (0, helpers_1.setCurrentRegion)(alternateRegion);
-                            // Update the API endpoint for the new region
-                            const regionEndpoints = {
-                                'US': 'https://smartapi.vesync.com',
-                                'EU': 'https://smartapi.vesync.eu'
-                            };
-                            if (alternateRegion in regionEndpoints) {
-                                (0, helpers_1.setApiBaseUrl)(regionEndpoints[alternateRegion]);
-                                logger_1.logger.debug(`API endpoint set to ${regionEndpoints[alternateRegion]}`);
-                            }
+                            logger_1.logger.debug(`Switching from ${attemptedRegion} to ${alternateRegion} region`);
+                            this.region = alternateRegion;
+                            logger_1.logger.debug(`API endpoint set to ${this.apiBaseUrl}`);
                             // Retry with the alternate region
                             [success, token, accountId, countryCode] = await helpers_1.Helpers.authNewFlow(this, this._appId, alternateRegion, this._countryCodeOverride || undefined);
                             if (success) {
@@ -614,7 +742,7 @@ class VeSync {
                         this.accountId = accountId;
                         this.countryCode = countryCode;
                         this.enabled = true;
-                        this.apiBaseUrl = (0, helpers_1.getApiBaseUrl)(); // Track the API endpoint being used
+                        this.apiBaseUrl = this.apiBaseUrl || 'https://smartapi.vesync.com'; // Track the API endpoint being used
                         // Persist session details for reuse across restarts
                         this.emitTokenChange();
                         // DO NOT change the region/endpoint after successful authentication!
@@ -634,7 +762,7 @@ class VeSync {
                             authFlow: this.authFlowUsed,
                             region: this._region,
                             countryCode: countryCode,
-                            endpoint: (0, helpers_1.getApiBaseUrl)()
+                            endpoint: this.apiBaseUrl
                         });
                         return true;
                     }

package/package.json

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

package/src/lib/constants.ts

@@ -15,6 +15,12 @@ export const CROSS_REGION_ERROR_CODES = [
     -11261022,  // access region conflict error
 ];
 
+// Token/auth invalidation error codes
+// pyvesync parity: `-11001000` maps to TOKEN_EXPIRED (invalid token)
+export const TOKEN_ERROR_CODES = [
+    -11001000,  // token expired/invalid
+];
+
 // Other error codes
 export const APP_VERSION_ERROR_CODES = [
     -11012022,  // app version is too low
@@ -32,4 +38,11 @@ export function isCredentialError(code: number): boolean {
  */
 export function isCrossRegionError(code: number): boolean {
     return CROSS_REGION_ERROR_CODES.includes(code);
-}
+}
+
+/**
+ * Check if an error code indicates the token is invalid/expired.
+ */
+export function isTokenError(code: number): boolean {
+    return TOKEN_ERROR_CODES.includes(code);
+}