Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

simplify daemon architecture: single session, socket-as-liveness, no PID/lock files

ShawnPana859cb9706310
diff --git a/browser_use/cli.py b/browser_use/cli.py
index 631127bf6..1534b8ae3 100644
--- a/browser_use/cli.py
+++ b/browser_use/cli.py
@@ -694,8 +694,6 @@ class BrowserUseApp(App):
'trafilatura.htmlprocessing',
'trafilatura',
'groq',
- 'portalocker',
- 'portalocker.utils',
]:
third_party = logging.getLogger(logger_name)
third_party.setLevel(logging.ERROR)
diff --git a/browser_use/logging_config.py b/browser_use/logging_config.py
index 950d0479f..3ef16bc14 100644
--- a/browser_use/logging_config.py
+++ b/browser_use/logging_config.py
@@ -223,9 +223,7 @@ def setup_logging(stream=None, log_level=None, force_setup=False, debug_log_file
'trafilatura.htmlprocessing',
'trafilatura',
'groq',
- 'portalocker',
'google_genai',
- 'portalocker.utils',
'websockets', # General websockets (but not websockets.client which we need)
]
for logger_name in third_party_loggers:
diff --git a/browser_use/skill_cli/README.md b/browser_use/skill_cli/README.md
index b39faa4a8..f81376a9b 100644
--- a/browser_use/skill_cli/README.md
+++ b/browser_use/skill_cli/README.md
@@ -322,22 +322,16 @@ browser-use -b remote open https://abc.trycloudflare.com
| `profile update <id> --name <name>` | Rename profile |
| `profile delete <id>` | Delete profile |
-## Local Session Management
+## Session Management
| Command | Description |
|---------|-------------|
-| `sessions` | List active sessions |
-| `close` | Close browser session |
-| `close --all` | Close all sessions |
-| `server status` | Check if server is running |
-| `server stop` | Stop server |
-| `server logs` | View server logs |
+| `close` | Close browser and stop daemon |
## Global Options
| Option | Description |
|--------|-------------|
-| `--session NAME` | Use named session (default: "default") |
| `--browser MODE` | Browser mode: chromium, real, remote |
| `--headed` | Show browser window |
| `--profile NAME` | Browser profile (local name or cloud ID) |
@@ -345,8 +339,6 @@ browser-use -b remote open https://abc.trycloudflare.com
| `--api-key KEY` | Override API key |
| `--mcp` | Run as MCP server via stdin/stdout |
-**Session behavior**: All commands without `--session` use the same "default" session. The browser stays open and is reused across commands. Use `--session NAME` to run multiple browsers in parallel.
-
## Examples
### Fill a Form
@@ -365,15 +357,6 @@ browser-use open https://news.ycombinator.com
browser-use eval "Array.from(document.querySelectorAll('.titleline a')).slice(0,5).map(a => a.textContent)"
```
-### Multi-Session Workflow
-```bash
-browser-use --session work open https://work.example.com
-browser-use --session personal open https://personal.example.com
-browser-use --session work state
-browser-use --session personal state
-browser-use close --all
-```
-
### Python Automation
```bash
browser-use open https://example.com
@@ -410,12 +393,12 @@ curl -o ~/.claude/skills/browser-use/SKILL.md \
## How It Works
-The CLI uses a session server architecture:
+The CLI uses a daemon architecture:
-1. First command starts a background server (browser stays open)
+1. First command starts a background daemon (browser stays open)
2. Subsequent commands communicate via Unix socket (or TCP on Windows)
3. Browser persists across commands for fast interaction
-4. Server auto-starts when needed, stops with `browser-use server stop`
+4. Daemon auto-starts when needed, auto-exits when browser dies, or stops with `browser-use close`
This gives you ~50ms command latency instead of waiting for browser startup each time.
@@ -444,11 +427,11 @@ echo $env:PATH
& "C:\Program Files\Git\bin\bash.exe" -c 'browser-use --help'
```
-### "Failed to start session server" error
+### "Failed to start daemon" error
Kill zombie processes:
```powershell
# Find process on port
-netstat -ano | findstr 49698
+netstat -ano | findstr 49200
# Kill by PID
taskkill /PID <pid> /F
diff --git a/browser_use/skill_cli/__init__.py b/browser_use/skill_cli/__init__.py
index 49b3c444a..72d560e0d 100644
--- a/browser_use/skill_cli/__init__.py
+++ b/browser_use/skill_cli/__init__.py
@@ -1,7 +1,7 @@
"""Browser-use CLI package.
This package provides a fast command-line interface for browser automation.
-The CLI uses a session server architecture for persistent browser sessions.
+The CLI uses a daemon architecture for persistent browser sessions.
Usage:
browser-use open https://example.com
diff --git a/browser_use/skill_cli/commands/__init__.py b/browser_use/skill_cli/commands/__init__.py
index 640a9ccd4..a94353af7 100644
--- a/browser_use/skill_cli/commands/__init__.py
+++ b/browser_use/skill_cli/commands/__init__.py
@@ -5,7 +5,6 @@ from browser_use.skill_cli.commands import (
browser,
doctor,
python_exec,
- session,
setup,
)
@@ -14,6 +13,5 @@ __all__ = [
'browser',
'doctor',
'python_exec',
- 'session',
'setup',
]
diff --git a/browser_use/skill_cli/commands/session.py b/browser_use/skill_cli/commands/session.py
deleted file mode 100644
index eb05d4ecc..000000000
--- a/browser_use/skill_cli/commands/session.py
+++ /dev/null
@@ -1,38 +0,0 @@
-"""Session management command handlers."""
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
- from browser_use.skill_cli.sessions import SessionRegistry
-
-logger = logging.getLogger(__name__)
-
-COMMANDS = {'sessions', 'close'}
-
-
-async def handle(action: str, session_name: str, registry: 'SessionRegistry', params: dict[str, Any]) -> Any:
- """Handle session management command."""
- if action == 'sessions':
- sessions = registry.list_sessions()
- return {
- 'sessions': sessions,
- 'count': len(sessions),
- }
-
- elif action == 'close':
- if params.get('all'):
- # Close all sessions and signal shutdown
- sessions = registry.list_sessions()
- await registry.close_all()
- return {
- 'closed': [s['name'] for s in sessions],
- 'count': len(sessions),
- '_shutdown': True, # Signal to stop server
- }
- else:
- # Close this server's session and shutdown
- await registry.close_session(session_name)
- return {'closed': session_name, '_shutdown': True}
-
- raise ValueError(f'Unknown session action: {action}')
diff --git a/browser_use/skill_cli/daemon.py b/browser_use/skill_cli/daemon.py
new file mode 100644
index 000000000..87f7f02d6
--- /dev/null
+++ b/browser_use/skill_cli/daemon.py
@@ -0,0 +1,267 @@
+"""Background daemon - keeps a single BrowserSession alive.
+
+Replaces the multi-session server.py with a simpler model:
+- One daemon, one session, one socket
+- Socket file existence = daemon is alive (no PID/lock files)
+- Auto-exits when browser dies (polls is_cdp_connected)
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import signal
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from browser_use.skill_cli.sessions import SessionInfo
+
+# Configure logging before imports
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
+ handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger('browser_use.skill_cli.daemon')
+
+
+class Daemon:
+ """Single-session daemon that manages a browser and handles CLI commands."""
+
+ def __init__(
+ self,
+ browser_mode: str,
+ headed: bool,
+ profile: str | None,
+ ) -> None:
+ self.browser_mode = browser_mode
+ self.headed = headed
+ self.profile = profile
+ self.running = True
+ self._server: asyncio.Server | None = None
+ self._shutdown_event = asyncio.Event()
+ self._session: 'SessionInfo | None' = None
+ self._browser_watchdog_task: asyncio.Task | None = None
+
+ async def _get_or_create_session(self) -> 'SessionInfo':
+ """Lazy-create the single session on first command."""
+ if self._session is not None:
+ return self._session
+
+ from browser_use.skill_cli.sessions import SessionInfo, create_browser_session
+
+ logger.info(f'Creating session (mode={self.browser_mode}, headed={self.headed})')
+
+ bs = await create_browser_session(self.browser_mode, self.headed, self.profile)
+ await bs.start()
+
+ self._session = SessionInfo(
+ name='default',
+ browser_mode=self.browser_mode,
+ headed=self.headed,
+ profile=self.profile,
+ browser_session=bs,
+ )
+ self._browser_watchdog_task = asyncio.create_task(self._watch_browser())
+ return self._session
+
+ async def _watch_browser(self) -> None:
+ """Poll BrowserSession.is_cdp_connected every 2s. Shutdown when browser dies."""
+ while self.running:
+ await asyncio.sleep(2.0)
+ if self._session and not self._session.browser_session.is_cdp_connected:
+ logger.info('Browser disconnected, shutting down daemon')
+ await self.shutdown()
+ return
+
+ async def handle_connection(
+ self,
+ reader: asyncio.StreamReader,
+ writer: asyncio.StreamWriter,
+ ) -> None:
+ """Handle a single client request (one command per connection)."""
+ try:
+ line = await asyncio.wait_for(reader.readline(), timeout=300)
+ if not line:
+ return
+
+ request = {}
+ try:
+ request = json.loads(line.decode())
+ response = await self.dispatch(request)
+ except json.JSONDecodeError as e:
+ response = {'id': '', 'success': False, 'error': f'Invalid JSON: {e}'}
+ except Exception as e:
+ logger.exception(f'Error handling request: {e}')
+ response = {'id': '', 'success': False, 'error': str(e)}
+
+ writer.write((json.dumps(response) + '\n').encode())
+ await writer.drain()
+
+ if request.get('action') == 'shutdown':
+ await self.shutdown()
+
+ except TimeoutError:
+ logger.debug('Connection timeout')
+ except Exception as e:
+ logger.exception(f'Connection error: {e}')
+ finally:
+ writer.close()
+ try:
+ await writer.wait_closed()
+ except Exception:
+ pass
+
+ async def dispatch(self, request: dict) -> dict:
+ """Route to command handlers."""
+ action = request.get('action', '')
+ params = request.get('params', {})
+ req_id = request.get('id', '')
+
+ logger.info(f'Dispatch: {action} (id={req_id})')
+
+ try:
+ # Handle shutdown
+ if action == 'shutdown':
+ return {'id': req_id, 'success': True, 'data': {'shutdown': True}}
+
+ # Handle ping — returns daemon config for mismatch detection
+ if action == 'ping':
+ return {
+ 'id': req_id,
+ 'success': True,
+ 'data': {
+ 'browser_mode': self.browser_mode,
+ 'headed': self.headed,
+ 'profile': self.profile,
+ },
+ }
+
+ from browser_use.skill_cli.commands import agent, browser, python_exec
+
+ # Get or create the single session
+ session = await self._get_or_create_session()
+
+ # Dispatch to handler
+ if action in browser.COMMANDS:
+ result = await browser.handle(action, session, params)
+ elif action == 'python':
+ result = await python_exec.handle(session, params)
+ elif action == 'run':
+ result = await agent.handle(session, params)
+ else:
+ return {'id': req_id, 'success': False, 'error': f'Unknown action: {action}'}
+
+ return {'id': req_id, 'success': True, 'data': result}
+
+ except Exception as e:
+ logger.exception(f'Error dispatching {action}: {e}')
+ return {'id': req_id, 'success': False, 'error': str(e)}
+
+ async def run(self) -> None:
+ """Listen on Unix socket (or TCP on Windows). No PID file, no lock file."""
+ from browser_use.skill_cli.utils import get_socket_path
+
+ # Setup signal handlers
+ loop = asyncio.get_running_loop()
+
+ def signal_handler():
+ asyncio.create_task(self.shutdown())
+
+ for sig in (signal.SIGINT, signal.SIGTERM):
+ try:
+ loop.add_signal_handler(sig, signal_handler)
+ except NotImplementedError:
+ pass # Windows doesn't support add_signal_handler
+
+ if hasattr(signal, 'SIGHUP'):
+ try:
+ loop.add_signal_handler(signal.SIGHUP, signal_handler)
+ except NotImplementedError:
+ pass
+
+ sock_path = get_socket_path()
+ logger.info(f'Socket: {sock_path}')
+
+ if sock_path.startswith('tcp://'):
+ # Windows: TCP server
+ _, hostport = sock_path.split('://', 1)
+ host, port = hostport.split(':')
+ self._server = await asyncio.start_server(
+ self.handle_connection,
+ host,
+ int(port),
+ reuse_address=True,
+ )
+ logger.info(f'Listening on TCP {host}:{port}')
+ else:
+ # Unix: socket server
+ Path(sock_path).unlink(missing_ok=True)
+ self._server = await asyncio.start_unix_server(
+ self.handle_connection,
+ sock_path,
+ )
+ logger.info(f'Listening on Unix socket {sock_path}')
+
+ try:
+ async with self._server:
+ await self._shutdown_event.wait()
+ except asyncio.CancelledError:
+ pass
+ finally:
+ # Clean up socket file
+ if not sock_path.startswith('tcp://'):
+ Path(sock_path).unlink(missing_ok=True)
+ logger.info('Daemon stopped')
+
+ async def shutdown(self) -> None:
+ """Graceful shutdown."""
+ logger.info('Shutting down daemon...')
+ self.running = False
+ self._shutdown_event.set()
+
+ if self._session:
+ try:
+ await self._session.browser_session.kill()
+ except Exception as e:
+ logger.warning(f'Error closing session: {e}')
+ self._session = None
+
+ if self._browser_watchdog_task:
+ self._browser_watchdog_task.cancel()
+
+ if self._server:
+ self._server.close()
+
+
+def main() -> None:
+ """Main entry point for daemon process."""
+ parser = argparse.ArgumentParser(description='Browser-use daemon')
+ parser.add_argument('--browser', default='chromium', choices=['chromium', 'real'])
+ parser.add_argument('--headed', action='store_true', help='Show browser window')
+ parser.add_argument('--profile', help='Chrome profile (real browser mode)')
+ args = parser.parse_args()
+
+ logger.info(f'Starting daemon: browser={args.browser}, headed={args.headed}')
+
+ daemon = Daemon(
+ browser_mode=args.browser,
+ headed=args.headed,
+ profile=args.profile,
+ )
+
+ try:
+ asyncio.run(daemon.run())
+ except KeyboardInterrupt:
+ logger.info('Interrupted')
+ except Exception as e:
+ logger.exception(f'Daemon error: {e}')
+ sys.exit(1)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/browser_use/skill_cli/direct.py b/browser_use/skill_cli/direct.py
deleted file mode 100644
index 593d30fb9..000000000
--- a/browser_use/skill_cli/direct.py
+++ /dev/null
@@ -1,711 +0,0 @@
-"""Serverless CLI for browser-use - runs commands directly without a session server.
-
-Each command reconnects to the browser via CDP WebSocket URL saved to a state file.
-The browser process stays alive between commands; only the Python process exits.
-
-Two-tier reconnection:
- Tier 1 (Lightweight CDP, ~200ms): Most commands use raw CDPClient + Target.attachToTarget.
- No BrowserSession, no watchdogs, no event bus.
- Tier 2 (Full BrowserSession, ~3s): Only for `state` (needs DOMWatchdog) and first-time
- `open` (needs to launch browser).
-
-Usage:
- python -m browser_use.skill_cli.direct open https://example.com
- python -m browser_use.skill_cli.direct state
- python -m browser_use.skill_cli.direct click 200 400
- python -m browser_use.skill_cli.direct screenshot ./shot.png
- python -m browser_use.skill_cli.direct close
-"""
-
-import asyncio
-import base64
-import json
-import sys
-import tempfile
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
- from cdp_use import CDPClient
-
- from browser_use.browser.session import BrowserSession
-
-STATE_FILE = Path(tempfile.gettempdir()) / 'browser-use-direct.json'
-
-# ---------------------------------------------------------------------------
-# State persistence
-# ---------------------------------------------------------------------------
-
-
-def _load_state() -> dict[str, Any]:
- if STATE_FILE.exists():
- try:
- return json.loads(STATE_FILE.read_text())
- except (json.JSONDecodeError, OSError):
- pass
- return {}
-
-
-def _save_state(state: dict[str, Any]) -> None:
- STATE_FILE.write_text(json.dumps(state))
-
-
-def _clear_state() -> None:
- STATE_FILE.unlink(missing_ok=True)
-
-
-# ---------------------------------------------------------------------------
-# Selector map cache (persisted in state file under "selector_map" key)
-# ---------------------------------------------------------------------------
-
-
-def _save_selector_cache(selector_map: dict[int, Any]) -> None:
- """Cache element positions from the selector map into the state file.
-
- Stores absolute_position (document coordinates) so click-by-index can
- convert to viewport coords at click time using current scroll offset.
- """
- cache: dict[str, dict[str, Any]] = {}
- for idx, node in selector_map.items():
- pos = getattr(node, 'absolute_position', None)
- if pos is None:
- continue
- text = ''
- if hasattr(node, 'ax_node') and node.ax_node and node.ax_node.name:
- text = node.ax_node.name
- elif hasattr(node, 'node_value') and node.node_value:
- text = node.node_value
- tag = getattr(node, 'node_name', '') or ''
- cache[str(idx)] = {
- 'x': pos.x,
- 'y': pos.y,
- 'w': pos.width,
- 'h': pos.height,
- 'tag': tag.lower(),
- 'text': text[:80],
- }
- state = _load_state()
- state['selector_map'] = cache
- _save_state(state)
-
-
-def _load_selector_cache() -> dict[int, dict[str, Any]]:
- """Load cached element positions. Returns {index: {x, y, w, h, tag, text}}."""
- state = _load_state()
- raw = state.get('selector_map', {})
- return {int(k): v for k, v in raw.items()}
-
-
-# ---------------------------------------------------------------------------
-# Tier 1: Lightweight CDP connection (~200ms)
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class LightCDP:
- """Minimal CDP connection — no BrowserSession, no watchdogs."""
-
- client: 'CDPClient'
- session_id: str
- target_id: str
-
-
-@asynccontextmanager
-async def _lightweight_cdp():
- """Connect to the browser via raw CDP. ~200ms total.
-
- Raises RuntimeError if no saved state or browser is dead.
- """
- from cdp_use import CDPClient
-
- state = _load_state()
- cdp_url = state.get('cdp_url')
- if not cdp_url:
- raise RuntimeError('No active browser session')
-
- client = CDPClient(cdp_url)
- try:
- await client.start()
- except Exception as e:
- raise RuntimeError(f'Cannot connect to browser at {cdp_url}: {e}') from e
-
- target_id = state.get('target_id')
-
- # If no saved target, discover one
- if not target_id:
- targets = await client.send.Target.getTargets()
- for t in targets.get('targetInfos', []):
- if t.get('type') == 'page' and t.get('url', '').startswith(('http://', 'https://')):
- target_id = t['targetId']
- break
- if not target_id:
- await client.stop()
- raise RuntimeError('No page target found in browser')
-
- # Attach to the target
- attach_result = await client.send.Target.attachToTarget(params={'targetId': target_id, 'flatten': True})
- session_id = attach_result.get('sessionId')
- if not session_id:
- await client.stop()
- raise RuntimeError(f'Failed to attach to target {target_id}')
-
- # Enable required domains
- await client.send.Page.enable(session_id=session_id)
- await client.send.Runtime.enable(session_id=session_id)
-
- try:
- yield LightCDP(client=client, session_id=session_id, target_id=target_id)
- finally:
- try:
- await client.stop()
- except Exception:
- pass
-
-
-# ---------------------------------------------------------------------------
-# Tier 2: Full BrowserSession (for state + first-time open)
-# ---------------------------------------------------------------------------
-
-
-async def _activate_content_target(session: 'BrowserSession', saved_target_id: str | None) -> None:
- """After reconnection, ensure the session focuses on the actual page, not about:blank."""
- current_url = await session.get_current_page_url()
- if current_url and current_url.startswith(('http://', 'https://')):
- return
-
- if saved_target_id and session.session_manager:
- target = session.session_manager.get_target(saved_target_id)
- if target and target.url and target.url.startswith(('http://', 'https://')):
- try:
- await session.get_or_create_cdp_session(saved_target_id, focus=True)
- return
- except (ValueError, Exception):
- pass
-
- if session._cdp_client_root:
- targets_result = await session._cdp_client_root.send.Target.getTargets()
- for t in targets_result.get('targetInfos', []):
- if t.get('type') == 'page' and t.get('url', '').startswith(('http://', 'https://')):
- try:
- await session.get_or_create_cdp_session(t['targetId'], focus=True)
- return
- except (ValueError, Exception):
- pass
-
-
-@asynccontextmanager
-async def browser(use_remote: bool = False):
- """Connect to existing browser or launch a new one. Disconnects CDP on exit."""
- from browser_use.browser.session import BrowserSession
-
- state = _load_state()
- cdp_url = state.get('cdp_url')
- session = None
-
- if cdp_url:
- session = BrowserSession(cdp_url=cdp_url)
- try:
- await session.start()
- await _activate_content_target(session, state.get('target_id'))
- except Exception:
- _clear_state()
- session = None
-
- if session is None:
- if use_remote:
- session = BrowserSession(use_cloud=True)
- else:
- session = BrowserSession(headless=False)
- await session.start()
- assert session.cdp_url is not None
- _save_state({'cdp_url': session.cdp_url, 'remote': use_remote})
-
- try:
- yield session
- finally:
- if session.agent_focus_target_id:
- current_state = _load_state()
- current_state['target_id'] = session.agent_focus_target_id
- _save_state(current_state)
- if session._cdp_client_root:
- try:
- await session._cdp_client_root.stop()
- except Exception:
- pass
- await session.event_bus.stop(clear=True, timeout=2)
-
-
-# ---------------------------------------------------------------------------
-# Lightweight CDP command functions (Tier 1)
-# ---------------------------------------------------------------------------
-
-
-async def _cdp_navigate(cdp: LightCDP, url: str) -> None:
- """Navigate to URL and invalidate selector cache."""
- await cdp.client.send.Page.navigate(params={'url': url}, session_id=cdp.session_id)
- # Invalidate selector cache — page changed, elements are gone
- state = _load_state()
- state.pop('selector_map', None)
- _save_state(state)
-
-
-async def _cdp_screenshot(cdp: LightCDP, path: str | None) -> None:
- """Take screenshot, save to file or print base64+dimensions."""
- result = await cdp.client.send.Page.captureScreenshot(params={'format': 'png'}, session_id=cdp.session_id)
- data = base64.b64decode(result['data'])
-
- if path:
- p = Path(path)
- p.write_bytes(data) # noqa: ASYNC240
- print(f'Screenshot saved to {p} ({len(data)} bytes)')
- else:
- # Get viewport dimensions
- metrics = await cdp.client.send.Page.getLayoutMetrics(session_id=cdp.session_id)
- visual = metrics.get('visualViewport', {})
- output: dict[str, Any] = {
- 'screenshot': result['data'],
- 'size_bytes': len(data),
- }
- if visual:
- output['viewport'] = {
- 'width': int(visual.get('clientWidth', 0)),
- 'height': int(visual.get('clientHeight', 0)),
- }
- print(json.dumps(output))
-
-
-async def _cdp_click_coordinate(cdp: LightCDP, x: int, y: int) -> None:
- """Click at viewport coordinates using CDP Input.dispatchMouseEvent."""
- sid = cdp.session_id
- await cdp.client.send.Input.dispatchMouseEvent(
- params={'type': 'mouseMoved', 'x': x, 'y': y},
- session_id=sid,
- )
- await asyncio.sleep(0.05)
- await cdp.client.send.Input.dispatchMouseEvent(
- params={'type': 'mousePressed', 'x': x, 'y': y, 'button': 'left', 'clickCount': 1},
- session_id=sid,
- )
- await asyncio.sleep(0.05)
- await cdp.client.send.Input.dispatchMouseEvent(
- params={'type': 'mouseReleased', 'x': x, 'y': y, 'button': 'left', 'clickCount': 1},
- session_id=sid,
- )
-
-
-async def _get_scroll_offset(cdp: LightCDP) -> tuple[float, float]:
- """Get current scroll position via JS."""
- result = await cdp.client.send.Runtime.evaluate(
- params={
- 'expression': 'JSON.stringify({x:window.scrollX,y:window.scrollY})',
- 'returnByValue': True,
- },
- session_id=cdp.session_id,
- )
- data = json.loads(result.get('result', {}).get('value', '{"x":0,"y":0}'))
- return (data['x'], data['y'])
-
-
-async def _cdp_click_index(cdp: LightCDP, index: int) -> None:
- """Click element by cached index. Converts document coords to viewport coords."""
- cache = _load_selector_cache()
- if index not in cache:
- print(f'Error: Element index {index} not in cache. Run "state" first.', file=sys.stderr)
- sys.exit(1)
-
- elem = cache[index]
- scroll_x, scroll_y = await _get_scroll_offset(cdp)
-
- # Center of element in document coords, converted to viewport coords
- viewport_x = int(elem['x'] + elem['w'] / 2 - scroll_x)
- viewport_y = int(elem['y'] + elem['h'] / 2 - scroll_y)
-
- await _cdp_click_coordinate(cdp, viewport_x, viewport_y)
- tag = elem.get('tag', '')
- text = elem.get('text', '')
- label = f'{tag}' + (f' "{text}"' if text else '')
- print(f'Clicked element [{index}] {label} at ({viewport_x}, {viewport_y})')
-
-
-async def _cdp_type(cdp: LightCDP, text: str) -> None:
- """Type text into focused element."""
- await cdp.client.send.Input.insertText(params={'text': text}, session_id=cdp.session_id)
-
-
-async def _cdp_input(cdp: LightCDP, index: int, text: str) -> None:
- """Click element by index then type text."""
- await _cdp_click_index(cdp, index)
- await asyncio.sleep(0.1)
- await _cdp_type(cdp, text)
- print(f'Typed "{text}" into element [{index}]')
-
-
-async def _cdp_scroll(cdp: LightCDP, direction: str) -> None:
- """Scroll page up or down by 500px."""
- amount = -500 if direction == 'up' else 500
- await cdp.client.send.Runtime.evaluate(
- params={
- 'expression': f'window.scrollBy(0, {amount})',
- 'returnByValue': True,
- },
- session_id=cdp.session_id,
- )
-
-
-async def _cdp_back(cdp: LightCDP) -> None:
- """Go back in browser history."""
- nav = await cdp.client.send.Page.getNavigationHistory(session_id=cdp.session_id)
- current_index = nav.get('currentIndex', 0)
- entries = nav.get('entries', [])
- if current_index > 0:
- prev_entry = entries[current_index - 1]
- await cdp.client.send.Page.navigateToHistoryEntry(params={'entryId': prev_entry['id']}, session_id=cdp.session_id)
- # Invalidate selector cache on navigation
- state = _load_state()
- state.pop('selector_map', None)
- _save_state(state)
- else:
- print('Already at the beginning of history', file=sys.stderr)
-
-
-async def _cdp_keys(cdp: LightCDP, keys_str: str) -> None:
- """Send keyboard keys/shortcuts via CDP."""
- from browser_use.actor.utils import get_key_info
-
- # Key alias normalization (same as default_action_watchdog)
- key_aliases = {
- 'ctrl': 'Control',
- 'control': 'Control',
- 'alt': 'Alt',
- 'option': 'Alt',
- 'meta': 'Meta',
- 'cmd': 'Meta',
- 'command': 'Meta',
- 'shift': 'Shift',
- 'enter': 'Enter',
- 'return': 'Enter',
- 'tab': 'Tab',
- 'delete': 'Delete',
- 'backspace': 'Backspace',
- 'escape': 'Escape',
- 'esc': 'Escape',
- 'space': ' ',
- 'up': 'ArrowUp',
- 'down': 'ArrowDown',
- 'left': 'ArrowLeft',
- 'right': 'ArrowRight',
- 'pageup': 'PageUp',
- 'pagedown': 'PageDown',
- 'home': 'Home',
- 'end': 'End',
- }
-
- sid = cdp.session_id
-
- async def dispatch_key(event_type: str, key: str, modifiers: int = 0) -> None:
- from cdp_use.cdp.input.commands import DispatchKeyEventParameters
-
- code, vk_code = get_key_info(key)
- params: DispatchKeyEventParameters = {'type': event_type, 'key': key, 'code': code}
- if modifiers:
- params['modifiers'] = modifiers
- if vk_code is not None:
- params['windowsVirtualKeyCode'] = vk_code
- await cdp.client.send.Input.dispatchKeyEvent(params=params, session_id=sid)
-
- # Normalize
- if '+' in keys_str:
- parts = [key_aliases.get(p.strip().lower(), p.strip()) for p in keys_str.split('+')]
- modifiers_list = parts[:-1]
- main_key = parts[-1]
-
- modifier_map = {'Alt': 1, 'Control': 2, 'Meta': 4, 'Shift': 8}
- modifier_value = 0
- for mod in modifiers_list:
- modifier_value |= modifier_map.get(mod, 0)
-
- for mod in modifiers_list:
- await dispatch_key('keyDown', mod)
- await dispatch_key('keyDown', main_key, modifier_value)
- await dispatch_key('keyUp', main_key, modifier_value)
- for mod in reversed(modifiers_list):
- await dispatch_key('keyUp', mod)
- else:
- normalized = key_aliases.get(keys_str.strip().lower(), keys_str)
- special_keys = {
- 'Enter',
- 'Tab',
- 'Delete',
- 'Backspace',
- 'Escape',
- 'ArrowUp',
- 'ArrowDown',
- 'ArrowLeft',
- 'ArrowRight',
- 'PageUp',
- 'PageDown',
- 'Home',
- 'End',
- 'Control',
- 'Alt',
- 'Meta',
- 'Shift',
- 'F1',
- 'F2',
- 'F3',
- 'F4',
- 'F5',
- 'F6',
- 'F7',
- 'F8',
- 'F9',
- 'F10',
- 'F11',
- 'F12',
- }
- if normalized in special_keys:
- await dispatch_key('keyDown', normalized)
- if normalized == 'Enter':
- await cdp.client.send.Input.dispatchKeyEvent(
- params={'type': 'char', 'text': '\r', 'key': 'Enter'},
- session_id=sid,
- )
- await dispatch_key('keyUp', normalized)
- else:
- # Plain text — use insertText for each character
- for char in normalized:
- await cdp.client.send.Input.insertText(
- params={'text': char},
- session_id=sid,
- )
-
-
-async def _cdp_html(cdp: LightCDP, selector: str | None) -> None:
- """Get raw HTML of the page or a CSS selector."""
- if selector:
- js = f'(function(){{ const el = document.querySelector({json.dumps(selector)}); return el ? el.outerHTML : null; }})()'
- else:
- js = 'document.documentElement.outerHTML'
- result = await cdp.client.send.Runtime.evaluate(params={'expression': js, 'returnByValue': True}, session_id=cdp.session_id)
- html = result.get('result', {}).get('value')
- if html:
- print(html)
- else:
- msg = f'No element found for selector: {selector}' if selector else 'Error: Could not get HTML'
- print(msg, file=sys.stderr)
- sys.exit(1)
-
-
-async def _cdp_eval(cdp: LightCDP, js: str) -> None:
- """Execute JavaScript and print result."""
- result = await cdp.client.send.Runtime.evaluate(params={'expression': js, 'returnByValue': True}, session_id=cdp.session_id)
- value = result.get('result', {}).get('value')
- print(json.dumps(value) if value is not None else 'undefined')
-
-
-# ---------------------------------------------------------------------------
-# Command routing
-# ---------------------------------------------------------------------------
-
-# Commands that always use lightweight CDP (Tier 1)
-_LIGHTWEIGHT_COMMANDS = frozenset(
- {
- 'screenshot',
- 'click',
- 'type',
- 'input',
- 'scroll',
- 'back',
- 'keys',
- 'html',
- 'eval',
- }
-)
-
-
-async def main() -> int:
- args = sys.argv[1:]
- if not args or args[0] in ('help', '--help', '-h'):
- print("""Usage: python -m browser_use.skill_cli.direct <command> [args]
-
-Commands:
- open <url> Navigate to URL
- state Get DOM state with viewport info
- click <index> Click element by index (uses cached positions)
- click <x> <y> Click at viewport coordinates
- type <text> Type into focused element
- input <index> <text> Click element then type
- screenshot [path] Take screenshot (saves to file or prints base64+dimensions)
- scroll [up|down] Scroll page (default: down)
- back Go back in history
- keys <keys> Send keyboard keys
- html [selector] Get raw HTML (full page or CSS selector)
- eval <js> Execute JavaScript
- close Kill browser and clean up
-
-Flags:
- --remote Use browser-use cloud browser (requires BROWSER_USE_API_KEY)""")
- return 0 if args else 1
-
- # Extract --remote flag
- use_remote = '--remote' in args
- args = [a for a in args if a != '--remote']
- if not args:
- print('Error: No command specified', file=sys.stderr)
- return 1
-
- command = args[0]
-
- # ── close: lightweight CDP kill ──────────────────────────────────────
- if command == 'close':
- state = _load_state()
- cdp_url = state.get('cdp_url')
- if not cdp_url:
- print('No active browser session')
- else:
- closed = False
- try:
- from cdp_use import CDPClient
-
- client = CDPClient(cdp_url)
- await client.start()
- await client.send.Browser.close()
- await client.stop()
- closed = True
- except Exception:
- pass
- if not closed:
- try:
- from browser_use.browser.session import BrowserSession
-
- session = BrowserSession(cdp_url=cdp_url)
- await session.start()
- await session.kill()
- except Exception:
- pass
- _clear_state()
- print('Browser closed')
- return 0
-
- # ── open: lightweight if reconnecting, full session if first launch ──
- if command == 'open' and len(args) >= 2:
- url = args[1]
- if not url.startswith(('http://', 'https://', 'file://')):
- url = 'https://' + url
-
- state = _load_state()
- if state.get('cdp_url'):
- # Reconnect — lightweight CDP navigate
- try:
- async with _lightweight_cdp() as cdp:
- await _cdp_navigate(cdp, url)
- # Update target_id in state
- current_state = _load_state()
- current_state['target_id'] = cdp.target_id
- _save_state(current_state)
- print(f'Navigated to: {url}')
- return 0
- except RuntimeError:
- # Browser died — fall through to full session launch
- _clear_state()
-
- # First launch — needs full session
- async with browser(use_remote=use_remote) as session:
- from browser_use.browser.events import NavigateToUrlEvent
-
- await session.event_bus.dispatch(NavigateToUrlEvent(url=url))
- if session.agent_focus_target_id:
- current_state = _load_state()
- current_state['target_id'] = session.agent_focus_target_id
- _save_state(current_state)
- print(f'Navigated to: {url}')
- return 0
-
- # ── state: full session (needs DOMWatchdog for DOM tree building) ────
- if command == 'state':
- async with browser(use_remote=use_remote) as session:
- state_summary = await session.get_browser_state_summary()
- assert state_summary.dom_state is not None
- text = state_summary.dom_state.llm_representation()
- if state_summary.page_info:
- pi = state_summary.page_info
- header = f'viewport: {pi.viewport_width}x{pi.viewport_height}\n'
- header += f'page: {pi.page_width}x{pi.page_height}\n'
- header += f'scroll: ({pi.scroll_x}, {pi.scroll_y})\n'
- text = header + text
- print(text)
-
- # Cache selector map for subsequent click-by-index
- selector_map = await session.get_selector_map()
- if selector_map:
- _save_selector_cache(selector_map)
- return 0
-
- # ── Lightweight commands (Tier 1) ────────────────────────────────────
- if command in _LIGHTWEIGHT_COMMANDS:
- try:
- async with _lightweight_cdp() as cdp:
- if command == 'screenshot':
- path = args[1] if len(args) >= 2 else None
- await _cdp_screenshot(cdp, path)
-
- elif command == 'click' and len(args) >= 2:
- int_args = [int(a) for a in args[1:]]
- if len(int_args) == 2:
- x, y = int_args
- await _cdp_click_coordinate(cdp, x, y)
- print(f'Clicked at ({x}, {y})')
- elif len(int_args) == 1:
- await _cdp_click_index(cdp, int_args[0])
- else:
- print('Usage: click <index> or click <x> <y>', file=sys.stderr)
- return 1
-
- elif command == 'type' and len(args) >= 2:
- text = ' '.join(args[1:])
- await _cdp_type(cdp, text)
- print(f'Typed: {text}')
-
- elif command == 'input' and len(args) >= 3:
- index = int(args[1])
- text = ' '.join(args[2:])
- await _cdp_input(cdp, index, text)
-
- elif command == 'scroll':
- direction = args[1] if len(args) >= 2 else 'down'
- await _cdp_scroll(cdp, direction)
- print(f'Scrolled {direction}')
-
- elif command == 'back':
- await _cdp_back(cdp)
- print('Navigated back')
-
- elif command == 'keys' and len(args) >= 2:
- await _cdp_keys(cdp, ' '.join(args[1:]))
- print(f'Sent keys: {" ".join(args[1:])}')
-
- elif command == 'html':
- selector = args[1] if len(args) >= 2 else None
- await _cdp_html(cdp, selector)
-
- elif command == 'eval' and len(args) >= 2:
- js = ' '.join(args[1:])
- await _cdp_eval(cdp, js)
-
- else:
- print(f'Missing arguments for: {command}', file=sys.stderr)
- return 1
-
- except RuntimeError as e:
- print(f'Error: {e}', file=sys.stderr)
- return 1
- return 0
-
- print(f'Unknown command: {command}', file=sys.stderr)
- return 1
-
-
-if __name__ == '__main__':
- sys.exit(asyncio.run(main()))
diff --git a/browser_use/skill_cli/install.sh b/browser_use/skill_cli/install.sh
index 23847d7a2..8c48ba5f0 100755
--- a/browser_use/skill_cli/install.sh
+++ b/browser_use/skill_cli/install.sh
@@ -76,10 +76,10 @@
# - Always kill stale processes before retrying
# - Or kill all Python: taskkill /IM python.exe /F
#
-# 7. Debugging server issues
-# To see actual error messages instead of "Failed to start session server":
-# & "$env:USERPROFILE\.browser-use-env\Scripts\python.exe" -m browser_use.skill_cli.server --session default --browser chromium
-# This runs the server in foreground and shows all errors.
+# 7. Debugging daemon issues
+# To see actual error messages instead of "Failed to start daemon":
+# & "$env:USERPROFILE\.browser-use-env\Scripts\python.exe" -m browser_use.skill_cli.daemon --browser chromium
+# This runs the daemon in foreground and shows all errors.
#
# =============================================================================
diff --git a/browser_use/skill_cli/main.py b/browser_use/skill_cli/main.py
index acb3cdbdb..09b727bf7 100755
--- a/browser_use/skill_cli/main.py
+++ b/browser_use/skill_cli/main.py
@@ -2,13 +2,12 @@
"""Fast CLI for browser-use. STDLIB ONLY - must start in <50ms.
This is the main entry point for the browser-use CLI. It uses only stdlib
-imports to ensure fast startup, delegating heavy operations to the session
-server which loads once and stays running.
+imports to ensure fast startup, delegating heavy operations to the daemon
+which loads once and stays running.
"""
import argparse
import asyncio
-import hashlib
import json
import os
import socket
@@ -20,7 +19,7 @@ from pathlib import Path
# =============================================================================
# Early command interception (before heavy imports)
-# These commands don't need the session server infrastructure
+# These commands don't need the daemon infrastructure
# =============================================================================
# Handle --mcp flag early to prevent logging initialization
@@ -124,7 +123,7 @@ if '--template' in sys.argv:
# Keep --force/-f and --list/-l flags
elif arg in ('--force', '-f', '--list', '-l'):
new_argv.append(arg)
- # Skip other flags (--session, --browser, --headed, etc.)
+ # Skip other flags (--browser, --headed, etc.)
i += 1
sys.argv = new_argv
@@ -136,69 +135,24 @@ if '--template' in sys.argv:
# =============================================================================
-def get_socket_path(session: str) -> str:
- """Get socket path for session."""
+def _get_socket_path() -> str:
+ """Get the fixed daemon socket path."""
if sys.platform == 'win32':
- # Use 127.0.0.1 explicitly (not localhost) to avoid IPv6 binding issues
- port = 49152 + (int(hashlib.md5(session.encode()).hexdigest()[:4], 16) % 16383)
- return f'tcp://127.0.0.1:{port}'
- return str(Path(tempfile.gettempdir()) / f'browser-use-{session}.sock')
+ return 'tcp://127.0.0.1:49200'
+ return str(Path(tempfile.gettempdir()) / 'browser-use-cli.sock')
-def get_pid_path(session: str) -> Path:
- """Get PID file path for session."""
- return Path(tempfile.gettempdir()) / f'browser-use-{session}.pid'
-
-
-def _pid_exists(pid: int) -> bool:
- """Check if a process with given PID exists.
-
- On Windows, uses ctypes to call OpenProcess (os.kill doesn't work reliably).
- On Unix, uses os.kill(pid, 0) which is the standard approach.
- """
- if sys.platform == 'win32':
- import ctypes
-
- PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
- handle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
- if handle:
- ctypes.windll.kernel32.CloseHandle(handle)
- return True
- return False
- else:
- try:
- os.kill(pid, 0)
- return True
- except OSError:
- return False
-
-
-def is_server_running(session: str) -> bool:
- """Check if server is running for session."""
- pid_path = get_pid_path(session)
- if not pid_path.exists():
- return False
- try:
- pid = int(pid_path.read_text().strip())
- return _pid_exists(pid)
- except (OSError, ValueError):
- # Can't read PID file or invalid PID
- return False
-
-
-def connect_to_server(session: str, timeout: float = 60.0) -> socket.socket:
- """Connect to session server."""
- sock_path = get_socket_path(session)
+def _connect_to_daemon(timeout: float = 60.0) -> socket.socket:
+ """Connect to daemon socket."""
+ sock_path = _get_socket_path()
if sock_path.startswith('tcp://'):
- # Windows: TCP connection
_, hostport = sock_path.split('://', 1)
host, port = hostport.split(':')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
sock.connect((host, int(port)))
else:
- # Unix socket
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.settimeout(timeout)
sock.connect(sock_path)
@@ -206,47 +160,52 @@ def connect_to_server(session: str, timeout: float = 60.0) -> socket.socket:
return sock
-def get_session_metadata_path(session: str) -> Path:
- """Get path to session metadata file (stores browser_mode, headed, profile)."""
- return Path(tempfile.gettempdir()) / f'browser-use-{session}.meta'
-
-
-def ensure_server(session: str, browser: str, headed: bool, profile: str | None, api_key: str | None) -> bool:
- """Start server if not running. Returns True if started."""
- from browser_use.skill_cli.utils import is_session_locked, kill_orphaned_server
+def _is_daemon_alive() -> bool:
+ """Check if daemon is alive by attempting socket connect."""
+ try:
+ sock = _connect_to_daemon(timeout=0.5)
+ sock.close()
+ return True
+ except OSError:
+ # Clean up stale socket on Unix
+ sock_path = _get_socket_path()
+ if not sock_path.startswith('tcp://'):
+ Path(sock_path).unlink(missing_ok=True)
+ return False
- meta_path = get_session_metadata_path(session)
- # Check if server is already running AND holding its lock (healthy server)
- if is_server_running(session) and is_session_locked(session):
+def ensure_daemon(
+ browser: str,
+ headed: bool,
+ profile: str | None,
+ api_key: str | None,
+ *,
+ explicit_config: bool = False,
+) -> None:
+ """Start daemon if not running. Restarts only if user explicitly set config flags."""
+ if _is_daemon_alive():
+ if not explicit_config:
+ return # Daemon is alive, user didn't request specific config — reuse it
+
+ # User explicitly set --browser/--headed/--profile — check config matches
try:
- sock = connect_to_server(session, timeout=0.5) # Increased from 0.1s
- sock.close()
-
- # Check browser mode matches existing session
- if meta_path.exists():
- try:
- meta = json.loads(meta_path.read_text())
- existing_mode = meta.get('browser_mode', 'chromium')
- if existing_mode != browser:
- pass # Mode mismatch is non-fatal for local modes
- except (json.JSONDecodeError, OSError):
- pass # Metadata file corrupt, ignore
-
- return False # Already running with correct mode
+ response = send_command('ping', {})
+ if response.get('success'):
+ data = response.get('data', {})
+ if data.get('browser_mode') == browser and data.get('headed') == headed and data.get('profile') == profile:
+ return # Already running with correct config
+
+ # Config mismatch — shutdown and restart
+ send_command('shutdown', {})
+ time.sleep(0.3)
except Exception:
- pass # Server not responsive, continue to restart logic
-
- # Kill any orphaned server (has PID file but no lock)
- kill_orphaned_server(session)
+ pass # Daemon not responsive, continue to start
- # Build server command
+ # Build daemon command
cmd = [
sys.executable,
'-m',
- 'browser_use.skill_cli.server',
- '--session',
- session,
+ 'browser_use.skill_cli.daemon',
'--browser',
browser,
]
@@ -260,10 +219,8 @@ def ensure_server(session: str, browser: str, headed: bool, profile: str | None,
if api_key:
env['BROWSER_USE_API_KEY'] = api_key
- # Start server as background process
+ # Start daemon as background process
if sys.platform == 'win32':
- # Windows: CREATE_NO_WINDOW prevents console window from appearing
- # CREATE_NEW_PROCESS_GROUP allows the process to survive parent exit
subprocess.Popen(
cmd,
env=env,
@@ -272,7 +229,6 @@ def ensure_server(session: str, browser: str, headed: bool, profile: str | None,
stderr=subprocess.DEVNULL,
)
else:
- # Unix: use start_new_session
subprocess.Popen(
cmd,
env=env,
@@ -281,43 +237,25 @@ def ensure_server(session: str, browser: str, headed: bool, profile: str | None,
stderr=subprocess.DEVNULL,
)
- # Wait for server to be ready (must have PID, lock, and responsive socket)
+ # Wait for daemon to be ready
for _ in range(100): # 5 seconds max
- if is_server_running(session) and is_session_locked(session):
- try:
- sock = connect_to_server(session, timeout=0.5)
- sock.close()
-
- # Write metadata file to track session config
- meta_path.write_text(
- json.dumps(
- {
- 'browser_mode': browser,
- 'headed': headed,
- 'profile': profile,
- }
- )
- )
-
- return True
- except Exception:
- pass
+ if _is_daemon_alive():
+ return
time.sleep(0.05)
- print('Error: Failed to start session server', file=sys.stderr)
+ print('Error: Failed to start daemon', file=sys.stderr)
sys.exit(1)
-def send_command(session: str, action: str, params: dict) -> dict:
- """Send command to server and get response."""
+def send_command(action: str, params: dict) -> dict:
+ """Send command to daemon and get response."""
request = {
'id': f'r{int(time.time() * 1000000) % 1000000}',
'action': action,
- 'session': session,
'params': params,
}
- sock = connect_to_server(session)
+ sock = _connect_to_daemon()
try:
# Send request
sock.sendall((json.dumps(request) + '\n').encode())
@@ -331,7 +269,7 @@ def send_command(session: str, action: str, params: dict) -> dict:
data += chunk
if not data:
- return {'id': request['id'], 'success': False, 'error': 'No response from server'}
+ return {'id': request['id'], 'success': False, 'error': 'No response from daemon'}
return json.loads(data.decode())
finally:
@@ -374,7 +312,6 @@ Setup:
)
# Global flags
- parser.add_argument('--session', '-s', default='default', help='Session name (default: default)')
parser.add_argument(
'--browser',
'-b',
@@ -607,22 +544,8 @@ Setup:
# Session Management
# -------------------------------------------------------------------------
- # sessions
- subparsers.add_parser('sessions', help='List active sessions')
-
# close
- p = subparsers.add_parser('close', help='Close session')
- p.add_argument('--all', action='store_true', help='Close all sessions')
-
- # -------------------------------------------------------------------------
- # Server Control
- # -------------------------------------------------------------------------
-
- server_p = subparsers.add_parser('server', help='Server control')
- server_sub = server_p.add_subparsers(dest='server_command')
- server_sub.add_parser('status', help='Check server status')
- server_sub.add_parser('stop', help='Stop server')
- server_sub.add_parser('logs', help='View server logs')
+ subparsers.add_parser('close', help='Close browser and stop daemon')
# -------------------------------------------------------------------------
# Profile Management (local only, use -b real)
@@ -645,39 +568,6 @@ Setup:
return parser
-def handle_server_command(args: argparse.Namespace) -> int:
- """Handle server subcommands."""
- if args.server_command == 'status':
- if is_server_running(args.session):
- print(f'Server for session "{args.session}" is running')
- return 0
- else:
- print(f'Server for session "{args.session}" is not running')
- return 1
-
- elif args.server_command == 'stop':
- if not is_server_running(args.session):
- print(f'Server for session "{args.session}" is not running')
- return 0
- response = send_command(args.session, 'shutdown', {})
- if response.get('success'):
- print(f'Server for session "{args.session}" stopped')
- return 0
- else:
- print(f'Error: {response.get("error")}', file=sys.stderr)
- return 1
-
- elif args.server_command == 'logs':
- log_path = Path(tempfile.gettempdir()) / f'browser-use-{args.session}.log'
- if log_path.exists():
- print(log_path.read_text())
- else:
- print('No logs found')
- return 0
-
- return 0
-
-
def main() -> int:
"""Main entry point."""
parser = build_parser()
@@ -687,60 +577,12 @@ def main() -> int:
parser.print_help()
return 0
- # Handle server subcommands without starting server
- if args.command == 'server':
- return handle_server_command(args)
-
- # Handle profile subcommands without starting server
+ # Handle profile subcommands without starting daemon
if args.command == 'profile':
from browser_use.skill_cli.commands.profile import handle_profile_command
return handle_profile_command(args)
- # Handle sessions list - find all running sessions
- if args.command == 'sessions':
- from browser_use.skill_cli.utils import find_all_sessions
-
- session_names = find_all_sessions()
- sessions = [{'name': name, 'status': 'running'} for name in session_names]
-
- if args.json:
- print(json.dumps(sessions))
- else:
- if sessions:
- for s in sessions:
- print(f' {s["name"]}: {s["status"]}')
- else:
- print('No active sessions')
- return 0
-
- # Handle close --all by closing all running sessions
- if args.command == 'close' and getattr(args, 'all', False):
- from browser_use.skill_cli.utils import find_all_sessions
-
- session_names = find_all_sessions()
- closed = []
- for name in session_names:
- try:
- response = send_command(name, 'close', {})
- if response.get('success'):
- closed.append(name)
- # Clean up metadata file
- meta_path = get_session_metadata_path(name)
- if meta_path.exists():
- meta_path.unlink()
- except Exception:
- pass # Server may already be stopping
-
- if args.json:
- print(json.dumps({'closed': closed, 'count': len(closed)}))
- else:
- if closed:
- print(f'Closed {len(closed)} session(s): {", ".join(closed)}')
- else:
- print('No active sessions')
- return 0
-
# Handle setup command
if args.command == 'setup':
from browser_use.skill_cli.commands import setup
@@ -864,6 +706,24 @@ def main() -> int:
print(f'Stopped tunnel on port {result["stopped"]}')
return 0
+ # Handle close — shutdown daemon
+ if args.command == 'close':
+ if _is_daemon_alive():
+ try:
+ response = send_command('shutdown', {})
+ if args.json:
+ print(json.dumps(response))
+ else:
+ print('Browser closed')
+ except Exception:
+ print('Browser closed')
+ else:
+ if args.json:
+ print(json.dumps({'success': True, 'data': {'shutdown': True}}))
+ else:
+ print('No active browser session')
+ return 0
+
# Validate requested mode is available based on installation config
from browser_use.skill_cli.install_config import get_mode_unavailable_error, is_mode_available
@@ -878,18 +738,19 @@ def main() -> int:
# Validate --profile flag usage
if args.profile and args.browser == 'chromium':
print(
- 'Error: --profile is not supported in chromium mode.\n'
- 'Use -b real for local Chrome profiles.',
+ 'Error: --profile is not supported in chromium mode.\nUse -b real for local Chrome profiles.',
file=sys.stderr,
)
return 1
- # Ensure server is running
- ensure_server(args.session, args.browser, args.headed, args.profile, args.api_key)
+ # Ensure daemon is running
+ # Only restart on config mismatch if the user explicitly passed config flags
+ explicit_config = any(flag in sys.argv for flag in ('--browser', '-b', '--headed', '--profile'))
+ ensure_daemon(args.browser, args.headed, args.profile, args.api_key, explicit_config=explicit_config)
# Build params from args
params = {}
- skip_keys = {'command', 'session', 'browser', 'headed', 'json', 'api_key', 'server_command'}
+ skip_keys = {'command', 'browser', 'headed', 'json', 'api_key'}
for key, value in vars(args).items():
if key not in skip_keys and value is not None:
@@ -899,14 +760,8 @@ def main() -> int:
if args.profile:
params['profile'] = args.profile
- # Send command to server
- response = send_command(args.session, args.command, params)
-
- # Clean up metadata file on successful close
- if args.command == 'close' and response.get('success'):
- meta_path = get_session_metadata_path(args.session)
- if meta_path.exists():
- meta_path.unlink()
+ # Send command to daemon
+ response = send_command(args.command, params)
# Output response
if args.json:
diff --git a/browser_use/skill_cli/protocol.py b/browser_use/skill_cli/protocol.py
deleted file mode 100644
index 9be7964d0..000000000
--- a/browser_use/skill_cli/protocol.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""Wire protocol for CLI↔Server communication.
-
-Uses JSON over Unix sockets (or TCP on Windows) with newline-delimited messages.
-"""
-
-import json
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-
-@dataclass
-class Request:
- """Command request from CLI to server."""
-
- id: str
- action: str
- session: str
- params: dict[str, Any] = field(default_factory=dict)
-
- def to_json(self) -> str:
- return json.dumps(asdict(self))
-
- @classmethod
- def from_json(cls, data: str) -> 'Request':
- d = json.loads(data)
- return cls(
- id=d['id'],
- action=d['action'],
- session=d['session'],
- params=d.get('params', {}),
- )
-
-
-@dataclass
-class Response:
- """Response from server to CLI."""
-
- id: str
- success: bool
- data: Any = None
- error: str | None = None
-
- def to_json(self) -> str:
- return json.dumps(asdict(self))
-
- @classmethod
- def from_json(cls, data: str) -> 'Response':
- d = json.loads(data)
- return cls(
- id=d['id'],
- success=d['success'],
- data=d.get('data'),
- error=d.get('error'),
- )
diff --git a/browser_use/skill_cli/server.py b/browser_use/skill_cli/server.py
deleted file mode 100644
index 01bf47e30..000000000
--- a/browser_use/skill_cli/server.py
+++ /dev/null
@@ -1,292 +0,0 @@
-"""Session server - keeps BrowserSession instances alive.
-
-This server runs as a background process, managing browser sessions and
-handling commands from the CLI. It uses Unix sockets (or TCP on Windows)
-for IPC communication.
-"""
-
-import argparse
-import asyncio
-import json
-import logging
-import os
-import signal
-import sys
-from pathlib import Path
-from typing import IO
-
-import portalocker
-
-# Configure logging before imports
-logging.basicConfig(
- level=logging.INFO,
- format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
- handlers=[logging.StreamHandler()],
-)
-logger = logging.getLogger('browser_use.skill_cli.server')
-
-
-class SessionServer:
- """Server that manages browser sessions and handles CLI commands."""
-
- def __init__(
- self,
- session_name: str,
- browser_mode: str,
- headed: bool,
- profile: str | None,
- ) -> None:
- self.session_name = session_name
- self.browser_mode = browser_mode
- self.headed = headed
- self.profile = profile
- self.running = True
- self._server: asyncio.Server | None = None
- self._shutdown_event: asyncio.Event | None = None
- self._lock_file: IO | None = None
-
- # Lazy import to avoid loading everything at startup
- from browser_use.skill_cli.sessions import SessionRegistry
-
- self.registry = SessionRegistry()
-
- async def handle_connection(
- self,
- reader: asyncio.StreamReader,
- writer: asyncio.StreamWriter,
- ) -> None:
- """Handle a client connection."""
- addr = writer.get_extra_info('peername')
- logger.debug(f'Connection from {addr}')
-
- try:
- while self.running:
- try:
- line = await asyncio.wait_for(reader.readline(), timeout=300) # 5 min timeout
- except TimeoutError:
- logger.debug(f'Connection timeout from {addr}')
- break
-
- if not line:
- break
-
- request = {}
- try:
- request = json.loads(line.decode())
- response = await self.dispatch(request)
- except json.JSONDecodeError as e:
- response = {'id': '', 'success': False, 'error': f'Invalid JSON: {e}'}
- except Exception as e:
- logger.exception(f'Error handling request: {e}')
- response = {'id': '', 'success': False, 'error': str(e)}
-
- writer.write((json.dumps(response) + '\n').encode())
- await writer.drain()
-
- # Check for shutdown command
- if request.get('action') == 'shutdown':
- await self.shutdown()
- break
-
- except Exception as e:
- logger.exception(f'Connection error: {e}')
- finally:
- writer.close()
- try:
- await writer.wait_closed()
- except Exception:
- pass
-
- async def dispatch(self, request: dict) -> dict:
- """Dispatch command to appropriate handler."""
- action = request.get('action', '')
- params = request.get('params', {})
- req_id = request.get('id', '')
-
- logger.info(f'Dispatch: {action} (id={req_id})')
-
- try:
- # Import command handlers
- from browser_use.skill_cli.commands import agent, browser, python_exec, session
-
- # Handle shutdown
- if action == 'shutdown':
- return {'id': req_id, 'success': True, 'data': {'shutdown': True}}
-
- # Session commands don't need a browser session
- if action in session.COMMANDS:
- result = await session.handle(action, self.session_name, self.registry, params)
- # Check if command wants to shutdown server
- if result.get('_shutdown'):
- asyncio.create_task(self.shutdown())
- return {'id': req_id, 'success': True, 'data': result}
-
- # Get or create session for browser commands
- session_info = await self.registry.get_or_create(
- self.session_name,
- self.browser_mode,
- self.headed,
- self.profile,
- )
-
- # Dispatch to handler
- if action in browser.COMMANDS:
- result = await browser.handle(action, session_info, params)
- elif action == 'python':
- result = await python_exec.handle(session_info, params)
- elif action == 'run':
- result = await agent.handle(session_info, params)
- else:
- return {'id': req_id, 'success': False, 'error': f'Unknown action: {action}'}
-
- return {'id': req_id, 'success': True, 'data': result}
-
- except Exception as e:
- logger.exception(f'Error dispatching {action}: {e}')
- return {'id': req_id, 'success': False, 'error': str(e)}
-
- async def shutdown(self) -> None:
- """Graceful shutdown."""
- logger.info('Shutting down server...')
- self.running = False
-
- # Signal the shutdown event
- if self._shutdown_event:
- self._shutdown_event.set()
-
- # Close all sessions
- await self.registry.close_all()
-
- # Stop the server
- if self._server:
- self._server.close()
- await self._server.wait_closed()
-
- # Clean up files
- from browser_use.skill_cli.utils import cleanup_session_files
-
- cleanup_session_files(self.session_name)
-
- async def run(self) -> None:
- """Run the server."""
- from browser_use.skill_cli.utils import get_lock_path, get_pid_path, get_socket_path
-
- # Acquire exclusive lock BEFORE writing PID - this prevents race conditions
- lock_path = get_lock_path(self.session_name)
- lock_path.parent.mkdir(parents=True, exist_ok=True)
- lock_path.touch(exist_ok=True)
-
- self._lock_file = open(lock_path, 'r+') # noqa: ASYNC230 - blocking ok at startup
- try:
- portalocker.lock(self._lock_file, portalocker.LOCK_EX | portalocker.LOCK_NB)
- except portalocker.LockException:
- logger.error(f'Another server is already running for session: {self.session_name}')
- self._lock_file.close()
- self._lock_file = None
- sys.exit(1)
-
- logger.info(f'Acquired exclusive lock for session: {self.session_name}')
-
- # NOW safe to write PID file
- pid_path = get_pid_path(self.session_name)
- pid_path.write_text(str(os.getpid()))
- logger.info(f'PID file: {pid_path}')
-
- # Setup signal handlers
- loop = asyncio.get_running_loop()
-
- def signal_handler():
- asyncio.create_task(self.shutdown())
-
- for sig in (signal.SIGINT, signal.SIGTERM):
- try:
- loop.add_signal_handler(sig, signal_handler)
- except NotImplementedError:
- # Windows doesn't support add_signal_handler
- pass
-
- # Also handle SIGHUP on Unix
- if hasattr(signal, 'SIGHUP'):
- try:
- loop.add_signal_handler(signal.SIGHUP, signal_handler)
- except NotImplementedError:
- pass
-
- # Get socket path
- sock_path = get_socket_path(self.session_name)
- logger.info(f'Socket: {sock_path}')
-
- # Start server
- if sock_path.startswith('tcp://'):
- # Windows: TCP server
- _, hostport = sock_path.split('://', 1)
- host, port = hostport.split(':')
- self._server = await asyncio.start_server(
- self.handle_connection,
- host,
- int(port),
- reuse_address=True, # Allow rebinding ports in TIME_WAIT state
- )
- logger.info(f'Listening on TCP {host}:{port}')
- else:
- # Unix: socket server
- # Remove stale socket file
- sock_file = Path(sock_path)
- if sock_file.exists():
- sock_file.unlink()
-
- self._server = await asyncio.start_unix_server(
- self.handle_connection,
- sock_path,
- )
- logger.info(f'Listening on Unix socket {sock_path}')
-
- # Run until shutdown
- self._shutdown_event = asyncio.Event()
- try:
- async with self._server:
- await self._shutdown_event.wait()
- except asyncio.CancelledError:
- pass
- finally:
- # Release lock on shutdown
- if self._lock_file:
- try:
- portalocker.unlock(self._lock_file)
- self._lock_file.close()
- except Exception:
- pass
- self._lock_file = None
- logger.info('Server stopped')
-
-
-def main() -> None:
- """Main entry point for server process."""
- parser = argparse.ArgumentParser(description='Browser-use session server')
- parser.add_argument('--session', required=True, help='Session name')
- parser.add_argument('--browser', default='chromium', choices=['chromium', 'real'])
- parser.add_argument('--headed', action='store_true', help='Show browser window')
- parser.add_argument('--profile', help='Chrome profile (real browser mode)')
- args = parser.parse_args()
-
- logger.info(f'Starting server for session: {args.session}')
- logger.info(f'Browser mode: {args.browser}, headed: {args.headed}')
-
- server = SessionServer(
- session_name=args.session,
- browser_mode=args.browser,
- headed=args.headed,
- profile=args.profile,
- )
-
- try:
- asyncio.run(server.run())
- except KeyboardInterrupt:
- logger.info('Interrupted')
- except Exception as e:
- logger.exception(f'Server error: {e}')
- sys.exit(1)
-
-
-if __name__ == '__main__':
- main()
diff --git a/browser_use/skill_cli/sessions.py b/browser_use/skill_cli/sessions.py
index 1b7f564b1..014199f87 100644
--- a/browser_use/skill_cli/sessions.py
+++ b/browser_use/skill_cli/sessions.py
@@ -1,8 +1,7 @@
-"""Session registry - manages BrowserSession instances."""
+"""Session data — SessionInfo dataclass and browser session factory."""
import logging
from dataclasses import dataclass, field
-from typing import Any
from browser_use.browser.session import BrowserSession
from browser_use.skill_cli.python_session import PythonSession
@@ -22,81 +21,6 @@ class SessionInfo:
python_session: PythonSession = field(default_factory=PythonSession)
-class SessionRegistry:
- """Registry of active browser sessions.
-
- Sessions are created on-demand when first accessed. Each named session
- is isolated with its own BrowserSession and Python namespace.
- """
-
- def __init__(self) -> None:
- self._sessions: dict[str, SessionInfo] = {}
-
- async def get_or_create(
- self,
- name: str,
- browser_mode: str,
- headed: bool,
- profile: str | None,
- ) -> SessionInfo:
- """Get existing session or create new one."""
- if name in self._sessions:
- return self._sessions[name]
-
- logger.info(f'Creating new session: {name} (mode={browser_mode}, headed={headed})')
-
- browser_session = await create_browser_session(browser_mode, headed, profile)
- await browser_session.start()
-
- session_info = SessionInfo(
- name=name,
- browser_mode=browser_mode,
- headed=headed,
- profile=profile,
- browser_session=browser_session,
- )
- self._sessions[name] = session_info
- return session_info
-
- def get(self, name: str) -> SessionInfo | None:
- """Get session by name."""
- return self._sessions.get(name)
-
- def list_sessions(self) -> list[dict[str, Any]]:
- """List all active sessions."""
- return [
- {
- 'name': s.name,
- 'browser_mode': s.browser_mode,
- 'headed': s.headed,
- 'profile': s.profile,
- }
- for s in self._sessions.values()
- ]
-
- async def close_session(self, name: str) -> bool:
- """Close and remove a session."""
- if name not in self._sessions:
- return False
-
- session = self._sessions.pop(name)
- logger.info(f'Closing session: {name}')
-
- # Note: Tunnels are managed independently via tunnel.py
- # They persist across session close/open cycles
-
- try:
- await session.browser_session.kill()
- except Exception as e:
- logger.warning(f'Error closing session {name}: {e}')
- return True
-
- async def close_all(self) -> None:
- """Close all sessions."""
- for name in list(self._sessions.keys()):
- await self.close_session(name)
-
-
async def create_browser_session(
mode: str,
headed: bool,
diff --git a/browser_use/skill_cli/utils.py b/browser_use/skill_cli/utils.py
index 0cdcab0a1..36baf129f 100644
--- a/browser_use/skill_cli/utils.py
+++ b/browser_use/skill_cli/utils.py
@@ -1,205 +1,63 @@
-"""Platform utilities for CLI and server."""
+"""Platform utilities for CLI and daemon."""
-import hashlib
import os
import platform
-import signal
import subprocess
import sys
import tempfile
from pathlib import Path
-from typing import IO
-import portalocker
-
-def get_socket_path(session: str) -> str:
- """Get socket path for session.
+def get_socket_path() -> str:
+ """Get the fixed daemon socket path.
On Windows, returns a TCP address (tcp://127.0.0.1:PORT).
On Unix, returns a Unix socket path.
"""
if sys.platform == 'win32':
- # Windows: use TCP on deterministic port (49152-65535)
- # Use 127.0.0.1 explicitly (not localhost) to avoid IPv6 binding issues
- port = 49152 + (int(hashlib.md5(session.encode()).hexdigest()[:4], 16) % 16383)
- return f'tcp://127.0.0.1:{port}'
- return str(Path(tempfile.gettempdir()) / f'browser-use-{session}.sock')
-
-
-def get_pid_path(session: str) -> Path:
- """Get PID file path for session."""
- return Path(tempfile.gettempdir()) / f'browser-use-{session}.pid'
-
-
-def get_log_path(session: str) -> Path:
- """Get log file path for session."""
- return Path(tempfile.gettempdir()) / f'browser-use-{session}.log'
-
+ return 'tcp://127.0.0.1:49200'
+ return str(Path(tempfile.gettempdir()) / 'browser-use-cli.sock')
-def get_lock_path(session: str) -> Path:
- """Get lock file path for session."""
- return Path(tempfile.gettempdir()) / f'browser-use-{session}.lock'
+def is_daemon_alive() -> bool:
+ """Check daemon liveness by attempting socket connect.
-def _pid_exists(pid: int) -> bool:
- """Check if a process with given PID exists.
-
- On Windows, uses ctypes to call OpenProcess (os.kill doesn't work reliably).
- On Unix, uses os.kill(pid, 0) which is the standard approach.
+ If socket file exists but nobody is listening, removes the stale file.
"""
- if sys.platform == 'win32':
- import ctypes
+ import socket
- PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
- handle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
- if handle:
- ctypes.windll.kernel32.CloseHandle(handle)
- return True
- return False
- else:
+ sock_path = get_socket_path()
+
+ if sock_path.startswith('tcp://'):
+ _, hostport = sock_path.split('://', 1)
+ host, port_str = hostport.split(':')
try:
- os.kill(pid, 0)
+ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ s.settimeout(0.5)
+ s.connect((host, int(port_str)))
+ s.close()
return True
except OSError:
return False
-
-
-def is_server_running(session: str) -> bool:
- """Check if server is running for session."""
- pid_path = get_pid_path(session)
- if not pid_path.exists():
- return False
- try:
- pid = int(pid_path.read_text().strip())
- return _pid_exists(pid)
- except (OSError, ValueError):
- # Can't read PID file or invalid PID
- return False
-
-
-def try_acquire_server_lock(session: str) -> IO | None:
- """Try to acquire the server lock non-blocking.
-
- Returns:
- Lock file handle if acquired (caller must keep in scope to maintain lock),
- None if lock is already held by another process.
- """
- lock_path = get_lock_path(session)
- lock_path.parent.mkdir(parents=True, exist_ok=True)
- lock_path.touch(exist_ok=True)
-
- lock_file = open(lock_path, 'r+')
- try:
- portalocker.lock(lock_file, portalocker.LOCK_EX | portalocker.LOCK_NB)
- return lock_file
- except portalocker.LockException:
- lock_file.close()
- return None
-
-
-def is_session_locked(session: str) -> bool:
- """Check if session has an active lock (server is holding it)."""
- lock_path = get_lock_path(session)
- if not lock_path.exists():
- return False
-
- try:
- with open(lock_path, 'r+') as f:
- portalocker.lock(f, portalocker.LOCK_EX | portalocker.LOCK_NB)
- portalocker.unlock(f)
- return False # Lock acquired = no one holding it
- except portalocker.LockException:
- return True # Lock failed = someone holding it
- except OSError:
- return False # File access error
-
-
-def kill_orphaned_server(session: str) -> bool:
- """Kill an orphaned server (has PID file but no lock).
-
- An orphaned server is one where the process is running but it doesn't
- hold the session lock (e.g., because a newer server took over the lock
- file but didn't kill the old process).
-
- Returns:
- True if an orphan was found and killed.
- """
- pid_path = get_pid_path(session)
- if not pid_path.exists():
- return False
-
- # Check if session is locked (server alive and holding lock)
- if is_session_locked(session):
- return False # Not an orphan - server is healthy
-
- # PID exists but no lock - orphan situation
- try:
- pid = int(pid_path.read_text().strip())
- if _pid_exists(pid):
- # Kill the orphaned process
- if sys.platform == 'win32':
- import ctypes
-
- PROCESS_TERMINATE = 1
- handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
- if handle:
- ctypes.windll.kernel32.TerminateProcess(handle, 1)
- ctypes.windll.kernel32.CloseHandle(handle)
- else:
- os.kill(pid, signal.SIGKILL)
- return True
- except (OSError, ValueError):
- pass
-
- # Clean up stale files even if we couldn't kill (process may be gone)
- cleanup_session_files(session)
- return False
-
-
-def find_all_sessions() -> list[str]:
- """Find all running browser-use sessions by scanning PID files."""
- sessions = []
- tmpdir = Path(tempfile.gettempdir())
- for pid_file in tmpdir.glob('browser-use-*.pid'):
- # Extract session name from filename: browser-use-{session}.pid
- name = pid_file.stem.replace('browser-use-', '', 1)
- if is_server_running(name):
- sessions.append(name)
- return sessions
-
-
-def cleanup_session_files(session: str) -> None:
- """Remove session socket, PID, lock, and metadata files."""
- sock_path = get_socket_path(session)
- pid_path = get_pid_path(session)
- lock_path = get_lock_path(session)
- meta_path = Path(tempfile.gettempdir()) / f'browser-use-{session}.meta'
-
- # Remove socket file (Unix only)
- if not sock_path.startswith('tcp://'):
+ else:
+ sock_file = Path(sock_path)
+ if not sock_file.exists():
+ return False
try:
- os.unlink(sock_path)
+ s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ s.settimeout(0.5)
+ s.connect(sock_path)
+ s.close()
+ return True
except OSError:
- pass
+ # Stale socket file — remove it
+ sock_file.unlink(missing_ok=True)
+ return False
- # Remove PID file
- try:
- pid_path.unlink()
- except OSError:
- pass
- # Remove lock file
- try:
- lock_path.unlink()
- except OSError:
- pass
-
- # Remove metadata file
- try:
- meta_path.unlink()
- except OSError:
- pass
+def get_log_path() -> Path:
+ """Get log file path for the daemon."""
+ return Path(tempfile.gettempdir()) / 'browser-use-cli.log'
def find_chrome_executable() -> str | None:
diff --git a/pyproject.toml b/pyproject.toml
index ddb7920f6..41cc7934d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,7 +19,6 @@ dependencies = [
"rich==14.3.1",
"google-api-core==2.29.0",
"httpx==0.28.1",
- "portalocker==2.10.1",
"posthog==7.7.0",
"psutil==7.2.2",
"pydantic==2.12.5",
diff --git a/skills/browser-use/SKILL.md b/skills/browser-use/SKILL.md
index c537e731d..c09a3d6cc 100644
--- a/skills/browser-use/SKILL.md
+++ b/skills/browser-use/SKILL.md
@@ -68,9 +68,7 @@ browser-use wait selector "h1" # Wait for element
browser-use wait text "Success" # Wait for text
# Session
-browser-use sessions # List active sessions
-browser-use close # Close current session
-browser-use close --all # Close all sessions
+browser-use close # Close browser session
# AI Agent
browser-use run "Fill the contact form" # Run local agent
@@ -186,9 +184,7 @@ browser-use tunnel stop --all # Stop all tunnels
### Session Management
```bash
-browser-use sessions # List active sessions
-browser-use close # Close current session
-browser-use close --all # Close all sessions
+browser-use close # Close browser session
```
### Profile Management
@@ -200,11 +196,6 @@ browser-use -b real profile get "Default" # Get profile details
browser-use -b real profile cookies "Default" # Show cookie domains in profile
```
-### Server Control
-```bash
-browser-use server logs # View server logs
-```
-
## Common Workflows
### Authenticated Browsing with Profiles
@@ -267,15 +258,12 @@ browser-use screenshot
| Option | Description |
|--------|-------------|
-| `--session NAME` | Use named session (default: "default") |
| `--browser MODE` | Browser mode: chromium, real |
| `--headed` | Show browser window (chromium mode) |
| `--profile NAME` | Browser profile (local Chrome profile name) |
| `--json` | Output as JSON |
| `--mcp` | Run as MCP server via stdin/stdout |
-**Session behavior**: All commands without `--session` use the same "default" session. The browser stays open and is reused across commands. Use `--session NAME` to run multiple browsers in parallel.
-
## Tips
1. **Always run `browser-use state` first** to see available elements and their indices
@@ -294,7 +282,7 @@ browser-use doctor
**Browser won't start?**
```bash
-browser-use close --all # Close all sessions
+browser-use close # Close browser session
browser-use --headed open <url> # Try with visible window
```
@@ -305,13 +293,6 @@ browser-use scroll down # Element might be below fold
browser-use state # Check again
```
-**Session issues?**
-```bash
-browser-use sessions # Check active sessions
-browser-use close --all # Clean slate
-browser-use open <url> # Fresh start
-```
-
## Cleanup
**Always close the browser when done:**
diff --git a/skills/remote-browser/SKILL.md b/skills/remote-browser/SKILL.md
index b8e903fd5..ffeb02373 100644
--- a/skills/remote-browser/SKILL.md
+++ b/skills/remote-browser/SKILL.md
@@ -180,9 +180,7 @@ browser-use tunnel stop --all # Stop all tunnels
### Session Management
```bash
-browser-use sessions # List active sessions
-browser-use close # Close current session
-browser-use close --all # Close all sessions
+browser-use close # Close browser session
```
## Common Workflows
@@ -213,7 +211,6 @@ browser-use screenshot
| Option | Description |
|--------|-------------|
-| `--session NAME` | Named session (default: "default") |
| `--browser MODE` | Browser mode: chromium, real |
| `--json` | Output as JSON |
@@ -230,7 +227,7 @@ browser-use screenshot
**Browser won't start?**
- Run `browser-use doctor` to check configuration
-- `browser-use close --all` then retry
+- `browser-use close` then retry
**Tunnel not working?**
- Verify cloudflared is installed: `which cloudflared`
diff --git a/tests/ci/test_cli_coordinate_click.py b/tests/ci/test_cli_coordinate_click.py
index a3f4e2c7a..f4dc22da6 100644
--- a/tests/ci/test_cli_coordinate_click.py
+++ b/tests/ci/test_cli_coordinate_click.py
@@ -1,19 +1,13 @@
"""Tests for CLI coordinate clicking support.
Verifies that the CLI correctly parses both index-based and coordinate-based
-click commands, that the browser command handler dispatches the right events,
-and that the direct CLI selector map cache works correctly.
+click commands, and that the browser command handler dispatches the right events.
"""
from __future__ import annotations
-from typing import TYPE_CHECKING
-
import pytest
-if TYPE_CHECKING:
- from browser_use.dom.views import DOMRect, EnhancedDOMTreeNode
-
from browser_use.skill_cli.main import build_parser
@@ -139,197 +133,3 @@ class TestClickCommandHandler:
result = await handle('click', session_info, {'args': [1, 2, 3]})
assert 'error' in result
assert 'Usage' in result['error']
-
-
-def _make_dom_node(
- *,
- node_name: str,
- absolute_position: DOMRect | None = None,
- ax_name: str | None = None,
- node_value: str = '',
-) -> EnhancedDOMTreeNode:
- """Build a real EnhancedDOMTreeNode for testing."""
- from browser_use.dom.views import (
- EnhancedAXNode,
- EnhancedDOMTreeNode,
- NodeType,
- )
-
- ax_node = None
- if ax_name is not None:
- ax_node = EnhancedAXNode(
- ax_node_id='ax-0',
- ignored=False,
- role='button',
- name=ax_name,
- description=None,
- properties=None,
- child_ids=None,
- )
-
- return EnhancedDOMTreeNode(
- node_id=1,
- backend_node_id=1,
- node_type=NodeType.ELEMENT_NODE,
- node_name=node_name,
- node_value=node_value,
- attributes={},
- is_scrollable=None,
- is_visible=True,
- absolute_position=absolute_position,
- target_id='target-0',
- frame_id=None,
- session_id=None,
- content_document=None,
- shadow_root_type=None,
- shadow_roots=None,
- parent_node=None,
- children_nodes=None,
- ax_node=ax_node,
- snapshot_node=None,
- )
-
-
-class TestSelectorCache:
- """Test selector map cache round-trip and coordinate conversion."""
-
- @pytest.fixture(autouse=True)
- def _use_tmp_state_file(self, monkeypatch, tmp_path):
- """Redirect STATE_FILE to a temp dir so tests don't clobber real state."""
- import browser_use.skill_cli.direct as direct_mod
-
- self.state_file = tmp_path / 'browser-use-direct.json'
- monkeypatch.setattr(direct_mod, 'STATE_FILE', self.state_file)
-
- def test_save_and_load_cache_round_trip(self):
- """_save_selector_cache → _load_selector_cache preserves data."""
- from browser_use.dom.views import DOMRect
- from browser_use.skill_cli.direct import (
- _load_selector_cache,
- _save_selector_cache,
- _save_state,
- )
-
- _save_state({'cdp_url': 'ws://localhost:9222'})
-
- node_1 = _make_dom_node(
- node_name='BUTTON',
- absolute_position=DOMRect(x=100.0, y=200.0, width=80.0, height=32.0),
- ax_name='Submit',
- )
- node_2 = _make_dom_node(
- node_name='A',
- absolute_position=DOMRect(x=50.0, y=800.5, width=200.0, height=40.0),
- node_value='Click here',
- )
-
- _save_selector_cache({5: node_1, 12: node_2})
-
- loaded = _load_selector_cache()
- assert 5 in loaded
- assert 12 in loaded
- assert loaded[5]['x'] == 100.0
- assert loaded[5]['y'] == 200.0
- assert loaded[5]['w'] == 80.0
- assert loaded[5]['h'] == 32.0
- assert loaded[5]['tag'] == 'button'
- assert loaded[5]['text'] == 'Submit'
- assert loaded[12]['x'] == 50.0
- assert loaded[12]['y'] == 800.5
- assert loaded[12]['tag'] == 'a'
- assert loaded[12]['text'] == 'Click here'
-
- def test_load_empty_cache(self):
- """_load_selector_cache returns empty dict when no cache exists."""
- from browser_use.skill_cli.direct import _load_selector_cache, _save_state
-
- _save_state({'cdp_url': 'ws://localhost:9222'})
- loaded = _load_selector_cache()
- assert loaded == {}
-
- def test_cache_skips_nodes_without_position(self):
- """Nodes without absolute_position are not cached."""
- from browser_use.skill_cli.direct import (
- _load_selector_cache,
- _save_selector_cache,
- _save_state,
- )
-
- _save_state({'cdp_url': 'ws://localhost:9222'})
-
- node = _make_dom_node(node_name='DIV', absolute_position=None)
- _save_selector_cache({1: node})
- loaded = _load_selector_cache()
- assert loaded == {}
-
- def test_viewport_coordinate_conversion(self):
- """Document coords + scroll offset → viewport coords."""
- elem = {'x': 150.0, 'y': 900.0, 'w': 80.0, 'h': 32.0}
- scroll_x, scroll_y = 0.0, 500.0
-
- viewport_x = int(elem['x'] + elem['w'] / 2 - scroll_x)
- viewport_y = int(elem['y'] + elem['h'] / 2 - scroll_y)
-
- assert viewport_x == 190
- assert viewport_y == 416
-
- def test_viewport_conversion_with_horizontal_scroll(self):
- """Horizontal scroll is also accounted for."""
- elem = {'x': 1200.0, 'y': 300.0, 'w': 100.0, 'h': 50.0}
- scroll_x, scroll_y = 800.0, 100.0
-
- viewport_x = int(elem['x'] + elem['w'] / 2 - scroll_x)
- viewport_y = int(elem['y'] + elem['h'] / 2 - scroll_y)
-
- assert viewport_x == 450
- assert viewport_y == 225
-
- def test_cache_invalidated_on_navigate(self):
- """Navigating clears selector_map from state."""
- from browser_use.skill_cli.direct import _load_state, _save_state
-
- _save_state(
- {
- 'cdp_url': 'ws://localhost:9222',
- 'target_id': 'abc',
- 'selector_map': {'1': {'x': 10, 'y': 20, 'w': 30, 'h': 40, 'tag': 'a', 'text': 'Link'}},
- }
- )
-
- state = _load_state()
- state.pop('selector_map', None)
- _save_state(state)
-
- reloaded = _load_state()
- assert 'selector_map' not in reloaded
- assert reloaded['cdp_url'] == 'ws://localhost:9222'
- assert reloaded['target_id'] == 'abc'
-
- def test_state_overwritten_on_fresh_cache(self):
- """Running state overwrites old cache with new data."""
- from browser_use.dom.views import DOMRect
- from browser_use.skill_cli.direct import (
- _load_selector_cache,
- _save_selector_cache,
- _save_state,
- )
-
- _save_state(
- {
- 'cdp_url': 'ws://localhost:9222',
- 'selector_map': {'99': {'x': 0, 'y': 0, 'w': 0, 'h': 0, 'tag': 'old', 'text': 'old'}},
- }
- )
-
- node = _make_dom_node(
- node_name='SPAN',
- absolute_position=DOMRect(x=5.0, y=10.0, width=20.0, height=15.0),
- ax_name='New',
- )
-
- _save_selector_cache({7: node})
- loaded = _load_selector_cache()
-
- assert 99 not in loaded
- assert 7 in loaded
- assert loaded[7]['tag'] == 'span'
diff --git a/tests/ci/test_cli_headed_flag.py b/tests/ci/test_cli_headed_flag.py
index d66b7586e..7145fa4f6 100644
--- a/tests/ci/test_cli_headed_flag.py
+++ b/tests/ci/test_cli_headed_flag.py
@@ -19,13 +19,13 @@ def test_headed_flag_before_open_subcommand():
assert args.command == 'open'
-def test_headed_flag_with_session():
- """Test that --headed works with other global flags like -s/--session."""
+def test_headed_flag_with_browser():
+ """Test that --headed works with other global flags like --browser."""
parser = build_parser()
- args = parser.parse_args(['--headed', '-s', 'mysession', 'open', 'http://example.com'])
+ args = parser.parse_args(['--headed', '-b', 'chromium', 'open', 'http://example.com'])
assert args.headed is True
- assert args.session == 'mysession'
+ assert args.browser == 'chromium'
assert args.url == 'http://example.com'
diff --git a/tests/ci/test_server_locking.py b/tests/ci/test_server_locking.py
deleted file mode 100644
index 63fcdaf31..000000000
--- a/tests/ci/test_server_locking.py
+++ /dev/null
@@ -1,256 +0,0 @@
-"""Tests for server locking to prevent race conditions."""
-
-import os
-import subprocess
-import sys
-import tempfile
-import time
-from pathlib import Path
-
-import portalocker
-import pytest
-
-from browser_use.skill_cli.utils import (
- cleanup_session_files,
- get_lock_path,
- get_pid_path,
- is_server_running,
- is_session_locked,
- kill_orphaned_server,
- try_acquire_server_lock,
-)
-
-
-def test_session():
- """Provide a unique test session name and cleanup after."""
- session = f'test-lock-{os.getpid()}-{time.time_ns()}'
- yield session
- cleanup_session_files(session)
-
-
-def test_lock_path_generation(test_session):
- """Test that lock path is generated correctly."""
- path = get_lock_path(test_session)
- assert path.parent == Path(tempfile.gettempdir())
- assert path.name == f'browser-use-{test_session}.lock'
-
-
-def test_try_acquire_server_lock_success(test_session):
- """Test acquiring lock when no one holds it."""
- lock = try_acquire_server_lock(test_session)
- assert lock is not None
-
- # Should block second acquisition
- lock2 = try_acquire_server_lock(test_session)
- assert lock2 is None
-
- # Release first lock
- portalocker.unlock(lock)
- lock.close()
-
- # Now should succeed
- lock3 = try_acquire_server_lock(test_session)
- assert lock3 is not None
- portalocker.unlock(lock3)
- lock3.close()
-
-
-def test_is_session_locked(test_session):
- """Test detecting if session is locked."""
- # Initially not locked
- assert is_session_locked(test_session) is False
-
- # Acquire lock
- lock = try_acquire_server_lock(test_session)
- assert lock is not None
-
- # Now should be locked
- assert is_session_locked(test_session) is True
-
- # Release
- portalocker.unlock(lock)
- lock.close()
-
- # No longer locked
- assert is_session_locked(test_session) is False
-
-
-def test_kill_orphaned_server_no_pid_file(test_session):
- """Test that kill_orphaned_server returns False when no PID file."""
- assert kill_orphaned_server(test_session) is False
-
-
-def test_kill_orphaned_server_with_lock(test_session):
- """Test that kill_orphaned_server doesn't kill server holding lock."""
- # Create PID file pointing to current process
- pid_path = get_pid_path(test_session)
- pid_path.write_text(str(os.getpid()))
-
- # Acquire lock (simulating a healthy server)
- lock = try_acquire_server_lock(test_session)
- assert lock is not None
-
- # Should not kill - server is healthy (has lock)
- assert kill_orphaned_server(test_session) is False
-
- portalocker.unlock(lock)
- lock.close()
-
-
-def test_cleanup_includes_lock_file(test_session):
- """Test that cleanup removes lock file."""
- lock_path = get_lock_path(test_session)
- pid_path = get_pid_path(test_session)
-
- # Create files
- lock_path.touch()
- pid_path.write_text('12345')
-
- assert lock_path.exists()
- assert pid_path.exists()
-
- cleanup_session_files(test_session)
-
- assert not lock_path.exists()
- assert not pid_path.exists()
-
-
-def test_concurrent_lock_acquisition(test_session):
- """Test that only one process can hold the lock."""
- lock_path = get_lock_path(test_session)
- lock_path.parent.mkdir(parents=True, exist_ok=True)
- lock_path.touch()
-
- # Acquire lock in current process
- lock = try_acquire_server_lock(test_session)
- assert lock is not None
-
- # Try to acquire in subprocess - should fail
- result = subprocess.run(
- [
- sys.executable,
- '-c',
- f'''
-import portalocker
-from pathlib import Path
-
-lock_path = Path("{lock_path}")
-f = open(lock_path, 'r+')
-try:
- portalocker.lock(f, portalocker.LOCK_EX | portalocker.LOCK_NB)
- print("ACQUIRED")
-except portalocker.LockException:
- print("BLOCKED")
-f.close()
-''',
- ],
- capture_output=True,
- text=True,
- timeout=5,
- )
-
- assert 'BLOCKED' in result.stdout
-
- # Release lock
- portalocker.unlock(lock)
- lock.close()
-
- # Now subprocess should succeed
- result = subprocess.run(
- [
- sys.executable,
- '-c',
- f'''
-import portalocker
-from pathlib import Path
-
-lock_path = Path("{lock_path}")
-f = open(lock_path, 'r+')
-try:
- portalocker.lock(f, portalocker.LOCK_EX | portalocker.LOCK_NB)
- print("ACQUIRED")
- portalocker.unlock(f)
-except portalocker.LockException:
- print("BLOCKED")
-f.close()
-''',
- ],
- capture_output=True,
- text=True,
- timeout=5,
- )
-
- assert 'ACQUIRED' in result.stdout
-
-
-def test_lock_released_on_process_death(test_session):
- """Test that lock is automatically released when process dies."""
- lock_path = get_lock_path(test_session)
- lock_path.parent.mkdir(parents=True, exist_ok=True)
- lock_path.touch()
-
- # Start subprocess that holds lock
- proc = subprocess.Popen(
- [
- sys.executable,
- '-c',
- f'''
-import portalocker
-import time
-from pathlib import Path
-
-lock_path = Path("{lock_path}")
-f = open(lock_path, 'r+')
-portalocker.lock(f, portalocker.LOCK_EX | portalocker.LOCK_NB)
-print("LOCKED", flush=True)
-time.sleep(60) # Hold lock
-''',
- ],
- stdout=subprocess.PIPE,
- text=True,
- )
-
- # Wait for lock acquisition
- assert proc.stdout is not None
- line = proc.stdout.readline()
- assert 'LOCKED' in line
-
- # Verify we can't acquire
- lock = try_acquire_server_lock(test_session)
- assert lock is None
-
- # Kill the process
- proc.terminate()
- proc.wait(timeout=5)
-
- # Small delay for OS to release lock
- time.sleep(0.1)
-
- # Now we should be able to acquire
- lock = try_acquire_server_lock(test_session)
- assert lock is not None
- portalocker.unlock(lock)
- lock.close()
-
-
-def test_is_server_running_without_pid(test_session):
- """Test is_server_running returns False when no PID file."""
- assert is_server_running(test_session) is False
-
-
-def test_is_server_running_with_current_pid(test_session):
- """Test is_server_running returns True when PID file points to live process."""
- pid_path = get_pid_path(test_session)
- pid_path.write_text(str(os.getpid()))
-
- assert is_server_running(test_session) is True
-
-
-def test_is_server_running_with_dead_pid(test_session):
- """Test is_server_running returns False when PID file points to dead process."""
- pid_path = get_pid_path(test_session)
- # Use a PID that's very unlikely to exist
- pid_path.write_text('999999999')
-
- assert is_server_running(test_session) is False
diff --git a/tests/ci/test_session_browser_mode.py b/tests/ci/test_session_browser_mode.py
deleted file mode 100644
index 40c72d97a..000000000
--- a/tests/ci/test_session_browser_mode.py
+++ /dev/null
@@ -1,175 +0,0 @@
-"""Tests for session browser mode validation.
-
-When a session is started with a specific browser mode (chromium, remote, real),
-subsequent commands with a different mode should error with helpful guidance.
-"""
-
-import json
-import tempfile
-from pathlib import Path
-
-from browser_use.skill_cli.main import get_session_metadata_path
-
-
-def test_get_session_metadata_path():
- """Test that metadata path is generated correctly."""
- path = get_session_metadata_path('default')
- assert path.parent == Path(tempfile.gettempdir())
- assert path.name == 'browser-use-default.meta'
-
-
-def test_get_session_metadata_path_custom_session():
- """Test metadata path for custom session names."""
- path = get_session_metadata_path('my-session')
- assert path.name == 'browser-use-my-session.meta'
-
-
-def test_metadata_file_format():
- """Test metadata file format matches expected structure."""
- meta_path = get_session_metadata_path('test-format')
- try:
- # Write metadata as the code does
- meta_path.write_text(
- json.dumps(
- {
- 'browser_mode': 'chromium',
- 'headed': False,
- 'profile': None,
- }
- )
- )
-
- # Read and verify
- meta = json.loads(meta_path.read_text())
- assert meta['browser_mode'] == 'chromium'
- assert meta['headed'] is False
- assert meta['profile'] is None
- finally:
- if meta_path.exists():
- meta_path.unlink()
-
-
-def test_metadata_file_remote_mode():
- """Test metadata file with remote browser mode."""
- meta_path = get_session_metadata_path('test-remote')
- try:
- meta_path.write_text(
- json.dumps(
- {
- 'browser_mode': 'remote',
- 'headed': True,
- 'profile': 'cloud-profile-123',
- }
- )
- )
-
- meta = json.loads(meta_path.read_text())
- assert meta['browser_mode'] == 'remote'
- assert meta['headed'] is True
- assert meta['profile'] == 'cloud-profile-123'
- finally:
- if meta_path.exists():
- meta_path.unlink()
-
-
-def test_metadata_cleanup():
- """Test that metadata file can be cleaned up."""
- meta_path = get_session_metadata_path('test-cleanup')
- meta_path.write_text(json.dumps({'browser_mode': 'chromium'}))
- assert meta_path.exists()
-
- # Cleanup
- meta_path.unlink()
- assert not meta_path.exists()
-
-
-def test_mode_mismatch_remote_on_local_should_error():
- """Test that requesting remote on local session triggers error condition.
-
- This is the problematic case: user wants cloud features (live_url) but
- session is running locally. They would silently lose those features.
- """
- meta_path = get_session_metadata_path('test-mismatch-error')
- try:
- # Simulate existing session with chromium (local) mode
- meta_path.write_text(json.dumps({'browser_mode': 'chromium'}))
-
- meta = json.loads(meta_path.read_text())
- existing_mode = meta.get('browser_mode', 'chromium')
- requested_mode = 'remote'
-
- # This combination should trigger an error
- should_error = requested_mode == 'remote' and existing_mode != 'remote'
- assert should_error is True
- finally:
- if meta_path.exists():
- meta_path.unlink()
-
-
-def test_mode_mismatch_local_on_remote_should_allow():
- """Test that requesting local on remote session is allowed.
-
- This case is fine: user gets a remote browser (more features than requested).
- The remote session works just like a local one, just with extra features.
- """
- meta_path = get_session_metadata_path('test-mismatch-allow')
- try:
- # Simulate existing session with remote mode
- meta_path.write_text(json.dumps({'browser_mode': 'remote'}))
-
- meta = json.loads(meta_path.read_text())
- existing_mode = meta.get('browser_mode')
- assert existing_mode == 'remote'
-
- requested_mode = 'chromium' # Default mode when user doesn't specify --browser
-
- # This combination should NOT trigger an error
- # (user requested chromium, but session is remote - that's fine)
- should_error = requested_mode == 'remote' and existing_mode != 'remote'
- assert should_error is False
- finally:
- if meta_path.exists():
- meta_path.unlink()
-
-
-def test_mode_match_detection_logic():
- """Test that matching modes pass validation."""
- meta_path = get_session_metadata_path('test-match')
- try:
- # Simulate existing session with chromium mode
- meta_path.write_text(json.dumps({'browser_mode': 'chromium'}))
-
- # Check match passes
- meta = json.loads(meta_path.read_text())
- existing_mode = meta.get('browser_mode', 'chromium')
- requested_mode = 'chromium'
-
- assert existing_mode == requested_mode
- finally:
- if meta_path.exists():
- meta_path.unlink()
-
-
-def test_different_sessions_independent():
- """Test that different session names are independent."""
- session1_meta = get_session_metadata_path('session-a')
- session2_meta = get_session_metadata_path('session-b')
-
- try:
- # Session A with chromium
- session1_meta.write_text(json.dumps({'browser_mode': 'chromium'}))
-
- # Session B with remote
- session2_meta.write_text(json.dumps({'browser_mode': 'remote'}))
-
- # Verify they are independent
- meta1 = json.loads(session1_meta.read_text())
- meta2 = json.loads(session2_meta.read_text())
-
- assert meta1['browser_mode'] == 'chromium'
- assert meta2['browser_mode'] == 'remote'
- finally:
- if session1_meta.exists():
- session1_meta.unlink()
- if session2_meta.exists():
- session2_meta.unlink()