homebridge-melcloud-control 4.0.0-beta.250 → 4.0.0-beta.252

package/package.json

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

package/src/melcloudhometoken.js

@@ -1,225 +1,62 @@
-// oauth-helper-axios.js
 import https from 'https';
-import crypto from 'crypto';
-import { URL, URLSearchParams } from 'url';
-import { JSDOM } from 'jsdom';
+import { URLSearchParams } from 'url';
 
-const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
+const TOKEN_ENDPOINT = 'https://auth.melcloudhome.com/connect/token';
 const CLIENT_ID = 'homemobile';
-const REDIRECT_URI = 'melcloudhome://';
+const REDIRECT_URI = 'melcloudhome://signin-oidc-meu';
 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 {
-    constructor(log) {
-        this.log = log;
-    }
-
-    // --- PKCE ---
-    generatePKCE() {
-        const verifier = crypto.randomBytes(32).toString('base64url');
-        const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
-        return { verifier, challenge };
-    }
-
-    generateState() {
-        return crypto.randomBytes(32).toString('hex');
-    }
-
-    // --- HTTPS request with cookies ---
-    httpsRequest(url, options = {}, body = undefined, cookies = [], redirectCount = 0) {
-        if (redirectCount > 10) throw new Error('Too many redirects');
-
+    httpsRequest(url, options = {}, body = undefined) {
         return new Promise((resolve, reject) => {
-            const urlObj = new URL(url);
-            const reqOptions = {
-                ...options,
-                hostname: urlObj.hostname,
-                path: urlObj.pathname + urlObj.search,
-            };
-
-            if (!reqOptions.headers) reqOptions.headers = {};
-            if (cookies.length > 0) reqOptions.headers['Cookie'] = cookies.join('; ');
-
-            const req = https.request(reqOptions, (res) => {
-                const setCookie = res.headers['set-cookie'];
-                if (setCookie) {
-                    setCookie.forEach(c => {
-                        const name = c.split('=')[0];
-                        const idx = cookies.findIndex(x => x.startsWith(name + '='));
-                        if (idx >= 0) cookies[idx] = c.split(';')[0];
-                        else cookies.push(c.split(';')[0]);
-                    });
-                }
-
-                if ([301, 302, 303].includes(res.statusCode) && res.headers.location) {
-                    const redirectUrl = res.headers.location.startsWith('http')
-                        ? res.headers.location
-                        : `https://${urlObj.hostname}${res.headers.location}`;
-                    return resolve(this.httpsRequest(redirectUrl, options, undefined, cookies, redirectCount + 1));
-                }
-
+            const req = https.request(url, options, (res) => {
                 let data = '';
                 res.on('data', chunk => data += chunk);
-                res.on('end', () => resolve({ html: data, cookies, finalUrl: url }));
+                res.on('end', () => resolve({ statusCode: res.statusCode, body: data }));
             });
-
             req.on('error', reject);
             if (body) req.write(body);
             req.end();
         });
     }
 
-    // --- Get login page ---
-    async getLoginPage(authUrl) {
-        console.log('Getting login page...');
-        const resp = await this.httpsRequest(authUrl, {
-            method: 'GET',
-            headers: {
-                'User-Agent': MOBILE_USER_AGENT,
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            }
-        });
-
-        const dom = new JSDOM(resp.html);
-        const form = dom.window.document.querySelector('form');
-        if (!form) throw new Error('Login form not found');
-
-        return { form, cookies: resp.cookies, loginPageUrl: resp.finalUrl };
-    }
-
-    // --- Submit login with debug ---
-    async submitLogin(form, email, password, cookies, loginPageUrl) {
-        console.log('Submitting login credentials...');
-
-        // 1️⃣ Zbieramy wszystkie hidden inputy
-        const formData = new URLSearchParams();
-        form.querySelectorAll('input').forEach(input => {
-            const name = input.getAttribute('name');
-            if (name) formData.append(name, input.getAttribute('value') || '');
-        });
-
-        // Overwrite username/password
-        formData.set('username', email);
-        formData.set('password', password);
-
-        console.log('Login form data (hidden + credentials):');
-        for (const [key, value] of formData.entries()) {
-            console.log(`  ${key} = ${value}`);
-        }
-
-        const actionUrl = new URL(form.getAttribute('action'), loginPageUrl).toString();
-        const resp = await this.httpsRequest(actionUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
-        }, formData.toString(), cookies);
-
-        // 2️⃣ Obsługa form_post (Cognito auto-submit)
-        const domPost = new JSDOM(resp.html);
-        const postForm = domPost.window.document.querySelector('form');
-        if (postForm) {
-            const postData = new URLSearchParams();
-            postForm.querySelectorAll('input').forEach(input => {
-                const name = input.getAttribute('name');
-                if (name) postData.append(name, input.getAttribute('value') || '');
-            });
-
-            console.log('Form_post hidden inputs:');
-            for (const [key, value] of postData.entries()) {
-                console.log(`  ${key} = ${value}`);
-            }
-
-            const postAction = new URL(postForm.getAttribute('action'), resp.finalUrl).toString();
-            const postResp = await this.httpsRequest(postAction, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
-            }, postData.toString(), cookies);
-
-            // 3️⃣ Wyciągamy authorization code
-            let codeMatch = postResp.finalUrl.match(/[?&]code=([^&]+)/);
-            if (!codeMatch) codeMatch = postResp.html.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
-
-            if (codeMatch) {
-                const code = codeMatch[1];
-                console.log(`Authorization code obtained: ${code}`);
-                return code;
-            }
-        }
-
-        // Fallback: sprawdzamy resp finalUrl i body
-        let codeMatch = resp.finalUrl.match(/[?&]code=([^&]+)/);
-        if (!codeMatch) codeMatch = resp.html.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
-        if (codeMatch) {
-            const code = codeMatch[1];
-            console.log(`Authorization code obtained: ${code}`);
-            return code;
-        }
-
-        throw new Error('No authorization code found after login');
-    }
-
-    // --- Exchange code for tokens (debug) ---
-    async exchangeCodeForTokens(code, codeVerifier) {
-        console.log('Exchanging authorization code for tokens...');
-        console.log(`Authorization code: ${code}`);
-        console.log(`Code verifier: ${codeVerifier}`);
+    /**
+     * Get OAuth tokens using username/password directly (ROPC)
+     * Works in Node.js / Docker, no Puppeteer needed
+     */
+    async getTokensWithPassword(username, password) {
+        console.log('Obtaining OAuth tokens using password grant...');
 
-        const tokenData = new URLSearchParams({
-            grant_type: 'authorization_code',
-            code,
-            redirect_uri: REDIRECT_URI,
+        const params = new URLSearchParams({
+            grant_type: 'password',
             client_id: CLIENT_ID,
-            code_verifier: codeVerifier,
+            username,
+            password,
+            scope: SCOPE,
         });
 
-        const resp = await this.httpsRequest(TOKEN_ENDPOINT, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Content-Length': tokenData.toString().length,
-            }
-        }, tokenData.toString());
+        const headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Content-Length': params.toString().length,
+        };
+
+        const resp = await this.httpsRequest(TOKEN_ENDPOINT, { method: 'POST', headers }, params.toString());
 
-        console.log('Token endpoint response:', resp.html);
+        console.log('Token endpoint response:', resp.body);
 
-        let tokens;
-        try { tokens = JSON.parse(resp.html); }
-        catch (err) { console.log('Failed to parse token response'); throw err; }
+        const tokens = JSON.parse(resp.body);
 
         if (tokens.error) {
-           console.log('Token response error:', tokens);
-            throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error}`);
+            console.error('Token response error:', tokens);
+            throw new Error(`Token request failed: ${tokens.error_description || tokens.error}`);
         }
 
-        return tokens;
-    }
-
-    // --- Main flow ---
-    async getTokensWithCredentials(email, password) {
-        console.log('Obtaining OAuth tokens automatically...');
-        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 { form, cookies, loginPageUrl } = await this.getLoginPage(authUrl.toString());
-        const authCode = await this.submitLogin(form, email, password, cookies, loginPageUrl);
-        const tokens = await this.exchangeCodeForTokens(authCode, pkce.verifier);
-
         console.log('✓ Successfully obtained OAuth tokens');
         return tokens;
     }
-
 }
 
+
 export default MelCloudHomeToken;