patchright-cli 0.2.0__tar.gz → 0.3.0__tar.gz

patchright_cli-0.3.0/CLAUDE.md

@@ -0,0 +1,55 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+patchright-cli is an anti-detect browser automation CLI built on [Patchright](https://github.com/kaliiiiiiiiii/patchright-python) (undetected Playwright fork). It provides the same command interface as Microsoft's playwright-cli but bypasses bot detection (Akamai, Cloudflare, etc.).
+
+## Development Setup
+
+```bash
+uv venv && uv pip install -e .
+python -m patchright install chromium
+pre-commit install
+```
+
+## Commands
+
+```bash
+# Lint (pre-commit runs ruff --fix + ruff-format)
+pre-commit run --all-files
+
+# Run the CLI directly
+python -m patchright_cli <command> [args...]
+# or after install:
+patchright-cli <command> [args...]
+```
+
+There are no automated tests yet — changes are tested manually via the CLI.
+
+## Architecture
+
+Three-component client-daemon-browser design:
+
+```
+CLI (cli.py) --TCP:9321--> Daemon (daemon.py) --Patchright--> Chrome
+```
+
+- **CLI (`src/patchright_cli/cli.py`)**: Stateless thin client. Parses argv manually (not click subcommands), builds a JSON `{command, args, options, cwd}` message, sends it over a length-prefixed TCP socket to the daemon, prints the response, and exits. All commands are defined in the `COMMANDS_HELP` dict and `ALL_COMMANDS` list.
+
+- **Daemon (`src/patchright_cli/daemon.py`)**: Long-running async process managing browser sessions. Auto-spawned on `open` via `ensure_daemon_running()` which launches a subprocess. Uses `DaemonState` → multiple `Session` objects, each owning a Patchright persistent browser context. Command dispatch is a large `handle_command()` function with if/elif branches. Console capture uses CDP sessions (not Playwright's `page.on('console')`) because Patchright suppresses it.
+
+- **Snapshot (`src/patchright_cli/snapshot.py`)**: Two-pass DOM scanner injected as JavaScript: Pass 1 uses TreeWalker to assign `data-patchright-ref` attributes (`e1`, `e2`, ...) in document order; Pass 2 builds a nested tree. Python side converts to flat YAML. Snapshots are saved to `.patchright-cli/` in the caller's cwd.
+
+## Key Design Decisions
+
+- Always uses persistent browser context (`launch_persistent_context`) with real Chrome (`channel="chrome"`), not Chromium
+- Headed by default (headless is more detectable)
+- Default daemon port: 9321, profiles stored at `~/.patchright-cli/profiles/<session-name>`
+- CLI-daemon protocol: length-prefixed (4-byte big-endian `!I`) JSON over TCP
+- CLI parses argv manually in `main()` — click is only used for `click.echo()`, not subcommands. New commands must be added to both `COMMANDS_HELP` dict and the `handle_command()` if/elif chain in daemon.py
+- Version must be updated in both `pyproject.toml` and `src/patchright_cli/__init__.py` (then run `uv lock` to sync the lock file)
+- `python -m patchright_cli` works via `__main__.py`
+- Uses hatchling as build backend, ruff for linting (line-length=120, target py310)
+- Ruff rules: E, F, I, W, UP, B, SIM (ignores E501, SIM105, E402)

{patchright_cli-0.2.0 → patchright_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchright-cli
-Version: 0.2.0
+Version: 0.3.0
 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.2.0 → patchright_cli-0.3.0}/README.md

@@ -50,25 +50,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:**
@@ -139,16 +136,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
@@ -241,18 +243,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.2.0 → patchright_cli-0.3.0}/docs/installation.md

@@ -7,50 +7,56 @@
 
 ## Install
 
-### Step 1: Install the package
+### Step 1: Ensure uv is installed
 
-```bash
-pip install patchright-cli
-```
-
-Or with uv (recommended):
+uv is the recommended Python package manager. Check if it's installed:
 
 ```bash
-uv tool install patchright-cli
+uv --version
 ```
 
-### Step 2: Install the Patchright browser
-
-Patchright needs to download its patched Chromium binary on first use:
+If not installed:
 
 ```bash
 # macOS / Linux
-python -m patchright install chromium
+curl -LsSf https://astral.sh/uv/install.sh | sh
 
 # Windows (PowerShell)
-python -m patchright install chromium
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+### Step 2: Run patchright-cli
+
+With uvx (recommended — always uses the latest version, no install needed):
 
-# Or if using uv
-uv run python -m patchright install chromium
+```bash
+uvx patchright-cli open https://example.com
+uvx patchright-cli snapshot
+uvx patchright-cli close
 ```
 
-> **Note:** If you have Google Chrome installed, patchright-cli will use it directly via `channel="chrome"` for maximum stealth. The Chromium install above is a fallback.
+> **Note:** If you have Google Chrome installed, patchright-cli will use it directly via `channel="chrome"` for maximum stealth. If Chrome is not found, install the Patchright fallback browser: `uvx patchright install chromium`
 
 ### Step 3: Verify
 
 ```bash
-patchright-cli --version
-patchright-cli open https://example.com
-patchright-cli eval "document.title"
-patchright-cli close
+uvx patchright-cli --version
+uvx patchright-cli open https://example.com
+uvx patchright-cli eval "document.title"
+uvx patchright-cli close
 ```
 
-### Quick one-liner (no install)
+<details>
+<summary><b>Alternative: pip install</b></summary>
 
 ```bash
-uvx patchright-cli open https://example.com
+pip install patchright-cli
+patchright-cli open https://example.com
+patchright-cli close
 ```
 
+</details>
+
 ### Troubleshooting
 
 If you see `browser not found` errors:
@@ -62,16 +68,13 @@ google-chrome --version    # Linux
 reg query "HKLM\SOFTWARE\Google\Chrome\BLBeacon" /v version   # Windows
 
 # If no Chrome, install the Patchright browser
-python -m patchright install chromium
+uvx patchright install chromium
 ```
 
 If you see `patchright-cli: command not found`:
 
 ```bash
-# Ensure pip scripts directory is in PATH
-python -m patchright_cli --help
-
-# Or use uvx (no PATH needed)
+# Use uvx instead (no install or PATH needed)
 uvx patchright-cli --help
 ```
 
@@ -148,25 +151,25 @@ curl -sL https://raw.githubusercontent.com/AhaiMk01/patchright-cli/main/skills/p
 
 ```bash
 # Open an anti-bot-protected site
-patchright-cli open https://protected-site.com
+uvx patchright-cli open https://protected-site.com
 
 # Take a snapshot to see interactive elements
-patchright-cli snapshot
+uvx patchright-cli snapshot
 
 # Interact with elements using refs from the snapshot
-patchright-cli fill e3 "username"
-patchright-cli fill e4 "password"
-patchright-cli click e5
+uvx patchright-cli fill e3 "username"
+uvx patchright-cli fill e4 "password"
+uvx patchright-cli click e5
 
 # Save login state for reuse
-patchright-cli state-save auth.json
+uvx patchright-cli state-save auth.json
 
 # Later, restore the session
-patchright-cli open https://protected-site.com --persistent
-patchright-cli state-load auth.json
+uvx patchright-cli open https://protected-site.com --persistent
+uvx patchright-cli state-load auth.json
 
 # Close when done
-patchright-cli close
+uvx patchright-cli close
 ```
 
 ## All Commands

{patchright_cli-0.2.0 → patchright_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "patchright-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Anti-detect browser automation CLI using Patchright (undetected Playwright fork)"
 license = "Apache-2.0"
 requires-python = ">=3.10"

{patchright_cli-0.2.0 → patchright_cli-0.3.0}/skills/patchright-cli/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: patchright-cli
 description: Anti-detect browser automation using Patchright (undetected Playwright fork). Use when you need to interact with websites that block regular Playwright/Chrome DevTools, such as Akamai/Cloudflare-protected sites. Provides the same command interface as playwright-cli but bypasses bot detection.
-allowed-tools: Bash(patchright-cli:*), Bash(python -m patchright_cli:*)
 ---
 
 # Anti-Detect Browser Automation with patchright-cli
@@ -47,21 +46,28 @@ patchright-cli open --headless                 # Run headless
 patchright-cli open --profile=/path/to/dir     # Custom profile directory
 patchright-cli goto https://example.com
 patchright-cli type "search query"
+patchright-cli type "search query" --submit    # Type and press Enter
 patchright-cli click e3
 patchright-cli click e3 right                  # Right-click
 patchright-cli click e3 --modifiers=Alt,Shift  # Click with modifiers
 patchright-cli dblclick e7
+patchright-cli dblclick e7 --modifiers=Shift   # Double-click with modifiers
 patchright-cli fill e5 "user@example.com"
+patchright-cli fill e5 "query" --submit        # Fill and press Enter
 patchright-cli drag e2 e8
 patchright-cli hover e4
 patchright-cli select e9 "option-value"
 patchright-cli check e12
 patchright-cli uncheck e12
 patchright-cli snapshot
+patchright-cli snapshot e3                     # Partial snapshot of element subtree
 patchright-cli snapshot --filename=snap.yml    # Save to custom path
 patchright-cli eval "document.title"
-patchright-cli eval "el => el.textContent" e5
+patchright-cli eval --file=script.js           # Read JS from file (avoids shell quoting)
+cat script.js | patchright-cli eval            # Read JS from stdin
 patchright-cli run-code "return document.querySelectorAll('a').length"
+patchright-cli run-code --file=script.js       # Read JS from file
+cat script.js | patchright-cli run-code        # Read JS from stdin
 patchright-cli screenshot
 patchright-cli screenshot e3                   # Element screenshot
 patchright-cli screenshot --filename=page.png
@@ -171,6 +177,8 @@ patchright-cli route "**/*" --remove-header=Content-Type
 patchright-cli route-list
 patchright-cli unroute "**/*.jpg"
 patchright-cli unroute                         # Remove all routes
+patchright-cli network-state-set offline       # Simulate offline mode
+patchright-cli network-state-set online        # Restore connectivity
 ```
 
 ### Tracing / Video / PDF
@@ -178,6 +186,9 @@ patchright-cli unroute                         # Remove all routes
 ```bash
 patchright-cli tracing-start
 patchright-cli tracing-stop
+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=rec.webm  # Save to custom path
 patchright-cli pdf --filename=page.pdf
 ```
 
@@ -185,8 +196,11 @@ patchright-cli pdf --filename=page.pdf
 
 ```bash
 patchright-cli console
-patchright-cli console warning
-patchright-cli network
+patchright-cli console warning                 # Filter by level
+patchright-cli console --clear                 # Clear message buffer after printing
+patchright-cli network                         # Show requests (excludes static resources)
+patchright-cli network --static                # Include images, fonts, scripts, etc.
+patchright-cli network --clear                 # Clear network log after printing
 ```
 
 ### Sessions
@@ -199,13 +213,33 @@ patchright-cli -s=mysession close
 # List all sessions
 patchright-cli list
 # Close all browsers
-patchright-cli close-all
-patchright-cli kill-all
+patchright-cli close-all                       # Gracefully close all sessions
+patchright-cli kill-all                        # Force-kill all sessions and stop daemon
 # Delete persistent profile data
 patchright-cli delete-data
 patchright-cli -s=mysession delete-data
 ```
 
+## Running JavaScript (eval / run-code)
+
+**Always use `--file` for `eval` and `run-code`**. Inline JS breaks because quotes get mangled through bash → uvx → python shell layers.
+
+```bash
+# WRONG — nested quotes break through shell layers
+patchright-cli eval "JSON.stringify({x: document.querySelector('a[href*=\"foo\"]')})"
+
+# RIGHT — write JS to a temp file, pass with --file
+cat > /tmp/check.js << 'JSEOF'
+JSON.stringify({x: !!document.querySelector('a[href*="foo"]')})
+JSEOF
+patchright-cli eval --file=/tmp/check.js
+
+# RIGHT — pipe via stdin (for simple expressions only)
+echo 'document.title' | patchright-cli eval
+```
+
+`--file` also avoids the OS argument length limit (`ARG_MAX`) for large scripts.
+
 ## Anti-detect features
 
 - Uses real Chrome browser (not Chromium)
@@ -229,11 +263,12 @@ After each command, outputs page state and a YAML snapshot file:
 ## Installation
 
 ```bash
-cd patchright-cli && uv pip install -e .
-```
+# Recommended — always runs latest version, no install needed
+uvx patchright-cli open https://example.com
 
-Or run directly:
-```bash
-python -m patchright_cli open https://example.com
-python -m patchright_cli click e1
+# Or install via pip
+pip install patchright-cli
+
+# Or from source
+cd patchright-cli && uv pip install -e .
 ```

{patchright_cli-0.2.0 → patchright_cli-0.3.0}/src/patchright_cli/__init__.py

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

{patchright_cli-0.2.0 → patchright_cli-0.3.0}/src/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",
@@ -207,7 +208,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"]),
@@ -244,7 +245,7 @@ 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("-s="):
@@ -253,10 +254,18 @@ def main():
             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 +301,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:
@@ -309,17 +339,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-0.2.0 → patchright_cli-0.3.0}/src/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):
@@ -286,6 +290,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 +369,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 +408,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 +460,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 +516,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 +555,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 +618,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 +695,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 +706,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 +794,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 +816,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 +974,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 +985,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 +997,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-0.2.0 → patchright_cli-0.3.0}/src/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 → patchright_cli-0.3.0}/uv.lock

@@ -6,7 +6,7 @@ name = "click"
 version = "8.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "platform_system == 'Windows'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065 }
 wheels = [
@@ -103,7 +103,7 @@ wheels = [
 
 [[package]]
 name = "patchright-cli"
-version = "0.1.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },