minitap-mcp 0.9.1__py3-none-any.whl → 0.9.2__py3-none-any.whl

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

@@ -1,5 +1,4 @@
 import asyncio
-import base64
 from pathlib import Path
 from uuid import uuid4
 
@@ -10,7 +9,6 @@ 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):
@@ -25,7 +23,7 @@ async def compare_screenshots(
     """
     Compare screenshots and return the comparison text along with both screenshots.
 
-    Supports both local devices (Android/iOS) and cloud devices.
+    Captures screenshot from local device and compares with expected screenshot.
 
     Returns:
         CompareScreenshotsOutput
@@ -34,14 +32,8 @@ async def compare_screenshots(
         Path(__file__).parent.joinpath("prompt.md").read_text(encoding="utf-8")
     ).render()
 
-    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)
+    device = find_mobile_device()
+    current_screenshot = capture_screenshot(device)
 
     messages: list[BaseMessage] = [
         SystemMessage(content=system_message),

minitap/mcp/core/config.py

@@ -62,11 +62,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)
+    # Local device configuration
+    # When False, disables the local device health poller.
+    # Useful when running the MCP server without a local device attached
+    # (e.g., only using cloud_platform parameter in execute_mobile_command).
+    ENABLE_LOCAL_DEVICE: bool = Field(default=True)
 
     # Trajectory GIF download configuration
     # When set, downloads the trajectory GIF after task execution to the specified folder.

minitap/mcp/core/sdk_agent.py

@@ -3,8 +3,6 @@ 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
 
@@ -26,10 +24,6 @@ def get_mobile_use_agent() -> Agent:
             _, 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

@@ -35,7 +35,6 @@ from minitap.mcp.core.logging_config import (
     configure_logging,  # noqa: E402
     get_logger,
 )
-from minitap.mcp.server.cloud_mobile import CloudMobileService
 from minitap.mcp.server.middleware import LocalDeviceHealthMiddleware
 from minitap.mcp.server.poller import device_health_poller
 from minitap.mobile_use.config import settings as sdk_settings
@@ -54,13 +53,7 @@ def main() -> None:
         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",
@@ -82,11 +75,6 @@ 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__()
@@ -123,7 +111,6 @@ class MCPLifespanContext:
     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
     remote_mcp_proxy: FastMCP | None = None
@@ -133,67 +120,30 @@ class MCPLifespanContext:
 async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
     """Lifespan context manager for MCP server.
 
-    Handles startup/shutdown for both cloud and local modes.
+    Handles startup/shutdown for local and cloud-only 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):
+    Local mode (ENABLE_LOCAL_DEVICE=True, default):
     - Starts device health poller
     - Monitors local device connection
 
+    Cloud-only mode (ENABLE_LOCAL_DEVICE=False):
+    - No local device polling
+    - Use cloud_platform parameter in execute_mobile_command to run tasks
+
     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:
+    if settings.ENABLE_LOCAL_DEVICE:
         # ==================== LOCAL MODE ====================
-        logger.info("Starting MCP in LOCAL mode (no CLOUD_MOBILE_NAME set)")
+        logger.info("Starting MCP in LOCAL mode with device polling")
 
         agent = get_mobile_use_agent()
         server.add_middleware(LocalDeviceHealthMiddleware(agent))
@@ -210,6 +160,12 @@ async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
         context.local_poller_stop_event = stop_event
         context.local_poller_thread = poller_thread
         logger.info("Device health poller started")
+    else:
+        # ==================== CLOUD-ONLY MODE ====================
+        logger.info(
+            "Starting MCP without local device polling (ENABLE_LOCAL_DEVICE=False). "
+            "Use cloud_platform parameter in execute_mobile_command to run tasks."
+        )
 
     # ==================== REMOTE MCP PROXY ====================
     # Mount remote MCP proxy if configured (works in both cloud and local modes)
@@ -257,15 +213,6 @@ async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
         # ==================== 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...")

minitap/mcp/server/middleware.py

@@ -6,14 +6,18 @@ from minitap.mobile_use.sdk import Agent
 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.
+    Only used in local mode (when ENABLE_LOCAL_DEVICE is True).
     """
 
     def __init__(self, agent: Agent):
         self.agent = agent
 
     async def on_call_tool(self, context: MiddlewareContext, call_next):
+        # Skip agent check if platform is set (Limrun mode creates its own agent)
+        tool_args = getattr(context.message, "arguments", None) or {}
+        if tool_args.get("cloud_platform"):
+            return await call_next(context)
+
         if not self.agent._initialized:
             raise ToolError(
                 "Agent not initialized.\nMake sure a mobile device is connected and try again."

minitap/mcp/tools/execute_mobile_command.py

@@ -7,11 +7,12 @@ from typing import Any
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import ToolResult
 from mcp.types import TextContent
-from minitap.mobile_use.sdk.types import ManualTaskConfig
+from minitap.mobile_use.sdk import Agent
+from minitap.mobile_use.sdk.builders import Builders
+from minitap.mobile_use.sdk.types import LimrunPlatform, 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.logging_config import get_logger
@@ -19,7 +20,6 @@ from minitap.mcp.core.sdk_agent import get_mobile_use_agent
 from minitap.mcp.core.storage import StorageDownloadError, download_trajectory_gif
 from minitap.mcp.core.task_runs import TaskRunsError, get_latest_task_run_id
 from minitap.mcp.main import mcp
-from minitap.mcp.server.cloud_mobile import check_cloud_mobile_status
 
 logger = get_logger(__name__)
 
@@ -39,33 +39,36 @@ def _serialize_result(result: Any) -> Any:
     name="execute_mobile_command",
     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.
+    This tool allows you to control Android or iOS devices 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"
+    Set cloud_platform to run on a cloud device (recommended for most use cases).
     
-    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
+    Examples:
+    - execute_mobile_command(cloud_platform="android", goal="Open Settings and check battery level")
+    - execute_mobile_command(cloud_platform="ios", goal="Open Safari and search for weather")
     
-    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"
-    )
+    App Deployment:
+    You can deploy and test apps by providing the path to a locally built app:
+    - Set app_path to the path of your .apk file (Android) or .app folder (iOS)
+    - The app will be automatically uploaded and installed on the device
+    - Must provide locked_app_package (package name or bundle ID) when using app_path
     
-    Note: If apk path is set and no cloud mobile name -> it will raise a tool error
+    Examples with app deployment:
+    - execute_mobile_command(cloud_platform="android", goal="Test login flow", 
+        app_path="/path/to/app-debug.apk", locked_app_package="com.example.myapp")
+    - execute_mobile_command(cloud_platform="ios", goal="Verify onboarding screens",
+        app_path="/path/to/MyApp.app", locked_app_package="com.example.myapp")
     """,
 )
 @handle_tool_errors
 async def execute_mobile_command(
     goal: str = Field(description="High-level goal describing the action to perform."),
+    cloud_platform: LimrunPlatform | None = Field(
+        default=None,
+        description="Cloud platform to run on: 'android' or 'ios'. "
+        "When set, a cloud device is automatically provisioned for this task "
+        "and cleaned up afterwards.",
+    ),
     output_description: str | None = Field(
         default=None,
         description="Optional description of the expected output format. "
@@ -76,33 +79,33 @@ 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. REQUIRED when using apk_path.",
+        "until the task is completed. REQUIRED when using app_path.",
     ),
-    apk_path: str | None = Field(
+    app_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. ",
+        description="Path to local .apk file (Android) or .app folder (iOS) to deploy. "
+        "The app will be automatically uploaded and installed on the device. "
+        "Must provide locked_app_package when using app_path.",
     ),
 ) -> str | dict[str, Any] | ToolResult:
     """Run a manual task on a mobile device via the Minitap platform."""
     try:
-        if settings.CLOUD_MOBILE_NAME:
-            await check_cloud_mobile_status(settings.CLOUD_MOBILE_NAME)
-
-        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)
+        # Cloud platform mode: provision a cloud device on-demand
+        if cloud_platform:
+            return await _execute_with_cloud_platform(
+                cloud_platform=cloud_platform,
+                goal=goal,
+                output_description=output_description,
+                locked_app_package=locked_app_package,
+                app_path=app_path,
+            )
 
-            # Step 2: Install APK on cloud mobile
-            await install_apk_on_cloud_mobile(filename=filename)
+        # Local device mode
+        if app_path:
+            raise ToolError(
+                "app_path parameter requires cloud_platform to be set. "
+                "App deployment is only supported in cloud platform mode."
+            )
 
         request = PlatformTaskRequest(
             task=ManualTaskConfig(
@@ -146,6 +149,81 @@ async def execute_mobile_command(
         raise ToolError(str(e))
 
 
+async def _execute_with_cloud_platform(
+    cloud_platform: LimrunPlatform,
+    goal: str,
+    output_description: str | None,
+    locked_app_package: str | None,
+    app_path: str | None = None,
+) -> str | dict[str, Any] | ToolResult:
+    """Execute a task using a cloud device.
+
+    Provisions a cloud device, runs the task, and cleans up afterwards.
+    """
+    api_key = settings.MINITAP_API_KEY.get_secret_value() if settings.MINITAP_API_KEY else None
+    if not api_key:
+        raise ToolError(
+            "MINITAP_API_KEY is required for cloud platform mode. "
+            "Please set your API key via --api-key or MINITAP_API_KEY environment variable."
+        )
+
+    logger.info(f"Provisioning {cloud_platform.value} cloud device for task execution...")
+
+    # Create a dedicated agent for this cloud task
+    config = Builders.AgentConfig.for_limrun(platform=cloud_platform, api_key=api_key)
+    agent = Agent(config=config.build())
+
+    try:
+        await agent.init(api_key=api_key)
+        logger.info(f"{cloud_platform.value} cloud device ready, executing task...")
+
+        request = PlatformTaskRequest(
+            task=ManualTaskConfig(
+                goal=goal,
+                output_description=output_description,
+            ),
+            execution_origin="mcp",
+        )
+
+        # Pass app_path to run_task - SDK handles upload and installation
+        result = await agent.run_task(
+            request=request,
+            locked_app_package=locked_app_package,
+            app_path=app_path,
+        )
+
+        trajectory_gif_path: Path | None = None
+        if settings.TRAJECTORY_GIF_DOWNLOAD_FOLDER:
+            trajectory_gif_path = await _download_trajectory_gif_if_available()
+
+        serialized_result = _serialize_result(result)
+
+        if trajectory_gif_path:
+            import json
+
+            result_text = (
+                json.dumps(serialized_result, indent=2)
+                if isinstance(serialized_result, dict)
+                else str(serialized_result)
+            )
+            return ToolResult(
+                content=[
+                    TextContent(type="text", text=result_text),
+                    TextContent(type="text", text=f"Trajectory saved to {trajectory_gif_path}"),
+                ],
+            )
+
+        return serialized_result
+    finally:
+        # Always clean up the cloud device
+        logger.info(f"Cleaning up {cloud_platform.value} cloud device...")
+        try:
+            await agent.clean()
+            logger.info(f"{cloud_platform.value} cloud device cleaned up successfully")
+        except Exception as e:
+            logger.error(f"Error cleaning up cloud device: {e}")
+
+
 async def _download_trajectory_gif_if_available() -> Path | None:
     """Download the trajectory GIF if available and folder is configured.
 

minitap/mcp/tools/take_screenshot.py

@@ -1,18 +1,11 @@
 """Simple screenshot capture tool - returns raw base64 image without LLM analysis."""
 
-import base64
-
 from mcp.types import ImageContent
 from pydantic import Field
 
 from minitap.mcp.core.decorators import handle_tool_errors
 from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.main import mcp
-from minitap.mcp.server.cloud_mobile import (
-    check_cloud_mobile_status,
-    get_cloud_mobile_id,
-    get_cloud_screenshot,
-)
 
 
 @mcp.tool(
@@ -32,17 +25,8 @@ async def take_screenshot(
     ),
 ) -> list[ImageContent]:
     """Capture screenshot and return as base64 image content."""
-    cloud_mobile_id = get_cloud_mobile_id()
-
-    if cloud_mobile_id:
-        # Cloud mode: use cloud screenshot API
-        await check_cloud_mobile_status(cloud_mobile_id)
-        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)
+    device = find_mobile_device(device_id=device_id)
+    screenshot_base64 = capture_screenshot(device)
 
     return [
         ImageContent(

minitap/mcp/tools/upload_screenshot.py

@@ -5,8 +5,6 @@ to remote storage, returning a filename that can be used with other tools
 like figma_compare_screenshot.
 """
 
-import base64
-
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import ToolResult
 
@@ -15,7 +13,6 @@ from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.core.logging_config import get_logger
 from minitap.mcp.core.storage import StorageUploadError, upload_screenshot_to_storage
 from minitap.mcp.main import mcp
-from minitap.mcp.server.cloud_mobile import get_cloud_mobile_id, get_cloud_screenshot
 
 logger = get_logger(__name__)
 
@@ -26,7 +23,7 @@ logger = get_logger(__name__)
     Capture a screenshot from the connected device and upload it to storage.
     
     This tool:
-    1. Captures a screenshot from the connected device (local or cloud)
+    1. Captures a screenshot from the connected local device
     2. Uploads the screenshot to remote storage
     3. Returns a filename that can be used with other tools
     
@@ -43,23 +40,13 @@ async def upload_screenshot() -> ToolResult:
     """Capture and upload a device screenshot, return the filename."""
     logger.info("Capturing and uploading device screenshot")
 
-    # Step 1: Capture screenshot from device
-    cloud_mobile_id = get_cloud_mobile_id()
-
-    if cloud_mobile_id:
-        logger.debug("Capturing screenshot from cloud device", device_id=cloud_mobile_id)
-        try:
-            screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
-            screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
-        except Exception as e:
-            raise ToolError(f"Failed to capture cloud device screenshot: {e}") from e
-    else:
-        logger.debug("Capturing screenshot from local device")
-        try:
-            device = find_mobile_device()
-            screenshot_base64 = capture_screenshot(device)
-        except Exception as e:
-            raise ToolError(f"Failed to capture local device screenshot: {e}") from e
+    # Step 1: Capture screenshot from local device
+    logger.debug("Capturing screenshot from local device")
+    try:
+        device = find_mobile_device()
+        screenshot_base64 = capture_screenshot(device)
+    except Exception as e:
+        raise ToolError(f"Failed to capture local device screenshot: {e}") from e
 
     logger.info("Screenshot captured from device")
 

{minitap_mcp-0.9.1.dist-info → minitap_mcp-0.9.2.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: minitap-mcp
-Version: 0.9.1
+Version: 0.9.2
 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>=3.4.0
+Requires-Dist: minitap-mobile-use>=3.5.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: langchain-core>=0.3.75
 Requires-Dist: pillow>=11.1.0

{minitap_mcp-0.9.1.dist-info → minitap_mcp-0.9.2.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=XRYyrv9QA4eb1b44hPjAqz6MKYM6y3THosxP21xzBY4,2458
+minitap/mcp/core/agents/compare_screenshots/agent.py,sha256=jujG09SmTUlnRbFmqPZuaQnR7KboN348sNzljGWpYqA,2136
 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,29 +7,27 @@ 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/cloud_apk.py,sha256=K0PmmkvkCzYo-eRfwGmfPcBbMy8KD32pHvrehm_L_YM,4308
-minitap/mcp/core/config.py,sha256=dCQMuT-jvGHBxIsvTQoUDOvZ98MTO5iwgCc3_bngX5M,4407
+minitap/mcp/core/config.py,sha256=lFpvKb_lpJRRWl_PF0SoRuK4Qssqy_3Uy2aGBt895nY,4382
 minitap/mcp/core/decorators.py,sha256=ipzR7kbMXacG91f6CliN-nl9unRTtjmANrfueaOXJ2s,3591
 minitap/mcp/core/device.py,sha256=0AU8qGi26axC6toqHrPIzNeDbNDtll0YRwkspHouPmM,8198
 minitap/mcp/core/llm.py,sha256=tI5m5rFDLeMkXE5WExnzYSzHU3nTIEiSC9nAsPzVMaU,1144
 minitap/mcp/core/logging_config.py,sha256=GElnKsOFtk58EMJWPKRGtKW101tnCubNKRFTe0gEh4I,2020
 minitap/mcp/core/models.py,sha256=egLScxPAMo4u5cqY33UKba7z7DsdgqfPW409UAqW1Jg,1942
-minitap/mcp/core/sdk_agent.py,sha256=5YEr7aDjoiwbRQkZBK3jDa08c5QhPwLxahzlYrEB_KE,1132
+minitap/mcp/core/sdk_agent.py,sha256=NmXMo4ZLAaiJgyRvyyrA-zbCGSrv7HveAxYgyKosbJU,902
 minitap/mcp/core/storage.py,sha256=t9BAEqXH7Nu8p8hgGIk3mO6rxLwviBP0FqvQD4Lz8CQ,13184
 minitap/mcp/core/task_runs.py,sha256=vGv8G-oZcfe_lpMOGiM649u10WNzoU3uWDgYWm1owdQ,3115
 minitap/mcp/core/utils/figma.py,sha256=L5aAHm59mrRYaqrwMJSM24SSdZPu2yVg-wsHTF3L8vk,2310
 minitap/mcp/core/utils/images.py,sha256=3uExpRoh7affIieZx3TLlZTmZCcoxWfx1YpPbwhjiJY,1791
-minitap/mcp/main.py,sha256=p5E_dBIBiS_sp_v9u8gNxjRGwl25T4De-ivZQbSqJa8,11269
-minitap/mcp/server/cloud_mobile.py,sha256=4cKnUzOJE5tBzgXgJXmyH0ESf6OyCTlNllputEQwFvE,18261
-minitap/mcp/server/middleware.py,sha256=SjPc4pcfPuG0TnaDH7a19DS_HRFPl3bkbovdOLzy_IU,768
+minitap/mcp/main.py,sha256=XCGHpi_afJRec5Bw_WQYZm252jSYPiGVPQ_S7lH9680,9163
+minitap/mcp/server/middleware.py,sha256=-UosvRBlk_DglmTte3Flh-1z0fbb6Cogg6D0T8rMExg,941
 minitap/mcp/server/poller.py,sha256=JsdW6nvj4r3tsn8AaTwXD4H9dVAAau4BhJXHXHit9nA,2528
 minitap/mcp/server/remote_proxy.py,sha256=IM7UfjbJlQRpFD_tdpdck1mFT1QOnlxj5OA1nS4tRhQ,3073
-minitap/mcp/tools/execute_mobile_command.py,sha256=K5KhSAqLdcmc6WH_u2TKAybECPw53TuSLEoSVrGCPOE,6776
+minitap/mcp/tools/execute_mobile_command.py,sha256=ouSC5LZQ8Fc-PUGMBYB9TnZ_BKSKwANmdnn-36l5Lx4,9766
 minitap/mcp/tools/read_swift_logs.py,sha256=Wc1XqQWWuNuPEIBioYD2geVd1p9Yq2USik6SX47Fq9A,9285
 minitap/mcp/tools/screen_analyzer.md,sha256=TTO80JQWusbA9cKAZn-9cqhgVHm6F_qJh5w152hG3YM,734
-minitap/mcp/tools/take_screenshot.py,sha256=gGySPSeVnx8lHiseGF_Wat82JLF-D8GuQIJ_hCaLZlQ,1730
-minitap/mcp/tools/upload_screenshot.py,sha256=kwh8Q46LWF3nyKbKlvnlf-CtGrPkctXSnLyeebQGNFI,2959
-minitap_mcp-0.9.1.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-minitap_mcp-0.9.1.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
-minitap_mcp-0.9.1.dist-info/METADATA,sha256=3zTwoaqHLDMUhftH78b7rO284NkyoBgBoOBPvuttzRM,10619
-minitap_mcp-0.9.1.dist-info/RECORD,,
+minitap/mcp/tools/take_screenshot.py,sha256=aL58qJaiLkBK95Ziagn7RQe713Pbu8E7AcoyK3GLlyw,1196
+minitap/mcp/tools/upload_screenshot.py,sha256=Ue1w8RHNNdGEIJizRdqKrmzeP0kymu1s5Uk3v2Ge-3E,2372
+minitap_mcp-0.9.2.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+minitap_mcp-0.9.2.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
+minitap_mcp-0.9.2.dist-info/METADATA,sha256=AbAyk7cQEZiI6K_u-N_twOLewx-cTHmPwG1S6JGG5hE,10619
+minitap_mcp-0.9.2.dist-info/RECORD,,

{minitap_mcp-0.9.1.dist-info → minitap_mcp-0.9.2.dist-info}/WHEEL

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

minitap/mcp/core/cloud_apk.py

@@ -1,117 +0,0 @@
-"""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}")
-
-    # Use APP_PACKAGE_NAME env var if set, otherwise generate a random name
-    # Preserve the original file extension
-    extension = apk_file.suffix  # e.g., ".apk"
-    if settings.APP_PACKAGE_NAME:
-        # Strip any existing extension from APP_PACKAGE_NAME to avoid double extensions
-        base_name = Path(settings.APP_PACKAGE_NAME).stem
-        filename = f"{base_name}{extension}"
-    else:
-        filename = f"app_{uuid.uuid4().hex[:6]}{extension}"
-    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/server/cloud_mobile.py

@@ -1,492 +0,0 @@
-"""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
-from minitap.mcp.core.device import DeviceNotReadyError
-
-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()
-
-
-async def check_cloud_mobile_status(
-    cloud_mobile_name: str | None = None,
-) -> VirtualMobileInfo:
-    """Check the current status of a cloud mobile device.
-
-    This function checks the device state once and raises an appropriate error
-    if the device is not ready. The MCP client can then decide to retry.
-
-    Args:
-        cloud_mobile_name: The reference name or UUID of the cloud mobile.
-                          If None, uses CLOUD_MOBILE_NAME from settings.
-
-    Returns:
-        VirtualMobileInfo: Device info if ready.
-
-    Raises:
-        DeviceNotReadyError: If device is not ready (starting, stopping, etc.).
-        RuntimeError: If device is in an error state, stopped, or not found.
-    """
-    target_name = cloud_mobile_name or settings.CLOUD_MOBILE_NAME
-    if not target_name:
-        raise RuntimeError(
-            "No cloud mobile specified. Either provide cloud_mobile_name or set CLOUD_MOBILE_NAME."
-        )
-
-    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 mobile operations.")
-
-    base_url = settings.MINITAP_DAAS_API.rstrip("/")
-    url = f"{base_url}/virtual-mobiles/{target_name}"
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
-
-    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_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 != 200:
-                error_text = await response.text()
-                raise RuntimeError(
-                    f"Failed to fetch cloud mobile: HTTP {response.status} - {error_text}"
-                )
-
-            data = await response.json()
-            info = VirtualMobileInfo.from_api_response(data)
-
-            if info.state == "Ready":
-                logger.info(f"Cloud mobile '{target_name}' is ready")
-                return info
-
-            if info.state == "Error":
-                raise RuntimeError(
-                    f"Cloud mobile '{target_name}' is in error state. "
-                    "Please check the Minitap Platform for details."
-                )
-
-            if info.state == "Stopped":
-                raise DeviceNotReadyError(
-                    f"Cloud mobile '{target_name}' is stopped. ",
-                    state=info.state,
-                )
-
-            if info.state == "Starting":
-                raise DeviceNotReadyError(
-                    f"Cloud mobile '{target_name}' is still starting. "
-                    "Please wait a minute and try again.",
-                    state=info.state,
-                )
-
-            if info.state == "Stopping":
-                raise DeviceNotReadyError(
-                    f"Cloud mobile '{target_name}' is stopping. ",
-                    state=info.state,
-                )
-
-            # Unknown state
-            raise DeviceNotReadyError(
-                f"Cloud mobile '{target_name}' is in state '{info.state}'. "
-                "Please check the Minitap Platform for details.",
-                state=info.state,
-            )