homebridge-melcloud-control 4.2.3-beta.1 → 4.2.3-beta.11

package/homebridge-ui/server.js

@@ -1,5 +1,6 @@
 import { HomebridgePluginUiServer } from '@homebridge/plugin-ui-utils';
 import MelCloud from '../src/melcloud.js';
+import MelCloudHome from '../src/melcloudhome.js';
 
 class PluginUiServer extends HomebridgePluginUiServer {
   constructor() {
@@ -17,7 +18,7 @@ class PluginUiServer extends HomebridgePluginUiServer {
     const accountFile = `${this.homebridgeStoragePath}/melcloud/${accountName}_Account`;
     const buildingsFile = `${this.homebridgeStoragePath}/melcloud/${accountName}_Buildings`;
     const devicesFile = `${this.homebridgeStoragePath}/melcloud/${accountName}_Devices`;
-    const melCloud = new MelCloud(account, accountFile, buildingsFile, devicesFile);
+    const melCloud = account.type === 'melcloud' ? new MelCloud(account, accountFile, buildingsFile, devicesFile) : new MelCloudHome(account, accountFile, buildingsFile, devicesFile);
 
     try {
       const accountInfo = await melCloud.connect();

package/index.js

@@ -1,6 +1,7 @@
 import { join } from 'path';
 import { mkdirSync, existsSync, writeFileSync } from 'fs';
 import MelCloud from './src/melcloud.js';
+import MelCloudHome from './src/melcloudhome.js';
 import DeviceAta from './src/deviceata.js';
 import DeviceAtw from './src/deviceatw.js';
 import DeviceErv from './src/deviceerv.js';
@@ -84,8 +85,8 @@ class MelCloudPlatform {
 						.on('start', async () => {
 							try {
 								//melcloud account
-								const melCloud = new MelCloud(account, accountFile, buildingsFile, devicesFile, true)
-									.on('success', (msg) => logLevel.success && log.success(`${accountName}, ${msg}`))
+								const melCloud = account.type === 'melcloud' ? new MelCloud(account, accountFile, buildingsFile, devicesFile, true) : new MelCloudHome(account, accountFile, buildingsFile, devicesFile, true);
+								melCloud.on('success', (msg) => logLevel.success && log.success(`${accountName}, ${msg}`))
 									.on('info', (msg) => logLevel.info && log.info(`${accountName}, ${msg}`))
 									.on('debug', (msg) => logLevel.debug && log.info(`${accountName}, debug: ${msg}`))
 									.on('warn', (msg) => logLevel.warn && log.warn(`${accountName}, ${msg}`))

package/package.json

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

package/src/deviceata.js

@@ -334,8 +334,6 @@ class DeviceAta extends EventEmitter {
                             return state;
                         })
                         .onSet(async (state) => {
-                            if (!!state === this.accessory.power) return;
-
                             try {
                                 deviceData.Device.Power = state ? true : false;
                                 await this.melCloudAta.send(this.accountType, this.displayType, deviceData, AirConditioner.EffectiveFlags.Power);
@@ -1331,7 +1329,7 @@ class DeviceAta extends EventEmitter {
                         maxTempHeat: maxTempHeat,
                         minTempCoolDryAuto: minTempCoolDryAuto,
                         maxTempCoolDryAuto: maxTempCoolDryAuto,
-                        power: power ? 1 : 0,
+                        power: power,
                         inStandbyMode: inStandbyMode,
                         operationMode: operationMode,
                         currentOperationMode: 0,
@@ -1427,7 +1425,7 @@ class DeviceAta extends EventEmitter {
 
                             //update characteristics
                             this.melCloudService
-                                ?.updateCharacteristic(Characteristic.Active, power ? 1 : 0)
+                                ?.updateCharacteristic(Characteristic.Active, power)
                                 .updateCharacteristic(Characteristic.CurrentHeaterCoolerState, obj.currentOperationMode)
                                 .updateCharacteristic(Characteristic.TargetHeaterCoolerState, obj.targetOperationMode)
                                 .updateCharacteristic(Characteristic.CurrentTemperature, roomTemperature)

package/src/deviceatw.js

@@ -340,8 +340,6 @@ class DeviceAtw extends EventEmitter {
                                     return state;
                                 })
                                 .onSet(async (state) => {
-                                    if (!!state === this.accessory.power) return;
-
                                     try {
                                         switch (i) {
                                             case 0: //Heat Pump
@@ -1340,8 +1338,15 @@ class DeviceAtw extends EventEmitter {
                                             effectiveFlags = HeatPump.EffectiveFlags.Power + HeatPump.EffectiveFlags.OperationMode;
                                             break;
                                         case 3: //HOLIDAY
-                                            deviceData.Device.HolidayMode = state;
-                                            effectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
+                                            if (this.accountType === 'melcloud') {
+                                                deviceData.Device.HolidayMode = state;
+                                                effectiveFlags = HeatPump.EffectiveFlags.HolidayMode;
+                                            }
+
+                                            if (this.accountType === 'melcloudhome') {
+                                                deviceData.Device.HolidayMode.Enabled = state;
+                                                effectiveFlags = 'holidaymode';
+                                            }
                                             break;
                                         case 10: //ALL ZONES PHYSICAL LOCK CONTROL
                                             deviceData.Device.ProhibitZone1 = state;
@@ -1510,7 +1515,8 @@ class DeviceAtw extends EventEmitter {
                     const scheduleEnabled = deviceData.ScheduleEnabled;
                     const schedulesOnServer = deviceData.Schedule ?? [];
                     const presetsOnServer = deviceData.Presets ?? [];
-                    const holidayModeEnabled = deviceData.HolidayMode?.Enabled;
+                    const holidayMode = deviceData.Device.HolidayMode;
+                    const holidayModeEnabled = accountTypeMelcloud ? holidayMode : deviceData.HolidayMode?.Enabled;
                     const holidayModeActive = deviceData.HolidayMode?.Active ?? false;
 
                     //device info
@@ -1545,12 +1551,11 @@ class DeviceAtw extends EventEmitter {
 
                     //heat pump
                     const heatPumpName = 'Heat Pump';
-                    const power = deviceData.Device.Power ?? false;
+                    const power = deviceData.Device.Power;
                     const inStandbyMode = deviceData.Device.InStandbyMode;
                     const unitStatus = deviceData.Device.UnitStatus ?? 0;
                     const operationMode = deviceData.Device.OperationMode;
                     const outdoorTemperature = deviceData.Device.OutdoorTemperature;
-                    const holidayMode = deviceData.Device.HolidayMode ?? false;
                     const flowTemperatureHeatPump = deviceData.Device.FlowTemperature;
                     const returnTemperatureHeatPump = deviceData.Device.ReturnTemperature;
                     const isConnected = accountTypeMelcloud ? !deviceData.Device[connectKey] : deviceData.Device[connectKey];
@@ -1594,7 +1599,7 @@ class DeviceAtw extends EventEmitter {
                     const obj = {
                         presets: presetsOnServer,
                         schedules: schedulesOnServer,
-                        power: power ? 1 : 0,
+                        power: power,
                         inStandbyMode: inStandbyMode,
                         unitStatus: unitStatus,
                         idleZone1: idleZone1,
@@ -2065,7 +2070,7 @@ class DeviceAtw extends EventEmitter {
                                     button.state = power ? (operationMode === 1) : false;
                                     break;
                                 case 53: //HOLIDAY
-                                    button.state = power ? (holidayMode === true) : false;
+                                    button.state = power ? (holidayModeEnabled === true) : false;
                                     break;
                                 case 10: //ALL ZONES PHYSICAL LOCK CONTROL
                                     button.state = power ? (prohibitZone1 === true && prohibitHotWater === true && prohibitZone2 === true) : false;

package/src/deviceerv.js

@@ -305,8 +305,6 @@ class DeviceErv extends EventEmitter {
                             return state;
                         })
                         .onSet(async (state) => {
-                            if (!!state === this.accessory.power) return;
-
                             try {
                                 deviceData.Device.Power = state ? true : false;
                                 await this.melCloudErv.send(this.accountType, this.displayType, deviceData, Ventilation.EffectiveFlags.Power);
@@ -1136,7 +1134,7 @@ class DeviceErv extends EventEmitter {
                         actualVentilationMode: actualVentilationMode,
                         numberOfFanSpeeds: numberOfFanSpeeds,
                         supportsFanSpeed: supportsFanSpeed,
-                        power: power ? 1 : 0,
+                        power: power,
                         inStandbyMode: inStandbyMode,
                         operationMode: operationMode,
                         currentOperationMode: 0,

package/src/melcloud.js

@@ -1,13 +1,10 @@
-import fs from 'fs';
 import axios from 'axios';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import EventEmitter from 'events';
-import puppeteer from 'puppeteer';
 import ImpulseGenerator from './impulsegenerator.js';
 import Functions from './functions.js';
-import { ApiUrls, ApiUrlsHome } from './constants.js';
-const execPromise = promisify(exec);
+import { ApiUrls } from './constants.js';
 
 class MelCloud extends EventEmitter {
     constructor(account, accountFile, buildingsFile, devicesFile, pluginStart = false) {
@@ -61,23 +58,22 @@ class MelCloud extends EventEmitter {
     }
 
     // MELCloud
-    async checkMelcloudDevicesList() {
+    async checkDevicesList() {
         try {
             const devicesList = { State: false, Info: null, Devices: [] }
             const headers = {
                 'X-MitsContextKey': this.contextKey,
                 'Content-Type': 'application/json'
             }
-            const axiosInstance = axios.create({
+
+            if (this.logDebug) this.emit('debug', `Scanning for devices...`);
+            const listDevicesData = await axios(ApiUrls.ListDevices, {
                 method: 'GET',
                 baseURL: ApiUrls.BaseURL,
                 timeout: 15000,
                 headers: headers
             });
 
-            if (this.logDebug) this.emit('debug', `Scanning for devices...`);
-            const listDevicesData = await axiosInstance(ApiUrls.ListDevices);
-
             if (!listDevicesData || !listDevicesData.data) {
                 devicesList.Info = 'Invalid or empty response from MELCloud API'
                 return devicesList;
@@ -138,28 +134,27 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    async connectToMelCloud() {
+    async connect() {
         if (this.logDebug) this.emit('debug', `Connecting to MELCloud`);
 
         try {
             const accountInfo = { State: false, Info: '', LoginData: null, ContextKey: null, UseFahrenheit: false }
-            const axiosInstance = axios.create({
+
+            const payload = {
+                Email: this.user,
+                Password: this.passwd,
+                Language: this.language,
+                AppVersion: '1.34.12',
+                CaptchaChallenge: '',
+                CaptchaResponse: '',
+                Persist: true
+            };
+            const accountData = await axios(ApiUrls.ClientLogin, {
                 method: 'POST',
                 baseURL: ApiUrls.BaseURL,
                 timeout: 15000,
-                data: {
-                    Email: this.user,
-                    Password: this.passwd,
-                    Language: this.language,
-                    AppVersion: '1.34.12',
-                    CaptchaChallenge: '',
-                    CaptchaResponse: '',
-                    Persist: true
-                }
+                data: payload
             });
-
-
-            const accountData = await axiosInstance(ApiUrls.ClientLogin);
             const account = accountData.data;
             const loginData = account.LoginData ?? [];
             const contextKey = loginData.ContextKey;
@@ -193,332 +188,6 @@ class MelCloud extends EventEmitter {
         }
     }
 
-    // MELCloud Home
-    async checkMelcloudHomeDevicesList() {
-        try {
-            const devicesList = { State: false, Info: null, Devices: [] }
-            const headers = {
-                'Accept': '*/*',
-                'Accept-Language': 'en-US,en;q=0.9',
-                'Cookie': this.contextKey,
-                'User-Agent': 'homebridge-melcloud-control/4.0.0',
-                'DNT': '1',
-                'Origin': 'https://melcloudhome.com',
-                'Referer': 'https://melcloudhome.com/dashboard',
-                'Sec-Fetch-Dest': 'empty',
-                'Sec-Fetch-Mode': 'cors',
-                'Sec-Fetch-Site': 'same-origin',
-                'X-CSRF': '1'
-            };
-            const axiosInstance = axios.create({
-                method: 'GET',
-                baseURL: ApiUrlsHome.BaseURL,
-                timeout: 25000,
-                headers: headers
-            });
-
-            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) {
-                devicesList.Info = 'No building found'
-                return devicesList;
-            }
-
-            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
-                        ])
-                    );
-
-                // Rekurencyjna kapitalizacja kluczy w obiekcie lub tablicy
-                const capitalizeKeysDeep = obj => {
-                    if (Array.isArray(obj)) return obj.map(capitalizeKeysDeep);
-                    if (obj && typeof obj === 'object') {
-                        return Object.fromEntries(
-                            Object.entries(obj).map(([key, value]) => [
-                                key.charAt(0).toUpperCase() + key.slice(1),
-                                capitalizeKeysDeep(value)
-                            ])
-                        );
-                    }
-                    return obj;
-                };
-
-                // 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,
-                        IsConnected: device.IsConnected
-                    };
-
-                    // Kapitalizacja brakujących obiektów/tablic
-                    if (device.FrostProtection) device.FrostProtection = { ...capitalizeKeys(device.FrostProtection || {}) };
-                    if (device.OverheatProtection) device.OverheatProtection = { ...capitalizeKeys(device.OverheatProtection || {}) };
-                    if (device.HolidayMode) device.HolidayMode = { ...capitalizeKeys(device.HolidayMode || {}) };
-                    if (Array.isArray(device.Schedule)) device.Schedule = device.Schedule.map(capitalizeKeysDeep);
-
-                    // Usuń stare pola Settings i Capabilities
-                    const { Settings, Capabilities, Id, GivenDisplayName, ...rest } = device;
-
-                    return {
-                        ...rest,
-                        Type: type,
-                        DeviceID: Id,
-                        DeviceName: GivenDisplayName,
-                        Device: deviceObject,
-                        Headers: headers
-                    };
-                };
-
-                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) {
-                devicesList.Info = 'No devices found'
-                return devicesList;
-            }
-
-            await this.functions.saveData(this.devicesFile, devices);
-            if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
-
-            devicesList.State = true;
-            devicesList.Info = `Found ${devicesCount} devices`;
-            devicesList.Devices = devices;
-            return devicesList;
-        } catch (error) {
-            if (error.response?.status === 401) {
-                await connectToMelCloudHome();
-                if (this.logWarn) this.emit('warn', 'Check devices list not possible, cookies expired, trying to get new.');
-                return;
-            }
-
-            throw new Error(`Check devices list error: ${error.message}`);
-        }
-    }
-
-    async connectToMelCloudHome() {
-        if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
-        const GLOBAL_TIMEOUT = 90000;
-
-        let browser;
-        try {
-            const accountInfo = { State: false, Info: '', ContextKey: null, UseFahrenheit: false };
-            let chromiumPath = await this.functions.ensureChromiumInstalled();
-
-            // === Fallback to Puppeteer's built-in Chromium ===
-            if (!chromiumPath) {
-                try {
-                    const puppeteerPath = puppeteer.executablePath();
-                    if (puppeteerPath && fs.existsSync(puppeteerPath)) {
-                        chromiumPath = puppeteerPath;
-                        if (this.logDebug) this.emit('debug', `Using puppeteer Chromium at ${chromiumPath}`);
-                    }
-                } catch { }
-            } else {
-                if (this.logDebug) this.emit('debug', `Using system Chromium at ${chromiumPath}`);
-            }
-
-            if (!chromiumPath) {
-                accountInfo.Info = 'Chromium not found on Your device, please install it manually and try again';
-                return accountInfo;
-            }
-
-            // Verify executable works
-            try {
-                const { stdout } = await execPromise(`"${chromiumPath}" --version`);
-                if (this.logDebug) this.emit('debug', `Chromium detected: ${stdout.trim()}`);
-            } catch (error) {
-                accountInfo.Info = `Chromium found at ${chromiumPath}, but cannot be executed: ${error.message}`;
-                return accountInfo;
-            }
-
-            if (this.logDebug) this.emit('debug', `Launching Chromium...`);
-            browser = await puppeteer.launch({
-                headless: true,
-                executablePath: chromiumPath,
-                timeout: GLOBAL_TIMEOUT,
-                args: [
-                    '--no-sandbox',
-                    '--disable-setuid-sandbox',
-                    '--disable-dev-shm-usage',
-                    '--single-process',
-                    '--disable-gpu',
-                    '--no-zygote'
-                ]
-            });
-            browser.on('disconnected', () => this.emit('debug', 'Browser disconnected'));
-
-            const page = await browser.newPage();
-            page.on('error', error => this.emit('error', `Page crashed: ${error.message}`));
-            page.on('pageerror', error => this.emit('error', `Browser error: ${error.message}`));
-            page.setDefaultTimeout(GLOBAL_TIMEOUT);
-            page.setDefaultNavigationTimeout(GLOBAL_TIMEOUT);
-
-            // Clear cookies before navigation
-            try {
-                const client = await page.createCDPSession();
-                await client.send('Network.clearBrowserCookies');
-            } catch (error) {
-                if (this.logError) this.emit('error', `Clear cookies error: ${error.message}`);
-            }
-
-            try {
-                await page.goto(ApiUrlsHome.BaseURL, { waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT });
-            } catch (error) {
-                accountInfo.Info = `Navigation to ${ApiUrlsHome.BaseURL} failed: ${error.message}`;
-                return accountInfo;
-            }
-
-            // Wait extra to ensure UI is rendered
-            await new Promise(r => setTimeout(r, 3000));
-            const loginBtn = await page.waitForSelector('button.btn--blue', { timeout: GLOBAL_TIMEOUT / 4 });
-            const loginText = await page.evaluate(el => el.textContent.trim(), loginBtn);
-
-            if (!['Zaloguj', 'Sign In', 'Login'].includes(loginText)) {
-                accountInfo.Info = `Login button ${loginText} not found`;
-                return accountInfo;
-            }
-
-            await loginBtn.click();
-            await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: GLOBAL_TIMEOUT / 3 });
-
-            const usernameInput = await page.$('input[name="username"]');
-            const passwordInput = await page.$('input[name="password"]');
-            if (!usernameInput || !passwordInput) {
-                accountInfo.Info = 'Username or password input not found';
-                return accountInfo;
-            }
-
-            await page.type('input[name="username"]', this.user, { delay: 50 });
-            await page.type('input[name="password"]', this.passwd, { delay: 50 });
-
-            const submitButton = await page.$('input[type="submit"], button[type="submit"]');
-            if (!submitButton) {
-                accountInfo.Info = 'Submit button not found';
-                return accountInfo;
-            }
-            await Promise.race([Promise.all([submitButton.click(), page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT / 4 })]), new Promise(r => setTimeout(r, GLOBAL_TIMEOUT / 3))]);
-
-            // Extract cookies
-            let c1 = null, c2 = null;
-            const start = Date.now();
-            while ((!c1 || !c2) && Date.now() - start < GLOBAL_TIMEOUT / 2) {
-                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) {
-                accountInfo.Info = 'Cookies C1/C2 missing';
-                return accountInfo;
-            }
-
-            const contextKey = [
-                '__Secure-monitorandcontrol=chunks-2',
-                `__Secure-monitorandcontrolC1=${c1}`,
-                `__Secure-monitorandcontrolC2=${c2}`
-            ].join('; ');
-            this.contextKey = contextKey;
-
-            accountInfo.State = true;
-            accountInfo.Info = 'Connect to MELCloud Home Success';
-            accountInfo.ContextKey = contextKey;
-            await this.functions.saveData(this.accountFile, accountInfo);
-
-            return accountInfo;
-        } catch (error) {
-            throw new Error(`Connect error: ${error.message}`);
-        } finally {
-            if (browser) {
-                try { await browser.close(); }
-                catch (closeErr) {
-                    if (this.logError) this.emit('error', `Failed to close Puppeteer: ${closeErr.message}`);
-                }
-            }
-        }
-    }
-
-    async checkDevicesList() {
-        const TIMEOUT_MS = 30000; // 30 seconds timeout
-        try {
-            const devicesList = await Promise.race([
-                (async () => {
-                    switch (this.accountType) {
-                        case "melcloud":
-                            return await this.checkMelcloudDevicesList();
-                        case "melcloudhome":
-                            return await this.checkMelcloudHomeDevicesList();
-                        default:
-                            return [];
-                    }
-                })(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Device list timeout (30s)')), TIMEOUT_MS))
-            ]);
-
-            return devicesList;
-        } catch (error) {
-            throw new Error(error);
-        }
-    }
-
-    async connect() {
-        const TIMEOUT_MS = 120000;
-
-        try {
-            const response = await Promise.race([
-                (async () => {
-                    switch (this.accountType) {
-                        case "melcloud":
-                            return await this.connectToMelCloud();
-                        case "melcloudhome":
-                            return await this.connectToMelCloudHome();
-                        default:
-                            return {};
-                    }
-                })(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout (90s)')), TIMEOUT_MS))
-            ]);
-
-            return response;
-        } catch (error) {
-            throw new Error(error);
-        }
-    }
-
     async send(accountInfo) {
         try {
             const axiosInstance = axios.create({

package/src/melcloudata.js

@@ -52,10 +52,6 @@ class MelCloudAta extends EventEmitter {
         try {
             //read device info from file
             const devicesData = await this.functions.readData(this.devicesFile, true);
-            if (!Array.isArray(devicesData)) {
-                if (this.logWarn) this.emit('warn', `Device data not found`);
-                return null;
-            }
             const deviceData = devicesData.find(device => device.DeviceID === this.deviceId);
 
             if (this.accountType === 'melcloudhome') {
@@ -118,10 +114,7 @@ class MelCloudAta extends EventEmitter {
 
             //check state changes
             const deviceDataHasNotChanged = JSON.stringify(deviceData) === JSON.stringify(this.deviceData);
-            if (deviceDataHasNotChanged) {
-                if (this.logDebug) this.emit('debug', `Device state not changed`);
-                return;
-            }
+            if (deviceDataHasNotChanged) return;
             this.deviceData = deviceData;
 
             //emit info
@@ -167,17 +160,15 @@ class MelCloudAta extends EventEmitter {
                         HideDryModeControl: deviceData.HideDryModeControl,
                         HasPendingCommand: true
                     };
-                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
 
-                    const axiosInstancePost = axios.create({
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(ApiUrls.SetAta, {
                         method: 'POST',
                         baseURL: ApiUrls.BaseURL,
                         timeout: 10000,
                         headers: deviceData.Headers,
                         data: payload
                     });
-
-                    await axiosInstancePost(ApiUrls.SetAta);
                     this.updateData(deviceData);
                     return true;
                 case "melcloudhome":
@@ -243,16 +234,14 @@ class MelCloudAta extends EventEmitter {
                             break
                     }
 
-                    const axiosInstancePut = axios.create({
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(path, {
                         method: method,
                         baseURL: ApiUrlsHome.BaseURL,
                         timeout: 10000,
                         headers: deviceData.Headers,
                         data: payload
                     });
-
-                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
-                    await axiosInstancePut(path);
                     this.updateData(deviceData);
                     return true;
                 default:
@@ -272,6 +261,5 @@ class MelCloudAta extends EventEmitter {
             this.lock = false
         }, 3000);
     }
-
 };
 export default MelCloudAta;

package/src/melcloudatw.js

@@ -52,10 +52,6 @@ class MelCloudAtw extends EventEmitter {
         try {
             //read device info from file
             const devicesData = await this.functions.readData(this.devicesFile, true);
-            if (!Array.isArray(devicesData)) {
-                if (this.logWarn) this.emit('warn', `Device data not found`);
-                return null;
-            }
             const deviceData = devicesData.find(device => device.DeviceID === this.deviceId);
 
             if (this.accountType === 'melcloudhome') {
@@ -109,10 +105,7 @@ class MelCloudAtw extends EventEmitter {
 
             //check state changes
             const deviceDataHasNotChanged = JSON.stringify(devicesData) === JSON.stringify(this.devicesData);
-            if (deviceDataHasNotChanged) {
-                if (this.logDebug) this.emit('debug', `Device state not changed`);
-                return;
-            }
+            if (deviceDataHasNotChanged)  return;
             this.devicesData = devicesData;
 
             //emit info
@@ -148,93 +141,81 @@ class MelCloudAtw extends EventEmitter {
             let path = '';
             switch (accountType) {
                 case "melcloud":
-                    const axiosInstancePost = axios.create({
+                    deviceData.Device.EffectiveFlags = effectiveFlags;
+                    payload = {
+                        DeviceID: deviceData.Device.DeviceID,
+                        EffectiveFlags: deviceData.Device.EffectiveFlags,
+                        Power: deviceData.Device.Power,
+                        SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
+                        SetTemperatureZone2: deviceData.Device.SetTemperatureZone2,
+                        OperationMode: deviceData.Device.OperationMode,
+                        OperationModeZone1: deviceData.Device.OperationModeZone1,
+                        OperationModeZone2: deviceData.Device.OperationModeZone2,
+                        SetHeatFlowTemperatureZone1: deviceData.Device.SetHeatFlowTemperatureZone1,
+                        SetHeatFlowTemperatureZone2: deviceData.Device.SetHeatFlowTemperatureZone2,
+                        SetCoolFlowTemperatureZone1: deviceData.Device.SetCoolFlowTemperatureZone1,
+                        SetCoolFlowTemperatureZone2: deviceData.Device.SetCoolFlowTemperatureZone2,
+                        SetTankWaterTemperature: deviceData.Device.SetTankWaterTemperature,
+                        ForcedHotWaterMode: deviceData.Device.ForcedHotWaterMode,
+                        EcoHotWater: deviceData.Device.EcoHotWater,
+                        HolidayMode: deviceData.Device.HolidayMode,
+                        ProhibitZone1: deviceData.Device.ProhibitHeatingZone1,
+                        ProhibitZone2: deviceData.Device.ProhibitHeatingZone2,
+                        ProhibitHotWater: deviceData.Device.ProhibitHotWater,
+                        HasPendingCommand: true
+                    }
+
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(ApiUrls.SetAtw, {
                         method: 'POST',
                         baseURL: ApiUrls.BaseURL,
                         timeout: 10000,
                         headers: deviceData.Headers,
-                        withCredentials: true
+                        data: payload
                     });
-
-                    deviceData.Device.EffectiveFlags = effectiveFlags;
-                    payload = {
-                        data: {
-                            DeviceID: deviceData.Device.DeviceID,
-                            EffectiveFlags: deviceData.Device.EffectiveFlags,
-                            Power: deviceData.Device.Power,
-                            SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
-                            SetTemperatureZone2: deviceData.Device.SetTemperatureZone2,
-                            OperationMode: deviceData.Device.OperationMode,
-                            OperationModeZone1: deviceData.Device.OperationModeZone1,
-                            OperationModeZone2: deviceData.Device.OperationModeZone2,
-                            SetHeatFlowTemperatureZone1: deviceData.Device.SetHeatFlowTemperatureZone1,
-                            SetHeatFlowTemperatureZone2: deviceData.Device.SetHeatFlowTemperatureZone2,
-                            SetCoolFlowTemperatureZone1: deviceData.Device.SetCoolFlowTemperatureZone1,
-                            SetCoolFlowTemperatureZone2: deviceData.Device.SetCoolFlowTemperatureZone2,
-                            SetTankWaterTemperature: deviceData.Device.SetTankWaterTemperature,
-                            ForcedHotWaterMode: deviceData.Device.ForcedHotWaterMode,
-                            EcoHotWater: deviceData.Device.EcoHotWater,
-                            HolidayMode: deviceData.Device.HolidayMode,
-                            ProhibitZone1: deviceData.Device.ProhibitHeatingZone1,
-                            ProhibitZone2: deviceData.Device.ProhibitHeatingZone2,
-                            ProhibitHotWater: deviceData.Device.ProhibitHotWater,
-                            HasPendingCommand: true
-                        }
-                    }
-
-                    await axiosInstancePost(ApiUrls.SetAtw, payload);
                     this.updateData(deviceData);
                     return true;
                 case "melcloudhome":
                     switch (effectiveFlags) {
                         case 'holidaymode':
-                            payload = {
-                                data: { enabled: deviceData.HolidayMode.Enabled, startDate: deviceData.HolidayMode.StartDate, endDate: deviceData.HolidayMode.EndDate, units: { "ATW": [deviceData.DeviceID] } }
-                            };
+                            payload = { enabled: deviceData.HolidayMode.Enabled, startDate: deviceData.HolidayMode.StartDate, endDate: deviceData.HolidayMode.EndDate, units: { "ATW": [deviceData.DeviceID] } };
                             method = 'POST';
                             path = ApiUrlsHome.PostHolidayMode;
                             break;
                         case 'schedule':
-                            payload = {
-                                data: {
-                                    enabled: deviceData.ScheduleEnabled
-                                }
-                            };
+                            payload = { enabled: deviceData.ScheduleEnabled };
                             method = 'PUT';
                             path = ApiUrlsHome.PutScheduleEnable.replace('deviceid', deviceData.DeviceID);
                             break;
                         default:
                             payload = {
-                                data: {
-                                    Power: deviceData.Device.Power,
-                                    SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
-                                    SetTemperatureZone2: deviceData.Device.SetTemperatureZone2,
-                                    OperationMode: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationMode],
-                                    OperationModeZone1: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationModeZone1],
-                                    OperationModeZone2: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationModeZone2],
-                                    SetHeatFlowTemperatureZone1: deviceData.Device.SetHeatFlowTemperatureZone1,
-                                    SetHeatFlowTemperatureZone2: deviceData.Device.SetHeatFlowTemperatureZone2,
-                                    SetCoolFlowTemperatureZone1: deviceData.Device.SetCoolFlowTemperatureZone1,
-                                    SetCoolFlowTemperatureZone2: deviceData.Device.SetCoolFlowTemperatureZone2,
-                                    SetTankWaterTemperature: deviceData.Device.SetTankWaterTemperature,
-                                    ForcedHotWaterMode: deviceData.Device.ForcedHotWaterMode,
-                                    EcoHotWater: deviceData.Device.EcoHotWater,
-                                }
+                                Power: deviceData.Device.Power,
+                                SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
+                                SetTemperatureZone2: deviceData.Device.SetTemperatureZone2,
+                                OperationMode: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationMode],
+                                OperationModeZone1: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationModeZone1],
+                                OperationModeZone2: HeatPump.OperationModeMapEnumToString[deviceData.Device.OperationModeZone2],
+                                SetHeatFlowTemperatureZone1: deviceData.Device.SetHeatFlowTemperatureZone1,
+                                SetHeatFlowTemperatureZone2: deviceData.Device.SetHeatFlowTemperatureZone2,
+                                SetCoolFlowTemperatureZone1: deviceData.Device.SetCoolFlowTemperatureZone1,
+                                SetCoolFlowTemperatureZone2: deviceData.Device.SetCoolFlowTemperatureZone2,
+                                SetTankWaterTemperature: deviceData.Device.SetTankWaterTemperature,
+                                ForcedHotWaterMode: deviceData.Device.ForcedHotWaterMode,
+                                EcoHotWater: deviceData.Device.EcoHotWater,
                             };
                             method = 'PUT';
                             path = ApiUrlsHome.SetAtw.replace('deviceid', deviceData.DeviceID);
                             break
                     }
 
-                    const axiosInstancePut = axios.create({
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(path, {
                         method: method,
                         baseURL: ApiUrlsHome.BaseURL,
                         timeout: 10000,
-                        headers: deviceData.Headers
+                        headers: deviceData.Headers,
+                        data: payload
                     });
-
-                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload.data, null, 2)}`);
-                    await axiosInstancePut(path, payload);
                     this.updateData(deviceData);
                     return true;
                 default:

package/src/melclouderv.js

@@ -52,10 +52,6 @@ class MelCloudErv extends EventEmitter {
         try {
             //read device info from file
             const devicesData = await this.functions.readData(this.devicesFile, true);
-            if (!Array.isArray(devicesData)) {
-                if (this.logWarn) this.emit('warn', `Device data not found`);
-                return null;
-            }
             const deviceData = devicesData.find(device => device.DeviceID === this.deviceId);
 
             if (this.accountType === 'melcloudhome') {
@@ -112,10 +108,7 @@ class MelCloudErv extends EventEmitter {
 
             //check state changes
             const deviceDataHasNotChanged = JSON.stringify(devicesData) === JSON.stringify(this.devicesData);
-            if (deviceDataHasNotChanged) {
-                if (this.logDebug) this.emit('debug', `Device state not changed`);
-                return;
-            }
+            if (deviceDataHasNotChanged) return;
             this.devicesData = devicesData;
 
             //emit info
@@ -137,14 +130,6 @@ class MelCloudErv extends EventEmitter {
             let path = '';
             switch (accountType) {
                 case "melcloud":
-                    const axiosInstancePost = axios.create({
-                        method: 'POST',
-                        baseURL: ApiUrls.BaseURL,
-                        timeout: 10000,
-                        headers: deviceData.Headers,
-                        withCredentials: true
-                    });
-
                     //set target temp based on display mode and ventilation mode
                     switch (displayType) {
                         case 1: //Heather/Cooler
@@ -168,25 +153,30 @@ class MelCloudErv extends EventEmitter {
                     //device state
                     deviceData.Device.EffectiveFlags = effectiveFlags;
                     payload = {
-                        data: {
-                            DeviceID: deviceData.Device.DeviceID,
-                            EffectiveFlags: deviceData.Device.EffectiveFlags,
-                            Power: deviceData.Device.Power,
-                            SetTemperature: deviceData.Device.SetTemperature,
-                            SetFanSpeed: deviceData.Device.SetFanSpeed,
-                            OperationMode: deviceData.Device.OperationMode,
-                            VentilationMode: deviceData.Device.VentilationMode,
-                            DefaultCoolingSetTemperature: deviceData.Device.DefaultCoolingSetTemperature,
-                            DefaultHeatingSetTemperature: deviceData.Device.DefaultHeatingSetTemperature,
-                            HideRoomTemperature: deviceData.Device.HideRoomTemperature,
-                            HideSupplyTemperature: deviceData.Device.HideSupplyTemperature,
-                            HideOutdoorTemperature: deviceData.Device.HideOutdoorTemperature,
-                            NightPurgeMode: deviceData.Device.NightPurgeMode,
-                            HasPendingCommand: true
-                        }
+                        DeviceID: deviceData.Device.DeviceID,
+                        EffectiveFlags: deviceData.Device.EffectiveFlags,
+                        Power: deviceData.Device.Power,
+                        SetTemperature: deviceData.Device.SetTemperature,
+                        SetFanSpeed: deviceData.Device.SetFanSpeed,
+                        OperationMode: deviceData.Device.OperationMode,
+                        VentilationMode: deviceData.Device.VentilationMode,
+                        DefaultCoolingSetTemperature: deviceData.Device.DefaultCoolingSetTemperature,
+                        DefaultHeatingSetTemperature: deviceData.Device.DefaultHeatingSetTemperature,
+                        HideRoomTemperature: deviceData.Device.HideRoomTemperature,
+                        HideSupplyTemperature: deviceData.Device.HideSupplyTemperature,
+                        HideOutdoorTemperature: deviceData.Device.HideOutdoorTemperature,
+                        NightPurgeMode: deviceData.Device.NightPurgeMode,
+                        HasPendingCommand: true
                     }
 
-                    await axiosInstancePost(ApiUrls.SetErv, payload);
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(ApiUrls.SetErv, {
+                        method: 'POST',
+                        baseURL: ApiUrls.BaseURL,
+                        timeout: 10000,
+                        headers: deviceData.Headers,
+                        data: payload
+                    });
                     this.updateData(deviceData);
                     return true;
                 case "melcloudhome":
@@ -204,45 +194,36 @@ class MelCloudErv extends EventEmitter {
 
                     switch (effectiveFlags) {
                         case 'holidaymode':
-                            payload = {
-                                data: { enabled: deviceData.HolidayMode.Enabled, startDate: deviceData.HolidayMode.StartDate, endDate: deviceData.HolidayMode.EndDate, units: { "ERV": [deviceData.DeviceID] } }
-                            };
+                            payload = { enabled: deviceData.HolidayMode.Enabled, startDate: deviceData.HolidayMode.StartDate, endDate: deviceData.HolidayMode.EndDate, units: { "ERV": [deviceData.DeviceID] } };
                             method = 'POST';
                             path = ApiUrlsHome.PostHolidayMode;
                             break;
                         case 'schedule':
-                            payload = {
-                                data: {
-                                    enabled: deviceData.ScheduleEnabled
-                                }
-                            };
+                            payload = { enabled: deviceData.ScheduleEnabled };
                             method = 'PUT';
                             path = ApiUrlsHome.PutScheduleEnable.replace('deviceid', deviceData.DeviceID);
                             break;
                         default:
                             payload = {
-                                data: {
-                                    Power: deviceData.Device.Power,
-                                    SetTemperature: deviceData.Device.SetTemperature,
-                                    SetFanSpeed: String(deviceData.Device.SetFanSpeed),
-                                    OperationMode: Ventilation.OperationModeMapEnumToString[deviceData.Device.OperationMode],
-                                    VentilationMode: Ventilation.VentilationModeMapEnumToString[deviceData.Device.VentilationMode],
-                                }
+                                Power: deviceData.Device.Power,
+                                SetTemperature: deviceData.Device.SetTemperature,
+                                SetFanSpeed: String(deviceData.Device.SetFanSpeed),
+                                OperationMode: Ventilation.OperationModeMapEnumToString[deviceData.Device.OperationMode],
+                                VentilationMode: Ventilation.VentilationModeMapEnumToString[deviceData.Device.VentilationMode],
                             };
                             method = 'PUT';
                             path = ApiUrlsHome.SetErv.replace('deviceid', deviceData.DeviceID);
                             break
                     }
 
-                    const axiosInstancePut = axios.create({
+                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload, null, 2)}`);
+                    await axios(path, {
                         method: method,
                         baseURL: ApiUrlsHome.BaseURL,
                         timeout: 10000,
-                        headers: deviceData.Headers
+                        headers: deviceData.Headers,
+                        data: payload
                     });
-
-                    if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(payload.data, null, 2)}`);
-                    await axiosInstancePut(path, payload);
                     this.updateData(deviceData);
                     return true;
                 default:

package/src/melcloudhome.js

@@ -0,0 +1,364 @@
+import fs from 'fs';
+import axios from 'axios';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import EventEmitter from 'events';
+import puppeteer from 'puppeteer';
+import ImpulseGenerator from './impulsegenerator.js';
+import Functions from './functions.js';
+import { ApiUrlsHome } from './constants.js';
+const execPromise = promisify(exec);
+
+class MelCloud extends EventEmitter {
+    constructor(account, accountFile, buildingsFile, devicesFile, pluginStart = false) {
+        super();
+        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.contextKey = null;
+        this.functions = new Functions(this.logWarn, this.logError, this.logDebug)
+            .on('warn', warn => this.emit('warn', warn))
+            .on('error', error => this.emit('error', error))
+            .on('debug', debug => this.emit('debug', debug));
+
+        if (pluginStart) {
+            //lock flags
+            this.locks = {
+                connect: false,
+                checkDevicesList: false
+            };
+            this.impulseGenerator = new ImpulseGenerator()
+                .on('connect', () => this.handleWithLock('connect', async () => {
+                    await this.connect(true);
+                }))
+                .on('checkDevicesList', () => this.handleWithLock('checkDevicesList', async () => {
+                    await this.checkDevicesList();
+                }))
+                .on('state', (state) => {
+                    this.emit(state ? 'success' : 'warn', `Impulse generator ${state ? 'started' : 'stopped'}`);
+                });
+        }
+    }
+
+    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 Home
+    async checkDevicesList() {
+        try {
+            const devicesList = { State: false, Info: null, Devices: [] }
+            const headers = {
+                'Accept': '*/*',
+                'Accept-Language': 'en-US,en;q=0.9',
+                'Cookie': this.contextKey,
+                'User-Agent': 'homebridge-melcloud-control/4.0.0',
+                'DNT': '1',
+                'Origin': 'https://melcloudhome.com',
+                'Referer': 'https://melcloudhome.com/dashboard',
+                'Sec-Fetch-Dest': 'empty',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Site': 'same-origin',
+                'X-CSRF': '1'
+            };
+
+            if (this.logDebug) this.emit('debug', `Scanning for devices`);
+            const listDevicesData = await axios(ApiUrlsHome.GetUserContext, {
+                method: 'GET',
+                baseURL: ApiUrlsHome.BaseURL,
+                timeout: 25000,
+                headers: headers
+            });
+            const buildingsList = listDevicesData.data.buildings;
+            if (this.logDebug) this.emit('debug', `Buildings: ${JSON.stringify(buildingsList, null, 2)}`);
+
+            if (!buildingsList) {
+                devicesList.Info = 'No building found'
+                return devicesList;
+            }
+
+            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
+                        ])
+                    );
+
+                // Rekurencyjna kapitalizacja kluczy w obiekcie lub tablicy
+                const capitalizeKeysDeep = obj => {
+                    if (Array.isArray(obj)) return obj.map(capitalizeKeysDeep);
+                    if (obj && typeof obj === 'object') {
+                        return Object.fromEntries(
+                            Object.entries(obj).map(([key, value]) => [
+                                key.charAt(0).toUpperCase() + key.slice(1),
+                                capitalizeKeysDeep(value)
+                            ])
+                        );
+                    }
+                    return obj;
+                };
+
+                // 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,
+                        IsConnected: device.IsConnected
+                    };
+
+                    // Kapitalizacja brakujących obiektów/tablic
+                    if (device.FrostProtection) device.FrostProtection = { ...capitalizeKeys(device.FrostProtection || {}) };
+                    if (device.OverheatProtection) device.OverheatProtection = { ...capitalizeKeys(device.OverheatProtection || {}) };
+                    if (device.HolidayMode) device.HolidayMode = { ...capitalizeKeys(device.HolidayMode || {}) };
+                    if (Array.isArray(device.Schedule)) device.Schedule = device.Schedule.map(capitalizeKeysDeep);
+
+                    // Usuń stare pola Settings i Capabilities
+                    const { Settings, Capabilities, Id, GivenDisplayName, ...rest } = device;
+
+                    return {
+                        ...rest,
+                        Type: type,
+                        DeviceID: Id,
+                        DeviceName: GivenDisplayName,
+                        Device: deviceObject,
+                        Headers: headers
+                    };
+                };
+
+                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) {
+                devicesList.Info = 'No devices found'
+                return devicesList;
+            }
+
+            await this.functions.saveData(this.devicesFile, devices);
+            if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
+
+            devicesList.State = true;
+            devicesList.Info = `Found ${devicesCount} devices`;
+            devicesList.Devices = devices;
+            return devicesList;
+        } catch (error) {
+            if (error.response?.status === 401) {
+                await connectToMelCloudHome();
+                if (this.logWarn) this.emit('warn', 'Check devices list not possible, cookies expired, trying to get new.');
+                return;
+            }
+
+            throw new Error(`Check devices list error: ${error.message}`);
+        }
+    }
+
+    async connect() {
+        if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
+        const GLOBAL_TIMEOUT = 90000;
+
+        let browser;
+        try {
+            const accountInfo = { State: false, Info: '', ContextKey: null, UseFahrenheit: false };
+            let chromiumPath = await this.functions.ensureChromiumInstalled();
+
+            // === Fallback to Puppeteer's built-in Chromium ===
+            if (!chromiumPath) {
+                try {
+                    const puppeteerPath = puppeteer.executablePath();
+                    if (puppeteerPath && fs.existsSync(puppeteerPath)) {
+                        chromiumPath = puppeteerPath;
+                        if (this.logDebug) this.emit('debug', `Using puppeteer Chromium at ${chromiumPath}`);
+                    }
+                } catch { }
+            } else {
+                if (this.logDebug) this.emit('debug', `Using system Chromium at ${chromiumPath}`);
+            }
+
+            if (!chromiumPath) {
+                accountInfo.Info = 'Chromium not found on Your device, please install it manually and try again';
+                return accountInfo;
+            }
+
+            // Verify executable works
+            try {
+                const { stdout } = await execPromise(`"${chromiumPath}" --version`);
+                if (this.logDebug) this.emit('debug', `Chromium detected: ${stdout.trim()}`);
+            } catch (error) {
+                accountInfo.Info = `Chromium found at ${chromiumPath}, but cannot be executed: ${error.message}`;
+                return accountInfo;
+            }
+
+            if (this.logDebug) this.emit('debug', `Launching Chromium...`);
+            browser = await puppeteer.launch({
+                headless: true,
+                executablePath: chromiumPath,
+                timeout: GLOBAL_TIMEOUT,
+                args: [
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--single-process',
+                    '--disable-gpu',
+                    '--no-zygote'
+                ]
+            });
+            browser.on('disconnected', () => this.emit('debug', 'Browser disconnected'));
+
+            const page = await browser.newPage();
+            page.on('error', error => this.emit('error', `Page crashed: ${error.message}`));
+            page.on('pageerror', error => this.emit('error', `Browser error: ${error.message}`));
+            page.setDefaultTimeout(GLOBAL_TIMEOUT);
+            page.setDefaultNavigationTimeout(GLOBAL_TIMEOUT);
+
+            // Clear cookies before navigation
+            try {
+                const client = await page.createCDPSession();
+                await client.send('Network.clearBrowserCookies');
+            } catch (error) {
+                if (this.logError) this.emit('error', `Clear cookies error: ${error.message}`);
+            }
+
+            try {
+                await page.goto(ApiUrlsHome.BaseURL, { waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT });
+            } catch (error) {
+                accountInfo.Info = `Navigation to ${ApiUrlsHome.BaseURL} failed: ${error.message}`;
+                return accountInfo;
+            }
+
+            // Wait extra to ensure UI is rendered
+            await new Promise(r => setTimeout(r, 3000));
+            const loginBtn = await page.waitForSelector('button.btn--blue', { timeout: GLOBAL_TIMEOUT / 4 });
+            const loginText = await page.evaluate(el => el.textContent.trim(), loginBtn);
+
+            if (!['Zaloguj', 'Sign In', 'Login'].includes(loginText)) {
+                accountInfo.Info = `Login button ${loginText} not found`;
+                return accountInfo;
+            }
+
+            await loginBtn.click();
+            await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: GLOBAL_TIMEOUT / 3 });
+
+            const usernameInput = await page.$('input[name="username"]');
+            const passwordInput = await page.$('input[name="password"]');
+            if (!usernameInput || !passwordInput) {
+                accountInfo.Info = 'Username or password input not found';
+                return accountInfo;
+            }
+
+            await page.type('input[name="username"]', this.user, { delay: 50 });
+            await page.type('input[name="password"]', this.passwd, { delay: 50 });
+
+            const submitButton = await page.$('input[type="submit"], button[type="submit"]');
+            if (!submitButton) {
+                accountInfo.Info = 'Submit button not found';
+                return accountInfo;
+            }
+            await Promise.race([Promise.all([submitButton.click(), page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT / 4 })]), new Promise(r => setTimeout(r, GLOBAL_TIMEOUT / 3))]);
+
+            // Extract cookies
+            let c1 = null, c2 = null;
+            const start = Date.now();
+            while ((!c1 || !c2) && Date.now() - start < GLOBAL_TIMEOUT / 2) {
+                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) {
+                accountInfo.Info = 'Cookies C1/C2 missing';
+                return accountInfo;
+            }
+
+            const contextKey = [
+                '__Secure-monitorandcontrol=chunks-2',
+                `__Secure-monitorandcontrolC1=${c1}`,
+                `__Secure-monitorandcontrolC2=${c2}`
+            ].join('; ');
+            this.contextKey = contextKey;
+
+            accountInfo.State = true;
+            accountInfo.Info = 'Connect to MELCloud Home Success';
+            accountInfo.ContextKey = contextKey;
+            await this.functions.saveData(this.accountFile, accountInfo);
+
+            return accountInfo;
+        } catch (error) {
+            throw new Error(`Connect error: ${error.message}`);
+        } finally {
+            if (browser) {
+                try { await browser.close(); }
+                catch (closeErr) {
+                    if (this.logError) this.emit('error', `Failed to close Puppeteer: ${closeErr.message}`);
+                }
+            }
+        }
+    }
+
+    async send(accountInfo) {
+        try {
+            const axiosInstance = axios.create({
+                method: 'POST',
+                baseURL: ApiUrlsHome.BaseURL,
+                timeout: 15000,
+                headers: {
+                    'X-MitsContextKey': accountInfo.ContextKey,
+                    'content-type': 'application/json'
+                }
+            });
+
+            const payload = { data: accountInfo.LoginData };
+            await axiosInstance(ApiUrlsHome.UpdateApplicationOptions, payload);
+            await this.functions.saveData(this.accountFile, accountInfo);
+            return true;
+        } catch (error) {
+            throw new Error(`Send data error: ${error.message}`);
+        }
+    }
+}
+
+export default MelCloud;
+