minitap-mcp 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

minitap/mcp/core/agents/compare_screenshots/agent.py

@@ -1,4 +1,5 @@
 import asyncio
+import base64
 from pathlib import Path
 from uuid import uuid4
 
@@ -9,6 +10,7 @@ from pydantic import BaseModel
 from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.core.llm import get_minitap_llm
 from minitap.mcp.core.utils.images import get_screenshot_message_for_llm
+from minitap.mcp.server.cloud_mobile import get_cloud_mobile_id, get_cloud_screenshot
 
 
 class CompareScreenshotsOutput(BaseModel):
@@ -23,6 +25,8 @@ async def compare_screenshots(
     """
     Compare screenshots and return the comparison text along with both screenshots.
 
+    Supports both local devices (Android/iOS) and cloud devices.
+
     Returns:
         CompareScreenshotsOutput
     """
@@ -30,8 +34,14 @@ async def compare_screenshots(
         Path(__file__).parent.joinpath("prompt.md").read_text(encoding="utf-8")
     ).render()
 
-    device = find_mobile_device()
-    current_screenshot = capture_screenshot(device)
+    cloud_mobile_id = get_cloud_mobile_id()
+
+    if cloud_mobile_id:
+        screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
+        current_screenshot = base64.b64encode(screenshot_bytes).decode("utf-8")
+    else:
+        device = find_mobile_device()
+        current_screenshot = capture_screenshot(device)
 
     messages: list[BaseMessage] = [
         SystemMessage(content=system_message),

minitap/mcp/core/cloud_apk.py

@@ -0,0 +1,109 @@
+"""Cloud APK deployment utilities for uploading and installing APKs on cloud mobiles."""
+
+import uuid
+from pathlib import Path
+
+import httpx
+
+from minitap.mcp.core.config import settings
+
+
+async def upload_apk_to_cloud_mobile(apk_path: str) -> str:
+    """
+    Upload an APK file via Platform storage API to user storage bucket.
+
+    Args:
+        apk_path: Path to the APK file
+
+    Returns:
+        Filename to use with install-apk endpoint
+
+    Raises:
+        FileNotFoundError: If APK file doesn't exist
+        httpx.HTTPError: If upload fails
+        ValueError: If MINITAP_API_KEY or MINITAP_API_BASE_URL is not configured
+    """
+    if not settings.MINITAP_API_KEY:
+        raise ValueError("MINITAP_API_KEY is not configured")
+    if not settings.MINITAP_API_BASE_URL:
+        raise ValueError("MINITAP_API_BASE_URL is not configured")
+
+    apk_file = Path(apk_path)
+    if not apk_file.exists():
+        raise FileNotFoundError(f"APK file not found: {apk_path}")
+
+    filename = f"app_{uuid.uuid4().hex[:6]}.apk"
+    api_key = settings.MINITAP_API_KEY.get_secret_value()
+    api_base_url = settings.MINITAP_API_BASE_URL.rstrip("/")
+
+    async with httpx.AsyncClient(timeout=300.0) as client:
+        # Step 1: Get signed upload URL from storage API
+        response = await client.get(
+            f"{api_base_url}/storage/signed-upload",
+            headers={"Authorization": f"Bearer {api_key}"},
+            params={"filenames": filename},
+        )
+        response.raise_for_status()
+        upload_data = response.json()
+
+        # Extract the signed URL for our file
+        signed_urls = upload_data.get("signed_urls", {})
+        if filename not in signed_urls:
+            raise ValueError(f"No signed URL returned for {filename}")
+
+        signed_url = signed_urls[filename]
+
+        # Step 2: Upload APK to signed URL
+        with open(apk_file, "rb") as f:
+            upload_response = await client.put(
+                signed_url,
+                content=f.read(),
+                headers={"Content-Type": "application/vnd.android.package-archive"},
+            )
+            upload_response.raise_for_status()
+
+        # Step 3: Return filename for install-apk call
+        return filename
+
+
+async def install_apk_on_cloud_mobile(filename: str) -> None:
+    """
+    Install an APK on a cloud mobile device via mobile-manager API.
+
+    Args:
+        filename: Filename returned from upload_apk_to_cloud_mobile
+
+    Raises:
+        httpx.HTTPError: If installation fails
+        ValueError: If required config settings are not configured
+    """
+    if not settings.MINITAP_API_KEY:
+        raise ValueError("MINITAP_API_KEY is not configured")
+    if not settings.MINITAP_DAAS_API:
+        raise ValueError("MINITAP_DAAS_API is not configured")
+    if not settings.CLOUD_MOBILE_NAME:
+        raise ValueError("CLOUD_MOBILE_NAME is not configured")
+
+    api_key = settings.MINITAP_API_KEY.get_secret_value()
+    base_url = settings.MINITAP_DAAS_API
+    cloud_mobile_name = settings.CLOUD_MOBILE_NAME
+
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        cloud_mobile_response = await client.get(
+            f"{base_url}/virtual-mobiles/{cloud_mobile_name}",
+            headers={"Authorization": f"Bearer {api_key}"},
+        )
+        cloud_mobile_response.raise_for_status()
+        response_data = cloud_mobile_response.json()
+        cloud_mobile_uuid = response_data.get("id")
+        if not cloud_mobile_uuid:
+            raise ValueError(f"Cloud mobile '{cloud_mobile_name}' response missing 'id' field")
+        response = await client.post(
+            f"{base_url}/virtual-mobiles/{cloud_mobile_uuid}/install-apk",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json={"filename": filename},
+        )
+        response.raise_for_status()

minitap/mcp/core/config.py

@@ -16,6 +16,7 @@ class MCPSettings(BaseSettings):
     # Minitap API configuration
     MINITAP_API_KEY: SecretStr | None = Field(default=None)
     MINITAP_API_BASE_URL: str = Field(default="https://platform.minitap.ai/api/v1")
+    MINITAP_DAAS_API: str = Field(default="https://platform.minitap.ai/api/daas")
     OPEN_ROUTER_API_KEY: SecretStr | None = Field(default=None)
 
     VISION_MODEL: str = Field(default="qwen/qwen-2.5-vl-7b-instruct")
@@ -27,5 +28,11 @@ class MCPSettings(BaseSettings):
     MCP_SERVER_HOST: str = Field(default="0.0.0.0")
     MCP_SERVER_PORT: int = Field(default=8000)
 
+    # Cloud Mobile configuration
+    # When set, the MCP server runs in cloud mode connecting to a Minitap cloud mobile
+    # instead of requiring a local device. Value can be a device name.
+    # Create cloud mobiles at https://platform.minitap.ai/cloud-mobiles
+    CLOUD_MOBILE_NAME: str | None = Field(default=None)
+
 
 settings = MCPSettings()  # type: ignore

minitap/mcp/core/sdk_agent.py

@@ -3,6 +3,8 @@ import os
 from minitap.mobile_use.sdk import Agent
 from minitap.mobile_use.sdk.builders import Builders
 
+from minitap.mcp.core.config import settings
+
 # Lazy-initialized singleton agent
 _agent: Agent | None = None
 
@@ -23,5 +25,11 @@ def get_mobile_use_agent() -> Agent:
                 raise ValueError(f"Invalid ADB server socket: {custom_adb_socket}")
             _, host, port = parts
             config = config.with_adb_server(host=host, port=int(port))
+
+        # Add cloud mobile configuration if set
+        if settings.CLOUD_MOBILE_NAME:
+            config = config.for_cloud_mobile(cloud_mobile_id_or_ref=settings.CLOUD_MOBILE_NAME)
+
         _agent = Agent(config=config.build())
+
     return _agent

minitap/mcp/main.py

@@ -4,6 +4,9 @@ import argparse
 import os
 import sys
 import threading
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
 
 # Fix Windows console encoding for Unicode characters (emojis in logs)
 if sys.platform == "win32":
@@ -25,13 +28,16 @@ from fastmcp import FastMCP  # noqa: E402
 from minitap.mobile_use.config import settings as sdk_settings
 
 from minitap.mcp.core.config import settings  # noqa: E402
-from minitap.mcp.core.device import DeviceInfo  # noqa: E402
-from minitap.mcp.core.device import list_available_devices
+from minitap.mcp.core.device import (
+    DeviceInfo,  # noqa: E402
+    list_available_devices,
+)
 from minitap.mcp.core.logging_config import (
     configure_logging,  # noqa: E402
     get_logger,
 )
-from minitap.mcp.server.middleware import MaestroCheckerMiddleware
+from minitap.mcp.server.cloud_mobile import CloudMobileService
+from minitap.mcp.server.middleware import LocalDeviceHealthMiddleware
 from minitap.mcp.server.poller import device_health_poller
 
 configure_logging(log_level=os.getenv("LOG_LEVEL", "INFO"))
@@ -41,7 +47,20 @@ def main() -> None:
     """Main entry point for the MCP server."""
 
     parser = argparse.ArgumentParser(description="Mobile Use MCP Server")
-    parser.add_argument("--api-key", type=str, required=False, default=None)
+    parser.add_argument(
+        "--api-key",
+        type=str,
+        required=False,
+        default=None,
+        help="Minitap API key for authentication",
+    )
+    parser.add_argument(
+        "--cloud-mobile-name",
+        type=str,
+        required=False,
+        default=None,
+        help="Name of the cloud mobile device to connect to (enables cloud mode)",
+    )
     parser.add_argument("--llm-profile", type=str, required=False, default=None)
     parser.add_argument(
         "--server",
@@ -63,6 +82,11 @@ def main() -> None:
         settings.__init__()
         sdk_settings.__init__()
 
+    if args.cloud_mobile_name:
+        os.environ["CLOUD_MOBILE_NAME"] = args.cloud_mobile_name
+        settings.__init__()
+        sdk_settings.__init__()
+
     if args.llm_profile:
         os.environ["MINITAP_LLM_PROFILE_NAME"] = args.llm_profile
         settings.__init__()
@@ -79,18 +103,143 @@ def main() -> None:
     # Run MCP server with optional host/port for remote access
     if args.server:
         logger.info(f"Starting MCP server on {settings.MCP_SERVER_HOST}:{settings.MCP_SERVER_PORT}")
-        mcp_lifespan(
+        run_mcp_server(
             transport="http",
             host=settings.MCP_SERVER_HOST,
             port=settings.MCP_SERVER_PORT,
         )
     else:
         logger.info("Starting MCP server in local mode")
-        mcp_lifespan()
+        run_mcp_server()
 
 
 logger = get_logger(__name__)
 
+
+@dataclass
+class MCPLifespanContext:
+    """Context for MCP server lifespan.
+
+    Stores references to services that need cleanup on shutdown.
+    """
+
+    cloud_mobile_service: CloudMobileService | None = None
+    local_poller_stop_event: threading.Event | None = None
+    local_poller_thread: threading.Thread | None = None
+
+
+@asynccontextmanager
+async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
+    """Lifespan context manager for MCP server.
+
+    Handles startup/shutdown for both cloud and local modes.
+
+    Cloud mode (CLOUD_MOBILE_NAME set):
+    - Connects to cloud mobile on startup
+    - Maintains keep-alive polling
+    - Disconnects on shutdown (critical for billing!)
+
+    Local mode (CLOUD_MOBILE_NAME not set):
+    - Starts device health poller
+    - Monitors local device connection
+
+    Args:
+        server: The FastMCP server instance.
+
+    Yields:
+        MCPLifespanContext with references to running services.
+
+    Raises:
+        RuntimeError: If cloud mobile connection fails
+            (crashes MCP to prevent false "connected" state).
+    """
+    from minitap.mcp.core.sdk_agent import get_mobile_use_agent  # noqa: E402
+
+    context = MCPLifespanContext()
+    api_key = settings.MINITAP_API_KEY.get_secret_value() if settings.MINITAP_API_KEY else None
+
+    # Check if running in cloud mode
+    if settings.CLOUD_MOBILE_NAME:
+        # ==================== CLOUD MODE ====================
+        logger.info(f"Starting MCP in CLOUD mode with mobile: {settings.CLOUD_MOBILE_NAME}")
+
+        if not api_key:
+            logger.error("MINITAP_API_KEY is required")
+            raise RuntimeError(
+                "MINITAP_API_KEY is required when CLOUD_MOBILE_NAME is set. "
+                "Please set your API key via --api-key or MINITAP_API_KEY environment variable."
+            )
+
+        # Create and connect cloud mobile service
+        cloud_service = CloudMobileService(
+            cloud_mobile_name=settings.CLOUD_MOBILE_NAME,
+            api_key=api_key,
+        )
+
+        try:
+            await cloud_service.connect()
+        except Exception as e:
+            # CRITICAL: If cloud mobile not found, crash the MCP!
+            # This prevents the IDE from showing the server as "connected"
+            # when it actually can't do anything useful.
+            logger.error(f"Failed to connect to cloud mobile: {e}")
+            raise RuntimeError(
+                f"Cloud mobile connection failed. The MCP server cannot start.\n{e}"
+            ) from e
+
+        context.cloud_mobile_service = cloud_service
+        logger.info("Cloud mobile connected, MCP server ready")
+
+    else:
+        # ==================== LOCAL MODE ====================
+        logger.info("Starting MCP in LOCAL mode (no CLOUD_MOBILE_NAME set)")
+
+        agent = get_mobile_use_agent()
+        server.add_middleware(LocalDeviceHealthMiddleware(agent))
+
+        # Start device health poller in background
+        stop_event = threading.Event()
+        poller_thread = threading.Thread(
+            target=device_health_poller,
+            args=(stop_event, agent),
+            daemon=True,
+        )
+        poller_thread.start()
+
+        context.local_poller_stop_event = stop_event
+        context.local_poller_thread = poller_thread
+        logger.info("Device health poller started")
+
+    try:
+        yield context
+    finally:
+        # ==================== SHUTDOWN ====================
+        logger.info("MCP server shutting down, cleaning up resources...")
+
+        if context.cloud_mobile_service:
+            # CRITICAL: Stop cloud mobile connection to stop billing!
+            logger.info("Disconnecting cloud mobile (stopping billing)...")
+            try:
+                await context.cloud_mobile_service.disconnect()
+                logger.info("Cloud mobile disconnected successfully")
+            except Exception as e:
+                logger.error(f"Error disconnecting cloud mobile: {e}")
+
+        if context.local_poller_stop_event and context.local_poller_thread:
+            # Stop local device health poller
+            logger.info("Stopping device health poller...")
+            context.local_poller_stop_event.set()
+            context.local_poller_thread.join(timeout=10.0)
+
+            if context.local_poller_thread.is_alive():
+                logger.warning("Device health poller thread did not stop gracefully")
+            else:
+                logger.info("Device health poller stopped successfully")
+
+        logger.info("MCP server shutdown complete")
+
+
+# Create MCP server with lifespan handler
 mcp = FastMCP(
     name="mobile-use-mcp",
     instructions="""
@@ -98,7 +247,9 @@ mcp = FastMCP(
         mobile devices (iOS or Android).
         Call get_available_devices() to list them.
     """,
+    lifespan=mcp_lifespan,
 )
+
 from minitap.mcp.tools import analyze_screen  # noqa: E402, F401
 from minitap.mcp.tools import compare_screenshot_with_figma  # noqa: E402, F401
 from minitap.mcp.tools import execute_mobile_command  # noqa: E402, F401
@@ -111,40 +262,15 @@ def get_available_devices() -> list[DeviceInfo]:
     return list_available_devices()
 
 
-def mcp_lifespan(**mcp_run_kwargs):
-    from minitap.mcp.core.sdk_agent import get_mobile_use_agent  # noqa: E402
-
-    agent = get_mobile_use_agent()
-    mcp.add_middleware(MaestroCheckerMiddleware(agent))
-
-    # Start device health poller in background
-    logger.info("Device health poller started")
-    stop_event = threading.Event()
-    poller_thread = threading.Thread(
-        target=device_health_poller,
-        args=(
-            stop_event,
-            agent,
-        ),
-        daemon=True,
-    )
-    poller_thread.start()
+def run_mcp_server(**mcp_run_kwargs):
+    """Run the MCP server with proper exception handling.
 
+    This wraps mcp.run() with exception handling for clean shutdown.
+    """
     try:
         mcp.run(**mcp_run_kwargs)
     except KeyboardInterrupt:
         logger.info("Keyboard interrupt received, shutting down...")
     except Exception as e:
         logger.error(f"Error running MCP server: {e}")
-    finally:
-        # Stop device health poller
-        logger.info("Stopping device health poller...")
-        stop_event.set()
-
-        # Give the poller thread a reasonable time to stop gracefully
-        poller_thread.join(timeout=10.0)
-
-        if poller_thread.is_alive():
-            logger.warning("Device health poller thread did not stop gracefully")
-        else:
-            logger.info("Device health poller stopped successfully")
+        raise

minitap/mcp/server/cloud_mobile.py

@@ -0,0 +1,397 @@
+"""Cloud mobile service for managing cloud-hosted mobile devices.
+
+This module handles:
+- Connecting to cloud mobiles on the Minitap platform via HTTP API
+- Keep-alive polling to maintain the connection (prevents idle shutdown)
+- Proper cleanup when the MCP server stops
+
+API Endpoints used:
+- GET  /api/daas/virtual-mobiles/{id} - Fetch device info by ID or reference name
+- POST /api/daas/virtual-mobiles/{id}/keep-alive - Keep device alive (prevents billing timeout)
+"""
+
+import asyncio
+import logging
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any
+
+import aiohttp
+
+from minitap.mcp.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Context variable to store cloud mobile ID accessible from any MCP tool
+# This is server-wide (not request-scoped) as it persists for the MCP lifecycle
+_cloud_mobile_id: ContextVar[str | None] = ContextVar("cloud_mobile_id", default=None)
+
+
+def get_cloud_mobile_id() -> str | None:
+    """Get the current cloud mobile ID (UUID) from context.
+
+    Returns:
+        The cloud mobile UUID if running in cloud mode, None otherwise.
+    """
+    return _cloud_mobile_id.get()
+
+
+def set_cloud_mobile_id(mobile_id: str | None) -> None:
+    """Set the cloud mobile ID in context.
+
+    Args:
+        mobile_id: The cloud mobile UUID or None to clear.
+    """
+    _cloud_mobile_id.set(mobile_id)
+
+
+@dataclass
+class VirtualMobileInfo:
+    """Information about a virtual mobile from the API."""
+
+    id: str  # UUID
+    reference_name: str | None
+    state: str  # Ready, Starting, Stopping, Stopped, Error
+    uptime_seconds: int
+    cost_micro_dollars: int
+
+    @classmethod
+    def from_api_response(cls, data: dict[str, Any]) -> "VirtualMobileInfo":
+        """Create from API response."""
+        return cls(
+            id=data["id"],
+            reference_name=data.get("referenceName"),
+            state=data.get("state", {}).get("current", "Unknown"),
+            uptime_seconds=data.get("uptimeSeconds", 0),
+            cost_micro_dollars=data.get("costMicroDollars", 0),
+        )
+
+
+class CloudMobileService:
+    """Service for managing cloud mobile connections via HTTP API.
+
+    This service handles:
+    1. Fetching cloud mobile info by name/UUID
+    2. Sending keep-alive pings to prevent idle shutdown
+    3. Proper cleanup on MCP server shutdown
+
+    The keep-alive is CRITICAL for billing - the platform will shut down
+    idle VMs after a timeout. The MCP server must send keep-alives while
+    waiting for user commands.
+    """
+
+    KEEP_ALIVE_INTERVAL_SECONDS = 30
+    API_TIMEOUT_SECONDS = 30
+
+    def __init__(self, cloud_mobile_name: str, api_key: str):
+        """Initialize the cloud mobile service.
+
+        Args:
+            cloud_mobile_name: The reference name or UUID of the cloud mobile.
+            api_key: The Minitap API key for authentication.
+        """
+        self.cloud_mobile_name = cloud_mobile_name
+        self.api_key = api_key
+        self._base_url = settings.MINITAP_DAAS_API.rstrip("/")
+        self._mobile_id: str | None = None  # UUID, resolved from name
+        self._mobile_info: VirtualMobileInfo | None = None
+        self._keep_alive_task: asyncio.Task | None = None
+        self._stop_event = asyncio.Event()
+        self._session: aiohttp.ClientSession | None = None
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get HTTP headers for API requests."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    async def _ensure_session(self) -> aiohttp.ClientSession:
+        """Get or create the aiohttp session."""
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=self.API_TIMEOUT_SECONDS)
+            self._session = aiohttp.ClientSession(timeout=timeout)
+        return self._session
+
+    async def _close_session(self) -> None:
+        """Close the aiohttp session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+    async def _fetch_virtual_mobile(self) -> VirtualMobileInfo:
+        """Fetch virtual mobile info from API.
+
+        GET /api/daas/virtual-mobiles/{id}
+
+        Args:
+            id can be UUID or reference name.
+
+        Returns:
+            VirtualMobileInfo with device details.
+
+        Raises:
+            RuntimeError: If device not found or API error.
+        """
+        session = await self._ensure_session()
+        url = f"{self._base_url}/virtual-mobiles/{self.cloud_mobile_name}"
+
+        logger.debug(f"Fetching virtual mobile: {url}")
+
+        async with session.get(url, headers=self._get_headers()) as response:
+            if response.status == 404:
+                raise RuntimeError(
+                    f"Cloud mobile '{self.cloud_mobile_name}' not found. "
+                    "Please verify the name/UUID exists in your Minitap Platform account."
+                )
+            if response.status == 401:
+                raise RuntimeError(
+                    "Authentication failed. Please verify your MINITAP_API_KEY is valid."
+                )
+            if response.status == 403:
+                raise RuntimeError(
+                    f"Access denied to cloud mobile '{self.cloud_mobile_name}'. "
+                    "Please verify your API key has access to this device."
+                )
+            if response.status != 200:
+                error_text = await response.text()
+                raise RuntimeError(
+                    f"Failed to fetch cloud mobile: HTTP {response.status} - {error_text}"
+                )
+
+            data = await response.json()
+            return VirtualMobileInfo.from_api_response(data)
+
+    async def _send_keep_alive(self) -> bool:
+        """Send keep-alive ping to prevent idle shutdown.
+
+        POST /api/daas/virtual-mobiles/{id}/keep-alive
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        if not self._mobile_id:
+            logger.warning("Cannot send keep-alive: no mobile ID")
+            return False
+
+        session = await self._ensure_session()
+        url = f"{self._base_url}/virtual-mobiles/{self._mobile_id}/keep-alive"
+
+        try:
+            async with session.post(url, headers=self._get_headers()) as response:
+                if response.status == 204:
+                    logger.debug(f"Keep-alive sent successfully for {self._mobile_id}")
+                    return True
+                else:
+                    error_text = await response.text()
+                    logger.warning(f"Keep-alive failed: HTTP {response.status} - {error_text}")
+                    return False
+        except Exception as e:
+            logger.error(f"Keep-alive request failed: {e}")
+            return False
+
+    async def connect(self) -> None:
+        """Connect to the cloud mobile and start keep-alive polling.
+
+        1. Fetches device info to verify it exists
+        2. Stores the UUID for keep-alive calls
+        3. Starts background keep-alive polling
+
+        Raises:
+            RuntimeError: If no cloud mobile is found with the given name.
+        """
+        logger.info(f"Connecting to cloud mobile: {self.cloud_mobile_name}")
+
+        try:
+            # Fetch device info to verify it exists and get UUID
+            self._mobile_info = await self._fetch_virtual_mobile()
+            self._mobile_id = self._mobile_info.id
+
+            logger.info(
+                f"Connected to cloud mobile: {self.cloud_mobile_name} "
+                f"(id={self._mobile_id}, state={self._mobile_info.state})"
+            )
+
+            # Check if device is in a usable state
+            if self._mobile_info.state not in ("Ready", "Starting"):
+                logger.warning(
+                    f"Cloud mobile state is '{self._mobile_info.state}'. "
+                    "Device may not be ready for use."
+                )
+
+            # Store the mobile ID in context for access from MCP tools
+            set_cloud_mobile_id(self._mobile_id)
+
+            # Send initial keep-alive
+            await self._send_keep_alive()
+
+            # Start keep-alive polling
+            self._stop_event.clear()
+            self._keep_alive_task = asyncio.create_task(
+                self._keep_alive_loop(),
+                name=f"cloud_mobile_keep_alive_{self._mobile_id}",
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to connect to cloud mobile '{self.cloud_mobile_name}': {e}")
+            await self._close_session()
+            raise RuntimeError(
+                f"Failed to connect to cloud mobile '{self.cloud_mobile_name}'. "
+                "Please verify:\n"
+                "  1. The cloud mobile exists in your Minitap Platform account\n"
+                "  2. The CLOUD_MOBILE_NAME matches exactly (case-sensitive)\n"
+                "  3. Your MINITAP_API_KEY has access to this cloud mobile\n"
+                f"Original error: {e}"
+            ) from e
+
+    async def _keep_alive_loop(self) -> None:
+        """Background task that sends periodic keep-alive pings.
+
+        This maintains the connection to the cloud mobile and prevents
+        idle shutdown (which would stop billing but also lose the session).
+        """
+        logger.info(
+            f"Starting cloud mobile keep-alive polling "
+            f"(interval={self.KEEP_ALIVE_INTERVAL_SECONDS}s)"
+        )
+
+        consecutive_failures = 0
+        max_failures = 3
+
+        while not self._stop_event.is_set():
+            try:
+                # Wait for the interval, but check stop_event frequently
+                for _ in range(self.KEEP_ALIVE_INTERVAL_SECONDS * 10):
+                    if self._stop_event.is_set():
+                        break
+                    await asyncio.sleep(0.1)
+
+                if self._stop_event.is_set():
+                    break
+
+                # Send keep-alive ping
+                success = await self._send_keep_alive()
+
+                if success:
+                    consecutive_failures = 0
+                else:
+                    consecutive_failures += 1
+                    if consecutive_failures >= max_failures:
+                        logger.error(
+                            f"Keep-alive failed {max_failures} times consecutively. "
+                            "Cloud mobile may have been shut down."
+                        )
+                        # Don't stop the loop - keep trying in case it recovers
+
+            except asyncio.CancelledError:
+                logger.info("Cloud mobile keep-alive task cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error in cloud mobile keep-alive: {e}")
+                consecutive_failures += 1
+                # Don't break on errors, try to continue
+                await asyncio.sleep(5)
+
+        logger.info("Cloud mobile keep-alive polling stopped")
+
+    async def disconnect(self) -> None:
+        """Disconnect from the cloud mobile and stop keep-alive polling.
+
+        This MUST be called when the MCP server shuts down to:
+        1. Stop keep-alive polling (allows VM to idle-shutdown if not used)
+        2. Clean up HTTP session
+
+        Note: We intentionally do NOT call a "stop" endpoint here.
+        Stopping keep-alive will let the VM idle-shutdown naturally
+        after its configured timeout, which is the expected behavior.
+        """
+        logger.info(f"Disconnecting from cloud mobile: {self.cloud_mobile_name}")
+
+        # Signal the keep-alive loop to stop
+        self._stop_event.set()
+
+        # Cancel and wait for keep-alive task
+        if self._keep_alive_task and not self._keep_alive_task.done():
+            self._keep_alive_task.cancel()
+            try:
+                await asyncio.wait_for(self._keep_alive_task, timeout=5.0)
+            except TimeoutError:
+                logger.warning("Keep-alive task did not stop in time")
+            except asyncio.CancelledError:
+                pass
+
+        # Close HTTP session
+        await self._close_session()
+
+        # Clear the context
+        set_cloud_mobile_id(None)
+        self._mobile_id = None
+        self._mobile_info = None
+
+        logger.info("Cloud mobile disconnected (keep-alive stopped)")
+
+    @property
+    def mobile_id(self) -> str | None:
+        """Get the cloud mobile UUID."""
+        return self._mobile_id
+
+    @property
+    def mobile_info(self) -> VirtualMobileInfo | None:
+        """Get the cloud mobile info."""
+        return self._mobile_info
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to a cloud mobile."""
+        return self._mobile_id is not None
+
+
+async def get_cloud_screenshot(mobile_id: str | None = None) -> bytes:
+    """Get a screenshot from a cloud mobile device.
+
+    GET /api/daas/virtual-mobiles/{id}/screenshot
+
+    Args:
+        mobile_id: The cloud mobile UUID. If None, uses the current context.
+
+    Returns:
+        Screenshot image bytes (PNG format).
+
+    Raises:
+        RuntimeError: If no cloud mobile is connected or screenshot fails.
+    """
+    target_id = mobile_id or get_cloud_mobile_id()
+
+    if not target_id:
+        raise RuntimeError(
+            "No cloud mobile connected. "
+            "Either provide a mobile_id or ensure CLOUD_MOBILE_NAME is set."
+        )
+
+    api_key = settings.MINITAP_API_KEY.get_secret_value() if settings.MINITAP_API_KEY else None
+    if not api_key:
+        raise RuntimeError("MINITAP_API_KEY is required for cloud screenshot.")
+
+    base_url = settings.MINITAP_DAAS_API.rstrip("/")
+    url = f"{base_url}/virtual-mobiles/{target_id}/screenshot"
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+    }
+
+    timeout = aiohttp.ClientTimeout(total=30)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.get(url, headers=headers) as response:
+            if response.status == 404:
+                raise RuntimeError(f"Cloud mobile '{target_id}' not found.")
+            if response.status == 401:
+                raise RuntimeError("Authentication failed for cloud screenshot.")
+            if response.status == 403:
+                raise RuntimeError(f"Access denied to cloud mobile '{target_id}'.")
+            if response.status != 200:
+                error_text = await response.text()
+                raise RuntimeError(
+                    f"Failed to get cloud screenshot: HTTP {response.status} - {error_text}"
+                )
+
+            return await response.read()

minitap/mcp/server/middleware.py

@@ -1,23 +1,21 @@
 from fastmcp.exceptions import ToolError
 from fastmcp.server.middleware import Middleware, MiddlewareContext
-
 from minitap.mobile_use.sdk import Agent
 
 
-class MaestroCheckerMiddleware(Middleware):
+class LocalDeviceHealthMiddleware(Middleware):
+    """Middleware that checks local device health before tool calls.
+
+    Only used in local mode (when CLOUD_MOBILE_NAME is not set).
+    For cloud mode, device health is managed by the cloud service.
+    """
+
     def __init__(self, agent: Agent):
         self.agent = agent
 
     async def on_call_tool(self, context: MiddlewareContext, call_next):
-        if context.fastmcp_context:
-            try:
-                tool = await context.fastmcp_context.fastmcp.get_tool(context.message.name)
-                if "requires-maestro" in tool.tags:
-                    if not self.agent.is_healthy():
-                        raise ToolError(
-                            "Maestro not healthy.\n"
-                            "Make sure a mobile device is connected and try again."
-                        )
-            except Exception:
-                pass
+        if not self.agent._initialized:
+            raise ToolError(
+                "Agent not initialized.\nMake sure a mobile device is connected and try again."
+            )
         return await call_next(context)

minitap/mcp/server/poller.py

@@ -33,11 +33,10 @@ async def _async_device_health_poller(stop_event: threading.Event, agent: Agent)
             devices = list_available_devices()
 
             if len(devices) > 0:
-                if not agent.is_healthy():
-                    logger.warning("Agent is not healthy. Reinitializing...")
-                    await agent.clean(force=True)
+                if not agent._initialized:
+                    logger.warning("Agent is not initialized. Initializing...")
                     await agent.init()
-                    logger.info("Agent reinitialized successfully")
+                    logger.info("Agent initialized successfully")
             else:
                 logger.info("No mobile device found, retrying in 5 seconds...")
 
@@ -45,8 +44,9 @@ async def _async_device_health_poller(stop_event: threading.Event, agent: Agent)
             logger.error(f"Error in device health poller: {e}")
 
     try:
-        await agent.clean(force=True)
-        logger.info("Agent cleaned up successfully")
+        if agent._initialized:
+            await agent.clean(force=True)
+            logger.info("Agent cleaned up successfully")
     except Exception as e:
         logger.error(f"Error cleaning up agent: {e}")
 

minitap/mcp/tools/analyze_screen.py

@@ -1,3 +1,4 @@
+import base64
 from pathlib import Path
 from uuid import uuid4
 
@@ -11,6 +12,7 @@ from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.core.llm import get_minitap_llm
 from minitap.mcp.core.utils.images import compress_base64_jpeg, get_screenshot_message_for_llm
 from minitap.mcp.main import mcp
+from minitap.mcp.server.cloud_mobile import get_cloud_mobile_id, get_cloud_screenshot
 
 
 @mcp.tool(
@@ -37,9 +39,18 @@ async def analyze_screen(
         Path(__file__).parent.joinpath("screen_analyzer.md").read_text(encoding="utf-8")
     ).render()
 
-    # Find the device and capture screenshot
-    device = find_mobile_device(device_id=device_id)
-    screenshot_base64 = capture_screenshot(device)
+    # Check if running in cloud mode
+    cloud_mobile_id = get_cloud_mobile_id()
+
+    if cloud_mobile_id:
+        # Cloud mode: fetch screenshot from DaaS API
+        screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
+        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+    else:
+        # Local mode: capture from local device
+        device = find_mobile_device(device_id=device_id)
+        screenshot_base64 = capture_screenshot(device)
+
     compressed_image_base64 = compress_base64_jpeg(screenshot_base64)
 
     messages: list[BaseMessage] = [

minitap/mcp/tools/compare_screenshot_with_figma.py

@@ -23,7 +23,7 @@ from minitap.mcp.main import mcp
     Compare a screenshot of the current state with a Figma design.
     
     This tool:
-    1. Captures a screenshot of the current state
+    1. Captures a screenshot of the current state (supports both local and cloud devices)
     2. Compares the live device screenshot with the Figma design
     3. Returns a detailed comparison report with both screenshots for visual context
     """,

minitap/mcp/tools/execute_mobile_command.py

@@ -8,6 +8,8 @@ from minitap.mobile_use.sdk.types import ManualTaskConfig
 from minitap.mobile_use.sdk.types.task import PlatformTaskRequest
 from pydantic import Field
 
+from minitap.mcp.core.cloud_apk import install_apk_on_cloud_mobile, upload_apk_to_cloud_mobile
+from minitap.mcp.core.config import settings
 from minitap.mcp.core.decorators import handle_tool_errors
 from minitap.mcp.core.sdk_agent import get_mobile_use_agent
 from minitap.mcp.main import mcp
@@ -26,14 +28,30 @@ def _serialize_result(result: Any) -> Any:
 
 @mcp.tool(
     name="execute_mobile_command",
-    tags={"requires-maestro"},
     description="""
     Execute a natural language command on a mobile device using the Minitap SDK.
     This tool allows you to control your Android or iOS device using natural language.
+    
     Examples:
     - "Open the settings app and tell me the battery level"
     - "Find the first 3 unread emails in Gmail"
     - "Take a screenshot and save it"
+    
+    APK Deployment (Cloud Mobile Only):
+    When CLOUD_MOBILE_NAME is set, you can deploy and test APKs on cloud mobiles:
+    - Set apk_path to the path of your locally built APK
+    - The APK will be uploaded to cloud storage and installed on the device
+    - Requires MINITAP_API_KEY environment variable
+    - Must provide locked_app_package when using apk_path
+    
+    Example with APK deployment:
+    execute_mobile_command(
+        apk_path="/path/to/app-debug.apk",
+        locked_app_package="com.example.myapp",
+        goal="Test the login flow with valid credentials"
+    )
+    
+    Note: If apk path is set and no cloud mobile name -> it will raise a tool error
     """,
 )
 @handle_tool_errors
@@ -49,18 +67,41 @@ async def execute_mobile_command(
         default=None,
         description="Optional package name of the app to lock the device to. "
         "Will launch the app if not already running, and keep it in foreground "
-        "until the task is completed.",
+        "until the task is completed. REQUIRED when using apk_path.",
+    ),
+    apk_path: str | None = Field(
+        default=None,
+        description="Path to local APK file to deploy to cloud mobile. "
+        "Only works when CLOUD_MOBILE_NAME is set. "
+        "The APK will be uploaded to cloud storage and installed before task execution. "
+        "Requires MINITAP_API_KEY to be configured. ",
     ),
 ) -> str | dict[str, Any]:
     """Run a manual task on a mobile device via the Minitap platform."""
     try:
+        if apk_path:
+            if not settings.CLOUD_MOBILE_NAME:
+                raise ToolError(
+                    "apk_path parameter requires CLOUD_MOBILE_NAME to be set. "
+                    "APK deployment is only supported in cloud mobile mode."
+                )
+
+            # Step 1: Upload APK via Platform storage API
+            filename = await upload_apk_to_cloud_mobile(apk_path=apk_path)
+
+            # Step 2: Install APK on cloud mobile
+            await install_apk_on_cloud_mobile(filename=filename)
+
         request = PlatformTaskRequest(
             task=ManualTaskConfig(
                 goal=goal,
                 output_description=output_description,
             ),
+            execution_origin="mcp",
         )
         agent = get_mobile_use_agent()
+        if not agent._initialized:
+            await agent.init()
         result = await agent.run_task(
             request=request,
             locked_app_package=locked_app_package,

{minitap_mcp-0.5.3.dist-info → minitap_mcp-0.6.0.dist-info}/METADATA

@@ -1,17 +1,18 @@
 Metadata-Version: 2.3
 Name: minitap-mcp
-Version: 0.5.3
+Version: 0.6.0
 Summary: Model Context Protocol server for controlling Android & iOS devices with natural language
 Author: Pierre-Louis Favreau, Jean-Pierre Lo, Clément Guiguet
 Requires-Dist: fastmcp>=2.12.4
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: pydantic>=2.12.0
 Requires-Dist: pydantic-settings>=2.10.1
-Requires-Dist: minitap-mobile-use>=2.9.3
+Requires-Dist: minitap-mobile-use>=3.0.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: langchain-core>=0.3.75
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: structlog>=24.4.0
+Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: ruff==0.5.3 ; extra == 'dev'
 Requires-Dist: pytest==8.4.1 ; extra == 'dev'
 Requires-Dist: pytest-cov==5.0.0 ; extra == 'dev'
@@ -40,11 +41,19 @@ Before running the MCP server, ensure you have the required mobile automation to
 - **For Android devices:**
 
   - [ADB (Android Debug Bridge)](https://developer.android.com/tools/adb) - For device communication
-  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
 
 - **For iOS devices (macOS only):**
   - Xcode Command Line Tools with `xcrun`
-  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
+  - **[fb-idb](https://fbidb.io/docs/installation/)**: Facebook's iOS Development Bridge for device automation.
+
+```bash
+# Install via Homebrew (macOS)
+brew tap facebook/fb
+brew install idb-companion
+```
+
+> [!NOTE]
+> `idb_companion` is required to communicate with iOS simulators. Make sure it's in your PATH after installation.
 
 For detailed setup instructions, see the [mobile-use repository](https://github.com/minitap-ai/mobile-use).
 
@@ -244,6 +253,50 @@ The tool will:
 3. Compare both screenshots using vision AI
 4. Return a detailed analysis highlighting differences
 
+## Cloud Mobile Mode
+
+Run the MCP server with cloud-hosted mobile devices instead of requiring a local device. This enables:
+
+- **Zero local setup**: No ADB or physical device required
+- **Remote development**: Control cloud mobiles from anywhere
+- **Scalable automation**: Access multiple cloud devices
+
+### Setting Up Cloud Mobile Mode
+
+1. **Create a Cloud Mobile** on [Minitap Platform](https://platform.minitap.ai/cloud-mobiles):
+   - Click **Create New Device**
+   - Choose platform (currently Android v11 / API level 30)
+   - Set a **Reference Name** (e.g., `my-dev-device`)
+
+2. **Configure the environment variable**:
+
+```bash
+# Using reference name (recommended)
+export CLOUD_MOBILE_NAME="my-dev-device"
+```
+
+3. **Start the server** (no local device needed):
+
+```bash
+minitap-mcp --server --api-key your_minitap_api_key
+```
+
+The server will:
+- Connect to your cloud mobile on startup
+- Maintain a keep-alive connection while running
+- Automatically disconnect when the server stops
+
+> ⚠️ **Important**: Cloud mobiles are billed while connected. The MCP server automatically stops the connection when you close your IDE or stop the server. Make sure to properly shut down the server to avoid unexpected charges.
+
+### Cloud vs Local Mode
+
+| Feature | Local Mode | Cloud Mode |
+|---------|------------|------------|
+| Device requirement | Physical/emulator | None |
+| Setup complexity | ADB setup required | Low (env var only) |
+| `CLOUD_MOBILE_NAME` | Not set | Set to device name/UUID |
+| Billing | None | Per-minute usage |
+
 ## Advanced Configuration
 
 ### Custom ADB Server

{minitap_mcp-0.5.3.dist-info → minitap_mcp-0.6.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 minitap/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-minitap/mcp/core/agents/compare_screenshots/agent.py,sha256=k25xbXJSMZgWYsDP0qpmNcqBo5yGbsQxRZ0nnYKHgbc,2054
+minitap/mcp/core/agents/compare_screenshots/agent.py,sha256=XRYyrv9QA4eb1b44hPjAqz6MKYM6y3THosxP21xzBY4,2458
 minitap/mcp/core/agents/compare_screenshots/eval/prompts/prompt_1.md,sha256=qAyqOroSJROgrvlbsLCtiwFyBKuIMCQ-720A5cwgwPY,3563
 minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_move_button/actual.png,sha256=woKE-aTTdb-9ArqfnV-xKKyit1Fu_hklavVwAaMQ14E,99455
 minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_move_button/figma.png,sha256=ghxi1P-ofnmMv5_ASm0Rzo5ll_C8-E6ojQUCHRR33TA,102098
@@ -7,24 +7,26 @@ minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_
 minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_move_button/prompt_1/model_params.json,sha256=p93kbUGxLYwc4NAEzPTBDA2XZ1ucsa7yevXZRe6V4Mc,37
 minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_move_button/prompt_1/output.md,sha256=Q0_5w9x5WAMqx6-I7KgjlS-tt7HnWKIunP43J7F0W_o,3703
 minitap/mcp/core/agents/compare_screenshots/prompt.md,sha256=qAyqOroSJROgrvlbsLCtiwFyBKuIMCQ-720A5cwgwPY,3563
-minitap/mcp/core/config.py,sha256=_rIH31treZlM2RVnTz5cPXhV9Bu4D-w4TmbPh5_mxxM,1026
+minitap/mcp/core/cloud_apk.py,sha256=Xeg1jrycm50UC72J4qVZ2NS9qs20oXKhvBcmBRs4rEA,3896
+minitap/mcp/core/config.py,sha256=v_neP4lqIx7sigiAPxUALZg5QBrIx-N4mJ848YRfG84,1428
 minitap/mcp/core/decorators.py,sha256=kMx_mlaa-2U1AgCoYkgPoLOa-iOoKUF1OjcNV7x59Ds,2940
 minitap/mcp/core/device.py,sha256=sEO3Z-8F325hDOObdH1YBhZE60f17FmIclt5UlhY_nU,7875
 minitap/mcp/core/llm.py,sha256=tI5m5rFDLeMkXE5WExnzYSzHU3nTIEiSC9nAsPzVMaU,1144
 minitap/mcp/core/logging_config.py,sha256=OJlArPJxflbhckerFsRHVTzy3jwsLsNSPN0LVpkmpNM,1861
 minitap/mcp/core/models.py,sha256=egLScxPAMo4u5cqY33UKba7z7DsdgqfPW409UAqW1Jg,1942
-minitap/mcp/core/sdk_agent.py,sha256=-9l1YetD93dzxOeSFOT_j8dDfDFjhJLiir8bhzEjI3Y,900
+minitap/mcp/core/sdk_agent.py,sha256=5YEr7aDjoiwbRQkZBK3jDa08c5QhPwLxahzlYrEB_KE,1132
 minitap/mcp/core/utils/figma.py,sha256=L5aAHm59mrRYaqrwMJSM24SSdZPu2yVg-wsHTF3L8vk,2310
 minitap/mcp/core/utils/images.py,sha256=3uExpRoh7affIieZx3TLlZTmZCcoxWfx1YpPbwhjiJY,1791
-minitap/mcp/main.py,sha256=RsFAU32Rgrt66OiOtO74k7HSeTWRqnw31IurbnsOI3I,4811
-minitap/mcp/server/middleware.py,sha256=fbry_IiHmwUxVjsWgOU2goybcS1kLRXFZZ89KPH1d8E,880
-minitap/mcp/server/poller.py,sha256=Qakq4yO3EJ9dXmRqtE3sJjyk0ij7VBU-NuupHhTf37g,2539
-minitap/mcp/tools/analyze_screen.py,sha256=xQALhVfbEn13ao7C3EvzuBusOgjYIkS9hzKhzQSne6g,1991
-minitap/mcp/tools/compare_screenshot_with_figma.py,sha256=a3rHi8MbomgspJ2iPPgTyRoYrcEai2r4ED_-DssSbNI,4581
-minitap/mcp/tools/execute_mobile_command.py,sha256=iZLQHu-NGSjtjIjzYLTf2Da0t--RgjcFghmUBfhmo1I,2484
+minitap/mcp/main.py,sha256=6UjO26otULFbTmoI_WziknaRyBTXSazH9sqXRP-wns8,9250
+minitap/mcp/server/cloud_mobile.py,sha256=kntcdMkc89QoXyLc-f5bzWFm6UBj52NqrBNHopAv-ag,14573
+minitap/mcp/server/middleware.py,sha256=SjPc4pcfPuG0TnaDH7a19DS_HRFPl3bkbovdOLzy_IU,768
+minitap/mcp/server/poller.py,sha256=JsdW6nvj4r3tsn8AaTwXD4H9dVAAau4BhJXHXHit9nA,2528
+minitap/mcp/tools/analyze_screen.py,sha256=_7tj7AJvopotvItGIN55OoztJXmVu3j2ZsBmYq28pVw,2422
+minitap/mcp/tools/compare_screenshot_with_figma.py,sha256=gMaYItE_bg_EwY2-Ux9RQd-Cnz6s2RCtYh1Q5n7HciU,4621
+minitap/mcp/tools/execute_mobile_command.py,sha256=e49Y14KLTJ63ZQvLUrn-CvC5TQrylCXsUDEuJOTE5j8,4271
 minitap/mcp/tools/save_figma_assets.py,sha256=V1gnQsJ1tciOxiK08aaqQxOEerJkKzxU8r4hJmkXHtA,9945
 minitap/mcp/tools/screen_analyzer.md,sha256=TTO80JQWusbA9cKAZn-9cqhgVHm6F_qJh5w152hG3YM,734
-minitap_mcp-0.5.3.dist-info/WHEEL,sha256=ZHijuPszqKbNczrBXkSuoxdxocbxgFghqnequ9ZQlVk,79
-minitap_mcp-0.5.3.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
-minitap_mcp-0.5.3.dist-info/METADATA,sha256=D6x7r5Lvd_L9OEjDxkRZJPx42kIexF_gK3Ovxf0q4K0,8827
-minitap_mcp-0.5.3.dist-info/RECORD,,
+minitap_mcp-0.6.0.dist-info/WHEEL,sha256=93kfTGt3a0Dykt_T-gsjtyS5_p8F_d6CE1NwmBOirzo,79
+minitap_mcp-0.6.0.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
+minitap_mcp-0.6.0.dist-info/METADATA,sha256=pzp6FGqqncEUQ9YNyheBLGonB2Pe8DDE2LKJRwJ-HE4,10589
+minitap_mcp-0.6.0.dist-info/RECORD,,

{minitap_mcp-0.5.3.dist-info → minitap_mcp-0.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.10
+Generator: uv 0.9.16
 Root-Is-Purelib: true
 Tag: py3-none-any