cmdop-browser 1.0.1__py3-none-any.whl

_skill.py

@@ -0,0 +1,792 @@
+"""cmdop-browser — CMDOP skill wrapper for browser automation."""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from cmdop_skill import Arg, Skill
+
+from src.browsers import create_browser
+from src.browsers.base import BrowserDriver
+from src.config import BrowserConfig
+from src.tools import ALL_TOOLS
+
+skill = Skill(
+    name="browser",
+    description="Playwright + Camoufox browser automation — 56 tools, stealth mode, network capture, profiles",
+    version="1.0.0",
+)
+
+# ── Singleton browser ────────────────────────────────────────────────────────
+
+_browser: BrowserDriver | None = None
+
+
+async def _get_browser() -> BrowserDriver:
+    global _browser
+    if _browser is not None and _browser.is_running():
+        return _browser
+    config = BrowserConfig()
+    _browser = create_browser(config)
+    await _browser.start()
+    return _browser
+
+
+@skill.teardown
+async def _teardown() -> None:
+    global _browser
+    if _browser is not None and _browser.is_running():
+        await _browser.close()
+    _browser = None
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+def _to_dict(result: Any) -> dict:
+    from pydantic import BaseModel
+    if isinstance(result, BaseModel):
+        return result.model_dump()
+    if isinstance(result, dict):
+        return result
+    return {"ok": True, "result": result}
+
+
+# ── Setup ────────────────────────────────────────────────────────────────────
+
+@skill.command
+def setup(
+    force: bool = Arg("--force", action="store_true", default=False, help="Re-install even if already present"),
+) -> dict:
+    """Download and install browser binaries."""
+    from src.browsers.install import install_browsers
+    from src.config import BROWSER_PROVIDER
+    provider = BROWSER_PROVIDER or "all"
+    install_browsers(provider=provider, force=force)
+    return {"provider": provider}
+
+
+# ── Navigation (6) ───────────────────────────────────────────────────────────
+
+@skill.command
+async def navigate(
+    url: str = Arg(help="URL to navigate to", required=True),
+    timeout: float = Arg("--timeout", default=30.0, help="Navigation timeout in seconds"),
+) -> dict:
+    """Navigate to a URL."""
+    browser = await _get_browser()
+    result = await ALL_TOOLS["navigate"](browser, url=url, timeout=timeout)
+    return _to_dict(result)
+
+
+@skill.command
+async def refresh() -> dict:
+    """Refresh the current page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["refresh"](browser))
+
+
+@skill.command
+async def back() -> dict:
+    """Go back in browser history."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["back"](browser))
+
+
+@skill.command
+async def forward() -> dict:
+    """Go forward in browser history."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["forward"](browser))
+
+
+@skill.command
+async def get_url() -> dict:
+    """Get the current page URL."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_url"](browser))
+
+
+@skill.command
+async def get_title() -> dict:
+    """Get the current page title."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_title"](browser))
+
+
+# ── Interaction (7) ──────────────────────────────────────────────────────────
+
+@skill.command
+async def click(
+    selector: str = Arg(help="CSS selector to click", required=True),
+    human: bool = Arg("--human", action="store_true", default=False, help="Move cursor like a human"),
+) -> dict:
+    """Click an element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["click"](browser, selector=selector, human=human))
+
+
+@skill.command
+async def type_text(
+    selector: str = Arg(help="CSS selector to type into", required=True),
+    text: str = Arg(help="Text to type", required=True),
+    clear: bool = Arg("--clear", action="store_true", default=False, help="Clear field before typing"),
+) -> dict:
+    """Type text into an element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["type"](browser, selector=selector, text=text, clear=clear))
+
+
+@skill.command
+async def type_human(
+    selector: str = Arg(help="CSS selector to type into", required=True),
+    text: str = Arg(help="Text to type with human-like delays", required=True),
+) -> dict:
+    """Type text with human-like timing."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["type_human"](browser, selector=selector, text=text))
+
+
+@skill.command
+async def clear(
+    selector: str = Arg(help="CSS selector to clear", required=True),
+) -> dict:
+    """Clear an input field."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["clear"](browser, selector=selector))
+
+
+@skill.command
+async def hover(
+    selector: str = Arg(help="CSS selector to hover over", required=True),
+) -> dict:
+    """Hover over an element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["hover"](browser, selector=selector))
+
+
+@skill.command
+async def press_key(
+    key: str = Arg(help="Key to press", required=True),
+    modifiers: str = Arg("--modifiers", default=None, nargs="*", help="Modifier keys"),
+) -> dict:
+    """Press a keyboard key."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["press_key"](browser, key=key, modifiers=modifiers))
+
+
+@skill.command
+async def mouse_move(
+    x: int = Arg(help="X coordinate", required=True),
+    y: int = Arg(help="Y coordinate", required=True),
+    steps: int = Arg("--steps", default=20, help="Number of intermediate steps"),
+) -> dict:
+    """Move the mouse cursor."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["mouse_move"](browser, x=x, y=y, steps=steps))
+
+
+# ── Wait (3) ─────────────────────────────────────────────────────────────────
+
+@skill.command
+async def wait_for_selector(
+    selector: str = Arg(help="CSS selector to wait for", required=True),
+    timeout: float = Arg("--timeout", default=45.0, help="Timeout in seconds"),
+    visible: bool = Arg("--visible", action="store_true", default=True, help="Wait for visible element"),
+) -> dict:
+    """Wait for an element to appear."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["wait_for_selector"](browser, selector=selector, timeout=timeout, visible=visible))
+
+
+@skill.command
+async def wait_for_idle(
+    timeout: float = Arg("--timeout", default=5.0, help="Timeout in seconds"),
+) -> dict:
+    """Wait for the page to become idle."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["wait_for_idle"](browser, timeout=timeout))
+
+
+@skill.command
+async def wait(
+    seconds: float = Arg(help="Seconds to wait", required=True),
+) -> dict:
+    """Wait for a specified number of seconds."""
+    return _to_dict(await ALL_TOOLS["wait"](seconds=seconds))
+
+
+# ── Control (3) ──────────────────────────────────────────────────────────────
+
+@skill.command
+async def set_viewport(
+    width: int = Arg(help="Viewport width", required=True),
+    height: int = Arg(help="Viewport height", required=True),
+) -> dict:
+    """Set the browser viewport size."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["set_viewport"](browser, width=width, height=height))
+
+
+@skill.command
+async def scroll(
+    direction: str = Arg(help="Scroll direction", required=True, choices=["up", "down", "left", "right"]),
+    amount: int = Arg("--amount", default=300, help="Scroll amount in pixels"),
+    selector: str = Arg("--selector", default="", help="Element to scroll within"),
+    smooth: bool = Arg("--no-smooth", dest="smooth", action="store_false", default=True, help="Disable smooth scrolling"),
+) -> dict:
+    """Scroll the page or element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["scroll"](browser, direction=direction, amount=amount, selector=selector, smooth=smooth))
+
+
+@skill.command
+async def close_browser() -> dict:
+    """Close the browser."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["close_browser"](browser))
+
+
+# ── Data (9) ─────────────────────────────────────────────────────────────────
+
+@skill.command
+async def screenshot(
+    full_page: bool = Arg("--full-page", action="store_true", default=False, help="Capture full page"),
+    selector: str = Arg("--selector", default="", help="Element to screenshot"),
+) -> dict:
+    """Take a screenshot."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["screenshot"](browser, full_page=full_page, selector=selector))
+
+
+@skill.command
+async def save_screenshot(
+    path: str = Arg("--path", default="", help="File path to save screenshot"),
+    full_page: bool = Arg("--full-page", action="store_true", default=False, help="Capture full page"),
+) -> dict:
+    """Save a screenshot to a file."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["save_screenshot"](browser, path=path, full_page=full_page))
+
+
+@skill.command
+async def get_html(
+    mode: str = Arg("--mode", default="agent", choices=["agent", "raw"], help="Output mode"),
+    selector: str = Arg("--selector", default="", help="Element selector"),
+) -> dict:
+    """Get page HTML."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_html"](browser, mode=mode, selector=selector))
+
+
+@skill.command
+async def get_text(
+    selector: str = Arg(help="CSS selector to extract text from", required=True),
+) -> dict:
+    """Get text content of an element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_text"](browser, selector=selector))
+
+
+@skill.command
+async def execute_script(
+    script: str = Arg(help="JavaScript code to execute", required=True),
+    args: str = Arg("--args", default=None, nargs="*", help="Script arguments"),
+) -> dict:
+    """Execute JavaScript in the browser."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["execute_script"](browser, script=script, args=args))
+
+
+@skill.command
+async def extract(
+    selector: str = Arg(help="CSS selector to extract from", required=True),
+    attribute: str = Arg("--attribute", default="text", help="Attribute to extract"),
+    limit: int = Arg("--limit", default=100, help="Maximum number of elements"),
+) -> dict:
+    """Extract data from elements matching a selector."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract"](browser, selector=selector, attribute=attribute, limit=limit))
+
+
+@skill.command
+async def get_attribute(
+    selector: str = Arg(help="CSS selector", required=True),
+    attribute: str = Arg(help="Attribute name", required=True),
+) -> dict:
+    """Get an attribute value from an element."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_attribute"](browser, selector=selector, attribute=attribute))
+
+
+@skill.command
+async def exists(
+    selector: str = Arg(help="CSS selector to check", required=True),
+) -> dict:
+    """Check if an element exists."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["exists"](browser, selector=selector))
+
+
+@skill.command
+async def count(
+    selector: str = Arg(help="CSS selector to count", required=True),
+) -> dict:
+    """Count elements matching a selector."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["count"](browser, selector=selector))
+
+
+# ── Perception (4) ───────────────────────────────────────────────────────────
+
+@skill.command
+async def get_page(
+    mode: str = Arg("--mode", default="full", help="Page capture mode"),
+) -> dict:
+    """Get annotated page HTML for LLM automation."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_page"](browser, mode=mode))
+
+
+@skill.command
+async def get_state() -> dict:
+    """Get text representation of page state."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_state"](browser))
+
+
+@skill.command
+async def get_interactive(
+    visible_only: bool = Arg("--visible-only", action="store_true", default=True, help="Only visible elements"),
+) -> dict:
+    """Get list of interactive elements."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_interactive"](browser, visible_only=visible_only))
+
+
+@skill.command
+async def get_diff() -> dict:
+    """Get page changes since last call."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_diff"](browser))
+
+
+# ── Extraction (4) ───────────────────────────────────────────────────────────
+
+@skill.command
+async def validate_selectors(
+    selectors: str = Arg(help="CSS selectors to validate", required=True, nargs="+"),
+) -> dict:
+    """Validate CSS selectors against the page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["validate_selectors"](browser, selectors=selectors))
+
+
+@skill.command
+async def extract_regex(
+    pattern: str = Arg(help="Regex pattern", required=True),
+    source: str = Arg("--source", default="text", choices=["text", "html"], help="Source to search"),
+    selector: str = Arg("--selector", default="", help="Limit to element"),
+    group: int = Arg("--group", default=0, help="Capture group number"),
+) -> dict:
+    """Extract text matching a regex pattern."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_regex"](browser, pattern=pattern, source=source, selector=selector, group=group))
+
+
+@skill.command
+async def extract_data(
+    mappings: str = Arg(help='JSON mapping: {"field": "selector"}', required=True),
+    attribute: str = Arg("--attribute", default="text", help="Attribute to extract"),
+    multiple: bool = Arg("--multiple", action="store_true", default=False, help="Extract multiple matches"),
+) -> dict:
+    """Extract structured data using selector mappings."""
+    browser = await _get_browser()
+    parsed = json.loads(mappings)
+    return _to_dict(await ALL_TOOLS["extract_data"](browser, mappings=parsed, attribute=attribute, multiple=multiple))
+
+
+@skill.command
+async def check_regex(
+    selector: str = Arg(help="CSS selector", required=True),
+    pattern: str = Arg(help="Regex pattern to check", required=True),
+    attribute: str = Arg("--attribute", default="text", help="Attribute to check against"),
+) -> dict:
+    """Check if element content matches a regex."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["check_regex"](browser, selector=selector, pattern=pattern, attribute=attribute))
+
+
+# ── Cookies (1) ──────────────────────────────────────────────────────────────
+
+@skill.command
+async def import_cookies(
+    domain: str = Arg(help="Domain to import cookies for", required=True),
+    source: str = Arg("--source", default="chrome", help="Cookie source"),
+) -> dict:
+    """Import cookies from local browser."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["import_cookies"](browser, domain=domain, source=source))
+
+
+# ── Media (2) ────────────────────────────────────────────────────────────────
+
+@skill.command
+async def extract_video_urls(
+    wait_for_play: bool = Arg("--wait-for-play", action="store_true", default=False, help="Wait for video to play"),
+) -> dict:
+    """Extract video source URLs from the page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_video_urls"](browser, wait_for_play=wait_for_play))
+
+
+@skill.command
+async def get_video_info(
+    selector: str = Arg("--selector", default="video", help="Video element selector"),
+) -> dict:
+    """Get video metadata."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_video_info"](browser, selector=selector))
+
+
+# ── Profiles (6) ─────────────────────────────────────────────────────────────
+
+@skill.command
+async def create_profile(
+    name: str = Arg("--name", default="", help="Profile name"),
+) -> dict:
+    """Create a new browser profile."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["create_profile"](browser, name=name))
+
+
+@skill.command
+async def switch_profile(
+    profile_id: str = Arg(help="Profile ID to switch to", required=True),
+) -> dict:
+    """Switch to a browser profile."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["switch_profile"](browser, profile_id=profile_id))
+
+
+@skill.command
+async def list_profiles() -> dict:
+    """List all browser profiles."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["list_profiles"](browser))
+
+
+@skill.command
+async def current_profile() -> dict:
+    """Get the current browser profile."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["current_profile"](browser))
+
+
+@skill.command
+async def save_profile() -> dict:
+    """Save the current browser profile."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["save_profile"](browser))
+
+
+@skill.command
+async def delete_profile(
+    profile_id: str = Arg(help="Profile ID to delete", required=True),
+) -> dict:
+    """Delete a browser profile."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["delete_profile"](browser, profile_id=profile_id))
+
+
+# ── Visual (1) ───────────────────────────────────────────────────────────────
+
+@skill.command
+async def show_toast(
+    message: str = Arg(help="Toast message", required=True),
+    type: str = Arg("--type", default="info", choices=["info", "success", "warning", "error"], help="Toast type"),
+    duration: int = Arg("--duration", default=3000, help="Duration in milliseconds"),
+) -> dict:
+    """Show a toast notification in the browser."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["show_toast"](browser, message=message, type=type, duration=duration))
+
+
+# ── Network (6) ──────────────────────────────────────────────────────────────
+
+@skill.command
+async def network_enable(
+    enabled: bool = Arg("--enabled", action="store_true", default=True, help="Enable network capture"),
+) -> dict:
+    """Enable or disable network request capture."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_enable"](browser, enabled=enabled))
+
+
+@skill.command
+async def network_get(
+    url_pattern: str = Arg("--url-pattern", default="", help="Filter by URL pattern"),
+    methods: str = Arg("--methods", default=None, nargs="*", help="Filter by HTTP methods"),
+    types: str = Arg("--types", default=None, nargs="*", help="Filter by request types"),
+    limit: int = Arg("--limit", default=100, help="Maximum number of requests"),
+) -> dict:
+    """Get captured network requests."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_get"](browser, url_pattern=url_pattern, methods=methods, types=types, limit=limit))
+
+
+@skill.command
+async def network_clear() -> dict:
+    """Clear captured network requests."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_clear"](browser))
+
+
+@skill.command
+async def network_stats() -> dict:
+    """Get network capture statistics."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_stats"](browser))
+
+
+@skill.command
+async def network_get_json(
+    url_pattern: str = Arg("--url-pattern", default="", help="Filter by URL pattern"),
+) -> dict:
+    """Extract JSON from captured network responses."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_get_json"](browser, url_pattern=url_pattern))
+
+
+@skill.command
+async def network_export_har(
+    path: str = Arg("--path", default="", help="File path for HAR export"),
+) -> dict:
+    """Export network requests as HAR file."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["network_export_har"](browser, path=path))
+
+
+# ── Tabs (11) ────────────────────────────────────────────────────────────────
+
+@skill.command
+async def tab_new() -> dict:
+    """Open a new empty tab."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_new"](browser))
+
+
+@skill.command
+async def tab_new_with_url(
+    url: str = Arg(help="URL to open in new tab", required=True),
+) -> dict:
+    """Open a new tab with a URL."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_new_with_url"](browser, url=url))
+
+
+@skill.command
+async def tab_switch(
+    tab_id: str = Arg(help="Tab ID to switch to", required=True),
+) -> dict:
+    """Switch to a tab by ID."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_switch"](browser, tab_id=tab_id))
+
+
+@skill.command
+async def tab_switch_index(
+    index: int = Arg(help="Tab index to switch to", required=True),
+) -> dict:
+    """Switch to a tab by index."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_switch_index"](browser, index=index))
+
+
+@skill.command
+async def tab_close(
+    tab_id: str = Arg(help="Tab ID to close", required=True),
+) -> dict:
+    """Close a tab by ID."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_close"](browser, tab_id=tab_id))
+
+
+@skill.command
+async def tab_close_all_except(
+    tab_id: str = Arg(help="Tab ID to keep", required=True),
+) -> dict:
+    """Close all tabs except the specified one."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_close_all_except"](browser, tab_id=tab_id))
+
+
+@skill.command
+async def tab_list() -> dict:
+    """List all open tabs."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_list"](browser))
+
+
+@skill.command
+async def tab_current() -> dict:
+    """Get the current tab info."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_current"](browser))
+
+
+@skill.command
+async def tab_next() -> dict:
+    """Switch to the next tab."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_next"](browser))
+
+
+@skill.command
+async def tab_previous() -> dict:
+    """Switch to the previous tab."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_previous"](browser))
+
+
+@skill.command
+async def tab_count() -> dict:
+    """Get the number of open tabs."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["tab_count"](browser))
+
+
+# ── Turnstile + Markdown (4) ─────────────────────────────────────────────────
+
+@skill.command
+async def solve_turnstile(
+    max_attempts: int = Arg("--max-attempts", default=3, help="Maximum solve attempts"),
+    token_timeout: float = Arg("--token-timeout", default=30.0, help="Token wait timeout"),
+) -> dict:
+    """Solve a Cloudflare Turnstile challenge."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["solve_turnstile"](browser, max_attempts=max_attempts, token_timeout=token_timeout))
+
+
+@skill.command
+async def is_turnstile_present() -> dict:
+    """Check if a Turnstile challenge is present."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["is_turnstile_present"](browser))
+
+
+@skill.command
+async def wait_turnstile(
+    timeout: float = Arg("--timeout", default=30.0, help="Timeout in seconds"),
+) -> dict:
+    """Wait for and solve a Turnstile challenge."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["wait_turnstile"](browser, timeout=timeout))
+
+
+@skill.command
+async def get_markdown() -> dict:
+    """Convert current page to markdown."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_markdown"](browser))
+
+
+# ── Advanced (9) ─────────────────────────────────────────────────────────────
+
+@skill.command
+async def extract_meta() -> dict:
+    """Extract meta tags from the page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_meta"](browser))
+
+
+@skill.command
+async def extract_tables() -> dict:
+    """Extract all tables from the page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_tables"](browser))
+
+
+@skill.command
+async def extract_table(
+    selector: str = Arg(help="Table selector", required=True),
+) -> dict:
+    """Extract a specific table."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_table"](browser, selector=selector))
+
+
+@skill.command
+async def extract_jsonld() -> dict:
+    """Extract JSON-LD structured data."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_jsonld"](browser))
+
+
+@skill.command
+async def extract_jsonld_type(
+    schema_type: str = Arg(help="Schema.org type to filter", required=True),
+) -> dict:
+    """Extract JSON-LD data by schema type."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_jsonld_type"](browser, schema_type=schema_type))
+
+
+@skill.command
+async def extract_all() -> dict:
+    """Extract all structured data from the page."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["extract_all"](browser))
+
+
+@skill.command
+async def get_ax_tree(
+    max_depth: int = Arg("--max-depth", default=10, help="Maximum tree depth"),
+) -> dict:
+    """Get the accessibility tree."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_ax_tree"](browser, max_depth=max_depth))
+
+
+@skill.command
+async def get_ax_text(
+    max_depth: int = Arg("--max-depth", default=10, help="Maximum tree depth"),
+) -> dict:
+    """Get accessibility tree as text."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_ax_text"](browser, max_depth=max_depth))
+
+
+@skill.command
+async def get_full_state() -> dict:
+    """Get complete page state."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["get_full_state"](browser))
+
+
+# ── Pool (2) ─────────────────────────────────────────────────────────────────
+
+@skill.command
+async def pool_navigate(
+    urls: str = Arg(help="URLs to navigate in parallel", required=True, nargs="+"),
+    timeout: float = Arg("--timeout", default=30.0, help="Navigation timeout"),
+) -> dict:
+    """Navigate multiple URLs in parallel."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["pool_navigate"](browser, urls=urls, timeout=timeout))
+
+
+@skill.command
+async def pool_stats() -> dict:
+    """Get pool statistics."""
+    browser = await _get_browser()
+    return _to_dict(await ALL_TOOLS["pool_stats"](browser))
+
+
+# ── Entry point ──────────────────────────────────────────────────────────────
+
+def main() -> None:
+    skill.run()
+
+
+if __name__ == "__main__":
+    main()