brave-real-browser 1.5.95 → 1.5.97

package/FIXES_NEEDED.md

@@ -0,0 +1,131 @@
+# Brave-Real-Browser - Critical Fixes Needed
+
+## ⚠️ Note
+यह project compiled JavaScript library है। Source code इस repository में नहीं है।
+
+## Critical Issues to Fix in Source Repository
+
+### 1. **pageController Error Handling** (Critical)
+**File**: `src/module/pageController.js` (in source repo)
+**Issue**: Promise rejections और errors को properly handle नहीं किया गया
+**Fix Required**:
+```javascript
+// Add comprehensive try-catch blocks
+async function handleNavigation(page, url) {
+  try {
+    await page.goto(url, { timeout: 30000 });
+  } catch (error) {
+    if (error.name === 'TimeoutError') {
+      throw new NavigationTimeoutError(`Navigation to ${url} timed out`);
+    }
+    throw new NavigationError(`Failed to navigate: ${error.message}`);
+  }
+}
+
+// Add error recovery mechanisms
+async function withRetry(fn, maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === maxRetries - 1) throw error;
+      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
+    }
+  }
+}
+```
+
+### 2. **turnstileSolver Infinite Loop Fix** (Critical)
+**File**: `src/module/turnstileSolver.js` (in source repo)
+**Issue**: Infinite loop possibility without timeout or max attempts
+**Fix Required**:
+```javascript
+async function solveTurnstile(page, maxAttempts = 10, timeout = 60000) {
+  const startTime = Date.now();
+  let attempts = 0;
+  
+  while (attempts < maxAttempts) {
+    // Check timeout
+    if (Date.now() - startTime > timeout) {
+      throw new TurnstileTimeoutError('Turnstile solving timed out');
+    }
+    
+    attempts++;
+    
+    try {
+      const solved = await attemptSolve(page);
+      if (solved) return true;
+    } catch (error) {
+      console.error(`Turnstile attempt ${attempts} failed:`, error);
+    }
+    
+    // Exponential backoff
+    await new Promise(resolve => 
+      setTimeout(resolve, Math.min(1000 * Math.pow(2, attempts), 10000))
+    );
+  }
+  
+  throw new TurnstileMaxAttemptsError(`Failed after ${maxAttempts} attempts`);
+}
+```
+
+### 3. **Proxy Validation** (Medium)
+**Fix Required**:
+```javascript
+function validateProxy(proxy) {
+  if (!proxy) return null;
+  
+  const proxyRegex = /^(https?|socks[45]):\/\/([^:]+):(\d+)$/;
+  if (!proxyRegex.test(proxy)) {
+    throw new Error('Invalid proxy format. Expected: protocol://host:port');
+  }
+  
+  return proxy;
+}
+```
+
+### 4. **Better Error Messages**
+```javascript
+class BrowserError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = 'BrowserError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+class NavigationError extends BrowserError {
+  constructor(message, details) {
+    super(message, 'NAVIGATION_ERROR', details);
+    this.name = 'NavigationError';
+  }
+}
+```
+
+## Version Synchronization Required
+- Current version: 1.5.95
+- Should match: brave-real-launcher, brave-real-puppeteer-core
+- Add version validation on startup
+
+## Dependencies to Update
+```json
+{
+  "dependencies": {
+    "brave-real-launcher": "^1.5.95",
+    "brave-real-puppeteer-core": "^1.5.95"
+  }
+}
+```
+
+## Testing Requirements
+1. Add unit tests for error handling
+2. Add integration tests with other components
+3. Add timeout/infinite loop regression tests
+4. Add proxy validation tests
+
+## Documentation Needed
+1. API documentation
+2. Error handling guide
+3. Configuration examples
+4. Troubleshooting guide

package/lib/cjs/module/pageController.js

@@ -2,6 +2,11 @@ const { createCursor } = require('ghost-cursor');
 const { checkTurnstile } = require('./turnstile.js');
 const kill = require('tree-kill');
 
+// Configuration constants
+const TURNSTILE_CHECK_INTERVAL = 1000; // 1 second
+const TURNSTILE_MAX_ATTEMPTS = 300; // 5 minutes max (300 attempts * 1 second)
+const TURNSTILE_TIMEOUT = 300000; // 5 minutes in milliseconds
+
 function getRandomInt(min, max) {
     min = Math.ceil(min);
     max = Math.floor(max);
@@ -10,60 +15,162 @@ function getRandomInt(min, max) {
 
 async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
 
-    let solveStatus = turnstile
+    let solveStatus = turnstile;
+    let turnstileSolverRunning = false;
+
+    // Safe cleanup function
+    const cleanup = async () => {
+        solveStatus = false;
+        if (killProcess === true) {
+            if (xvfbsession) {
+                try { 
+                    xvfbsession.stopSync();
+                } catch (err) { 
+                    console.error('Error stopping Xvfb session:', err.message);
+                }
+            }
+            if (chrome) {
+                try { 
+                    chrome.kill();
+                } catch (err) { 
+                    console.error('Error killing Chrome process:', err.message);
+                }
+            }
+            if (pid) {
+                try { 
+                    kill(pid, 'SIGKILL', (err) => {
+                        if (err) console.error('Error killing process:', err.message);
+                    });
+                } catch (err) { 
+                    console.error('Error in kill command:', err.message);
+                }
+            }
+        }
+    };
 
     page.on('close', () => {
-        solveStatus = false
+        solveStatus = false;
     });
 
-
     browser.on('disconnected', async () => {
-        solveStatus = false
-        if (killProcess === true) {
-            if (xvfbsession) try { xvfbsession.stopSync() } catch (err) { }
-            if (chrome) try { chrome.kill() } catch (err) { console.log(err); }
-            if (pid) try { kill(pid, 'SIGKILL', () => { }) } catch (err) { }
-        }
+        await cleanup();
     });
 
+    // Enhanced turnstile solver with timeout and max attempts protection
     async function turnstileSolver() {
-        while (solveStatus) {
-            await checkTurnstile({ page }).catch(() => { });
-            await new Promise(r => setTimeout(r, 1000));
+        if (turnstileSolverRunning) {
+            console.warn('Turnstile solver already running, skipping duplicate start');
+            return;
         }
-        return
-    }
+        
+        turnstileSolverRunning = true;
+        const startTime = Date.now();
+        let attempts = 0;
+
+        try {
+            while (solveStatus && attempts < TURNSTILE_MAX_ATTEMPTS) {
+                // Check timeout
+                if (Date.now() - startTime > TURNSTILE_TIMEOUT) {
+                    console.warn('Turnstile solver timeout reached after', attempts, 'attempts');
+                    break;
+                }
+
+                // Check if page is still valid
+                if (page.isClosed()) {
+                    console.log('Page closed, stopping turnstile solver');
+                    break;
+                }
+
+                attempts++;
+
+                try {
+                    await checkTurnstile({ page });
+                } catch (err) {
+                    // Silent fail for individual checks, log only if debug enabled
+                    if (process.env.DEBUG === 'true') {
+                        console.debug('Turnstile check failed:', err.message);
+                    }
+                }
+
+                // Wait before next check
+                await new Promise(r => setTimeout(r, TURNSTILE_CHECK_INTERVAL));
+            }
 
-    turnstileSolver()
+            if (attempts >= TURNSTILE_MAX_ATTEMPTS) {
+                console.warn('Turnstile solver stopped: max attempts reached');
+            }
+        } catch (err) {
+            console.error('Error in turnstile solver:', err.message);
+        } finally {
+            turnstileSolverRunning = false;
+        }
+    }
 
-    if (proxy.username && proxy.password) await page.authenticate({ username: proxy.username, password: proxy.password });
+    // Start turnstile solver only if enabled
+    if (turnstile) {
+        turnstileSolver().catch(err => {
+            console.error('Failed to start turnstile solver:', err.message);
+        });
+    }
 
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            plugin.onPageCreated(page)
+    // Proxy authentication with error handling
+    if (proxy && proxy.username && proxy.password) {
+        try {
+            await page.authenticate({ 
+                username: proxy.username, 
+                password: proxy.password 
+            });
+        } catch (err) {
+            console.error('Proxy authentication failed:', err.message);
+            throw new Error(`Failed to authenticate proxy: ${err.message}`);
         }
     }
 
-    await page.evaluateOnNewDocument(() => {
-        Object.defineProperty(MouseEvent.prototype, 'screenX', {
-            get: function () {
-                return this.clientX + window.screenX;
+    // Plugin initialization with error handling
+    if (plugins && plugins.length > 0) {
+        for (const plugin of plugins) {
+            try {
+                if (plugin && typeof plugin.onPageCreated === 'function') {
+                    await plugin.onPageCreated(page);
+                }
+            } catch (err) {
+                console.error('Plugin initialization failed:', err.message);
+                // Continue with other plugins even if one fails
             }
-        });
+        }
+    }
 
-        Object.defineProperty(MouseEvent.prototype, 'screenY', {
-            get: function () {
-                return this.clientY + window.screenY;
-            }
+    // Mouse event handling with error handling
+    try {
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(MouseEvent.prototype, 'screenX', {
+                get: function () {
+                    return this.clientX + window.screenX;
+                }
+            });
+
+            Object.defineProperty(MouseEvent.prototype, 'screenY', {
+                get: function () {
+                    return this.clientY + window.screenY;
+                }
+            });
         });
+    } catch (err) {
+        console.error('Failed to setup mouse event handlers:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    });
-
-    const cursor = createCursor(page);
-    page.realCursor = cursor
-    page.realClick = cursor.click
+    // Cursor setup with error handling
+    try {
+        const cursor = createCursor(page);
+        page.realCursor = cursor;
+        page.realClick = cursor.click;
+    } catch (err) {
+        console.error('Failed to create ghost cursor:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    return page
+    return page;
 }
 
 module.exports = { pageController }

package/lib/esm/module/pageController.mjs

@@ -2,65 +2,175 @@ import { createCursor } from 'ghost-cursor';
 import { checkTurnstile } from './turnstile.mjs';
 import kill from 'tree-kill';
 
+// Configuration constants
+const TURNSTILE_CHECK_INTERVAL = 1000; // 1 second
+const TURNSTILE_MAX_ATTEMPTS = 300; // 5 minutes max (300 attempts * 1 second)
+const TURNSTILE_TIMEOUT = 300000; // 5 minutes in milliseconds
+
 function getRandomInt(min, max) {
     min = Math.ceil(min);
     max = Math.floor(max);
     return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
-export async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
+async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
+
+    let solveStatus = turnstile;
+    let turnstileSolverRunning = false;
 
-    let solveStatus = turnstile
+    // Safe cleanup function
+    const cleanup = async () => {
+        solveStatus = false;
+        if (killProcess === true) {
+            if (xvfbsession) {
+                try { 
+                    xvfbsession.stopSync();
+                } catch (err) { 
+                    console.error('Error stopping Xvfb session:', err.message);
+                }
+            }
+            if (chrome) {
+                try { 
+                    chrome.kill();
+                } catch (err) { 
+                    console.error('Error killing Chrome process:', err.message);
+                }
+            }
+            if (pid) {
+                try { 
+                    kill(pid, 'SIGKILL', (err) => {
+                        if (err) console.error('Error killing process:', err.message);
+                    });
+                } catch (err) { 
+                    console.error('Error in kill command:', err.message);
+                }
+            }
+        }
+    };
 
     page.on('close', () => {
-        solveStatus = false
+        solveStatus = false;
     });
 
-
     browser.on('disconnected', async () => {
-        solveStatus = false
-        if (killProcess === true) {
-            if (xvfbsession) try { xvfbsession.stopSync() } catch (err) { }
-            if (chrome) try { chrome.kill() } catch (err) { console.log(err); }
-            if (pid) try { kill(pid, 'SIGKILL', () => { }) } catch (err) { }
-        }
+        await cleanup();
     });
 
+    // Enhanced turnstile solver with timeout and max attempts protection
     async function turnstileSolver() {
-        while (solveStatus) {
-            await checkTurnstile({ page }).catch(() => { });
-            await new Promise(r => setTimeout(r, 1000));
+        if (turnstileSolverRunning) {
+            console.warn('Turnstile solver already running, skipping duplicate start');
+            return;
         }
-        return
-    }
+        
+        turnstileSolverRunning = true;
+        const startTime = Date.now();
+        let attempts = 0;
 
-    turnstileSolver()
+        try {
+            while (solveStatus && attempts < TURNSTILE_MAX_ATTEMPTS) {
+                // Check timeout
+                if (Date.now() - startTime > TURNSTILE_TIMEOUT) {
+                    console.warn('Turnstile solver timeout reached after', attempts, 'attempts');
+                    break;
+                }
 
-    if (proxy.username && proxy.password) await page.authenticate({ username: proxy.username, password: proxy.password });
+                // Check if page is still valid
+                if (page.isClosed()) {
+                    console.log('Page closed, stopping turnstile solver');
+                    break;
+                }
 
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            plugin.onPageCreated(page)
+                attempts++;
+
+                try {
+                    await checkTurnstile({ page });
+                } catch (err) {
+                    // Silent fail for individual checks, log only if debug enabled
+                    if (process.env.DEBUG === 'true') {
+                        console.debug('Turnstile check failed:', err.message);
+                    }
+                }
+
+                // Wait before next check
+                await new Promise(r => setTimeout(r, TURNSTILE_CHECK_INTERVAL));
+            }
+
+            if (attempts >= TURNSTILE_MAX_ATTEMPTS) {
+                console.warn('Turnstile solver stopped: max attempts reached');
+            }
+        } catch (err) {
+            console.error('Error in turnstile solver:', err.message);
+        } finally {
+            turnstileSolverRunning = false;
         }
     }
 
-    await page.evaluateOnNewDocument(() => {
-        Object.defineProperty(MouseEvent.prototype, 'screenX', {
-            get: function () {
-                return this.clientX + window.screenX;
-            }
+    // Start turnstile solver only if enabled
+    if (turnstile) {
+        turnstileSolver().catch(err => {
+            console.error('Failed to start turnstile solver:', err.message);
         });
+    }
+
+    // Proxy authentication with error handling
+    if (proxy && proxy.username && proxy.password) {
+        try {
+            await page.authenticate({ 
+                username: proxy.username, 
+                password: proxy.password 
+            });
+        } catch (err) {
+            console.error('Proxy authentication failed:', err.message);
+            throw new Error(`Failed to authenticate proxy: ${err.message}`);
+        }
+    }
 
-        Object.defineProperty(MouseEvent.prototype, 'screenY', {
-            get: function () {
-                return this.clientY + window.screenY;
+    // Plugin initialization with error handling
+    if (plugins && plugins.length > 0) {
+        for (const plugin of plugins) {
+            try {
+                if (plugin && typeof plugin.onPageCreated === 'function') {
+                    await plugin.onPageCreated(page);
+                }
+            } catch (err) {
+                console.error('Plugin initialization failed:', err.message);
+                // Continue with other plugins even if one fails
             }
+        }
+    }
+
+    // Mouse event handling with error handling
+    try {
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(MouseEvent.prototype, 'screenX', {
+                get: function () {
+                    return this.clientX + window.screenX;
+                }
+            });
+
+            Object.defineProperty(MouseEvent.prototype, 'screenY', {
+                get: function () {
+                    return this.clientY + window.screenY;
+                }
+            });
         });
+    } catch (err) {
+        console.error('Failed to setup mouse event handlers:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    });
+    // Cursor setup with error handling
+    try {
+        const cursor = createCursor(page);
+        page.realCursor = cursor;
+        page.realClick = cursor.click;
+    } catch (err) {
+        console.error('Failed to create ghost cursor:', err.message);
+        // Non-critical, continue anyway
+    }
+
+    return page;
+}
 
-    const cursor = createCursor(page);
-    page.realCursor = cursor
-    page.realClick = cursor.click
-    return page
-}
+export { pageController };

package/lib/esm/module/turnstile.mjs

@@ -1,7 +1,6 @@
-export const checkTurnstile = ({ page }) => {
+const checkTurnstile = ({ page }) => {
     return new Promise(async (resolve, reject) => {
         var waitInterval = setTimeout(() => { clearInterval(waitInterval); resolve(false) }, 5000);
-
         try {
             const elements = await page.$$('[name="cf-turnstile-response"]');
             if (elements.length <= 0) {
@@ -59,4 +58,6 @@ export const checkTurnstile = ({ page }) => {
             resolve(false)
         }
     })
-}
+}
+
+export { checkTurnstile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser",
-  "version": "1.5.95",
+  "version": "1.5.97",
   "description": "This package is designed to bypass puppeteer's bot-detecting captchas such as Cloudflare. It acts like a real browser and can be managed with puppeteer.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -40,7 +40,7 @@
   "dependencies": {
     "brave-real-launcher": "latest",
     "brave-real-puppeteer-core": "latest",
-    "ghost-cursor": "^1.4.1 ",
+    "ghost-cursor": "^1.4.1",
     "puppeteer-extra": "^3.3.6",
     "tree-kill": "^1.2.2",
     "xvfb": "^0.4.0"