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

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.251",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",

package/src/melcloudhometoken.js

@@ -1,4 +1,3 @@
-// oauth-helper-axios.js
 import https from 'https';
 import crypto from 'crypto';
 import { URL, URLSearchParams } from 'url';
@@ -6,220 +5,207 @@ import { JSDOM } from 'jsdom';
 
 const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
 const CLIENT_ID = 'homemobile';
-const REDIRECT_URI = 'melcloudhome://';
+// ⚠ Zmieniamy na redirect URI, który faktycznie akceptuje Cognito
+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');
-
-        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));
-                }
-
-                let data = '';
-                res.on('data', chunk => data += chunk);
-                res.on('end', () => resolve({ html: data, cookies, finalUrl: url }));
-            });
-
-            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}`);
+  constructor() {}
+
+  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');
+  }
+
+  httpsRequest(url, options = {}, body = undefined, cookies = [], redirectCount = 0) {
+    if (redirectCount > 10) throw new Error('Too many redirects');
+
+    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]);
+          });
         }
 
-        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;
-            }
+        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));
         }
 
-        // 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');
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve({ html: data, cookies, finalUrl: url }));
+      });
+
+      req.on('error', reject);
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+
+  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 };
+  }
+
+  async submitLogin(form, email, password, cookies, loginPageUrl) {
+    console.log('Submitting login credentials...');
+
+    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);
+
+    // Form_post auto-submit handling
+    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);
+
+      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;
+      }
     }
 
-    // --- 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}`);
-
-        const tokenData = new URLSearchParams({
-            grant_type: 'authorization_code',
-            code,
-            redirect_uri: REDIRECT_URI,
-            client_id: CLIENT_ID,
-            code_verifier: codeVerifier,
-        });
-
-        const resp = await this.httpsRequest(TOKEN_ENDPOINT, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Content-Length': tokenData.toString().length,
-            }
-        }, tokenData.toString());
-
-        console.log('Token endpoint response:', resp.html);
-
-        let tokens;
-        try { tokens = JSON.parse(resp.html); }
-        catch (err) { console.log('Failed to parse token response'); throw err; }
-
-        if (tokens.error) {
-           console.log('Token response error:', tokens);
-            throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error}`);
-        }
-
-        return tokens;
+    // Fallback: finalUrl or HTML
+    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;
     }
 
-    // --- 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;
+    throw new Error('No authorization code found after login');
+  }
+
+  async exchangeCodeForTokens(code, codeVerifier) {
+    console.log('Exchanging authorization code for tokens...');
+    console.log(`Authorization code: ${code}`);
+    console.log(`Code verifier: ${codeVerifier}`);
+
+    const tokenData = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: REDIRECT_URI,
+      client_id: CLIENT_ID,
+      code_verifier: codeVerifier,
+    });
+
+    const resp = await this.httpsRequest(TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': tokenData.toString().length,
+      }
+    }, tokenData.toString());
+
+    console.log('Token endpoint response:', resp.html);
+
+    let tokens;
+    try { tokens = JSON.parse(resp.html); } 
+    catch (err) { console.error('Failed to parse token response'); throw err; }
+
+    if (tokens.error) {
+      console.error('Token response error:', tokens);
+      throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error}`);
     }
 
+    return tokens;
+  }
+
+  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;