browser-use-agent/browser.py at master · agentsdance/browser-use-agent · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import asyncio
import logging
import os
import aiohttp
from playwright.async_api import async_playwright
from playwright.async_api import Browser
from playwright.async_api._generated import Playwright as AsyncPlaywright

browser_ready_event = asyncio.Event()

class BrowserWrapper:
    def __init__(self, port, browser: Browser, playwright: AsyncPlaywright, remote_browser_id: str = None, endpoint: str = None):
        self.port = port
        self.browser = browser
        self.playwright = playwright
        self.remote_browser_id = remote_browser_id
        self.endpoint = endpoint

    async def stop(self):
        if self.browser:
            logging.info(f"Closing browser on port {self.port}...")
            # try:
            #     for context in self.browser.contexts:
            #         await context.close()
            # except Exception as e:
            #     logging.error(f"Error closing contexts: {e}")
            await self.browser.close()
            logging.info(f"Browser on port {self.port} closed successfully")
        if self.playwright:
            logging.info(f"Closing playwright session {self.port}...")
            await self.playwright.stop()
            logging.info(
                f"Paywright session on port {self.port} closed successfully")
        if self.remote_browser_id and self.endpoint:
            logging.info(f"Closing remote browser {self.remote_browser_id}...")
            try:
                async with aiohttp.ClientSession() as session:
                    delete_url = f"{self.endpoint}/{self.remote_browser_id}"
                    async with session.delete(delete_url, timeout=30) as response:
                        if response.status == 200:
                            logging.info(f"Remote browser {self.remote_browser_id} closed successfully")
                        else:
                            error_text = await response.text()
                            logging.error(f"Failed to close remote browser. Status: {response.status}, Error: {error_text}")
            except Exception as e:
                logging.error(f"Error closing remote browser {self.remote_browser_id}: {e}")


async def start_local_browser(port):
    logging.info(f"Attempting to start browser on port {port}")
    p = None
    browser = None

    try:
        p = await async_playwright().start()

        w = BrowserWrapper(port, None, p)

        try:
            # Configure proxy if environment variables are set
            proxy_config = None
            proxy_server = os.getenv('PROXY_SERVER')
            if proxy_server:
                proxy_config = {
                    'server': proxy_server,
                    'bypass': '127.0.0.1,localhost'
                }

            browser = await p.chromium.launch(
                # executable_path="/opt/chromium.org/browser_use/chromium/chromium-browser-use",
                headless=False,
                args=[
                    f'--remote-debugging-port={port}',
                    '--no-sandbox'
                ],
                proxy=proxy_config
            )

            w = BrowserWrapper(port, browser, p)

            logging.info(f"Browser launched successfully on port {port}")

            # Verify CDP is actually running
            try:
                async with aiohttp.ClientSession() as session:
                    async with session.get(f"http://127.0.0.1:{port}/json/version", timeout=5) as response:
                        if response.status == 200:
                            version_info = await response.json()
                            logging.info(
                                f"successfully connected to cdp: {version_info}")
                        else:
                            logging.error(
                                f"Failed to get CDP version. Status: {response.status}")
            except Exception as cdp_e:
                logging.error(f"Error checking CDP availability: {cdp_e}")

                logging.info('closing playwright driver and browser')
                await w.stop()
                raise
            return BrowserWrapper(port, browser, p)

        except Exception as launch_e:
            logging.error(f"Failed to launch browser: {launch_e}")
            browser_ready_event.clear()

            logging.info('closing playwright driver and browser')
            await w.stop()
            raise
    except Exception as p_e:
        logging.error(f"Playwright initialization error: {p_e}")
        browser_ready_event.clear()

        logging.info('closing playwright driver and browser')
        await w.stop()
        raise

async def start_remote_browser(endpoint):
    logging.info(f"Attempting to create browser via remote endpoint: {endpoint}")

    try:
        async with aiohttp.ClientSession() as session:
            data = {"timeout": 30}

            async with session.post(
                endpoint,
                json=data,
                headers={'Content-Type': 'application/json'},
                timeout=30
            ) as response:
                if response.status == 200:
                    result = await response.json()
                    logging.info(f"Browser created successfully: {result}")
                    return BrowserWrapper(None, None, None, result['id'], endpoint)
                else:
                    error_text = await response.text()
                    logging.error(f"Failed to create browser. Status: {response.status}, Error: {error_text}")
                    raise Exception(f"Failed to create browser: {response.status} - {error_text}")

    except Exception as e:
        logging.error(f"Error creating remote browser: {e}")
        raise