homebridge-melcloud-control 4.0.0-beta.43 → 4.0.0-beta.430

package/src/melcloud.js

@@ -1,79 +1,87 @@
-import { Agent } from 'https';
 import axios from 'axios';
-import puppeteer from 'puppeteer';
 import EventEmitter from 'events';
+import puppeteer from 'puppeteer-core';
+import MelCloudHomeToken from './melcloudhometoken.js';
 import ImpulseGenerator from './impulsegenerator.js';
 import Functions from './functions.js';
 import { ApiUrls, ApiUrlsHome } from './constants.js';
 
 class MelCloud extends EventEmitter {
-    constructor(displayType, user, passwd, language, accountFile, buildingsFile, devicesFile, logWarn, logDebug, requestConfig) {
+    constructor(account, accountFile, buildingsFile, devicesFile, pluginStart = false) {
         super();
-        this.displayType = displayType;
-        this.user = user;
-        this.passwd = passwd;
-        this.language = language;
+        this.accountType = account.type;
+        this.user = account.user;
+        this.passwd = account.passwd;
+        this.language = account.language;
+        this.logWarn = account.log?.warn;
+        this.logError = account.log?.error;
+        this.logDebug = account.log?.debug;
         this.accountFile = accountFile;
         this.buildingsFile = buildingsFile;
         this.devicesFile = devicesFile;
-        this.logWarn = logWarn;
-        this.logDebug = logDebug;
-        this.requestConfig = requestConfig;
         this.devicesId = [];
         this.contextKey = '';
         this.functions = new Functions();
+        this.tokens = null;
 
-        this.loginData = {
-            Email: user,
-            Password: passwd,
-            Language: language,
-            AppVersion: '1.34.12',
-            CaptchaChallenge: '',
-            CaptchaResponse: '',
-            Persist: true
-        };
-
-        this.axiosDefaults = {
-            timeout: 15000,
-            maxContentLength: 100000000,
-            maxBodyLength: 1000000000,
-            httpsAgent: new Agent({
-                keepAlive: false,
-                rejectUnauthorized: false
-            })
-        };
-
-        if (!requestConfig) {
+        if (pluginStart) {
+            //lock flags
+            this.locks = {
+                connect: false,
+                checkDevicesList: false
+            };
             this.impulseGenerator = new ImpulseGenerator()
-                .on('checkDevicesList', async () => {
-                    try {
-                        await this.checkDevicesList(this.contextKey);
-                    } catch (error) {
-                        this.emit('error', `Impulse generator error: ${error}`);
-                    }
-                })
+                .on('connect', () => this.handleWithLock('connect', async () => {
+                    await this.connect(true);
+                }))
+                .on('checkDevicesList', () => this.handleWithLock('checkDevicesList', async () => {
+                    await this.checkDevicesList();
+                }))
                 .on('state', (state) => {
                     this.emit('success', `Impulse generator ${state ? 'started' : 'stopped'}.`);
                 });
         }
     }
 
-    async checkMelcloudDevicesList(contextKey) {
+    async handleWithLock(lockKey, fn) {
+        if (this.locks[lockKey]) return;
+
+        this.locks[lockKey] = true;
+        try {
+            await fn();
+        } catch (error) {
+            this.emit('error', `Inpulse generator error: ${error}`);
+        } finally {
+            this.locks[lockKey] = false;
+        }
+    }
+
+    // MELCloud
+    async checkMelcloudDevicesList() {
         try {
-            const axiosInstanceGet = axios.create({
+            const axiosInstance = axios.create({
                 method: 'GET',
                 baseURL: ApiUrls.BaseURL,
-                headers: { 'X-MitsContextKey': contextKey },
-                ...this.axiosDefaults
+                timeout: 15000,
+                headers: { 'X-MitsContextKey': this.contextKey }
             });
 
-            if (this.logDebug) this.emit('debug', `Scanning for devices`);
-            const listDevicesData = await axiosInstanceGet(ApiUrls.ListDevices);
+            if (this.logDebug) this.emit('debug', `Scanning for devices...`);
+
+            const listDevicesData = await axiosInstance(ApiUrls.ListDevices);
+
+            if (!listDevicesData || !listDevicesData.data) {
+                if (this.logWarn) this.emit('warn', `Invalid or empty response from MELCloud API`);
+                return null;
+            }
+
             const buildingsList = listDevicesData.data;
-            if (this.logDebug) this.emit('debug', `Buildings: ${JSON.stringify(buildingsList, null, 2)}`);
 
-            if (!buildingsList) {
-                if (this.logWarn) this.emit('warn', `No building found`);
+            if (this.logDebug)
+                this.emit('debug', `Buildings: ${JSON.stringify(buildingsList, null, 2)}`);
+
+            if (!Array.isArray(buildingsList) || buildingsList.length === 0) {
+                if (this.logWarn) this.emit('warn', `No buildings found in MELCloud account`);
                 return null;
             }
 
@@ -81,31 +89,55 @@ class MelCloud extends EventEmitter {
             if (this.logDebug) this.emit('debug', `Buildings list saved`);
 
             const devices = [];
+
             for (const building of buildingsList) {
-                const buildingStructure = building.Structure;
+                if (!building.Structure) {
+                    this.emit(
+                        'warn',
+                        `Building missing structure: ${building.BuildingName || 'Unnamed'}`
+                    );
+                    continue;
+                }
+
+                const { Structure } = building;
+
                 const allDevices = [
-                    ...buildingStructure.Floors.flatMap(floor => [
-                        ...floor.Areas.flatMap(area => area.Devices),
-                        ...floor.Devices
-                    ]),
-                    ...buildingStructure.Areas.flatMap(area => area.Devices),
-                    ...buildingStructure.Devices
-                ];
+                    ...(Structure.Floors?.flatMap(floor => [
+                        ...(floor.Areas?.flatMap(area => area.Devices || []) || []),
+                        ...(floor.Devices || [])
+                    ]) || []),
+                    ...(Structure.Areas?.flatMap(area => area.Devices || []) || []),
+                    ...(Structure.Devices || [])
+                ].filter(d => d != null);
+
+                // Zamiana ID na string
+                allDevices.forEach(device => {
+                    if (device.DeviceID != null) device.DeviceID = String(device.DeviceID);
+                });
+
+                if (this.logDebug) {
+                    const count = allDevices.length;
+                    this.emit(
+                        'debug',
+                        `Found ${count} devices in building: ${building.BuildingName || 'Unnamed'}`
+                    );
+                }
+
                 devices.push(...allDevices);
             }
 
-            const devicesCount = devices.length;
-            if (devicesCount === 0) {
-                if (this.logWarn) this.emit('warn', `No devices found`);
+            if (devices.length === 0) {
+                if (this.logWarn) this.emit('warn', `No devices found in any building`);
                 return null;
             }
 
             await this.functions.saveData(this.devicesFile, devices);
-            if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
+            if (this.logDebug) this.emit('debug', `${devices.length} devices saved`);
 
             return devices;
         } catch (error) {
-            throw new Error(`Check devices list error: ${error.message}`);
+            const msg = error.response ? `HTTP ${error.response.status}: ${error.response.statusText}` : error.message;
+            throw new Error(`Check devices list error: ${msg}`);
         }
     }
 
@@ -113,17 +145,26 @@ class MelCloud extends EventEmitter {
         if (this.logDebug) this.emit('debug', `Connecting to MELCloud`);
 
         try {
-            const axiosInstanceLogin = axios.create({
+            const axiosInstance = axios.create({
                 method: 'POST',
                 baseURL: ApiUrls.BaseURL,
-                ...this.axiosDefaults
+                timeout: 15000,
             });
 
-            const accountData = await axiosInstanceLogin(ApiUrls.ClientLogin, { data: this.loginData });
+            const loginData = {
+                Email: this.user,
+                Password: this.passwd,
+                Language: this.language,
+                AppVersion: '1.34.12',
+                CaptchaChallenge: '',
+                CaptchaResponse: '',
+                Persist: true
+            };
+
+            const accountData = await axiosInstance(ApiUrls.ClientLogin, { data: loginData });
             const account = accountData.data;
-            const accountInfo = account.LoginData;
-            const contextKey = accountInfo?.ContextKey;
-            const useFahrenheit = accountInfo?.UseFahrenheit ?? false;
+            const accountInfo = account.LoginData ?? [];
+            const contextKey = accountInfo.ContextKey;
             this.contextKey = contextKey;
 
             const debugData = {
@@ -142,35 +183,26 @@ class MelCloud extends EventEmitter {
                 return null;
             }
 
-            this.axiosInstancePost = axios.create({
-                method: 'POST',
-                baseURL: ApiUrls.BaseURL,
-                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}`);
+            throw new Error(`Connect error: ${error.message}`);
         }
     }
 
-    async checkMelcloudHomeDevicesList(contextKey) {
+    // MELCloud Home
+    async checkMelcloudHomeDevicesList() {
         try {
             const axiosInstance = axios.create({
                 method: 'GET',
                 baseURL: ApiUrlsHome.BaseURL,
+                timeout: 25000,
                 headers: {
                     'Accept': '*/*',
                     'Accept-Language': 'en-US,en;q=0.9',
-                    'Cookie': contextKey,
+                    'Cookie': this.contextKey,
                     'User-Agent': 'homebridge-melcloud-control/4.0.0',
                     'DNT': '1',
                     'Origin': 'https://melcloudhome.com',
@@ -179,8 +211,7 @@ class MelCloud extends EventEmitter {
                     'Sec-Fetch-Mode': 'cors',
                     'Sec-Fetch-Site': 'same-origin',
                     'X-CSRF': '1'
-                },
-                ...this.axiosDefaults
+                }
             });
 
             if (this.logDebug) this.emit('debug', `Scanning for devices`);
@@ -196,10 +227,59 @@ class MelCloud extends EventEmitter {
             await this.functions.saveData(this.buildingsFile, buildingsList);
             if (this.logDebug) this.emit('debug', `Buildings list saved`);
 
-            const devices = buildingsList.flatMap(building => [
-                ...(building.airToAirUnits || []),
-                ...(building.airToWaterUnits || [])
-            ]);
+            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) => {
+                    // 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: this.contextKey,
+                        Type: type,
+                        DeviceID: Id,
+                        DeviceName: GivenDisplayName,
+                        Device: deviceObject
+                    };
+                };
+
+                return [
+                    ...(building.airToAirUnits || []).map(d => createDevice(capitalizeKeys(d), 0)),
+                    ...(building.airToWaterUnits || []).map(d => createDevice(capitalizeKeys(d), 1)),
+                    ...(building.airToVentilationUnits || []).map(d => createDevice(capitalizeKeys(d), 3))
+                ];
+            });
 
             const devicesCount = devices.length;
             if (devicesCount === 0) {
@@ -212,104 +292,205 @@ class MelCloud extends EventEmitter {
 
             return devices;
         } catch (error) {
-            throw new Error(`Connect to MELCloud Home error: ${error.message}`);
+            throw new Error(`Check devices list error: ${error.message}`);
         }
     }
 
-    async connectToMelCloudHome() {
-        if (this.logDebug) this.emit('debug', `Connecting to MELCloud Home`);
+    async connectToMelCloudHome1() {
+        try {
+            const melCloudHomeToken = new MelCloudHomeToken({
+                user: this.user,
+                passwd: this.passwd,
+                logWarn: this.logWarn,
+                logError: this.logError,
+                logDebug: this.logDebug,
+            })
+                .on('success', message => this.emit('success', message))
+                .on('warn', warn => this.emit('warn', warn))
+                .on('error', error => this.emit('error', error));
 
-        const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
-        const page = await browser.newPage();
+            const { codeVerifier, url } = await melCloudHomeToken.buildAuthorizeUrl();
+            const code = await melCloudHomeToken.loginToMelCloudHome(url);
+            const token = await melCloudHomeToken.getTokens(code, codeVerifier);
+
+            const accountInfo = { ContextKey: code, UseFahrenheit: false };
+            this.contextKey = code;
+
+            return accountInfo
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async connectToMelCloudHome(refresh = false) {
+        if (this.logDebug) this.emit('debug', `Connecting to MELCloud Home`);
+        let browser;
 
         try {
-            // Open MELCloud Home
-            await page.goto(ApiUrlsHome.BaseURL, { waitUntil: 'networkidle2' });
+            // --- System Detection & Chromium install ---
+            const chromiumPath = await this.functions.ensureChromiumInstalled(
+                msg => this.emit('debug', msg),
+                msg => this.emit('warn', msg),
+                msg => this.emit('error', msg)
+            );
+
+            const launchOptions = {
+                headless: true,
+                executablePath: chromiumPath,
+                args: [
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--single-process',
+                    '--no-zygote'
+                ]
+            };
+
+            browser = await puppeteer.launch(launchOptions);
+            const page = await browser.newPage();
+
+            // --- Event handlers ---
+            page.on('error', err => this.emit('error', `Page crashed: ${err.message}`));
+            page.on('pageerror', err => this.emit('error', `Browser error: ${err.message}`));
+            page.on('close', () => this.emit('debug', 'Page was closed unexpectedly'));
+            browser.on('disconnected', () => this.emit('debug', 'Browser disconnected unexpectedly'));
+
+            page.setDefaultTimeout(30000);
+            page.setDefaultNavigationTimeout(30000);
+
+            // --- Go to login page ---
+            await page.goto(ApiUrlsHome.BaseURL, { waitUntil: ['domcontentloaded', 'networkidle2'] });
+
+            // --- Login flow ---
             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' || text.trim() === 'Log In') {
+                const text = await page.evaluate(el => el.textContent.trim(), btn);
+                if (['Zaloguj', 'Sign In', 'Login'].includes(text)) {
                     loginBtn = btn;
                     break;
                 }
             }
+            if (!loginBtn) {
+                this.emit('warn', 'Login button not found');
+                return null;
+            }
 
-            if (!loginBtn && this.logWarn) this.emit('warn', `Login button not found`);
+            await Promise.race([
+                Promise.all([
+                    loginBtn.click(),
+                    page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: 15000 })
+                ]),
+                new Promise(r => setTimeout(r, 12000))
+            ]);
+
+            // --- Credentials ---
+            const usernameInput = await page.$('input[name="username"]');
+            const passwordInput = await page.$('input[name="password"]');
+            if (!usernameInput || !passwordInput) {
+                this.emit('warn', 'Username or password input not found');
+                return null;
+            }
 
-            // Set credentials and login
-            await Promise.all([loginBtn.click(), page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 20000 })]);
-            await page.waitForSelector('input[name="username"]', { timeout: 15000 });
             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: 20000 })]);
+            const submitButton = await page.$('input[type="submit"], button[type="submit"]');
+            if (!submitButton) {
+                this.emit('warn', 'Submit button not found on login form');
+                return null;
+            }
 
-            // Get cookies C1 and C2
+            await Promise.race([
+                Promise.all([
+                    submitButton.click(),
+                    page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: 20000 })
+                ]),
+                new Promise(r => setTimeout(r, 15000))
+            ]);
+
+            // --- Cookie extraction ---
             let c1 = null, c2 = null;
             const start = Date.now();
-
-            // Loop max 20s
             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) {
-                if (this.logWarn) this.emit('warn', `Cookies C1/C2 missing`);
+                this.emit('warn', 'Cookies C1/C2 missing after login');
                 return null;
             }
 
-            const accountInfo = {};
-            const contextKey = ['__Secure-monitorandcontrol=chunks-2', `__Secure-monitorandcontrolC1=${c1}`, `__Secure-monitorandcontrolC2=${c2}`,].join('; ');
-            const useFahrenheit = false;
+            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);
 
-            this.emit('success', `Connect to MELCloud Home Success`);
+            if (!refresh) this.emit('success', `Connect to MELCloud Home Success`);
+            return accountInfo;
 
-            return { accountInfo, contextKey, useFahrenheit };
         } catch (error) {
-            throw new Error(`Connect to MELCloud Home error: ${error.message}`);
+            throw new Error(`Connect error: ${error.message}`);
         } finally {
-            await browser.close();
+            if (browser) {
+                try {
+                    await browser.close();
+                } catch (closeErr) {
+                    this.emit('error', `Failed to close Puppeteer browser: ${closeErr.message}`);
+                }
+            }
         }
     }
 
-    async connect() {
-        let response = {};
-        switch (this.displayType) {
+    async checkDevicesList() {
+        let devices = [];
+        switch (this.accountType) {
             case "melcloud":
-                response = await this.connectToMelCloud();
-                return response
+                devices = await this.checkMelcloudDevicesList();
+                return devices
             case "melcloudhome":
-                response = await this.connectToMelCloudHome();
-                return response
+                devices = await this.checkMelcloudHomeDevicesList();
+                return devices;
             default:
-                return response
+                return devices;
         }
     }
 
-    async checkDevicesList(contextKey) {
-        let devices = [];
-        switch (this.displayType) {
+    async connect(refresh) {
+        let response = {};
+        switch (this.accountType) {
             case "melcloud":
-                devices = await this.checkMelcloudDevicesList(contextKey);
-                return devices
+                response = await this.connectToMelCloud();
+                return response
             case "melcloudhome":
-                devices = await this.checkMelcloudHomeDevicesList(contextKey);
-                return devices
+                response = await this.connectToMelCloudHome(refresh);
+                return response
             default:
-                return devices;
+                return response
         }
     }
 
     async send(accountInfo) {
         try {
+            const axiosInstance = axios.create({
+                baseURL: ApiUrls.BaseURL,
+                timeout: 15000,
+                headers: {
+                    'X-MitsContextKey': this.contextKey,
+                    'content-type': 'application/json'
+                }
+            });
+
             const options = { data: accountInfo };
-            await this.axiosInstancePost(ApiUrls.UpdateApplicationOptions, options);
+            await axiosInstance.post(ApiUrls.UpdateApplicationOptions, options);
             await this.functions.saveData(this.accountFile, accountInfo);
             return true;
         } catch (error) {