model-compose 0.4.47__tar.gz → 0.4.49__tar.gz

{model_compose-0.4.47/src/model_compose.egg-info → model_compose-0.4.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.47
+Version: 0.4.49
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.47 → model_compose-0.4.49}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.47"
+version = "0.4.49"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.47 → model_compose-0.4.49}/src/mindor/cli/compose.py

@@ -203,6 +203,12 @@ def stop_command(
     required=False,
     help="Path to save the output result as a file."
 )
+@click.option(
+    "--metadata", "-m", "metadata_json",
+    type=str,
+    required=False,
+    help="JSON metadata string to pass through the workflow and echo back in the response.",
+)
 @click.option("--auto-resume", is_flag=True, help="Automatically resume interrupts without prompting.")
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
@@ -213,6 +219,7 @@ def run_command(
     env_files: List[Path],
     env_data: List[str],
     output_path: Optional[Path],
+    metadata_json: Optional[str],
     auto_resume: bool,
     verbose: bool
 ) -> None:
@@ -224,10 +231,11 @@ def run_command(
         try:
             config = _load_compose_config(config_files, env_files, env_data)
             input = json.loads(input_json) if input_json else {}
+            metadata = json.loads(metadata_json) if metadata_json else None
             is_tty = sys.stdin.isatty()
 
             manager = ComposeManager(config, daemon=False)
-            state = await manager.run_workflow(workflow_id or "__default__", input, output_path, verbose)
+            state = await manager.run_workflow(workflow_id or "__default__", input, output_path, verbose, metadata=metadata)
 
             while state.status == TaskStatus.INTERRUPTED:
                 if not auto_resume and not is_tty:
@@ -280,7 +288,6 @@ def validate_command(
     env_data: List[str],
     verbose: bool
 ) -> None:
-    """Validate the compose configuration without starting any services."""
     from mindor.core.compose import validate_compose_config
     config_files = ctx.obj.get("config_files", [])
     try:

model_compose-0.4.49/src/mindor/core/component/services/web_browser/__init__.py

@@ -0,0 +1 @@
+from .web_browser import *

model_compose-0.4.49/src/mindor/core/component/services/web_browser/base.py

@@ -0,0 +1,117 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.component import WebBrowserComponentConfig, WebBrowserDriver
+from mindor.dsl.schema.action import WebBrowserActionConfig
+from mindor.core.foundation import AsyncService
+from ...context import ComponentActionContext
+
+class WebBrowserSession(ABC):
+    """Abstract browser session exposing high-level browser actions."""
+
+    # ---- Navigation ----
+
+    @abstractmethod
+    async def navigate(self, url: str, wait_until: str, timeout: float) -> Dict[str, Any]:
+        pass
+
+    # ---- Interaction ----
+
+    @abstractmethod
+    async def click(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        x: Optional[int],
+        y: Optional[int],
+        timeout: float
+    ) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def input(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        text: str,
+        clear_first: bool,
+        timeout: float
+    ) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def scroll(self, selector: Optional[str], x: int, y: int) -> Dict[str, Any]:
+        pass
+
+    # ---- Query ----
+
+    @abstractmethod
+    async def wait_for(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        condition: str,
+        timeout: float
+    ) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def extract(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        extract_mode: str,
+        attribute: Optional[str],
+        multiple: bool
+    ) -> Any:
+        pass
+
+    @abstractmethod
+    async def evaluate(self, expression: str) -> Any:
+        pass
+
+    # ---- Capture ----
+
+    @abstractmethod
+    async def screenshot(
+        self,
+        full_page: bool,
+        selector: Optional[str],
+        format: str,
+        quality: Optional[int]
+    ) -> str:
+        pass
+
+    # ---- State ----
+
+    @abstractmethod
+    async def get_cookies(self, urls: Optional[List[str]]) -> List[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    async def set_cookies(self, cookies: List[Dict[str, Any]]) -> Dict[str, Any]:
+        pass
+
+    # ---- Lifecycle ----
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+class WebBrowserService(AsyncService):
+    def __init__(self, id: str, config: WebBrowserComponentConfig, daemon: bool):
+        super().__init__(daemon)
+
+        self.id: str = id
+        self.config: WebBrowserComponentConfig = config
+
+    @abstractmethod
+    async def create_session(self) -> WebBrowserSession:
+        pass
+
+def register_web_browser_service(driver: WebBrowserDriver):
+    def decorator(cls: Type[WebBrowserService]) -> Type[WebBrowserService]:
+        WebBrowserServiceRegistry[driver] = cls
+        return cls
+    return decorator
+
+WebBrowserServiceRegistry: Dict[WebBrowserDriver, Type[WebBrowserService]] = {}

model_compose-0.4.49/src/mindor/core/component/services/web_browser/drivers/__init__.py

@@ -0,0 +1,2 @@
+from .chrome import *
+from .playwright import *

model_compose-0.4.49/src/mindor/core/component/services/web_browser/drivers/chrome.py

@@ -0,0 +1,323 @@
+from typing import Optional, Dict, List, Any
+from mindor.dsl.schema.component import ChromeWebBrowserComponentConfig, WebBrowserDriver
+from mindor.core.utils.cdp_client import CdpClient
+from ..base import WebBrowserService, WebBrowserSession, register_web_browser_service
+import asyncio
+
+
+class ChromeBrowserSession(WebBrowserSession):
+    """Browser session backed by a persistent CDP connection."""
+
+    def __init__(self, client: CdpClient):
+        self.client = client
+        self._lifecycle_enabled = False
+
+    # ---- Navigation ----
+
+    async def navigate(self, url: str, wait_until: str, timeout: float) -> Dict[str, Any]:
+        await self._ensure_page_enabled()
+
+        loop = asyncio.get_running_loop()
+        nav_done: asyncio.Future = loop.create_future()
+
+        event_map = {
+            "load": "Page.loadEventFired",
+            "domcontentloaded": "Page.domContentEventFired",
+            "networkidle": "Page.lifecycleEvent",
+        }
+        event_method = event_map.get(wait_until, "Page.loadEventFired")
+
+        async def _on_event(params):
+            if not nav_done.done():
+                if wait_until == "networkidle":
+                    if params.get("name") == "networkIdle":
+                        nav_done.set_result(True)
+                else:
+                    nav_done.set_result(True)
+
+        self.client.on_event(event_method, _on_event)
+        try:
+            result = await self.client.send_command("Page.navigate", {"url": url})
+            await asyncio.wait_for(nav_done, timeout=timeout)
+        except asyncio.TimeoutError:
+            raise TimeoutError(f"Navigation to '{url}' did not complete within {timeout}s")
+        finally:
+            self.client.remove_event_listener(event_method, _on_event)
+
+        return {"url": url, "frameId": result.get("frameId")}
+
+    # ---- Interaction ----
+
+    async def click(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        x: Optional[int],
+        y: Optional[int],
+        timeout: float
+    ) -> Dict[str, Any]:
+        if x is not None and y is not None:
+            cx, cy = int(x), int(y)
+        else:
+            cx, cy = await self._get_element_center(selector, xpath, timeout)
+
+        for event in ("mousePressed", "mouseReleased"):
+            await self.client.send_command("Input.dispatchMouseEvent", {
+                "type": event, "x": cx, "y": cy, "button": "left", "clickCount": 1
+            })
+
+        return { "x": cx, "y": cy }
+
+    async def input(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        text: str,
+        clear_first: bool,
+        timeout: float
+    ) -> Dict[str, Any]:
+        cx, cy = await self._get_element_center(selector, xpath, timeout)
+
+        # Focus element by clicking
+        for event_type in ("mousePressed", "mouseReleased"):
+            await self.client.send_command("Input.dispatchMouseEvent", {
+                "type": event_type, "x": cx, "y": cy, "button": "left", "clickCount": 1
+            })
+
+        if clear_first:
+            # Select all and delete
+            await self.client.send_command("Input.dispatchKeyEvent", {
+                "type": "keyDown", "key": "a", "modifiers": 2  # Ctrl+A
+            })
+            await self.client.send_command("Input.dispatchKeyEvent", {
+                "type": "keyUp", "key": "a", "modifiers": 2
+            })
+            await self.client.send_command("Input.dispatchKeyEvent", {
+                "type": "keyDown", "key": "Backspace"
+            })
+            await self.client.send_command("Input.dispatchKeyEvent", {
+                "type": "keyUp", "key": "Backspace"
+            })
+
+        for char in text:
+            await self.client.send_command("Input.dispatchKeyEvent", {
+                "type": "char", "text": char
+            })
+
+        return { "typed": text }
+
+    async def scroll(self, selector: Optional[str], x: int, y: int) -> Dict[str, Any]:
+        if selector:
+            js = f"""(function() {{
+                const el = document.querySelector({repr(selector)});
+                if (el) el.scrollBy({x}, {y});
+            }})()"""
+        else:
+            js = f"window.scrollBy({x}, {y})"
+
+        await self.client.send_command("Runtime.evaluate", { "expression": js, "returnByValue": True })
+        return { "scrolled_x": x, "scrolled_y": y }
+
+    # ---- Query ----
+
+    async def wait_for(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        condition: str,
+        timeout: float
+    ) -> Dict[str, Any]:
+        js = self._build_wait_condition_js(selector, xpath, condition)
+        deadline = asyncio.get_event_loop().time() + timeout
+
+        while asyncio.get_event_loop().time() < deadline:
+            result = await self.client.send_command("Runtime.evaluate", {
+                "expression": js, "returnByValue": True
+            })
+            value = result.get("result", {}).get("value")
+            if value:
+                return {"found": True}
+            await asyncio.sleep(0.3)
+
+        target = selector or xpath
+        raise TimeoutError(f"wait_for '{target}' ({condition}) timed out after {timeout}s")
+
+    async def extract(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        extract_mode: str,
+        attribute: Optional[str],
+        multiple: bool
+    ) -> Any:
+        js = self._build_extract_js(selector, xpath, extract_mode, attribute, multiple)
+        result = await self.client.send_command("Runtime.evaluate", {
+            "expression": js, "returnByValue": True
+        })
+        if "exceptionDetails" in result:
+            raise RuntimeError(f"Extract JavaScript error: { result['exceptionDetails'] }")
+        return result.get("result", {}).get("value")
+
+    async def evaluate(self, expression: str) -> Any:
+        result = await self.client.send_command("Runtime.evaluate", {
+            "expression": expression,
+            "returnByValue": True,
+            "awaitPromise": True,
+        })
+
+        if "exceptionDetails" in result:
+            raise RuntimeError(f"JavaScript error: { result['exceptionDetails'] }")
+
+        return result.get("result", {}).get("value")
+
+    # ---- Capture ----
+
+    async def screenshot(
+        self,
+        full_page: bool,
+        selector: Optional[str],
+        format: str,
+        quality: Optional[int]
+    ) -> str:
+        params: Dict[str, Any] = {"format": format}
+        if format == "jpeg" and quality is not None:
+            params["quality"] = int(quality)
+        if full_page:
+            params["captureBeyondViewport"] = True
+        if selector:
+            box = await self._find_element_bounding_box(selector, None)
+            if box:
+                params["clip"] = {**box, "scale": 1}
+
+        result = await self.client.send_command("Page.captureScreenshot", params)
+        return result["data"]  # base64-encoded
+
+    # ---- State ----
+
+    async def get_cookies(self, urls: Optional[List[str]]) -> List[Dict[str, Any]]:
+        params = {}
+        if urls:
+            params["urls"] = urls
+        result = await self.client.send_command("Network.getCookies", params)
+        return result.get("cookies", [])
+
+    async def set_cookies(self, cookies: List[Dict[str, Any]]) -> Dict[str, Any]:
+        await self.client.send_command("Network.setCookies", {"cookies": cookies})
+        return {"set": len(cookies)}
+
+    # ---- Lifecycle ----
+
+    async def close(self) -> None:
+        await self.client.close()
+
+    # ---- Internal helpers ----
+
+    async def _ensure_page_enabled(self) -> None:
+        await self.client.send_command("Page.enable")
+        if not self._lifecycle_enabled:
+            await self.client.send_command("Page.setLifecycleEventsEnabled", {"enabled": True})
+            self._lifecycle_enabled = True
+
+    async def _get_element_center(self, selector: Optional[str], xpath: Optional[str], timeout: float) -> tuple:
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            box = await self._find_element_bounding_box(selector, xpath)
+            if box:
+                cx = int(box["x"] + box["width"] / 2)
+                cy = int(box["y"] + box["height"] / 2)
+                return cx, cy
+            await asyncio.sleep(0.3)
+
+        target = selector or xpath
+        raise TimeoutError(f"Element '{target}' not found within {timeout}s")
+
+    async def _find_element_bounding_box(self, selector: Optional[str], xpath: Optional[str]) -> Optional[Dict]:
+        if selector:
+            js = f"""(function() {{
+                const el = document.querySelector({repr(selector)});
+                if (!el) return null;
+                const r = el.getBoundingClientRect();
+                return {{x: r.left, y: r.top, width: r.width, height: r.height}};
+            }})()"""
+        else:
+            js = f"""(function() {{
+                const result = document.evaluate({repr(xpath)}, document, null,
+                    XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+                const el = result.singleNodeValue;
+                if (!el) return null;
+                const r = el.getBoundingClientRect();
+                return {{x: r.left, y: r.top, width: r.width, height: r.height}};
+            }})()"""
+
+        result = await self.client.send_command("Runtime.evaluate", {
+            "expression": js, "returnByValue": True
+        })
+        return result.get("result", {}).get("value")
+
+    def _build_wait_condition_js(self, selector: Optional[str], xpath: Optional[str], condition: str) -> str:
+        if selector:
+            target_js = f"document.querySelector({repr(selector)})"
+        else:
+            target_js = (f"document.evaluate({repr(xpath)}, document, null, "
+                         f"XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue")
+
+        if condition == "present":
+            return f"!!({target_js})"
+        if condition == "visible":
+            return f"""(function() {{
+                const el = {target_js};
+                if (!el) return false;
+                const s = window.getComputedStyle(el);
+                return s.display !== 'none' && s.visibility !== 'hidden' && s.opacity !== '0';
+            }})()"""
+        if condition == "hidden":
+            return f"""(function() {{
+                const el = {target_js};
+                if (!el) return true;
+                const s = window.getComputedStyle(el);
+                return s.display === 'none' || s.visibility === 'hidden' || s.opacity === '0';
+            }})()"""
+        return "true"
+
+    def _build_extract_js(self, selector: Optional[str], xpath: Optional[str],
+                          extract_mode: str, attribute: Optional[str], multiple: bool) -> str:
+        if selector:
+            if multiple:
+                get_els = f"Array.from(document.querySelectorAll({repr(selector)}))"
+            else:
+                get_els = f"[document.querySelector({repr(selector)})].filter(Boolean)"
+        else:
+            if multiple:
+                get_els = f"""(function() {{
+                    const r = document.evaluate({repr(xpath)}, document, null,
+                        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+                    return Array.from({{length: r.snapshotLength}}, (_, i) => r.snapshotItem(i));
+                }})()"""
+            else:
+                get_els = (f"[document.evaluate({repr(xpath)}, document, null, "
+                           f"XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue].filter(Boolean)")
+
+        if extract_mode == "text":
+            map_fn = "el => el.innerText || el.textContent || ''"
+        elif extract_mode == "html":
+            map_fn = "el => el.outerHTML"
+        else:  # attribute
+            map_fn = f"el => el.getAttribute({repr(attribute)})"
+
+        if multiple:
+            return f"({get_els}).map({map_fn})"
+        else:
+            return f"""(function() {{ const els = {get_els}; return els.length ? ({get_els}).map({map_fn})[0] : null; }})()"""
+
+
+@register_web_browser_service(WebBrowserDriver.CHROME)
+class ChromeWebBrowserService(WebBrowserService):
+    async def create_session(self) -> ChromeBrowserSession:
+        if self.config.endpoint:
+            client = CdpClient(self.config.endpoint)
+            await client.connect()
+        else:
+            client = await CdpClient.from_host_port(
+                self.config.host, self.config.port, self.config.target_index
+            )
+        return ChromeBrowserSession(client)

model_compose-0.4.49/src/mindor/core/component/services/web_browser/drivers/playwright.py

@@ -0,0 +1,178 @@
+from typing import Optional, Dict, List, Any
+from mindor.dsl.schema.component import PlaywrightWebBrowserComponentConfig, WebBrowserDriver
+from ..base import WebBrowserService, WebBrowserSession, register_web_browser_service
+
+
+class PlaywrightBrowserSession(WebBrowserSession):
+    """Browser session backed by a Playwright page."""
+
+    def __init__(self, browser: Any, page: Any):
+        self._browser = browser
+        self._page = page
+
+    # ---- Navigation ----
+
+    async def navigate(self, url: str, wait_until: str, timeout: float) -> Dict[str, Any]:
+        response = await self._page.goto(url, wait_until=wait_until, timeout=timeout * 1000)
+        return { "url": url, "status": response.status if response else None }
+
+    # ---- Interaction ----
+
+    async def click(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        x: Optional[int],
+        y: Optional[int],
+        timeout: float
+    ) -> Dict[str, Any]:
+        if x is not None and y is not None:
+            await self._page.mouse.click(x, y)
+            return {"x": x, "y": y}
+
+        locator = self._resolve_locator(selector, xpath)
+        box = await locator.bounding_box(timeout=timeout * 1000)
+        if not box:
+            target = selector or xpath
+            raise TimeoutError(f"Element '{target}' not found within {timeout}s")
+        cx = int(box["x"] + box["width"] / 2)
+        cy = int(box["y"] + box["height"] / 2)
+        await self._page.mouse.click(cx, cy)
+        return {"x": cx, "y": cy}
+
+    async def input(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        text: str,
+        clear_first: bool,
+        timeout: float
+    ) -> Dict[str, Any]:
+        locator = self._resolve_locator(selector, xpath)
+        if clear_first:
+            await locator.fill(text, timeout=timeout * 1000)
+        else:
+            await locator.press_sequentially(text, timeout=timeout * 1000)
+        return {"typed": text}
+
+    async def scroll(self, selector: Optional[str], x: int, y: int) -> Dict[str, Any]:
+        if selector:
+            await self._page.evaluate(
+                f"""(function() {{
+                    const el = document.querySelector({repr(selector)});
+                    if (el) el.scrollBy({x}, {y});
+                }})()"""
+            )
+        else:
+            await self._page.evaluate(f"window.scrollBy({x}, {y})")
+        return {"scrolled_x": x, "scrolled_y": y}
+
+    # ---- Query ----
+
+    async def wait_for(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        condition: str,
+        timeout: float
+    ) -> Dict[str, Any]:
+        locator = self._resolve_locator(selector, xpath)
+        state_map = {
+            "present": "attached",
+            "visible": "visible",
+            "hidden": "hidden",
+        }
+        state = state_map.get(condition, "visible")
+        await locator.wait_for(state=state, timeout=timeout * 1000)
+        return {"found": True}
+
+    async def extract(
+        self,
+        selector: Optional[str],
+        xpath: Optional[str],
+        extract_mode: str,
+        attribute: Optional[str],
+        multiple: bool
+    ) -> Any:
+        locator = self._resolve_locator(selector, xpath)
+
+        if multiple:
+            elements = await locator.all()
+            results = []
+            for el in elements:
+                results.append(await self._extract_from_element(el, extract_mode, attribute))
+            return results
+        else:
+            return await self._extract_from_element(locator.first, extract_mode, attribute)
+
+    async def evaluate(self, expression: str) -> Any:
+        return await self._page.evaluate(expression)
+
+    # ---- Capture ----
+
+    async def screenshot(
+        self,
+        full_page: bool,
+        selector: Optional[str],
+        format: str,
+        quality: Optional[int]
+    ) -> str:
+        import base64
+
+        params: Dict[str, Any] = {"type": format, "full_page": full_page}
+        if format == "jpeg" and quality is not None:
+            params["quality"] = int(quality)
+
+        if selector:
+            locator = self._page.locator(selector)
+            data = await locator.screenshot(**params)
+        else:
+            data = await self._page.screenshot(**params)
+
+        return base64.b64encode(data).decode("ascii")
+
+    # ---- State ----
+
+    async def get_cookies(self, urls: Optional[List[str]]) -> List[Dict[str, Any]]:
+        context = self._page.context
+        cookies = await context.cookies(urls or [])
+        return cookies
+
+    async def set_cookies(self, cookies: List[Dict[str, Any]]) -> Dict[str, Any]:
+        context = self._page.context
+        await context.add_cookies(cookies)
+        return { "set": len(cookies) }
+
+    # ---- Lifecycle ----
+
+    async def close(self) -> None:
+        await self._browser.close()
+
+    # ---- Internal helpers ----
+
+    def _resolve_locator(self, selector: Optional[str], xpath: Optional[str]) -> Any:
+        if selector:
+            return self._page.locator(selector)
+        return self._page.locator(f"xpath={xpath}")
+
+    async def _extract_from_element(self, el: Any, extract_mode: str, attribute: Optional[str]) -> Any:
+        if extract_mode == "text":
+            return await el.inner_text()
+        if extract_mode == "html":
+            return await el.evaluate("el => el.outerHTML")
+        # attribute
+        return await el.get_attribute(attribute)
+
+
+@register_web_browser_service(WebBrowserDriver.PLAYWRIGHT)
+class PlaywrightWebBrowserService(WebBrowserService):
+    async def create_session(self) -> PlaywrightBrowserSession:
+        from playwright.async_api import async_playwright
+
+        pw = await async_playwright().start()
+
+        launcher = getattr(pw, self.config.browser)
+        browser = await launcher.launch(headless=self.config.headless, args=self.config.args or None)
+        page = await browser.new_page()
+
+        return PlaywrightBrowserSession(browser, page)