sycommon-python-lib 0.2.1b5__tar.gz → 0.2.1b6__tar.gz

{sycommon_python_lib-0.2.1b5 → sycommon_python_lib-0.2.1b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.1b5
+Version: 0.2.1b6
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: aiohttp>=3.13.5
 Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: anyio>=4.12.1
 Requires-Dist: decorator>=5.2.1
-Requires-Dist: deepagents>=0.5.1
+Requires-Dist: deepagents>=0.5.2
 Requires-Dist: elasticsearch>=9.3.0
 Requires-Dist: fastapi>=0.135.3
 Requires-Dist: jinja2>=3.1.6
@@ -17,7 +17,7 @@ Requires-Dist: kafka-python>=2.3.1
 Requires-Dist: langchain>=1.2.15
 Requires-Dist: langchain-core>=1.2.28
 Requires-Dist: langchain-openai>=1.1.11
-Requires-Dist: langfuse>=4.1.0
+Requires-Dist: langfuse>=4.2.0
 Requires-Dist: langgraph>=1.1.6
 Requires-Dist: langgraph-checkpoint-redis>=0.4.0
 Requires-Dist: ldap3>=2.9.1
@@ -28,7 +28,7 @@ Requires-Dist: psutil>=7.2.2
 Requires-Dist: pyxxl>=0.4.6
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.2
-Requires-Dist: python-multipart>=0.0.24
+Requires-Dist: python-multipart>=0.0.26
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: redis>=7.3.0
 Requires-Dist: sentry-sdk[fastapi]>=2.57.0

{sycommon_python_lib-0.2.1b5 → sycommon_python_lib-0.2.1b6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.1b5"
+version = "0.2.1b6"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -10,7 +10,7 @@ dependencies = [
     "aiomysql>=0.3.2",
     "anyio>=4.12.1",
     "decorator>=5.2.1",
-    "deepagents>=0.5.1",
+    "deepagents>=0.5.2",
     "elasticsearch>=9.3.0",
     "fastapi>=0.135.3",
     "jinja2>=3.1.6",
@@ -18,7 +18,7 @@ dependencies = [
     "langchain>=1.2.15",
     "langchain-core>=1.2.28",
     "langchain-openai>=1.1.11",
-    "langfuse>=4.1.0",
+    "langfuse>=4.2.0",
     "langgraph>=1.1.6",
     "langgraph-checkpoint-redis>=0.4.0",
     "ldap3>=2.9.1",
@@ -29,7 +29,7 @@ dependencies = [
     "pyxxl>=0.4.6",
     "pydantic>=2.12.5",
     "python-dotenv>=1.2.2",
-    "python-multipart>=0.0.24",
+    "python-multipart>=0.0.26",
     "pyyaml>=6.0.3",
     "redis>=7.3.0",
     "sentry-sdk[fastapi]>=2.57.0",

sycommon_python_lib-0.2.1b6/src/sycli/cdp/__init__.py

@@ -0,0 +1 @@
+"""sycli CDP — Chrome DevTools Protocol debugging support."""

sycommon_python_lib-0.2.1b6/src/sycli/cdp/browser.py

@@ -0,0 +1,214 @@
+"""Browser launcher — find and start Chrome/Chromium with remote debugging.
+
+Supports macOS, Linux, and Windows. Uses a temporary user data directory
+and cleans up the process tree on termination.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+# Platform-specific Chrome search paths
+_CHROME_PATHS: dict[str, list[str]] = {
+    "Darwin": [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    ],
+    "Linux": [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/chromium",
+        "/snap/bin/chromium",
+    ],
+    "Windows": [
+        os.path.expandvars(r"%ProgramFiles%\Google\Chrome\Application\chrome.exe"),
+        os.path.expandvars(r"%ProgramFiles(x86)%\Google\Chrome\Application\chrome.exe"),
+        os.path.expandvars(r"%LocalAppData%\Google\Chrome\Application\chrome.exe"),
+    ],
+}
+
+
+class BrowserProcess:
+    """Manages a launched Chrome subprocess."""
+
+    def __init__(self, process: subprocess.Popen, port: int, user_data_dir: str) -> None:
+        self.process = process
+        self.port = port
+        self.user_data_dir = user_data_dir
+
+    async def wait_for_ready(self, timeout: float = 10.0) -> None:
+        """Poll the /json/version endpoint until Chrome is ready."""
+        import time
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(
+                        f"http://localhost:{self.port}/json/version",
+                        timeout=aiohttp.ClientTimeout(total=2),
+                    ) as resp:
+                        if resp.status == 200:
+                            return
+            except Exception:
+                pass
+            await asyncio.sleep(0.2)
+        raise TimeoutError(f"Chrome did not become ready on port {self.port} within {timeout}s")
+
+    async def terminate(self) -> None:
+        """Terminate the Chrome process and clean up."""
+        if self.process.poll() is None:
+            try:
+                import psutil
+                parent = psutil.Process(self.process.pid)
+                children = parent.children(recursive=True)
+                for child in children:
+                    try:
+                        child.terminate()
+                    except psutil.NoSuchProcess:
+                        pass
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.process.kill()
+            except ImportError:
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.process.kill()
+
+        # Clean up temp directory
+        if self.user_data_dir and os.path.exists(self.user_data_dir):
+            try:
+                shutil.rmtree(self.user_data_dir, ignore_errors=True)
+            except Exception:
+                pass
+
+
+class BrowserLauncher:
+    """Find and launch Chrome/Chromium with remote debugging enabled."""
+
+    @staticmethod
+    def find_chrome() -> str | None:
+        """Return the path to a Chrome/Chromium executable, or None."""
+        system = platform.system()
+        paths = _CHROME_PATHS.get(system, [])
+
+        for path in paths:
+            if os.path.isfile(path):
+                return path
+
+        # Fallback to PATH lookup
+        for name in ("google-chrome", "google-chrome-stable", "chromium-browser", "chromium", "chrome"):
+            found = shutil.which(name)
+            if found:
+                return found
+
+        return None
+
+    @staticmethod
+    async def launch(
+        port: int = 0,
+        headless: bool = True,
+        extra_args: list[str] | None = None,
+    ) -> BrowserProcess:
+        """Launch Chrome and return a BrowserProcess handle.
+
+        Args:
+            port: Remote debugging port. 0 = auto-select an available port.
+            headless: Run in headless mode.
+            extra_args: Additional Chrome command-line arguments.
+        """
+        chrome_path = BrowserLauncher.find_chrome()
+        if not chrome_path:
+            raise FileNotFoundError(
+                "Chrome/Chromium not found. Install Chrome or use --port to connect "
+                "to an existing browser with --remote-debugging-port."
+            )
+
+        # Auto-select port if 0
+        if port == 0:
+            import socket
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(("", 0))
+                port = s.getsockname()[1]
+
+        user_data_dir = tempfile.mkdtemp(prefix="sycli-cdp-")
+
+        args = [
+            chrome_path,
+            f"--remote-debugging-port={port}",
+            f"--user-data-dir={user_data_dir}",
+            "--disable-gpu",
+            "--no-sandbox",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-background-networking",
+            "--disable-sync",
+            "--no-first-run",
+            "--disable-default-apps",
+        ]
+
+        if headless:
+            args.append("--headless=new")
+
+        if extra_args:
+            args.extend(extra_args)
+
+        logger.debug("Launching Chrome: %s", " ".join(args))
+
+        process = subprocess.Popen(
+            args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+
+        bp = BrowserProcess(process, port, user_data_dir)
+        await bp.wait_for_ready()
+        return bp
+
+
+async def discover_ws_url(port: int, target_id: str | None = None) -> str | None:
+    """Query /json endpoint to find a page's WebSocket debugger URL."""
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"http://localhost:{port}/json",
+                timeout=aiohttp.ClientTimeout(total=5),
+            ) as resp:
+                if resp.status != 200:
+                    return None
+                targets = await resp.json()
+                if not isinstance(targets, list):
+                    return None
+
+                if target_id:
+                    for t in targets:
+                        if t.get("id") == target_id:
+                            return t.get("webSocketDebuggerUrl")
+
+                # Default: first page target
+                for t in targets:
+                    if t.get("type") == "page":
+                        return t.get("webSocketDebuggerUrl")
+
+                # Fallback: any target
+                if targets:
+                    return targets[0].get("webSocketDebuggerUrl")
+    except Exception:
+        return None
+    return None

sycommon_python_lib-0.2.1b6/src/sycli/cdp/capabilities/__init__.py

@@ -0,0 +1 @@
+"""CDP capability modules for browser debugging."""

sycommon_python_lib-0.2.1b6/src/sycli/cdp/capabilities/console.py

@@ -0,0 +1,85 @@
+"""Console capability — capture Runtime console events and exceptions."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from sycli.cdp.client import CDPClient
+from sycli.cdp.protocol import enable_runtime, evaluate_js
+
+
+async def capture_console(
+    client: CDPClient,
+    duration: float = 5.0,
+    evaluate: str | None = None,
+) -> list[dict[str, Any]]:
+    """Capture console logs for a duration.
+
+    Args:
+        client: Connected CDP client.
+        duration: How long to capture (seconds).
+        evaluate: Optional JS expression to evaluate after enabling console capture.
+
+    Returns:
+        List of console entries: {"type", "args", "timestamp", "text"}.
+    """
+    entries: list[dict[str, Any]] = []
+
+    def on_console_api(params: dict) -> None:
+        args = params.get("args", [])
+        text = " ".join(_arg_to_str(a) for a in args)
+        entries.append({
+            "type": params.get("type", "log"),
+            "args": [_arg_summary(a) for a in args],
+            "text": text,
+            "timestamp": params.get("timestamp", 0),
+        })
+
+    def on_exception(params: dict) -> None:
+        detail = params.get("exceptionDetails", {})
+        exc = detail.get("exception", {})
+        entries.append({
+            "type": "exception",
+            "text": exc.get("description", detail.get("text", "Unknown exception")),
+            "args": [],
+            "timestamp": params.get("timestamp", 0),
+            "url": detail.get("url", ""),
+            "line": detail.get("lineNumber", -1),
+            "column": detail.get("columnNumber", -1),
+        })
+
+    client.on_event("Runtime.consoleAPICalled", on_console_api)
+    client.on_event("Runtime.exceptionThrown", on_exception)
+    await enable_runtime(client)
+
+    if evaluate:
+        await evaluate_js(client, evaluate)
+
+    await asyncio.sleep(duration)
+
+    client.remove_event_handler("Runtime.consoleAPICalled", on_console_api)
+    client.remove_event_handler("Runtime.exceptionThrown", on_exception)
+
+    return entries
+
+
+def _arg_to_str(arg: dict) -> str:
+    """Convert a CDP RemoteObject to a readable string."""
+    if "value" in arg:
+        import json
+        v = arg["value"]
+        return json.dumps(v, ensure_ascii=False) if isinstance(v, (dict, list)) else str(v)
+    if "description" in arg:
+        return arg["description"]
+    return arg.get("type", "undefined")
+
+
+def _arg_summary(arg: dict) -> dict:
+    """Summarize a CDP RemoteObject for structured output."""
+    return {
+        "type": arg.get("type"),
+        "value": arg.get("value"),
+        "description": arg.get("description"),
+    }

sycommon_python_lib-0.2.1b6/src/sycli/cdp/capabilities/dom.py

@@ -0,0 +1,53 @@
+"""DOM capability — query and inspect DOM elements."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sycli.cdp.client import CDPClient
+from sycli.cdp.protocol import (
+    enable_dom,
+    enable_page,
+    get_document,
+    get_outer_html,
+    query_selector,
+)
+
+
+async def query_dom(
+    client: CDPClient,
+    selector: str,
+) -> dict[str, Any]:
+    """Query a DOM element by CSS selector.
+
+    Args:
+        client: Connected CDP client.
+        selector: CSS selector string.
+
+    Returns:
+        Dict with "selector", "node_id", "outer_html".
+    """
+    await enable_page(client)
+    await enable_dom(client)
+
+    doc = await get_document(client)
+    root_node_id = doc.get("root", {}).get("nodeId", 0)
+
+    result = await query_selector(client, root_node_id, selector)
+    node_id = result.get("nodeId", 0)
+
+    if node_id == 0:
+        return {
+            "selector": selector,
+            "node_id": 0,
+            "outer_html": None,
+            "found": False,
+        }
+
+    html_result = await get_outer_html(client, node_id)
+    return {
+        "selector": selector,
+        "node_id": node_id,
+        "outer_html": html_result.get("outerHTML", ""),
+        "found": True,
+    }

sycommon_python_lib-0.2.1b6/src/sycli/cdp/capabilities/network.py

@@ -0,0 +1,119 @@
+"""Network capability — capture HTTP request/response traffic."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from sycli.cdp.client import CDPClient
+from sycli.cdp.protocol import (
+    disable_network,
+    enable_network,
+    get_response_body,
+)
+
+
+async def capture_network(
+    client: CDPClient,
+    duration: float = 10.0,
+    url_filter: str | None = None,
+    include_body: bool = False,
+) -> list[dict[str, Any]]:
+    """Capture network requests for a duration.
+
+    Args:
+        client: Connected CDP client.
+        duration: How long to capture (seconds).
+        url_filter: Optional URL substring filter.
+        include_body: Fetch response bodies for text responses.
+
+    Returns:
+        List of network entries with request/response info.
+    """
+    entries: dict[str, dict[str, Any]] = {}
+
+    def on_request(params: dict) -> None:
+        req = params.get("request", {})
+        rid = params.get("requestId", "")
+        entries[rid] = {
+            "request_id": rid,
+            "method": req.get("method", ""),
+            "url": req.get("url", ""),
+            "headers": req.get("headers", {}),
+            "request_type": params.get("type", ""),
+            "timestamp": params.get("timestamp", 0),
+            "status": None,
+            "mime_type": None,
+            "size": None,
+            "timing": None,
+            "body": None,
+            "failed": False,
+            "error_text": None,
+        }
+
+    def on_response(params: dict) -> None:
+        rid = params.get("requestId", "")
+        resp = params.get("response", {})
+        if rid in entries:
+            entries[rid]["status"] = resp.get("status")
+            entries[rid]["mime_type"] = resp.get("mimeType", "")
+            entries[rid]["size"] = resp.get("encodedDataLength") or resp.get("content", {}).get("size")
+            entries[rid]["timing"] = resp.get("timing")
+
+    def on_loading_finished(params: dict) -> None:
+        rid = params.get("requestId", "")
+        if rid in entries:
+            entries[rid]["size"] = params.get("encodedDataLength", entries[rid]["size"])
+
+    def on_loading_failed(params: dict) -> None:
+        rid = params.get("requestId", "")
+        if rid in entries:
+            entries[rid]["failed"] = True
+            entries[rid]["error_text"] = params.get("errorText", "")
+            entries[rid]["canceled"] = params.get("canceled", False)
+
+    # Enable network BEFORE any page activity
+    client.on_event("Network.requestWillBeSent", on_request)
+    client.on_event("Network.responseReceived", on_response)
+    client.on_event("Network.loadingFinished", on_loading_finished)
+    client.on_event("Network.loadingFailed", on_loading_failed)
+    await enable_network(client)
+
+    # If page is already loaded, reload to capture traffic
+    try:
+        from sycli.cdp.protocol import enable_page
+        await enable_page(client)
+        await client.send("Page.reload", {"ignoreCache": True})
+    except Exception:
+        pass
+
+    await asyncio.sleep(duration)
+
+    try:
+        await disable_network(client)
+    except Exception:
+        pass
+
+    # Fetch response bodies if requested
+    results = list(entries.values())
+    if include_body:
+        for entry in results:
+            if entry["failed"] or entry["status"] is None:
+                continue
+            mime = (entry.get("mime_type") or "").lower()
+            if any(t in mime for t in ("text", "json", "javascript", "html", "xml", "css")):
+                try:
+                    body_result = await get_response_body(client, entry["request_id"])
+                    body = body_result.get("body", "")
+                    if body_result.get("base64Encoded"):
+                        import base64
+                        body = base64.b64decode(body).decode("utf-8", errors="replace")
+                    entry["body"] = body[:10000]  # Truncate large bodies
+                except Exception:
+                    pass
+
+    # Apply URL filter
+    if url_filter:
+        results = [e for e in results if url_filter in e.get("url", "")]
+
+    return results

sycommon_python_lib-0.2.1b6/src/sycli/cdp/capabilities/page_errors.py

@@ -0,0 +1,91 @@
+"""Page errors capability — capture JS exceptions, window.onerror, and log entries."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from sycli.cdp.client import CDPClient
+from sycli.cdp.protocol import enable_log, enable_page, enable_runtime
+
+
+async def capture_errors(
+    client: CDPClient,
+    duration: float = 5.0,
+) -> list[dict[str, Any]]:
+    """Capture page errors for a duration.
+
+    Listens for Runtime.exceptionThrown, Page.windowOnError (via Runtime.evaluate),
+    and Log.entryAdded events.
+
+    Args:
+        client: Connected CDP client.
+        duration: How long to capture (seconds).
+
+    Returns:
+        List of error entries with type, message, url, line, column, stack.
+    """
+    errors: list[dict[str, Any]] = []
+
+    def on_exception(params: dict) -> None:
+        detail = params.get("exceptionDetails", {})
+        exc = detail.get("exception", {})
+        errors.append({
+            "type": "exception",
+            "message": exc.get("description", detail.get("text", "")),
+            "url": detail.get("url", ""),
+            "line": detail.get("lineNumber", -1),
+            "column": detail.get("columnNumber", -1),
+            "stack": _format_stack(detail.get("stackTrace", {})),
+        })
+
+    def on_log_entry(params: dict) -> None:
+        entry = params.get("entry", {})
+        if entry.get("level") in ("error", "warning"):
+            errors.append({
+                "type": f"log_{entry.get('level', 'unknown')}",
+                "message": entry.get("text", ""),
+                "url": entry.get("url", ""),
+                "line": entry.get("lineNumber", -1),
+                "source": entry.get("source", ""),
+                "stack": _format_stack(entry.get("stackTrace", {})),
+            })
+
+    client.on_event("Runtime.exceptionThrown", on_exception)
+    client.on_event("Log.entryAdded", on_log_entry)
+
+    await enable_page(client)
+    await enable_runtime(client)
+    await enable_log(client)
+
+    # Install window.onerror handler
+    await client.send("Runtime.evaluate", {
+        "expression": (
+            "window.onerror = function(msg, url, line, col, error) {"
+            "  console.error('[window.onerror]', msg, url, line, col);"
+            "};"
+        ),
+        "returnByValue": True,
+    })
+
+    await asyncio.sleep(duration)
+
+    client.remove_event_handler("Runtime.exceptionThrown", on_exception)
+    client.remove_event_handler("Log.entryAdded", on_log_entry)
+
+    return errors
+
+
+def _format_stack(stack_trace: dict) -> str:
+    """Format a CDP StackTrace object into a readable string."""
+    frames = stack_trace.get("callFrames", [])
+    if not frames:
+        return ""
+    lines = []
+    for f in frames:
+        name = f.get("functionName", "<anonymous>")
+        url = f.get("url", "")
+        line = f.get("lineNumber", -1)
+        col = f.get("columnNumber", -1)
+        lines.append(f"  at {name} ({url}:{line}:{col})")
+    return "\n".join(lines)