optexity-browser-use 0.9.5__py3-none-any.whl

browser_use/init_cmd.py

@@ -0,0 +1,376 @@
+"""
+Standalone init command for browser-use template generation.
+
+This module provides a minimal command-line interface for generating
+browser-use templates without requiring heavy TUI dependencies.
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+from urllib import request
+from urllib.error import URLError
+
+import click
+from InquirerPy.base.control import Choice
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.utils import InquirerPyStyle
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+# Rich console for styled output
+console = Console()
+
+# GitHub template repository URL (for runtime fetching)
+TEMPLATE_REPO_URL = 'https://raw.githubusercontent.com/browser-use/template-library/main'
+
+# Export for backward compatibility with cli.py
+# Templates are fetched at runtime via _get_template_list()
+INIT_TEMPLATES: dict[str, Any] = {}
+
+
+def _fetch_template_list() -> dict[str, Any] | None:
+	"""
+	Fetch template list from GitHub templates.json.
+
+	Returns template dict if successful, None if failed.
+	"""
+	try:
+		url = f'{TEMPLATE_REPO_URL}/templates.json'
+		with request.urlopen(url, timeout=5) as response:
+			data = response.read().decode('utf-8')
+			return json.loads(data)
+	except (URLError, TimeoutError, json.JSONDecodeError, Exception):
+		return None
+
+
+def _get_template_list() -> dict[str, Any]:
+	"""
+	Get template list from GitHub.
+
+	Raises FileNotFoundError if GitHub fetch fails.
+	"""
+	templates = _fetch_template_list()
+	if templates is not None:
+		return templates
+	raise FileNotFoundError('Could not fetch templates from GitHub. Check your internet connection.')
+
+
+def _fetch_from_github(file_path: str) -> str | None:
+	"""
+	Fetch template file from GitHub.
+
+	Returns file content if successful, None if failed.
+	"""
+	try:
+		url = f'{TEMPLATE_REPO_URL}/{file_path}'
+		with request.urlopen(url, timeout=5) as response:
+			return response.read().decode('utf-8')
+	except (URLError, TimeoutError, Exception):
+		return None
+
+
+def _fetch_binary_from_github(file_path: str) -> bytes | None:
+	"""
+	Fetch binary file from GitHub.
+
+	Returns file content if successful, None if failed.
+	"""
+	try:
+		url = f'{TEMPLATE_REPO_URL}/{file_path}'
+		with request.urlopen(url, timeout=5) as response:
+			return response.read()
+	except (URLError, TimeoutError, Exception):
+		return None
+
+
+def _get_template_content(file_path: str) -> str:
+	"""
+	Get template file content from GitHub.
+
+	Raises exception if fetch fails.
+	"""
+	content = _fetch_from_github(file_path)
+
+	if content is not None:
+		return content
+
+	raise FileNotFoundError(f'Could not fetch template from GitHub: {file_path}')
+
+
+# InquirerPy style for template selection (browser-use orange theme)
+inquirer_style = InquirerPyStyle(
+	{
+		'pointer': '#fe750e bold',
+		'highlighted': '#fe750e bold',
+		'question': 'bold',
+		'answer': '#fe750e bold',
+		'questionmark': '#fe750e bold',
+	}
+)
+
+
+def _write_init_file(output_path: Path, content: str, force: bool = False) -> bool:
+	"""Write content to a file, with safety checks."""
+	# Check if file already exists
+	if output_path.exists() and not force:
+		console.print(f'[yellow]⚠[/yellow]  File already exists: [cyan]{output_path}[/cyan]')
+		if not click.confirm('Overwrite?', default=False):
+			console.print('[red]✗[/red] Cancelled')
+			return False
+
+	# Ensure parent directory exists
+	output_path.parent.mkdir(parents=True, exist_ok=True)
+
+	# Write file
+	try:
+		output_path.write_text(content, encoding='utf-8')
+		return True
+	except Exception as e:
+		console.print(f'[red]✗[/red] Error writing file: {e}')
+		return False
+
+
+@click.command('browser-use-init')
+@click.option(
+	'--template',
+	'-t',
+	type=str,
+	help='Template to use',
+)
+@click.option(
+	'--output',
+	'-o',
+	type=click.Path(),
+	help='Output file path (default: browser_use_<template>.py)',
+)
+@click.option(
+	'--force',
+	'-f',
+	is_flag=True,
+	help='Overwrite existing files without asking',
+)
+@click.option(
+	'--list',
+	'-l',
+	'list_templates',
+	is_flag=True,
+	help='List available templates',
+)
+def main(
+	template: str | None,
+	output: str | None,
+	force: bool,
+	list_templates: bool,
+):
+	"""
+	Generate a browser-use template file to get started quickly.
+
+	Examples:
+
+	\b
+	# Interactive mode - prompts for template selection
+	uvx browser-use init
+	uvx browser-use init --template
+
+	\b
+	# Generate default template
+	uvx browser-use init --template default
+
+	\b
+	# Generate advanced template with custom filename
+	uvx browser-use init --template advanced --output my_script.py
+
+	\b
+	# List available templates
+	uvx browser-use init --list
+	"""
+
+	# Fetch template list at runtime
+	try:
+		INIT_TEMPLATES = _get_template_list()
+	except FileNotFoundError as e:
+		console.print(f'[red]✗[/red] {e}')
+		sys.exit(1)
+
+	# Handle --list flag
+	if list_templates:
+		console.print('\n[bold]Available templates:[/bold]\n')
+		for name, info in INIT_TEMPLATES.items():
+			console.print(f'  [#fe750e]{name:12}[/#fe750e] - {info["description"]}')
+		console.print()
+		return
+
+	# Interactive template selection if not provided
+	if not template:
+		# Create choices with numbered display
+		template_list = list(INIT_TEMPLATES.keys())
+		choices = [
+			Choice(
+				name=f'{i}. {name:12} - {info["description"]}',
+				value=name,
+			)
+			for i, (name, info) in enumerate(INIT_TEMPLATES.items(), 1)
+		]
+
+		# Create the prompt
+		prompt = ListPrompt(
+			message='Select a template:',
+			choices=choices,
+			default='default',
+			style=inquirer_style,
+		)
+
+		# Register custom keybindings for instant selection with number keys
+		@prompt.register_kb('1')
+		def _(event):
+			event.app.exit(result=template_list[0])
+
+		@prompt.register_kb('2')
+		def _(event):
+			event.app.exit(result=template_list[1])
+
+		@prompt.register_kb('3')
+		def _(event):
+			event.app.exit(result=template_list[2])
+
+		@prompt.register_kb('4')
+		def _(event):
+			event.app.exit(result=template_list[3])
+
+		@prompt.register_kb('5')
+		def _(event):
+			event.app.exit(result=template_list[4])
+
+		template = prompt.execute()
+
+		# Handle user cancellation (Ctrl+C)
+		if template is None:
+			console.print('\n[red]✗[/red] Cancelled')
+			sys.exit(1)
+
+	# Template is guaranteed to be set at this point (either from option or prompt)
+	assert template is not None
+
+	# Create template directory
+	template_dir = Path.cwd() / template
+	if template_dir.exists() and not force:
+		console.print(f'[yellow]⚠[/yellow]  Directory already exists: [cyan]{template_dir}[/cyan]')
+		if not click.confirm('Continue and overwrite files?', default=False):
+			console.print('[red]✗[/red] Cancelled')
+			sys.exit(1)
+
+	# Create directory
+	template_dir.mkdir(parents=True, exist_ok=True)
+
+	# Determine output path
+	if output:
+		output_path = template_dir / Path(output)
+	else:
+		output_path = template_dir / 'main.py'
+
+	# Read template file from GitHub
+	try:
+		template_file = INIT_TEMPLATES[template]['file']
+		content = _get_template_content(template_file)
+	except Exception as e:
+		console.print(f'[red]✗[/red] Error reading template: {e}')
+		sys.exit(1)
+
+	# Write file
+	if _write_init_file(output_path, content, force):
+		console.print(f'\n[green]✓[/green] Created [cyan]{output_path}[/cyan]')
+
+		# Generate additional files if template has a manifest
+		if 'files' in INIT_TEMPLATES[template]:
+			import stat
+
+			for file_spec in INIT_TEMPLATES[template]['files']:
+				source_path = file_spec['source']
+				dest_name = file_spec['dest']
+				dest_path = output_path.parent / dest_name
+				is_binary = file_spec.get('binary', False)
+				is_executable = file_spec.get('executable', False)
+
+				# Skip if we already wrote this file (main.py)
+				if dest_path == output_path:
+					continue
+
+				# Fetch and write file
+				try:
+					if is_binary:
+						file_content = _fetch_binary_from_github(source_path)
+						if file_content:
+							if not dest_path.exists() or force:
+								dest_path.write_bytes(file_content)
+								console.print(f'[green]✓[/green] Created [cyan]{dest_name}[/cyan]')
+						else:
+							console.print(f'[yellow]⚠[/yellow]  Could not fetch [cyan]{dest_name}[/cyan] from GitHub')
+					else:
+						file_content = _get_template_content(source_path)
+						if _write_init_file(dest_path, file_content, force):
+							console.print(f'[green]✓[/green] Created [cyan]{dest_name}[/cyan]')
+							# Make executable if needed
+							if is_executable and sys.platform != 'win32':
+								dest_path.chmod(dest_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+				except Exception as e:
+					console.print(f'[yellow]⚠[/yellow]  Error generating [cyan]{dest_name}[/cyan]: {e}')
+
+		# Create a nice panel for next steps
+		next_steps = Text()
+
+		# Display next steps from manifest if available
+		if 'next_steps' in INIT_TEMPLATES[template]:
+			steps = INIT_TEMPLATES[template]['next_steps']
+			for i, step in enumerate(steps, 1):
+				# Handle footer separately (no numbering)
+				if 'footer' in step:
+					next_steps.append(f'{step["footer"]}\n', style='dim italic')
+					continue
+
+				# Step title
+				next_steps.append(f'\n{i}. {step["title"]}:\n', style='bold')
+
+				# Step commands
+				for cmd in step.get('commands', []):
+					# Replace placeholders
+					cmd = cmd.replace('{template}', template)
+					cmd = cmd.replace('{output}', output_path.name)
+					next_steps.append(f'   {cmd}\n', style='dim')
+
+				# Optional note
+				if 'note' in step:
+					next_steps.append(f'   {step["note"]}\n', style='dim italic')
+
+				next_steps.append('\n')
+		else:
+			# Default workflow for templates without custom next_steps
+			next_steps.append('\n1. Navigate to project directory:\n', style='bold')
+			next_steps.append(f'   cd {template}\n\n', style='dim')
+			next_steps.append('2. Initialize uv project:\n', style='bold')
+			next_steps.append('   uv init\n\n', style='dim')
+			next_steps.append('3. Install browser-use:\n', style='bold')
+			next_steps.append('   uv add browser-use\n\n', style='dim')
+			next_steps.append('4. Set up your API key in .env file or environment:\n', style='bold')
+			next_steps.append('   BROWSER_USE_API_KEY=your-key\n', style='dim')
+			next_steps.append(
+				'   (Get your key at https://cloud.browser-use.com/dashboard/settings?tab=api-keys&new)\n\n',
+				style='dim italic',
+			)
+			next_steps.append('5. Run your script:\n', style='bold')
+			next_steps.append(f'   uv run {output_path.name}\n', style='dim')
+
+		console.print(
+			Panel(
+				next_steps,
+				title='[bold]Next steps[/bold]',
+				border_style='#fe750e',
+				padding=(1, 2),
+			)
+		)
+
+
+if __name__ == '__main__':
+	main()

browser_use/integrations/gmail/__init__.py

@@ -0,0 +1,24 @@
+"""
+Gmail Integration for Browser Use
+Provides Gmail API integration for email reading and verification code extraction.
+This integration enables agents to read email content and extract verification codes themselves.
+Usage:
+    from browser_use.integrations.gmail import GmailService, register_gmail_actions
+    # Option 1: Register Gmail actions with file-based authentication
+    tools = Tools()
+    register_gmail_actions(tools)
+    # Option 2: Register Gmail actions with direct access token (recommended for production)
+    tools = Tools()
+    register_gmail_actions(tools, access_token="your_access_token_here")
+    # Option 3: Use the service directly
+    gmail = GmailService(access_token="your_access_token_here")
+    await gmail.authenticate()
+    emails = await gmail.get_recent_emails()
+"""
+
+# @file purpose: Gmail integration for 2FA email authentication and email reading
+
+from .actions import register_gmail_actions
+from .service import GmailService
+
+__all__ = ['GmailService', 'register_gmail_actions']

browser_use/integrations/gmail/actions.py

@@ -0,0 +1,115 @@
+"""
+Gmail Actions for Browser Use
+Defines agent actions for Gmail integration including 2FA code retrieval,
+email reading, and authentication management.
+"""
+
+import logging
+
+from pydantic import BaseModel, Field
+
+from browser_use.agent.views import ActionResult
+from browser_use.tools.service import Tools
+
+from .service import GmailService
+
+logger = logging.getLogger(__name__)
+
+# Global Gmail service instance - initialized when actions are registered
+_gmail_service: GmailService | None = None
+
+
+class GetRecentEmailsParams(BaseModel):
+	"""Parameters for getting recent emails"""
+
+	keyword: str = Field(default='', description='A single keyword for search, e.g. github, airbnb, etc.')
+	max_results: int = Field(default=3, ge=1, le=50, description='Maximum number of emails to retrieve (1-50, default: 3)')
+
+
+def register_gmail_actions(tools: Tools, gmail_service: GmailService | None = None, access_token: str | None = None) -> Tools:
+	"""
+	Register Gmail actions with the provided tools
+	Args:
+	    tools: The browser-use tools to register actions with
+	    gmail_service: Optional pre-configured Gmail service instance
+	    access_token: Optional direct access token (alternative to file-based auth)
+	"""
+	global _gmail_service
+
+	# Use provided service or create a new one with access token if provided
+	if gmail_service:
+		_gmail_service = gmail_service
+	elif access_token:
+		_gmail_service = GmailService(access_token=access_token)
+	else:
+		_gmail_service = GmailService()
+
+	@tools.registry.action(
+		description='Get recent emails from the mailbox with a keyword to retrieve verification codes, OTP, 2FA tokens, magic links, or any recent email content. Keep your query a single keyword.',
+		param_model=GetRecentEmailsParams,
+	)
+	async def get_recent_emails(params: GetRecentEmailsParams) -> ActionResult:
+		"""Get recent emails from the last 5 minutes with full content"""
+		try:
+			if _gmail_service is None:
+				raise RuntimeError('Gmail service not initialized')
+
+			# Ensure authentication
+			if not _gmail_service.is_authenticated():
+				logger.info('📧 Gmail not authenticated, attempting authentication...')
+				authenticated = await _gmail_service.authenticate()
+				if not authenticated:
+					return ActionResult(
+						extracted_content='Failed to authenticate with Gmail. Please ensure Gmail credentials are set up properly.',
+						long_term_memory='Gmail authentication failed',
+					)
+
+			# Use specified max_results (1-50, default 10), last 5 minutes
+			max_results = params.max_results
+			time_filter = '5m'
+
+			# Build query with time filter and optional user query
+			query_parts = [f'newer_than:{time_filter}']
+			if params.keyword.strip():
+				query_parts.append(params.keyword.strip())
+
+			query = ' '.join(query_parts)
+			logger.info(f'🔍 Gmail search query: {query}')
+
+			# Get emails
+			emails = await _gmail_service.get_recent_emails(max_results=max_results, query=query, time_filter=time_filter)
+
+			if not emails:
+				query_info = f" matching '{params.keyword}'" if params.keyword.strip() else ''
+				memory = f'No recent emails found from last {time_filter}{query_info}'
+				return ActionResult(
+					extracted_content=memory,
+					long_term_memory=memory,
+				)
+
+			# Format with full email content for large display
+			content = f'Found {len(emails)} recent email{"s" if len(emails) > 1 else ""} from the last {time_filter}:\n\n'
+
+			for i, email in enumerate(emails, 1):
+				content += f'Email {i}:\n'
+				content += f'From: {email["from"]}\n'
+				content += f'Subject: {email["subject"]}\n'
+				content += f'Date: {email["date"]}\n'
+				content += f'Content:\n{email["body"]}\n'
+				content += '-' * 50 + '\n\n'
+
+			logger.info(f'📧 Retrieved {len(emails)} recent emails')
+			return ActionResult(
+				extracted_content=content,
+				include_extracted_content_only_once=True,
+				long_term_memory=f'Retrieved {len(emails)} recent emails from last {time_filter} for query {query}.',
+			)
+
+		except Exception as e:
+			logger.error(f'Error getting recent emails: {e}')
+			return ActionResult(
+				error=f'Error getting recent emails: {str(e)}',
+				long_term_memory='Failed to get recent emails due to error',
+			)
+
+	return tools