homebridge-melcloud-control 4.0.0-beta.52 → 4.0.0-beta.521

package/src/melcloud.js

@@ -1,111 +1,140 @@
-import { Agent } from 'https';
 import axios from 'axios';
-import puppeteer from 'puppeteer';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 import EventEmitter from 'events';
+import puppeteer from 'puppeteer-core';
 import ImpulseGenerator from './impulsegenerator.js';
 import Functions from './functions.js';
 import { ApiUrls, ApiUrlsHome } from './constants.js';
+const execPromise = promisify(exec);
 
 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.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) {
+        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('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'}.`);
+                    this.emit(state ? 'success' : 'warn', `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 devicesList = { State: false, Info: null, Devices: [] }
+            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;
             }
 
             await this.functions.saveData(this.buildingsFile, buildingsList);
             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
-                ];
-                devices.push(...allDevices);
+                    ...(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) this.emit('debug', `Found ${allDevices.length} devices in building: ${building.Name || 'Unnamed'}`);
+                devicesList.Devices.push(...allDevices);
             }
 
-            const devicesCount = devices.length;
+            const devicesCount = devicesList.Devices.length;
             if (devicesCount === 0) {
-                if (this.logWarn) this.emit('warn', `No devices found`);
-                return null;
+                devicesList.State = false;
+                devicesList.Info = 'No devices found'
+                return devicesList;
             }
 
-            await this.functions.saveData(this.devicesFile, devices);
+            await this.functions.saveData(this.devicesFile, devicesList.Devices);
             if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
 
-            return devices;
+            devicesList.State = true;
+            devicesList.Info = `Found ${devicesCount} devices`;
+            return devicesList;
         } 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,20 +142,30 @@ class MelCloud extends EventEmitter {
         if (this.logDebug) this.emit('debug', `Connecting to MELCloud`);
 
         try {
-            const axiosInstanceLogin = axios.create({
+            const accountInfo = { State: false, Info: '', LoginData: null, ContextKey: null, UseFahrenheit: false }
+            const axiosInstance = axios.create({
                 method: 'POST',
                 baseURL: ApiUrls.BaseURL,
-                ...this.axiosDefaults
+                timeout: 15000,
             });
 
-            const accountData = await axiosInstanceLogin(ApiUrls.ClientLogin, { data: this.loginData });
+            const data = {
+                Email: this.user,
+                Password: this.passwd,
+                Language: this.language,
+                AppVersion: '1.34.12',
+                CaptchaChallenge: '',
+                CaptchaResponse: '',
+                Persist: true
+            };
+
+            const accountData = await axiosInstance(ApiUrls.ClientLogin, { data: data });
             const account = accountData.data;
-            const accountInfo = account.LoginData;
-            const contextKey = accountInfo?.ContextKey;
-            this.contextKey = contextKey;
+            const loginData = account.LoginData ?? [];
+            const contextKey = loginData.ContextKey;
 
             const debugData = {
-                ...accountInfo,
+                ...loginData,
                 ContextKey: 'removed',
                 ClientId: 'removed',
                 Client: 'removed',
@@ -137,38 +176,36 @@ class MelCloud extends EventEmitter {
             if (this.logDebug) this.emit('debug', `MELCloud Info: ${JSON.stringify(debugData, null, 2)}`);
 
             if (!contextKey) {
-                if (this.logWarn) this.emit('warn', `Context key missing`);
-                return null;
+                accountInfo.State = false;
+                accountInfo.Info = 'Context key missing'
+                return accountInfo;
             }
+            this.contextKey = contextKey;
 
-            this.axiosInstancePost = axios.create({
-                method: 'POST',
-                baseURL: ApiUrls.BaseURL,
-                headers: {
-                    'X-MitsContextKey': contextKey,
-                    'content-type': 'application/json'
-                },
-                ...this.axiosDefaults
-            });
-
+            accountInfo.State = true;
+            accountInfo.Info = 'Connect to MELCloud Success';
+            accountInfo.LoginData = loginData;
+            accountInfo.ContextKey = contextKey;
             await this.functions.saveData(this.accountFile, accountInfo);
-            this.emit('success', `Connect to MELCloud Success`);
 
             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 devicesList = { State: false, Info: null, Devices: [] }
             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',
@@ -177,8 +214,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`);
@@ -187,14 +223,16 @@ class MelCloud extends EventEmitter {
             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;
+                devicesList.State = false;
+                devicesList.Info = 'No building found'
+                return devicesList;
             }
 
             await this.functions.saveData(this.buildingsFile, buildingsList);
             if (this.logDebug) this.emit('debug', `Buildings list saved`);
 
-            const allDevices = buildingsList.flatMap(building => {
+            const devices = buildingsList.flatMap(building => {
+                // Funkcja kapitalizująca klucze obiektu
                 const capitalizeKeys = obj =>
                     Object.fromEntries(
                         Object.entries(obj).map(([key, value]) => [
@@ -203,143 +241,270 @@ class MelCloud extends EventEmitter {
                         ])
                     );
 
+                // 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(device => ({ ...capitalizeKeys(device), Type: 0 })),
-                    ...(building.airToWaterUnits || []).map(device => ({ ...capitalizeKeys(device), Type: 1 })),
-                    ...(building.airToVentilationUnits || []).map(device => ({ ...capitalizeKeys(device), Type: 3 }))
+                    ...(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 = allDevices.length;
+            const devicesCount = devices.length;
             if (devicesCount === 0) {
-                if (this.logWarn) this.emit('warn', `No devices found`);
-                return null;
+                devicesList.State = false;
+                devicesList.Info = 'No devices found'
+                return devicesList;
             }
 
-            const devices = allDevices.map(device => {
-                const settingsArray = device.Settings || device.settings || []; // obsługa różnych nazw
-
-                // Konwersja tablicy [{ name, value }] → { Name: Value }
-                const settingsObject = Object.fromEntries(
-                    settingsArray.map(({ name, value }) => [
-                        name.charAt(0).toUpperCase() + name.slice(1),
-                        value
-                    ])
-                );
-
-                return {
-                    ...device, // zachowuje wszystko z allDevices
-                    DeviceID: device.Id,
-                    DeviceName: device.GivenDisplayName,
-                    Settings: settingsObject,
-                    Device: device.Capabilities
-                };
-            });
-
-
             await this.functions.saveData(this.devicesFile, devices);
             if (this.logDebug) this.emit('debug', `${devicesCount} devices saved`);
 
-            return devices;
+            devicesList.State = true;
+            devicesList.Info = `Found ${devicesCount} devices`;
+            devicesList.Devices = devices;
+            return devicesList;
         } 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`);
-
-        const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
-        const page = await browser.newPage();
+        if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
+        const GLOBAL_TIMEOUT = 90000;
 
+        let browser;
         try {
-            // Open MELCloud Home
-            await page.goto(ApiUrlsHome.BaseURL, { waitUntil: 'networkidle2' });
-            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') {
-                    loginBtn = btn;
-                    break;
-                }
+            const accountInfo = { State: false, Info: '', ContextKey: null, UseFahrenheit: false };
+            const chromiumPath = await this.functions.ensureChromiumInstalled();
+            if (!chromiumPath) {
+                accountInfo.State = false;
+                accountInfo.Info = 'Chromium not found on Your device, please install it manually and try again';
+                return accountInfo;
             }
 
-            if (!loginBtn && this.logWarn) this.emit('warn', `Login button not found`);
+            // Verify executable works
+            try {
+                const { stdout } = await execPromise(`"${chromiumPath}" --version`);
+                this.emit('warn', `Chromium detected: ${stdout.trim()}`);
+                if (this.logDebug) this.emit('debug', `Chromium detected: ${stdout.trim()}`);
+            } catch (error) {
+                accountInfo.State = false;
+                accountInfo.Info = `Chromium found at ${chromiumPath}, but cannot be executed: ${error.message}`;
+                return accountInfo;
+            }
+
+            this.emit('warn', `Launching Chromium...`);
+            browser = await puppeteer.launch({
+                headless: 'shell',
+                executablePath: chromiumPath,
+                timeout: GLOBAL_TIMEOUT,
+                args: [
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--single-process',
+                    '--disable-gpu',
+                    '--no-zygote'
+                ]
+            });
 
-            // Set credentials and login
-            await Promise.all([loginBtn.click(), page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 20000 })]);
-            await page.waitForSelector('input[name="username"]', { timeout: 15000 });
+            const [page] = await browser.pages();
+            page.setDefaultTimeout(GLOBAL_TIMEOUT);
+            page.setDefaultNavigationTimeout(GLOBAL_TIMEOUT);
+
+            page.on('error', err => this.emit('error', `Page crashed: ${err.message}`));
+            page.on('pageerror', err => this.emit('error', `Browser error: ${err.message}`));
+            browser.on('disconnected', () => this.emit('debug', 'Browser disconnected'));
+
+            this.emit('warn', `Navigating to MELCloud...`);
+            try {
+                await page.goto(ApiUrlsHome.BaseURL, { waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT });
+            } catch (error) {
+                accountInfo.State = false;
+                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));
+
+            this.emit('warn', `Looking for login button...`);
+            let loginBtn;
+            try {
+                loginBtn = await page.waitForFunction(() => {
+                    const btns = Array.from(document.querySelectorAll('button.btn--blue'));
+                    return btns.find(b => ['Zaloguj', 'Sign In', 'Login'].includes(b.textContent.trim()));
+                }, { timeout: GLOBAL_TIMEOUT / 6 });
+            } catch {
+                accountInfo.State = false;
+                accountInfo.Info = 'Login button not found';
+                return accountInfo;
+            }
+
+            this.emit('warn', `Found login button ${loginBtn}`);
+            await Promise.race([Promise.all([loginBtn.click(), page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT / 4 })]), new Promise(r => setTimeout(r, GLOBAL_TIMEOUT / 3))]);
+
+            this.emit('warn', `Looking for credentials form...`);
+            const usernameInput = await page.$('input[name="username"]');
+            const passwordInput = await page.$('input[name="password"]');
+            if (!usernameInput || !passwordInput) {
+                accountInfo.State = false;
+                accountInfo.Info = 'Username or password input not found';
+                return accountInfo;
+            }
+
+            this.emit('warn', `Type credentials data..`);
             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 })]);
+            this.emit('warn', `Looking for submit button...`);
+            const submitButton = await page.$('input[type="submit"], button[type="submit"]');
+            if (!submitButton) {
+                accountInfo.State = false;
+                accountInfo.Info = 'Submit button not found';
+                return accountInfo;
+            }
+
+            this.emit('warn', `Found submit button ${submitButton}`);
+            await Promise.race([Promise.all([submitButton.click(), page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT / 4 })]), new Promise(r => setTimeout(r, GLOBAL_TIMEOUT / 3))]);
 
-            // Get cookies C1 and C2
+            this.emit('warn', `Looking for cookies...`);
+            // Extract cookies
             let c1 = null, c2 = null;
             const start = Date.now();
-
-            // Loop max 20s
-            while ((!c1 || !c2) && Date.now() - start < 20000) {
-                const cookies = await page.cookies();
+            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) {
-                if (this.logWarn) this.emit('warn', `Cookies C1/C2 missing`);
-                return null;
+                accountInfo.State = false;
+                accountInfo.Info = 'Cookies C1/C2 missing';
+                return accountInfo;
             }
 
-            const contextKey = ['__Secure-monitorandcontrol=chunks-2', `__Secure-monitorandcontrolC1=${c1}`, `__Secure-monitorandcontrolC2=${c2}`,].join('; ');
-            const accountInfo = { ContextKey: contextKey, UseFahrenheit: false };
+            this.emit('warn', `Found cookies`);
+            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);
-            this.emit('success', `Connect to MELCloud Home Success`);
 
             return accountInfo;
         } 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: ${closeErr.message}`); }
+            }
         }
     }
 
-    async connect() {
-        let response = {};
-        switch (this.displayType) {
-            case "melcloud":
-                response = await this.connectToMelCloud();
-                return response
-            case "melcloudhome":
-                response = await this.connectToMelCloudHome();
-                return response
-            default:
-                return response
+    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(`Device list error: ${error.message}`);
         }
     }
 
-    async checkDevicesList(contextKey) {
-        let devices = [];
-        switch (this.displayType) {
-            case "melcloud":
-                devices = await this.checkMelcloudDevicesList(contextKey);
-                return devices
-            case "melcloudhome":
-                devices = await this.checkMelcloudHomeDevicesList(contextKey);
-                return devices
-            default:
-                return devices;
+    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(`Connect error: ${error.message}`);
         }
     }
 
     async send(accountInfo) {
         try {
-            const options = { data: accountInfo };
-            await this.axiosInstancePost(ApiUrls.UpdateApplicationOptions, options);
+            const axiosInstance = axios.create({
+                baseURL: ApiUrls.BaseURL,
+                timeout: 15000,
+                headers: {
+                    'X-MitsContextKey': accountInfo.ContextKey,
+                    'content-type': 'application/json'
+                }
+            });
+
+            const options = { data: accountInfo.LoginData };
+            await axiosInstance.post(ApiUrls.UpdateApplicationOptions, options);
             await this.functions.saveData(this.accountFile, accountInfo);
             return true;
         } catch (error) {