feat(cli): add full install command

Author: kacigaya

README.md

@@ -17,7 +17,7 @@ Documentation: [https://kacigaya.github.io/webskrap/](https://kacigaya.github.io
 
 ```bash
 pip install webskrap
-python -m playwright install chromium
+webskrap install
 ```
 
 ## Quickstart
@@ -233,10 +233,8 @@ the [`patchright`](https://github.com/Kaliiiiiiiiii-Vinyzu/patchright) driver, a
 CDP-leak-free Playwright fork, and let the browser's real fingerprint show through.
 WebSkrap does not inject JavaScript stealth patches.
 
-```bash
-pip install "webskrap[stealth]"
-patchright install chromium
-```
+`pip install webskrap` includes Patchright. Run `webskrap install` to download
+browser binaries.
 
 ```python
 from pathlib import Path
@@ -362,12 +360,12 @@ flags, but pages that need WebGL or canvas export may not work correctly.
 
 ## CLI
 
-`webskrap fetch` always runs headless Patchright stealth mode. Install the
-stealth extra before using it. `webskrap doctor` verifies this CLI setup.
+`webskrap fetch` always runs headless Patchright stealth mode. `webskrap install`
+downloads the browser binaries, and `webskrap doctor` verifies this CLI setup.
 
 ```bash
-pip install "webskrap[stealth]"
-patchright install chromium
+pip install webskrap
+webskrap install
 ```
 
 ```bash
@@ -398,8 +396,8 @@ Desktop, Claude Code, ...) can drive scraping directly. It exposes three tools
 over stdio: `fetch`, `stealth_fetch`, and `doctor`.
 
 ```bash
-pip install "webskrap[mcp]"
-python -m playwright install chromium
+pip install webskrap
+webskrap install
 webskrap-mcp
 ```
 
@@ -431,8 +429,8 @@ command = "webskrap-mcp"
 args = []
 ```
 
-`stealth_fetch` also needs the `stealth` extra (`pip install "webskrap[mcp,stealth]"`
-and `patchright install chromium`).
+The legacy extras `webskrap[mcp]` and `webskrap[stealth]` remain accepted for
+older install snippets, but MCP and Patchright are included by default.
 
 ## Performance benchmarks
 

SKILL.md

@@ -37,7 +37,7 @@ Install normal API/browser support:
 
 ```bash
 pip install webskrap
-python -m playwright install chromium
+webskrap install
 ```
 
 Use `WebSkrapClient` as an async context manager. Use `client.fetch()` for a
@@ -60,13 +60,8 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-The Python API defaults to Playwright. For Patchright, opt in through
-`SessionConfig`:
-
-```bash
-pip install "webskrap[stealth]"
-patchright install chromium
-```
+The Python API defaults to Playwright. `pip install webskrap` includes Patchright
+and MCP dependencies. For Patchright, opt in through `SessionConfig`:
 
 ```python
 from pathlib import Path
@@ -104,12 +99,13 @@ config = SessionConfig(
 
 ## CLI
 
-The CLI `fetch` command always uses headless Patchright stealth mode. Install
-the stealth extra first; `webskrap doctor` checks this CLI setup.
+The CLI `fetch` command always uses headless Patchright stealth mode.
+`webskrap install` downloads Playwright and Patchright Chromium browsers;
+`webskrap doctor` checks this CLI setup.
 
 ```bash
-pip install "webskrap[stealth]"
-patchright install chromium
+pip install webskrap
+webskrap install
 
 webskrap doctor
 webskrap doctor --format json
@@ -133,16 +129,15 @@ readable body text.
 Install MCP support when an MCP client should call WebSkrap directly:
 
 ```bash
-pip install "webskrap[mcp]"
-python -m playwright install chromium
+pip install webskrap
+webskrap install
 webskrap-mcp
 ```
 
 MCP tools:
 
 - `fetch`: standard Playwright fetch.
-- `stealth_fetch`: Patchright fetch; requires `pip install "webskrap[mcp,stealth]"`
-  and `patchright install chromium`.
+- `stealth_fetch`: Patchright fetch.
 - `doctor`: Playwright/Chromium MCP readiness check.
 
 ## Validation

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "webskrap"
-version = "0.5.3"
+version = "0.5.4"
 description = "A Playwright-based Python scraping framework with coherent browser profiles and session controls."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -24,6 +24,8 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
+  "mcp>=1.2",
+  "patchright>=1.60.0",
   "playwright>=1.49",
   "pydantic>=2.8",
   "rich>=13.9",
@@ -37,10 +39,8 @@ dev = [
   "ruff>=0.8",
 ]
 stealth = [
-    "patchright>=1.60.0",
 ]
 mcp = [
-    "mcp>=1.2",
 ]
 
 [project.scripts]

src/webskrap/cli.py

@@ -2,6 +2,8 @@
 
 import asyncio
 import json
+import subprocess
+import sys
 from pathlib import Path
 from typing import Annotated, Literal
 
@@ -26,6 +28,29 @@
 app = typer.Typer(help="WebSkrap browser scraping toolkit.")
 console = Console()
 OutputFormat = Literal["human", "json"]
+INSTALL_COMMANDS = (
+    (sys.executable, "-m", "playwright", "install", "chromium"),
+    ("patchright", "install", "chromium"),
+)
+
+
+@app.command("install")
+def install_command(
+    format: Annotated[
+        str,
+        typer.Option("--format", help="Output format: human or json."),
+    ] = "human",
+) -> None:
+    output_format = _parse_output_format(format)
+    results = [_run_install_command(command) for command in INSTALL_COMMANDS]
+    ok = all(result["ok"] for result in results)
+    payload = {"ok": ok, "steps": results}
+    if output_format == "json":
+        _print_json(payload)
+    else:
+        _print_install_result(results)
+    if not ok:
+        raise typer.Exit(code=1)
 
 
 @app.command("profiles")
@@ -84,7 +109,7 @@ async def _doctor() -> dict[str, object]:
         return {
             "ok": False,
             "message": f"Patchright import failed: {exc}",
-            "hint": 'Run: pip install "webskrap[stealth]" && patchright install chromium',
+            "hint": "Run: webskrap install",
         }
 
     try:
@@ -97,7 +122,7 @@ async def _doctor() -> dict[str, object]:
         return {
             "ok": False,
             "message": f"Patchright headless Chrome did not launch: {exc}",
-            "hint": 'Run: pip install "webskrap[stealth]" && patchright install chromium',
+            "hint": "Run: webskrap install",
         }
 
     return {"ok": True, "message": "Patchright headless Chrome is ready."}
@@ -321,6 +346,34 @@ def _print_json(payload: object) -> None:
     typer.echo(json.dumps(payload, ensure_ascii=False))
 
 
+def _run_install_command(command: tuple[str, ...]) -> dict[str, object]:
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError as exc:
+        return {
+            "ok": False,
+            "command": list(command),
+            "message": str(exc),
+        }
+    output = (completed.stdout or completed.stderr).strip()
+    return {
+        "ok": completed.returncode == 0,
+        "command": list(command),
+        "message": output,
+    }
+
+
+def _print_install_result(results: list[dict[str, object]]) -> None:
+    for result in results:
+        command = " ".join(str(part) for part in result["command"])
+        if result["ok"]:
+            console.print(f"[green]OK:[/green] {command}")
+        else:
+            console.print(f"[red]FAILED:[/red] {command}")
+        if result["message"]:
+            console.print(str(result["message"]))
+
+
 def _print_doctor_result(result: dict[str, object]) -> None:
     message = str(result["message"])
     if result["ok"]:

src/webskrap/client.py

@@ -21,17 +21,14 @@ def _async_playwright(driver: str):
 
     ``patchright`` is a drop-in, API-compatible fork of Playwright that hides the
     CDP ``Runtime.enable`` leak used by CDP-aware bot detectors. It requires the
-    optional ``stealth`` extra (``pip install webskrap[stealth]``) and its own
-    browser download (``patchright install chromium``).
+    ``patchright`` ships with WebSkrap, but needs its browser download
+    (``webskrap install``).
     """
     if driver == "patchright":
         try:
             from patchright.async_api import async_playwright
         except ImportError as exc:  # pragma: no cover - optional dependency
-            msg = (
-                "driver='patchright' requires the optional dependency: "
-                "pip install webskrap[stealth] && patchright install chromium"
-            )
+            msg = "driver='patchright' requires patchright. Run: pip install webskrap"
             raise WebSkrapError(msg) from exc
         return async_playwright()
     from playwright.async_api import async_playwright

src/webskrap/mcp_server.py

@@ -1,6 +1,6 @@
 """Model Context Protocol server exposing WebSkrap over stdio.
 
-Run with ``webskrap-mcp`` (after ``pip install webskrap[mcp]``) or
+Run with ``webskrap-mcp`` (after ``pip install webskrap``) or
 ``python -m webskrap.mcp_server``. Point an MCP client (Claude Desktop, Claude
 Code, ...) at that command to drive scraping through the tools below.
 """
@@ -22,7 +22,7 @@
 try:
     from mcp.server.fastmcp import FastMCP
 except ImportError as exc:  # pragma: no cover - optional dependency
-    msg = "the MCP server requires the optional dependency: pip install webskrap[mcp]"
+    msg = "the MCP server requires mcp. Run: pip install webskrap"
     raise WebSkrapError(msg) from exc
 
 mcp = FastMCP("webskrap")
@@ -78,9 +78,8 @@ async def stealth_fetch(
 ) -> dict[str, Any]:
     """Fetch a URL with the Patchright stealth driver (CDP-leak-free).
 
-    Requires the optional stealth extra: pip install webskrap[stealth] and
-    patchright install chromium. Prefer headless=False with channel="chrome"
-    for the strictest anti-bot path.
+    Requires Patchright's browser download: webskrap install. Prefer
+    headless=False with channel="chrome" for the strictest anti-bot path.
 
     Args:
         url: The URL to load.
@@ -135,7 +134,7 @@ async def doctor() -> dict[str, Any]:
         return {
             "ok": False,
             "message": f"Chromium did not launch: {exc}",
-            "hint": "Run: python -m playwright install chromium",
+            "hint": "Run: webskrap install",
         }
 
     return {"ok": True, "message": "Playwright and Chromium are ready."}

tests/test_bot_detection.py

@@ -25,8 +25,7 @@
 
 Compare this strict headed suite with ``test_bot_detection_headless.py`` for the
 current headless baseline. Requires Google Chrome installed on the host and the
-optional stealth extra (``pip install webskrap[stealth]`` plus
-``patchright install chromium``).
+Patchright browser download (``webskrap install``).
 """
 
 from __future__ import annotations

tests/test_cli.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import subprocess
 from typing import Any
 
 from typer.testing import CliRunner
@@ -135,3 +136,76 @@ async def fake_doctor() -> dict[str, object]:
 
     assert result.exit_code == 1
     assert json.loads(result.output) == {"ok": False, "message": "broken", "hint": "fix it"}
+
+
+def test_install_json_success(monkeypatch: Any) -> None:
+    calls: list[tuple[str, ...]] = []
+
+    def fake_run(command: tuple[str, ...], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
+        calls.append(command)
+        return subprocess.CompletedProcess(command, 0, stdout="installed", stderr="")
+
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+
+    result = runner.invoke(cli.app, ["install", "--format", "json"])
+
+    assert result.exit_code == 0, result.output
+    payload = json.loads(result.output)
+    assert payload["ok"] is True
+    assert [tuple(step["command"]) for step in payload["steps"]] == list(cli.INSTALL_COMMANDS)
+    assert calls == list(cli.INSTALL_COMMANDS)
+
+
+def test_install_json_failure(monkeypatch: Any) -> None:
+    def fake_run(command: tuple[str, ...], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
+        return_code = 1 if command[0] == "patchright" else 0
+        return subprocess.CompletedProcess(
+            command,
+            return_code,
+            stdout="",
+            stderr="missing browser",
+        )
+
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+
+    result = runner.invoke(cli.app, ["install", "--format", "json"])
+
+    assert result.exit_code == 1
+    payload = json.loads(result.output)
+    assert payload["ok"] is False
+    assert payload["steps"][0]["ok"] is True
+    assert payload["steps"][1]["ok"] is False
+    assert payload["steps"][1]["message"] == "missing browser"
+
+
+def test_install_json_handles_missing_executable(monkeypatch: Any) -> None:
+    def fake_run(command: tuple[str, ...], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
+        if command[0] == "patchright":
+            raise FileNotFoundError("missing patchright")
+        return subprocess.CompletedProcess(command, 0, stdout="installed", stderr="")
+
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+
+    result = runner.invoke(cli.app, ["install", "--format", "json"])
+
+    assert result.exit_code == 1
+    payload = json.loads(result.output)
+    assert payload["ok"] is False
+    assert payload["steps"][1]["ok"] is False
+    assert payload["steps"][1]["message"] == "missing patchright"
+
+
+def test_install_human_output(monkeypatch: Any) -> None:
+    def fake_run(command: tuple[str, ...], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
+        return subprocess.CompletedProcess(command, 0, stdout="installed", stderr="")
+
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+
+    result = runner.invoke(cli.app, ["install"])
+
+    assert result.exit_code == 0, result.output
+    assert "OK:" in result.output
+    assert "playwright" in result.output
+    assert "install" in result.output
+    assert "chromium" in result.output
+    assert "patchright install chromium" in result.output