intuned-runtime 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

runtime/browser/launch_browser.py

@@ -1,31 +1,59 @@
 from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack
+from typing import AsyncContextManager
+from typing import overload
+from typing import TYPE_CHECKING
 
-from playwright.async_api import ProxySettings
+if TYPE_CHECKING:
+    from playwright.async_api import BrowserContext
+    from playwright.async_api import Page
+    from playwright.async_api import ProxySettings
 
 from runtime.env import get_browser_type
+from runtime.errors.run_api_errors import AutomationError
 
 from .launch_camoufox import launch_camoufox
 from .launch_chromium import launch_chromium
 
 
+@overload
+def launch_browser(
+    *,
+    cdp_address: str,
+) -> "AsyncContextManager[tuple['BrowserContext', 'Page']]": ...
+
+
+@overload
+def launch_browser(
+    proxy: "ProxySettings | None" = None,
+    headless: bool = False,
+    *,
+    cdp_port: int | None = None,
+) -> "AsyncContextManager[tuple['BrowserContext', 'Page']]": ...
+
+
 @asynccontextmanager
 async def launch_browser(
-    proxy: ProxySettings | None = None,
+    proxy: "ProxySettings | None" = None,
     headless: bool = False,
     *,
+    cdp_port: int | None = None,
     cdp_address: str | None = None,
 ):
     browser_type = get_browser_type()
-    match browser_type:
-        case "camoufox":
-            async with launch_camoufox(headless=headless, proxy=proxy) as (context, page):
-                try:
-                    yield context, page
-                finally:
-                    await context.close()
-        case "chromium" | _:
-            async with launch_chromium(headless=headless, cdp_address=cdp_address, proxy=proxy) as (context, page):
-                try:
-                    yield context, page
-                finally:
-                    await context.close()
+    async with AsyncExitStack() as stack:
+        match browser_type:
+            case "camoufox":
+                if cdp_address:
+                    raise AutomationError(ValueError("CDP address is not supported with Camoufox"))
+                if cdp_port:
+                    raise AutomationError(ValueError("CDP port is not supported with Camoufox"))
+                context, page = await stack.enter_async_context(launch_camoufox(headless=headless, proxy=proxy))
+            case "chromium" | _:
+                context, page = await stack.enter_async_context(
+                    launch_chromium(headless=headless, cdp_address=cdp_address, cdp_port=cdp_port, proxy=proxy)
+                )
+        try:
+            yield context, page
+        finally:
+            await context.close()

runtime/browser/launch_chromium.py

@@ -4,46 +4,19 @@ import logging
 import os
 from contextlib import asynccontextmanager
 from typing import Any
+from typing import TYPE_CHECKING
 
 import anyio
 
+from .helpers import get_local_cdp_address
 from .helpers import get_proxy_env
+from .helpers import wait_on_cdp_address
 
 logger = logging.getLogger(__name__)
 
-
-chromium_launch_args_to_ignore = [
-    "--disable-field-trial-config",
-    "--disable-background-networking",
-    "--enable-features=NetworkService,NetworkServiceInProcess",
-    "--disable-background-timer-throttling",
-    "--disable-backgrounding-occluded-windows",
-    "--disable-back-forward-cache",
-    "--disable-breakpad",
-    "--disable-client-side-phishing-detection",
-    "--disable-component-extensions-with-background-pages",
-    "--disable-component-update",
-    "--no-default-browser-check",
-    "--disable-default-apps",
-    "--disable-dev-shm-usage",
-    "--disable-extensions",
-    "--disable-features=ImprovedCookieControls,LazyFrameLoading,GlobalMediaControls,DestroyProfileOnBrowserClose,MediaRouter,DialMediaRouteProvider,AcceptCHFrame,AutoExpandDetailsElement,CertificateTransparencyComponentUpdater,AvoidUnnecessaryBeforeUnloadCheckSync,Translate,TranslateUI",
-    "--allow-pre-commit-input",
-    "--disable-hang-monitor",
-    "--disable-ipc-flooding-protection",
-    "--disable-prompt-on-repost",
-    "--disable-renderer-backgrounding",
-    "--force-color-profile=srgb",
-    "--metrics-recording-only",
-    "--no-first-run",
-    "--enable-automation",
-    "--password-store=basic",
-    "--use-mock-keychain",
-    "--no-service-autorun",
-    "--export-tagged-pdf",
-    "--enable-use-zoom-for-dsf=false",
-    "--disable-popup-blocking",
-]
+if TYPE_CHECKING:
+    from playwright.async_api import ProxySettings
+    from playwright.async_api import ViewportSize
 
 
 async def create_user_dir_with_preferences():
@@ -78,21 +51,17 @@ default_user_agent = (
 async def launch_chromium(
     headless: bool = True,
     timeout: int = 10,
+    cdp_port: int | None = None,
     cdp_address: str | None = None,
+    *,
+    proxy: "ProxySettings | None" = None,
+    viewport: "ViewportSize | None" = None,
     **kwargs: Any,
 ):
     from playwright.async_api import async_playwright
     from playwright.async_api import Browser
 
-    extra_args = [
-        "--no-first-run",
-        "--disable-sync",
-        "--disable-translate",
-        "--disable-features=TranslateUI",
-        "--disable-features=NetworkService",
-        "--lang=en",
-        "--disable-blink-features=AutomationControlled",
-    ]
+    extra_args: list[str] = []
     async with async_playwright() as playwright:
         if cdp_address is not None:
             browser: Browser = await playwright.chromium.connect_over_cdp(cdp_address)
@@ -104,29 +73,25 @@ async def launch_chromium(
                 user_preferences_dir,
                 dir_to_clean,
             ) = await create_user_dir_with_preferences()
-            if kwargs.get("proxy") is None:
-                proxy_env = get_proxy_env()
-            else:
-                proxy_env = kwargs.get("proxy")
+            proxy = proxy or get_proxy_env()
             # Remove proxy from kwargs if it exists
-            kwargs.pop("proxy", None)
-            viewport = kwargs.get("viewport", {"width": 1280, "height": 800})
-            kwargs.pop("viewport", None)
+            viewport = viewport or {"width": 1280, "height": 800}
 
-            if headless:
-                chromium_launch_args_to_ignore.append("--headless")
-                extra_args.append("--headless=new")
+            if cdp_port:
+                extra_args.append(f"--remote-debugging-port={cdp_port}")
 
             context = await playwright.chromium.launch_persistent_context(
                 os.fspath(user_preferences_dir),
                 headless=headless,
                 viewport=viewport,
-                proxy=proxy_env,
-                # ignore_default_args=chromium_launch_args_to_ignore,
+                proxy=proxy,
                 user_agent=os.environ.get("USER_AGENT", default_user_agent),
-                # args=extra_args,
+                args=extra_args,
                 **kwargs,
             )
+            if cdp_port:
+                await wait_on_cdp_address(get_local_cdp_address(cdp_port))
+
         context.set_default_timeout(timeout * 1000)
 
         async def remove_dir_after_close(*_: Any, **__: Any) -> None:
@@ -145,6 +110,7 @@ async def launch_chromium(
             await process.wait()
 
         context.once("close", remove_dir_after_close)
+
         yield context, context.pages[0]
 
 
@@ -166,6 +132,8 @@ async def dangerous_launch_chromium(
         "--disable-features=NetworkService",
         "--lang=en",
         "--disable-blink-features=AutomationControlled",
+        "--disable-dev-shm-usage",
+        "--disk-cache-dir=/mnt/data/tmp/chrome-cache",
     ]
     playwright = await async_playwright().start()
     if cdp_url is not None:
@@ -173,6 +141,10 @@ async def dangerous_launch_chromium(
         browser: Browser = await playwright.chromium.connect_over_cdp(cdp_url)
         browser.on("disconnected", lambda _: logging.info("Browser Session disconnected"))
         context = browser.contexts[0]
+        # set view port for the already existing pages and any new pages
+        for page in context.pages:
+            await page.set_viewport_size(kwargs.get("viewport", {"width": 1280, "height": 800}))
+        context.on("page", lambda page: page.set_viewport_size(kwargs.get("viewport", {"width": 1280, "height": 800})))
         user_preferences_dir = None
         dir_to_clean = None
     else:
@@ -189,7 +161,6 @@ async def dangerous_launch_chromium(
         kwargs.pop("viewport", None)
 
         if headless:
-            chromium_launch_args_to_ignore.append("--headless")
             extra_args.append("--headless=new")
 
         if port:
@@ -200,7 +171,6 @@ async def dangerous_launch_chromium(
             headless=headless,
             viewport=viewport,
             proxy=proxy_env,
-            ignore_default_args=chromium_launch_args_to_ignore,
             user_agent=os.environ.get("USER_AGENT", default_user_agent),
             args=extra_args,
             **kwargs,

runtime/constants.py

@@ -0,0 +1 @@
+api_key_header_name = "x-api-key"

runtime/context/context.py

@@ -21,6 +21,7 @@ class IntunedContext(BaseModel):
     extended_payloads: list[Payload] = Field(default_factory=lambda: list[Payload]())
     run_context: IntunedRunContext | None = None
     get_auth_session_parameters: Callable[[], Awaitable[dict[str, Any]]] | None = None
+    store: dict[str, Any] = Field(default_factory=lambda: dict())
 
     _token: Token["IntunedContext"] | None = None
 

runtime/env.py

@@ -6,7 +6,7 @@ def get_workspace_id():
 
 
 def get_project_id():
-    return os.environ.get("INTUNED_INTEGRATION_ID")
+    return os.environ.get("INTUNED_INTEGRATION_ID", os.environ.get("INTUNED_PROJECT_ID"))
 
 
 def get_functions_domain():
@@ -15,3 +15,17 @@ def get_functions_domain():
 
 def get_browser_type():
     return os.environ.get("BROWSER_TYPE")
+
+
+def get_api_key():
+    return os.environ.get(api_key_env_var_key)
+
+
+def get_is_running_in_cli():
+    return os.environ.get(cli_env_var_key) == "true"
+
+
+cli_env_var_key = "INTUNED_CLI"
+workspace_env_var_key = "INTUNED_WORKSPACE_ID"
+project_env_var_key = "INTUNED_PROJECT_ID"
+api_key_env_var_key = "INTUNED_API_KEY"

runtime/errors/run_api_errors.py

@@ -58,6 +58,14 @@ class NoAutomationInApiError(RunApiError):
         )
 
 
+class InvalidAPIError(RunApiError):
+    def __init__(self, message: str):
+        super().__init__(
+            message,
+            "InvalidAPIError",
+        )
+
+
 class AutomationNotCoroutineError(RunApiError):
     def __init__(self, module: str, automation_function_name: str = "automation"):
         super().__init__(

runtime/helpers/__init__.py

@@ -1,5 +1,6 @@
+from .attempt_store import attempt_store
 from .extend_payload import extend_payload
 from .extend_timeout import extend_timeout
 from .get_auth_session_parameters import get_auth_session_parameters
 
-__all__ = ["extend_payload", "extend_timeout", "get_auth_session_parameters"]
+__all__ = ["extend_payload", "extend_timeout", "get_auth_session_parameters", "attempt_store"]

runtime/helpers/attempt_store.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from runtime.context.context import IntunedContext
+
+
+class Store:
+    def get(self, key: str, default: Any = None) -> Any:
+        return IntunedContext.current().store.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        IntunedContext.current().store[key] = value
+
+
+attempt_store = Store()

runtime/run/playwright_context.py

@@ -0,0 +1,147 @@
+import asyncio
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack
+from typing import Any
+from typing import AsyncContextManager
+from typing import overload
+from typing import TYPE_CHECKING
+from typing import TypedDict
+from typing import Unpack
+
+from ..browser import launch_browser
+from ..browser.helpers import get_local_cdp_address
+from ..errors.run_api_errors import AutomationError
+from ..errors.run_api_errors import InvalidAPIError
+from ..run.types import ImportFunction
+from .setup_context_hook import load_setup_context_hook
+from .setup_context_hook import setup_context_hook_function_name
+
+if TYPE_CHECKING:
+    from playwright.async_api import BrowserContext
+    from playwright.async_api import Page
+    from playwright.async_api import ProxySettings
+
+
+class _CommonKwargs(TypedDict):
+    import_function: "ImportFunction"
+    api_name: str
+    api_parameters: Any
+
+
+@overload
+def playwright_context(
+    *,
+    proxy: "ProxySettings | None" = None,
+    headless: bool = False,
+    **kwargs: Unpack[_CommonKwargs],
+) -> "AsyncContextManager[tuple[BrowserContext, Page]]": ...
+@overload
+def playwright_context(
+    *,
+    cdp_address: str | None = None,
+    **kwargs: Unpack[_CommonKwargs],
+) -> "AsyncContextManager[tuple[BrowserContext, Page]]": ...
+
+
+@asynccontextmanager
+async def playwright_context(
+    *,
+    proxy: "ProxySettings | None" = None,
+    headless: bool = False,
+    cdp_address: str | None = None,
+    **kwargs: Unpack[_CommonKwargs],
+) -> "AsyncGenerator[tuple[BrowserContext, Page], None]":
+    setup_context_hook = load_setup_context_hook(import_function=kwargs["import_function"])
+
+    if setup_context_hook is None:
+        if cdp_address:
+            async with launch_browser(
+                cdp_address=cdp_address,
+            ) as (context, page):
+                yield context, page
+        else:
+            async with launch_browser(
+                proxy=proxy,
+                headless=headless,
+            ) as (context, page):
+                yield context, page
+        return
+
+    if cdp_address is not None:
+        cdp_port = None
+        hook_cdp_url = cdp_address
+    else:
+        cdp_port = await get_random_free_port()
+        hook_cdp_url = get_local_cdp_address(cdp_port)
+
+    async with AsyncExitStack() as stack:
+        if cdp_address:
+            context, page = await stack.enter_async_context(
+                launch_browser(
+                    cdp_address=cdp_address,
+                )
+            )
+        else:
+            context, page = await stack.enter_async_context(
+                launch_browser(
+                    proxy=proxy,
+                    headless=headless,
+                    cdp_port=cdp_port,
+                )
+            )
+        try:
+            hook_result = await setup_context_hook(
+                api_name=kwargs["api_name"],
+                api_parameters=kwargs["api_parameters"],
+                cdp_url=hook_cdp_url,
+            )
+        except Exception as e:
+            raise AutomationError(e) from e
+
+        if hook_result is None:
+            yield context, page
+            return
+
+        new_context: "BrowserContext | None" = None  # noqa: UP037
+        try:
+            if not isinstance(hook_result, tuple):
+                new_context = hook_result
+                yield new_context, page
+                return
+
+            if len(hook_result) == 2:
+                new_context, new_page = hook_result
+
+                yield new_context, new_page or page
+                return
+
+            if len(hook_result) == 3:
+                new_context, new_page, cleanup = hook_result
+
+                try:
+                    yield new_context, new_page or page
+                    return
+                finally:
+                    try:
+                        await cleanup()
+                    except Exception as e:
+                        raise AutomationError(e) from e
+
+            raise InvalidAPIError(
+                f"{setup_context_hook_function_name} hook returned an invalid value. Return value must be one of: None, BrowserContext, (BrowserContext, Page | None), (BrowserContext, Page | None, Callable[..., Awaitable[None]])"
+            )
+        finally:
+            if new_context is not None and new_context != context:
+                await new_context.close()
+
+
+async def get_random_free_port() -> int:
+    def get_random_free_port_sync():
+        import socket
+
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            return s.getsockname()[1]
+
+    return await asyncio.to_thread(get_random_free_port_sync)

runtime/run/playwright_tracing.py

@@ -0,0 +1,27 @@
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from playwright.async_api import BrowserContext
+
+from anyio import Path
+
+
+@asynccontextmanager
+async def playwright_tracing(
+    *,
+    context: "BrowserContext",
+    trace_path: str,
+    screenshots: bool = True,
+    snapshots: bool = True,
+    sources: bool = True,
+):
+    await context.tracing.start(screenshots=screenshots, snapshots=snapshots, sources=sources)
+    try:
+        yield
+    finally:
+        try:
+            await context.tracing.stop(path=trace_path)
+        except Exception as e:
+            print("Error stopping tracing:", e)
+            await Path(trace_path).unlink(missing_ok=True)