fleet-python 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

fleet/_async/playwright.py

@@ -0,0 +1,291 @@
+import base64
+from typing import List, Dict, Any
+from playwright.async_api import async_playwright, Browser, Page
+from .client import AsyncEnvironment
+
+
+# Key mapping for computer use actions
+CUA_KEY_TO_PLAYWRIGHT_KEY = {
+    "/": "Divide",
+    "\\": "Backslash",
+    "alt": "Alt",
+    "arrowdown": "ArrowDown",
+    "arrowleft": "ArrowLeft",
+    "arrowright": "ArrowRight",
+    "arrowup": "ArrowUp",
+    "backspace": "Backspace",
+    "capslock": "CapsLock",
+    "cmd": "Meta",
+    "ctrl": "Control",
+    "delete": "Delete",
+    "end": "End",
+    "enter": "Enter",
+    "esc": "Escape",
+    "home": "Home",
+    "insert": "Insert",
+    "option": "Alt",
+    "pagedown": "PageDown",
+    "pageup": "PageUp",
+    "shift": "Shift",
+    "space": " ",
+    "super": "Meta",
+    "tab": "Tab",
+    "win": "Meta",
+}
+
+
+class FleetPlaywrightWrapper:
+    """
+    A wrapper that adds Playwright browser automation to Fleet environment instances.
+
+    This class handles:
+    - Browser connection via CDP
+    - Computer actions (click, scroll, type, etc.)
+    - Screenshot capture
+    - Integration with OpenAI computer use API
+
+    Usage:
+        instance = await fleet.env.make(env_key="hubspot", version="v1.2.7")
+        browser = FleetPlaywrightWrapper(instance)
+        await browser.start()
+
+        # Use browser methods
+        screenshot = await browser.screenshot()
+        tools = [browser.openai_cua_tool]
+
+        # Clean up when done
+        await browser.close()
+    """
+
+    def get_environment(self):
+        return "browser"
+
+    def get_dimensions(self):
+        return (1920, 1080)
+
+    def __init__(
+        self,
+        env: AsyncEnvironment,
+        display_width: int = 1920,
+        display_height: int = 1080,
+    ):
+        """
+        Initialize the Fleet Playwright wrapper.
+
+        Args:
+            env: Fleet environment instance
+            display_width: Browser viewport width
+            display_height: Browser viewport height
+        """
+        self.env = env
+        self.display_width = display_width
+        self.display_height = display_height
+
+        self._playwright = None
+        self._browser: Browser | None = None
+        self._page: Page | None = None
+        self._started = False
+
+    async def start(self):
+        """Start the browser and establish connection."""
+        if self._started:
+            return
+
+        # Start Playwright
+        self._playwright = await async_playwright().start()
+
+        # Start browser on the Fleet instance
+        print("Starting browser...")
+        await self.env.browser().start()
+        cdp = await self.env.browser().describe()
+
+        # Connect to browser
+        self._browser = await self._playwright.chromium.connect_over_cdp(
+            cdp.cdp_browser_url
+        )
+        self._page = self._browser.contexts[0].pages[0]
+        await self._page.set_viewport_size(
+            {"width": self.display_width, "height": self.display_height}
+        )
+
+        self._started = True
+        print(f"Track agent: {cdp.cdp_devtools_url}")
+
+    async def close(self):
+        """Close the browser connection."""
+        if self._playwright:
+            await self._playwright.stop()
+            self._playwright = None
+            self._browser = None
+            self._page = None
+            self._started = False
+
+    def _ensure_started(self):
+        """Ensure browser is started before operations."""
+        if not self._started:
+            raise RuntimeError("Browser not started. Call await browser.start() first.")
+
+    @property
+    def openai_cua_tool(self) -> Dict[str, Any]:
+        """
+        Tool definition for OpenAI computer use API.
+
+        Returns:
+            Tool definition dict for use with OpenAI responses API
+        """
+        return {
+            "type": "computer_use_preview",
+            "display_width": self.display_width,
+            "display_height": self.display_height,
+            "environment": "browser",
+        }
+
+    async def screenshot(self) -> str:
+        """
+        Take a screenshot and return base64 encoded string.
+
+        Returns:
+            Base64 encoded PNG screenshot
+        """
+        self._ensure_started()
+
+        png_bytes = await self._page.screenshot(full_page=False)
+        return base64.b64encode(png_bytes).decode("utf-8")
+
+    def get_current_url(self) -> str:
+        """Get the current page URL."""
+        self._ensure_started()
+        return self._page.url
+
+    async def execute_computer_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute a computer action and return the result for OpenAI API.
+
+        Args:
+            action: Computer action dict from OpenAI response
+
+        Returns:
+            Result dict for computer_call_output
+        """
+        self._ensure_started()
+
+        action_type = action["type"]
+        action_args = {k: v for k, v in action.items() if k != "type"}
+
+        print(f"Executing: {action_type}({action_args})")
+
+        # Execute the action
+        if hasattr(self, f"_{action_type}"):
+            method = getattr(self, f"_{action_type}")
+            await method(**action_args)
+        else:
+            raise ValueError(f"Unsupported action type: {action_type}")
+
+        # Take screenshot after action
+        screenshot_base64 = await self.screenshot()
+
+        return {
+            "type": "input_image",
+            "image_url": f"data:image/png;base64,{screenshot_base64}",
+            "current_url": self.get_current_url(),
+        }
+
+    # Computer action implementations
+    async def _click(self, x: int, y: int, button: str = "left") -> None:
+        """Click at coordinates."""
+        self._ensure_started()
+        await self._page.mouse.click(x, y, button=button)
+
+    async def _double_click(self, x: int, y: int) -> None:
+        """Double-click at coordinates."""
+        self._ensure_started()
+        await self._page.mouse.dblclick(x, y)
+
+    async def _scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
+        """Scroll from coordinates."""
+        self._ensure_started()
+        await self._page.mouse.move(x, y)
+        await self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+
+    async def _type(self, text: str) -> None:
+        """Type text."""
+        self._ensure_started()
+        await self._page.keyboard.type(text)
+
+    async def _keypress(self, keys: List[str]) -> None:
+        """Press key combination."""
+        self._ensure_started()
+        mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
+        for key in mapped_keys:
+            await self._page.keyboard.down(key)
+        for key in reversed(mapped_keys):
+            await self._page.keyboard.up(key)
+
+    async def _move(self, x: int, y: int) -> None:
+        """Move mouse to coordinates."""
+        self._ensure_started()
+        await self._page.mouse.move(x, y)
+
+    async def _drag(self, path: List[Dict[str, int]]) -> None:
+        """Drag mouse along path."""
+        self._ensure_started()
+        if not path:
+            return
+        await self._page.mouse.move(path[0]["x"], path[0]["y"])
+        await self._page.mouse.down()
+        for point in path[1:]:
+            await self._page.mouse.move(point["x"], point["y"])
+        await self._page.mouse.up()
+
+    async def _wait(self, ms: int = 1000) -> None:
+        """Wait for specified milliseconds."""
+        import asyncio
+
+        await asyncio.sleep(ms / 1000)
+
+    # Browser-specific actions
+    async def _goto(self, url: str) -> None:
+        """Navigate to URL."""
+        self._ensure_started()
+        try:
+            await self._page.goto(url)
+        except Exception as e:
+            print(f"Error navigating to {url}: {e}")
+
+    async def _back(self) -> None:
+        """Go back in browser history."""
+        self._ensure_started()
+        await self._page.go_back()
+
+    async def _forward(self) -> None:
+        """Go forward in browser history."""
+        self._ensure_started()
+        await self._page.go_forward()
+
+    async def _refresh(self) -> None:
+        """Refresh the page."""
+        self._ensure_started()
+        await self._page.reload()
+
+    # ------------------------------------------------------------------
+    # Public aliases (no leading underscore) expected by the Agent &
+    # OpenAI computer-use API. They forward directly to the underscored
+    # implementations above so the external interface matches the older
+    # BasePlaywrightComputer class.
+    # ------------------------------------------------------------------
+
+    # Mouse / keyboard actions
+    click = _click
+    double_click = _double_click
+    scroll = _scroll
+    type = _type  # noqa: A003 – shadowing built-in for API compatibility
+    keypress = _keypress
+    move = _move
+    drag = _drag
+    wait = _wait
+
+    # Browser navigation actions
+    goto = _goto
+    back = _back
+    forward = _forward
+    refresh = _refresh

fleet/_async/resources/base.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from ..instance.models import Resource as ResourceModel, ResourceType, ResourceMode
+
+
+class Resource(ABC):
+    def __init__(self, resource: ResourceModel):
+        self.resource = resource
+
+    @property
+    def uri(self) -> str:
+        return f"{self.resource.type.value}://{self.resource.name}"
+
+    @property
+    def name(self) -> str:
+        return self.resource.name
+
+    @property
+    def type(self) -> ResourceType:
+        return self.resource.type
+
+    @property
+    def mode(self) -> ResourceMode:
+        return self.resource.mode
+    
+    def __repr__(self) -> str:
+        return f"Resource(uri={self.uri}, mode={self.mode.value})"

fleet/_async/resources/browser.py

@@ -0,0 +1,41 @@
+from typing import Optional
+from ..instance.models import (
+    Resource as ResourceModel,
+    CDPDescribeResponse,
+    ChromeStartRequest,
+    ChromeStartResponse,
+)
+from .base import Resource
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..instance.base import AsyncWrapper
+
+
+class AsyncBrowserResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+        super().__init__(resource)
+        self.client = client
+
+    async def start(self, width: int = 1920, height: int = 1080) -> CDPDescribeResponse:
+        response = await self.client.request(
+            "POST",
+            "/resources/cdp/start",
+            json=ChromeStartRequest(resolution=f"{width},{height}").model_dump(),
+        )
+        ChromeStartResponse(**response.json())
+        return await self.describe()
+
+    async def describe(self) -> CDPDescribeResponse:
+        response = await self.client.request("GET", "/resources/cdp/describe")
+        if response.status_code != 200:
+            await self.start()
+            response = await self.client.request("GET", "/resources/cdp/describe")
+        return CDPDescribeResponse(**response.json())
+
+    async def cdp_url(self) -> str:
+        return (await self.describe()).cdp_browser_url
+
+    async def devtools_url(self) -> str:
+        return (await self.describe()).cdp_devtools_url

fleet/_async/resources/sqlite.py

@@ -0,0 +1,41 @@
+from typing import Any, List, Optional
+from ..instance.models import Resource as ResourceModel
+from ..instance.models import DescribeResponse, QueryRequest, QueryResponse
+from .base import Resource
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..instance.base import AsyncWrapper
+
+
+class AsyncSQLiteResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+        super().__init__(resource)
+        self.client = client
+
+    async def describe(self) -> DescribeResponse:
+        """Describe the SQLite database schema."""
+        response = await self.client.request(
+            "GET", f"/resources/sqlite/{self.resource.name}/describe"
+        )
+        return DescribeResponse(**response.json())
+
+    async def query(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
+        return await self._query(query, args, read_only=True)
+
+    async def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+        return await self._query(query, args, read_only=False)
+
+    async def _query(
+        self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
+    ) -> QueryResponse:
+        request = QueryRequest(query=query, args=args, read_only=read_only)
+        response = await self.client.request(
+            "POST",
+            f"/resources/sqlite/{self.resource.name}/query",
+            json=request.model_dump(),
+        )
+        return QueryResponse(**response.json())

fleet/base.py

@@ -48,27 +48,4 @@ class SyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
-
-
-class AsyncWrapper(BaseWrapper):
-    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
-        super().__init__(**kwargs)
-        self.httpx_client = httpx_client
-
-    async def request(
-        self,
-        method: str,
-        url: str,
-        params: Optional[Dict[str, Any]] = None,
-        json: Optional[Any] = None,
-        **kwargs,
-    ) -> httpx.Response:
-        return await self.httpx_client.request(
-            method,
-            f"{self.base_url}{url}",
-            headers=self.get_headers(),
-            params=params,
-            json=json,
-            **kwargs,
-        )
+        )

fleet/client.py

@@ -14,26 +14,24 @@
 
 """Fleet API Client for making HTTP requests to Fleet services."""
 
-import asyncio
 import os
 import httpx
 import logging
 from typing import Optional, List
 
-from .base import EnvironmentBase, AsyncWrapper, SyncWrapper
+from .base import EnvironmentBase, SyncWrapper
 from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
 
 from .instance import (
     InstanceClient,
-    AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
     ValidatorType,
     ExecuteFunctionResponse,
 )
 from .resources.base import Resource
-from .resources.sqlite import AsyncSQLiteResource
-from .resources.browser import AsyncBrowserResource
+from .resources.sqlite import SQLiteResource
+from .resources.browser import BrowserResource
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +39,7 @@ logger = logging.getLogger(__name__)
 class Environment(EnvironmentBase):
     def __init__(self, httpx_client: Optional[httpx.Client] = None, **kwargs):
         super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.Client()
+        self._httpx_client = httpx_client or httpx.Client(timeout=60.0)
         self._instance: Optional[InstanceClient] = None
 
     @property
@@ -50,46 +48,33 @@ class Environment(EnvironmentBase):
             self._instance = InstanceClient(self.manager_url, self._httpx_client)
         return self._instance
 
-
-class AsyncEnvironment(EnvironmentBase):
-    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
-        super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
-        self._instance: Optional[AsyncInstanceClient] = None
-
-    @property
-    def instance(self) -> AsyncInstanceClient:
-        if self._instance is None:
-            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
-        return self._instance
-
-    async def reset(
+    def reset(
         self, seed: Optional[int] = None, timestamp: Optional[int] = None
     ) -> ResetResponse:
-        return await self.instance.reset(ResetRequest(seed=seed, timestamp=timestamp))
+        return self.instance.reset(ResetRequest(seed=seed, timestamp=timestamp))
 
-    def db(self, name: str = "current") -> AsyncSQLiteResource:
+    def db(self, name: str = "current") -> SQLiteResource:
         return self.instance.db(name)
 
-    def browser(self, name: str = "cdp") -> AsyncBrowserResource:
+    def browser(self, name: str = "cdp") -> BrowserResource:
         return self.instance.browser(name)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
 
-    async def resources(self) -> List[Resource]:
-        return await self.instance.resources()
+    def resources(self) -> List[Resource]:
+        return self.instance.resources()
 
-    async def close(self) -> InstanceRecord:
-        return await AsyncFleet().delete(self.instance_id)
+    def close(self) -> InstanceRecord:
+        return Fleet().delete(self.instance_id)
 
-    async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
-        return await self.instance.verify(validator)
+    def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
+        return self.instance.verify(validator)
 
-    async def verify_raw(
+    def verify_raw(
         self, function_code: str, function_name: str
     ) -> ExecuteFunctionResponse:
-        return await self.instance.verify_raw(function_code, function_name)
+        return self.instance.verify_raw(function_code, function_name)
 
 
 class Fleet:
@@ -106,7 +91,7 @@ class Fleet:
             httpx_client=self._httpx_client,
         )
 
-    def environments(self) -> List[EnvironmentModel]:
+    def list_envs(self) -> List[EnvironmentModel]:
         response = self.client.request("GET", "/v1/env/")
         return [EnvironmentModel(**env_data) for env_data in response.json()]
 
@@ -114,52 +99,7 @@ class Fleet:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    def make(self, request: InstanceRequest) -> Environment:
-        response = self.client.request(
-            "POST", "/v1/env/instances", json=request.model_dump()
-        )
-        return Environment(**response.json())
-
-    def instances(self, status: Optional[str] = None) -> List[Environment]:
-        params = {}
-        if status:
-            params["status"] = status
-
-        response = self.client.request("GET", "/v1/env/instances", params=params)
-        return [Environment(**instance_data) for instance_data in response.json()]
-
-    def instance(self, instance_id: str) -> Environment:
-        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        return Environment(**response.json())
-
-    def delete(self, instance_id: str) -> InstanceRecord:
-        response = self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
-        return InstanceRecord(**response.json())
-
-
-class AsyncFleet:
-    def __init__(
-        self,
-        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
-        base_url: Optional[str] = None,
-        httpx_client: Optional[httpx.AsyncClient] = None,
-    ):
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
-        self.client = AsyncWrapper(
-            api_key=api_key,
-            base_url=base_url,
-            httpx_client=self._httpx_client,
-        )
-
-    async def list_envs(self) -> List[EnvironmentModel]:
-        response = await self.client.request("GET", "/v1/env/")
-        return [EnvironmentModel(**env_data) for env_data in response.json()]
-
-    async def environment(self, env_key: str) -> EnvironmentModel:
-        response = await self.client.request("GET", f"/v1/env/{env_key}")
-        return EnvironmentModel(**response.json())
-
-    async def make(self, env_key: str) -> AsyncEnvironment:
+    def make(self, env_key: str) -> Environment:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if not version.startswith("v"):
@@ -169,33 +109,25 @@ class AsyncFleet:
             version = None
 
         request = InstanceRequest(env_key=env_key_part, version=version)
-        response = await self.client.request(
+        response = self.client.request(
             "POST", "/v1/env/instances", json=request.model_dump()
         )
-        instance = AsyncEnvironment(**response.json())
-        await instance.instance.load()
+        instance = Environment(**response.json())
+        instance.instance.load()
         return instance
 
-    async def instances(self, status: Optional[str] = None) -> List[AsyncEnvironment]:
+    def instances(self, status: Optional[str] = None) -> List[Environment]:
         params = {}
         if status:
             params["status"] = status
 
-        response = await self.client.request("GET", "/v1/env/instances", params=params)
-        instances = [
-            AsyncEnvironment(**instance_data) for instance_data in response.json()
-        ]
-        await asyncio.gather(*[instance.instance.load() for instance in instances])
-        return instances
-
-    async def instance(self, instance_id: str) -> AsyncEnvironment:
-        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = AsyncEnvironment(**response.json())
-        await instance.instance.load()
-        return instance
+        response = self.client.request("GET", "/v1/env/instances", params=params)
+        return [Environment(**instance_data) for instance_data in response.json()]
 
-    async def delete(self, instance_id: str) -> InstanceRecord:
-        response = await self.client.request(
-            "DELETE", f"/v1/env/instances/{instance_id}"
-        )
-        return InstanceRecord(**response.json())
+    def instance(self, instance_id: str) -> Environment:
+        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        return Environment(**response.json())
+
+    def delete(self, instance_id: str) -> InstanceRecord:
+        response = self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
+        return InstanceRecord(**response.json())

fleet/env/__init__.py

@@ -1,3 +1,15 @@
+"""Fleet env module - convenience functions for environment management."""
+
 from .client import make, list_envs, get
 
-__all__ = ["make", "list_envs", "get"]
+# Import async versions from _async
+from .._async.env.client import make_async, list_envs_async, get_async
+
+__all__ = [
+    "make",
+    "list_envs", 
+    "get",
+    "make_async",
+    "list_envs_async",
+    "get_async",
+]

fleet/env/client.py

@@ -1,15 +1,15 @@
-from ..client import AsyncFleet, AsyncEnvironment
+from ..client import Fleet, Environment
 from ..models import Environment as EnvironmentModel
 from typing import List
 
 
-async def make(env_key: str) -> AsyncEnvironment:
-    return await AsyncFleet().make(env_key)
+def make(env_key: str) -> Environment:
+    return Fleet().make(env_key)
 
 
-async def list_envs() -> List[EnvironmentModel]:
-    return await AsyncFleet().list_envs()
+def list_envs() -> List[EnvironmentModel]:
+    return Fleet().list_envs()
 
 
-async def get(instance_id: str) -> AsyncEnvironment:
-    return await AsyncFleet().instance(instance_id)
+def get(instance_id: str) -> Environment:
+    return Fleet().instance(instance_id)