patchright-cli 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

patchright_cli/__init__.py

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

patchright_cli/cli.py

@@ -64,14 +64,14 @@ COMMANDS_HELP = {
     "goto": "goto <url>           Navigate to URL",
     "click": "click <ref> [button]  Click element [--modifiers=Alt,Shift]",
     "dblclick": "dblclick <ref> [btn] Double-click [--modifiers=Alt,Shift]",
-    "fill": "fill <ref> <value>   Fill text into element",
-    "type": "type <text>          Type text via keyboard",
+    "fill": "fill <ref> <value>   Fill text into element [--submit]",
+    "type": "type <text>          Type text via keyboard [--submit]",
     "hover": "hover <ref>          Hover over element",
     "select": "select <ref> <value> Select dropdown option",
     "check": "check <ref>          Check checkbox/radio",
     "uncheck": "uncheck <ref>        Uncheck checkbox/radio",
-    "snapshot": "snapshot             Take accessibility snapshot",
-    "eval": "eval <expr>          Evaluate JavaScript",
+    "snapshot": "snapshot [ref]        Take accessibility snapshot",
+    "eval": "eval <expr>          Evaluate JavaScript [--file=F or stdin]",
     "screenshot": "screenshot [ref]     Save screenshot [--full-page] [--filename=F]",
     "drag": "drag <from> <to>     Drag element to target",
     "close": "close                Close browser session",
@@ -120,22 +120,23 @@ COMMANDS_HELP = {
     "sessionstorage-delete": "sessionstorage-delete <k> Delete sessionStorage item",
     "sessionstorage-clear": "sessionstorage-clear Clear sessionStorage",
     # Route
-    "route": "route <pattern> [--status=N] [--body=S] [--header=K:V] [--remove-header=H]  Mock requests",
+    "route": "route <pattern> [--status=N] [--body=S] [--content-type=T] [--header=K:V]  Mock requests",
     "route-list": "route-list           List active routes",
     "unroute": "unroute [pattern]    Remove route(s)",
+    "network-state-set": "network-state-set <state>  Set online/offline (online|offline)",
     # Run code
-    "run-code": "run-code <code>      Run raw JS in page context",
+    "run-code": "run-code <code>      Run raw JS in page context [--file=F or stdin]",
     # Tracing
     "tracing-start": "tracing-start        Start Playwright tracing",
     "tracing-stop": "tracing-stop         Stop tracing and save",
     # Video
     "video-start": "video-start          Start video recording",
-    "video-stop": "video-stop [file]    Stop recording and save",
+    "video-stop": "video-stop           Stop recording and save [--filename=F]",
     # PDF
     "pdf": "pdf [--filename=F]   Save page as PDF",
     # DevTools
-    "console": "console [level]      Show console messages",
-    "network": "network              Show network requests",
+    "console": "console [level]      Show console messages [--clear]",
+    "network": "network              Show network requests [--static] [--clear]",
     # Session
     "list": "list                 List sessions",
     "close-all": "close-all            Close all sessions",
@@ -153,6 +154,7 @@ def _print_help():
     click.echo("  --headless          Run headless (default: headed)")
     click.echo("  --persistent        Use persistent profile")
     click.echo("  --profile=<path>    Custom profile directory")
+    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("  --version           Show version")
@@ -207,7 +209,7 @@ def _print_help():
                 "sessionstorage-clear",
             ],
         ),
-        ("Route", ["route", "route-list", "unroute"]),
+        ("Route", ["route", "route-list", "unroute", "network-state-set"]),
         ("Code", ["run-code"]),
         ("Tracing", ["tracing-start", "tracing-stop"]),
         ("Video", ["video-start", "video-stop"]),
@@ -230,6 +232,7 @@ def main():
     headless = False
     persistent = False
     profile = None
+    proxy = None
     session_name = "default"
     port = DEFAULT_PORT
 
@@ -244,19 +247,32 @@ def main():
             persistent = True
         elif arg.startswith("--profile="):
             profile = arg.split("=", 1)[1]
-        elif arg.startswith("--profile") and i + 1 < len(argv):
+        elif arg == "--profile" and i + 1 < len(argv):
             i += 1
             profile = argv[i]
+        elif arg.startswith("--proxy="):
+            proxy = arg.split("=", 1)[1]
+        elif arg == "--proxy" and i + 1 < len(argv):
+            i += 1
+            proxy = argv[i]
         elif arg.startswith("-s="):
             session_name = arg.split("=", 1)[1]
         elif arg == "-s" and i + 1 < len(argv):
             i += 1
             session_name = argv[i]
         elif arg.startswith("--port="):
-            port = int(arg.split("=", 1)[1])
+            try:
+                port = int(arg.split("=", 1)[1])
+            except ValueError:
+                click.echo(f"Invalid port value: {arg}", err=True)
+                sys.exit(1)
         elif arg == "--port" and i + 1 < len(argv):
             i += 1
-            port = int(argv[i])
+            try:
+                port = int(argv[i])
+            except ValueError:
+                click.echo(f"Invalid port value: {argv[i]}", err=True)
+                sys.exit(1)
         elif arg in ("--version", "-v"):
             click.echo(f"patchright-cli {__version__}")
             sys.exit(0)
@@ -292,6 +308,27 @@ def main():
             positional_args.append(a)
     args = positional_args
 
+    # For eval/run-code: support --file=<path> and stdin via "-"
+    if command in ("eval", "run-code"):
+        file_opt = extra_opts.pop("file", None)
+        if file_opt:
+            # Read JS from file
+            try:
+                with open(file_opt, encoding="utf-8") as f:
+                    args = [f.read()]
+            except FileNotFoundError:
+                click.echo(f"File not found: {file_opt}", err=True)
+                sys.exit(1)
+        elif args and args[0] == "-":
+            # Read JS from stdin
+            args = [sys.stdin.read()]
+        elif not args and not sys.stdin.isatty():
+            # Piped input with no positional arg
+            args = [sys.stdin.read()]
+        if not args:
+            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}
     if headless:
@@ -300,6 +337,8 @@ def main():
         options["persistent"] = True
     if profile:
         options["profile"] = profile
+    if proxy:
+        options["proxy"] = proxy
 
     # Ensure daemon is running (auto-start for 'open', require for others)
     try:
@@ -309,17 +348,18 @@ def main():
             # Try connecting first; if fails, tell user to open
             import socket as _socket
 
+            sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
             try:
-                sock = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
                 sock.settimeout(1)
                 sock.connect(("127.0.0.1", port))
-                sock.close()
             except (ConnectionRefusedError, OSError, TimeoutError):
                 click.echo(
                     f"Daemon is not running on port {port}. Run 'patchright-cli open' first.",
                     err=True,
                 )
                 sys.exit(1)
+            finally:
+                sock.close()
     except RuntimeError as e:
         click.echo(str(e), err=True)
         sys.exit(1)

patchright_cli/daemon.py

@@ -44,6 +44,9 @@ class Session:
         self._pending_dialog_action: tuple | None = None
         self._profile_dir: str | None = None
         self._cdp_sessions: dict[int, object] = {}
+        self._video_cdp = None
+        self._video_frames: list[bytes] = []
+        self._video_recording: bool = False
 
     # -- internal helpers ---------------------------------------------------
 
@@ -54,8 +57,9 @@ class Session:
         self.context.on("page", lambda page: asyncio.ensure_future(self._on_new_page(page)))
 
     async def _on_new_page(self, page):
-        self.pages.append(page)
-        self.current_tab = len(self.pages) - 1
+        if page not in self.pages:
+            self.pages.append(page)
+            self.current_tab = len(self.pages) - 1
         await self._attach_page_listeners(page)
 
     async def _attach_page_listeners(self, page):
@@ -133,6 +137,7 @@ class DaemonState:
         headless: bool | None = None,
         persistent: bool = True,
         profile: str | None = None,
+        proxy: str | None = None,
         url: str | None = None,
     ) -> Session:
         if name in self.sessions:
@@ -147,14 +152,18 @@ 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:
+            launch_kwargs["proxy"] = {"server": proxy}
+
         context = await self.playwright.chromium.launch_persistent_context(
             profile_dir,
-            channel="chrome",
-            headless=use_headless,
-            no_viewport=True,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-            ],
+            **launch_kwargs,
         )
 
         pages = context.pages or []
@@ -259,6 +268,7 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 headless=headless,
                 persistent=options.get("persistent", True),
                 profile=options.get("profile"),
+                proxy=options.get("proxy"),
                 url=url,
             )
             return await _page_info(session, cwd)
@@ -286,6 +296,50 @@ 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":
+            closed = await state.close_session(session_name)
+            return {"success": True, "output": f"Session '{session_name}' closed." if closed else "Session not found."}
+
+        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:
+                s = state.sessions.get(n)
+                if s:
+                    try:
+                        for p in s.pages:
+                            try:
+                                await p.close()
+                            except Exception:
+                                pass
+                        await s.context.close()
+                    except Exception:
+                        pass
+                    state.sessions.pop(n, None)
+            if hasattr(state, "shutdown_event"):
+                state.shutdown_event.set()
+            return {"success": True, "output": f"Killed {len(names)} session(s) and stopping daemon."}
+
+        if page is None:
+            return {
+                "success": False,
+                "output": "No page open. Run 'tab-new' to create one, or 'close' and 'open' again.",
+            }
+
         # -- Navigation -----------------------------------------------------
         if cmd == "goto":
             await page.goto(args[0])
@@ -321,11 +375,15 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
         if cmd == "fill":
             elem = await _resolve_ref(session, page, args[0])
             await elem.fill(args[1])
+            if options.get("submit"):
+                await page.keyboard.press("Enter")
             return await _page_info(session, cwd)
 
         if cmd == "type":
             text = args[0] if args else ""
             await page.keyboard.type(text)
+            if options.get("submit"):
+                await page.keyboard.press("Enter")
             return await _page_info(session, cwd)
 
         if cmd == "hover":
@@ -356,7 +414,13 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
 
         # -- Snapshot -------------------------------------------------------
         if cmd == "snapshot":
-            yaml_text, session.ref_map = await take_snapshot(page)
+            element_ref = args[0] if args else None
+            if element_ref:
+                # Partial snapshot: scope JS to a specific element subtree
+                elem = await _resolve_ref(session, page, element_ref)
+                yaml_text, session.ref_map = await take_snapshot(page, root_element=elem)
+            else:
+                yaml_text, session.ref_map = await take_snapshot(page)
             fn = options.get("filename")
             if fn:
                 Path(fn).parent.mkdir(parents=True, exist_ok=True)
@@ -402,11 +466,6 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 await page.screenshot(path=str(filepath), full_page=full_page)
             return {"success": True, "output": f"Screenshot saved to {filepath}"}
 
-        # -- Close ----------------------------------------------------------
-        if cmd == "close":
-            closed = await state.close_session(session_name)
-            return {"success": True, "output": f"Session '{session_name}' closed." if closed else "Session not found."}
-
         # -- Keyboard -------------------------------------------------------
         if cmd == "press":
             await page.keyboard.press(args[0])
@@ -463,6 +522,7 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
             idx = int(args[0]) if args else session.current_tab
             if 0 <= idx < len(session.pages):
                 p = session.pages.pop(idx)
+                session._cdp_sessions.pop(id(p), None)
                 await p.close()
                 session.current_tab = max(0, min(session.current_tab, len(session.pages) - 1))
             return {"success": True, "output": f"Tab {idx} closed."}
@@ -501,9 +561,9 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 cookie["path"] = options.get("path", "/")
             else:
                 cookie["url"] = page.url
-            if options.get("httpOnly") or "httpOnly" in options:
+            if options.get("httpOnly"):
                 cookie["httpOnly"] = True
-            if options.get("secure") or "secure" in options:
+            if options.get("secure"):
                 cookie["secure"] = True
             if options.get("sameSite"):
                 cookie["sameSite"] = options["sameSite"]
@@ -564,34 +624,38 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                 if level_filter and m["type"] != level_filter:
                     continue
                 lines.append(f"[{m['type']}] {m['text']}")
+            if options.get("clear"):
+                session.console_messages.clear()
             return {"success": True, "output": "\n".join(lines) or "(no console messages)"}
 
         if cmd == "network":
+            include_static = bool(options.get("static"))
+            static_types = {"image", "font", "stylesheet", "script", "media"}
             lines = []
             for r in session.network_log[-50:]:
+                if not include_static and r["resource"] in static_types:
+                    continue
                 lines.append(f"{r['method']} {r['url']} [{r['resource']}]")
+            if options.get("clear"):
+                session.network_log.clear()
             return {"success": True, "output": "\n".join(lines) or "(no network requests)"}
 
-        # -- Session management ---------------------------------------------
-        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:
-                await state.close_session(n)
-            return {"success": True, "output": f"Killed {len(names)} session(s)."}
+        if cmd == "network-state-set":
+            state_val = args[0] if args else ""
+            if state_val not in ("online", "offline"):
+                return {"success": False, "output": "Usage: network-state-set <online|offline>"}
+            cdp = await page.context.new_cdp_session(page)
+            if state_val == "offline":
+                await cdp.send(
+                    "Network.emulateNetworkConditions",
+                    {"offline": True, "latency": 0, "downloadThroughput": -1, "uploadThroughput": -1},
+                )
+            else:
+                await cdp.send(
+                    "Network.emulateNetworkConditions",
+                    {"offline": False, "latency": 0, "downloadThroughput": -1, "uploadThroughput": -1},
+                )
+            return {"success": True, "output": f"Network state set to {state_val}."}
 
         # -- Dialog handling ------------------------------------------------
         if cmd == "dialog-accept":
@@ -637,7 +701,9 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
             # Apply cookies
             if state_data.get("cookies"):
                 await session.context.add_cookies(state_data["cookies"])
-            # Apply localStorage via JS
+            # Apply localStorage via JS (only works if page is on the matching origin)
+            ls_applied = 0
+            ls_skipped = 0
             for origin_data in state_data.get("origins", []):
                 origin = origin_data.get("origin", "")
                 ls = origin_data.get("localStorage", [])
@@ -646,7 +712,13 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
                         await page.evaluate(
                             f"() => localStorage.setItem({json.dumps(item['name'])}, {json.dumps(item['value'])})"
                         )
-            return {"success": True, "output": f"State loaded from {filepath}"}
+                    ls_applied += len(ls)
+                elif ls:
+                    ls_skipped += len(ls)
+            msg = f"State loaded from {filepath}"
+            if ls_skipped:
+                msg += f" (note: {ls_skipped} localStorage item(s) skipped — navigate to the matching origin first)"
+            return {"success": True, "output": msg}
 
         # -- Session storage ------------------------------------------------
         if cmd == "sessionstorage-list":
@@ -728,8 +800,7 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
         # -- Run code -------------------------------------------------------
         if cmd == "run-code":
             code = args[0] if args else ""
-            fn = f"async (page) => {{ {code} }}"
-            result = await page.evaluate(f"async () => {{ const page = window; {code} }}")
+            result = await page.evaluate(f"async () => {{ {code} }}")
             return {
                 "success": True,
                 "output": json.dumps(result, indent=2, default=str) if result is not None else "Code executed.",
@@ -751,19 +822,88 @@ async def handle_command(state: DaemonState, msg: dict) -> dict:
 
         # -- Video recording ------------------------------------------------
         if cmd == "video-start":
-            session._video_page = page
-            # Video requires a new context with record_video_dir
-            return {
-                "success": False,
-                "output": "Video recording requires starting a new session with video enabled. Use: open --video",
-            }
+            if session._video_recording:
+                return {"success": False, "output": "Video recording is already in progress."}
+            cdp = await page.context.new_cdp_session(page)
+            session._video_cdp = cdp
+            session._video_frames = []
+            session._video_recording = True
+
+            def _on_frame(event):
+                import base64
+
+                session._video_frames.append(base64.b64decode(event["data"]))
+                asyncio.ensure_future(cdp.send("Page.screencastFrameAck", {"sessionId": event["sessionId"]}))
+
+            cdp.on("Page.screencastFrame", _on_frame)
+            await cdp.send(
+                "Page.startScreencast", {"format": "jpeg", "quality": 80, "maxWidth": 1280, "maxHeight": 720}
+            )
+            return {"success": True, "output": "Video recording started."}
 
         if cmd == "video-stop":
-            if hasattr(session, "_video_page") and session._video_page and session._video_page.video:
-                path = await session._video_page.video.path()
-                dest = args[0] if args else str(path)
-                return {"success": True, "output": f"Video saved to {dest}"}
-            return {"success": False, "output": "No video recording in progress."}
+            if not session._video_recording or not session._video_cdp:
+                return {"success": False, "output": "No video recording in progress."}
+            try:
+                await session._video_cdp.send("Page.stopScreencast")
+            except Exception:
+                pass
+            session._video_recording = False
+            frames = session._video_frames
+            session._video_frames = []
+            session._video_cdp = None
+
+            if not frames:
+                return {"success": False, "output": "No video frames were captured."}
+
+            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)
+
+            fn = options.get("filename")
+
+            # Try ffmpeg for webm output, fall back to saving frames as images
+            video_path = snap_dir / (fn or f"video-{ts}.webm")
+            try:
+                import shutil
+                import tempfile
+
+                if not shutil.which("ffmpeg"):
+                    raise FileNotFoundError("ffmpeg not found")
+
+                with tempfile.TemporaryDirectory() as tmpdir:
+                    for i, frame_data in enumerate(frames):
+                        Path(tmpdir, f"frame-{i:06d}.jpg").write_bytes(frame_data)
+                    proc = await asyncio.create_subprocess_exec(
+                        "ffmpeg",
+                        "-y",
+                        "-framerate",
+                        "5",
+                        "-i",
+                        str(Path(tmpdir, "frame-%06d.jpg")),
+                        "-c:v",
+                        "libvpx",
+                        "-b:v",
+                        "1M",
+                        str(video_path),
+                        stdout=asyncio.subprocess.DEVNULL,
+                        stderr=asyncio.subprocess.DEVNULL,
+                    )
+                    await proc.wait()
+                    if proc.returncode != 0:
+                        raise RuntimeError("ffmpeg failed")
+                return {"success": True, "output": f"Video saved to {video_path} ({len(frames)} frames)"}
+            except (FileNotFoundError, RuntimeError):
+                # Fallback: save frames as individual images
+                frames_dir = snap_dir / f"video-{ts}-frames"
+                frames_dir.mkdir(parents=True, exist_ok=True)
+                for i, frame_data in enumerate(frames):
+                    (frames_dir / f"frame-{i:04d}.jpg").write_bytes(frame_data)
+                return {
+                    "success": True,
+                    "output": f"Saved {len(frames)} frames to {frames_dir}/ (install ffmpeg for video output)",
+                }
 
         # -- PDF ------------------------------------------------------------
         if cmd == "pdf":
@@ -840,6 +980,7 @@ async def run_daemon(port: int = DEFAULT_PORT, headless: bool = False):
     """Start the daemon TCP server."""
     state = DaemonState()
     state.default_headless = headless
+    state.shutdown_event = asyncio.Event()
 
     async def client_handler(reader, writer):
         await _handle_client(reader, writer, state)
@@ -850,7 +991,7 @@ async def run_daemon(port: int = DEFAULT_PORT, headless: bool = False):
     print(f"patchright-cli daemon listening on {addr[0]}:{addr[1]}", flush=True)
 
     # Handle graceful shutdown
-    shutdown_event = asyncio.Event()
+    shutdown_event = state.shutdown_event
 
     def _signal_handler():
         logger.info("Shutdown signal received")
@@ -862,12 +1003,11 @@ async def run_daemon(port: int = DEFAULT_PORT, headless: bool = False):
             loop.add_signal_handler(sig, _signal_handler)
 
     try:
-        if sys.platform == "win32":
-            # On Windows, asyncio signal handlers don't work; just serve forever
-            async with server:
-                await server.serve_forever()
-        else:
-            async with server:
+        async with server:
+            if sys.platform == "win32":
+                # On Windows, asyncio signal handlers don't work; use shutdown_event from kill-all
+                await shutdown_event.wait()
+            else:
                 await shutdown_event.wait()
     except (KeyboardInterrupt, asyncio.CancelledError):
         pass

patchright_cli/snapshot.py

@@ -48,7 +48,10 @@ _SNAPSHOT_JS = r"""
     }
 
     function isVis(el) {
-        if (!el.offsetParent && el.tagName !== "BODY" && el.tagName !== "HTML") return false;
+        if (!el.offsetParent && el.tagName !== "BODY" && el.tagName !== "HTML") {
+            try { const pos = getComputedStyle(el).position; if (pos !== "fixed" && pos !== "sticky") return false; }
+            catch(e) { return false; }
+        }
         try { const s = getComputedStyle(el); return s.display !== "none" && s.visibility !== "hidden" && s.opacity !== "0"; }
         catch(e) { return false; }
     }
@@ -115,6 +118,110 @@ _SNAPSHOT_JS = r"""
 })()
 """
 
+# Variant that takes a root element argument for partial snapshots
+_SNAPSHOT_ELEMENT_JS = r"""
+(rootEl) => {
+    const SKIP = new Set(["SCRIPT","STYLE","NOSCRIPT","SVG","LINK","META","BR","HR"]);
+    const INTERACTIVE = new Set(["A","BUTTON","INPUT","TEXTAREA","SELECT","DETAILS","SUMMARY","LABEL"]);
+    const SEMANTIC = new Set(["H1","H2","H3","H4","H5","H6","NAV","MAIN","HEADER","FOOTER","ARTICLE","SECTION","ASIDE","FORM","TABLE","UL","OL","LI","IMG","VIDEO","AUDIO","IFRAME"]);
+
+    rootEl.querySelectorAll("[data-patchright-ref]").forEach(el => el.removeAttribute("data-patchright-ref"));
+
+    function getRole(el) {
+        const ar = el.getAttribute && el.getAttribute("role");
+        if (ar) return ar;
+        const t = el.tagName;
+        const m = {A:"link",BUTTON:"button",TEXTAREA:"textbox",SELECT:"combobox",IMG:"img",TABLE:"table",FORM:"form",NAV:"navigation",MAIN:"main",HEADER:"banner",FOOTER:"contentinfo"};
+        if (m[t]) return m[t];
+        if (t === "INPUT") { const tp = (el.type||"text").toLowerCase(); return tp==="checkbox"?"checkbox":tp==="radio"?"radio":(tp==="submit"||tp==="button")?"button":"textbox"; }
+        if (t === "UL" || t === "OL") return "list";
+        if (t === "LI") return "listitem";
+        if (/^H[1-6]$/.test(t)) return "heading";
+        return t.toLowerCase();
+    }
+
+    function getName(el) {
+        const t = el.tagName;
+        const ar = el.getAttribute && el.getAttribute("aria-label");
+        if (ar) return ar.substring(0, 120);
+        if (t === "IMG") return (el.getAttribute("alt") || "").substring(0, 120);
+        if (t === "INPUT" || t === "TEXTAREA") return (el.getAttribute("placeholder") || "").substring(0, 80);
+        if (t === "A" || t === "BUTTON" || /^H[1-6]$/.test(t) || t === "LABEL" || t === "LI" || t === "SUMMARY")
+            return (el.innerText || "").replace(/\s+/g, " ").trim().substring(0, 120);
+        const ti = el.getAttribute && el.getAttribute("title");
+        if (ti) return ti.substring(0, 80);
+        return "";
+    }
+
+    function isVis(el) {
+        if (!el.offsetParent && el.tagName !== "BODY" && el.tagName !== "HTML") {
+            try { const pos = getComputedStyle(el).position; if (pos !== "fixed" && pos !== "sticky") return false; }
+            catch(e) { return false; }
+        }
+        try { const s = getComputedStyle(el); return s.display !== "none" && s.visibility !== "hidden" && s.opacity !== "0"; }
+        catch(e) { return false; }
+    }
+
+    function shouldTag(el) {
+        return INTERACTIVE.has(el.tagName) || SEMANTIC.has(el.tagName) || !!el.getAttribute("role") || !!el.getAttribute("data-testid") || !!getName(el);
+    }
+
+    const tw = document.createTreeWalker(rootEl, NodeFilter.SHOW_ELEMENT, {
+        acceptNode(n) {
+            if (SKIP.has(n.tagName)) return NodeFilter.FILTER_REJECT;
+            if (!isVis(n)) return NodeFilter.FILTER_REJECT;
+            return NodeFilter.FILTER_ACCEPT;
+        }
+    });
+
+    let counter = 0;
+    const flatList = [];
+    let node;
+    while (node = tw.nextNode()) {
+        if (shouldTag(node)) {
+            counter++;
+            const ref = "e" + counter;
+            node.setAttribute("data-patchright-ref", ref);
+            const role = getRole(node);
+            const name = getName(node);
+            const entry = { ref, role, name, tag: node.tagName };
+            if (node.tagName === "INPUT" || node.tagName === "TEXTAREA" || node.tagName === "SELECT") {
+                if (node.value) entry.value = node.value.substring(0, 200);
+                if (node.type === "checkbox" || node.type === "radio") entry.checked = node.checked;
+                if (node.disabled) entry.disabled = true;
+            }
+            if (node.tagName === "A" && node.href) entry.url = node.href.substring(0, 200);
+            if (/^H[1-6]$/.test(node.tagName)) entry.level = parseInt(node.tagName[1]);
+            flatList.push(entry);
+        }
+    }
+
+    function buildTree(el, depth) {
+        if (depth > 12 || !el || !el.tagName) return null;
+        if (SKIP.has(el.tagName)) return null;
+        const ref = el.getAttribute("data-patchright-ref");
+        const children = [];
+        for (const ch of el.children) {
+            if (!isVis(ch)) continue;
+            const c = buildTree(ch, depth + 1);
+            if (c) children.push(c);
+        }
+        if (!ref && !children.length) return null;
+        const out = {};
+        if (ref) {
+            const f = flatList.find(x => x.ref === ref);
+            if (f) Object.assign(out, f);
+            delete out.tag;
+        }
+        if (children.length) out.children = children;
+        return out;
+    }
+
+    const tree = buildTree(rootEl, 0) || { role: "element", name: "", children: [] };
+    return { tree, flatList };
+}
+"""
+
 
 def _walk_tree(node: dict, depth: int = 0) -> list[str]:
     """Recursively walk the parsed tree and produce YAML lines."""
@@ -158,11 +265,13 @@ def _yaml_escape(s: str) -> str:
     if any(
         c in s
         for c in (
+            "\\",
             ":",
             "#",
             "'",
             '"',
             "\n",
+            "\r",
             "[",
             "]",
             "{",
@@ -182,50 +291,45 @@ def _yaml_escape(s: str) -> str:
             "`",
         )
     ):
-        escaped = s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+        escaped = s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n").replace("\r", "\\r")
         return f'"{escaped}"'
     return s
 
 
-async def take_snapshot(page) -> tuple[str, dict[str, dict]]:
-    """Take a DOM snapshot. Returns (yaml_text, ref_map)."""
+async def take_snapshot(page, root_element=None) -> tuple[str, dict[str, dict]]:
+    """Take a DOM snapshot. Returns (yaml_text, ref_map).
+
+    If root_element is provided, only snapshot the subtree under that element.
+    """
     result = None
-    try:
-        result = await page.evaluate(_SNAPSHOT_JS, isolated_context=False)
-    except TypeError:
+    if root_element:
         try:
-            result = await page.evaluate(_SNAPSHOT_JS)
+            result = await root_element.evaluate(_SNAPSHOT_ELEMENT_JS)
+        except Exception:
+            pass
+    else:
+        try:
+            result = await page.evaluate(_SNAPSHOT_JS, isolated_context=False)
+        except TypeError:
+            try:
+                result = await page.evaluate(_SNAPSHOT_JS)
+            except Exception:
+                pass
         except Exception:
             pass
-    except Exception:
-        pass
 
     if not result or not result.get("tree"):
         return "# Empty page - no accessible elements found\n", {}
 
     flat_list = result.get("flatList", [])
+    tree = result.get("tree", {})
 
     refs: dict[str, dict] = {}
-    lines: list[str] = []
     for item in flat_list:
         refs[item["ref"]] = item
-        lines.append(f"- ref: {item['ref']}")
-        lines.append(f"  role: {item.get('role', '')}")
-        name = item.get("name", "")
-        if name:
-            lines.append(f"  name: {_yaml_escape(name)}")
-        for key in ("value", "url"):
-            val = item.get(key, "")
-            if val:
-                lines.append(f"  {key}: {_yaml_escape(str(val))}")
-        if item.get("checked") is not None:
-            lines.append(f"  checked: {str(item['checked']).lower()}")
-        if item.get("disabled"):
-            lines.append("  disabled: true")
-        if item.get("level") is not None:
-            lines.append(f"  level: {item['level']}")
-
-    yaml_text = "\n".join(lines) + "\n"
+
+    lines = _walk_tree(tree)
+    yaml_text = "\n".join(lines) + "\n" if lines else "# Empty page - no accessible elements found\n"
     return yaml_text, refs
 
 

{patchright_cli-0.2.0.dist-info → patchright_cli-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchright-cli
-Version: 0.2.0
+Version: 0.3.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
@@ -78,25 +78,22 @@ curl -s https://raw.githubusercontent.com/AhaiMk01/patchright-cli/main/docs/inst
 > [!IMPORTANT]
 > **Requirements:** Python 3.10+ and Google Chrome
 
-<details>
-<summary><b>Manual Install</b></summary>
-
 ```bash
-# 1. Install the package
-pip install patchright-cli        # or: uv tool install patchright-cli
+# Recommended — always runs latest version, no install needed
+uvx patchright-cli open https://example.com
+```
 
-# 2. Install the Patchright browser (fallback if Chrome is not found)
-python -m patchright install chromium
+<details>
+<summary><b>Other install methods</b></summary>
 
-# 3. Verify
+```bash
+# Via pip
+pip install patchright-cli
 patchright-cli open https://example.com
 patchright-cli close
-```
 
-Or run without installing (like npx):
-
-```bash
-uvx patchright-cli open https://example.com
+# Update
+pip install --upgrade patchright-cli
 ```
 
 **From source:**
@@ -167,16 +164,21 @@ patchright-cli click <ref> --modifiers=Alt,Shift
 patchright-cli dblclick <ref>          # Double-click
 patchright-cli dblclick <ref> --modifiers=Shift
 patchright-cli fill <ref> <value>      # Fill text input
+patchright-cli fill <ref> <value> --submit  # Fill and press Enter
 patchright-cli type <text>             # Type via keyboard
+patchright-cli type <text> --submit    # Type and press Enter
 patchright-cli hover <ref>             # Hover over element
 patchright-cli select <ref> <value>    # Select dropdown option
 patchright-cli check <ref>             # Check checkbox
 patchright-cli uncheck <ref>           # Uncheck checkbox
 patchright-cli drag <from> <to>        # Drag and drop
 patchright-cli snapshot                # Accessibility snapshot
+patchright-cli snapshot <ref>          # Snapshot element subtree
 patchright-cli snapshot --filename=f   # Save to custom path
 patchright-cli eval <expr>             # Run JavaScript
+patchright-cli eval --file=script.js   # Run JS from file
 patchright-cli run-code <code>         # Run JS with return value
+patchright-cli run-code --file=f.js    # Run JS from file
 patchright-cli screenshot              # Page screenshot
 patchright-cli screenshot --full-page  # Full scrollable page
 patchright-cli screenshot <ref>        # Element screenshot
@@ -269,18 +271,30 @@ patchright-cli unroute "**/*.jpg"
 patchright-cli unroute                 # Remove all routes
 ```
 
-### Tracing / PDF
+### Tracing / Video / PDF
 ```bash
 patchright-cli tracing-start
 patchright-cli tracing-stop            # Saves .zip trace file
+patchright-cli video-start             # Start video recording (CDP screencast)
+patchright-cli video-stop              # Stop and save video (requires ffmpeg for .webm)
+patchright-cli video-stop --filename=recording.webm
 patchright-cli pdf --filename=page.pdf
 ```
 
+### Network
+```bash
+patchright-cli network                 # Network request log
+patchright-cli network --static        # Include static resources
+patchright-cli network --clear         # Clear log after printing
+patchright-cli network-state-set offline  # Simulate offline mode
+patchright-cli network-state-set online   # Restore connectivity
+```
+
 ### DevTools
 ```bash
 patchright-cli console                 # All console messages
 patchright-cli console warning         # Filter by level
-patchright-cli network                 # Network request log
+patchright-cli console --clear         # Clear after printing
 ```
 
 ### Sessions

patchright_cli-0.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+patchright_cli/__init__.py,sha256=EPqY-eBKEojjl1y9dwsndFlrKpBqB0Wz6OBMfewzVWE,100
+patchright_cli/__main__.py,sha256=iVuBuI_rPOENLhffOEHoS7JWCDBQciqT1kPXjRuhbZ4,127
+patchright_cli/cli.py,sha256=pbwyLdszogGpgSiCEBW5lrsTssOEJaQzbbx7o1HduL4,14137
+patchright_cli/daemon.py,sha256=AhGUiiuvAH197sDMhBsHvvDvB8YMQiYmX4XD4ie4oWM,44323
+patchright_cli/snapshot.py,sha256=JuXO3dN6-JNSQ0-lLEXIkg3YqGXW6Ul4I6KskdPygtQ,13621
+patchright_cli-0.3.1.dist-info/METADATA,sha256=Va7G26o7qU29yC0vcF3yZFsi6BVjxuchtviG5Nsdc0E,15498
+patchright_cli-0.3.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+patchright_cli-0.3.1.dist-info/entry_points.txt,sha256=Syh904eOQA8ylakyqIvG4LmIHx3LMjgeNcnFap3O0NQ,59
+patchright_cli-0.3.1.dist-info/licenses/LICENSE,sha256=adszqL4YR4pQUrc7LeAFxeg5Mc2cvljXp7QPlzKVWm8,10760
+patchright_cli-0.3.1.dist-info/RECORD,,

patchright_cli-0.2.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-patchright_cli/__init__.py,sha256=5FxYv6u1EbGSdJfoc1ZD217_KGIHbI5M8LjoKfv0M1w,100
-patchright_cli/__main__.py,sha256=iVuBuI_rPOENLhffOEHoS7JWCDBQciqT1kPXjRuhbZ4,127
-patchright_cli/cli.py,sha256=wR5v8OlXUBkHFW3rkBuEcG4wDq4wHHjMSifYL8l_Lfg,12415
-patchright_cli/daemon.py,sha256=OtM3Gsm36F3tCDH6y5X8wEA2igp-cpsTmuvjl4ItDuI,38273
-patchright_cli/snapshot.py,sha256=KTIcRyUl2kUFs3yfpPi3YVvz17zRjr4rcfqFgiyt1PM,8906
-patchright_cli-0.2.0.dist-info/METADATA,sha256=VFBWzcV2Tzb3iIowYb5EFwudQjGoZehi2UWmAXy2nec,14710
-patchright_cli-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-patchright_cli-0.2.0.dist-info/entry_points.txt,sha256=Syh904eOQA8ylakyqIvG4LmIHx3LMjgeNcnFap3O0NQ,59
-patchright_cli-0.2.0.dist-info/licenses/LICENSE,sha256=adszqL4YR4pQUrc7LeAFxeg5Mc2cvljXp7QPlzKVWm8,10760
-patchright_cli-0.2.0.dist-info/RECORD,,