patchright-cli 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

patchright_cli/__init__.py

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

patchright_cli/cli.py

@@ -11,6 +11,7 @@ import os
 import socket
 import struct
 import sys
+from pathlib import Path
 
 import click
 
@@ -18,6 +19,23 @@ from patchright_cli import __version__
 from patchright_cli.daemon import DEFAULT_PORT, ensure_daemon_running
 
 
+def _load_config(config_path: str | None) -> dict:
+    """Load JSON config file. If config_path is None, try .patchright-cli/config.json in cwd."""
+    p = Path(config_path) if config_path else Path.cwd() / ".patchright-cli" / "config.json"
+    if p.exists():
+        return json.loads(p.read_text(encoding="utf-8"))
+    return {}
+
+
+def _merge_config_with_options(config: dict, options: dict) -> dict:
+    """Merge config dict with CLI options. CLI options take precedence."""
+    merged = dict(config)
+    for k, v in options.items():
+        if v is not None:
+            merged[k] = v
+    return merged
+
+
 def _send_command(command: str, args: list, options: dict, port: int = DEFAULT_PORT) -> dict:
     """Connect to daemon, send command, receive response."""
     msg = {
@@ -61,6 +79,7 @@ def _recv_exact(sock: socket.socket, n: int) -> bytes:
 COMMANDS_HELP = {
     # Core
     "open": "open [url]           Open browser (starts daemon if needed)",
+    "attach": "attach --cdp=<url>   Attach to running Chrome via CDP",
     "goto": "goto <url>           Navigate to URL",
     "click": "click <ref> [button]  Click element [--modifiers=Alt,Shift]",
     "dblclick": "dblclick <ref> [btn] Double-click [--modifiers=Alt,Shift]",
@@ -70,8 +89,8 @@ COMMANDS_HELP = {
     "select": "select <ref> <value> Select dropdown option",
     "check": "check <ref>          Check checkbox/radio",
     "uncheck": "uncheck <ref>        Uncheck checkbox/radio",
-    "snapshot": "snapshot [ref]        Take accessibility snapshot",
-    "eval": "eval <expr>          Evaluate JavaScript [--file=F or stdin]",
+    "snapshot": "snapshot [ref]        Take accessibility snapshot [--filename=F] [--depth=N]",
+    "eval": "eval <expr> [ref]     Evaluate JavaScript [--file=F or stdin]",
     "text": "text <ref|selector>  Get text content of element",
     "screenshot": "screenshot [ref]     Save screenshot [--full-page] [--filename=F]",
     "drag": "drag <from> <to>     Drag element to target",
@@ -117,6 +136,8 @@ COMMANDS_HELP = {
     # Dialog
     "dialog-accept": "dialog-accept [text] Accept next dialog",
     "dialog-dismiss": "dialog-dismiss       Dismiss next dialog",
+    # Permissions
+    "grant-permissions": "grant-permissions <perms>  Grant permissions [--origin=url]",
     # Upload / Resize
     "upload": "upload <file> [ref]   Upload file to input",
     "resize": "resize <w> <h>        Resize viewport",
@@ -142,6 +163,7 @@ COMMANDS_HELP = {
     # Video
     "video-start": "video-start          Start video recording",
     "video-stop": "video-stop           Stop recording and save [--filename=F]",
+    "video-chapter": "video-chapter <title>  Add chapter marker to video",
     # PDF
     "pdf": "pdf [--filename=F]   Save page as PDF",
     # DevTools
@@ -152,6 +174,11 @@ COMMANDS_HELP = {
     "close-all": "close-all            Close all sessions",
     "kill-all": "kill-all             Kill all sessions",
     "delete-data": "delete-data          Delete persistent profile",
+    # Dashboard
+    "show": "show [--port=N]       Open session dashboard in browser",
+    # Codegen
+    "codegen": "codegen [file]        Start recording interactions",
+    "codegen-stop": "codegen-stop [file]   Stop recording and save script",
 }
 
 ALL_COMMANDS = list(COMMANDS_HELP.keys())
@@ -167,6 +194,18 @@ def _print_help():
     click.echo("  --proxy=<url>       Proxy server (e.g. http://host:port, socks5://host:port)")
     click.echo("  -s=<name>           Named session (default: 'default')")
     click.echo("  --port=<n>          Daemon port (default: 9321)")
+    click.echo("  --config=<path>     Load config from JSON file")
+    click.echo("  --timeout-action=ms   Default action timeout")
+    click.echo("  --timeout-navigation=ms Default navigation timeout")
+    click.echo("  --device=<name>     Emulate a device (e.g. 'iPhone 15')")
+    click.echo("  --viewport-size=WxH Set viewport size")
+    click.echo("  --locale=<code>     Locale (e.g. en-US)")
+    click.echo("  --timezone=<id>     Timezone ID")
+    click.echo("  --geolocation=lat,lon Geolocation override")
+    click.echo("  --user-agent=<ua>   Custom user agent")
+    click.echo("  --grant-permissions=P Comma-separated permissions to grant")
+    click.echo("  --cdp=<url>         Attach to Chrome via CDP endpoint")
+    click.echo("  --show-port=N       Dashboard port (default: 9322)")
     click.echo("  --version           Show version")
     click.echo("  --help              Show this help\n")
     click.echo("Commands:")
@@ -176,6 +215,7 @@ def _print_help():
             "Core",
             [
                 "open",
+                "attach",
                 "goto",
                 "click",
                 "dblclick",
@@ -223,13 +263,16 @@ def _print_help():
                 "sessionstorage-clear",
             ],
         ),
+        ("Permissions", ["grant-permissions"]),
         ("Route", ["route", "route-list", "unroute", "network-state-set"]),
         ("Code", ["run-code"]),
         ("Tracing", ["tracing-start", "tracing-stop"]),
-        ("Video", ["video-start", "video-stop"]),
+        ("Video", ["video-start", "video-stop", "video-chapter"]),
         ("PDF", ["pdf"]),
         ("DevTools", ["console", "network"]),
         ("Session", ["list", "close-all", "kill-all", "delete-data"]),
+        ("Dashboard", ["show"]),
+        ("Codegen", ["codegen", "codegen-stop"]),
     ]
     for cat_name, cmds in categories:
         click.echo(f"\n  {cat_name}:")
@@ -247,8 +290,10 @@ def main():
     persistent = False
     profile = None
     proxy = None
-    session_name = "default"
+    config_path = None
+    session_name = os.environ.get("PATCHRIGHT_CLI_SESSION", "default")
     port = DEFAULT_PORT
+    extra_opts: dict = {}
 
     # Extract options
     remaining = []
@@ -287,6 +332,60 @@ def main():
             except ValueError:
                 click.echo(f"Invalid port value: {argv[i]}", err=True)
                 sys.exit(1)
+        elif arg.startswith("--config="):
+            config_path = arg.split("=", 1)[1]
+        elif arg == "--config" and i + 1 < len(argv):
+            i += 1
+            config_path = argv[i]
+        elif arg.startswith("--device="):
+            extra_opts["device"] = arg.split("=", 1)[1]
+        elif arg == "--device" and i + 1 < len(argv):
+            i += 1
+            extra_opts["device"] = argv[i]
+        elif arg.startswith("--viewport-size="):
+            vw, vh = arg.split("=", 1)[1].split("x", 1)
+            extra_opts["viewport"] = {"width": vw, "height": vh}
+        elif arg == "--viewport-size" and i + 1 < len(argv):
+            i += 1
+            vw, vh = argv[i].split("x", 1)
+            extra_opts["viewport"] = {"width": vw, "height": vh}
+        elif arg.startswith("--locale="):
+            extra_opts["locale"] = arg.split("=", 1)[1]
+        elif arg == "--locale" and i + 1 < len(argv):
+            i += 1
+            extra_opts["locale"] = argv[i]
+        elif arg.startswith("--timezone="):
+            extra_opts["timezone"] = arg.split("=", 1)[1]
+        elif arg == "--timezone" and i + 1 < len(argv):
+            i += 1
+            extra_opts["timezone"] = argv[i]
+        elif arg.startswith("--geolocation="):
+            lat, lon = arg.split("=", 1)[1].split(",", 1)
+            extra_opts["geolocation"] = {"lat": lat, "lon": lon}
+        elif arg == "--geolocation" and i + 1 < len(argv):
+            i += 1
+            lat, lon = argv[i].split(",", 1)
+            extra_opts["geolocation"] = {"lat": lat, "lon": lon}
+        elif arg.startswith("--user-agent="):
+            extra_opts["user-agent"] = arg.split("=", 1)[1]
+        elif arg == "--user-agent" and i + 1 < len(argv):
+            i += 1
+            extra_opts["user-agent"] = argv[i]
+        elif arg.startswith("--grant-permissions="):
+            extra_opts["grant-permissions"] = arg.split("=", 1)[1]
+        elif arg == "--grant-permissions" and i + 1 < len(argv):
+            i += 1
+            extra_opts["grant-permissions"] = argv[i]
+        elif arg.startswith("--cdp="):
+            extra_opts["cdp"] = arg.split("=", 1)[1]
+        elif arg == "--cdp" and i + 1 < len(argv):
+            i += 1
+            extra_opts["cdp"] = argv[i]
+        elif arg.startswith("--show-port="):
+            extra_opts["show-port"] = arg.split("=", 1)[1]
+        elif arg == "--show-port" and i + 1 < len(argv):
+            i += 1
+            extra_opts["show-port"] = argv[i]
         elif arg in ("--version", "-v"):
             click.echo(f"patchright-cli {__version__}")
             sys.exit(0)
@@ -311,16 +410,18 @@ def main():
 
     # Separate --key=value and --flag from positional args
     positional_args = []
-    extra_opts = {}
+    cmd_opts: dict = {}
     for a in args:
         if a.startswith("--") and "=" in a:
             k, v = a[2:].split("=", 1)
-            extra_opts[k] = v
+            cmd_opts[k] = v
         elif a.startswith("--"):
-            extra_opts[a[2:]] = True
+            cmd_opts[a[2:]] = True
         else:
             positional_args.append(a)
     args = positional_args
+    # Merge: global opts as base, command-level opts take precedence
+    extra_opts = {**extra_opts, **cmd_opts}
 
     # For eval/run-code: support --file=<path> and stdin via "-"
     if command in ("eval", "run-code"):
@@ -343,8 +444,9 @@ def main():
             click.echo(f"'{command}' requires a JS expression, --file=<path>, or piped stdin.", err=True)
             sys.exit(1)
 
-    # Build options dict
-    options = {"session": session_name, **extra_opts}
+    # Build options dict (config file values are overridden by explicit CLI flags)
+    config = _load_config(config_path)
+    options = {"session": session_name, **_merge_config_with_options(config, extra_opts)}
     if headless:
         options["headless"] = True
     if persistent:

patchright_cli/daemon.py

@@ -27,6 +27,8 @@ logger = logging.getLogger("patchright-cli.daemon")
 DEFAULT_PORT = 9321
 DEFAULT_PROFILE_DIR = str(Path.home() / ".patchright-cli" / "profiles" / "default")
 
+_dashboard_runners: dict[int, tuple] = {}
+
 # ---------------------------------------------------------------------------
 # Command handler registry
 # ---------------------------------------------------------------------------
@@ -66,8 +68,10 @@ class Session:
         self._video_cdp = None
         self._video_frames: list[bytes] = []
         self._video_recording: bool = False
+        self._video_chapters: list[tuple[int, str]] = []
         self._history: list[str] = []
         self._history_index: int = -1
+        self._codegen: list[str] | None = None
 
     # -- internal helpers ---------------------------------------------------
 
@@ -185,6 +189,16 @@ class DaemonState:
         profile: str | None = None,
         proxy: str | None = None,
         url: str | None = None,
+        device: str | None = None,
+        viewport: dict | None = None,
+        locale: str | None = None,
+        timezone: str | None = None,
+        geolocation: dict | None = None,
+        user_agent: str | None = None,
+        grant_permissions: str | None = None,
+        cdp_endpoint: str | None = None,
+        cdp_headers: dict | None = None,
+        cdp_timeout: int = 30000,
     ) -> Session:
         if name in self.sessions:
             return self.sessions[name]
@@ -198,37 +212,69 @@ class DaemonState:
         profile_dir = profile or str(Path.home() / ".patchright-cli" / "profiles" / name)
         Path(profile_dir).mkdir(parents=True, exist_ok=True)
 
-        launch_kwargs = {
-            "channel": "chrome",
-            "headless": use_headless,
-            "no_viewport": True,
-            "args": ["--disable-blink-features=AutomationControlled"],
-        }
-        if proxy:
-            parsed = urlparse(proxy)
-            if parsed.username or parsed.password:
-                import base64
-
-                creds = base64.b64encode(f"{parsed.username or ''}:{parsed.password or ''}".encode()).decode()
-                launch_kwargs["extra_http_headers"] = {"Proxy-Authorization": f"Basic {creds}"}
-                # Rebuild proxy URL without credentials
-                netloc = parsed.hostname or ""
-                if parsed.port:
-                    netloc += f":{parsed.port}"
-                cleaned = parsed._replace(netloc=netloc).geturl()
-                launch_kwargs["proxy"] = {"server": cleaned}
-            else:
-                launch_kwargs["proxy"] = {"server": proxy}
-
-        context = await self.playwright.chromium.launch_persistent_context(
-            profile_dir,
-            **launch_kwargs,
-        )
-
-        pages = context.pages or []
-        if not pages:
-            page = await context.new_page()
-            pages = [page]
+        context_options: dict = {}
+        if device and self.playwright is not None:
+            device_descriptor = self.playwright.devices.get(device)
+            if device_descriptor:
+                context_options.update(device_descriptor)
+        if viewport:
+            context_options["viewport"] = {"width": int(viewport["width"]), "height": int(viewport["height"])}
+        if locale:
+            context_options["locale"] = locale
+        if timezone:
+            context_options["timezone_id"] = timezone
+        if geolocation:
+            context_options["geolocation"] = {
+                "latitude": float(geolocation["lat"]),
+                "longitude": float(geolocation["lon"]),
+            }
+            context_options["permissions"] = context_options.get("permissions", []) + ["geolocation"]
+        if user_agent:
+            context_options["user_agent"] = user_agent
+        if grant_permissions:
+            perms = [p.strip() for p in grant_permissions.split(",") if p.strip()]
+            context_options["permissions"] = list(set(context_options.get("permissions", []) + perms))
+
+        if cdp_endpoint:
+            browser = await self.playwright.chromium.connect_over_cdp(
+                cdp_endpoint, headers=cdp_headers, timeout=cdp_timeout
+            )
+            context = await browser.new_context(**context_options)
+            pages = context.pages or []
+            if not pages:
+                page = await context.new_page()
+                pages = [page]
+        else:
+            launch_kwargs = {
+                "channel": "chrome",
+                "headless": use_headless,
+                "no_viewport": True,
+                "args": ["--disable-blink-features=AutomationControlled"],
+            }
+            if proxy:
+                parsed = urlparse(proxy)
+                if parsed.username or parsed.password:
+                    import base64
+
+                    creds = base64.b64encode(f"{parsed.username or ''}:{parsed.password or ''}".encode()).decode()
+                    launch_kwargs["extra_http_headers"] = {"Proxy-Authorization": f"Basic {creds}"}
+                    # Rebuild proxy URL without credentials
+                    netloc = parsed.hostname or ""
+                    if parsed.port:
+                        netloc += f":{parsed.port}"
+                    cleaned = parsed._replace(netloc=netloc).geturl()
+                    launch_kwargs["proxy"] = {"server": cleaned}
+                else:
+                    launch_kwargs["proxy"] = {"server": proxy}
+            launch_kwargs.update(context_options)
+            context = await self.playwright.chromium.launch_persistent_context(
+                profile_dir,
+                **launch_kwargs,
+            )
+            pages = context.pages or []
+            if not pages:
+                page = await context.new_page()
+                pages = [page]
 
         if url:
             await pages[0].goto(url)
@@ -294,6 +340,20 @@ async def _resolve_ref(session: Session, page, ref: str):
     return session.ref_registry.resolve(page, ref)
 
 
+async def _apply_timeouts(page, options: dict) -> None:
+    """Apply per-command timeout overrides from CLI options."""
+    if options.get("timeout-action"):
+        try:
+            page.set_default_timeout(float(options["timeout-action"]))
+        except Exception:
+            pass
+    if options.get("timeout-navigation"):
+        try:
+            page.set_default_navigation_timeout(float(options["timeout-navigation"]))
+        except Exception:
+            pass
+
+
 # ---------------------------------------------------------------------------
 # Command handlers
 # ---------------------------------------------------------------------------
@@ -433,11 +493,12 @@ async def cmd_drag(session: Session, page, args: list, options: dict, cwd: str |
 @register("snapshot")
 async def cmd_snapshot(session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState) -> dict:
     element_ref = args[0] if args else None
+    max_depth = int(options["depth"]) if options.get("depth") is not None else None
     if element_ref:
         elem = await _resolve_ref(session, page, element_ref)
-        snapshot_text, session.ref_registry = await take_snapshot(page, root_element=elem)
+        snapshot_text, session.ref_registry = await take_snapshot(page, root_element=elem, max_depth=max_depth)
     else:
-        snapshot_text, session.ref_registry = await take_snapshot(page)
+        snapshot_text, session.ref_registry = await take_snapshot(page, max_depth=max_depth)
     fn = options.get("filename")
     if fn:
         Path(fn).parent.mkdir(parents=True, exist_ok=True)
@@ -465,8 +526,16 @@ async def cmd_snapshot(session: Session, page, args: list, options: dict, cwd: s
 
 @register("eval")
 async def cmd_eval(session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState) -> dict:
-    expr = args[0] if args else ""
-    result = await page.evaluate(expr)
+    import re
+
+    if len(args) >= 2 and re.fullmatch(r"e\d+", args[-1]) and session.ref_registry is not None:
+        expr = " ".join(args[:-1])
+        ref = args[-1]
+        elem = await _resolve_ref(session, page, ref)
+        result = await elem.evaluate(expr)
+    else:
+        expr = args[0] if args else ""
+        result = await page.evaluate(expr)
     return {"success": True, "output": json.dumps(result, indent=2, default=str)}
 
 
@@ -848,6 +917,25 @@ async def cmd_resize(session: Session, page, args: list, options: dict, cwd: str
     return {"success": True, "output": f"Viewport resized to {w}x{h}"}
 
 
+# -- Permissions -------------------------------------------------------------
+
+
+@register("grant-permissions")
+async def cmd_grant_permissions(
+    session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState
+) -> dict:
+    perms_str = args[0] if args else ""
+    perms = [p.strip() for p in perms_str.split(",") if p.strip()]
+    if not perms:
+        return {"success": False, "output": "Usage: grant-permissions <perm1,perm2> [--origin=url]"}
+    origin = options.get("origin")
+    kwargs = {"permissions": perms}
+    if origin:
+        kwargs["origin"] = origin
+    await session.context.grant_permissions(**kwargs)
+    return {"success": True, "output": f"Granted permissions: {', '.join(perms)}"}
+
+
 # -- State save/load ---------------------------------------------------------
 
 
@@ -1075,6 +1163,8 @@ async def cmd_video_stop(
     frames = session._video_frames
     session._video_frames = []
     session._video_cdp = None
+    chapters = list(session._video_chapters)
+    session._video_chapters = []
 
     if not frames:
         return {"success": False, "output": "No video frames were captured."}
@@ -1084,6 +1174,13 @@ async def cmd_video_stop(
     snap_dir.mkdir(parents=True, exist_ok=True)
     ts = int(time.time() * 1000)
 
+    if chapters:
+        chapters_path = snap_dir / f"video-{ts}-chapters.json"
+        chapters_path.write_text(
+            json.dumps([{"frame": f, "title": t} for f, t in chapters], indent=2),
+            encoding="utf-8",
+        )
+
     fn = options.get("filename")
     video_path = snap_dir / (fn or f"video-{ts}.webm")
     try:
@@ -1126,6 +1223,18 @@ async def cmd_video_stop(
         }
 
 
+@register("video-chapter")
+async def cmd_video_chapter(
+    session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState
+) -> dict:
+    if not session._video_recording:
+        return {"success": False, "output": "No video recording in progress."}
+    title = args[0] if args else "Chapter"
+    frame_index = len(session._video_frames)
+    session._video_chapters.append((frame_index, title))
+    return {"success": True, "output": f"Chapter '{title}' added at frame {frame_index}."}
+
+
 # -- PDF ---------------------------------------------------------------------
 
 
@@ -1174,6 +1283,98 @@ async def cmd_wait_for(session: Session, page, args: list, options: dict, cwd: s
     return {"success": True, "output": f"Element is {state_arg}"}
 
 
+@register("show")
+async def cmd_show(session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState) -> dict:
+    from patchright_cli.dashboard import start_dashboard_server
+
+    port = int(options.get("show-port", 9322))
+    if port not in _dashboard_runners:
+        runner, url = await start_dashboard_server(state, port=port)
+        _dashboard_runners[port] = (runner, url)
+    else:
+        _, url = _dashboard_runners[port]
+    return {"success": True, "output": f"Dashboard running at {url}"}
+
+
+_CODEGEN_RECORDABLE = {
+    "goto",
+    "go-back",
+    "go-forward",
+    "reload",
+    "click",
+    "dblclick",
+    "fill",
+    "type",
+    "hover",
+    "select",
+    "check",
+    "uncheck",
+    "drag",
+    "press",
+    "keydown",
+    "keyup",
+    "mousemove",
+    "mousedown",
+    "mouseup",
+    "mousewheel",
+    "scroll",
+    "scroll-to",
+    "wait",
+    "wait-for",
+    "tab-new",
+    "tab-close",
+    "tab-select",
+    "upload",
+    "resize",
+    "cookie-set",
+    "cookie-delete",
+    "cookie-clear",
+    "localstorage-set",
+    "localstorage-delete",
+    "localstorage-clear",
+    "sessionstorage-set",
+    "sessionstorage-delete",
+    "sessionstorage-clear",
+    "state-load",
+    "route",
+    "unroute",
+    "network-state-set",
+    "dialog-accept",
+    "dialog-dismiss",
+    "screenshot",
+    "pdf",
+}
+
+
+@register("codegen")
+async def cmd_codegen(session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState) -> dict:
+    session._codegen = []
+    if page:
+        url = page.url
+        session._codegen.append(f'patchright-cli open "{url}"')
+    return {"success": True, "output": "Recording started. Run 'codegen-stop' to save the script."}
+
+
+@register("codegen-stop")
+async def cmd_codegen_stop(
+    session: Session, page, args: list, options: dict, cwd: str | None, state: DaemonState
+) -> dict:
+    if session._codegen is None:
+        return {"success": False, "output": "No recording in progress. Run 'codegen' first."}
+    lines = ["#!/usr/bin/env bash", "set -e", ""] + session._codegen
+    script = "\n".join(lines) + "\n"
+    session._codegen = None
+
+    base = Path(cwd) if cwd else Path.cwd()
+    snap_dir = base / ".patchright-cli"
+    snap_dir.mkdir(parents=True, exist_ok=True)
+    ts = int(time.time() * 1000)
+    filepath = args[0] if args else str(snap_dir / f"script-{ts}.sh")
+    Path(filepath).parent.mkdir(parents=True, exist_ok=True)
+    Path(filepath).write_text(script, encoding="utf-8")
+    return {"success": True, "output": f"Saved {len(lines) - 3} command(s) to {filepath}"}
+
+
 # ---------------------------------------------------------------------------
 # Command dispatch
 # ---------------------------------------------------------------------------
@@ -1202,6 +1403,36 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 profile=options.get("profile"),
                 proxy=options.get("proxy"),
                 url=url,
+                device=options.get("device"),
+                viewport=options.get("viewport"),
+                locale=options.get("locale"),
+                timezone=options.get("timezone"),
+                geolocation=options.get("geolocation"),
+                user_agent=options.get("user-agent") or options.get("userAgent"),
+                grant_permissions=options.get("grant-permissions") or options.get("grantPermissions"),
+            )
+            if session.page:
+                session.push_history(session.page.url)
+            return await _page_info(session, cwd)
+
+        if cmd == "attach":
+            cdp = options.get("cdp")
+            if not cdp:
+                return {"success": False, "output": "Usage: attach --cdp=<url>"}
+            headless = options.get("headless", False)
+            session = await state.get_or_create_session(
+                session_name,
+                headless=headless,
+                cdp_endpoint=cdp,
+                cdp_headers=options.get("cdp-headers"),
+                cdp_timeout=int(options.get("cdp-timeout", 30000)),
+                device=options.get("device"),
+                viewport=options.get("viewport"),
+                locale=options.get("locale"),
+                timezone=options.get("timezone"),
+                geolocation=options.get("geolocation"),
+                user_agent=options.get("user-agent") or options.get("userAgent"),
+                grant_permissions=options.get("grant-permissions") or options.get("grantPermissions"),
             )
             if session.page:
                 session.push_history(session.page.url)
@@ -1218,6 +1449,11 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 return {"success": True, "output": f"Profile data deleted for '{session_name}'."}
             return {"success": False, "output": "No persistent profile to delete."}
 
+        # Dashboard command — no session required
+        if cmd == "show":
+            handler = COMMAND_HANDLERS.get("show")
+            return await handler(None, None, args, options, cwd, state)
+
         # All other commands require an existing session
         session = state.sessions.get(session_name)
         if session is None:
@@ -1272,11 +1508,26 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 "output": "No page open. Run 'tab-new' to create one, or 'close' and 'open' again.",
             }
 
+        await _apply_timeouts(page, options)
+
         handler = COMMAND_HANDLERS.get(cmd)
         if handler is None:
             return {"success": False, "output": f"Unknown command: {cmd}"}
 
-        return await handler(session, page, args, options, cwd, state)
+        result = await handler(session, page, args, options, cwd, state)
+        if result.get("success") and session._codegen is not None and cmd in _CODEGEN_RECORDABLE:
+            args_quoted = [f'"{a}"' if " " in a else a for a in args]
+            opt_parts = []
+            for k, v in options.items():
+                if k in ("session", "headless", "persistent", "profile", "proxy"):
+                    continue
+                if v is True:
+                    opt_parts.append(f"--{k}")
+                elif isinstance(v, str):
+                    opt_parts.append(f"--{k}={v}")
+            cmd_line = " ".join(["patchright-cli"] + opt_parts + [cmd] + args_quoted)
+            session._codegen.append(cmd_line)
+        return result
 
     except Exception as e:
         logger.error("Command %s failed: %s", cmd, traceback.format_exc())

patchright_cli/dashboard.py

@@ -0,0 +1,135 @@
+"""Web dashboard for monitoring patchright-cli sessions."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+
+from aiohttp import web
+
+HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>patchright-cli dashboard</title>
+<style>
+body { font-family: sans-serif; margin: 0; padding: 20px; background: #111; color: #eee; }
+h1 { margin-top: 0; }
+.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); gap: 16px; }
+.card { background: #222; border-radius: 8px; padding: 12px; }
+.card h3 { margin: 0 0 8px; font-size: 14px; }
+.card img { width: 100%; border-radius: 4px; background: #333; }
+.card p { margin: 4px 0; font-size: 12px; color: #aaa; }
+.status { font-size: 11px; color: #888; }
+</style>
+</head>
+<body>
+<h1>patchright-cli sessions</h1>
+<div id="grid" class="grid"></div>
+<script>
+const grid = document.getElementById('grid');
+const ws = new WebSocket(`ws://${location.host}/ws`);
+const sessions = {};
+
+ws.onmessage = (ev) => {
+  const data = JSON.parse(ev.data);
+  if (!data.sessions) return;
+  data.sessions.forEach(s => {
+    sessions[s.name] = s;
+  });
+  render();
+};
+
+function render() {
+  grid.innerHTML = '';
+  Object.values(sessions).forEach(s => {
+    const div = document.createElement('div');
+    div.className = 'card';
+    div.innerHTML = `
+      <h3>${s.name}</h3>
+      <p>${s.url}</p>
+      <p class="status">${s.title} — ${s.tabs} tab(s)</p>
+      ${s.screenshot ? `<img src="data:image/png;base64,${s.screenshot}" />` : '<p class="status">No screenshot yet</p>'}
+    `;
+    grid.appendChild(div);
+  });
+}
+</script>
+</body>
+</html>
+"""
+
+
+class DashboardState:
+    def __init__(self, daemon_state):
+        self.daemon_state = daemon_state
+        self._screenshots: dict[str, str | None] = {}
+
+    async def capture_loop(self):
+        while True:
+            await asyncio.sleep(1)
+            for name, session in list(self.daemon_state.sessions.items()):
+                page = session.page
+                if page is None:
+                    self._screenshots[name] = None
+                    continue
+                try:
+                    data = await page.screenshot(type="png")
+                    self._screenshots[name] = base64.b64encode(data).decode()
+                except Exception:
+                    self._screenshots[name] = None
+
+    def _session_payload(self):
+        sessions = []
+        for name, session in self.daemon_state.sessions.items():
+            page = session.page
+            sessions.append(
+                {
+                    "name": name,
+                    "url": page.url if page else "",
+                    "title": "",
+                    "tabs": len(session.pages),
+                    "screenshot": self._screenshots.get(name),
+                }
+            )
+        return {"sessions": sessions}
+
+
+async def index(request: web.Request):
+    return web.Response(text=HTML, content_type="text/html")
+
+
+async def api_sessions(request: web.Request):
+    state: DashboardState = request.app["dashboard_state"]
+    return web.json_response(state._session_payload())
+
+
+async def websocket_handler(request: web.Request):
+    ws = web.WebSocketResponse()
+    await ws.prepare(request)
+    state: DashboardState = request.app["dashboard_state"]
+    try:
+        while not ws.closed:
+            await ws.send_json(state._session_payload())
+            await asyncio.sleep(1)
+    except Exception:
+        pass
+    return ws
+
+
+async def start_dashboard_server(daemon_state, port: int = 9322):
+    dashboard_state = DashboardState(daemon_state)
+    app = web.Application()
+    app["dashboard_state"] = dashboard_state
+    app.router.add_get("/", index)
+    app.router.add_get("/api/sessions", api_sessions)
+    app.router.add_get("/ws", websocket_handler)
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, "127.0.0.1", port)
+    await site.start()
+
+    asyncio.create_task(dashboard_state.capture_loop())
+    return runner, f"http://127.0.0.1:{port}"

patchright_cli/ref_registry.py

@@ -31,7 +31,7 @@ class RefRegistry:
         self.entries: dict[str, AriaRefEntry] = {}
         self._counter = 0
 
-    def parse(self, aria_text: str) -> str:
+    def parse(self, aria_text: str, max_depth: int | None = None) -> str:
         """Return annotated snapshot text with [ref=eN] tags inserted."""
         self.entries.clear()
         self._counter = 0
@@ -44,6 +44,12 @@ class RefRegistry:
                 result_lines.append(line)
                 continue
 
+            indent = len(line) - len(line.lstrip())
+            depth = indent // 2
+            if max_depth is not None and depth > max_depth:
+                result_lines.append(line)
+                continue
+
             role = m.group(1)
             name = m.group(2) or ""
 

patchright_cli/snapshot.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from patchright_cli.ref_registry import RefRegistry
 
 
-async def take_snapshot(page, root_element=None) -> tuple[str, RefRegistry]:
+async def take_snapshot(page, root_element=None, max_depth: int | None = None) -> tuple[str, RefRegistry]:
     """Take a DOM snapshot. Returns (annotated_text, registry).
 
     If root_element is provided, only snapshot the subtree under that element.
@@ -29,7 +29,7 @@ async def take_snapshot(page, root_element=None) -> tuple[str, RefRegistry]:
         return "# Empty page - no accessible elements found\n", RefRegistry()
 
     registry = RefRegistry()
-    annotated = registry.parse(aria_text)
+    annotated = registry.parse(aria_text, max_depth=max_depth)
     return annotated + "\n", registry
 
 

{patchright_cli-0.4.0.dist-info → patchright_cli-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchright-cli
-Version: 0.4.0
+Version: 0.4.1
 Summary: Anti-detect browser automation CLI using Patchright (undetected Playwright fork)
 Project-URL: Homepage, https://github.com/AhaiMk01/patchright-cli
 Project-URL: Repository, https://github.com/AhaiMk01/patchright-cli
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.9
 Requires-Dist: click
 Requires-Dist: patchright
 Requires-Dist: pyyaml

patchright_cli-0.4.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+patchright_cli/__init__.py,sha256=oB58iGqDXQVGaly01ZXz2e6NME0PUB_q3tsutDeGG-4,100
+patchright_cli/__main__.py,sha256=iVuBuI_rPOENLhffOEHoS7JWCDBQciqT1kPXjRuhbZ4,127
+patchright_cli/cli.py,sha256=NFNouWurV7Ccq6-yR6yaF9GfM3qtTxvtkS_X9Dn5PJE,19201
+patchright_cli/daemon.py,sha256=nYJLTVs3X0n7giCZ1xH7IQXg0K80-goEu7t1Fq0JaMA,63687
+patchright_cli/dashboard.py,sha256=aQHujW9tHTOQhbyqm4M6OknShLaJSnRFHFZRRfs3l20,4022
+patchright_cli/ref_registry.py,sha256=OeXJFdOkEaJdqWAquykve654u0mYByt3-SKatAO5pOk,2413
+patchright_cli/snapshot.py,sha256=mk3WO_caVIgVmUgb_NQok_wLrvYJhQ7dXPE59mHRtrk,1497
+patchright_cli-0.4.1.dist-info/METADATA,sha256=Q0nYW6Q-HF2zGAuhwD-IgrzqEc9cfeDzDya6zcyxMAM,15526
+patchright_cli-0.4.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+patchright_cli-0.4.1.dist-info/entry_points.txt,sha256=Syh904eOQA8ylakyqIvG4LmIHx3LMjgeNcnFap3O0NQ,59
+patchright_cli-0.4.1.dist-info/licenses/LICENSE,sha256=adszqL4YR4pQUrc7LeAFxeg5Mc2cvljXp7QPlzKVWm8,10760
+patchright_cli-0.4.1.dist-info/RECORD,,

patchright_cli-0.4.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-patchright_cli/__init__.py,sha256=C_CFSqu0FaTOqyo9f_La4N54hGykX-OR-EX9QBt-bjE,100
-patchright_cli/__main__.py,sha256=iVuBuI_rPOENLhffOEHoS7JWCDBQciqT1kPXjRuhbZ4,127
-patchright_cli/cli.py,sha256=FzHkMDl2mI4Moh6MVN0xfdyfoqJX2ubyttN8QQJct9Y,14259
-patchright_cli/daemon.py,sha256=Zwy35BFFzcXB9AX-Bz9Ms3YyqaBVlIyquTeegrnUfu8,54021
-patchright_cli/ref_registry.py,sha256=_RhBC0xcVUhghWJLqWXV3ycWngtVCEnozbX-FVZ_UXM,2171
-patchright_cli/snapshot.py,sha256=ZvJaikXEI9MOwBInI1rW0M3pFfla5bTFtGZYryQYM94,1446
-patchright_cli-0.4.0.dist-info/METADATA,sha256=Z6iUn8P_vfylXnzCHHrUiPtMZGjXjaVC1tWe1VGzdiM,15498
-patchright_cli-0.4.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-patchright_cli-0.4.0.dist-info/entry_points.txt,sha256=Syh904eOQA8ylakyqIvG4LmIHx3LMjgeNcnFap3O0NQ,59
-patchright_cli-0.4.0.dist-info/licenses/LICENSE,sha256=adszqL4YR4pQUrc7LeAFxeg5Mc2cvljXp7QPlzKVWm8,10760
-patchright_cli-0.4.0.dist-info/RECORD,,