control-dom 0.1.0__py3-none-any.whl

control_dom/main.py

@@ -0,0 +1,176 @@
+"""
+control_dom Tool
+=================
+Evaluates arbitrary JavaScript in a Tauri child webview using
+the in-browser Playwright Page API polyfill (window.__page).
+
+The JS code runs inside the target webview's renderer context.
+Console output (console.log / warn / error) is captured and
+returned so the agent can observe results.
+
+Parameters:
+  js_code         – JavaScript source to evaluate.  Has full access to
+                    window.__page and the Playwright polyfill API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+from openchadpy.context import console_messages
+from openchadpy.tool_base import ToolBase
+
+logger = logging.getLogger(__name__)
+
+# How long (seconds) to wait for console output after the script fires.
+_DEFAULT_WAIT = 8.0
+# How long (seconds) between console-poll ticks.
+_POLL_INTERVAL = 0.15
+
+
+class Tool(ToolBase):
+    """Evaluate JavaScript inside a Tauri child webview (DOM control)."""
+
+    name = "control_dom"
+    description = (
+        "Evaluate JavaScript code inside a Tauri child webview. "
+        "The code runs in the page context and has access to "
+        "window.__page — a Playwright Page API polyfill — so you can "
+        "click, fill, navigate, scrape, wait for selectors, and more. "
+        "All console.log / console.error / console.warn output is captured "
+        "and returned so you can observe results. "
+        "Always write console.log() statements so you can verify actions succeeded. "
+        "Prefer window.__page methods over raw DOM when possible."
+    )
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "js_code": {
+                "type": "string",
+                "description": (
+                    "JavaScript code to evaluate in the webview. "
+                    "Top-level await is supported — wrap async logic directly. "
+                    "Use window.__page for Playwright-style DOM control. "
+                    "Use console.log() to emit observable output. "
+                    "Example:\n"
+                    "  const loc = window.__page.getByRole('button', { name: 'Submit' });\n"
+                    "  await loc.click();\n"
+                    "  console.log('clicked:', await loc.textContent());"
+                ),
+            },
+            "timeout": {
+                "type": "number",
+                "description": (
+                    "Seconds to wait for console output after the script runs "
+                    f"(default: {_DEFAULT_WAIT}). Increase for long-running scripts."
+                ),
+            },
+        },
+        "required": ["js_code"],
+    }
+    allowed_callers = ["direct", "code_execution", "mcp_client"]
+
+    # ------------------------------------------------------------------
+    # helpers
+    # ------------------------------------------------------------------
+
+    def _resolve_target(self, target_webview: Optional[str]) -> str:
+        """Return a best-effort webview label."""
+        if target_webview:
+            return target_webview
+        # Fall back to the active tab id formatted as a webview agent label.
+        tid = self.tab_id
+        if tid and tid != "global":
+            return f"webview-agent-{tid}"
+        return ""
+
+    async def _collect_new_console(
+        self,
+        label: str,
+        before_count: int,
+        timeout: float,
+    ) -> List[Dict[str, Any]]:
+        """
+        Poll console_messages[label] until new entries appear or timeout.
+        Returns the list of new message dicts appended after `before_count`.
+        """
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            entries: List[Any] = console_messages.get(label, [])
+            if len(entries) > before_count:
+                return list(entries[before_count:])
+            await asyncio.sleep(_POLL_INTERVAL)
+        # Return whatever arrived even if we timed out
+        entries = console_messages.get(label, [])
+        return list(entries[before_count:])
+
+    # ------------------------------------------------------------------
+    # execute
+    # ------------------------------------------------------------------
+
+    async def execute(self, **kwargs) -> Dict[str, Any]:  # noqa: C901
+        js_code: str = kwargs.get("js_code", "").strip()
+        target_webview: str = self.get_field("Browser ID") or ""
+        timeout: float = float(kwargs.get("timeout", _DEFAULT_WAIT))
+
+        if not js_code:
+            return {"error": "js_code is required and must not be empty."}
+
+        label = self._resolve_target(target_webview or None)
+        if not label:
+            return {
+                "error": (
+                    "Could not determine target webview. "
+                    "Please supply target_webview explicitly."
+                )
+            }
+
+        # Snapshot current console length so we can detect new messages.
+        before_count: int = len(console_messages.get(label, []))
+
+        # Wrap the user code in an async IIFE so top-level await works
+        # and unhandled errors surface as console.error output.
+        wrapped = (
+            "(async () => { try {\n"
+            + js_code
+            + "\n} catch (e) { console.error('[control_dom error]', e && (e.stack || e.message || String(e))); } })();"
+        )
+
+        try:
+            if not self.event_emitter:
+                return {"error": "event_emitter not available (tool not fully initialised)."}
+
+            await self.event_emitter.emit("eval", {"script": wrapped, "label": label})
+        except Exception as exc:
+            logger.error(f"[control_dom] emit eval failed: {exc}", exc_info=True)
+            return {"error": f"Failed to send script to webview: {exc}"}
+
+        # Collect console output that arrives within the timeout window.
+        new_messages = await self._collect_new_console(label, before_count, timeout)
+
+        # Build human-readable output lines.
+        output_lines: List[str] = []
+        has_error = False
+        for msg in new_messages:
+            mtype = msg.get("type", "log")
+            text = msg.get("text", "")
+            output_lines.append(f"[{mtype}] {text}")
+            if mtype == "error":
+                has_error = True
+
+        result: Dict[str, Any] = {
+            "label": label,
+            "console": output_lines,
+        }
+        if has_error:
+            result["warning"] = "One or more console.error() calls were recorded."
+        if not output_lines:
+            result["note"] = (
+                "No console output was captured within the timeout window. "
+                "Add console.log() calls to your js_code to verify execution."
+            )
+
+        return result

control_dom-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: control_dom
+Version: 0.1.0
+Summary: Evaluate JavaScript code inside a Tauri child webview.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: openchadpy>=0.1.23

control_dom-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+control_dom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+control_dom/main.py,sha256=vdF0mfU5uOq9Bm8RTjBew2o_XOihyLUwISCHeDk6BF0,6787
+control_dom-0.1.0.dist-info/METADATA,sha256=y2PK4zLZakQJTE229mLio-L9AKPZCvksRZokS9c8WB0,217
+control_dom-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+control_dom-0.1.0.dist-info/top_level.txt,sha256=oAOFPYp3QHhrMjhd255o0pHYLw-Dig_-YpnAc9D04Pw,12
+control_dom-0.1.0.dist-info/RECORD,,

control_dom-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

control_dom-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+control_dom