homebridge-melcloud-control 4.0.0-beta.403 → 4.0.0-beta.405

package/package.json

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

package/src/melcloudhometoken.js

@@ -7,177 +7,207 @@ import EventEmitter from 'events';
 const MOBILE_USER_AGENT = 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0';
 const CLIENT_ID = 'homemobile';
 const REDIRECT_URI = 'melcloudhome://';
-const SCOPE = 'openid profile';
+const SCOPE = 'openid profile email';
+const AUTH_BASE = 'https://live-melcloudhome.auth.eu-west-1.amazoncognito.com';
+const TOKEN_URL = `${AUTH_BASE}/oauth2/token`;
+const AUTHORIZE_URL = `${AUTH_BASE}/login?`;
 
 class MelCloudHomeToken extends EventEmitter {
     constructor() {
         super();
         this.cookieJar = new CookieJar();
+        this.http = wrapper(axios.create({ jar: this.cookieJar }));
     }
 
-    async getTokens(email, password) {
-        const verifier = this._generateCodeVerifier();
-        const challenge = this._generateCodeChallenge(verifier);
-        const authUrl = `https://live-melcloudhome.auth.eu-west-1.amazoncognito.com/login?client_id=3g4d5l5kivuqi7oia68gib7uso&redirect_uri=${encodeURIComponent(
-            'https://auth.melcloudhome.com/signin-oidc-meu'
-        )}&response_type=code&scope=openid%20profile&code_challenge=${challenge}&code_challenge_method=S256`;
-
-        console.log('[OAuth] Starting MELCloud login flow');
-
-        const html = await this._get(authUrl);
-        const csrf = this._extractCsrf(html);
-        if (!csrf) throw new Error('Cannot find CSRF token');
-
-        console.log('[OAuth] Submitting credentials...');
-
-        const form = new URLSearchParams({
-            _csrf: csrf,
-            username: email,
-            password: password,
-        });
-
-        const loginResp = await this._post('https://live-melcloudhome.auth.eu-west-1.amazoncognito.com/login', form);
-
-        if (loginResp.status === 302 && loginResp.headers.location) {
-            const nextUrl = this._resolveUrl('https://live-melcloudhome.auth.eu-west-1.amazoncognito.com', loginResp.headers.location);
-            console.log('[OAuth] Redirecting to:', nextUrl);
-            return await this._followRedirects(nextUrl, verifier);
-        } else if (loginResp.status === 200) {
-            throw new Error('Login failed — probably wrong credentials');
-        } else {
-            throw new Error(`Unexpected login status: ${loginResp.status}`);
-        }
+    // --- Utility: generate PKCE pair ---
+    _generatePkcePair() {
+        const verifier = crypto.randomBytes(32).toString('base64url');
+        const challenge = crypto
+            .createHash('sha256')
+            .update(verifier)
+            .digest('base64url');
+        return { verifier, challenge };
     }
 
-    async _followRedirects(url, verifier, depth = 0) {
-        if (depth > 10) throw new Error('Too many redirects');
-
-        const resp = await this._get(url);
-
-        if (resp.status === 302 && resp.headers.location) {
-            const nextUrl = this._resolveUrl(url, resp.headers.location);
-            console.log(`[OAuth] Redirect (${resp.status}) to: ${nextUrl}`);
-            return await this._followRedirects(nextUrl, verifier, depth + 1);
-        }
-
-        if (typeof resp.data === 'string') {
-            const code = this._extractAuthCode(resp.data);
-            if (code) {
-                console.log('[OAuth] Got authorization code');
-                return await this._exchangeToken(code, verifier);
-            }
-        }
-
-        throw new Error(`No authorization code found (status ${resp.status})`);
-    }
-
-    async _exchangeToken(code, verifier) {
-        console.log('[OAuth] Exchanging code for tokens...');
-
-        const tokenUrl = 'https://auth.melcloudhome.com/connect/token';
-        const data = new URLSearchParams({
-            grant_type: 'authorization_code',
-            client_id: CLIENT_ID,
-            code: code,
-            redirect_uri: REDIRECT_URI,
-            code_verifier: verifier,
-        });
-
-        const resp = await axios.post(tokenUrl, data.toString(), {
-            headers: {
-                'User-Agent': MOBILE_USER_AGENT,
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Authorization': 'Basic aG9tZW1vYmlsZTo=',
-            },
-            validateStatus: () => true,
-        });
-
-        if (resp.status !== 200) {
-            console.error('[OAuth] Token exchange failed:', resp.status, resp.data);
-            throw new Error(`Token exchange failed with status ${resp.status}`);
-        }
-
-        console.log('[OAuth] Tokens received!');
-        return {
-            accessToken: resp.data.access_token,
-            refreshToken: resp.data.refresh_token,
-            expiresIn: resp.data.expires_in,
-        };
+    // --- Utility: extract CSRF token from HTML ---
+    _extractCsrf(html) {
+        if (typeof html !== 'string') return null;
+        const match = html.match(/name=['"]_csrf['"][^>]*value=['"]([^'"]+)['"]/i);
+        return match ? match[1] : null;
     }
 
-    async _get(url) {
+    // --- GET request with redirect + cookie management ---
+    async _get(url, depth = 0) {
         const cookies = await this.cookieJar.getCookieString(url);
-        const resp = await axios.get(url, {
+        const resp = await this.http.get(url, {
             headers: {
                 'User-Agent': MOBILE_USER_AGENT,
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-                'Cookie': cookies,
+                Accept:
+                    'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                Cookie: cookies,
             },
-            validateStatus: () => true,
             maxRedirects: 0,
+            validateStatus: () => true,
             responseType: 'text',
-            transformResponse: [(data) => data], // <— force raw string
+            transformResponse: [(d) => d],
         });
+
+        // Save cookies
         if (resp.headers['set-cookie']) {
-            await this.cookieJar.setCookie(resp.headers['set-cookie'].join('; '), url);
+            await Promise.all(
+                resp.headers['set-cookie'].map((c) =>
+                    this.cookieJar.setCookie(c, url)
+                )
+            );
         }
+
+        // Follow redirect manually
+        if (
+            resp.status >= 300 &&
+            resp.status < 400 &&
+            resp.headers.location &&
+            depth < 5
+        ) {
+            const nextUrl = new URL(resp.headers.location, url).href;
+            console.log(`[OAuth] Redirect → ${nextUrl}`);
+            return this._get(nextUrl, depth + 1);
+        }
+
         return resp;
     }
 
-    async _post(url, formData) {
+    // --- POST request helper ---
+    async _post(url, data, headers = {}) {
         const cookies = await this.cookieJar.getCookieString(url);
-        const resp = await axios.post(url, formData.toString(), {
+        const resp = await this.http.post(url, data, {
             headers: {
                 'User-Agent': MOBILE_USER_AGENT,
                 'Content-Type': 'application/x-www-form-urlencoded',
-                'Accept': 'text/html,application/xhtml+xml',
-                'Cookie': cookies,
-                'Content-Length': Buffer.byteLength(formData.toString()),
+                Cookie: cookies,
+                ...headers,
             },
-            validateStatus: () => true,
             maxRedirects: 0,
+            validateStatus: () => true,
             responseType: 'text',
-            transformResponse: [(data) => data], // <— force raw string
+            transformResponse: [(d) => d],
         });
+
         if (resp.headers['set-cookie']) {
-            await this.cookieJar.setCookie(resp.headers['set-cookie'].join('; '), url);
+            await Promise.all(
+                resp.headers['set-cookie'].map((c) =>
+                    this.cookieJar.setCookie(c, url)
+                )
+            );
         }
+
         return resp;
     }
 
+    // --- Main login flow ---
+    async login(email, password) {
+        const { verifier, challenge } = this._generatePkcePair();
+
+        // Build authorize URL
+        const authUrl =
+            `${AUTH_BASE}/oauth2/authorize?` +
+            new URLSearchParams({
+                client_id: CLIENT_ID,
+                redirect_uri: REDIRECT_URI,
+                response_type: 'code',
+                scope: SCOPE,
+                code_challenge: challenge,
+                code_challenge_method: 'S256',
+            });
+
+        console.log(`[OAuth] Opening login page...`);
+        let resp = await this._get(authUrl);
+        if (resp.status >= 300 && resp.status < 400) {
+            const redirectUrl = new URL(resp.headers.location, AUTH_BASE).href;
+            console.log(`[OAuth] Redirected to: ${redirectUrl}`);
+            resp = await this._get(redirectUrl);
+        }
 
-    _extractCsrf(html) {
-        if (typeof html !== 'string') return null;
-        const match = html.match(/name="_csrf" value="([^"]+)"/);
-        return match ? match[1] : null;
-    }
+        // --- Extract CSRF token ---
+        const csrf = this._extractCsrf(resp.data);
+        if (!csrf) {
+            console.error('[OAuth] ❌ Cannot find CSRF token!');
+            console.log(resp.data.substring(0, 400));
+            throw new Error('Cannot find CSRF token');
+        }
 
-    _extractAuthCode(html) {
-        if (typeof html !== 'string') return null;
-        const urlMatch = html.match(/[?&]code=([^&]+)/);
-        if (urlMatch) return urlMatch[1];
-        const formMatch = html.match(/name="code"\s+value="([^"]+)"/);
-        return formMatch ? formMatch[1] : null;
-    }
+        console.log(`[OAuth] Found CSRF token: ${csrf}`);
 
-    _generateCodeVerifier() {
-        return crypto.randomBytes(32).toString('base64url');
-    }
+        // --- Submit login form ---
+        const loginUrl = resp.request.res.responseUrl || `${AUTH_BASE}/login`;
+        const formData = new URLSearchParams({
+            _csrf: csrf,
+            username: email,
+            password: password,
+        });
+
+        console.log(`[OAuth] Submitting login form...`);
+        const loginResp = await this._post(loginUrl, formData.toString());
 
-    _generateCodeChallenge(verifier) {
-        const hash = crypto.createHash('sha256').update(verifier).digest();
-        return hash.toString('base64url');
+        if (loginResp.status >= 300 && loginResp.status < 400) {
+            const redirectUrl = new URL(loginResp.headers.location, AUTH_BASE).href;
+            console.log(`[OAuth] Login redirect → ${redirectUrl}`);
+
+            // Extract code from redirect URL
+            const codeMatch = redirectUrl.match(/[?&]code=([^&]+)/);
+            if (!codeMatch) throw new Error('No code found after login redirect');
+            const code = codeMatch[1];
+            console.log(`[OAuth] ✅ Got authorization code: ${code}`);
+
+            // Exchange code for token
+            return this.exchangeToken(code, verifier);
+        }
+
+        console.error('[OAuth] ❌ Unexpected status on login:', loginResp.status);
+        console.log(loginResp.data.substring(0, 400));
+        throw new Error('Unexpected status on login page');
     }
 
-    _resolveUrl(base, relative) {
-        try {
-            return new URL(relative, base).toString();
-        } catch {
-            return relative;
+    // --- Exchange code for access token ---
+    async exchangeToken(code, verifier) {
+        console.log('[OAuth] Exchanging code for token...');
+
+        const body = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: CLIENT_ID,
+            redirect_uri: REDIRECT_URI,
+            code,
+            code_verifier: verifier,
+        });
+
+        const resp = await this.http.post(TOKEN_URL, body.toString(), {
+            headers: {
+                'User-Agent': MOBILE_USER_AGENT,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        });
+
+        if (resp.status !== 200) {
+            console.error('[OAuth] ❌ Token exchange failed:', resp.status);
+            console.log(resp.data);
+            throw new Error('Token exchange failed');
         }
+
+        console.log('[OAuth] ✅ Token response received');
+        return resp.data;
     }
 }
 
+// --- Example usage ---
+(async () => {
+    try {
+        const mel = new MelCloudHomeOAuth();
+        const token = await mel.login('YOUR_EMAIL', 'YOUR_PASSWORD');
+        console.log('✅ Final token:', token);
+    } catch (err) {
+        console.error('iDom Home, Connect error:', err.message);
+    }
+})();
+
 
 export default MelCloudHomeToken;