patchright-cli 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

patchright_cli/__init__.py

@@ -1,3 +1,3 @@
 """patchright-cli — Undetected browser automation CLI using Patchright."""
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"

patchright_cli/cli.py

@@ -6,6 +6,7 @@ receives the result, and prints it.
 
 from __future__ import annotations
 
+import argparse
 import json
 import os
 import socket
@@ -248,6 +249,36 @@ def _handle_install(args: list) -> None:
     click.echo(f"\npatchright-cli v{__version__} skills installed.")
 
 
+def _handle_mcp(args: list[str]) -> None:
+    """Handle the optional MCP server command."""
+    parser = argparse.ArgumentParser(
+        prog="patchright-cli mcp",
+        description="Run the MCP server. Stdio is the default transport.",
+    )
+    parser.add_argument("--http", action="store_true", help="Use Streamable HTTP instead of stdio.")
+    parser.add_argument("--host", default="127.0.0.1", help="HTTP bind host.")
+    parser.add_argument("--port", type=int, default=8000, help="HTTP bind port.")
+    options = parser.parse_args(args)
+
+    if not 1 <= options.port <= 65535:
+        parser.error("--port must be between 1 and 65535")
+    if not options.http and (options.host != "127.0.0.1" or options.port != 8000):
+        parser.error("--host and --port require --http")
+
+    try:
+        from patchright_cli.mcp_server import run_mcp_server
+    except ImportError as exc:
+        if exc.name not in {"fastmcp", "mcp", "pydantic"}:
+            raise
+        click.echo(
+            "MCP support is not installed. Install it with: pip install 'patchright-cli[mcp]'",
+            err=True,
+        )
+        raise SystemExit(1) from exc
+
+    run_mcp_server(http=options.http, host=options.host, port=options.port)
+
+
 _VERSION_CHECK_INTERVAL = 24 * 60 * 60
 _PYPI_URL = "https://pypi.org/pypi/patchright-cli/json"
 
@@ -510,6 +541,7 @@ COMMANDS_HELP = {
     "codegen-stop": "codegen-stop [file]   Stop recording and save script",
     # Setup
     "install": "install --skills      Install skill files for AI agents",
+    "mcp": "mcp [--http] [--host=HOST] [--port=N]  Start MCP server (stdio by default)",
 }
 
 ALL_COMMANDS = list(COMMANDS_HELP.keys())
@@ -616,7 +648,7 @@ def _print_help():
         ("Profiles", ["profile-list", "profile-delete"]),
         ("Dashboard", ["show"]),
         ("Codegen", ["codegen", "codegen-stop"]),
-        ("Setup", ["install"]),
+        ("Setup", ["install", "mcp"]),
     ]
     for cat_name, cmds in categories:
         click.echo(f"\n  {cat_name}:")
@@ -630,6 +662,13 @@ def main():
     _soften_output_encoding(sys.stdout, sys.stderr)
     argv = sys.argv[1:]
 
+    # MCP is a self-contained subcommand with its own transport options.
+    # Dispatch it before global option parsing so `patchright-cli mcp --help`
+    # shows MCP help rather than the top-level CLI help.
+    if argv and argv[0] == "mcp":
+        _handle_mcp(argv[1:])
+        return
+
     # Parse global options manually (before the command)
     headless = False
     persistent = False
@@ -779,6 +818,10 @@ def main():
         _handle_install(args + [k if v is True else f"{k}={v}" for k, v in extra_opts.items()])
         sys.exit(0)
 
+    if command == "mcp":
+        _handle_mcp(args)
+        sys.exit(0)
+
     _warn_stale_skills()
 
     # Only on `open`: one browser launch already costs seconds, and this keeps

patchright_cli/daemon.py

@@ -2846,6 +2846,30 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
             handler = COMMAND_HANDLERS.get("show")
             return await handler(None, None, args, options, cwd, state)
 
+        if cmd == "list":
+            lines = ["### Sessions"]
+            for sname, s in state.sessions.items():
+                marker = " *" if sname == session_name else ""
+                tab_count = len(s.pages)
+                lines.append(f"  - {sname}{marker}: {tab_count} tab(s)")
+            return {"success": True, "output": "\n".join(lines)}
+
+        if cmd == "close-all":
+            names = list(state.sessions.keys())
+            for n in names:
+                await state.close_session(n)
+            return {"success": True, "output": f"Closed {len(names)} session(s)."}
+
+        if cmd == "kill-all":
+            names = list(state.sessions.keys())
+            for n in names:
+                # close_session ends each Session the way it is allowed to
+                # (Detach from a Host Context) and frees its Profile.
+                await state.close_session(n)
+            if state.shutdown_event:
+                state.shutdown_event.set()
+            return {"success": True, "output": f"Killed {len(names)} session(s) and stopping daemon."}
+
         # All other commands require an existing session
         session = state.sessions.get(session_name)
         if session is None:
@@ -2857,14 +2881,6 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
         page = session.page
 
         # Commands that don't need a page
-        if cmd == "list":
-            lines = ["### Sessions"]
-            for sname, s in state.sessions.items():
-                marker = " *" if sname == session_name else ""
-                tab_count = len(s.pages)
-                lines.append(f"  - {sname}{marker}: {tab_count} tab(s)")
-            return {"success": True, "output": "\n".join(lines)}
-
         if cmd == "close":
             # `close` releases the tab it is addressed to. The browser goes when
             # the last tab does, so concurrent agents clean up without having to
@@ -2905,22 +2921,6 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 return {"success": True, "output": f"Detached from '{session_name}' (Host Context left untouched)."}
             return {"success": True, "output": f"Detached from '{session_name}' (external browser kept running)."}
 
-        if cmd == "close-all":
-            names = list(state.sessions.keys())
-            for n in names:
-                await state.close_session(n)
-            return {"success": True, "output": f"Closed {len(names)} session(s)."}
-
-        if cmd == "kill-all":
-            names = list(state.sessions.keys())
-            for n in names:
-                # close_session ends each Session the way it is allowed to
-                # (Detach from a Host Context) and frees its Profile.
-                await state.close_session(n)
-            if state.shutdown_event:
-                state.shutdown_event.set()
-            return {"success": True, "output": f"Killed {len(names)} session(s) and stopping daemon."}
-
         handler = COMMAND_HANDLERS.get(cmd)
         if handler is None:
             return {"success": False, "output": f"Unknown command: {cmd}"}