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

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "MELCloud Control",
   "name": "homebridge-melcloud-control",
-  "version": "4.0.0-beta.255",
+  "version": "4.0.0-beta.257",
   "description": "Homebridge plugin to control Mitsubishi Air Conditioner, Heat Pump and Energy Recovery Ventilation.",
   "license": "MIT",
   "author": "grzegorz914",
@@ -40,7 +40,8 @@
     "axios": "^1.12.2",
     "express": "^5.1.0",
     "puppeteer": "^24.26.1",
-    "jsdom": "^27.0.1"
+    "axios-cookiejar-support": "^6.0.4",
+    "tough-cookie": "^6.0.0"
   },
   "keywords": [
     "homebridge",

package/src/melcloud.js

@@ -177,7 +177,7 @@ class MelCloud extends EventEmitter {
     // MELCloud Home
     async connectToMelCloudHome() {
         const oauth = new MelCloudHomeToken();
-        this.tokens = await oauth.oauth.getTokensWithCredentials(this.user, this.passwd);
+        this.tokens = await 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,8 +1,6 @@
-/**
- * OAuth Helper - Automatic Token Management (ES Module)
- */
-
-import https from 'https';
+import axios from 'axios';
+import { wrapper } from 'axios-cookiejar-support';
+import { CookieJar } from 'tough-cookie';
 import crypto from 'crypto';
 
 const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
@@ -13,204 +11,108 @@ 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;
-  }
-
-  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, redirectCount = 0) {
-    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 };
-
-      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);
-        }
+    constructor(log = console) {
+        this.log = log;
+        const jar = new CookieJar();
+        this.client = wrapper(axios.create({ jar, withCredentials: true }));
+        this.client.defaults.headers['User-Agent'] = MOBILE_USER_AGENT;
+    }
 
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => resolve(data));
-      });
-
-      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]);
-          });
-        }
+    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');
+    }
+
+    async getLoginPage(authUrl) {
+        this.log.debug('Getting login page...');
+        const res = await this.client.get(authUrl, { maxRedirects: 10 });
+        const csrfMatch = res.data.match(/name="_csrf"\s+value="([^"]+)"/);
+        if (!csrfMatch) throw new Error('Could not extract CSRF token from login page');
+        return { html: res.data, csrf: csrfMatch[1], url: res.request.res.responseUrl };
+    }
+
+    async submitLogin(loginUrl, csrf, email, password) {
+        const form = new URLSearchParams({ _csrf: csrf, username: email, password });
+        const res = await this.client.post(loginUrl, form.toString(), {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Referer: loginUrl,
+            },
+            maxRedirects: 0, // manual redirect handling
+            validateStatus: (status) => status >= 200 && status < 400,
+        });
 
-        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);
+        // Try to get code from Location header
+        const location = res.headers.location;
+        if (location?.startsWith('melcloudhome://')) {
+            const codeMatch = location.match(/[?&]code=([^&]+)/);
+            if (codeMatch) return codeMatch[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 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'));
+        // Try to get code from HTML (form_post or JS)
+        const codeMatch = res.data.match(/name="code"\s+value="([^"]+)"/) ||
+            res.data.match(/melcloudhome:\/\/[^"'\s]*[?&]code=([^&"'\s]+)/);
+        if (codeMatch) return codeMatch[1];
+
+        throw new Error('Authorization code not found in login response');
+    }
+
+    async exchangeCodeForTokens(code, codeVerifier) {
+        const form = new URLSearchParams({
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: REDIRECT_URI,
+            client_id: CLIENT_ID,
+            code_verifier: codeVerifier,
+        });
+
+        const res = await this.client.post(TOKEN_ENDPOINT, form.toString(), {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Authorization: 'Basic aG9tZW1vYmlsZTo=',
+            },
         });
-      });
-
-      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;
+
+        if (res.data.error) throw new Error(`Token exchange failed: ${res.data.error_description || res.data.error}`);
+        return {
+            accessToken: res.data.access_token,
+            refreshToken: res.data.refresh_token,
+            expiresIn: res.data.expires_in,
+            idToken: res.data.id_token,
+        };
+    }
+
+    async getTokensWithCredentials(email, password) {
+        try {
+            this.log.info('Obtaining OAuth tokens...');
+            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.url, loginPage.csrf, email, password);
+            const tokens = await this.exchangeCodeForTokens(authCode, pkce.verifier);
+
+            this.log.info('✓ Successfully obtained OAuth tokens');
+            return tokens;
+        } catch (error) {
+            this.log.error('Failed to obtain OAuth tokens:', error);
+            throw error;
+        }
     }
-  }
 }