drissionpage-cli 0.1.5__tar.gz → 0.2.0__tar.gz

{drissionpage_cli-0.1.5 → drissionpage_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drissionpage-cli
-Version: 0.1.5
+Version: 0.2.0
 Summary: DrissionPage CLI - Token-efficient browser automation for coding agents
 Author: DrissionPage-MCP Contributors
 License: Apache-2.0
@@ -75,13 +75,15 @@ cd DrissionPage-MCP/DrissionPage-cli
 pip install -e .
 ```
 
-After installation the `drissionpage-cli` command is available globally:
+After installation both `drissionpage-cli` and the shortcut `dp-cli` are available globally:
 
 ```bash
-drissionpage-cli --version
-drissionpage-cli --help
+dp-cli --version
+dp-cli --help
 ```
 
+`dp-cli` and `drissionpage-cli` are identical — use whichever you prefer.
+
 ### Install skills for Claude Code
 
 ```bash
@@ -170,6 +172,29 @@ For a fully isolated throwaway session (no persistent state):
 drissionpage-cli open --sandbox
 ```
 
+### Capture mode (full page archive)
+
+```bash
+drissionpage-cli open https://example.com --capture
+```
+
+Creates a timestamped folder `capture-<ts>/` in the current directory containing:
+
+| File | Contents |
+|------|----------|
+| `snapshot.html` | Page HTML at load-complete time |
+| `traffic.json` | Manifest of all requests (url, method, status, content_type, file) |
+| `0001_*.{ext}` … | Every response body saved as an individual file |
+
+Captured file types include: HTML, CSS, JS, JSON, images (jpg, png, webp, gif, svg, avif, bmp, ico), audio (mp3, ogg, wav, aac, flac), and video (mp4, webm, ogv, mov).
+
+```
+[capture] folder   → /project/capture-2026-04-14T16-06-30
+[capture] snapshot → snapshot.html
+[capture] traffic  → traffic.json  (125 requests)
+[capture] media    → 63 files (images/audio/video)
+```
+
 ## Commands
 
 ### Core

{drissionpage_cli-0.1.5 → drissionpage_cli-0.2.0}/README.md

@@ -49,13 +49,15 @@ cd DrissionPage-MCP/DrissionPage-cli
 pip install -e .
 ```
 
-After installation the `drissionpage-cli` command is available globally:
+After installation both `drissionpage-cli` and the shortcut `dp-cli` are available globally:
 
 ```bash
-drissionpage-cli --version
-drissionpage-cli --help
+dp-cli --version
+dp-cli --help
 ```
 
+`dp-cli` and `drissionpage-cli` are identical — use whichever you prefer.
+
 ### Install skills for Claude Code
 
 ```bash
@@ -144,6 +146,29 @@ For a fully isolated throwaway session (no persistent state):
 drissionpage-cli open --sandbox
 ```
 
+### Capture mode (full page archive)
+
+```bash
+drissionpage-cli open https://example.com --capture
+```
+
+Creates a timestamped folder `capture-<ts>/` in the current directory containing:
+
+| File | Contents |
+|------|----------|
+| `snapshot.html` | Page HTML at load-complete time |
+| `traffic.json` | Manifest of all requests (url, method, status, content_type, file) |
+| `0001_*.{ext}` … | Every response body saved as an individual file |
+
+Captured file types include: HTML, CSS, JS, JSON, images (jpg, png, webp, gif, svg, avif, bmp, ico), audio (mp3, ogg, wav, aac, flac), and video (mp4, webm, ogv, mov).
+
+```
+[capture] folder   → /project/capture-2026-04-14T16-06-30
+[capture] snapshot → snapshot.html
+[capture] traffic  → traffic.json  (125 requests)
+[capture] media    → 63 files (images/audio/video)
+```
+
 ## Commands
 
 ### Core

{drissionpage_cli-0.1.5 → drissionpage_cli-0.2.0}/drissionpage_cli/__init__.py

@@ -9,11 +9,14 @@ Designed for token-efficient browser automation by coding agents.
 import argparse
 import json
 import os
+import re
+import shutil
 import signal
 import sys
 import time
 import traceback
 from pathlib import Path
+from urllib.parse import urlparse
 
 from importlib.metadata import version as _pkg_version, PackageNotFoundError as _PackageNotFoundError
 try:
@@ -21,6 +24,10 @@ try:
 except _PackageNotFoundError:
     __version__ = "unknown"
 
+# Apply runtime patches for Chrome compatibility before any DrissionPage usage.
+from drissionpage_cli._compat import apply_patches as _apply_patches
+_apply_patches()
+
 # Session storage directory — home-based so profile and state persist across
 # different working directories.
 CLI_DIR = Path(os.environ.get("DRISSIONPAGE_CLI_DIR", str(Path.home() / ".drissionpage-cli")))
@@ -29,6 +36,55 @@ SESSIONS_FILE = CLI_DIR / "sessions.json"
 # Default CDP port — drissionpage-cli owns this port exclusively
 DEFAULT_PORT = int(os.environ.get("DRISSIONPAGE_CLI_PORT", "9222"))
 
+_BROWSER_CANDIDATES = {
+    "chrome": [
+        "google-chrome-stable",
+        "google-chrome",
+        "chrome",
+    ],
+    "chromium": [
+        "chromium-browser",
+        "chromium",
+    ],
+    "edge": [
+        "microsoft-edge-stable",
+        "microsoft-edge",
+        "msedge",
+    ],
+}
+
+_BROWSER_SEARCH_ORDER = ["chrome", "chromium", "edge"]
+
+
+def _find_browser_path(browser=None):
+    """Return the path to a Chromium-family binary.
+
+    *browser* can be ``"chrome"``, ``"chromium"``, or ``"edge"``.
+    When *None*, tries all families in order and returns the first hit.
+    """
+    if browser:
+        key = browser.lower()
+        candidates = _BROWSER_CANDIDATES.get(key)
+        if not candidates:
+            raise RuntimeError(
+                f"Unknown browser '{browser}'. "
+                f"Choose from: {', '.join(_BROWSER_CANDIDATES)}"
+            )
+        for name in candidates:
+            p = shutil.which(name)
+            if p:
+                return p
+        raise RuntimeError(
+            f"Browser '{browser}' not found on PATH. "
+            f"Looked for: {', '.join(candidates)}"
+        )
+    for key in _BROWSER_SEARCH_ORDER:
+        for name in _BROWSER_CANDIDATES[key]:
+            p = shutil.which(name)
+            if p:
+                return p
+    return None
+
 
 def ensure_cli_dir():
     CLI_DIR.mkdir(parents=True, exist_ok=True)
@@ -67,17 +123,55 @@ def _kill_session(sessions, session_name):
         try:
             os.kill(pid, signal.SIGTERM)
             time.sleep(0.5)
-        except (ProcessLookupError, PermissionError):
+        except (ProcessLookupError, PermissionError, OSError):
             pass
     del sessions[session_name]
     _save_sessions(sessions)
 
 
-def _cli_profile_path():
-    """Return the persistent Chrome profile directory managed by drissionpage-cli."""
+def _snap_name(path):
+    """Return the snap package name if *path* is a snap binary, else None.
+
+    Snap binaries live under ``/snap/bin/<name>`` (symlink to ``/usr/bin/snap``)
+    or ``/snap/<name>/...``.  We check the original path (not resolved) because
+    resolve() follows the symlink to ``/usr/bin/snap``.
+    """
+    if not path:
+        return None
+    p = str(Path(path))
+    # /snap/bin/<name>
+    if p.startswith("/snap/bin/"):
+        return Path(p).name
+    # /snap/<name>/current/... or /snap/<name>/<rev>/...
+    parts = Path(p).parts
+    if len(parts) >= 3 and parts[1] == "snap" and parts[2] != "bin":
+        return parts[2]
+    return None
+
+
+def _cli_profile_path(browser_path=None):
+    """Return the persistent profile directory managed by drissionpage-cli.
+
+    Snap-packaged browsers cannot write to arbitrary home-directory paths due
+    to AppArmor confinement, so we use ``~/snap/<name>/common/drissionpage-cli``
+    instead.
+    """
+    name = _snap_name(browser_path)
+    if name:
+        return Path.home() / "snap" / name / "common" / "drissionpage-cli"
     return CLI_DIR / "profile"
 
 
+def _apply_chrome146_fix(page):
+    """No-op. Kept for call-site compatibility.
+
+    The Chrome 147+ viewport fix is now handled by the monkey-patch in
+    ``_compat.py`` which filters out ``chrome://newtab-footer/`` during
+    target selection, applied at import time.
+    """
+    pass
+
+
 def _get_page(session_name, create=False, options=None):
     """Get or create a ChromiumPage for the given session.
 
@@ -102,6 +196,7 @@ def _get_page(session_name, create=False, options=None):
             co.headless(info.get("headless", False))
             try:
                 page = ChromiumPage(addr_or_opts=co)
+                _apply_chrome146_fix(page)
                 if not create:
                     return page
                 # create=True but session is alive — close old one first
@@ -139,14 +234,25 @@ def _get_page(session_name, create=False, options=None):
     explicit_port = options and options.get("port")
     is_headless = options.get("headless", False) if options else False
 
+    # Resolve browser binary first — profile path depends on whether it's a
+    # snap package (AppArmor confinement restricts writable paths).
+    browser_path = (options and options.get("browser_path")) or None
+    if not browser_path:
+        browser_path = _find_browser_path(
+            options.get("browser") if options else None
+        )
+
     co = ChromiumOptions()
 
+    if browser_path:
+        co.set_browser_path(browser_path)
+
     if sandbox:
         # Isolated profile: random port + temporary user data dir managed by DrissionPage.
         # State is not persisted — the temp dir is cleaned up when Chrome exits.
         co.auto_port()
     else:
-        # Persistent profile: fixed port + CLI-managed profile at ~/.drissionpage-cli/profile.
+        # Persistent profile: fixed port + CLI-managed profile.
         # Works in both headed and headless mode — Chrome 136+ only blocks remote debugging
         # on the OS-default profile path, not on custom paths.
         port = explicit_port or DEFAULT_PORT
@@ -158,15 +264,16 @@ def _get_page(session_name, create=False, options=None):
             )
         co.set_local_port(port)
 
-        profile_path = (options and options.get("user_data_path")) or str(_cli_profile_path())
-        _cli_profile_path().mkdir(parents=True, exist_ok=True)
+        if options and options.get("user_data_path"):
+            profile_path = options["user_data_path"]
+        else:
+            profile_path = str(_cli_profile_path(browser_path))
+        Path(profile_path).mkdir(parents=True, exist_ok=True)
         co.set_user_data_path(profile_path)
 
     if options:
         if options.get("headless") is not None:
             co.headless(options["headless"])
-        if options.get("browser_path"):
-            co.set_browser_path(options["browser_path"])
         if options.get("proxy"):
             co.set_proxy(options["proxy"])
         if options.get("user_agent"):
@@ -176,6 +283,7 @@ def _get_page(session_name, create=False, options=None):
                 co.set_argument(arg)
 
     page = ChromiumPage(addr_or_opts=co)
+    _apply_chrome146_fix(page)
 
     # Record session info
     sessions[session_name] = {
@@ -189,7 +297,7 @@ def _get_page(session_name, create=False, options=None):
     return page
 
 
-def _format_snapshot(page, element=None):
+def _format_snapshot(page, element=None, save=True):
     """Produce a text snapshot of the current page state, similar to playwright-cli's snapshot."""
     lines = []
     lines.append("### Page")
@@ -206,18 +314,177 @@ def _format_snapshot(page, element=None):
                 lines.append(f"  @{k}={v}")
     else:
         lines.append("### Snapshot")
-        # Save snapshot to file
-        timestamp = time.strftime("%Y-%m-%dT%H-%M-%S")
-        snap_dir = CLI_DIR / "snapshots"
-        snap_dir.mkdir(parents=True, exist_ok=True)
-        snap_file = snap_dir / f"page-{timestamp}.html"
+        if save:
+            timestamp = time.strftime("%Y-%m-%dT%H-%M-%S")
+            snap_file = Path.cwd() / f"page-{timestamp}.html"
+            try:
+                snap_file.write_text(page.html, encoding="utf-8")
+                lines.append(f"[Snapshot]({snap_file})")
+            except Exception:
+                lines.append(f"- HTML length: {len(page.html):,} chars")
+        else:
+            lines.append(f"- HTML length: {len(page.html):,} chars")
+
+    return "\n".join(lines)
+
+
+def _ct_to_ext(ct: str) -> str:
+    """Map a Content-Type value to a file extension."""
+    ct = ct.lower().split(";")[0].strip()
+    return {
+        "text/html":                "html",
+        "text/plain":               "txt",
+        "text/css":                 "css",
+        "text/javascript":          "js",
+        "application/javascript":   "js",
+        "application/x-javascript":"js",
+        "application/json":         "json",
+        "application/xml":          "xml",
+        "text/xml":                 "xml",
+        "image/png":                "png",
+        "image/jpeg":               "jpg",
+        "image/webp":               "webp",
+        "image/gif":                "gif",
+        "image/svg+xml":            "svg",
+        "image/avif":               "avif",
+        "image/bmp":                "bmp",
+        "image/x-icon":             "ico",
+        "image/vnd.microsoft.icon": "ico",
+        "audio/mpeg":               "mp3",
+        "audio/mp3":                "mp3",
+        "audio/ogg":                "ogg",
+        "audio/wav":                "wav",
+        "audio/x-wav":              "wav",
+        "audio/webm":               "webm",
+        "audio/aac":                "aac",
+        "audio/flac":               "flac",
+        "audio/x-flac":             "flac",
+        "video/mp4":                "mp4",
+        "video/webm":               "webm",
+        "video/ogg":                "ogv",
+        "video/x-msvideo":          "avi",
+        "video/quicktime":          "mov",
+        "application/pdf":          "pdf",
+        "font/woff":                "woff",
+        "font/woff2":               "woff2",
+        "application/font-woff":    "woff",
+        "application/font-woff2":   "woff2",
+        "application/octet-stream": "bin",
+    }.get(ct, "bin")
+
+
+def _response_filename(counter: int, url: str, ct: str) -> str:
+    """Build a short, readable filename for a captured response."""
+    from urllib.parse import urlparse
+    parsed = urlparse(url)
+    # Use last non-empty path segment, falling back to hostname
+    segments = [s for s in parsed.path.split("/") if s]
+    name = segments[-1] if segments else parsed.netloc
+    # Strip existing extension so we control it via content-type
+    name = re.sub(r"\.[^.]{1,6}$", "", name)
+    # Sanitize: keep alphanum, dot, hyphen; collapse everything else to _
+    name = re.sub(r"[^\w.\-]", "_", name)[:50].strip("_") or "response"
+    ext = _ct_to_ext(ct)
+    return f"{counter:04d}_{name}.{ext}"
+
+
+def _collect_traffic(page, settle: float = 1.0, out_dir: Path = None) -> list:
+    """
+    Drain the network listener queue started before page.get().
+
+    Call after page.get() returns.  ``settle`` gives async XHR/fetch calls
+    a moment to complete before we declare the queue exhausted.
+
+    If ``out_dir`` is given every response body is written as an individual
+    file inside that directory and each record gets a ``"file"`` field with
+    the relative filename.
+
+    Returns a list of dicts (the traffic manifest), one per request/response.
+    """
+    _TEXT_TYPES = (
+        "text/", "application/json", "application/javascript",
+        "application/xml", "application/x-www-form-urlencoded",
+    )
+
+    time.sleep(settle)   # let in-flight async requests finish
+    records = []
+    counter = 0
+
+    for packet in page.listen.steps(timeout=2):
+        url = getattr(packet, "url", "") or ""
+
+        # Only keep real HTTP(S) traffic — skip chrome://, data:, etc.
+        if not url.startswith(("http://", "https://")):
+            continue
+
+        counter += 1
+        resp   = getattr(packet, "response", None)
+        method = getattr(packet, "method", "GET") or "GET"
+        status = getattr(resp, "status", None) if resp else None
+
+        ct = ""
         try:
-            snap_file.write_text(page.html)
-            lines.append(f"[Snapshot]({snap_file})")
+            ct = (resp.headers.get("content-type") or "") if resp else ""
         except Exception:
-            lines.append("[Snapshot could not be saved]")
+            pass
 
-    return "\n".join(lines)
+        rec = {"url": url, "method": method, "status": status, "content_type": ct}
+
+        # Request headers
+        try:
+            req = getattr(packet, "request", None)
+            if req and getattr(req, "headers", None):
+                rec["request_headers"] = dict(req.headers)
+        except Exception:
+            pass
+
+        # Request body (POST etc.)
+        try:
+            req = getattr(packet, "request", None)
+            post = getattr(req, "postData", None) or getattr(req, "body", None) if req else None
+            if post:
+                rec["request_body"] = post if isinstance(post, str) else post.decode("utf-8", errors="replace")
+        except Exception:
+            pass
+
+        # Response headers
+        try:
+            if resp and getattr(resp, "headers", None):
+                rec["response_headers"] = dict(resp.headers)
+        except Exception:
+            pass
+
+        # Response body
+        body = getattr(resp, "body", None) if resp else None
+        if body is not None:
+            if isinstance(body, (bytes, bytearray)):
+                data: bytes = bytes(body)
+            elif isinstance(body, str):
+                data = body.encode("utf-8", errors="replace")
+            elif isinstance(body, (dict, list)):
+                # DrissionPage auto-parses JSON responses into Python objects
+                data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+            else:
+                data = str(body).encode("utf-8", errors="replace")
+            rec["size"] = len(data)
+
+            if out_dir is not None:
+                # Save every response as its own file
+                fname = _response_filename(counter, url, ct)
+                try:
+                    (out_dir / fname).write_bytes(data)
+                    rec["file"] = fname
+                except Exception as e:
+                    rec["file_error"] = str(e)
+            else:
+                # Inline text bodies only (no out_dir → old compact behaviour)
+                is_text = any(t in ct.lower() for t in _TEXT_TYPES)
+                if is_text:
+                    rec["body"] = data.decode("utf-8", errors="replace")
+
+        records.append(rec)
+
+    return records
 
 
 def _find_element(page, ref):
@@ -267,15 +534,65 @@ def cmd_open(args):
         "user_data_path": getattr(args, "profile", None),
         "port": getattr(args, "port", None),
         "sandbox": getattr(args, "sandbox", False),
+        "browser": getattr(args, "browser", None),
     }
     page = _get_page(session, create=True, options=options)
 
     url = getattr(args, "url", None)
+    capture = getattr(args, "capture", False)
+
+    _MEDIA_EXTS = {
+        ".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".avif", ".bmp", ".ico",
+        ".mp3", ".mp4", ".ogg", ".ogv", ".wav", ".webm", ".aac", ".flac", ".avi", ".mov",
+    }
+
     if url:
+        if capture:
+            # Start listening BEFORE navigation so no packet is missed
+            page.listen.start()
+
         page.get(url)
 
+        if capture:
+            timestamp = time.strftime("%Y-%m-%dT%H-%M-%S")
+            capture_dir = Path.cwd() / f"capture-{timestamp}"
+            capture_dir.mkdir(parents=True, exist_ok=True)
+
+            # Save page snapshot HTML
+            html_file = capture_dir / "snapshot.html"
+            try:
+                html_file.write_text(page.html, encoding="utf-8")
+            except Exception as e:
+                print(f"[warn] could not save snapshot HTML: {e}", file=sys.stderr)
+
+            # Drain listener; each response body is written as its own file
+            records = _collect_traffic(page, out_dir=capture_dir)
+
+            # Save traffic manifest
+            traffic_file = capture_dir / "traffic.json"
+            try:
+                traffic_file.write_text(
+                    json.dumps(records, indent=2, ensure_ascii=False),
+                    encoding="utf-8",
+                )
+            except Exception as e:
+                print(f"[warn] could not save traffic manifest: {e}", file=sys.stderr)
+
+            n_media = sum(
+                1 for r in records
+                if r.get("file") and Path(r["file"]).suffix.lower() in _MEDIA_EXTS
+            )
+            print(f"[capture] folder   → {capture_dir}")
+            print(f"[capture] snapshot → snapshot.html")
+            print(f"[capture] traffic  → traffic.json  ({len(records)} requests)")
+            if n_media:
+                print(f"[capture] media    → {n_media} files (images/audio/video)")
+    else:
+        if capture:
+            print("[warn] --capture requires a URL to be useful; listener not started.", file=sys.stderr)
+
     _inject_console_capture(page)
-    print(_format_snapshot(page))
+    print(_format_snapshot(page, save=not capture))
 
 
 def cmd_goto(args):
@@ -1175,6 +1492,38 @@ def cmd_state_load(args):
 # --- Install skills ---
 
 
+def cmd_md(args):
+    """Convert a Feishu document to Markdown with locally saved images."""
+    from drissionpage_cli._feishu import convert
+
+    url = args.url
+    parsed = urlparse(url)
+    is_feishu = (
+        parsed.netloc.endswith(".feishu.cn")
+        and ("/wiki/" in parsed.path or "/docx/" in parsed.path)
+    )
+    if not is_feishu:
+        print(f"Error: '{url}' is not a supported Feishu document.", file=sys.stderr)
+        print("Supported: https://<company>.feishu.cn/wiki/<id>  or  /docx/<id>", file=sys.stderr)
+        sys.exit(1)
+
+    session = _get_session_name(args)
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        page = _get_page(session)
+    except RuntimeError:
+        page = _get_page(session, create=True, options={"headless": False})
+
+    convert(
+        page,
+        url=url,
+        out_dir=out_dir,
+        save_html=getattr(args, "save_html", False),
+    )
+
+
 def cmd_install(args):
     """Install skills for Claude Code or other agents."""
     if not getattr(args, "skills", False):
@@ -1231,6 +1580,11 @@ def build_parser():
     p.add_argument("--sandbox", action="store_true",
                    help="Isolated session: random port + temporary profile, no persistent state")
     p.add_argument("--port", type=int, help=f"CDP debugging port (default: {DEFAULT_PORT})")
+    p.add_argument("--capture", action="store_true",
+                   help="Capture full network traffic during page load; saves paired "
+                        "page-<ts>.html and page-<ts>.traffic.json to the snapshots dir")
+    p.add_argument("--browser", choices=["chrome", "chromium", "edge"],
+                   help="Browser to use (default: auto-detect)")
     p.set_defaults(func=cmd_open)
 
     # goto
@@ -1507,6 +1861,13 @@ def build_parser():
     p.add_argument("--skills", action="store_true", help="Install Claude Code skills")
     p.set_defaults(func=cmd_install)
 
+    # md - Convert Feishu document to Markdown with locally saved images
+    p = subparsers.add_parser("md", help="Convert a Feishu document to Markdown")
+    p.add_argument("url", help="Feishu document URL (*.feishu.cn/wiki/* or /docx/*)")
+    p.add_argument("out_dir", nargs="?", default=".", help="Output directory (default: .)")
+    p.add_argument("--save-html", action="store_true", help="Also save the raw SSR HTML")
+    p.set_defaults(func=cmd_md)
+
     return parser