browser-control-and-automation-cli 0.1.1.dev3__py3-none-any.whl

browser_cli/drivers/playwright_driver.py

@@ -0,0 +1,499 @@
+"""Playwright-backed driver adapter."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from browser_cli.browser.service import BrowserService as PlaywrightBrowserService
+from browser_cli.profiles.discovery import ChromeEnvironment
+from browser_cli.refs.models import LocatorSpec, SnapshotInput
+
+from .base import BrowserDriver
+from .models import DriverHealth, TabState
+
+
+class PlaywrightDriver(BrowserDriver):
+    name = "playwright"
+
+    def __init__(
+        self,
+        chrome_environment: ChromeEnvironment | None = None,
+        *,
+        headless: bool | None = None,
+    ) -> None:
+        self._service = PlaywrightBrowserService(
+            chrome_environment=chrome_environment, headless=headless
+        )
+
+    @property
+    def chrome_environment(self) -> ChromeEnvironment | None:
+        return self._service.chrome_environment
+
+    def configure_environment(self, chrome_environment: ChromeEnvironment) -> None:
+        self._service.configure_environment(chrome_environment)
+
+    @staticmethod
+    def build_search_url(query: str, engine: str = "duckduckgo") -> str:
+        return PlaywrightBrowserService._build_search_url(query, engine)
+
+    async def ensure_started(self) -> None:
+        await self._service.ensure_started()
+
+    async def stop(self) -> dict[str, Any]:
+        return await self._service.stop()
+
+    async def health(self) -> DriverHealth:
+        environment = self.chrome_environment
+        return DriverHealth(
+            name=self.name,
+            available=True,
+            details={
+                "chrome_environment": (environment.source if environment is not None else None),
+                "user_data_dir": str(environment.user_data_dir)
+                if environment is not None
+                else None,
+                "profile_directory": environment.profile_directory
+                if environment is not None
+                else None,
+            },
+        )
+
+    async def new_tab(
+        self,
+        *,
+        page_id: str,
+        url: str | None = None,
+        wait_until: str = "load",
+        timeout_seconds: float | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.new_tab(
+            page_id=page_id,
+            url=url,
+            wait_until=wait_until,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def close_tab(self, page_id: str) -> dict[str, Any]:
+        return await self._service.close_tab(page_id)
+
+    async def list_tabs(self) -> list[TabState]:
+        results: list[TabState] = []
+        for page_id in sorted(self._service._pages.keys()):  # noqa: SLF001
+            summary = await self._service.get_page_summary(page_id)
+            results.append(
+                TabState(
+                    page_id=page_id,
+                    url=str(summary["url"]),
+                    title=str(summary["title"]),
+                    active=False,
+                )
+            )
+        return results
+
+    async def switch_tab(self, page_id: str) -> dict[str, Any]:
+        page = self._service._require_page(page_id)  # noqa: SLF001
+        await page.bring_to_front()
+        return await self._service.get_page_summary(page_id)
+
+    async def get_page_summary(self, page_id: str) -> dict[str, Any]:
+        return await self._service.get_page_summary(page_id)
+
+    async def get_page_info(self, page_id: str) -> dict[str, Any]:
+        return await self._service.get_page_info(page_id)
+
+    async def capture_html(self, page_id: str) -> dict[str, Any]:
+        return await self._service.capture_html(page_id)
+
+    async def capture_snapshot_input(
+        self,
+        page_id: str,
+        *,
+        interactive: bool = False,
+        full_page: bool = True,
+    ) -> SnapshotInput:
+        return await self._service.capture_snapshot_input(
+            page_id,
+            interactive=interactive,
+            full_page=full_page,
+        )
+
+    async def navigate(
+        self,
+        page_id: str,
+        url: str,
+        *,
+        wait_until: str = "load",
+        timeout_seconds: float = 30.0,
+    ) -> dict[str, Any]:
+        return await self._service.navigate(
+            page_id,
+            url,
+            wait_until=wait_until,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def reload(
+        self,
+        page_id: str,
+        *,
+        wait_until: str = "load",
+        timeout_seconds: float = 30.0,
+    ) -> dict[str, Any]:
+        return await self._service.reload(
+            page_id, wait_until=wait_until, timeout_seconds=timeout_seconds
+        )
+
+    async def go_back(self, page_id: str) -> dict[str, Any]:
+        return await self._service.go_back(page_id)
+
+    async def go_forward(self, page_id: str) -> dict[str, Any]:
+        return await self._service.go_forward(page_id)
+
+    async def resize(self, page_id: str, *, width: int, height: int) -> dict[str, Any]:
+        return await self._service.resize(page_id, width=width, height=height)
+
+    async def click(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.click_locator(page_id, locator)
+
+    async def double_click(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.double_click_locator(page_id, locator)
+
+    async def hover(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.hover_locator(page_id, locator)
+
+    async def focus(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.focus_locator(page_id, locator)
+
+    async def fill(
+        self,
+        page_id: str,
+        locator: LocatorSpec,
+        text: str,
+        *,
+        submit: bool = False,
+    ) -> dict[str, Any]:
+        return await self._service.fill_locator(page_id, locator, text, submit=submit)
+
+    async def select_option(self, page_id: str, locator: LocatorSpec, text: str) -> dict[str, Any]:
+        return await self._service.select_locator(page_id, locator, text)
+
+    async def list_options(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.list_locator_options(page_id, locator)
+
+    async def check(self, page_id: str, locator: LocatorSpec, *, checked: bool) -> dict[str, Any]:
+        return await self._service.set_checked_locator(page_id, locator, checked=checked)
+
+    async def scroll_to(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        return await self._service.scroll_to_locator(page_id, locator)
+
+    async def drag(
+        self, page_id: str, start_locator: LocatorSpec, end_locator: LocatorSpec
+    ) -> dict[str, Any]:
+        return await self._service.drag_between_locators(page_id, start_locator, end_locator)
+
+    async def upload(self, page_id: str, locator: LocatorSpec, file_path: str) -> dict[str, Any]:
+        return await self._service.upload_to_locator(page_id, locator, file_path)
+
+    async def evaluate(self, page_id: str, code: str) -> dict[str, Any]:
+        return await self._service.evaluate(page_id, code)
+
+    async def evaluate_on(self, page_id: str, locator: LocatorSpec, code: str) -> dict[str, Any]:
+        return await self._service.evaluate_on_locator(page_id, locator, code)
+
+    async def wait(
+        self,
+        page_id: str,
+        *,
+        seconds: float | None = None,
+        text: str | None = None,
+        gone: bool = False,
+        exact: bool = False,
+    ) -> dict[str, Any]:
+        return await self._service.wait(
+            page_id,
+            seconds=seconds,
+            text=text,
+            gone=gone,
+            exact=exact,
+        )
+
+    async def wait_for_network_idle(
+        self, page_id: str, *, timeout_seconds: float = 30.0
+    ) -> dict[str, Any]:
+        return await self._service.wait_for_network_idle(page_id, timeout_seconds=timeout_seconds)
+
+    async def start_console_capture(self, page_id: str) -> dict[str, Any]:
+        return await self._service.start_console_capture(page_id)
+
+    async def get_console_messages(
+        self,
+        page_id: str,
+        *,
+        message_type: str | None = None,
+        clear: bool = True,
+    ) -> dict[str, Any]:
+        return await self._service.get_console_messages(
+            page_id, message_type=message_type, clear=clear
+        )
+
+    async def stop_console_capture(self, page_id: str) -> dict[str, Any]:
+        return await self._service.stop_console_capture(page_id)
+
+    async def start_network_capture(self, page_id: str) -> dict[str, Any]:
+        return await self._service.start_network_capture(page_id)
+
+    async def wait_for_network_record(
+        self,
+        page_id: str,
+        *,
+        url_contains: str | None = None,
+        url_regex: str | None = None,
+        method: str | None = None,
+        status: int | None = None,
+        resource_type: str | None = None,
+        mime_contains: str | None = None,
+        include_static: bool = False,
+        timeout_seconds: float = 30.0,
+    ) -> dict[str, Any]:
+        return await self._service.wait_for_network_record(
+            page_id,
+            url_contains=url_contains,
+            url_regex=url_regex,
+            method=method,
+            status=status,
+            resource_type=resource_type,
+            mime_contains=mime_contains,
+            include_static=include_static,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def get_network_records(
+        self,
+        page_id: str,
+        *,
+        url_contains: str | None = None,
+        url_regex: str | None = None,
+        method: str | None = None,
+        status: int | None = None,
+        resource_type: str | None = None,
+        mime_contains: str | None = None,
+        include_static: bool = False,
+        clear: bool = True,
+    ) -> dict[str, Any]:
+        return await self._service.get_network_records(
+            page_id,
+            url_contains=url_contains,
+            url_regex=url_regex,
+            method=method,
+            status=status,
+            resource_type=resource_type,
+            mime_contains=mime_contains,
+            include_static=include_static,
+            clear=clear,
+        )
+
+    async def stop_network_capture(self, page_id: str) -> dict[str, Any]:
+        return await self._service.stop_network_capture(page_id)
+
+    async def get_cookies(
+        self,
+        page_id: str,
+        *,
+        name: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.get_cookies(page_id, name=name, domain=domain, path=path)
+
+    async def set_cookie(
+        self,
+        page_id: str,
+        *,
+        name: str,
+        value: str,
+        domain: str | None = None,
+        path: str = "/",
+        expires: float | None = None,
+        http_only: bool = False,
+        secure: bool = False,
+        same_site: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.set_cookie(
+            page_id,
+            name=name,
+            value=value,
+            domain=domain,
+            path=path,
+            expires=expires,
+            http_only=http_only,
+            secure=secure,
+            same_site=same_site,
+        )
+
+    async def clear_cookies(
+        self,
+        page_id: str,
+        *,
+        name: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.clear_cookies(page_id, name=name, domain=domain, path=path)
+
+    async def save_storage_state(self, page_id: str, *, path: str | None = None) -> dict[str, Any]:
+        return await self._service.save_storage_state(page_id, path=path)
+
+    async def load_storage_state(self, page_id: str, *, path: str) -> dict[str, Any]:
+        return await self._service.load_storage_state(page_id, path=path)
+
+    async def verify_text(
+        self,
+        page_id: str,
+        *,
+        text: str,
+        exact: bool = False,
+        timeout_seconds: float = 5.0,
+    ) -> dict[str, Any]:
+        return await self._service.verify_text(
+            page_id,
+            text=text,
+            exact=exact,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def verify_url(
+        self, page_id: str, *, expected: str, exact: bool = False
+    ) -> dict[str, Any]:
+        return await self._service.verify_url(page_id, expected=expected, exact=exact)
+
+    async def verify_title(
+        self, page_id: str, *, expected: str, exact: bool = False
+    ) -> dict[str, Any]:
+        return await self._service.verify_title(page_id, expected=expected, exact=exact)
+
+    async def verify_visible(
+        self,
+        page_id: str,
+        *,
+        role: str,
+        name: str,
+        timeout_seconds: float = 5.0,
+    ) -> dict[str, Any]:
+        return await self._service.verify_visible(
+            page_id,
+            role=role,
+            name=name,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def verify_state(
+        self, page_id: str, *, locator: LocatorSpec, state: str
+    ) -> dict[str, Any]:
+        return await self._service.verify_state_locator(page_id, locator, state=state)
+
+    async def verify_value(
+        self, page_id: str, *, locator: LocatorSpec, expected: str
+    ) -> dict[str, Any]:
+        return await self._service.verify_value_locator(page_id, locator, expected=expected)
+
+    async def type_text(self, page_id: str, text: str, *, submit: bool = False) -> dict[str, Any]:
+        return await self._service.type_text(page_id, text, submit=submit)
+
+    async def press_key(self, page_id: str, key: str) -> dict[str, Any]:
+        return await self._service.press_key(page_id, key)
+
+    async def key_down(self, page_id: str, key: str) -> dict[str, Any]:
+        return await self._service.key_down(page_id, key)
+
+    async def key_up(self, page_id: str, key: str) -> dict[str, Any]:
+        return await self._service.key_up(page_id, key)
+
+    async def wheel(self, page_id: str, *, dx: int = 0, dy: int = 700) -> dict[str, Any]:
+        return await self._service.wheel(page_id, dx=dx, dy=dy)
+
+    async def mouse_move(self, page_id: str, *, x: int, y: int) -> dict[str, Any]:
+        return await self._service.mouse_move(page_id, x=x, y=y)
+
+    async def mouse_click(
+        self,
+        page_id: str,
+        *,
+        x: int,
+        y: int,
+        button: str = "left",
+        count: int = 1,
+    ) -> dict[str, Any]:
+        return await self._service.mouse_click(page_id, x=x, y=y, button=button, count=count)
+
+    async def mouse_drag(
+        self, page_id: str, *, x1: int, y1: int, x2: int, y2: int
+    ) -> dict[str, Any]:
+        return await self._service.mouse_drag(page_id, x1=x1, y1=y1, x2=x2, y2=y2)
+
+    async def mouse_down(self, page_id: str, *, button: str = "left") -> dict[str, Any]:
+        return await self._service.mouse_down(page_id, button=button)
+
+    async def mouse_up(self, page_id: str, *, button: str = "left") -> dict[str, Any]:
+        return await self._service.mouse_up(page_id, button=button)
+
+    async def screenshot(
+        self, page_id: str, *, path: str, full_page: bool = False
+    ) -> dict[str, Any]:
+        return await self._service.screenshot(page_id, path=path, full_page=full_page)
+
+    async def save_pdf(self, page_id: str, *, path: str) -> dict[str, Any]:
+        return await self._service.save_pdf(page_id, path=path)
+
+    async def setup_dialog_handler(
+        self,
+        page_id: str,
+        *,
+        default_action: str = "accept",
+        default_prompt_text: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.setup_dialog_handler(
+            page_id,
+            default_action=default_action,
+            default_prompt_text=default_prompt_text,
+        )
+
+    async def handle_dialog(
+        self,
+        page_id: str,
+        *,
+        accept: bool,
+        prompt_text: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._service.handle_dialog(page_id, accept=accept, prompt_text=prompt_text)
+
+    async def remove_dialog_handler(self, page_id: str) -> dict[str, Any]:
+        return await self._service.remove_dialog_handler(page_id)
+
+    async def start_tracing(
+        self,
+        page_id: str,
+        *,
+        screenshots: bool = True,
+        snapshots: bool = True,
+        sources: bool = False,
+    ) -> dict[str, Any]:
+        return await self._service.start_tracing(
+            page_id,
+            screenshots=screenshots,
+            snapshots=snapshots,
+            sources=sources,
+        )
+
+    async def add_trace_chunk(self, page_id: str, *, title: str | None = None) -> dict[str, Any]:
+        return await self._service.add_trace_chunk(page_id, title=title)
+
+    async def stop_tracing(self, page_id: str, *, path: str | None = None) -> dict[str, Any]:
+        return await self._service.stop_tracing(page_id, path=path)
+
+    async def start_video(
+        self, page_id: str, *, width: int | None = None, height: int | None = None
+    ) -> dict[str, Any]:
+        return await self._service.start_video(page_id, width=width, height=height)
+
+    async def stop_video(self, page_id: str, *, path: str | None = None) -> dict[str, Any]:
+        return await self._service.stop_video(page_id, path=path)

browser_cli/error_codes.py

@@ -0,0 +1,27 @@
+"""Stable machine-readable error codes."""
+
+DAEMON_NOT_AVAILABLE = "DAEMON_NOT_AVAILABLE"
+NO_ACTIVE_TAB = "NO_ACTIVE_TAB"
+NO_VISIBLE_TABS = "NO_VISIBLE_TABS"
+AGENT_ACTIVE_TAB_BUSY = "AGENT_ACTIVE_TAB_BUSY"
+TAB_NOT_FOUND = "TAB_NOT_FOUND"
+REF_NOT_FOUND = "REF_NOT_FOUND"
+STALE_SNAPSHOT = "STALE_SNAPSHOT"
+NO_SNAPSHOT_CONTEXT = "NO_SNAPSHOT_CONTEXT"
+AMBIGUOUS_REF = "AMBIGUOUS_REF"
+INVALID_INPUT = "INVALID_INPUT"
+OPERATION_FAILED = "OPERATION_FAILED"
+INTERNAL_ERROR = "INTERNAL_ERROR"
+BROWSER_UNAVAILABLE = "BROWSER_UNAVAILABLE"
+PROFILE_UNAVAILABLE = "PROFILE_UNAVAILABLE"
+TEMPORARY_FAILURE = "TEMPORARY_FAILURE"
+EMPTY_CONTENT = "EMPTY_CONTENT"
+DRIVER_UNSUPPORTED = "DRIVER_UNSUPPORTED"
+EXTENSION_UNAVAILABLE = "EXTENSION_UNAVAILABLE"
+EXTENSION_CAPABILITY_INCOMPLETE = "EXTENSION_CAPABILITY_INCOMPLETE"
+EXTENSION_REQUEST_FAILED = "EXTENSION_REQUEST_FAILED"
+EXTENSION_DISCONNECTED = "EXTENSION_DISCONNECTED"
+AUTOMATION_SERVICE_NOT_AVAILABLE = "AUTOMATION_SERVICE_NOT_AVAILABLE"
+AUTOMATION_INVALID = "AUTOMATION_INVALID"
+AUTOMATION_RUN_FAILED = "AUTOMATION_RUN_FAILED"
+AUTOMATION_RUN_TIMEOUT = "AUTOMATION_RUN_TIMEOUT"

browser_cli/errors.py

@@ -0,0 +1,146 @@
+"""Project-level error types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import error_codes, exit_codes
+
+
+@dataclass(slots=True)
+class BrowserCliError(Exception):
+    """Base typed error surfaced to the CLI."""
+
+    message: str
+    exit_code: int = exit_codes.INTERNAL_ERROR
+    error_code: str = error_codes.INTERNAL_ERROR
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class BrowserUnavailableError(BrowserCliError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, exit_codes.BROWSER_UNAVAILABLE, error_codes.BROWSER_UNAVAILABLE)
+
+
+class ProfileUnavailableError(BrowserCliError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, exit_codes.PROFILE_UNAVAILABLE, error_codes.PROFILE_UNAVAILABLE)
+
+
+class TemporaryReadError(BrowserCliError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.TEMPORARY_FAILURE)
+
+
+class EmptyContentError(BrowserCliError):
+    def __init__(self, message: str = "Read completed but produced no content.") -> None:
+        super().__init__(message, exit_codes.EMPTY_CONTENT, error_codes.EMPTY_CONTENT)
+
+
+class InvalidInputError(BrowserCliError):
+    def __init__(self, message: str, *, error_code: str = error_codes.INVALID_INPUT) -> None:
+        super().__init__(message, exit_codes.USAGE_ERROR, error_code)
+
+
+class DaemonNotAvailableError(BrowserCliError):
+    def __init__(self, message: str = "Browser daemon is not available.") -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.DAEMON_NOT_AVAILABLE)
+
+
+class NoActiveTabError(BrowserCliError):
+    def __init__(self, message: str = "No active tab is available for this agent.") -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.NO_ACTIVE_TAB)
+
+
+class NoVisibleTabsError(BrowserCliError):
+    def __init__(self, message: str = "No visible tabs are available for this agent.") -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.NO_VISIBLE_TABS)
+
+
+class BusyTabError(BrowserCliError):
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(
+            message
+            or "The current active tab is already being operated on. Create a new tab or retry after the other command finishes.",
+            exit_codes.TEMPORARY_FAILURE,
+            error_codes.AGENT_ACTIVE_TAB_BUSY,
+        )
+
+
+class TabNotFoundError(BrowserCliError):
+    def __init__(
+        self, message: str = "The requested tab is not visible or does not exist."
+    ) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.TAB_NOT_FOUND)
+
+
+class RefNotFoundError(BrowserCliError):
+    def __init__(
+        self, message: str = "The requested ref is not known in the latest snapshot."
+    ) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.REF_NOT_FOUND)
+
+
+class NoSnapshotContextError(BrowserCliError):
+    def __init__(
+        self,
+        message: str = "No snapshot context is available for the active tab. Capture a snapshot first.",
+    ) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.NO_SNAPSHOT_CONTEXT)
+
+
+class StaleSnapshotError(BrowserCliError):
+    def __init__(
+        self, message: str = "The requested ref is stale. Capture a new snapshot and retry."
+    ) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.STALE_SNAPSHOT)
+
+
+class AmbiguousRefError(BrowserCliError):
+    def __init__(
+        self,
+        message: str = "The requested ref resolved to multiple elements. Capture a new snapshot and retry.",
+    ) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_codes.AMBIGUOUS_REF)
+
+
+class OperationFailedError(BrowserCliError):
+    def __init__(self, message: str, *, error_code: str = error_codes.OPERATION_FAILED) -> None:
+        super().__init__(message, exit_codes.TEMPORARY_FAILURE, error_code)
+
+
+class AutomationServiceNotAvailableError(BrowserCliError):
+    def __init__(self, message: str = "Automation service is not available.") -> None:
+        super().__init__(
+            message,
+            exit_codes.TEMPORARY_FAILURE,
+            error_codes.AUTOMATION_SERVICE_NOT_AVAILABLE,
+        )
+
+
+class AutomationServiceError(BrowserCliError):
+    def __init__(self, payload: dict[str, object]) -> None:
+        error_code = str(payload.get("error_code") or error_codes.INTERNAL_ERROR)
+        exit_code = (
+            exit_codes.USAGE_ERROR
+            if error_code in {error_codes.INVALID_INPUT, error_codes.AUTOMATION_INVALID}
+            else exit_codes.TEMPORARY_FAILURE
+        )
+        super().__init__(
+            str(payload.get("error_message") or "Automation service request failed."),
+            exit_code,
+            error_code,
+        )
+        self.payload = payload
+
+
+class AutomationInvalidError(BrowserCliError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, exit_codes.USAGE_ERROR, error_codes.AUTOMATION_INVALID)
+
+
+class AutomationRunTimeoutError(OperationFailedError):
+    def __init__(self, message: str = "Automation run timed out.") -> None:
+        super().__init__(message, error_code=error_codes.AUTOMATION_RUN_TIMEOUT)

browser_cli/exit_codes.py

@@ -0,0 +1,9 @@
+"""Stable CLI exit codes."""
+
+SUCCESS = 0
+INTERNAL_ERROR = 1
+USAGE_ERROR = 2
+EMPTY_CONTENT = 66
+BROWSER_UNAVAILABLE = 69
+PROFILE_UNAVAILABLE = 73
+TEMPORARY_FAILURE = 75