homebridge-melcloud-control 4.0.0-beta.407 → 4.0.0-beta.409

package/package.json

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

package/src/melcloud.js

@@ -277,7 +277,7 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    async connectToMelCloudHome() {
+    async connectToMelCloudHome1() {
         try {
             const melCloudHomeToken = new MelCloudHomeToken({
                 user: this.user,
@@ -289,11 +289,11 @@ class MelCloud extends EventEmitter {
                 .on('warn', warn => this.emit('warn', warn))
                 .on('error', error => this.emit('error', error));
 
-            //const { codeVerifier, url } = await melCloudHomeToken.buildAuthorizeUrl();
-            //const code = await melCloudHomeToken.loginToMelCloudHome(url);
-            const token = await melCloudHomeToken.getTokens(this.user, this.passwd);
+            const { codeVerifier, url } = await melCloudHomeToken.buildAuthorizeUrl();
+            const code = await melCloudHomeToken.loginToMelCloudHome(url);
+            const token = await melCloudHomeToken.getTokens(code, codeVerifier);
 
-            const accountInfo = { ContextKey: token, UseFahrenheit: false };
+            const accountInfo = { ContextKey: code, UseFahrenheit: false };
             this.contextKey = code;
 
             return accountInfo
@@ -302,7 +302,7 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    async connectToMelCloudHome1(refresh = false) {
+    async connectToMelCloudHome(refresh = false) {
         if (this.logDebug) this.emit('debug', `Connecting to MELCloud Home`);
 
         let browser;

package/src/melcloudhometoken.js

@@ -1,203 +1,227 @@
 import axios from 'axios';
 import crypto from 'crypto';
-import { CookieJar } from 'tough-cookie';
 import { wrapper } from 'axios-cookiejar-support';
+import { CookieJar } from 'tough-cookie';
+import { JSDOM } from 'jsdom';
 import EventEmitter from 'events';
 
 const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
 const CLIENT_ID = 'homemobile';
 const REDIRECT_URI = 'melcloudhome://';
-const SCOPE = 'openid profile email';
-const AUTH_BASE = 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com';
-const TOKEN_URL = `${AUTH_BASE}/oauth2/token`;
-const AUTHORIZE_URL = `${AUTH_BASE}/login?`;
+const SCOPE = 'openid profile email offline_access IdentityServerApi';
+const TOKEN_ENDPOINT = 'https://auth.melcloudhome.com/connect/token';
+const AUTHORIZE_ENDPOINT = 'https://auth.melcloudhome.com/connect/authorize';
 
 class MelCloudHomeToken extends EventEmitter {
-    constructor() {
+    constructor(config) {
         super();
-        this.cookieJar = new CookieJar();
-        this.http = wrapper(axios.create({ jar: this.cookieJar }));
+        this.user = config.user;
+        this.passwd = config.passwd;
+        this.logWarn = config.logWarn;
+        this.logError = config.logError;
+
+        const jar = new CookieJar();
+        this.client = wrapper(axios.create({ jar, withCredentials: true }));
+        this.client.defaults.headers['User-Agent'] = MOBILE_USER_AGENT;
     }
 
-    // --- Utility: generate PKCE pair ---
-    _generatePkcePair() {
+    generatePKCE() {
         const verifier = crypto.randomBytes(32).toString('base64url');
-        const challenge = crypto
-            .createHash('sha256')
-            .update(verifier)
-            .digest('base64url');
+        const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
         return { verifier, challenge };
     }
 
-    // --- Utility: extract CSRF token from HTML ---
-    _extractCsrf(html) {
-        if (typeof html !== 'string') return null;
-        const match = html.match(/name=['"]_csrf['"][^>]*value=['"]([^'"]+)['"]/i);
-        return match ? match[1] : null;
+    generateState() {
+        return crypto.randomBytes(32).toString('hex');
     }
 
-    // --- GET request with redirect + cookie management ---
-    async _get(url, depth = 0) {
-        const cookies = await this.cookieJar.getCookieString(url);
-        const resp = await this.http.get(url, {
-            headers: {
-                'User-Agent': MOBILE_USER_AGENT,
-                Accept:
-                    'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-                Cookie: cookies,
-            },
-            maxRedirects: 0,
-            validateStatus: () => true,
-            responseType: 'text',
-            transformResponse: [(d) => d],
-        });
+    async buildAuthorizeUrl() {
+        const pkce = this.generatePKCE();
+        const state = this.generateState();
 
-        // Save cookies
-        if (resp.headers['set-cookie']) {
-            await Promise.all(
-                resp.headers['set-cookie'].map((c) =>
-                    this.cookieJar.setCookie(c, url)
-                )
-            );
-        }
-
-        // Follow redirect manually
-        if (
-            resp.status >= 300 &&
-            resp.status < 400 &&
-            resp.headers.location &&
-            depth < 5
-        ) {
-            const nextUrl = new URL(resp.headers.location, url).href;
-            console.log(`[OAuth] Redirect → ${nextUrl}`);
-            return this._get(nextUrl, depth + 1);
-        }
+        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 resp;
+        return { url: authUrl.toString(), codeVerifier: pkce.verifier };
     }
 
-    // --- POST request helper ---
-    async _post(url, data, headers = {}) {
-        const cookies = await this.cookieJar.getCookieString(url);
-        const resp = await this.http.post(url, data, {
-            headers: {
-                'User-Agent': MOBILE_USER_AGENT,
-                'Content-Type': 'application/x-www-form-urlencoded',
-                Cookie: cookies,
-                ...headers,
-            },
-            maxRedirects: 0,
-            validateStatus: () => true,
-            responseType: 'text',
-            transformResponse: [(d) => d],
-        });
-
-        if (resp.headers['set-cookie']) {
-            await Promise.all(
-                resp.headers['set-cookie'].map((c) =>
-                    this.cookieJar.setCookie(c, url)
-                )
-            );
-        }
-
-        return resp;
-    }
+    async loginToMelCloudHome(authUrl) {
+        try {
+            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;
+
+            if (!csrf) {
+                this.emit('warn', 'CSRF token not found');
+                return null;
+            }
+
+            const formData = new URLSearchParams({
+                _csrf: csrf,
+                username: this.user,
+                password: this.passwd
+            });
 
-    // --- Main login flow ---
-    async getTokens(email, password) {
-        const { verifier, challenge } = this._generatePkcePair();
-
-        // Build authorize URL
-        const authUrl =
-            `${AUTH_BASE}/oauth2/authorize?` +
-            new URLSearchParams({
-                client_id: CLIENT_ID,
-                redirect_uri: REDIRECT_URI,
-                response_type: 'code',
-                scope: SCOPE,
-                code_challenge: challenge,
-                code_challenge_method: 'S256',
+            const response = await this.client.post(authUrl, formData.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': authUrl
+                },
+                maxRedirects: 0,
+                validateStatus: status => [200, 302, 400].includes(status)
             });
 
-        console.log(`[OAuth] Opening login page...`);
-        let resp = await this._get(authUrl);
-        if (resp.status >= 300 && resp.status < 400) {
-            const redirectUrl = new URL(resp.headers.location, AUTH_BASE).href;
-            console.log(`[OAuth] Redirected to: ${redirectUrl}`);
-            resp = await this._get(redirectUrl);
-        }
+            if (response.status === 400) {
+                this.emit('warn', `Login failed: ${response.data}`);
+                return null;
+            }
+
+            // 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));
+                }
+            );
 
-        // --- Extract CSRF token ---
-        const csrf = this._extractCsrf(resp.data);
-        if (!csrf) {
-            console.error('[OAuth] ❌ Cannot find CSRF token!');
-            console.log(resp.data.substring(0, 400));
-            throw new Error('Cannot find CSRF token');
-        }
+            if (code) this.emit('warn', `Authorization code obtained: ${code}`);
+            return code || null;
 
-        console.log(`[OAuth] Found CSRF token: ${csrf}`);
+        } catch (err) {
+            this.emit('warn', `loginToMelCloudHome error: ${err}`);
+            return null;
+        }
+    }
 
-        // --- Submit login form ---
-        const loginUrl = resp.request.res.responseUrl || `${AUTH_BASE}/login`;
-        const formData = new URLSearchParams({
-            _csrf: csrf,
-            username: email,
-            password: password,
+    async extractCodeFromResponse(data, headers, followRedirect) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const locationHeader = headers['location'] || headers['Location'];
+
+                // 1️⃣ Location header
+                if (locationHeader && locationHeader.startsWith('melcloudhome://')) {
+                    const match = locationHeader.match(/[?&]code=([^&]+)/);
+                    if (match) {
+                        this.emit('warn', `Found code in Location header: ${match[1]}`);
+                        resolve(match[1]);
+                        return;
+                    }
+                }
+
+                // 2️⃣ form_post HTML
+                const formCodeMatch = data.match(/name="code"\s+value="([^"]+)"/);
+                const formStateMatch = data.match(/name="state"\s+value="([^"]+)"/);
+                const formActionMatch = data.match(/action="([^"]+)"/);
+
+                if (formCodeMatch && formStateMatch && formActionMatch) {
+                    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}`);
+                        resolve(code);
+                        return;
+                    } catch (err) {
+                        this.emit('warn', `submitFormPost failed: ${err}`);
+                        reject(err);
+                        return;
+                    }
+                }
+
+                // 3️⃣ JS redirect in body
+                const bodyCodeMatch = data.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
+                if (bodyCodeMatch) {
+                    this.emit('warn', `Found code in body: ${bodyCodeMatch[1]}`);
+                    resolve(bodyCodeMatch[1]);
+                    return;
+                }
+
+                // 4️⃣ Follow redirect
+                if (locationHeader && ['301', '302', '303'].includes(headers['status'] || '')) {
+                    this.emit('warn', `Following redirect to ${locationHeader}`);
+                    try {
+                        const code = await followRedirect(locationHeader);
+                        resolve(code);
+                        return;
+                    } catch (err) {
+                        this.emit('warn', `Follow redirect failed: ${err}`);
+                        reject(err);
+                        return;
+                    }
+                }
+
+                this.emit('warn', 'Authorization code not found in response');
+                reject(new Error('Authorization code not found'));
+            } catch (err) {
+                this.emit('warn', `extractCodeFromResponse error: ${err}`);
+                reject(err);
+            }
         });
+    }
 
-        console.log(`[OAuth] Submitting login form...`);
-        const loginResp = await this._post(loginUrl, formData.toString());
-
-        if (loginResp.status >= 300 && loginResp.status < 400) {
-            const redirectUrl = new URL(loginResp.headers.location, AUTH_BASE).href;
-            console.log(`[OAuth] Login redirect → ${redirectUrl}`);
-
-            // Extract code from redirect URL
-            const codeMatch = redirectUrl.match(/[?&]code=([^&]+)/);
-            if (!codeMatch) throw new Error('No code found after login redirect');
-            const code = codeMatch[1];
-            console.log(`[OAuth] ✅ Got authorization code: ${code}`);
+    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)
+        });
 
-            // Exchange code for token
-            return this.exchangeToken(code, verifier);
+        const location = res.headers['location'];
+        if (location) {
+            const match = location.match(/[?&]code=([^&]+)/);
+            if (match) return match[1];
         }
 
-        console.error('[OAuth] ❌ Unexpected status on login:', loginResp.status);
-        console.log(loginResp.data.substring(0, 400));
-        throw new Error('Unexpected status on login page');
+        this.emit('warn', 'Code not found after form_post submission');
+        throw new Error('Code not found after form_post submission');
     }
 
-    // --- Exchange code for access token ---
-    async exchangeToken(code, verifier) {
-        console.log('[OAuth] Exchanging code for token...');
-
-        const body = new URLSearchParams({
+    async getTokens(code, codeVerifier) {
+        const tokenData = new URLSearchParams({
             grant_type: 'authorization_code',
-            client_id: CLIENT_ID,
+            code: code,
             redirect_uri: REDIRECT_URI,
-            code,
-            code_verifier: verifier,
+            client_id: CLIENT_ID,
+            code_verifier: codeVerifier
         });
 
-        const resp = await this.http.post(TOKEN_URL, body.toString(), {
-            headers: {
-                'User-Agent': MOBILE_USER_AGENT,
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-        });
+        try {
+            const tokenResponse = await this.client.post(TOKEN_ENDPOINT, tokenData.toString(), {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Authorization': 'Basic aG9tZW1vYmlsZTo='
+                }
+            });
 
-        if (resp.status !== 200) {
-            console.error('[OAuth] ❌ Token exchange failed:', resp.status);
-            console.log(resp.data);
-            throw new Error('Token exchange failed');
-        }
+            const tokens = tokenResponse.data;
+            this.emit('warn', `Token obtained: ${JSON.stringify(tokens)}`);
+            return tokens;
 
-        console.log('[OAuth] ✅ Token response received');
-        return resp.data;
+        } catch (err) {
+            throw new Error(`Failed to obtain OAuth token: ${err}`);
+        }
     }
 }
 
-
 export default MelCloudHomeToken;