homebridge-melcloud-control 4.0.0-beta.31 → 4.0.0-beta.310

package/src/melcloud.js

@@ -1,21 +1,26 @@
-import { Agent } from 'https';
-import axios from 'axios';
+
+import { execSync } from 'child_process';
 import puppeteer from 'puppeteer';
+import axios from 'axios';
 import EventEmitter from 'events';
+import MelCloudHomeToken from './melcloudhometoken.js';
 import ImpulseGenerator from './impulsegenerator.js';
 import Functions from './functions.js';
 import { ApiUrls, ApiUrlsHome } from './constants.js';
+import { URLSearchParams } from 'url';
+const TOKEN_ENDPOINT = 'https://auth.melcloudhome.com/connect/token';
+const REDIRECT_URI = 'melcloudhome://';
 
 class MelCloud extends EventEmitter {
-    constructor(user, passwd, language, accountFile, buildingsFile, devicesFile, cookiesFile, logWarn, logDebug, requestConfig) {
+    constructor(accountType, user, passwd, language, accountFile, buildingsFile, devicesFile, logWarn, logDebug, requestConfig) {
         super();
+        this.accountType = accountType;
         this.user = user;
         this.passwd = passwd;
         this.language = language;
         this.accountFile = accountFile;
         this.buildingsFile = buildingsFile;
         this.devicesFile = devicesFile;
-        this.cookiesFile = cookiesFile;
         this.logWarn = logWarn;
         this.logDebug = logDebug;
         this.requestConfig = requestConfig;
@@ -23,6 +28,12 @@ class MelCloud extends EventEmitter {
         this.contextKey = '';
         this.functions = new Functions();
 
+        this.axiosInstance = axios.create({
+            baseURL: 'https://app.melcloud.com/Mitsubishi.Wifi.Client',
+            headers: { 'User-Agent': 'MonitorAndControl.App.Mobile/35 CFNetwork/3860.100.1 Darwin/25.0.0' }
+        });
+        this.tokens = null;
+
         this.loginData = {
             Email: user,
             Password: passwd,
@@ -33,18 +44,15 @@ class MelCloud extends EventEmitter {
             Persist: true
         };
 
-        this.axiosDefaults = {
-            timeout: 15000,
-            maxContentLength: 100000000,
-            maxBodyLength: 1000000000,
-            httpsAgent: new Agent({
-                keepAlive: false,
-                rejectUnauthorized: false
-            })
-        };
-
         if (!requestConfig) {
             this.impulseGenerator = new ImpulseGenerator()
+                .on('connect', async () => {
+                    try {
+                        await this.connect(true);
+                    } catch (error) {
+                        this.emit('error', `Impulse generator error: ${error}`);
+                    }
+                })
                 .on('checkDevicesList', async () => {
                     try {
                         await this.checkDevicesList(this.contextKey);
@@ -58,13 +66,14 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    async checkDevicesList(contextKey) {
+    // MELCloud
+    async checkMelcloudDevicesList(contextKey) {
         try {
             const axiosInstanceGet = axios.create({
                 method: 'GET',
                 baseURL: ApiUrls.BaseURL,
-                headers: { 'X-MitsContextKey': contextKey },
-                ...this.axiosDefaults
+                timeout: 15000,
+                headers: { 'X-MitsContextKey': contextKey }
             });
 
             if (this.logDebug) this.emit('debug', `Scanning for devices`);
@@ -91,6 +100,14 @@ class MelCloud extends EventEmitter {
                     ...buildingStructure.Areas.flatMap(area => area.Devices),
                     ...buildingStructure.Devices
                 ];
+
+                // Zamiana DeviceID na string
+                allDevices.forEach(device => {
+                    if (device.DeviceID !== undefined && device.DeviceID !== null) {
+                        device.DeviceID = device.DeviceID.toString();
+                    }
+                });
+
                 devices.push(...allDevices);
             }
 
@@ -109,21 +126,20 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    async connectMelCloud() {
+    async connectToMelCloud() {
         if (this.logDebug) this.emit('debug', `Connecting to MELCloud`);
 
         try {
             const axiosInstanceLogin = axios.create({
                 method: 'POST',
                 baseURL: ApiUrls.BaseURL,
-                ...this.axiosDefaults
+                timeout: 15000,
             });
 
             const accountData = await axiosInstanceLogin(ApiUrls.ClientLogin, { data: this.loginData });
             const account = accountData.data;
             const accountInfo = account.LoginData;
             const contextKey = accountInfo?.ContextKey;
-            const useFahrenheit = accountInfo?.UseFahrenheit ?? false;
             this.contextKey = contextKey;
 
             const debugData = {
@@ -145,52 +161,33 @@ class MelCloud extends EventEmitter {
             this.axiosInstancePost = axios.create({
                 method: 'POST',
                 baseURL: ApiUrls.BaseURL,
+                timeout: 15000,
                 headers: {
                     'X-MitsContextKey': contextKey,
                     'content-type': 'application/json'
-                },
-                ...this.axiosDefaults
+                }
             });
 
             await this.functions.saveData(this.accountFile, accountInfo);
-
             this.emit('success', `Connect to MELCloud Success`);
 
-            return {
-                accountInfo,
-                contextKey,
-                useFahrenheit
-            };
+            return accountInfo
         } catch (error) {
             throw new Error(`Connect to MELCloud error: ${error.message}`);
         }
     }
 
-    async connectMelCloudHome() {
-        if (this.logDebug) this.emit('debug', `Connecting to MELCloud Home`);
-
+    // MELCloud Home
+    async checkMelcloudHomeDevicesList(contextKey) {
         try {
-            const coocies = await this.getCookies();
-            const c1 = coocies.C1.trim();
-            const c2 = coocies.C2.trim();
-
-            const cookies = [
-                '__Secure-monitorandcontrol=chunks-2',
-                `__Secure-monitorandcontrolC1=${c1}`,
-                `__Secure-monitorandcontrolC2=${c2}`,
-            ].join('; ');
-
             const axiosInstance = axios.create({
+                method: 'GET',
                 baseURL: ApiUrlsHome.BaseURL,
-                timeout: 10000,
-                httpsAgent: new Agent({
-                    keepAlive: false,
-                    rejectUnauthorized: false
-                }),
+                timeout: 25000,
                 headers: {
                     'Accept': '*/*',
                     'Accept-Language': 'en-US,en;q=0.9',
-                    'Cookie': cookies,
+                    'Cookie': contextKey,
                     'User-Agent': 'homebridge-melcloud-control/4.0.0',
                     'DNT': '1',
                     'Origin': 'https://melcloudhome.com',
@@ -202,94 +199,277 @@ class MelCloud extends EventEmitter {
                 }
             });
 
-            const response = await axiosInstance.get(ApiUrlsHome.GetUserContext);
-            const homeData = response.data;
-            if (this.logDebug) this.emit('debug', `MELCloud Home data: ${JSON.stringify(homeData, null, 2)}`);
+            if (this.logDebug) this.emit('debug', `Scanning for devices`);
+            const listDevicesData = await axiosInstance(ApiUrlsHome.GetUserContext);
+            const buildingsList = listDevicesData.data.buildings;
+            if (this.logDebug) this.emit('debug', `Buildings: ${JSON.stringify(buildingsList, null, 2)}`);
+
+            if (!buildingsList) {
+                if (this.logWarn) this.emit('warn', `No building found`);
+                return null;
+            }
+
+            await this.functions.saveData(this.buildingsFile, buildingsList);
+            if (this.logDebug) this.emit('debug', `Buildings list saved`);
+
+            const devices = buildingsList.flatMap(building => {
+                // Funkcja kapitalizująca klucze obiektu
+                const capitalizeKeys = obj =>
+                    Object.fromEntries(
+                        Object.entries(obj).map(([key, value]) => [
+                            key.charAt(0).toUpperCase() + key.slice(1),
+                            value
+                        ])
+                    );
+
+                // Funkcja tworząca finalny obiekt Device
+                const createDevice = (device, type, contextKey) => {
+                    // Settings już kapitalizowane w nazwach
+                    const settingsArray = device.Settings || [];
+
+                    const settingsObject = Object.fromEntries(
+                        settingsArray.map(({ name, value }) => {
+                            let parsedValue = value;
+                            if (value === "True") parsedValue = true;
+                            else if (value === "False") parsedValue = false;
+                            else if (!isNaN(value) && value !== "") parsedValue = Number(value);
+
+                            const key = name.charAt(0).toUpperCase() + name.slice(1);
+                            return [key, parsedValue];
+                        })
+                    );
+
+                    // Scal Capabilities + Settings + DeviceType w Device
+                    const deviceObject = {
+                        ...capitalizeKeys(device.Capabilities || {}),
+                        ...settingsObject,
+                        DeviceType: type
+                    };
+
+                    // Usuń stare pola Settings i Capabilities
+                    const { Settings, Capabilities, Id, GivenDisplayName, ...rest } = device;
+
+                    return {
+                        ...rest,
+                        ContextKey: contextKey,
+                        Type: type,
+                        DeviceID: Id,
+                        DeviceName: GivenDisplayName,
+                        Device: deviceObject
+                    };
+                };
+
+                return [
+                    ...(building.airToAirUnits || []).map(d => createDevice(capitalizeKeys(d), 0, this.contextKey)),
+                    ...(building.airToWaterUnits || []).map(d => createDevice(capitalizeKeys(d), 1, this.contextKey)),
+                    ...(building.airToVentilationUnits || []).map(d => createDevice(capitalizeKeys(d), 3, this.contextKey))
+                ];
+            });
+
+            const devicesCount = devices.length;
+            if (devicesCount === 0) {
+                if (this.logWarn) this.emit('warn', `No devices found`);
+                return null;
+            }
 
-            this.emit('success', `Connect to MELCloud Home Success`);
+            await this.functions.saveData(this.devicesFile, devices);
+            if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
 
-            return
+            return devices;
         } catch (error) {
             throw new Error(`Connect to MELCloud Home error: ${error.message}`);
         }
     }
 
-    async getCookies() {
-        const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
-        const page = await browser.newPage();
+    async connectToMelCloudHome() {
+        let browser;
+        try {
+
+            const melCloudHomeToken = new MelCloudHomeToken({
+                user: this.user,
+                passwd: this.passwd,
+                logWarn: this.logWarn,
+                logError: this.logError,
+            })
+                .on('success', message => this.emit('success', message))
+                .on('warn', warn => this.emit('warn', warn))
+                .on('error', error => this.emit('error', error));
+
+            const data = await melCloudHomeToken.buildAuthorizeUrl();
+            const code = await melCloudHomeToken.loginToMelCloudHome(data.url);
+
+            return false
+
+            browser = await puppeteer.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox']
+            });
+
+            const page = await browser.newPage();
+            await page.goto(data.url, { waitUntil: 'networkidle2' });
+
+            await page.waitForSelector('input[name="username"]', { timeout: 5000 });
+            await page.type('input[name="username"]', this.user, { delay: 50 });
+            await page.type('input[name="password"]', this.passwd, { delay: 50 });
+            const button1 = await page.$('input[type="submit"]');
+            await Promise.all([button1.click(), page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 })]);
+            const html = await page.content();
+            const code1 = await melCloudHomeToken.extractCodeFromHtml(html);
+            this.emit('warn', code);
+
+            // 5. Wymień code na access_token
+            const tokenResponse = await melCloudHomeToken.getTokens(code, data.codeVerifier);
+            const tokenData = await tokenResponse.json();
+            this.emit('debug', `Token: ${JSON.stringify(tokenData, null, 2)}`);
+            const accountInfo = {
+                accessToken: tokenData.access_token,
+                refreshToken: tokenData.refresh_token,
+                expiresIn: tokenData.expires_in
+            };
+
+            return accountInfo;
+        } catch (error) {
+            if (browser) await browser.close().catch(() => { });
+            throw error;
+        }
+    }
+
+    async connectToMelCloudHome1(refresh = false) {
+        if (this.logDebug) this.emit('debug', `Connecting to MELCloud Home`);
 
+        let browser;
         try {
-            this.emit('warn', 'Opening login page...');
+            browser = await puppeteer.launch({
+                headless: true,
+                args: ['--no-sandbox', '--disable-setuid-sandbox']
+            });
+
+            const page = await browser.newPage();
             await page.goto(ApiUrlsHome.BaseURL, { waitUntil: 'networkidle2' });
 
-            // Kliknij przycisk logowania
             const buttons = await page.$$('button.btn--blue');
             let loginBtn = null;
+
             for (const btn of buttons) {
                 const text = await page.evaluate(el => el.textContent, btn);
-                if (text.trim() === 'Zaloguj') {
+                if (text.trim() === 'Zaloguj' || text.trim() === 'Sign In') {
                     loginBtn = btn;
                     break;
                 }
             }
 
-            if (!loginBtn) throw new Error('Login button not found on homepage');
+            if (!loginBtn && this.logWarn) this.emit('warn', `Login button not found`);
 
             await Promise.all([
                 loginBtn.click(),
-                page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 20000 })
+                page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 })
             ]);
 
-            // Poczekaj, aż strona przekieruje do Cognito login
-            await page.waitForSelector('input[name="username"]', { timeout: 15000 });
-
-            this.emit('warn', 'Typing credentials...');
+            await page.waitForSelector('input[name="username"]', { timeout: 5000 });
             await page.type('input[name="username"]', this.user, { delay: 50 });
             await page.type('input[name="password"]', this.passwd, { delay: 50 });
 
-            // Kliknij przycisk logowania
             const button1 = await page.$('input[type="submit"]');
             await Promise.all([
                 button1.click(),
-                page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 20000 })
+                page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 })
             ]);
 
             let c1 = null, c2 = null;
             const start = Date.now();
 
-            // Loop max 20s, czekamy aż pojawią się cookies
             while ((!c1 || !c2) && Date.now() - start < 20000) {
-                const cookies = await page.cookies();
+                const cookies = await page.browserContext().cookies();
                 c1 = cookies.find(c => c.name === '__Secure-monitorandcontrolC1')?.value || c1;
                 c2 = cookies.find(c => c.name === '__Secure-monitorandcontrolC2')?.value || c2;
                 if (!c1 || !c2) await new Promise(r => setTimeout(r, 500));
             }
 
+
             if (!c1 || !c2) {
-                await browser.close();
-                throw new Error('Cookies C1/C2 not found after login');
+                if (this.logWarn) this.emit('warn', `Cookies C1/C2 missing`);
+                return null;
             }
 
-            // Zapis do pliku
-            const data = { C1: c1, C2: c2, date: new Date().toISOString() };
-            await this.functions.saveData(this.cookiesFile, data);
+            const contextKey = [
+                '__Secure-monitorandcontrol=chunks-2',
+                `__Secure-monitorandcontrolC1=${c1}`,
+                `__Secure-monitorandcontrolC2=${c2}`
+            ].join('; ');
+
+            const accountInfo = { ContextKey: contextKey, UseFahrenheit: false };
+            this.contextKey = contextKey;
+
+            await this.functions.saveData(this.accountFile, accountInfo);
+            if (!refresh) this.emit('success', `Connect to MELCloud Home Success`);
+
+            return accountInfo;
+        } catch (error) {
+            if (error.message.includes('libnspr4.so') || error.message.includes('Failed to launch the browser process')) {
+                const inDocker = await this.functions.isRunningInDocker();
+                if (this.logWarn) this.emit('warn', `Missing system libraries detected.`);
+
+                if (inDocker) {
+                    this.emit('warn', `Running in Docker — attempting automatic fix...`);
+
+                    const installCmd =
+                        'apt-get update && apt-get install -y ' +
+                        'libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 libcups2 ' +
+                        'libxcomposite1 libxrandr2 libxdamage1 libxkbcommon0 libpango-1.0-0 ' +
+                        'libgbm1 libasound2 libxshmfence1 fonts-liberation libappindicator3-1 libu2f-udev';
+
+                    try {
+                        execSync(installCmd, { stdio: 'inherit' });
+                        if (this.logDebug) this.emit('debug', `Libraries installed. Retrying Puppeteer...`);
+
+                        const testBrowser = await puppeteer.launch({
+                            headless: true,
+                            args: ['--no-sandbox', '--disable-setuid-sandbox']
+                        });
+                        await testBrowser.close();
+
+                        this.emit('success', `Puppeteer repaired and running, try again.`);
+                        return true;
+                    } catch (fixError) {
+                        throw new Error(`Automatic fix failed. Run manually inside container:\n${installCmd}`);
+                    }
 
-            this.emit('warn', 'Login successful.');
-            return data;
-        } catch (err) {
-            this.emit('error', `Login failed: ${err.message}`);
-            return null;
+                } else {
+                    throw new Error(`System libraries missing. Non-Docker environment detected — install dependencies manually.`);
+                }
+            } else {
+                throw new Error(`Puppeteer failed: ${error.message}`);
+            }
         } finally {
-            await browser.close();
+            if (browser) await browser.close().catch(() => { });
+        }
+    }
+
+    async checkDevicesList(contextKey) {
+        let devices = [];
+        switch (this.accountType) {
+            case "melcloud":
+                devices = await this.checkMelcloudDevicesList(contextKey);
+                return devices
+            case "melcloudhome":
+                devices = await this.checkMelcloudHomeDevicesList(contextKey);
+                return devices;
+            default:
+                return devices;
         }
     }
 
-    async connect(mode) {
-        switch (mode) {
-            case 'home':
-                return await this.connectMelCloudHome();
+    async connect(refresh) {
+        let response = {};
+        switch (this.accountType) {
+            case "melcloud":
+                response = await this.connectToMelCloud();
+                return response
+            case "melcloudhome":
+                response = await this.connectToMelCloudHome(refresh);
+                return response
             default:
-                return await this.connectMelCloud();
+                return response
         }
     }