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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drissionpage-cli
-Version: 0.1.8
+Version: 0.2.0
 Summary: DrissionPage CLI - Token-efficient browser automation for coding agents
 Author: DrissionPage-MCP Contributors
 License: Apache-2.0

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

@@ -10,6 +10,7 @@ import argparse
 import json
 import os
 import re
+import shutil
 import signal
 import sys
 import time
@@ -23,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")))
@@ -31,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)
@@ -69,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.
 
@@ -104,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
@@ -141,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
@@ -160,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"):
@@ -178,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] = {
@@ -428,6 +534,7 @@ 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)
 
@@ -1476,6 +1583,8 @@ def build_parser():
     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

drissionpage_cli-0.2.0/drissionpage_cli/_compat.py

@@ -0,0 +1,105 @@
+"""Runtime patches for DrissionPage compatibility with newer Chrome versions.
+
+DrissionPage-cli does not own the DrissionPage codebase.  Rather than forking
+or modifying installed files via post-install scripts, we apply targeted
+monkey-patches at import time.  Each patch:
+
+  - wraps (not replaces) the original method so upstream changes pass through,
+  - is guarded by a version or feature check when possible,
+  - is documented with the upstream issue link so it can be removed once fixed.
+
+Call ``apply_patches()`` once, early in the process (e.g. at package import).
+"""
+
+_PATCHES_APPLIED = False
+
+# ── Chrome 147+ newtab-footer target ─────────────────────────────────────
+#
+# Chrome 147 on Windows exposes ``chrome://newtab-footer/`` as a separate
+# CDP ``page`` target.  DrissionPage's ``_connect_browser`` can pick it as
+# the default tab, causing all subsequent page content to render inside the
+# footer's tiny area (~100 px at the bottom of the window).
+#
+# Fix: wrap ``_connect_browser`` so that when it would auto-select a target,
+# we do the selection ourselves (filtering out the footer) and hand the
+# correct target_id to the original method, which then skips its own
+# selection entirely.
+
+_NEWTAB_FOOTER_URLS = frozenset((
+    'chrome://newtab-footer/',
+    'chrome://newtab-footer',
+))
+
+
+def _patch_connect_browser():
+    from DrissionPage._pages.chromium_base import ChromiumBase
+
+    _original = ChromiumBase._connect_browser
+
+    def _patched(self, target_id=None):
+        if target_id is None:
+            target_id = _select_target(self)
+        return _original(self, target_id)
+
+    ChromiumBase._connect_browser = _patched
+
+
+def _select_target(page_obj):
+    """Replicate DrissionPage's default target selection with extra filtering.
+
+    Returns the target_id of the best user-facing tab, skipping known
+    Chrome-internal sub-pages.
+    """
+    browser = page_obj.browser
+
+    if browser._ws_only:
+        tabs = page_obj._run_cdp('Target.getTargets')['targetInfos']
+        _id = 'targetId'
+    else:
+        tabs = browser._driver.get(
+            f'http://{browser.address}/json').json()
+        _id = 'id'
+
+    tabs = [
+        (i[_id], i['url']) for i in tabs
+        if i['type'] in ('page', 'webview')
+        and not i['url'].startswith('devtools://')
+        and i['url'] not in _NEWTAB_FOOTER_URLS
+    ]
+
+    if not tabs:
+        # Nothing matched after filtering; fall back to letting the
+        # original method handle it (it will re-fetch and pick whatever
+        # is available).
+        return None
+
+    target_id = None
+    dialog = None
+
+    if len(tabs) > 1:
+        for k, t in enumerate(tabs):
+            if t[1] == 'chrome://privacy-sandbox-dialog/notice':
+                dialog = k
+            elif target_id is None:
+                target_id = t[0]
+            if target_id and dialog is not None:
+                break
+
+        if dialog is not None:
+            from DrissionPage._pages.chromium_base import close_privacy_dialog
+            close_privacy_dialog(page_obj, tabs[dialog][0])
+    else:
+        target_id = tabs[0][0]
+
+    return target_id
+
+
+# ── Public entry point ────────────────────────────────────────────────────
+
+def apply_patches():
+    """Apply all runtime patches (idempotent)."""
+    global _PATCHES_APPLIED
+    if _PATCHES_APPLIED:
+        return
+    _PATCHES_APPLIED = True
+    _patch_connect_browser()

{drissionpage_cli-0.1.8 → drissionpage_cli-0.2.0}/drissionpage_cli/_feishu.py

@@ -82,6 +82,19 @@ _ATTACH_CT = _IMG_CT | frozenset([
 
 # ── helpers ────────────────────────────────────────────────────────────────────
 
+_B36 = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+def _int_to_base36(n: int) -> str:
+    """Convert a non-negative integer to a base-36 string (Etherpad encoding)."""
+    if n == 0:
+        return "0"
+    digits = []
+    while n:
+        digits.append(_B36[n % 36])
+        n //= 36
+    return "".join(reversed(digits))
+
+
 def _strip_zero_width(text: str) -> str:
     return _INVISIBLE_RE.sub("", text)
 
@@ -114,17 +127,10 @@ def _extract_block_map(ssr_html: str) -> tuple:
     Returns (block_map: dict, title: str).
     block_map is empty if not found.
     """
-    # Detect old-format "DOC" (wikcn prefix) — uses a completely different structure
-    if '"type":"DOC"' in ssr_html or '"type": "DOC"' in ssr_html:
-        # Best-effort title extraction from old format
-        m = re.search(r'window\.SERVER_DATA\s*=\s*Object\(\{"meta":\{"title":"([^"]+)"', ssr_html)
-        title = _strip_zero_width(m.group(1)) if m else ""
-        raise RuntimeError(
-            "This document uses the old Feishu 'DOC' format (wikcn… URL prefix), "
-            "which stores content differently from the modern 'docx' block format. "
-            "Old-format DOC conversion is not yet supported. "
-            f"Document: {title or '(unknown)'}"
-        )
+    # Old-format DOC is now handled by convert() before calling this function,
+    # but guard here as well in case _extract_block_map is called directly.
+    if _is_old_doc(ssr_html):
+        return {}, ""
 
     # There are two clientVars occurrences; we want the one with block_map data.
     idx = ssr_html.find('clientVars: Object({"data":{"block_map":')
@@ -160,12 +166,219 @@ def _extract_block_map(ssr_html: str) -> tuple:
     return block_map, _strip_zero_width(title)
 
 
+# ── old-format DOC (wikcn / "type":"DOC") ─────────────────────────────────────
+
+def _is_old_doc(ssr_html: str) -> bool:
+    """Return True if the SSR HTML is for an old-format Feishu DOC."""
+    return '"type":"DOC"' in ssr_html or '"type": "DOC"' in ssr_html
+
+
+def _extract_old_doc_data(ssr_html: str) -> tuple:
+    """
+    Extract Etherpad-format document data from old-format Feishu DOC SSR HTML.
+
+    Old DOCs store content as a single attributed text string (Etherpad OT
+    format) rather than the modern block_map.  The data lives in::
+
+        window.DATA.clientVars.data.collab_client_vars
+
+    Returns ``(title, text, attribs_str, nta_b36, resources)`` where
+    *nta_b36* is the ``numToAttrib`` dict re-keyed with base-36 strings
+    so it can be fed directly to :func:`_parse_attribs`.
+    """
+    idx = ssr_html.find('clientVars: Object({"type":"DOC"')
+    if idx < 0:
+        idx = ssr_html.find('clientVars: Object({"type": "DOC"')
+    if idx < 0:
+        raise RuntimeError("Could not locate old-format DOC clientVars in SSR HTML")
+
+    obj_start = ssr_html.find("Object(", idx) + len("Object(")
+    depth = 0
+    obj_end = obj_start
+    for i, c in enumerate(ssr_html[obj_start:], obj_start):
+        if c == "{":
+            depth += 1
+        elif c == "}":
+            depth -= 1
+            if depth == 0:
+                obj_end = i + 1
+                break
+
+    data = json.loads(ssr_html[obj_start:obj_end])
+    ccv = data.get("data", {}).get("collab_client_vars", {})
+
+    iat = ccv.get("initialAttributedText", {})
+    text = iat.get("text", "")
+    attribs_str = iat.get("attribs", "")
+    nta = (ccv.get("apool") or {}).get("numToAttrib") or {}
+    resources = ccv.get("resources") or {}
+
+    # Re-key numToAttrib: Feishu stores decimal string keys ("10", "11", …)
+    # but attribs references them as base-36 ("a", "b", …).
+    nta_b36 = {}
+    for k, v in nta.items():
+        try:
+            nta_b36[_int_to_base36(int(k))] = v
+        except (ValueError, TypeError):
+            nta_b36[k] = v
+
+    # Title: prefer SERVER_DATA meta, fall back to ccv.title
+    m = re.search(
+        r'window\.SERVER_DATA\s*=\s*Object\(\{"meta":\{"title":"([^"]+)"',
+        ssr_html,
+    )
+    title = _strip_zero_width(m.group(1)) if m else ccv.get("title", "")
+
+    return title, text, attribs_str, nta_b36, resources
+
+
+def _old_doc_to_markdown(
+    text: str,
+    attribs_str: str,
+    nta_b36: dict,
+    resources: dict,
+) -> str:
+    """
+    Convert old-format Feishu DOC Etherpad data to Markdown.
+
+    Handles headings (h1-h9), numbered/bulleted lists, inline links
+    (``url-*`` and ``mention-link_*``), and embedded block placeholders
+    (mind-notes, etc.).
+    """
+    segments = _parse_attribs(attribs_str, nta_b36)
+
+    # ── walk segments and split into lines ────────────────────────────────
+    # Each line: (line_attrs from its lmkr segment, [(text, inline_attrs)…])
+    lines: list[tuple[dict, list]] = []
+    cur_attrs: dict = {}
+    cur_spans: list = []
+    pos = 0
+
+    for count, attrs in segments:
+        chunk = text[pos : pos + count]
+        pos += count
+        if not chunk:
+            continue
+
+        # Line-marker character (*) — carries line-level attrs, skip the char
+        if attrs.get("lmkr"):
+            cur_attrs = dict(attrs)
+            continue
+
+        # Split at embedded newlines
+        while "\n" in chunk:
+            nl = chunk.index("\n")
+            before = chunk[:nl]
+            if before:
+                cur_spans.append((before, attrs))
+            lines.append((dict(cur_attrs), list(cur_spans)))
+            cur_attrs = {}
+            cur_spans = []
+            chunk = chunk[nl + 1 :]
+
+        if chunk:
+            cur_spans.append((chunk, attrs))
+
+    if cur_spans:
+        lines.append((dict(cur_attrs), list(cur_spans)))
+
+    # ── render each line to Markdown ──────────────────────────────────────
+    md_parts: list[str] = []
+
+    for line_attrs, spans in lines:
+        heading = line_attrs.get("heading", "")
+        list_type = line_attrs.get("list", "")
+        start_num = line_attrs.get("start", "1")
+
+        inline = _render_old_doc_spans(spans)
+
+        # Blank line
+        if not inline.strip():
+            # Collapse consecutive blanks
+            if not md_parts or md_parts[-1] != "":
+                md_parts.append("")
+            continue
+
+        # Line-level prefix (heading wins over list)
+        if heading:
+            lvl = int(heading[1:]) if heading[1:].isdigit() else 1
+            md_parts.append("#" * min(lvl, 6) + " " + inline)
+        elif list_type.startswith("number"):
+            depth = int(list_type[-1]) - 1 if list_type[-1].isdigit() else 0
+            md_parts.append("   " * depth + f"{start_num}. " + inline)
+        elif list_type.startswith("indent") or list_type.startswith("bullet"):
+            depth = int(list_type[-1]) - 1 if list_type[-1].isdigit() else 0
+            md_parts.append("   " * depth + "- " + inline)
+        else:
+            md_parts.append(inline)
+
+    return "\n".join(md_parts)
+
+
+def _render_old_doc_spans(spans: list) -> str:
+    """Render a list of ``(text, attrs)`` spans to inline Markdown."""
+    parts: list[str] = []
+
+    for raw_text, attrs in spans:
+        chunk = raw_text
+
+        # ── embedded block placeholder (mindnote / diagram) ───────────
+        meta_json = attrs.get("dataMetaBlockProps")
+        if meta_json:
+            try:
+                meta = json.loads(meta_json)
+                engine = meta.get("engineType", "block")
+                token = meta.get("token", "")
+                chunk = f"*[Embedded {engine}: {token}]*"
+            except (json.JSONDecodeError, TypeError):
+                chunk = "*[embedded block]*"
+            parts.append(chunk)
+            continue
+
+        # ── find link URL ─────────────────────────────────────────────
+        link_url = None
+        for k, v in attrs.items():
+            if k.startswith("url-"):
+                link_url = _url_unquote(v)
+                break
+            if k.startswith("mention-link_"):
+                link_url = _url_unquote(k[len("mention-link_") :])
+                break
+
+        # ── inline formatting ─────────────────────────────────────────
+        bold = attrs.get("bold") == "true"
+        italic = attrs.get("italic") == "true"
+        code = attrs.get("code") == "true"
+        strike = attrs.get("strikethrough") == "true"
+
+        if code:
+            chunk = f"`{chunk}`"
+        elif bold and italic:
+            chunk = f"***{chunk}***"
+        elif bold:
+            chunk = f"**{chunk}**"
+        elif italic:
+            chunk = f"*{chunk}*"
+
+        if strike:
+            chunk = f"~~{chunk}~~"
+
+        if link_url:
+            chunk = f"[{chunk}]({link_url})"
+
+        parts.append(chunk)
+
+    return "".join(parts)
+
+
 # ── attributed text (Etherpad/Changeset format) ────────────────────────────────
 
 def _parse_attribs(attribs_str: str, num_to_attrib: dict) -> list:
     """
     Parse an Etherpad changeset attrib string into segments.
     Counts are base-36 encoded (e.g. '+h' = 17 chars, '+11' = 37 chars).
+    ``|L`` before ``+N`` means "N chars include L newlines" — we skip the L
+    since the newlines are already in the text.
     Returns list of (char_count, {attr_key: attr_value}).
     """
     segments = []
@@ -176,16 +389,22 @@ def _parse_attribs(attribs_str: str, num_to_attrib: dict) -> list:
         if c == "*":
             i += 1
             j = i
-            while j < len(attribs_str) and attribs_str[j] not in "+*":
+            while j < len(attribs_str) and attribs_str[j] not in "+*|":
                 j += 1
             pair = num_to_attrib.get(attribs_str[i:j])
             if pair and len(pair) == 2 and pair[1] not in ("", "false", None):
                 current_attrs[pair[0]] = pair[1]
             i = j
+        elif c == "|":
+            # |L prefix: skip the newline count L; the following +N has the
+            # total character count we need.
+            i += 1
+            while i < len(attribs_str) and attribs_str[i] not in "+*|":
+                i += 1
         elif c == "+":
             i += 1
             j = i
-            while j < len(attribs_str) and attribs_str[j] not in "+*":
+            while j < len(attribs_str) and attribs_str[j] not in "+*|":
                 j += 1
             raw = attribs_str[i:j]
             count = int(raw, 36) if raw else 0
@@ -975,6 +1194,40 @@ def convert(page, url: str, out_dir: Path, save_html: bool = False) -> Path:
                 "Make sure you are logged in and the document is accessible."
             )
 
+        # ── old-format DOC: completely different conversion path ────────────
+        if _is_old_doc(ssr_html):
+            print("[feishu2md] old-format DOC detected, using legacy converter…")
+            title, doc_text, doc_attribs, doc_nta, doc_res = (
+                _extract_old_doc_data(ssr_html)
+            )
+            safe = _safe_title(title)
+            print(f"[feishu2md] document: {title}")
+
+            doc_dir = out_dir / safe
+            doc_dir.mkdir(parents=True, exist_ok=True)
+
+            body = _old_doc_to_markdown(doc_text, doc_attribs, doc_nta, doc_res)
+
+            # Skip the first line of the body if it duplicates the title
+            body_lines = body.split("\n")
+            if body_lines and body_lines[0].strip() == title.strip():
+                body = "\n".join(body_lines[1:]).lstrip("\n")
+
+            md = f"# {_strip_zero_width(title)}\n\n{body}"
+            md = re.sub(r"\n{3,}", "\n\n", md)
+            print(f"  {len(md):,} chars")
+
+            md_path = doc_dir / f"{safe}.md"
+            md_path.write_text(md, encoding="utf-8")
+            print(f"[feishu2md] done  → {md_path}")
+
+            if save_html:
+                html_path = doc_dir / f"{safe}_ssr.html"
+                shutil.copy2(tmp_dir / ssr_file, html_path)
+                print(f"[feishu2md] html  → {html_path}")
+
+            return md_path
+
         # ── extract block_map ─────────────────────────────────────────────────
         print("[feishu2md] extracting block map…")
         block_map, title = _extract_block_map(ssr_html)

{drissionpage_cli-0.1.8 → drissionpage_cli-0.2.0}/drissionpage_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drissionpage-cli
-Version: 0.1.8
+Version: 0.2.0
 Summary: DrissionPage CLI - Token-efficient browser automation for coding agents
 Author: DrissionPage-MCP Contributors
 License: Apache-2.0

{drissionpage_cli-0.1.8 → drissionpage_cli-0.2.0}/drissionpage_cli.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 drissionpage_cli/__init__.py
 drissionpage_cli/__main__.py
+drissionpage_cli/_compat.py
 drissionpage_cli/_feishu.py
 drissionpage_cli.egg-info/PKG-INFO
 drissionpage_cli.egg-info/SOURCES.txt

{drissionpage_cli-0.1.8 → drissionpage_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "drissionpage-cli"
-version = "0.1.8"
+version = "0.2.0"
 description = "DrissionPage CLI - Token-efficient browser automation for coding agents"
 readme = "README.md"
 license = {text = "Apache-2.0"}