Update app.js

app.js

@@ -1,5 +1,6 @@
 const puppeteer = require('puppeteer-extra');
 const StealthPlugin = require('puppeteer-extra-plugin-stealth');
+const RecaptchaPlugin = require('puppeteer-extra-plugin-recaptcha');
 const FormData = require('form-data');
 const fs = require('fs');
 const path = require('path');
@@ -7,12 +8,28 @@ const path = require('path');
 // Use stealth plugin to avoid detection
 puppeteer.use(StealthPlugin());
 
+// Add recaptcha plugin (requires 2captcha API key for actual solving, but helps with detection)
+puppeteer.use(
+    RecaptchaPlugin({
+        visualFeedback: true, // Show when solving captcha
+        throwOnError: false   // Don't throw errors, just try to continue
+    })
+);
+
 // Helper function to wait
 const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 
 // Random delay to appear more human-like
 const randomWait = (min, max) => wait(Math.floor(Math.random() * (max - min + 1)) + min);
 
+// Check if we should wait for manual Cloudflare solving
+const MANUAL_CLOUDFLARE = process.env.MANUAL_CLOUDFLARE === 'true';
+const CLOUDFLARE_WAIT = parseInt(process.env.CLOUDFLARE_WAIT || '30000');
+
+if (MANUAL_CLOUDFLARE) {
+    console.log('⚠️  MANUAL_CLOUDFLARE mode enabled - will wait up to', CLOUDFLARE_WAIT / 1000, 'seconds for manual solving');
+}
+
 // Function to upload image to uploadnx.zone.id
 async function uploadToServer(filePath) {
     return new Promise((resolve, reject) => {
@@ -89,7 +106,7 @@ function loadCookies(cookieFilePath) {
     }
 
     const browser = await puppeteer.launch({
-        headless: true,
+        headless: false,
         args: [
             '--no-sandbox',
             '--disable-setuid-sandbox',
@@ -122,17 +139,38 @@ function loadCookies(cookieFilePath) {
             '--disable-sync',
             '--disable-client-side-phishing-detection',
             '--disable-features=site-per-process',
-            '--enable-features=NetworkServiceInProcess'
+            '--enable-features=NetworkServiceInProcess',
+            // Additional anti-Cloudflare flags
+            '--disable-features=IsolateOrigins,site-per-process,SitePerProcess',
+            '--disable-web-security',
+            '--allow-running-insecure-content',
+            '--disable-features=VizDisplayCompositor',
+            '--disable-ipc-flooding-protection',
+            '--disable-hang-monitor',
+            '--disable-prompt-on-repost',
+            '--disable-background-timer-throttling',
+            '--disable-backgrounding-occluded-windows',
+            '--disable-renderer-backgrounding',
+            '--force-color-profile=srgb',
+            '--disable-features=TranslateUI',
+            '--disable-features=Translate'
         ],
         ignoreHTTPSErrors: true,
         defaultViewport: null,
-        ignoreDefaultArgs: ['--enable-automation']
+        ignoreDefaultArgs: ['--enable-automation', '--enable-blink-features=IdleDetection']
     });
 
     const page = await browser.newPage();
 
     // EXTREME: Additional page configurations
     await page.setBypassCSP(true);
+    
+    // Set extra permissions to look more like real browser
+    const context = browser.defaultBrowserContext();
+    await context.overridePermissions('https://m.betking.com', [
+        'geolocation',
+        'notifications'
+    ]);
 
     try {
         // Enable JavaScript
@@ -191,13 +229,16 @@ function loadCookies(cookieFilePath) {
         if (cookieData && cookieData.cookies) {
             console.log('\n🍪 Pre-loading cookies...');
             
-            // Strategy 1: Navigate to base domain first with minimal load
+            // First, navigate to the domain to establish context
             try {
                 await page.goto('https://m.betking.com/', { 
                     waitUntil: 'domcontentloaded', 
                     timeout: 15000 
                 });
                 console.log('✓ Base domain loaded');
+                
+                // Wait a bit for any Cloudflare JS to run
+                await wait(3000);
             } catch (baseError) {
                 console.log('⚠️  Base domain load issue, trying alternative...');
                 // Try setting domain manually
@@ -383,6 +424,53 @@ function loadCookies(cookieFilePath) {
             delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
             delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
             delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
+            
+            // Override Performance API to prevent timing attacks
+            const originalGetEntries = Performance.prototype.getEntries;
+            Performance.prototype.getEntries = function() {
+                const entries = originalGetEntries.call(this);
+                return entries.filter(entry => !entry.name.includes('devtools'));
+            };
+            
+            // Override Date to add small random variations
+            const originalDate = Date;
+            Date = class extends originalDate {
+                constructor(...args) {
+                    if (args.length === 0) {
+                        super();
+                        const offset = Math.floor(Math.random() * 10);
+                        return new originalDate(this.getTime() + offset);
+                    }
+                    return new originalDate(...args);
+                }
+            };
+            Date.prototype = originalDate.prototype;
+            Date.now = function() {
+                return originalDate.now() + Math.floor(Math.random() * 10);
+            };
+            
+            // Spoof notification permission
+            Object.defineProperty(Notification, 'permission', {
+                get: () => 'default'
+            });
+            
+            // Mock realistic connection
+            Object.defineProperty(navigator, 'connection', {
+                get: () => ({
+                    effectiveType: '4g',
+                    rtt: 50,
+                    downlink: 10,
+                    saveData: false
+                })
+            });
+            
+            // Override outerHeight/Width to match viewport
+            Object.defineProperty(window, 'outerWidth', {
+                get: () => 390
+            });
+            Object.defineProperty(window, 'outerHeight', {
+                get: () => 844
+            });
         });
 
         console.log('\n🌐 Navigating to the page...');
@@ -406,16 +494,151 @@ function loadCookies(cookieFilePath) {
 
             if (statusCode === 403) {
                 console.log('⚠️  Received 403 Forbidden error.');
-                console.log('Trying alternative approaches...');
-                
-                // Wait and try reloading
-                await wait(2000);
+                console.log('Checking for Cloudflare challenge...');
                 
-                try {
-                    await page.reload({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: 30000 });
-                    console.log('✓ Page reloaded with cookies');
-                } catch (reloadError) {
-                    console.log('Reload had issues, but continuing...');
+                // Check if it's a Cloudflare challenge page
+                const isCloudflare = await page.evaluate(() => {
+                    const body = document.body.innerText;
+                    const title = document.title;
+                    return (
+                        body.includes('Cloudflare') ||
+                        body.includes('Just a moment') ||
+                        body.includes('Checking your browser') ||
+                        title.includes('Just a moment') ||
+                        document.querySelector('#challenge-form') !== null ||
+                        document.querySelector('.cf-browser-verification') !== null
+                    );
+                });
+
+                if (isCloudflare) {
+                    console.log('🔍 Cloudflare challenge detected!');
+                    console.log('⏳ Attempting to solve automatically...');
+                    
+                    // Try to click the Cloudflare Turnstile checkbox
+                    try {
+                        // Wait for checkbox to be clickable
+                        await page.waitForSelector('input[type="checkbox"]', { timeout: 5000, visible: true })
+                            .catch(() => console.log('No visible checkbox found, trying iframe...'));
+                        
+                        // Check for iframe (Cloudflare Turnstile uses iframe)
+                        const frames = page.frames();
+                        console.log(`Found ${frames.length} frames, checking for Cloudflare challenge...`);
+                        
+                        let clicked = false;
+                        for (const frame of frames) {
+                            try {
+                                // Try to find and click checkbox in iframe
+                                const checkbox = await frame.$('input[type="checkbox"]');
+                                if (checkbox) {
+                                    console.log('✓ Found checkbox in iframe, clicking...');
+                                    await checkbox.click();
+                                    clicked = true;
+                                    console.log('✓ Checkbox clicked!');
+                                    break;
+                                }
+                                
+                                // Try Turnstile specific selector
+                                const turnstile = await frame.$('.cf-turnstile');
+                                if (turnstile) {
+                                    console.log('✓ Found Turnstile widget, clicking...');
+                                    await turnstile.click();
+                                    clicked = true;
+                                    console.log('✓ Turnstile clicked!');
+                                    break;
+                                }
+                                
+                                // Try clicking the challenge box area
+                                const challengeBox = await frame.$('#challenge-stage');
+                                if (challengeBox) {
+                                    console.log('✓ Found challenge box, clicking...');
+                                    await challengeBox.click();
+                                    clicked = true;
+                                    console.log('✓ Challenge box clicked!');
+                                    break;
+                                }
+                            } catch (frameError) {
+                                // Continue to next frame
+                            }
+                        }
+                        
+                        if (!clicked) {
+                            console.log('⚠️  Could not find clickable element, trying main page...');
+                            // Try clicking on main page
+                            const mainCheckbox = await page.$('input[type="checkbox"]').catch(() => null);
+                            if (mainCheckbox) {
+                                await mainCheckbox.click();
+                                console.log('✓ Main page checkbox clicked!');
+                            }
+                        }
+                        
+                    } catch (clickError) {
+                        console.log('⚠️  Auto-click failed:', clickError.message);
+                    }
+                    
+                    // Simulate human-like mouse movements
+                    try {
+                        await wait(500);
+                        await page.mouse.move(100, 100);
+                        await wait(100);
+                        await page.mouse.move(200, 200);
+                        await wait(150);
+                        await page.mouse.move(150, 300);
+                        console.log('✓ Mouse movements simulated');
+                    } catch (mouseError) {
+                        console.log('Mouse simulation skipped');
+                    }
+                    
+                    const waitSeconds = CLOUDFLARE_WAIT / 1000;
+                    console.log(`⏳ Waiting for Cloudflare to verify (up to ${waitSeconds} seconds)...`);
+                    if (MANUAL_CLOUDFLARE) {
+                        console.log('💡 You can manually solve the challenge in the browser window!');
+                    }
+                    
+                    // Wait for Cloudflare challenge to complete
+                    try {
+                        await page.waitForFunction(
+                            () => {
+                                // Check if we've passed the challenge
+                                const body = document.body.innerText;
+                                const title = document.title;
+                                return (
+                                    !body.includes('Just a moment') &&
+                                    !body.includes('Checking your browser') &&
+                                    !body.includes('Verify you are human') &&
+                                    !title.includes('Just a moment') &&
+                                    document.querySelector('#challenge-form') === null &&
+                                    document.querySelector('.cf-browser-verification') === null
+                                );
+                            },
+                            { timeout: CLOUDFLARE_WAIT, polling: 500 }
+                        );
+                        console.log('✓ Cloudflare challenge passed!');
+                        
+                        // Take screenshot after passing challenge
+                        await wait(2000);
+                        await page.screenshot({ path: './after-cloudflare.png', fullPage: true });
+                        console.log('Screenshot after Cloudflare: after-cloudflare.png');
+                    } catch (cfError) {
+                        console.log('⚠️  Cloudflare challenge timeout - may need manual intervention');
+                        console.log('Taking screenshot of challenge page...');
+                        await page.screenshot({ path: './cloudflare-challenge.png', fullPage: true });
+                        console.log('Screenshot saved to cloudflare-challenge.png');
+                        
+                        // Try to continue anyway
+                        console.log('Attempting to continue despite challenge...');
+                    }
+                } else {
+                    console.log('Trying alternative approaches...');
+                    
+                    // Wait and try reloading
+                    await wait(2000);
+                    
+                    try {
+                        await page.reload({ waitUntil: ['domcontentloaded', 'networkidle2'], timeout: 30000 });
+                        console.log('✓ Page reloaded with cookies');
+                    } catch (reloadError) {
+                        console.log('Reload had issues, but continuing...');
+                    }
                 }
             } else if (statusCode >= 400) {
                 console.log(`⚠️  Received error status: ${statusCode}`);