uiautomator2-mcp-server 0.1.0__py3-none-any.whl

u2mcp/__main__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import logging
+from enum import StrEnum
+from typing import Annotated
+
+import typer
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s] %(levelname)s %(name)s - %(message)s",
+    handlers=[logging.StreamHandler()],
+    force=True,
+)
+
+logging.getLogger("mcp.server").setLevel(logging.WARNING)
+logging.getLogger("sse_starlette").setLevel(logging.WARNING)
+logging.getLogger("docket").setLevel(logging.WARNING)
+logging.getLogger("fakeredis").setLevel(logging.WARNING)
+
+
+class Transport(StrEnum):
+    streamable_http = "streamable-http"
+    stdio = "stdio"
+    # http = "http"
+    # sse = "sse"
+
+
+def run(
+    transport: Annotated[
+        Transport, typer.Option("--transport", "-f", help="The transport mechanisms for client-server communication")
+    ] = Transport.streamable_http,
+    host: Annotated[str | None, typer.Option("--host", "-H", show_default=False, help="Host address for http mode")] = None,
+    port: Annotated[int | None, typer.Option("--port", "-p", show_default=False, help="Port number for http mode")] = None,
+):
+    """Run mcp server
+    Args:
+        transport (Literal["http", "stdio"]): transport type
+        host (str | None): host
+        port (int | None): port
+    """
+    from . import tools as _
+    from .mcp import mcp
+
+    if transport == Transport.stdio:
+        mcp.run(transport.value)
+    elif transport == Transport.streamable_http:
+        transport_kwargs = {}
+        if host:
+            transport_kwargs["host"] = host
+        if port:
+            transport_kwargs["port"] = port
+        mcp.run(transport.value, **transport_kwargs)
+    else:
+        typer.Abort(f"Unknown transport: {transport}")
+
+
+def main():
+    typer.run(run)
+
+
+if __name__ == "__main__":
+    main()

u2mcp/mcp.py

@@ -0,0 +1,18 @@
+"""
+This MCP server provides tools for controlling and interacting with Android devices using uiautomator2.
+
+It allows you to perform various operations on Android devices such as connecting to devices, taking screenshots,
+getting device information, accessing UI hierarchy, tap on screens, and more...
+
+It also provides tools for managing Android applications, such as installing, uninstalling, starting, stopping, and clearing applications.
+
+Before performing operations on a device, you need to initialize it using the init tool.
+
+All operations require a device serial number to identify the target device.
+"""
+
+from fastmcp import FastMCP
+
+__all__ = ["mcp"]
+
+mcp = FastMCP(name="uiautomator2", instructions=__doc__)

u2mcp/tools/__init__.py

@@ -0,0 +1,3 @@
+from .action import *
+from .app import *
+from .device import *

u2mcp/tools/action.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import asyncio
+
+from ..mcp import mcp
+from .device import get_device
+
+__all__ = (
+    "click",
+    "long_click",
+    "double_click",
+    "swipe",
+    "swipe_points",
+    "drag",
+    "press_key",
+    "send_text",
+    "clear_text",
+    "screen_on",
+    "screen_off",
+)
+
+
+@mcp.tool("click")
+async def click(serial: str, x: int, y: int):
+    """Click at specific coordinates
+
+    Args:
+        serial (str): Android device serialno
+        x (int): X coordinate
+        y (int): Y coordinate
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.click, x, y)
+
+
+@mcp.tool("long_click")
+async def long_click(serial: str, x: int, y: int, duration: float = 0.5):
+    """Long click at specific coordinates
+
+    Args:
+        serial (str): Android device serialno
+        x (int): X coordinate
+        y (int): Y coordinate
+        duration (float): Duration of the long click in seconds, default is 0.5
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.long_click, x, y, duration)
+
+
+@mcp.tool("double_click")
+async def double_click(serial: str, x: int, y: int, duration: float = 0.1):
+    """Double click at specific coordinates
+
+    Args:
+        serial (str): Android device serialno
+        x (int): X coordinate
+        y (int): Y coordinate
+        duration (float): Duration between clicks in seconds, default is 0.1
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.double_click, x, y, duration)
+
+
+@mcp.tool("swipe")
+async def swipe(serial: str, fx: int, fy: int, tx: int, ty: int, duration: float = 0.0, step: int = 0):
+    """Swipe from one point to another
+
+    Args:
+        serial (str): Android device serialno
+        fx (int): From position X coordinate
+        fy (int): From position Y coordinate
+        tx (int): To position X coordinate
+        ty (int): To position Y coordinate
+        duration (float): duration
+        steps: 1 steps is about 5ms, if set, duration will be ignore
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.swipe, fx, fy, tx, ty, duration if duration > 0 else None, step if step > 0 else None)
+
+
+@mcp.tool("swipe_points")
+async def swipe_points(serial: str, points: list[tuple[int, int]], duration: float = 0.5):
+    """Swipe through multiple points
+
+    Args:
+        serial (str): Android device serialno
+        points (list[tuple[int, int]]): List of (x, y) coordinates to swipe through
+        duration (float): Duration of swipe in seconds, default is 0.5
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.swipe_points, points, duration)
+
+
+@mcp.tool("drag")
+async def drag(serial: str, sx: int, sy: int, ex: int, ey: int, duration: float = 0.5):
+    """Swipe from one point to another point.
+
+    Args:
+        serial (str): Android device serialno
+        sx (int): Start X coordinate
+        sy (int): Start Y coordinate
+        ex (int): End X coordinate
+        ey (int): End Y coordinate
+        duration (float): Duration of drag in seconds, default is 0.5
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.drag, sx, sy, ex, ey, duration)
+
+
+@mcp.tool("press_key")
+async def press_key(serial: str, key: str):
+    """Press a key
+
+    Args:
+        serial (str): Android device serialno
+        key (str): Key to press.
+            Supported key name includes:
+            home, back, left, right, up, down, center, menu, search, enter,
+            delete(or del), recent(recent apps), volume_up, volume_down,
+            volume_mute, camera, power
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.press, key)
+
+
+@mcp.tool("send_text")
+async def send_text(serial: str, text: str, clear: bool = False):
+    """Send text to the current input field
+
+    Args:
+        serial (str): Android device serialno
+        text (str): input text
+            clear: clear text before input
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.send_keys, text, clear)
+
+
+@mcp.tool("clear_text")
+async def clear_text(serial: str):
+    """Clear text in the current input field
+
+    Args:
+        serial (str): Android device serialno
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.clear_text)
+
+
+@mcp.tool("screen_on")
+async def screen_on(serial: str):
+    """Turn screen on
+
+    Args:
+        serial (str): Android device serialno
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.screen_on)
+
+
+@mcp.tool("screen_off")
+async def screen_off(serial: str):
+    """Turn screen off
+
+    Args:
+        serial (str): Android device serialno
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.screen_off)

u2mcp/tools/app.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from ..mcp import mcp
+from .device import get_device
+
+__all__ = (
+    "app_install",
+    "app_uninstall",
+    "app_uninstall_all",
+    "app_start",
+    "app_stop",
+    "app_stop_all",
+    "app_clear",
+    "app_info",
+    "app_current",
+    "app_list",
+    "app_list_running",
+    "app_auto_grant_permissions",
+)
+
+
+@mcp.tool("app_install")
+async def app_install(serial: str, data: str):
+    """Install app
+
+    Args:
+        serial (str): Android device serialno
+        data (str): APK file path or url
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.app_install, data)
+
+
+@mcp.tool("app_uninstall")
+async def app_uninstall(serial: str, package_name: str) -> bool:
+    """Uninstall an app
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+
+    Returns:
+        bool: success
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_uninstall, package_name)
+
+
+@mcp.tool("app_uninstall_all")
+async def app_uninstall_all(serial: str, excludes: list[str] | None = None) -> list[str]:
+    """Uninstall all apps
+
+    Args:
+        serial (str): Android device serialno
+        excludes (list[str] | None): packages that do not want to uninstall
+
+    Returns:
+        list[str]: list of uninstalled apps
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_uninstall_all, excludes or [])
+
+
+@mcp.tool("app_start")
+async def app_start(
+    serial: str,
+    package_name: str,
+    activity: str | None = None,
+    wait: bool = False,
+    stop: bool = False,
+):
+    """Launch application
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+        activity (str): app activity
+        stop (bool): Stop app before starting the activity. (require activity)
+        wait (bool): wait until app started. default False
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.app_start, package_name, activity, wait, stop)
+
+
+@mcp.tool("app_wait")
+async def app_wait(serial: str, package_name: str, timeout: float = 20.0, front=False):
+    """Wait until app launched
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+        timeout (float): maximum wait time seconds
+        front (bool): wait until app is current app
+    """
+    async with get_device(serial) as device:
+        if not await asyncio.to_thread(device.app_wait, package_name, timeout, front):
+            raise RuntimeError(f"Failed to wait App {package_name} to launch")
+
+
+@mcp.tool("app_stop")
+async def app_stop(serial: str, package_name: str):
+    """Stop one application
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.app_stop, package_name)
+
+
+@mcp.tool("app_stop_all")
+async def app_stop_all(serial: str, excludes: list[str] | None = None) -> list[str]:
+    """Stop all third party applications
+
+    Args:
+        excludes (list): apps that do now want to kill
+
+    Returns:
+        list[str]: a list of killed apps
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_stop_all, excludes or [])
+
+
+@mcp.tool("app_clear")
+async def app_clear(serial: str, package_name: str):
+    """Stop and clear app data: pm clear
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+
+    Returns:
+        bool: success
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.app_clear, package_name)
+
+
+@mcp.tool("app_info")
+async def app_info(serial: str, package_name: str) -> dict[str, Any]:
+    """
+    Get app info
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+
+    Returns:
+        dict[str,Any]: app info
+
+        Example:
+            {"versionName": "1.1.7", "versionCode": 1001007}
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_info, package_name)
+
+
+@mcp.tool("app_current")
+async def app_current(serial: str) -> dict[str, Any]:
+    """
+    Get current app info
+
+    Args:
+        serial (str): Android device serialno
+
+    Returns:
+        dict[str,Any]: running app info
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_current)
+
+
+@mcp.tool("app_list")
+async def app_list(serial: str, filter: str = "") -> list[str]:
+    """
+    List installed app package names
+
+    Args:
+        serial (str): Android device serialno
+        filter (str): [-f] [-d] [-e] [-s] [-3] [-i] [-u] [--user USER_ID] [FILTER]
+
+    Returns:
+        list[str]: list of apps by filter
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_list, filter.strip())
+
+
+@mcp.tool("app_list_running")
+async def app_list_running(serial: str) -> list[str]:
+    """
+    List running apps
+
+    Args:
+        serial (str): Android device serialno
+
+    Returns:
+        list[str]: list of running apps
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(device.app_list_running)
+
+
+@mcp.tool("app_auto_grant_permissions")
+async def app_auto_grant_permissions(serial: str, package_name: str):
+    """auto grant permissions
+
+    Args:
+        serial (str): Android device serialno
+        package_name (str): package name
+
+    Help of "adb shell pm":
+        grant [--user USER_ID] PACKAGE PERMISSION
+        revoke [--user USER_ID] PACKAGE PERMISSION
+            These commands either grant or revoke permissions to apps.  The permissions
+            must be declared as used in the app's manifest, be runtime permissions
+            (protection level dangerous), and the app targeting SDK greater than Lollipop MR1 (API level 22).
+
+    Help of "Android official pm" see <https://developer.android.com/tools/adb#pm>
+        Grant a permission to an app. On devices running Android 6.0 (API level 23) and higher,
+            the permission can be any permission declared in the app manifest.
+        On devices running Android 5.1 (API level 22) and lower,
+            must be an optional permission defined by the app.
+    """
+    async with get_device(serial) as device:
+        await asyncio.to_thread(device.app_auto_grant_permissions, package_name)

u2mcp/tools/device.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from base64 import b64encode
+from contextlib import asynccontextmanager
+from io import BytesIO
+from typing import Any, Literal
+
+import uiautomator2 as u2
+from adbutils import adb
+from fastmcp.dependencies import CurrentContext
+from fastmcp.server.context import Context
+from fastmcp.utilities.logging import get_logger
+from PIL.Image import Image
+
+from ..mcp import mcp
+
+__all__ = (
+    "device_list",
+    "init",
+    "connect",
+    "disconnect",
+    "disconnect_all",
+    "window_size",
+    "screenshot",
+    "dump_hierarchy",
+    "info",
+)
+
+
+StdoutType = Literal["stdout", "stderr"]
+
+_devices: dict[str, tuple[asyncio.Semaphore, u2.Device]] = {}
+_device_connect_lock = asyncio.Lock()
+
+
+@asynccontextmanager
+async def get_device(serial: str):
+    async with _device_connect_lock:
+        try:
+            semaphore, device = _devices[serial]
+        except KeyError:
+
+            def _connect():
+                _d = u2.connect(serial)
+                _d.info
+                return _d
+
+            device = await asyncio.to_thread(_connect)
+            semaphore = asyncio.Semaphore()
+            _devices[serial] = semaphore, device
+    async with semaphore:
+        yield device
+
+
+@mcp.tool("device_list")
+async def device_list() -> list[dict[str, Any]]:
+    device_list = await asyncio.to_thread(adb.device_list)
+    return [d.info for d in device_list]
+
+
+@mcp.tool("init")
+async def init(serial: str = "", ctx: Context = CurrentContext()):
+    """Install essential resources to device.
+
+    Important:
+        This tool must be run on the Android device before running operation actions.
+
+    Args:
+        serial (str): Android device serialno to initialize. If empty string, all devices will be initialized.
+
+    Returns:
+        None upon successful completion (exit code 0).
+        Raises an exception if the subprocess returns a non-zero exit code.
+    """
+    logger = get_logger(f"{__name__}.init")
+    args = ["-m", "uiautomator2", "init"]
+    if serial := serial.strip():
+        args.extend(["--serial", serial])
+
+    logger.info("Running uiautomator2 init command: %s %s", sys.executable, args)
+    process = await asyncio.create_subprocess_exec(
+        sys.executable, *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    if process.stdout is None:
+        raise RuntimeError("stdout is None")
+    if process.stderr is None:
+        raise RuntimeError("stderr is None")
+
+    output_queue: asyncio.Queue[tuple[StdoutType, str]] = asyncio.Queue()
+
+    async def stream_subprocess(stream: asyncio.streams.StreamReader, tag: StdoutType):
+        while True:
+            line_bytes = await stream.readline()
+            await output_queue.put((tag, line_bytes.decode()))
+            if not line_bytes:  # Reached EOF, the empty string is in the queue
+                break
+
+    # Start the stream reading tasks
+    tasks = [
+        asyncio.create_task(coro)
+        for coro in (
+            stream_subprocess(process.stdout, "stdout"),
+            stream_subprocess(process.stderr, "stderr"),
+        )
+    ]
+
+    completed_streams = 0
+
+    logger.info("read uiautomator2 init command stdio")
+
+    while True:
+        tag, line = await output_queue.get()
+
+        if not line:  # This was the EOF sentinel (empty string)
+            completed_streams += 1
+            if completed_streams == len(tasks):
+                output_queue.task_done()
+                break  # Both streams are done, exit the main consumer loop
+
+        # Process the actual line data
+        if line := line.strip():
+            logger.info("%s: %s", tag, line)
+            if tag == "stdout":
+                await ctx.info(line)
+            else:
+                await ctx.warning(line)
+
+        output_queue.task_done()
+
+    # Wait for the tasks to formally complete and the process to exit
+    logger.info("waiting for uiautomator2 init command to complete")
+    await asyncio.gather(*tasks)
+    exit_code = await process.wait()
+    logger.info("uiautomator2 init command exited with code: %s", exit_code)
+    if exit_code != 0:
+        raise RuntimeError(f"uiautomator2 init command exited with non-zero code: {exit_code}")
+
+
+@mcp.tool("connect")
+async def connect(serial: str = ""):
+    """Connect to an Android device
+
+    Args:
+        serial (str): Android device serial number. If empty string, connects to the unique device if only one device is connected.
+
+
+    Returns:
+        dict[str,Any]: Device information
+    """
+    global _devices
+    device: u2.Device | None = None
+
+    logger = get_logger(f"{__name__}.connect")
+
+    if serial := serial.strip():
+        try:
+            async with get_device(serial) as device:
+                # Found, then check if it's still connected
+                try:
+                    return await asyncio.to_thread(lambda: device.device_info | device.info)
+                except u2.ConnectError as e:
+                    # Found, but not connected, delete it
+                    logger.warning("Device %s is no longer connected, delete it!", serial)
+                    del _devices[serial]
+                    raise e from None
+        except KeyError:
+            # Not found, need a new connection!
+            logger.info("Cannot find device with serial %s, connecting...")
+
+    # make new connection here!
+    async with _device_connect_lock:
+        device = await asyncio.to_thread(u2.connect, serial)
+        logger.info("Connected to device %s", device.serial)
+        result = await asyncio.to_thread(lambda: device.device_info | device.info)
+        _devices[device.serial] = asyncio.Semaphore(), device
+        return result
+
+
+@mcp.tool("disconnect")
+async def disconnect(serial: str):
+    """Disconnect from an Android device
+
+    Args:
+        serial (str): Android device serialno
+
+    Returns:
+        None
+    """
+    if not (serial := serial.strip()):
+        raise ValueError("serial cannot be empty")
+    async with _device_connect_lock:
+        del _devices[serial]
+
+
+@mcp.tool("disconnect_all")
+async def disconnect_all():
+    """Disconnect from all Android devices"""
+    async with _device_connect_lock:
+        _devices.clear()
+
+
+@mcp.tool("window_size")
+async def window_size(serial: str) -> dict[str, int]:
+    """Get window size of an Android device
+
+    Args:
+        serial (str): Android device serialno
+
+    Returns:
+        dict[str,int]: Window size object:
+            - "width" (int): Window width
+            - "height" (int): Window height
+    """
+    async with get_device(serial) as device:
+        width, height = await asyncio.to_thread(device.window_size)
+        return {"width": width, "height": height}
+
+
+@mcp.tool("screenshot")
+async def screenshot(serial: str, display_id: int = -1) -> dict[str, Any]:
+    """
+    Take screenshot of device
+
+    Args:
+        serial (str): Android device serialno
+        display_id (int): use specific display if device has multiple screen. Defaults to -1.
+
+    Returns:
+        dict[str,Any]: Screenshot image JPEG data with the following keys:
+            - "image" (str): Base64 encoded image data in data URL format (data:image/jpeg;base64,...)
+            - "size" (tuple[int,int]): Image dimensions as (width, height)
+    """
+    display_id = int(display_id)
+    async with get_device(serial) as device:
+        im = await asyncio.to_thread(
+            device.screenshot,
+            display_id=display_id if display_id >= 0 else None,
+        )  # type: ignore[arg-type]
+
+    if not isinstance(im, Image):
+        raise RuntimeError("Invalid image")
+
+    with BytesIO() as fp:
+        im.save(fp, "jpeg")
+        im_data = fp.getvalue()
+
+    return {
+        "width": im.width,
+        "height": im.height,
+        "image": "data:image/jpeg;base64," + b64encode(im_data).decode(),
+    }
+
+
+@mcp.tool("dump_hierarchy")
+async def dump_hierarchy(serial: str, compressed: bool = False, pretty: bool = False, max_depth: int = -1) -> str:
+    """
+    Dump window hierarchy
+
+    Args:
+        serial (str): Android device serialno
+        compressed (bool): return compressed xml
+        pretty (bool): pretty print xml
+        max_depth (int): max depth of hierarchy
+
+    Returns:
+        str: xml string of the hierarchy tree
+    """
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(
+            device.dump_hierarchy, compressed=compressed, pretty=pretty, max_depth=max_depth if max_depth > 0 else None
+        )
+
+
+@mcp.tool("info")
+async def info(serial: str) -> dict[str, Any]:
+    """
+    Get device info
+
+    Args:
+        serial (str): Android device serialno
+
+    Returns:
+        dict[str,Any]: Device info
+    """
+
+    async with get_device(serial) as device:
+        return await asyncio.to_thread(lambda: device.info)
+

uiautomator2_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: uiautomator2-mcp-server
+Version: 0.1.0
+Summary: Add your description here
+Author: tanbro
+Author-email: tanbro <tanbro@163.com>
+Requires-Dist: fastmcp>=2.14.2,<3.0
+Requires-Dist: uiautomator2>=3.5.0,<4.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+

uiautomator2_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+u2mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+u2mcp/__main__.py,sha256=-Vd3rfbMDPvY-TNgyntRRG-_cMj7kxgsag_df3gAe_w,1769
+u2mcp/mcp.py,sha256=j8b_G2d8QX6VdjsUqwmeD1Eu9Sc79BlBWvKAmhTQOK8,721
+u2mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+u2mcp/tools/__init__.py,sha256=tKfsoF6tYQSapfGC1ybEcU4S77cipyfO5tYR6u0eAlI,66
+u2mcp/tools/action.py,sha256=A9dCED1NiKOJpw9lBewOQ9YQvfGOkK8bEL1L9FLjCQg,5088
+u2mcp/tools/app.py,sha256=k_9ROOdEbHOFWbh0sO6pL1x4YN0NjvhcnHcXfaN9Rvw,6578
+u2mcp/tools/device.py,sha256=NBNt210Sx9Ffbw0luUL69k_SAKUOCVsI313BQ5FbtTs,9077
+uiautomator2_mcp_server-0.1.0.dist-info/WHEEL,sha256=ZyFSCYkV2BrxH6-HRVRg3R9Fo7MALzer9KiPYqNxSbo,79
+uiautomator2_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=uIp3lo8qa_IGxe_Wx-3sReaooXzhvViP7b5YS-RPMPY,47
+uiautomator2_mcp_server-0.1.0.dist-info/METADATA,sha256=4WF7HSKeaKsU9LD-OQRKQl65WiUKg0yZIGpT8lnAJmY,296
+uiautomator2_mcp_server-0.1.0.dist-info/RECORD,,

uiautomator2_mcp_server-0.1.0.dist-info/WHEEL

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

uiautomator2_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+u2mcp = u2mcp.__main__:main
+