cdpwave 0.1.0__tar.gz

cdpwave-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,42 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: mypy cdpwave/
+
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: pytest tests/unit/ -v --cov=cdpwave --cov-report=term-missing
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - uses: browser-actions/setup-chrome@v1
+        with:
+          chrome-version: stable
+      - run: pip install -e ".[dev]"
+      - run: pytest tests/integration/ -m integration -v

cdpwave-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,33 @@
+name: Docs
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[docs]"
+      - run: mkdocs build --strict
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+      - id: deployment
+        uses: actions/deploy-pages@v4

cdpwave-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,64 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  id-token: write
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: mypy cdpwave/
+      - run: pytest tests/unit/ -c pyproject.toml
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/download-artifact@v5
+        with:
+          name: dist
+          path: dist/
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if gh release view "${{ github.ref_name }}" >/dev/null 2>&1; then
+            echo "Release ${{ github.ref_name }} already exists, uploading assets"
+            gh release upload "${{ github.ref_name }}" dist/* --clobber
+          else
+            gh release create "${{ github.ref_name }}" \
+              --title "${{ github.ref_name }}" \
+              --generate-notes \
+              dist/*
+          fi

cdpwave-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,30 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  unit-tests:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: mypy cdpwave/
+      - run: pytest tests/unit/ --cov=cdpwave --cov-report=xml --cov-fail-under=80
+      - uses: codecov/codecov-action@v4
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
+        with:
+          files: ./coverage.xml
+          token: ${{ secrets.CODECOV_TOKEN }}

cdpwave-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+env/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+*.so
+.idea/
+.vscode/
+*.swp
+*.swo
+site/
+CONTEXT.md
+spike.py

cdpwave-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mathias Paulenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cdpwave-0.1.0/Makefile

@@ -0,0 +1,27 @@
+.PHONY: install lint typecheck test test-unit test-integration clean build docs
+
+install:
+	pip install -e ".[dev]"
+
+lint:
+	ruff check .
+
+typecheck:
+	mypy cdpwave/
+
+test: test-unit test-integration
+
+test-unit:
+	pytest tests/unit/ -v --cov=cdpwave --cov-report=term-missing
+
+test-integration:
+	pytest tests/integration/ -m integration -v
+
+clean:
+	rm -rf build/ dist/ *.egg-info .pytest_cache .mypy_cache .ruff_cache htmlcov coverage.xml
+
+build:
+	python -m build
+
+docs:
+	mkdocs serve

cdpwave-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: cdpwave
+Version: 0.1.0
+Summary: Chrome DevTools Protocol for Python — direct CDP over WebSocket, no Selenium, no Playwright
+Project-URL: Homepage, https://github.com/MathiasPaulenko/cdpwave
+Project-URL: Repository, https://github.com/MathiasPaulenko/cdpwave
+Project-URL: Issues, https://github.com/MathiasPaulenko/cdpwave/issues
+Author-email: Mathias Paulenko <mathias.paulenko@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: async,automation,browser,cdp,chrome,chromium,devtools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.5
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# cdpwave
+
+[![CI](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/ci.yml/badge.svg)](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/ci.yml)
+[![Tests](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/test.yml/badge.svg)](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/cdpwave.svg)](https://pypi.org/project/cdpwave/)
+[![Python](https://img.shields.io/pypi/pyversions/cdpwave.svg)](https://pypi.org/project/cdpwave/)
+[![License: MIT](https://img.shields.io/badge-License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Chrome DevTools Protocol for Python — direct, typed, async.
+
+cdpwave talks to Chrome over a raw WebSocket. No Node.js, no ChromeDriver, no browser downloads. Just pure Python with full type hints and async-first design.
+
+## Why cdpwave?
+
+- **Direct WebSocket** — single connection to Chrome's DevTools Protocol, no intermediate layers
+- **Fully typed** — `mypy --strict` across the entire codebase, IDE autocomplete everywhere
+- **Async-first** — built on `asyncio`, no threading, no blocking calls
+- **Browser detection** — finds Chrome, Edge, Brave, or Chromium already on your system
+- **Flatten sessions** — one WebSocket for all tabs via `Target.attachToTarget` + `sessionId`
+- **Escape hatch** — `session.send("Any.CDPMethod", params)` for uncovered domains
+- **HTTP discovery** — typed access to `/json/version` and `/json/list` endpoints
+- **MIT licensed** — permissive, compatible with any use
+
+## Install
+
+```bash
+pip install cdpwave
+```
+
+## Quick start
+
+```python
+import asyncio
+from cdpwave import CDPClient
+
+async def main() -> None:
+    async with await CDPClient.launch(headless=True) as client:
+        page = await client.new_page("https://example.com")
+        result = await page.runtime.evaluate("document.title", return_by_value=True)
+        print(result["result"]["value"])  # "Example Domain"
+        await page.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+Full documentation at [mathiaspaulenko.github.io/cdpwave](https://mathiaspaulenko.github.io/cdpwave/).
+
+- [Quickstart](https://mathiaspaulenko.github.io/cdpwave/quickstart/) — 10-minute tutorial
+- [Guide](https://mathiaspaulenko.github.io/cdpwave/guide/installation/) — in-depth feature coverage
+- [Cookbook](https://mathiaspaulenko.github.io/cdpwave/cookbook/connect-existing/) — common recipes
+- [API Reference](https://mathiaspaulenko.github.io/cdpwave/api/client/) — auto-generated docs
+- [Migration](https://mathiaspaulenko.github.io/cdpwave/migration/pyppeteer/) — from pyppeteer or pychrome
+
+## License
+
+MIT

cdpwave-0.1.0/README.md

@@ -0,0 +1,58 @@
+# cdpwave
+
+[![CI](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/ci.yml/badge.svg)](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/ci.yml)
+[![Tests](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/test.yml/badge.svg)](https://github.com/MathiasPaulenko/cdpwave/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/cdpwave.svg)](https://pypi.org/project/cdpwave/)
+[![Python](https://img.shields.io/pypi/pyversions/cdpwave.svg)](https://pypi.org/project/cdpwave/)
+[![License: MIT](https://img.shields.io/badge-License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Chrome DevTools Protocol for Python — direct, typed, async.
+
+cdpwave talks to Chrome over a raw WebSocket. No Node.js, no ChromeDriver, no browser downloads. Just pure Python with full type hints and async-first design.
+
+## Why cdpwave?
+
+- **Direct WebSocket** — single connection to Chrome's DevTools Protocol, no intermediate layers
+- **Fully typed** — `mypy --strict` across the entire codebase, IDE autocomplete everywhere
+- **Async-first** — built on `asyncio`, no threading, no blocking calls
+- **Browser detection** — finds Chrome, Edge, Brave, or Chromium already on your system
+- **Flatten sessions** — one WebSocket for all tabs via `Target.attachToTarget` + `sessionId`
+- **Escape hatch** — `session.send("Any.CDPMethod", params)` for uncovered domains
+- **HTTP discovery** — typed access to `/json/version` and `/json/list` endpoints
+- **MIT licensed** — permissive, compatible with any use
+
+## Install
+
+```bash
+pip install cdpwave
+```
+
+## Quick start
+
+```python
+import asyncio
+from cdpwave import CDPClient
+
+async def main() -> None:
+    async with await CDPClient.launch(headless=True) as client:
+        page = await client.new_page("https://example.com")
+        result = await page.runtime.evaluate("document.title", return_by_value=True)
+        print(result["result"]["value"])  # "Example Domain"
+        await page.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+Full documentation at [mathiaspaulenko.github.io/cdpwave](https://mathiaspaulenko.github.io/cdpwave/).
+
+- [Quickstart](https://mathiaspaulenko.github.io/cdpwave/quickstart/) — 10-minute tutorial
+- [Guide](https://mathiaspaulenko.github.io/cdpwave/guide/installation/) — in-depth feature coverage
+- [Cookbook](https://mathiaspaulenko.github.io/cdpwave/cookbook/connect-existing/) — common recipes
+- [API Reference](https://mathiaspaulenko.github.io/cdpwave/api/client/) — auto-generated docs
+- [Migration](https://mathiaspaulenko.github.io/cdpwave/migration/pyppeteer/) — from pyppeteer or pychrome
+
+## License
+
+MIT

cdpwave-0.1.0/cdpwave/__init__.py

@@ -0,0 +1,34 @@
+__version__ = "0.1.0"
+
+from cdpwave.client import CDPClient, CDPSession
+from cdpwave.events.dispatcher import EventDispatcher
+from cdpwave.events.handlers import EventHandler, Subscription
+from cdpwave.exceptions import (
+    BrowserNotFoundError,
+    CDPError,
+    CommandError,
+    CommandTimeoutError,
+    ConnectionClosedError,
+    DiscoveryError,
+    LaunchError,
+    LaunchTimeoutError,
+    SessionClosedError,
+)
+
+__all__ = [
+    "CDPClient",
+    "CDPSession",
+    "CDPError",
+    "ConnectionClosedError",
+    "CommandError",
+    "CommandTimeoutError",
+    "BrowserNotFoundError",
+    "SessionClosedError",
+    "DiscoveryError",
+    "EventDispatcher",
+    "Subscription",
+    "EventHandler",
+    "LaunchError",
+    "LaunchTimeoutError",
+    "__version__",
+]

cdpwave-0.1.0/cdpwave/browser/discovery.py

@@ -0,0 +1,86 @@
+import asyncio
+import json
+import urllib.request
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class TargetInfo:
+    target_id: str
+    type: str
+    title: str
+    url: str
+    web_socket_debugger_url: str | None
+
+
+@dataclass(frozen=True)
+class VersionInfo:
+    browser: str
+    protocol_version: str
+    user_agent: str
+    web_socket_debugger_url: str
+
+
+def _http_get(url: str) -> Any:
+    with urllib.request.urlopen(url, timeout=10) as resp:
+        data = json.loads(resp.read().decode("utf-8"))
+        return data
+
+
+def _http_put(url: str) -> Any:
+    req = urllib.request.Request(url, method="PUT")
+    with urllib.request.urlopen(req, timeout=10) as resp:
+        data = json.loads(resp.read().decode("utf-8"))
+        return data
+
+
+class TargetDiscovery:
+    def __init__(self, host: str = "localhost", port: int = 9222) -> None:
+        self._base_url = f"http://{host}:{port}"
+
+    async def get_version(self) -> VersionInfo:
+        data: dict[str, Any] = await asyncio.to_thread(
+            _http_get, f"{self._base_url}/json/version"
+        )
+        return VersionInfo(
+            browser=str(data.get("Browser", "")),
+            protocol_version=str(data.get("Protocol-Version", "")),
+            user_agent=str(data.get("User-Agent", "")),
+            web_socket_debugger_url=str(data.get("webSocketDebuggerUrl", "")),
+        )
+
+    async def list_targets(self) -> list[TargetInfo]:
+        data: list[dict[str, Any]] = await asyncio.to_thread(
+            _http_get, f"{self._base_url}/json/list"
+        )
+        targets: list[TargetInfo] = []
+        for item in data:
+            targets.append(
+                TargetInfo(
+                    target_id=str(item.get("id", "")),
+                    type=str(item.get("type", "")),
+                    title=str(item.get("title", "")),
+                    url=str(item.get("url", "")),
+                    web_socket_debugger_url=item.get("webSocketDebuggerUrl"),
+                )
+            )
+        return targets
+
+    async def new_tab(self, url: str = "about:blank") -> TargetInfo:
+        data: dict[str, Any] = await asyncio.to_thread(
+            _http_put, f"{self._base_url}/json/new?{url}"
+        )
+        return TargetInfo(
+            target_id=str(data.get("id", "")),
+            type=str(data.get("type", "")),
+            title=str(data.get("title", "")),
+            url=str(data.get("url", "")),
+            web_socket_debugger_url=data.get("webSocketDebuggerUrl"),
+        )
+
+    async def activate_tab(self, target_id: str) -> None:
+        await asyncio.to_thread(_http_get, f"{self._base_url}/json/activate/{target_id}")
+
+    async def close_tab(self, target_id: str) -> None:
+        await asyncio.to_thread(_http_get, f"{self._base_url}/json/close/{target_id}")

cdpwave-0.1.0/cdpwave/browser/finder.py

@@ -0,0 +1,130 @@
+import os
+import shutil
+import sys
+
+from cdpwave.exceptions import BrowserNotFoundError
+from cdpwave.types import BrowserType
+
+_WIN_CHROME_PATHS = [
+    r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+    r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+]
+
+_WIN_EDGE_PATHS = [
+    r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
+    r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
+]
+
+_WIN_BRAVE_PATHS = [
+    os.path.expandvars(r"%LOCALAPPDATA%\BraveSoftware\Brave-Browser\Application\brave.exe"),
+    r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe",
+    r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe",
+]
+
+_WIN_CHROMIUM_PATHS = [
+    r"C:\Program Files\Chromium\Application\chromium.exe",
+    r"C:\Program Files (x86)\Chromium\Application\chromium.exe",
+]
+
+_MAC_CHROME_PATH = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+_MAC_EDGE_PATH = "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+_MAC_BRAVE_PATH = "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+_MAC_CHROMIUM_PATH = "/Applications/Chromium.app/Contents/MacOS/Chromium"
+
+_LINUX_NAMES: dict[str, list[str]] = {
+    "chrome": ["google-chrome", "google-chrome-stable", "chrome"],
+    "edge": ["microsoft-edge", "microsoft-edge-stable"],
+    "brave": ["brave-browser", "brave"],
+    "chromium": ["chromium", "chromium-browser"],
+}
+
+
+def _check_paths(paths: list[str]) -> str | None:
+    for path in paths:
+        if os.path.isfile(path):
+            return path
+    return None
+
+
+def _find_on_linux(names: list[str]) -> str | None:
+    for name in names:
+        path = shutil.which(name)
+        if path:
+            return path
+    return None
+
+
+def find_chrome() -> str | None:
+    env_path = os.environ.get("CDPWAVE_CHROME_PATH")
+    if env_path and os.path.isfile(env_path):
+        return env_path
+    if sys.platform == "win32":
+        return _check_paths(_WIN_CHROME_PATHS)
+    if sys.platform == "darwin":
+        return _check_paths([_MAC_CHROME_PATH])
+    return _find_on_linux(_LINUX_NAMES["chrome"])
+
+
+def find_edge() -> str | None:
+    env_path = os.environ.get("CDPWAVE_EDGE_PATH")
+    if env_path and os.path.isfile(env_path):
+        return env_path
+    if sys.platform == "win32":
+        return _check_paths(_WIN_EDGE_PATHS)
+    if sys.platform == "darwin":
+        return _check_paths([_MAC_EDGE_PATH])
+    return _find_on_linux(_LINUX_NAMES["edge"])
+
+
+def find_brave() -> str | None:
+    env_path = os.environ.get("CDPWAVE_BRAVE_PATH")
+    if env_path and os.path.isfile(env_path):
+        return env_path
+    if sys.platform == "win32":
+        return _check_paths(_WIN_BRAVE_PATHS)
+    if sys.platform == "darwin":
+        return _check_paths([_MAC_BRAVE_PATH])
+    return _find_on_linux(_LINUX_NAMES["brave"])
+
+
+def find_chromium() -> str | None:
+    env_path = os.environ.get("CDPWAVE_CHROMIUM_PATH")
+    if env_path and os.path.isfile(env_path):
+        return env_path
+    if sys.platform == "win32":
+        return _check_paths(_WIN_CHROMIUM_PATHS)
+    if sys.platform == "darwin":
+        return _check_paths([_MAC_CHROMIUM_PATH])
+    return _find_on_linux(_LINUX_NAMES["chromium"])
+
+
+_FINDER_NAMES: dict[BrowserType, str] = {
+    "chrome": "find_chrome",
+    "edge": "find_edge",
+    "brave": "find_brave",
+    "chromium": "find_chromium",
+}
+
+_SEARCH_ORDER: list[BrowserType] = ["chrome", "edge", "brave", "chromium"]
+
+
+def find_browser(preferred: BrowserType | None = None) -> str:
+    env_override = os.environ.get("CDPWAVE_BROWSER_PATH")
+    if env_override and os.path.isfile(env_override):
+        return env_override
+
+    search_order: list[BrowserType] = []
+    if preferred is not None:
+        search_order.append(preferred)
+    search_order.extend([b for b in _SEARCH_ORDER if b != preferred])
+
+    for browser_type in search_order:
+        finder = globals()[_FINDER_NAMES[browser_type]]
+        path: str | None = finder()
+        if path:
+            return path
+
+    raise BrowserNotFoundError(
+        "No Chromium-based browser found."
+        " Set CDPWAVE_BROWSER_PATH or install Chrome/Edge/Brave/Chromium."
+    )