homebridge-melcloud-control 4.0.0-beta.373 → 4.0.0-beta.374

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "4.0.0-beta.373",
+  "version": "4.0.0-beta.374",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",

package/src/melcloudhometoken.js

@@ -31,11 +31,7 @@ class MelCloudHomeToken extends EventEmitter {
     }
 
     async getLoginPage(authUrl) {
-        const res = await this.axiosInstance({
-            method: 'GET',
-            baseURL: authUrl,
-            maxRedirects: 10
-        });
+        const res = await this.axiosInstance.get(authUrl, { maxRedirects: 10 });
         return { url: res.request.res.responseUrl };
     }
 
@@ -86,47 +82,46 @@ class MelCloudHomeToken extends EventEmitter {
         try {
             const tokenData = new URLSearchParams({
                 grant_type: 'authorization_code',
-                code: code,
+                code,
                 redirect_uri: REDIRECT_URI,
                 client_id: CLIENT_ID,
                 code_verifier: codeVerifier,
             });
 
-            const tokenResponse = await this.axiosInstance(tokenData.toString(), {
-                method: 'POST',
-                baseURL: TOKEN_ENDPOINT,
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                    'Content-Length': tokenData.toString().length,
-                    'Authorization': 'Basic aG9tZW1vYmlsZTo=',
-                },
-            });
+            const response = await this.axiosInstance.post(
+                TOKEN_ENDPOINT,
+                tokenData.toString(),
+                {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Authorization': 'Basic aG9tZW1vYmlsZTo=', // optional, Cognito may ignore
+                    },
+                }
+            );
+
+            this.emit('warn', `Token response: ${JSON.stringify(response.data)}`);
+            return response.data;
 
-            const tokens = tokenResponse.data;
-            this.emit('warn', `Token ${JSON.stringify(tokens)}`);
-            return tokens;
         } catch (error) {
-            throw new Error(`Failed to obtain OAuth token: ${error}`);
+            throw new Error(`Failed to obtain OAuth token: ${error.response?.data || error.message}`);
         }
     }
 
+
     async loginToMelCloudHome(url) {
         try {
-            // Step 1: Pobierz stronę logowania, żeby uzyskać sesję + token _csrf
-            const getResp = await this.axiosInstance({
-                method: 'GET',
-                baseURL: url,
-                headers: {
-                    'Accept': 'text/html',
-                },
+            // Step 1: Pobierz stronę logowania
+            const getResp = await this.axiosInstance.get(url, {
+                headers: { 'Accept': 'text/html' },
                 withCredentials: true,
             });
 
-            const cookies = getResp.headers['set-cookie'] || [];
+            const cookies = (getResp.headers['set-cookie'] || []).map(c => c.split(';')[0]).join('; ');
             const dom = new JSDOM(getResp.data);
             const csrf = dom.window.document.querySelector('input[name="_csrf"]')?.value;
+
             if (!csrf) {
-                if (this.logWarn) this.emit('warn', `CSRF token not found`);
+                this.emit('warn', `CSRF token not found`);
                 return null;
             }
 
@@ -137,49 +132,66 @@ class MelCloudHomeToken extends EventEmitter {
                 password: this.passwd,
             });
 
-            if (this.logWarn) this.emit('warn', `Redirect URL: ${url}`);
-
-            // Step 3: Wyślij POST z danymi logowania
-            const response = await this.axiosInstance(formData.toString(), {
-                method: 'POST',
-                baseURL: url,
-                headers: {
-                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-                    'Accept-Language': 'en-US,en;q=0.9',
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                    'Content-Length': formData.toString().length,
-                    'Cookie': cookies,
-                    'Origin': 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com',
-                    'Referer': url,
-                },
-                maxRedirects: 10,
-                validateStatus: status => [200, 302, 400].includes(status),
-            });
+            // Step 3: Wyślij login POST
+            const postResp = await this.axiosInstance.post(
+                url,
+                formData.toString(),
+                {
+                    headers: {
+                        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Cookie': cookies,
+                        'Origin': 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com',
+                        'Referer': url,
+                    },
+                    maxRedirects: 0, // kontrolujmy redirecty ręcznie
+                    validateStatus: s => [200, 302, 400].includes(s),
+                }
+            );
 
-            if (response.status === 400) if (this.logWarn) this.emit('warn', `Login failed (bad request or invalid credentials: ${response.data}`);
-            if (response.status === 302 && response.headers.location) {
-                // Login success — mamy redirect z "code="
-                const redirectUrl = response.headers.location;
-                if (this.logWarn) this.emit('warn', `Redirect URL: ${redirectUrl}`);
-                if (this.logWarn) this.emit('warn', `Response headers: ${response.headers}`);
-
-                const match = redirectUrl.match(/[?&]code=([^&]+)/);
-                if (match) {
-                    const code = match[1];
-                    if (this.logWarn) this.emit('warn', `Redirect URL found code: ${code}`);
-                    return code;
-                } else {
-                    if (this.logWarn) this.emit('warn', `Redirect URL found, but no "code=" param: ${redirectUrl}`);
-                    return null;
+            if (postResp.status === 400) {
+                this.emit('warn', `Login failed: ${postResp.data}`);
+                return null;
+            }
+
+            let redirectUrl = postResp.headers.location;
+            let cookieChain = cookies;
+
+            // Step 4: Podążaj za przekierowaniami
+            for (let i = 0; i < 5 && redirectUrl; i++) {
+                const redirectResp = await this.axiosInstance.get(redirectUrl, {
+                    headers: { 'Cookie': cookieChain },
+                    maxRedirects: 0,
+                    validateStatus: s => [200, 302].includes(s),
+                });
+
+                // aktualizuj cookies
+                const newCookies = redirectResp.headers['set-cookie'] || [];
+                if (newCookies.length) {
+                    cookieChain += '; ' + newCookies.map(c => c.split(';')[0]).join('; ');
+                }
+
+                redirectUrl = redirectResp.headers.location;
+
+                if (redirectUrl && redirectUrl.includes('code=')) {
+                    const match = redirectUrl.match(/[?&]code=([^&]+)/);
+                    if (match) {
+                        const code = match[1];
+                        this.emit('warn', `Authorization code obtained: ${code}`);
+                        return code;
+                    }
                 }
             }
 
+            this.emit('warn', 'Login flow finished, but no code found');
             return null;
+
         } catch (error) {
-            throw new Error(`Login to MELCloud Home error: ${error}`);
+            throw new Error(`Login to MELCloud Home error: ${error.message}`);
         }
     }
 
+
     async buildAuthorizeUrl() {
         try {
             const pkce = this.generatePKCE();