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

package/package.json

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

package/src/melcloud.js

@@ -177,7 +177,7 @@ class MelCloud extends EventEmitter {
     // MELCloud Home
     async connectToMelCloudHome() {
         const oauth = new MelCloudHomeToken();
-        this.tokens = await oauth.getTokensWithCredentials(this.user, this.passwd);
+        this.tokens = await oauth.getTokensWithPassword(this.user, this.passwd);
         this.emit('warn', `Token ${JSON.stringify(this.tokens, null, 2)}`);
         //this.axiosInstance.defaults.headers['Authorization'] = `Bearer ${this.tokens.accessToken}`;
         return false;

package/src/melcloudhometoken.js

@@ -1,211 +1,61 @@
 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';
-// ⚠ 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() {}
-
-  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]);
-          });
-        }
-
-        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();
-    });
-  }
-
-  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;
-      }
+    httpsRequest(url, options = {}, body = undefined) {
+        return new Promise((resolve, reject) => {
+            const req = https.request(url, options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => resolve({ statusCode: res.statusCode, body: data }));
+            });
+            req.on('error', reject);
+            if (body) req.write(body);
+            req.end();
+        });
     }
 
-    // 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;
-    }
+    /**
+     * 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...');
 
-    throw new Error('No authorization code found after login');
-  }
+        const params = new URLSearchParams({
+            grant_type: 'password',
+            client_id: CLIENT_ID,
+            username,
+            password,
+            scope: SCOPE,
+        });
 
-  async exchangeCodeForTokens(code, codeVerifier) {
-    console.log('Exchanging authorization code for tokens...');
-    console.log(`Authorization code: ${code}`);
-    console.log(`Code verifier: ${codeVerifier}`);
+        const headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Content-Length': params.toString().length,
+        };
 
-    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 }, params.toString());
 
-    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.body);
 
-    console.log('Token endpoint response:', resp.html);
+        const tokens = JSON.parse(resp.body);
 
-    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 request failed: ${tokens.error_description || tokens.error}`);
+        }
 
-    if (tokens.error) {
-      console.error('Token response error:', tokens);
-      throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error}`);
+        console.log('✓ Successfully obtained OAuth tokens');
+        return tokens;
     }
-
-    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;