homebridge-melcloud-control 4.4.1-beta.22 → 4.4.1-beta.23

package/CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Changes
 
+- stability and performance improvements
 - bump dependencies
 - config schema updated
 - redme updated

package/package.json

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

package/src/melcloudhome.js

@@ -9,6 +9,9 @@ import Functions from './functions.js';
 import { ApiUrls, LanguageLocaleMap } from './constants.js';
 const execPromise = promisify(exec);
 
+const crypto = require('crypto');
+const { URL } = require('url');
+
 class MelCloudHome extends EventEmitter {
     constructor(account, accountFile, buildingsFile, pluginStart = false) {
         super();
@@ -28,6 +31,8 @@ class MelCloudHome extends EventEmitter {
         this.socketConnected = false;
         this.heartbeat = null;
 
+        this.cookies = [];
+
         this.functions = new Functions(this.logWarn, this.logError, this.logDebug)
             .on('warn', warn => this.emit('warn', warn))
             .on('error', error => this.emit('error', error))
@@ -215,7 +220,7 @@ class MelCloudHome extends EventEmitter {
         }
     }
 
-    async connect() {
+    async connect1() {
         if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
         const GLOBAL_TIMEOUT = 120000;
 
@@ -421,7 +426,7 @@ class MelCloudHome extends EventEmitter {
                 baseURL: ApiUrls.Home.Base,
                 timeout: 30000,
                 headers: headers
-            })
+            });
             this.emit('client', this.client);
 
             accountInfo.State = true;
@@ -440,6 +445,199 @@ class MelCloudHome extends EventEmitter {
             }
         }
     }
+
+
+    async axiosRequest(url, options, jar, maxRedirects = 10) {
+        let currentUrl = url;
+
+        for (let i = 0; i < maxRedirects; i++) {
+            const response = await axios({
+                url: currentUrl,
+                method: options.method || 'GET',
+                data: options.body,
+                headers: {
+                    ...options.headers,
+                    ...(jar.headerFor(currentUrl) && { Cookie: jar.headerFor(currentUrl) }),
+                },
+                validateStatus: () => true,
+                maxRedirects: 0,
+                responseType: 'text',
+            });
+
+            jar.addFromHeader(response.headers['set-cookie'], currentUrl);
+
+            if ([301, 302, 303, 307, 308].includes(response.status)) {
+                const location = response.headers.location;
+                if (!location) break;
+
+                if (location.startsWith('melcloudhome://')) {
+                    return { url: location, data: response.data };
+                }
+
+                currentUrl = location.startsWith('http')
+                    ? location
+                    : new URL(location, currentUrl).toString();
+
+                options.method = 'GET';
+                options.body = undefined;
+                continue;
+            }
+
+            return { url: currentUrl, data: response.data };
+        }
+
+        throw new Error('Too many redirects');
+    }
+
+    async loginWithCredentials(email, password) {
+        const jar = new CookieJar();
+
+        const userAgent =
+            'Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile Safari/604.1';
+
+        const codeVerifier = crypto.randomBytes(32).toString('base64url');
+        const codeChallenge = crypto
+            .createHash('sha256')
+            .update(codeVerifier)
+            .digest('base64url');
+
+        const authUrl =
+            'https://auth.melcloudhome.com/connect/authorize?' +
+            new URLSearchParams({
+                client_id: 'homemobile',
+                redirect_uri: 'melcloudhome://',
+                response_type: 'code',
+                scope: 'openid profile email offline_access IdentityServerApi',
+                code_challenge: codeChallenge,
+                code_challenge_method: 'S256',
+            }).toString();
+
+        // STEP 1 – get login page
+        const loginPage = await axiosRequest(authUrl, {
+            headers: { 'User-Agent': userAgent },
+        }, jar);
+
+        const csrfMatch =
+            loginPage.data.match(/name="(_csrf|__RequestVerificationToken)".*?value="([^"]+)"/);
+
+        if (!csrfMatch) throw new Error('CSRF token not found');
+        const csrfToken = csrfMatch[2];
+
+        // STEP 2 – submit credentials
+        const form = new URLSearchParams({
+            _csrf: csrfToken,
+            username: email,
+            password,
+        }).toString();
+
+        const loginResult = await axiosRequest(loginPage.url, {
+            method: 'POST',
+            headers: {
+                'User-Agent': userAgent,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Content-Length': Buffer.byteLength(form),
+            },
+            body: form,
+        }, jar);
+
+        if (!loginResult.url.startsWith('melcloudhome://')) {
+            throw new Error('OAuth redirect not received');
+        }
+
+        const code = new URL(loginResult.url).searchParams.get('code');
+        if (!code) throw new Error('Authorization code missing');
+
+        // STEP 3 – exchange token
+        const tokenResponse = await axios.post(
+            'https://auth.melcloudhome.com/connect/token',
+            new URLSearchParams({
+                grant_type: 'authorization_code',
+                client_id: 'homemobile',
+                redirect_uri: 'melcloudhome://',
+                code,
+                code_verifier: codeVerifier,
+            }).toString(),
+            {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Authorization': 'Basic aG9tZW1vYmlsZTo=',
+                },
+            },
+        );
+
+        if (!tokenResponse.data.refresh_token) {
+            throw new Error('No refresh token returned');
+        }
+
+        return {
+            refreshToken: tokenResponse.data.refresh_token,
+            accessToken: tokenResponse.data.access_token,
+            expiresIn: tokenResponse.data.expires_in,
+        };
+    }
+
+    addFromHeader(setCookie, url) {
+        if (!setCookie) return;
+        const urlObj = new URL(url);
+        const cookies = Array.isArray(setCookie) ? setCookie : [setCookie];
+
+        for (const header of cookies) {
+            const parts = header.split(';').map(p => p.trim());
+            const [name, value] = parts[0].split('=');
+
+            const cookie = {
+                name,
+                value,
+                domain: urlObj.hostname,
+                path: '/',
+                expires: null,
+            };
+
+            for (const part of parts.slice(1)) {
+                const [k, v] = part.split('=');
+                if (!k) continue;
+                const key = k.toLowerCase();
+                if (key === 'domain') cookie.domain = v;
+                if (key === 'path') cookie.path = v;
+                if (key === 'expires') cookie.expires = new Date(v);
+                if (key === 'max-age') cookie.expires = new Date(Date.now() + Number(v) * 1000);
+            }
+
+            this.cookies = this.cookies.filter(
+                c => !(c.name === cookie.name && c.domain === cookie.domain && c.path === cookie.path),
+            );
+            this.cookies.push(cookie);
+        }
+    }
+
+    headerFor(url) {
+        const urlObj = new URL(url);
+        const now = Date.now();
+
+        return this.cookies
+            .filter(c =>
+                (!c.expires || c.expires.getTime() > now) &&
+                urlObj.hostname.endsWith(c.domain) &&
+                urlObj.pathname.startsWith(c.path),
+            )
+            .map(c => `${c.name}=${c.value}`)
+            .join('; ');
+    }
+
+    async connect() {
+        if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
+
+        try {
+            const accountInfo = { State: false, Info: '', Account: {}, UseFahrenheit: false };
+
+            const tokens = await loginWithCredentials(this.user, this.passwd);
+            this.emit('debug', `Tokens: ${JSON.stringify(tokens, null, 2)}`);
+            return accountInfo
+        } catch (error) {
+            throw new Error(`Connect error: ${error.message}`);
+        }
+    }
+
 }
 
 export default MelCloudHome;