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

minitap/mcp/tools/execute_mobile_command.py

@@ -8,9 +8,12 @@ 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
+from minitap.mcp.server.cloud_mobile import check_cloud_mobile_status
 
 
 def _serialize_result(result: Any) -> Any:
@@ -26,14 +29,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 +68,44 @@ 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 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)
+
+            # 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/tools/read_swift_logs.py

@@ -0,0 +1,297 @@
+"""Tool for reading Swift/iOS logs for debugging during development."""
+
+import asyncio
+import json
+import sys
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+from minitap.mcp.core.decorators import handle_tool_errors
+from minitap.mcp.core.logging_config import get_logger
+from minitap.mcp.main import mcp
+
+logger = get_logger(__name__)
+
+
+class BacktraceFrame(BaseModel):
+    imageOffset: int | None = None
+    imageUUID: str | None = None
+    imagePath: str | None = None
+    symbol: str | None = None
+
+
+class Backtrace(BaseModel):
+    frames: list[BacktraceFrame] = []
+
+
+class SimplifiedLog(BaseModel):
+    timestamp: str
+    level: str
+    category: str
+    message: str
+    process_id: int
+    backtrace: Backtrace | None = None
+    sender_image_path: str | None = None
+    process_image_path: str | None = None
+    sender_image_uuid: str | None = None
+
+
+class LogsOutput(BaseModel):
+    bundle_id: str
+    last_minutes: int
+    log_count: int
+    logs: list[SimplifiedLog]
+    message: str | None = None
+
+
+def _convert_to_iso8601(timestamp: str) -> str:
+    """Convert macOS log show timestamp to ISO8601 format.
+
+    Input format:  "YYYY-MM-DD HH:MM:SS.NNNNNN±TTTT"
+    Output format: "YYYY-MM-DDTHH:MM:SS.NNNNNN±TT:TT"
+    """
+    if not timestamp:
+        return timestamp
+
+    try:
+        dt = datetime.fromisoformat(timestamp.replace(" ", "T"))
+        return dt.isoformat()
+    except ValueError:
+        return timestamp
+
+
+def _parse_backtrace(raw: dict | None) -> Backtrace | None:
+    """Parse raw backtrace dict into Backtrace model."""
+    if not raw or not isinstance(raw, dict):
+        return None
+    frames_raw = raw.get("frames", [])
+    if not frames_raw:
+        return None
+    frames = [
+        BacktraceFrame(
+            imageOffset=f.get("imageOffset"),
+            imageUUID=f.get("imageUUID"),
+            imagePath=f.get("imagePath"),
+            symbol=f.get("symbol"),
+        )
+        for f in frames_raw
+        if isinstance(f, dict)
+    ]
+    return Backtrace(frames=frames) if frames else None
+
+
+async def _run_log_show(
+    predicate: str | None,
+    last_minutes: int,
+    include_debug: bool,
+    *,
+    simulator: bool = False,
+) -> tuple[list, str | None]:
+    """Run log show command and return parsed logs and optional error message."""
+    if simulator:
+        cmd = ["xcrun", "simctl", "spawn", "booted", "log", "show"]
+    else:
+        cmd = ["log", "show"]
+
+    cmd.extend(["--style", "json", "--last", f"{last_minutes}m"])
+
+    if predicate:
+        cmd.extend(["--predicate", predicate])
+
+    if include_debug:
+        cmd.extend(["--debug", "--info"])
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    stdout, stderr = await process.communicate()
+    error_output = stderr.decode("utf-8", errors="replace")
+
+    if process.returncode != 0:
+        if simulator and "No devices are booted" in error_output:
+            return [], "Error: No iOS Simulator is running. Please boot a simulator first."
+        return [], None
+
+    output = stdout.decode("utf-8", errors="replace").strip()
+    lines = output.split("\n")
+    if lines and lines[0].startswith("Filtering the log data"):
+        lines = lines[1:]
+    if lines and lines[0].startswith("Skipping info and debug"):
+        lines = lines[1:]
+
+    json_output = "\n".join(lines).strip()
+
+    if not json_output or json_output == "[]":
+        return [], None
+
+    try:
+        return json.loads(json_output), None
+    except json.JSONDecodeError:
+        return [], None
+
+
+@mcp.tool(
+    name="read_swift_logs",
+    description="""
+    Read Swift/iOS logs for debugging during app development. Please note that this tool expect the
+    bundle identifier of the app to be passed as an argument.
+    
+    This tool can read logs from:
+    1. iOS Simulator runtime logs (source="simulator") - filters by process name
+    2. All unified logging sources (source="all") - queries by subsystem and process name
+    
+    Use cases:
+    - Debug runtime issues by reading simulator logs
+    - Find crash logs and error messages
+    - Read print() statements and os.Logger output from your Swift app
+    
+    Examples:
+    - read_swift_logs(source="simulator", bundle_id="com.example.myapp")
+    - read_swift_logs(source="simulator", bundle_id="com.example.myapp", last_minutes=10)
+    - read_swift_logs(source="all", bundle_id="com.example.myapp", last_minutes=5)
+    """,
+)
+@handle_tool_errors
+async def read_swift_logs(
+    bundle_id: str = Field(
+        description="The bundle identifier of the iOS app (e.g., 'com.example.myapp'). "
+        "This is used to filter logs by subsystem.",
+    ),
+    source: str = Field(
+        default="all",
+        description="Log source: 'simulator' for iOS Simulator runtime logs, "
+        "'all' to read from all sources that generate runtime logs related with the bundle.",
+    ),
+    last_minutes: int = Field(
+        default=5,
+        description="Number of minutes of logs to retrieve. Default is 5 minutes.",
+    ),
+) -> LogsOutput | str:
+    """Read Swift/iOS logs from simulator or file."""
+    if sys.platform != "darwin":
+        return "Error: This tool only works on macOS with Xcode installed."
+
+    process_name = bundle_id.split(".")[-1]
+
+    if source == "simulator":
+        return await _read_simulator_logs(bundle_id, last_minutes, process_name)
+    elif source == "all":
+        return await _read_file_logs(bundle_id, process_name, last_minutes)
+    else:
+        return f"Error: Unknown source '{source}'. Use 'simulator' or 'all'."
+
+
+def _map_to_simplified_logs(log_entries: list[dict]) -> list[SimplifiedLog]:
+    return [
+        SimplifiedLog(
+            timestamp=_convert_to_iso8601(entry.get("timestamp", "")),
+            level=entry.get("messageType", ""),
+            category=entry.get("category", ""),
+            message=entry.get("eventMessage", ""),
+            process_id=entry.get("processID", 0),
+            backtrace=_parse_backtrace(entry.get("backtrace")),
+            sender_image_path=entry.get("senderImagePath"),
+            process_image_path=entry.get("processImagePath"),
+            sender_image_uuid=entry.get("senderImageUUID"),
+        )
+        for entry in log_entries
+        if entry.get("eventMessage")
+    ]
+
+
+async def _read_simulator_logs(
+    bundle_id: str,
+    last_minutes: int,
+    process_name: str | None,
+) -> LogsOutput | str:
+    """Read historical logs from the booted iOS Simulator."""
+    predicate = f'processImagePath CONTAINS "{process_name}"' if process_name else None
+
+    logger.info(f"Reading simulator logs for last {last_minutes}m")
+
+    log_entries, error = await _run_log_show(
+        predicate, last_minutes, include_debug=True, simulator=True
+    )
+
+    if error:
+        return error
+
+    if not log_entries:
+        return LogsOutput(
+            bundle_id=bundle_id,
+            last_minutes=last_minutes,
+            log_count=0,
+            logs=[],
+            message=f"No logs found for '{process_name}' in the last {last_minutes} min.",
+        )
+
+    simplified_logs = _map_to_simplified_logs(log_entries)
+
+    return LogsOutput(
+        bundle_id=bundle_id,
+        last_minutes=last_minutes,
+        log_count=len(simplified_logs),
+        logs=simplified_logs,
+    )
+
+
+async def _read_file_logs(bundle_id: str, process_name: str, last_minutes: int) -> LogsOutput:
+    # Query 1: Logs by subsystem (os.Logger logs)
+    subsystem_predicate = f'subsystem == "{bundle_id}"'
+
+    # Query 2: Logs by process name (catches crashes and system logs)
+    # Include fatal errors, crashes, and error-level logs
+    process_predicate = (
+        f'process == "{process_name}" AND '
+        f'(messageType == "Fault" OR messageType == "Error" OR '
+        f'eventMessage CONTAINS "fatal" OR eventMessage CONTAINS "crash")'
+    )
+
+    logger.info(
+        "fetching_ios_logs",
+        bundle_id=bundle_id,
+        last_minutes=last_minutes,
+    )
+
+    # Run both queries in parallel
+    (subsystem_logs, _), (process_logs, _) = await asyncio.gather(
+        _run_log_show(subsystem_predicate, last_minutes, include_debug=True),
+        _run_log_show(process_predicate, last_minutes, include_debug=False),
+    )
+
+    # Merge and deduplicate logs by timestamp + message
+    all_logs = subsystem_logs + process_logs
+    seen = set()
+    unique_logs = []
+    for log_entry in all_logs:
+        key = (log_entry.get("timestamp"), log_entry.get("eventMessage"))
+        if key not in seen:
+            seen.add(key)
+            unique_logs.append(log_entry)
+
+    # Sort by timestamp
+    unique_logs.sort(key=lambda x: x.get("timestamp", ""))
+
+    if not unique_logs:
+        return LogsOutput(
+            bundle_id=bundle_id,
+            last_minutes=last_minutes,
+            log_count=0,
+            logs=[],
+            message=f"No logs found for '{bundle_id}' in the last {last_minutes} min.",
+        )
+
+    simplified_logs = _map_to_simplified_logs(unique_logs)
+
+    logger.info("logs_retrieved", bundle_id=bundle_id, log_count=len(simplified_logs))
+
+    return LogsOutput(
+        bundle_id=bundle_id,
+        last_minutes=last_minutes,
+        log_count=len(simplified_logs),
+        logs=simplified_logs,
+    )

minitap/mcp/tools/take_screenshot.py

@@ -0,0 +1,53 @@
+"""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(
+    name="take_screenshot",
+    description="""
+    Capture a screenshot from the connected mobile device.
+    Returns the raw base64-encoded PNG image directly without any LLM analysis.
+    Use this when you need the screenshot image for display or further processing.
+    """,
+)
+@handle_tool_errors
+async def take_screenshot(
+    device_id: str | None = Field(
+        default=None,
+        description="ID of the device to capture screenshot from. "
+        "If not provided, the first available device is used.",
+    ),
+) -> 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)
+
+    return [
+        ImageContent(
+            type="image",
+            data=screenshot_base64,
+            mimeType="image/png",
+        )
+    ]

minitap/mcp/tools/upload_screenshot.py

@@ -0,0 +1,80 @@
+"""Tool for uploading device screenshots to remote storage.
+
+This tool captures a screenshot from the connected device and uploads it
+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
+
+from minitap.mcp.core.decorators import handle_tool_errors
+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__)
+
+
+@mcp.tool(
+    name="upload_screenshot",
+    description="""
+    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)
+    2. Uploads the screenshot to remote storage
+    3. Returns a filename that can be used with other tools
+    
+    Use this to get a screenshot filename for tools like figma_compare_screenshot
+    that require a current_screenshot_filename parameter.
+    
+    Example workflow:
+    1. Call upload_screenshot to get a filename
+    2. Use the returned filename with figma_compare_screenshot
+    """,
+)
+@handle_tool_errors
+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
+
+    logger.info("Screenshot captured from device")
+
+    # Step 2: Upload screenshot to storage
+    try:
+        filename = await upload_screenshot_to_storage(screenshot_base64)
+        logger.info("Screenshot uploaded to storage", filename=filename)
+    except StorageUploadError as e:
+        raise ToolError(f"Failed to upload screenshot: {e}") from e
+
+    return ToolResult(
+        content=[
+            {
+                "type": "text",
+                "text": f"Screenshot uploaded successfully.\n\n**Filename:** {filename}",
+            }
+        ]
+    )

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

@@ -1,17 +1,19 @@
 Metadata-Version: 2.3
 Name: minitap-mcp
-Version: 0.5.3
+Version: 0.7.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.4.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: httpx>=0.28.1
 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 +42,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 +254,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
@@ -259,7 +313,7 @@ export ADB_SERVER_SOCKET="tcp:192.168.1.100:5037"
 Customize the vision model used for screen analysis:
 
 ```bash
-export VISION_MODEL="qwen/qwen-2.5-vl-7b-instruct"
+export VISION_MODEL="google/gemini-3-flash-preview"
 ```
 
 ## Device Setup

minitap_mcp-0.7.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+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/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
+minitap/mcp/core/agents/compare_screenshots/eval/scenario_1_add_cartoon_img_and_move_button/human_feedback.txt,sha256=0gVEqIFpmCX1cx1tlGBdfqDGbTeedyVfwTJZqePURkA,700
+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=Xeg1jrycm50UC72J4qVZ2NS9qs20oXKhvBcmBRs4rEA,3896
+minitap/mcp/core/config.py,sha256=aN2x4Qj5lSmwCCxH03Si6-pZ7oIVKOTBKF4itfg1ifM,1408
+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=OJlArPJxflbhckerFsRHVTzy3jwsLsNSPN0LVpkmpNM,1861
+minitap/mcp/core/models.py,sha256=egLScxPAMo4u5cqY33UKba7z7DsdgqfPW409UAqW1Jg,1942
+minitap/mcp/core/sdk_agent.py,sha256=5YEr7aDjoiwbRQkZBK3jDa08c5QhPwLxahzlYrEB_KE,1132
+minitap/mcp/core/storage.py,sha256=y92pnE0pfLtH4nDKHZeUAZm_udR5sbRQGWbw13mjd_U,8189
+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/server/poller.py,sha256=JsdW6nvj4r3tsn8AaTwXD4H9dVAAau4BhJXHXHit9nA,2528
+minitap/mcp/server/remote_proxy.py,sha256=IM7UfjbJlQRpFD_tdpdck1mFT1QOnlxj5OA1nS4tRhQ,3073
+minitap/mcp/tools/execute_mobile_command.py,sha256=YXHLKvNFmuvwh7d_kPYw0R64bHzKCjyqp38adx8jWWI,4453
+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.7.0.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+minitap_mcp-0.7.0.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
+minitap_mcp-0.7.0.dist-info/METADATA,sha256=1WRLCep-7AjDFfhBEUNwZToFWzb26Tml1XafKjWBvuE,10619
+minitap_mcp-0.7.0.dist-info/RECORD,,

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

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