homebridge-melcloud-control 4.0.0-beta.391 → 4.0.0-beta.392

package/package.json

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

package/src/melcloudhometoken.js

@@ -35,39 +35,79 @@ class MelCloudHomeToken extends EventEmitter {
         return crypto.randomBytes(32).toString('hex');
     }
 
-    async getLoginPage(authUrl) {
-        const res = await this.client.get(authUrl, { maxRedirects: 10 });
-        return { url: res.request.res.responseUrl };
+    async buildAuthorizeUrl() {
+        const pkce = this.generatePKCE();
+        const state = this.generateState();
+
+        const authUrl = new URL(AUTHORIZE_ENDPOINT);
+        authUrl.searchParams.set('client_id', CLIENT_ID);
+        authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('scope', SCOPE);
+        authUrl.searchParams.set('code_challenge', pkce.challenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('state', state);
+
+        return { url: authUrl.toString(), codeVerifier: pkce.verifier };
     }
 
-    async getTokens(code, codeVerifier) {
+    async loginToMelCloudHome(authUrl) {
         try {
-            const tokenData = new URLSearchParams({
-                grant_type: 'authorization_code',
-                code: code,
-                redirect_uri: REDIRECT_URI,
-                client_id: CLIENT_ID,
-                code_verifier: codeVerifier,
-            });
+            const getResp = await this.client.get(authUrl, { headers: { 'Accept': 'text/html' } });
+            const cookies = getResp.headers['set-cookie'] || [];
+            const dom = new JSDOM(getResp.data);
+            const csrf = dom.window.document.querySelector('input[name="_csrf"]')?.value;
 
-            this.emit('warn', `Code used: ${code}`);
-            this.emit('warn', `Verifier: ${codeVerifier}`);
-            this.emit('warn', `Redirect URI: ${REDIRECT_URI}`);
+            if (!csrf) {
+                this.emit('warn', 'CSRF token not found');
+                return null;
+            }
 
-            const tokenResponse = await this.client.post(TOKEN_ENDPOINT, tokenData.toString(), {
+            const formData = new URLSearchParams({
+                _csrf: csrf,
+                username: this.user,
+                password: this.passwd
+            });
+
+            const response = await this.client.post(authUrl, formData.toString(), {
                 headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded'
+                    'User-Agent': MOBILE_USER_AGENT,
+                    '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.join('; '),
+                    'Origin': 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com',
+                    'Referer': authUrl
                 },
+                maxRedirects: 0,
+                validateStatus: status => [200, 302, 400].includes(status)
             });
 
-            const tokens = tokenResponse.data;
-            this.emit('warn', `Token ${JSON.stringify(tokens)}`);
-            return tokens;
-        } catch (error) {
-            if (error.response) {
-                this.emit('warn', `Token error response: ${JSON.stringify(error.response.data)}`);
+            if (response.status === 400) {
+                this.emit('warn', `Login failed: ${response.data}`);
+                return null;
             }
-            throw new Error(`Failed to obtain OAuth token: ${error}`);
+
+            // Extract authorization code
+            const code = await this.extractCodeFromResponse(
+                response.data,
+                response.headers,
+                async (url) => {
+                    const r = await this.client.get(url, {
+                        maxRedirects: 0,
+                        validateStatus: status => [200, 302, 303].includes(status)
+                    });
+                    return this.extractCodeFromResponse(r.data, r.headers, async u => this.extractCodeFromResponse(r.data, r.headers, u));
+                }
+            );
+
+            if (code) this.emit('warn', `Authorization code obtained: ${code}`);
+            return code || null;
+
+        } catch (err) {
+            this.emit('warn', `loginToMelCloudHome error: ${err}`);
+            return null;
         }
     }
 
@@ -92,7 +132,7 @@ class MelCloudHomeToken extends EventEmitter {
                 const formActionMatch = data.match(/action="([^"]+)"/);
 
                 if (formCodeMatch && formStateMatch && formActionMatch) {
-                    this.emit('warn', 'Found form_post response, submitting to callback endpoint...');
+                    this.emit('warn', 'Found form_post, submitting...');
                     try {
                         const code = await this.submitFormPost(formActionMatch[1], formCodeMatch[1], formStateMatch[1]);
                         this.emit('warn', `submitFormPost returned code: ${code}`);
@@ -105,10 +145,10 @@ class MelCloudHomeToken extends EventEmitter {
                     }
                 }
 
-                // 3️⃣ JS redirect w body
+                // 3️⃣ JS redirect in body
                 const bodyCodeMatch = data.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
                 if (bodyCodeMatch) {
-                    this.emit('warn', `Found code in response body: ${bodyCodeMatch[1]}`);
+                    this.emit('warn', `Found code in body: ${bodyCodeMatch[1]}`);
                     resolve(bodyCodeMatch[1]);
                     return;
                 }
@@ -129,134 +169,55 @@ class MelCloudHomeToken extends EventEmitter {
 
                 this.emit('warn', 'Authorization code not found in response');
                 reject(new Error('Authorization code not found'));
-            } catch (error) {
-                this.emit('warn', `extractCodeFromResponse error: ${error}`);
-                reject(error);
+            } catch (err) {
+                this.emit('warn', `extractCodeFromResponse error: ${err}`);
+                reject(err);
             }
         });
     }
 
-    // submitFormPost w JS
     async submitFormPost(actionUrl, code, state) {
         const formData = new URLSearchParams({ code, state });
         this.emit('warn', `Submitting form_post to ${actionUrl}`);
         const res = await this.client.post(actionUrl, formData.toString(), {
             headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
             maxRedirects: 0,
-            validateStatus: status => [200, 302, 303].includes(status),
+            validateStatus: status => [200, 302, 303].includes(status)
         });
 
         const location = res.headers['location'];
         if (location) {
             const match = location.match(/[?&]code=([^&]+)/);
-            if (match) {
-                this.emit('warn', `Form post redirect returned code: ${match[1]}`);
-                return match[1];
-            }
+            if (match) return match[1];
         }
 
         this.emit('warn', 'Code not found after form_post submission');
         throw new Error('Code not found after form_post submission');
     }
 
+    async getTokens(code, codeVerifier) {
+        const tokenData = new URLSearchParams({
+            grant_type: 'authorization_code',
+            code: code,
+            redirect_uri: REDIRECT_URI,
+            client_id: CLIENT_ID,
+            code_verifier: codeVerifier
+        });
 
-    async loginToMelCloudHome(url) {
         try {
-            // Step 1: Pobierz stronę logowania
-            const getResp = await this.client.get(url, {
-                headers: { 'Accept': 'text/html' }
-            });
-
-            const cookies = getResp.headers['set-cookie'] || [];
-            const dom = new JSDOM(getResp.data);
-            const csrf = dom.window.document.querySelector('input[name="_csrf"]')?.value;
-            if (!csrf) {
-                this.emit('warn', `CSRF token not found`);
-                return null;
-            }
-
-            // Step 2: Przygotuj dane logowania
-            const formData = new URLSearchParams({
-                _csrf: csrf,
-                username: this.user,
-                password: this.passwd,
-            });
-
-            // Step 3: Wyślij POST z danymi logowania
-            const response = await this.client.post(url, formData.toString(), {
+            const tokenResponse = await this.client.post(TOKEN_ENDPOINT, tokenData.toString(), {
                 headers: {
-                    'User-Agent': MOBILE_USER_AGENT,
-                    '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.join('; '),
-                    'Origin': 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com',
-                    'Referer': url,
-                },
-                maxRedirects: 0,
-                validateStatus: status => [200, 302, 400].includes(status),
-            });
-
-            if (response.status === 400) {
-                this.emit('warn', `Login failed (bad request or invalid credentials): ${response.data}`);
-                return null;
-            }
-
-            // Step 4: Pobierz Authorization Code
-            if (response.status === 200 || response.status === 302) {
-                try {
-                    const code = await this.extractCodeFromResponse(
-                        response.data,          // HTML lub body
-                        response.headers,       // nagłówki
-                        async (url) => {        // followRedirect
-                            const r = await this.client.get(url, {
-                                maxRedirects: 0,
-                                validateStatus: status => [200, 302, 303].includes(status),
-                            });
-                            return this.extractCodeFromResponse(r.data, r.headers, followRedirect);
-                        }
-                    );
-
-                    if (code) {
-                        this.emit('warn', `Authorization code obtained: ${code}`);
-                        return code;
-                    } else {
-                        this.emit('warn', 'Authorization code not found in response');
-                        return null;
-                    }
-                } catch (err) {
-                    this.emit('warn', `extractCodeFromResponse error: ${err}`);
-                    return null;
+                    'Authorization': 'Basic aG9tZW1vYmlsZTo='
                 }
-            }
-
-            return null;
-
-        } catch (error) {
-            throw new Error(`Login to MELCloud Home error: ${error}`);
-        }
-    }
+            });
 
+            const tokens = tokenResponse.data;
+            this.emit('warn', `Token obtained: ${JSON.stringify(tokens)}`);
+            return tokens;
 
-    async buildAuthorizeUrl() {
-        try {
-            const pkce = this.generatePKCE();
-            const state = this.generateState();
-            const authUrl = new URL(AUTHORIZE_ENDPOINT);
-            authUrl.searchParams.set('client_id', CLIENT_ID);
-            authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
-            authUrl.searchParams.set('response_type', 'code');
-            authUrl.searchParams.set('scope', SCOPE);
-            authUrl.searchParams.set('code_challenge', pkce.challenge);
-            authUrl.searchParams.set('code_challenge_method', 'S256');
-            authUrl.searchParams.set('state', state);
-
-            const loginPage = await this.getLoginPage(authUrl.toString());
-            const data = { codeVerifier: pkce.verifier, url: loginPage.url }
-            return data;
-        } catch (error) {
-            throw new Error(`Failed to obtain OAuth link: ${error}`);
+        } catch (err) {
+            throw new Error(`Failed to obtain OAuth token: ${err}`);
         }
     }
 }
@@ -267,3 +228,4 @@ export default MelCloudHomeToken;
 
 
 
+