quash-mcp 0.2.0__tar.gz → 0.2.1__tar.gz

{quash_mcp-0.2.0 → quash_mcp-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.2.0
+Version: 0.2.1
 Summary: Model Context Protocol server for Quash - AI-powered mobile automation agent
 Project-URL: Homepage, https://quashbugs.com
 Project-URL: Repository, https://github.com/quash/quash-mcp
@@ -24,6 +24,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: mcp>=0.9.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
 Requires-Dist: rich>=13.0.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'

{quash_mcp-0.2.0 → quash_mcp-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quash-mcp"
-version = "0.2.0"
+version = "0.2.1"
 description = "Model Context Protocol server for Quash - AI-powered mobile automation agent"
 readme = "README.md"
 license = {text = "MIT"}
@@ -23,6 +23,7 @@ dependencies = [
     "rich>=13.0.0",
     "pydantic>=2.0.0",
     "python-dotenv>=1.0.0",
+    "requests>=2.31.0",
     "adbutils==2.10.0",
     "apkutils==2.0.0",
 ]

quash_mcp-0.2.1/quash_mcp/device/__init__.py

@@ -0,0 +1,34 @@
+"""
+Device management module for Quash MCP.
+
+This module contains utilities for managing Android devices, including:
+- Portal APK installation and setup
+- ADB device communication
+- Accessibility service management
+"""
+
+from .portal import (
+    download_portal_apk,
+    get_local_portal_apk,
+    use_portal_apk,
+    enable_portal_accessibility,
+    check_portal_accessibility,
+    ping_portal,
+    ping_portal_content,
+    ping_portal_tcp,
+    PORTAL_PACKAGE_NAME,
+    A11Y_SERVICE_NAME,
+)
+
+__all__ = [
+    "download_portal_apk",
+    "get_local_portal_apk",
+    "use_portal_apk",
+    "enable_portal_accessibility",
+    "check_portal_accessibility",
+    "ping_portal",
+    "ping_portal_content",
+    "ping_portal_tcp",
+    "PORTAL_PACKAGE_NAME",
+    "A11Y_SERVICE_NAME",
+]

quash_mcp-0.2.1/quash_mcp/device/adb_tools.py

@@ -0,0 +1,108 @@
+"""
+ADB Tools - Basic Android device communication wrapper.
+Simplified version for device management without agent-specific functionality.
+"""
+
+import logging
+from typing import Optional
+from adbutils import adb
+import requests
+
+logger = logging.getLogger("quash-device")
+PORTAL_DEFAULT_TCP_PORT = 8080
+
+
+class AdbTools:
+    """Basic ADB device communication wrapper."""
+
+    def __init__(
+        self,
+        serial: str | None = None,
+        use_tcp: bool = False,
+        remote_tcp_port: int = PORTAL_DEFAULT_TCP_PORT,
+    ) -> None:
+        """Initialize the AdbTools instance.
+
+        Args:
+            serial: Device serial number
+            use_tcp: Whether to use TCP communication (default: False)
+            remote_tcp_port: TCP port for communication (default: 8080)
+        """
+        self.device = adb.device(serial=serial)
+        self.use_tcp = use_tcp
+        self.remote_tcp_port = remote_tcp_port
+        self.tcp_forwarded = False
+
+        # Set up TCP forwarding if requested
+        if self.use_tcp:
+            self.setup_tcp_forward()
+
+    def setup_tcp_forward(self) -> bool:
+        """
+        Set up ADB TCP port forwarding for communication with the portal app.
+
+        Returns:
+            bool: True if forwarding was set up successfully, False otherwise
+        """
+        try:
+            logger.debug(
+                f"Setting up TCP port forwarding for port tcp:{self.remote_tcp_port} on device {self.device.serial}"
+            )
+            # Use adb forward command to set up port forwarding
+            self.local_tcp_port = self.device.forward_port(self.remote_tcp_port)
+            self.tcp_base_url = f"http://localhost:{self.local_tcp_port}"
+            logger.debug(
+                f"TCP port forwarding set up successfully to {self.tcp_base_url}"
+            )
+
+            # Test the connection with a ping
+            try:
+                response = requests.get(f"{self.tcp_base_url}/ping", timeout=5)
+                if response.status_code == 200:
+                    logger.debug("TCP connection test successful")
+                    self.tcp_forwarded = True
+                    return True
+                else:
+                    logger.warning(
+                        f"TCP connection test failed with status: {response.status_code}"
+                    )
+                    return False
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"TCP connection test failed: {e}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to set up TCP port forwarding: {e}")
+            self.tcp_forwarded = False
+            return False
+
+    def teardown_tcp_forward(self) -> bool:
+        """
+        Remove ADB TCP port forwarding.
+
+        Returns:
+            bool: True if forwarding was removed successfully, False otherwise
+        """
+        try:
+            if self.tcp_forwarded:
+                logger.debug(
+                    f"Removing TCP port forwarding for port {self.local_tcp_port}"
+                )
+                # remove forwarding
+                cmd = f"killforward:tcp:{self.local_tcp_port}"
+                logger.debug(f"Removing TCP port forwarding: {cmd}")
+                c = self.device.open_transport(cmd)
+                c.close()
+
+                self.tcp_forwarded = False
+                logger.debug(f"TCP port forwarding removed")
+                return True
+            return True
+        except Exception as e:
+            logger.error(f"Failed to remove TCP port forwarding: {e}")
+            return False
+
+    def __del__(self):
+        """Cleanup when the object is destroyed."""
+        if hasattr(self, "tcp_forwarded") and self.tcp_forwarded:
+            self.teardown_tcp_forward()

quash_mcp-0.2.1/quash_mcp/device/portal.py

@@ -0,0 +1,163 @@
+import os
+import contextlib
+import tempfile
+import requests
+from adbutils import adb, AdbDevice
+from rich.console import Console
+
+ASSET_NAME = "mahoraga-portal"
+APK_DOWNLOAD_URL = "https://storage.googleapis.com/misc_quash_static/mahoraga-portal-v0.1.apk"
+
+PORTAL_PACKAGE_NAME = "com.mahoraga.portal"
+A11Y_SERVICE_NAME = (
+    f"{PORTAL_PACKAGE_NAME}/com.mahoraga.portal.MahoragaAccessibilityService"
+)
+
+
+def download_portal_apk(debug: bool = False) -> str:
+    """Download the Mahoraga Portal APK from cloud storage."""
+    console = Console()
+
+    try:
+        console.print("📥 Downloading Quash Portal APK...")
+        if debug:
+            console.print(f"Download URL: {APK_DOWNLOAD_URL}")
+
+        response = requests.get(APK_DOWNLOAD_URL, stream=True)
+        response.raise_for_status()
+
+        # Create temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.apk')
+
+        # Download with progress
+        total_size = int(response.headers.get('content-length', 0))
+        downloaded = 0
+
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
+                temp_file.write(chunk)
+                downloaded += len(chunk)
+                if total_size > 0:
+                    progress = (downloaded / total_size) * 100
+                    console.print(f"\rProgress: {progress:.1f}%", end="")
+
+        temp_file.close()
+        console.print(f"\n✅ Downloaded APK to {temp_file.name}")
+        return temp_file.name
+
+    except requests.RequestException as e:
+        raise Exception(f"Failed to download Portal APK: {e}")
+    except Exception as e:
+        raise Exception(f"Error downloading Portal APK: {e}")
+
+
+def get_local_portal_apk(apk_path: str = None):
+    """Get the path to a local portal APK file."""
+    if apk_path and os.path.exists(apk_path):
+        return apk_path
+
+    # Look for APK in common locations
+    common_paths = [
+        f"{ASSET_NAME}.apk",
+        f"./assets/{ASSET_NAME}.apk",
+        f"./portal/{ASSET_NAME}.apk"
+    ]
+
+    for path in common_paths:
+        if os.path.exists(path):
+            return path
+
+    # If no local APK found, download it
+    return download_portal_apk()
+
+
+@contextlib.contextmanager
+def use_portal_apk(apk_path: str = None, debug: bool = False):
+    console = Console()
+    temp_file = None
+
+    try:
+        local_apk_path = get_local_portal_apk(apk_path)
+        console.print(f"📱 Using Portal APK: [bold]{os.path.basename(local_apk_path)}[/bold]")
+        if debug:
+            console.print(f"APK Path: {local_apk_path}")
+
+        # Track if this is a temp file we downloaded
+        if local_apk_path.startswith(tempfile.gettempdir()):
+            temp_file = local_apk_path
+
+        yield local_apk_path
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise
+    finally:
+        # Clean up downloaded temp file
+        if temp_file and os.path.exists(temp_file):
+            try:
+                os.unlink(temp_file)
+                if debug:
+                    console.print(f"🗑️ Cleaned up temp file: {temp_file}")
+            except Exception:
+                pass  # Ignore cleanup errors
+
+
+def enable_portal_accessibility(device: AdbDevice):
+    device.shell(
+        f"settings put secure enabled_accessibility_services {A11Y_SERVICE_NAME}"
+    )
+    device.shell("settings put secure accessibility_enabled 1")
+
+
+def check_portal_accessibility(device: AdbDevice, debug: bool = False) -> bool:
+    a11y_services = device.shell("settings get secure enabled_accessibility_services")
+    if not A11Y_SERVICE_NAME in a11y_services:
+        if debug:
+            print(a11y_services)
+        return False
+
+    a11y_enabled = device.shell("settings get secure accessibility_enabled")
+    if a11y_enabled != "1":
+        if debug:
+            print(a11y_enabled)
+        return False
+
+    return True
+
+
+def ping_portal(device: AdbDevice, debug: bool = False):
+    """
+    Ping the Quash Portal to check if it is installed and accessible.
+    """
+    try:
+        packages = device.list_packages()
+    except Exception as e:
+        raise Exception(f"Failed to list packages: {e}")
+
+    if not PORTAL_PACKAGE_NAME in packages:
+        if debug:
+            print(packages)
+        raise Exception("Portal is not installed on the device")
+
+    if not check_portal_accessibility(device, debug):
+        device.shell("am start -a android.settings.ACCESSIBILITY_SETTINGS")
+        raise Exception(
+            "Quash Portal is not enabled as an accessibility service on the device"
+        )
+
+
+def ping_portal_content(device: AdbDevice, debug: bool = False):
+    try:
+        state = device.shell("content query --uri content://com.mahoraga.portal/state")
+        if not "Row: 0 result=" in state:
+            raise Exception("Failed to get state from Quash Portal")
+    except Exception as e:
+        raise Exception(f"Quash Portal is not reachable: {e}")
+
+
+def ping_portal_tcp(device: AdbDevice, debug: bool = False):
+    """Check TCP forwarding to portal."""
+    from .adb_tools import AdbTools
+    try:
+        tools = AdbTools(serial=device.serial, use_tcp=True)
+    except Exception as e:
+        raise Exception(f"Failed to setup TCP forwarding: {e}")

{quash_mcp-0.2.0 → quash_mcp-0.2.1}/quash_mcp/tools/build.py

@@ -557,7 +557,7 @@ class DependencyChecker:
     def check_portal(self) -> Tuple[bool, str, str]:
         """Check if Portal APK download works"""
         try:
-            from mahoraga.portal import download_portal_apk
+            from quash_mcp.device.portal import download_portal_apk
             return True, "✓ Portal APK download available", None
         except ImportError as e:
             return False, f"✗ Portal module not found: {str(e)}", None
@@ -644,40 +644,53 @@ async def build() -> Dict[str, Any]:
         all_ok = False
     print()
 
-    # 4. Check Quash Package
-    print("4️⃣  Checking Quash package...")
+    # 4. Check Quash Package (Optional - only for developers with local source)
+    print("4️⃣  Checking Quash package (optional for development)...")
     mhg_ok, mhg_msg, _ = checker.check_mahoraga()
     details["mahoraga"] = mhg_msg
     print(f"   {mhg_msg}")
 
     mahoraga_just_installed = False
     if not mhg_ok:
-        # Try to install
-        print("   Attempting to install Quash...")
-        install_ok, install_msg = checker.install_mahoraga()
-        details["mahoraga_install"] = install_msg
-        print(f"   {install_msg}")
+        # Check if we're in development mode (source available)
+        project_root = Path(__file__).parent.parent.parent.parent
+        mahoraga_src = project_root / "mahoraga"
+
+        if mahoraga_src.exists() and (mahoraga_src / "pyproject.toml").exists():
+            # Only try to install if local source is available (development mode)
+            print("   Local Quash source detected. Attempting to install...")
+            install_ok, install_msg = checker.install_mahoraga()
+            details["mahoraga_install"] = install_msg
+            print(f"   {install_msg}")
 
-        if not install_ok:
-            all_ok = False
+            if install_ok:
+                fixes_applied.append("Installed Quash from local source")
+                mahoraga_just_installed = True
         else:
-            fixes_applied.append("Installed Quash")
-            mahoraga_just_installed = True  # Track that we just installed Quash
+            # Production mode - skip mahoraga (not needed, device tools in quash_mcp)
+            print("   ⏭️  Skipped (not required for end users)")
+            details["mahoraga"] = "⏭️  Skipped (device tools included in quash-mcp)"
     print()
 
-    # 5. Check Quash Version
-    print("5️⃣  Checking Quash version...")
-    ver_ok, ver_msg, ver_fix = checker.check_mahoraga_version()
-    details["mahoraga_version"] = ver_msg
-    print(f"   {ver_msg}")
-
-    if not ver_ok:
-        all_ok = False
-        if ver_fix:
-            fix_msg = f"Please upgrade: pip install --upgrade mahoraga"
-            details["mahoraga_version_fix"] = fix_msg
-            print(f"   💡 {fix_msg}")
-    print()
+    # 5. Check Quash Version (only if installed)
+    if mhg_ok or mahoraga_just_installed:
+        print("5️⃣  Checking Quash version...")
+        ver_ok, ver_msg, ver_fix = checker.check_mahoraga_version()
+        details["mahoraga_version"] = ver_msg
+        print(f"   {ver_msg}")
+
+        if not ver_ok:
+            # Don't fail build for version mismatch - just warn
+            if ver_fix:
+                fix_msg = f"💡 Consider upgrading: pip install --upgrade mahoraga"
+                details["mahoraga_version_fix"] = fix_msg
+                print(f"   {fix_msg}")
+        print()
+    else:
+        print("5️⃣  Checking Quash version...")
+        print("   ⏭️  Skipped (Quash package not installed)")
+        details["mahoraga_version"] = "⏭️  Skipped"
+        print()
 
     # 6. Check Python Dependencies
     # Note: Only check if Quash wasn't just installed, because 'pip install -e'

{quash_mcp-0.2.0 → quash_mcp-0.2.1}/quash_mcp/tools/connect.py

@@ -41,7 +41,7 @@ def check_portal_service(serial: str) -> bool:
     """Check if Quash Portal accessibility service is enabled."""
     try:
         from adbutils import adb
-        from mahoraga.portal import ping_portal
+        from quash_mcp.device.portal import ping_portal
 
         device = adb.device(serial)
         ping_portal(device, debug=False)
@@ -54,7 +54,7 @@ def setup_portal(serial: str) -> tuple[bool, str]:
     """Setup Quash Portal on the device."""
     try:
         from adbutils import adb
-        from mahoraga.portal import use_portal_apk, enable_portal_accessibility
+        from quash_mcp.device.portal import use_portal_apk, enable_portal_accessibility
 
         device = adb.device(serial)