homebridge-melcloud-control 4.0.0-beta.539 → 4.0.0-beta.540

package/package.json

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

package/src/melcloud.js

@@ -307,148 +307,143 @@ class MelCloud extends EventEmitter {
     async connectToMelCloudHome() {
         if (this.logDebug) this.emit('debug', 'Connecting to MELCloud Home');
         const GLOBAL_TIMEOUT = 90000;
-
         let browser;
+
+        const accountInfo = { State: false, Info: '', ContextKey: null, UseFahrenheit: false };
+
         try {
-            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';
+                accountInfo.Info = 'Chromium not found on your device, please install it manually and try again';
                 return accountInfo;
             }
 
-            // Verify executable works
+            // Check if executable is valid
             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...`);
+            this.emit('warn', 'Launching Chromium...');
             browser = await puppeteer.launch({
-                headless: 'new',
+                headless: true, // "new" deprecated, use true
                 executablePath: chromiumPath,
                 timeout: GLOBAL_TIMEOUT,
                 args: [
                     '--no-sandbox',
                     '--disable-setuid-sandbox',
                     '--disable-dev-shm-usage',
-                    '--single-process',
                     '--disable-gpu',
-                    '--no-zygote'
-                ]
+                    '--no-zygote',
+                    '--disable-background-networking',
+                    '--disable-software-rasterizer',
+                ],
             });
 
-            let context;
-            if (typeof browser.createBrowserContext === 'function') {
-                // nowoczesne API
-                context = await browser.createBrowserContext();
-            } else {
-                // fallback do starego API (dla bezpieczeństwa)
-                context = browser.defaultBrowserContext?.() || browser;
-            }
-
+            const context = await browser.createIncognitoBrowserContext();
             const page = await context.newPage();
 
-            // --- wyczyszczenie cookies ---
-            const client = await page.createCDPSession();
-            await client.send('Network.clearBrowserCookies');
-
+            await page.setViewport({ width: 1280, height: 800 });
             await page.goto('about:blank');
             page.setDefaultTimeout(GLOBAL_TIMEOUT);
             page.setDefaultNavigationTimeout(GLOBAL_TIMEOUT);
 
+            // Handle page errors
             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...`);
+            // Navigate to MELCloud
+            this.emit('warn', 'Navigating to MELCloud...');
             try {
-                await page.goto(ApiUrlsHome.BaseURL, { waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT });
+                await page.goto(ApiUrlsHome.BaseURL, {
+                    waitUntil: '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));
+            await page.waitForTimeout(3000);
 
-            this.emit('warn', `Looking for login button...`);
+            // Find login button
+            this.emit('warn', 'Looking for login button...');
             const loginBtn = await page.waitForSelector('button.btn--blue', { timeout: GLOBAL_TIMEOUT / 6 });
-            const loginText = await loginBtn.evaluate(el => el.textContent.trim());
+            const loginText = await page.evaluate(el => el.textContent.trim(), loginBtn);
+
             if (!['Zaloguj', 'Sign In', 'Login'].includes(loginText)) {
-                accountInfo.State = false;
                 accountInfo.Info = 'Login button not found or has unexpected label';
                 return accountInfo;
             }
 
-            this.emit('warn', `Found login button ${loginBtn}`);
             await loginBtn.click();
-            await page.waitForNavigation({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: GLOBAL_TIMEOUT / 4 });
+            await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: GLOBAL_TIMEOUT / 3 });
 
+            // Find and fill form
+            this.emit('warn', 'Looking for credentials form...');
+            const usernameInput = await page.waitForSelector('input[name="username"]', { timeout: GLOBAL_TIMEOUT / 6 });
+            const passwordInput = await page.waitForSelector('input[name="password"]', { timeout: GLOBAL_TIMEOUT / 6 });
 
-            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 });
+            this.emit('warn', 'Typing credentials...');
+            await usernameInput.type(this.user, { delay: 50 });
+            await passwordInput.type(this.passwd, { delay: 50 });
 
-            this.emit('warn', `Looking for submit button...`);
+            // Submit form
+            this.emit('warn', 'Submitting login form...');
             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))]);
-            await new Promise(r => setTimeout(r, 2000));
+            await Promise.all([
+                submitButton.click(),
+                page.waitForNavigation({ waitUntil: 'networkidle2', timeout: GLOBAL_TIMEOUT / 2 }),
+            ]);
+
+            await page.waitForTimeout(2000);
 
-            this.emit('warn', `Looking for cookies...`);
-            // Extract cookies
+            // Get cookies
+            this.emit('warn', 'Looking for cookies...');
+            const deadline = Date.now() + GLOBAL_TIMEOUT / 2;
             let c1 = null, c2 = null;
-            const start = Date.now();
-            while ((!c1 || !c2) && Date.now() - start < GLOBAL_TIMEOUT / 2) {
-                const cookies = await page.browserContext().cookies();
+
+            while (Date.now() < deadline && (!c1 || !c2)) {
+                const cookies = await page.cookies();
                 c1 = cookies.find(c => c.name === '__Secure-monitorandcontrolC1')?.value || c1;
                 c2 = cookies.find(c => c.name === '__Secure-monitorandcontrolC2')?.value || c2;
-                if (!c1 || !c2) await new Promise(r => setTimeout(r, 500));
+                if (!c1 || !c2) await page.waitForTimeout(500);
             }
 
             if (!c1 || !c2) {
-                accountInfo.State = false;
                 accountInfo.Info = 'Cookies C1/C2 missing';
                 return accountInfo;
             }
 
-            this.emit('warn', `Found cookies`);
             const contextKey = [
                 '__Secure-monitorandcontrol=chunks-2',
                 `__Secure-monitorandcontrolC1=${c1}`,
-                `__Secure-monitorandcontrolC2=${c2}`
+                `__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.contextKey = contextKey;
 
+            await this.functions.saveData(this.accountFile, accountInfo);
             return accountInfo;
+
         } catch (error) {
             throw new Error(`Connect error: ${error.message}`);
         } finally {
@@ -459,6 +454,7 @@ class MelCloud extends EventEmitter {
         }
     }
 
+
     async checkDevicesList() {
         const TIMEOUT_MS = 30000; // 30 seconds timeout
         try {