intuned-runtime 1.3.4__tar.gz → 1.3.6__tar.gz

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intuned-runtime
-Version: 1.3.4
+Version: 1.3.6
 Summary: Runtime SDK that powers browser automation projects running on Intuned
 License: Elastic-2.0
 License-File: LICENSE
@@ -27,6 +27,7 @@ Requires-Dist: jsonc-parser (>=1.1.5,<2.0.0)
 Requires-Dist: more-termcolor (>=1.1.3,<2.0.0)
 Requires-Dist: pathspec (>=0.12.1,<0.13.0)
 Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: pyee (>=13.0.0,<14.0.0)
 Requires-Dist: pyright (>=1.1.387,<2.0.0)
 Requires-Dist: python-dotenv (==1.0.1)
 Requires-Dist: pytimeparse (>=1.1.8,<2.0.0)

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/intuned_cli/controller/save.py

@@ -60,8 +60,8 @@ async def validate_intuned_project():
 
 
 def validate_project_name(project_name: str):
-    if len(project_name) > 50:
-        raise CLIError("Project name must be 50 characters or less.")
+    if len(project_name) > 200:
+        raise CLIError("Project name must be 200 characters or less.")
 
     project_name_regex = r"^[a-z0-9]+(?:[-_][a-z0-9]+)*$"
     if not re.match(project_name_regex, project_name):

intuned_runtime-1.3.6/intuned_runtime/captcha/__init__.py

@@ -0,0 +1,7 @@
+from runtime.helpers.extensions import on_captcha_event
+from runtime.helpers.extensions import wait_for_captcha_solve
+
+__all__ = [
+    "on_captcha_event",
+    "wait_for_captcha_solve",
+]

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "intuned-runtime"
-version = "1.3.4"
+version = "1.3.6"
 description = "Runtime SDK that powers browser automation projects running on Intuned"
 authors = [ "Intuned Developers <engineering@intunedhq.com>",]
 readme = "README.md"
@@ -52,6 +52,7 @@ pytimeparse = "^1.1.8"
 rich = "^14.1.0"
 jsonc-parser = "^1.1.5"
 pyyaml = "^6.0.3"
+pyee = "^13.0.0"
 
 [tool.poetry.scripts]
 intuned = "intuned_cli:run"

intuned_runtime-1.3.6/runtime/browser/extensions/__init__.py

@@ -0,0 +1,7 @@
+from .helpers import build_extensions_list
+from .intuned_extension_server import clean_intuned_extension_server
+
+__all__ = [
+    "build_extensions_list",
+    "clean_intuned_extension_server",
+]

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/runtime/browser/extensions/intuned_extension.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from playwright.async_api import BrowserContext
 
+from runtime.browser.extensions.intuned_extension_server import setup_intuned_extension_server
 from runtime.context.context import IntunedContext
 from runtime.env import get_functions_domain
 from runtime.env import get_project_id
@@ -50,13 +51,7 @@ async def get_intuned_worker(context: BrowserContext):
     return None
 
 
-async def get_intuned_extension_settings() -> dict[str, Any]:
-    intuned_json = await load_intuned_json()
-    captcha_settings: CaptchaSolverSettings = (
-        intuned_json.captcha_solver
-        if intuned_json and intuned_json.captcha_solver is not None
-        else CaptchaSolverSettings()
-    )
+async def get_intuned_extension_settings(captcha_settings: CaptchaSolverSettings) -> dict[str, Any]:
     context = IntunedContext.current()
     return {
         **captcha_settings.model_dump(mode="json"),
@@ -70,13 +65,20 @@ async def get_intuned_extension_settings() -> dict[str, Any]:
 async def setup_intuned_extension():
     if not is_intuned_extension_enabled():
         return
+    intuned_json = await load_intuned_json()
+    captcha_settings: CaptchaSolverSettings = (
+        intuned_json.captcha_solver
+        if intuned_json and intuned_json.captcha_solver is not None
+        else CaptchaSolverSettings()
+    )
+    await setup_intuned_extension_server(captcha_settings)
     intuned_extension_path = get_intuned_extension_path()
     if intuned_extension_path is None:
         logger.warning("Intuned extension path not found, intuned extension might not work properly")
         return
 
     settings_path = intuned_extension_path / "intunedSettings.json"
-    settings_data = await get_intuned_extension_settings()
+    settings_data = await get_intuned_extension_settings(captcha_settings)
 
     try:
         with open(settings_path, "w") as f:

intuned_runtime-1.3.6/runtime/browser/extensions/intuned_extension_server.py

@@ -0,0 +1,207 @@
+import asyncio
+import json
+import logging
+import threading
+from collections import deque
+from typing import Any
+from typing import Deque
+from typing import Literal
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import ValidationError
+from pyee.asyncio import AsyncIOEventEmitter
+from waitress.server import BaseWSGIServer
+from waitress.server import create_server
+from waitress.server import MultiSocketServer
+
+from runtime.types import CaptchaSolverSettings
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+CaptchaEvent = Literal[
+    "CAPTCHA_EXTENSION_READY", "CAPTCHA_DETECTED", "CAPTCHA_SOLVED", "HIT_LIMIT", "MAX_RETRIES_EXHAUSTED", "ERROR"
+]
+
+
+class EventRequest(BaseModel):
+    model_config = {"populate_by_name": True}
+    event: CaptchaEvent
+    # tab_id: str = Field(None, alias="tabId")
+    session_id: Optional[str] = Field(None, alias="sessionId")
+    payload: Optional[Any] = None
+
+
+class EventQueues:
+    queues: dict[CaptchaEvent, Deque[EventRequest]]
+
+    def __init__(self):
+        self.queues = {}
+
+
+class TabEventQueue:
+    events_queue: dict[str, EventQueues]
+    last_detection_event: Optional[EventRequest]
+
+    def __init__(self, tab_id: str):
+        self.tab_id = tab_id
+        self.events_queue = {}
+        self.last_detection_event = None
+
+
+class ExtensionServer:
+    tabs: dict[str, TabEventQueue]
+    is_healthy: bool = False
+    _server: Optional[MultiSocketServer | BaseWSGIServer] = None
+    _loop: Optional[asyncio.AbstractEventLoop] = None
+    _thread: Optional[threading.Thread] = None
+
+    def __init__(self):
+        self.tabs = dict()
+
+    def __call__(self, environ, start_response):
+        """WSGI application"""
+        path = environ.get("PATH_INFO", "")
+        method = environ["REQUEST_METHOD"]
+
+        if path == "/ingest" and method == "POST":
+            return self._handle_ingest(environ, start_response)
+
+        start_response("404 Not Found", [("Content-Type", "application/json")])
+        return [json.dumps({"error": "Not found"}).encode()]
+
+    def _handle_queue_event(self, event: EventRequest):
+        queueable_events: list[CaptchaEvent] = [
+            "CAPTCHA_DETECTED",
+            "CAPTCHA_SOLVED",
+            "HIT_LIMIT",
+            "MAX_RETRIES_EXHAUSTED",
+            "ERROR",
+        ]
+
+        if event.event not in queueable_events:
+            return
+        tab_id = "page-0"  # We will revisit on multi-tab support
+        if event.session_id is None:
+            return
+        if tab_id not in self.tabs:
+            self.tabs[tab_id] = TabEventQueue(tab_id=tab_id)
+        tab_info = self.tabs[tab_id]
+        if event.event == "CAPTCHA_DETECTED":
+            tab_info.last_detection_event = event
+            return
+
+        if event.session_id not in tab_info.events_queue:
+            tab_info.events_queue[event.session_id] = EventQueues()
+
+        event_queues = tab_info.events_queue[event.session_id]
+        if event.event not in event_queues.queues:
+            event_queues.queues[event.event] = deque(maxlen=5)
+
+        event_queues.queues[event.event].append(event)
+
+    def _handle_ingest(self, environ, start_response):
+        try:
+            global event_emitter
+            if event_emitter is None:
+                event_emitter = AsyncIOEventEmitter()
+            content_length = int(environ.get("CONTENT_LENGTH", 0))
+            body = environ["wsgi.input"].read(content_length)
+            data = json.loads(body)
+            event_data = EventRequest(**data)
+            if event_data.event == "CAPTCHA_EXTENSION_READY":
+                self.is_healthy = True
+            self._handle_queue_event(event=event_data)
+            if self._loop and not self._loop.is_closed():
+                self._loop.call_soon_threadsafe(event_emitter.emit, event_data.event, {})
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps({}).encode()]
+
+        except ValidationError as e:
+            start_response("400 Bad Request", [("Content-Type", "application/json")])
+            return [json.dumps({"error": e.errors()}).encode()]
+        except Exception as e:
+            logger.error(f"Error: {e}")
+            start_response("500 Internal Server Error", [("Content-Type", "application/json")])
+            return [json.dumps({"error": "Internal server error"}).encode()]
+
+    async def start(self, port: int = 3000, host: str = "0.0.0.0") -> None:
+        """Start server using daemon thread"""
+        self._loop = asyncio.get_running_loop()
+        self._server = create_server(self.__call__, host=host, port=port)
+
+        def _run_server():
+            try:
+                if self._server:
+                    self._server.run()
+            except OSError as err:
+                if err.errno != 9:
+                    raise
+
+        self._thread = threading.Thread(target=_run_server, daemon=True)
+        self._thread.start()
+
+    async def stop(self):
+        self._loop = None
+        if self._server:
+            self._server.close()
+
+            if self._thread and self._thread.is_alive():
+                self._thread.join(timeout=5.0)
+
+
+event_emitter: Optional[AsyncIOEventEmitter] = None
+extension_server: Optional[ExtensionServer] = None
+
+
+async def setup_intuned_extension_server(captcha_settings: Optional[CaptchaSolverSettings] = None):
+    global event_emitter, extension_server
+    if captcha_settings is None:
+        captcha_settings = CaptchaSolverSettings()
+    extension_server = ExtensionServer()
+    event_emitter = AsyncIOEventEmitter()
+    await extension_server.start(port=captcha_settings.port)
+
+
+async def clean_intuned_extension_server():
+    global event_emitter, extension_server
+    if extension_server is not None:
+        await extension_server.stop()
+        extension_server = None
+
+    if event_emitter is not None:
+        event_emitter.remove_all_listeners()
+        event_emitter = None
+
+
+def get_event_from_event_queue(
+    event: CaptchaEvent, tab_id: str = "page-0", session_id: str = ""
+) -> Optional[EventRequest]:
+    if extension_server is None:
+        raise RuntimeError("Extension server is not initialized or healthy")
+
+    tab_info = extension_server.tabs.get(tab_id)
+    if tab_info is None:
+        return None
+    if event == "CAPTCHA_DETECTED":
+        value = tab_info.last_detection_event
+        tab_info.last_detection_event = None
+        return value
+
+    if session_id not in tab_info.events_queue:
+        return None
+
+    event_queues = tab_info.events_queue[session_id]
+    if event not in event_queues.queues or len(event_queues.queues[event]) == 0:
+        return None
+
+    return event_queues.queues[event].popleft()
+
+
+def get_intuned_event_emitter() -> AsyncIOEventEmitter:
+    if event_emitter is None:
+        raise RuntimeError("Event emitter is not initliazed")
+    return event_emitter

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/runtime/browser/launch_chromium.py

@@ -12,6 +12,8 @@ from runtime.browser.extensions import build_extensions_list
 from runtime.browser.extensions.intuned_extension import get_intuned_worker
 from runtime.browser.extensions.intuned_extension import is_intuned_extension_enabled
 from runtime.browser.extensions.intuned_extension import setup_intuned_extension
+from runtime.browser.extensions.intuned_extension_server import clean_intuned_extension_server
+from runtime.browser.extensions.intuned_extension_server import setup_intuned_extension_server
 
 from .helpers import get_local_cdp_address
 from .helpers import get_proxy_env
@@ -67,6 +69,8 @@ async def launch_chromium(
     extra_args: list[str] = []
     async with async_playwright() as playwright:
         if cdp_address is not None:
+            if is_intuned_extension_enabled():
+                await setup_intuned_extension_server()
             browser: Browser = await playwright.chromium.connect_over_cdp(cdp_address)
             context = browser.contexts[0]
             user_preferences_dir = None
@@ -127,6 +131,10 @@ async def launch_chromium(
 
         context.set_default_timeout(timeout * 1000)
 
+        async def clean_up_after_close(*_: Any, **__: Any) -> None:
+            await remove_dir_after_close()
+            await clean_intuned_extension_server()
+
         async def remove_dir_after_close(*_: Any, **__: Any) -> None:
             if not dir_to_clean:
                 return
@@ -142,7 +150,7 @@ async def launch_chromium(
             )
             await process.wait()
 
-        context.once("close", remove_dir_after_close)
+        context.once("close", clean_up_after_close)
 
         yield context, context.pages[0]
 

intuned_runtime-1.3.6/runtime/helpers/extensions.py

@@ -0,0 +1,371 @@
+import asyncio
+import functools
+import logging
+from collections.abc import Awaitable
+from collections.abc import Callable
+from typing import Any
+from typing import Optional
+from typing import overload
+from typing import TypeVar
+
+from playwright.async_api import Page
+
+from runtime.browser.extensions.intuned_extension_server import CaptchaEvent
+from runtime.browser.extensions.intuned_extension_server import EventRequest
+from runtime.browser.extensions.intuned_extension_server import get_event_from_event_queue
+from runtime.browser.extensions.intuned_extension_server import get_intuned_event_emitter
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+# Overload 1: Direct call with page only (callable pattern)
+@overload
+async def wait_for_captcha_solve(
+    page: Page,
+    *,
+    timeout: int = 10_000,
+) -> None: ...
+
+
+# Overload 2: Wrapper pattern with page and func
+@overload
+async def wait_for_captcha_solve(
+    *,
+    page: Page,
+    func: Callable[[], Awaitable[Any]],
+    timeout: int = 10_000,
+    wait_for_network_settled: bool = True,
+) -> Any: ...
+
+
+# Overload 3: Decorator without arguments
+@overload
+def wait_for_captcha_solve(
+    func: Callable[..., Awaitable[Any]],
+) -> Callable[..., Awaitable[Any]]: ...
+
+
+# Overload 4: Decorator factory with arguments
+@overload
+def wait_for_captcha_solve(
+    *,
+    timeout: int = 10_000,
+    wait_for_network_settled: bool = True,
+) -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable[Any]]]: ...
+
+
+def wait_for_captcha_solve(
+    *args: Any,
+    **kwargs: Any,
+) -> Any:
+    """
+    Wait for CAPTCHA solve after performing an action or by itself.
+
+    Usage patterns:
+    1. Callable: await wait_for_captcha_solve(page, timeout=10_000)
+    2. Wrapper: await wait_for_captcha_solve(page=page, func=my_func, timeout=10_000)
+    3. Decorator: @wait_for_captcha_solve or @wait_for_captcha_solve()
+    4. Decorator with options: @wait_for_captcha_solve(timeout=10_000, wait_for_network_settled=True)
+
+    Args:
+        page: Playwright Page object
+        func: Optional callable to execute before waiting for captcha solve
+        timeout: Maximum time to wait in milliseconds (default: 10_000)
+        wait_for_network_settled: Whether to wait for network idle before checking captcha (default: True)
+    """
+
+    # Case 1a: Direct call with page only (callable pattern - positional)
+    # await wait_for_captcha_solve(page, timeout=10_000, wait_for_network_settled=True)
+    if len(args) == 1 and isinstance(args[0], Page):
+        page = args[0]
+        timeout = kwargs.get("timeout", 10_000)
+        wait_for_network_settled = kwargs.get("wait_for_network_settled", True)
+        return _wait_for_captcha_solve_core(
+            page=page,
+            func=None,
+            timeout=timeout,
+            wait_for_network_settled=wait_for_network_settled,
+        )
+
+    # Case 1b: Direct call with page only (callable pattern - keyword)
+    # await wait_for_captcha_solve(page=page, timeout=10_000, wait_for_network_settled=True)
+    if "page" in kwargs and "func" not in kwargs and len(args) == 0:
+        page = kwargs["page"]
+        timeout = kwargs.get("timeout", 10_000)
+        wait_for_network_settled = kwargs.get("wait_for_network_settled", True)
+
+        if not isinstance(page, Page):
+            raise ValueError(
+                "No Page object found in function arguments. 'page' parameter must be a Playwright Page object."
+            )
+
+        return _wait_for_captcha_solve_core(
+            page=page,
+            func=None,
+            timeout=timeout,
+            wait_for_network_settled=wait_for_network_settled,
+        )
+
+    # Case 2: Wrapper pattern with page and func as keyword arguments
+    # await wait_for_captcha_solve(page=page, func=func, timeout=10_000)
+    if "page" in kwargs and "func" in kwargs:
+        page = kwargs["page"]
+        func = kwargs["func"]
+        timeout = kwargs.get("timeout", 10_000)
+        wait_for_network_settled = kwargs.get("wait_for_network_settled", True)
+
+        if not isinstance(page, Page):
+            raise ValueError(
+                "No Page object found in function arguments. 'page' parameter must be a Playwright Page object."
+            )
+
+        return _wait_for_captcha_solve_core(
+            page=page,
+            func=func,
+            timeout=timeout,
+            wait_for_network_settled=wait_for_network_settled,
+        )
+
+    # Case 3: Decorator without arguments
+    # @wait_for_captcha_solve
+    if len(args) == 1 and callable(args[0]) and not isinstance(args[0], Page):
+        func = args[0]
+        return _create_decorated_function(func, timeout=10_000, wait_for_network_settled=True)  # type: ignore
+
+    # Case 4: Decorator factory with arguments (including empty parentheses)
+    # @wait_for_captcha_solve() or @wait_for_captcha_solve(timeout=10_000, wait_for_network_settled=True)
+    if len(args) == 0 and "page" not in kwargs and "func" not in kwargs:
+        timeout = kwargs.get("timeout", 10_000)
+        wait_for_network_settled = kwargs.get("wait_for_network_settled", True)
+
+        def decorator(func: Callable[..., Awaitable[Any]]) -> Callable[..., Awaitable[Any]]:
+            return _create_decorated_function(func, timeout=timeout, wait_for_network_settled=wait_for_network_settled)
+
+        return decorator
+
+    raise ValueError(
+        "Invalid usage. Valid patterns:\n"
+        "1. await wait_for_captcha_solve(page, timeout=10_000) or await wait_for_captcha_solve(page=page, timeout=10_000)\n"
+        "2. await wait_for_captcha_solve(page=page, func=func, timeout=10_000)\n"
+        "3. @wait_for_captcha_solve or @wait_for_captcha_solve()\n"
+        "4. @wait_for_captcha_solve(timeout=10_000, wait_for_network_settled=True)"
+    )
+
+
+def _create_decorated_function(
+    func: Callable[..., Awaitable[Any]],
+    timeout: int,
+    wait_for_network_settled: bool,
+) -> Callable[..., Awaitable[Any]]:
+    """Helper to create a decorated function with captcha solve waiting."""
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Find the page object in function arguments
+        page = next((arg for arg in args if isinstance(arg, Page)), None)
+        if page is None:
+            page = kwargs.get("page")
+
+        if not page or not isinstance(page, Page):
+            logger.error(
+                "No Page object found in function arguments. The decorated function must have a 'page' parameter or receive a Page object as an argument."
+            )
+            raise ValueError(
+                "No Page object found in function arguments. The decorated function must have a 'page' parameter or receive a Page object as an argument."
+            )
+
+        async def func_with_args():
+            return await func(*args, **kwargs)
+
+        return await _wait_for_captcha_solve_core(
+            page=page,
+            func=func_with_args,
+            timeout=timeout,
+            wait_for_network_settled=wait_for_network_settled,
+        )
+
+    return wrapper
+
+
+async def _wait_for_captcha_solve_core(
+    *,
+    page: Page,
+    func: Optional[Callable[..., Awaitable[Any]]],
+    timeout: int = 10_000,
+    wait_for_network_settled: bool = True,
+):
+    """Core implementation of captcha solve waiting logic."""
+    if not isinstance(page, Page):
+        raise ValueError("No Page object found in function arguments. Page parameter must be a Playwright Page object.")
+
+    logger.debug(f"Page object: {page}")
+
+    result = None
+    if func is not None:
+        result = await func()
+
+    if wait_for_network_settled:
+        try:
+            await page.wait_for_load_state("networkidle", timeout=timeout)
+        except Exception as e:
+            logger.debug(f"Network idle wait failed: {e}")
+
+    detection_event: EventRequest
+    try:
+        detection_event = await wait_for_captcha_event("CAPTCHA_DETECTED", timeout=timeout)
+    except asyncio.TimeoutError:
+        logger.info("CAPTCHA Detection timed out")
+        return result
+    except Exception as e:
+        logger.error(f"Error while waiting for captcha: {e}")
+        raise e
+
+    logger.info("CAPTCHA Detected, awaiting result...")
+    if detection_event.session_id is None:
+        raise RuntimeError("CAPTCHA_DETECTED event missing session ID")
+    try:
+        solved_task = asyncio.create_task(
+            wait_for_captcha_event("CAPTCHA_SOLVED", session_id=detection_event.session_id, timeout=timeout)
+        )
+        max_retries_task = asyncio.create_task(
+            wait_for_captcha_event("MAX_RETRIES_EXHAUSTED", session_id=detection_event.session_id, timeout=timeout)
+        )
+        error_task = asyncio.create_task(
+            wait_for_captcha_event("ERROR", session_id=detection_event.session_id, timeout=timeout)
+        )
+        hit_limit_task = asyncio.create_task(
+            wait_for_captcha_event("HIT_LIMIT", session_id=detection_event.session_id, timeout=timeout)
+        )
+
+        done, pending = await asyncio.wait(
+            [solved_task, max_retries_task, error_task, hit_limit_task], return_when=asyncio.FIRST_COMPLETED
+        )
+
+        # Cancel pending tasks
+        for task in pending:
+            task.cancel()
+
+        # Get the completed task
+        completed = done.pop()
+        exception = completed.exception()
+        if exception:
+            raise exception
+
+        # Check which task completed
+        if completed == max_retries_task:
+            raise RuntimeError("Reached maximum retries on solving captcha")
+        elif completed == error_task:
+            raise RuntimeError("Captcha error")
+        elif completed == hit_limit_task:
+            raise RuntimeError("Insufficient resource credits to execute the captcha solve")
+
+        logger.info("CAPTCHA solved successfully")
+
+    except asyncio.TimeoutError as e:
+        logger.error("CAPTCHA Result timeout")
+        raise RuntimeError("CAPTCHA Solving timeout") from e
+    except Exception as e:
+        logger.error(f"CAPTCHA solve error: {e}")
+        raise
+
+    return result
+
+
+def on_captcha_event(
+    event: CaptchaEvent,
+    f: Callable[..., Awaitable[None] | None],
+    *args,
+    **kwargs,
+):
+    """
+    Register a callback for a captcha event.
+
+    Args:
+        event: The captcha event to listen for
+        f: The callback function to execute
+        *args: Additional arguments to pass to the callback
+        **kwargs: Additional keyword arguments to pass to the callback
+    """
+    emitter = get_intuned_event_emitter()
+
+    async def wrapper(*_, **__):
+        result = f(*args, **kwargs)
+        if asyncio.iscoroutine(result):
+            await result
+
+    emitter.on(event, wrapper)
+
+
+def once_captcha_event(
+    event: CaptchaEvent,
+    f: Callable[..., Awaitable[None] | None],
+    *args,
+    **kwargs,
+):
+    """
+    Register a one-time callback for a captcha event.
+
+    Args:
+        event: The captcha event to listen for
+        f: The callback function to execute
+        *args: Additional arguments to pass to the callback
+        **kwargs: Additional keyword arguments to pass to the callback
+    """
+    event_emitter = get_intuned_event_emitter()
+
+    async def wrapper(*_, **__):
+        result = f(*args, **kwargs)
+        if asyncio.iscoroutine(result):
+            await result
+
+    event_emitter.once(event, wrapper)
+
+
+async def wait_for_captcha_event(event: CaptchaEvent, session_id: str = "", timeout: int = 10_000) -> EventRequest:
+    """
+    Wait for a captcha event to be emitted.
+
+    Args:
+        event: Event name to wait for
+        session_id: ID for the captcha solve session
+        timeout: Optional timeout in milliseconds (default: 10_000)
+
+    Returns:
+        The event payload
+
+    Raises:
+        RuntimeError: If the event emitter is not initialized
+        asyncio.TimeoutError: If the timeout is reached before the event fires
+    """
+
+    # Check if event was already fired before attaching the listener
+    event_from_queue = get_event_from_event_queue(
+        event=event, tab_id="page-0", session_id=session_id
+    )  # For now we stick with page-0, will revisit on multi page support
+    if event_from_queue is not None:
+        return event_from_queue
+
+    emitter = get_intuned_event_emitter()
+    if emitter is None:
+        raise RuntimeError("Intuned Extensions listener is not initialized")
+
+    loop = asyncio.get_event_loop()
+    future: asyncio.Future = asyncio.Future()
+
+    def handler(*_, **__):
+        if not future.done():
+            consumed_event = get_event_from_event_queue(session_id=session_id, event=event)
+            loop.call_soon_threadsafe(future.set_result, consumed_event)
+
+    emitter.once(event, handler)
+
+    try:
+        if timeout:
+            return await asyncio.wait_for(future, timeout=timeout / 1000)
+        else:
+            return await future
+    except (asyncio.TimeoutError, asyncio.CancelledError):
+        emitter.remove_listener(event, handler)
+        raise

{intuned_runtime-1.3.4 → intuned_runtime-1.3.6}/runtime/types/settings_types.py

@@ -1,3 +1,5 @@
+import os
+import socket
 from typing import List
 from typing import Literal
 
@@ -5,6 +7,14 @@ from pydantic import BaseModel
 from pydantic import Field
 
 
+def get_intuned_captcha_extension_port():
+    if "INTUNED_CAPTCHA_EXTENSION_PORT" in os.environ:
+        return int(os.environ["INTUNED_CAPTCHA_EXTENSION_PORT"])
+    with socket.socket() as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
 class CaptchaSettings(BaseModel):
     enabled: bool = Field(default=False)
 
@@ -47,6 +57,7 @@ class CaptchaSolverSettings(BaseModel):
     }
 
     enabled: bool = Field(default=False)
+    port: int = Field(default_factory=get_intuned_captcha_extension_port)
     cloudflare: CaptchaSettings = Field(default_factory=CaptchaSettings)
     google_recaptcha_v2: CaptchaSettings = Field(alias="googleRecaptchaV2", default_factory=CaptchaSettings)
     google_recaptcha_v3: CaptchaSettings = Field(alias="googleRecaptchaV3", default_factory=CaptchaSettings)

intuned_runtime-1.3.4/runtime/browser/extensions/__init__.py

@@ -1,3 +0,0 @@
-from .helpers import build_extensions_list
-
-__all__ = ["build_extensions_list"]