uiautomator2-mcp-server 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

u2mcp/.gitignore

@@ -1 +1 @@
-_version.py
+_version.py

u2mcp/__init__.py

@@ -1,2 +1,2 @@
-from . import _version as version
-from ._version import __commit_id__, __version__, __version_tuple__
+from . import _version as version
+from ._version import __commit_id__, __version__, __version_tuple__

u2mcp/__main__.py

@@ -1,60 +1,82 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Annotated, Any, Awaitable
-
-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)
-
-
-def run(
-    http: Annotated[bool, typer.Option("--http", "-h", help="Run mcp server in streamable http mode")] = False,
-    stdio: Annotated[bool, typer.Option("--stdio", "-s", help="Run mcp server in stdio mode")] = False,
-    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,
-    log_level: Annotated[str | None, typer.Option("--log-level", "-l", help="Log level")] = None,
-):
-    """Run uiautomator2 mcp server"""
-    if not http and not stdio:
-        typer.Abort("Please specify one of ‘--http’ or ‘--stdio’")
-
-    from . import tools as _
-    from .mcp import mcp
-
-    awaitables: list[Awaitable] = []
-
-    if http:
-        transport_kwargs: dict[str, Any] = {}
-        if host:
-            transport_kwargs["host"] = host
-        if port:
-            transport_kwargs["port"] = port
-        awaitables.append(mcp.run_http_async(transport="streamable-http", **transport_kwargs, log_level=log_level))
-
-    if stdio:
-        awaitables.append(mcp.run_stdio_async(log_level=log_level))
-
-    async def _run():
-        await asyncio.gather(*awaitables)
-
-    asyncio.run(_run())
-
-
-def main():
-    typer.run(run)
-
-
-if __name__ == "__main__":
-    main()
+from __future__ import annotations
+
+import logging
+import re
+import secrets
+from typing import Annotated, Any, Literal
+
+import typer
+
+from .mcp import make_mcp
+
+
+def run(
+    transport: Annotated[
+        Literal["http", "stdio"], typer.Argument(help="Run mcp server on streamable-http http or stdio transport")
+    ] = "stdio",
+    host: Annotated[
+        str, typer.Option("--host", "-H", show_default=False, help="Host address of streamable-http transport")
+    ] = "127.0.0.1",
+    port: Annotated[
+        int, typer.Option("--port", "-p", show_default=False, help="Port number of streamable-http transport")
+    ] = 8000,
+    json_response: Annotated[bool, typer.Option("--json-response", "-j", help="Whether to use JSON response format")] = True,
+    log_level: Annotated[
+        Literal["debug", "info", "warning", "error", "critical"], typer.Option("--log-level", "-l", help="Log level")
+    ] = "info",
+    no_token: Annotated[
+        bool,
+        typer.Option(
+            "--no-token",
+            help="Disable authentication bearer token verification of streamable-http transport. If not set, a token will be generated randomly.",
+        ),
+    ] = False,
+    token: Annotated[
+        str | None,
+        typer.Option("--token", "-t", help="Explicit set token of streamable-http authentication"),
+    ] = None,
+):
+    """Run uiautomator2 mcp server"""
+    logging.basicConfig(
+        level=log_level.upper(),
+        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)
+
+    run_kwargs: dict[str, Any] = {"json_response": json_response, "log_level": log_level}
+
+    if transport == "http":
+        run_kwargs["transport"] = "streamable-http"
+        if host:
+            run_kwargs["host"] = host
+        if port:
+            run_kwargs["port"] = port
+        if token:
+            token = token.strip()
+            if not re.match(r"^[a-zA-Z0-9\-_.~!$&'()*+,;=:@]{8,64}$", token):
+                raise typer.BadParameter("Token must be 8-64 characters long and can only contain URL-safe characters")
+        elif not no_token:
+            token = secrets.token_urlsafe()
+        mcp = make_mcp(token)
+    else:
+        run_kwargs["transport"] = "stdio"
+        mcp = make_mcp()
+
+    # can NOT import tools until mcp is crated
+    from . import tools as _
+
+    # run mcp
+    mcp.run(**run_kwargs)
+
+
+def main():
+    typer.run(run)
+
+
+if __name__ == "__main__":
+    main()

u2mcp/_version.py

@@ -1,34 +1,34 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
-
-__commit_id__ = commit_id = None
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)
+
+__commit_id__ = commit_id = None

u2mcp/mcp.py

@@ -1,18 +1,79 @@
-"""
-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__)
+"""
+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.
+"""
+
+import sys
+from contextlib import asynccontextmanager
+from functools import partial
+from textwrap import dedent
+from typing import Any
+
+if sys.version_info >= (3, 12):  # qa: noqa
+    from typing import override
+else:  # qa: noqa
+    from typing_extensions import override
+
+from fastmcp import FastMCP
+from fastmcp.server.auth import AccessToken, AuthProvider
+from pydantic import AnyHttpUrl
+from rich.console import Console
+from rich.markdown import Markdown
+
+__all__ = ["mcp", "make_mcp"]
+
+
+# Warning: You can NOT import it unless call `make_mcp()`
+mcp: FastMCP
+
+
+@asynccontextmanager
+async def _lifespan(instance: FastMCP, token: str | None):
+    content = Markdown(
+        dedent(f"""
+        ------
+
+        Server configured with **authentication token**. Connect using this token in the Authorization header:
+
+        `Authorization: Bearer {token}`
+
+        ------
+        """)
+    )
+    Console(stderr=True).print(content)
+    yield
+
+
+class _SimpleTokenAuthProvider(AuthProvider):
+    @override
+    def __init__(
+        self,
+        base_url: AnyHttpUrl | str | None = None,
+        required_scopes: list[str] | None = ["mcp:tools"],
+        token: str | None = None,
+    ):
+        super().__init__(base_url, required_scopes)
+        self.token = token
+
+    @override
+    async def verify_token(self, token: str) -> AccessToken | None:
+        if self.token == token:
+            return AccessToken(token=token, client_id="user", scopes=self.required_scopes)
+        return None
+
+
+def make_mcp(token: str | None = None) -> FastMCP:
+    global mcp
+    params: dict[str, Any] = dict(name="uiautomator2", instructions=__doc__)
+    if token:
+        params.update(lifespan=partial(_lifespan, token=token), auth=_SimpleTokenAuthProvider(token=token))
+    mcp = FastMCP(**params)
+    return mcp

u2mcp/tools/__init__.py

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

u2mcp/tools/action.py

@@ -1,169 +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)
+from __future__ import annotations
+
+from anyio import to_thread
+
+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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(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 to_thread.run_sync(device.screen_off)