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

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "4.0.0-beta.253",
+  "version": "4.0.0-beta.255",
   "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.getTokensWithPassword(this.user, this.passwd);
+        this.tokens = await oauth.oauth.getTokensWithCredentials(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,61 +1,219 @@
+/**
+ * OAuth Helper - Automatic Token Management (ES Module)
+ */
+
 import https from 'https';
-import { URLSearchParams } from 'url';
+import crypto from 'crypto';
 
-const TOKEN_ENDPOINT = 'https://auth.melcloudhome.com/connect/token';
+const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
 const CLIENT_ID = 'homemobile';
-const REDIRECT_URI = 'melcloudhome://signin-oidc-meu';
+const REDIRECT_URI = 'melcloudhome://';
 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 {
-    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();
-        });
-    }
+  constructor(log) {
+    this.log = log;
+  }
 
-    /**
-     * 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 params = new URLSearchParams({
-            grant_type: 'password',
-            client_id: CLIENT_ID,
-            username,
-            password,
-            scope: SCOPE,
-        });
+  generatePKCE() {
+    const verifier = crypto.randomBytes(32).toString('base64url');
+    const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
+    return { verifier, challenge };
+  }
 
-        const headers = {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Content-Length': params.toString().length,
-        };
+  generateState() {
+    return crypto.randomBytes(32).toString('hex');
+  }
 
-        const resp = await this.httpsRequest(TOKEN_ENDPOINT, { method: 'POST', headers }, params.toString());
+  httpsRequest(url, options, body, redirectCount = 0) {
+    if (redirectCount > 10) return Promise.reject(new Error('Too many redirects'));
 
-        console.log('Token endpoint response:', resp.body);
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const reqOptions = { ...options, hostname: urlObj.hostname, path: urlObj.pathname + urlObj.search };
+
+      const req = https.request(reqOptions, (res) => {
+        if ([301, 302].includes(res.statusCode) && res.headers.location) {
+          const redirectUrl = res.headers.location.startsWith('http')
+            ? res.headers.location
+            : `https://${urlObj.hostname}${res.headers.location}`;
+          return this.httpsRequest(redirectUrl, options, undefined, redirectCount + 1)
+            .then(resolve).catch(reject);
+        }
 
-        const tokens = JSON.parse(resp.body);
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(data));
+      });
 
-        if (tokens.error) {
-            console.error('Token response error:', tokens);
-            throw new Error(`Token request failed: ${tokens.error_description || tokens.error}`);
+      req.on('error', reject);
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+
+  httpsRequestWithCookies(url, options, body, redirectCount = 0, cookies = []) {
+    if (redirectCount > 10) return Promise.reject(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 (cookies.length) {
+        reqOptions.headers = { ...(reqOptions.headers || {}), Cookie: cookies.join('; ') };
+      }
+
+      const req = https.request(reqOptions, (res) => {
+        const setCookie = res.headers['set-cookie'];
+        if (setCookie) {
+          setCookie.forEach(cookie => {
+            const cookieName = cookie.split('=')[0];
+            const existingIndex = cookies.findIndex(c => c.startsWith(cookieName + '='));
+            if (existingIndex >= 0) cookies[existingIndex] = cookie.split(';')[0];
+            else cookies.push(cookie.split(';')[0]);
+          });
         }
 
-        console.log('✓ Successfully obtained OAuth tokens');
-        return tokens;
+        if ([301, 302].includes(res.statusCode) && res.headers.location) {
+          const redirectUrl = res.headers.location.startsWith('http')
+            ? res.headers.location
+            : `https://${urlObj.hostname}${res.headers.location}`;
+          return this.httpsRequestWithCookies(redirectUrl, options, undefined, redirectCount + 1, cookies)
+            .then(resolve).catch(reject);
+        }
+
+        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 cookies = [];
+    const response = await this.httpsRequestWithCookies(authUrl, {
+      method: 'GET',
+      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',
+      },
+    }, undefined, 0, cookies);
+
+    const csrfMatch = response.html.match(/name="_csrf"\s+value="([^"]+)"/);
+    if (!csrfMatch) throw new Error('Could not extract CSRF token from login page');
+
+    return {
+      html: response.html,
+      loginUrl: response.finalUrl,
+      csrf: csrfMatch[1],
+      cookies: response.cookies.join('; '),
+    };
+  }
+
+  submitLogin(loginUrl, csrf, email, password, cookies) {
+    const formData = new URLSearchParams({ _csrf: csrf, username: email, password });
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(loginUrl);
+      const req = https.request({
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        method: 'POST',
+        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,
+          Origin: 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com',
+          Referer: loginUrl,
+        },
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          const locationHeader = res.headers.location;
+          const bodyCodeMatch = data.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
+          if (locationHeader && locationHeader.startsWith('melcloudhome://')) {
+            const codeMatch = locationHeader.match(/[?&]code=([^&]+)/);
+            if (codeMatch) return resolve(codeMatch[1]);
+          } else if (bodyCodeMatch) return resolve(bodyCodeMatch[1]);
+          reject(new Error('No authorization code found in login response'));
+        });
+      });
+
+      req.on('error', reject);
+      req.write(formData.toString());
+      req.end();
+    });
+  }
+
+  async exchangeCodeForTokens(code, codeVerifier) {
+    const tokenData = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: REDIRECT_URI,
+      client_id: CLIENT_ID,
+      code_verifier: codeVerifier,
+    });
+
+    const response = await this.httpsRequest(TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': tokenData.toString().length,
+        Authorization: 'Basic aG9tZW1vYmlsZTo=',
+      },
+    }, tokenData.toString());
+
+    const tokens = JSON.parse(response);
+    if (tokens.error) throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error}`);
+
+    return {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiresIn: tokens.expires_in,
+      idToken: tokens.id_token,
+    };
+  }
+
+  async getTokensWithCredentials(email, password) {
+    try {
+     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 loginPage = await this.getLoginPage(authUrl.toString());
+      const authCode = await this.submitLogin(loginPage.loginUrl, loginPage.csrf, email, password, loginPage.cookies);
+      const tokens = await this.exchangeCodeForTokens(authCode, pkce.verifier);
+
+      console.log('✓ Successfully obtained OAuth tokens');
+      return tokens;
+    } catch (error) {
+      console.log('Failed to obtain OAuth tokens:', error);
+      throw error;
     }
+  }
 }
 
+
 export default MelCloudHomeToken;