quash-mcp 0.3.0__py3-none-any.whl → 0.3.3__py3-none-any.whl

quash_mcp/backend_client.py

@@ -20,7 +20,7 @@ class BackendClient:
 
     def __init__(self):
         # Get backend URL from environment variable, default to production backend
-        self.base_url = os.getenv("MAHORAGA_BACKEND_URL", "http://localhost:8000")
+        self.base_url = os.getenv("MAHORAGA_BACKEND_URL", "https://mcpbe.quashbugs.com")
         self.timeout = 300.0  # 5 minutes for long-running LLM calls
         logger.info(f"🔧 Backend client initialized: URL={self.base_url}")
 
@@ -57,7 +57,9 @@ class BackendClient:
                     }
 
         except Exception as e:
-            logger.error(f"Failed to validate API key: {e}")
+            import traceback
+            error_details = traceback.format_exc()
+            logger.error(f"Failed to validate API key: {e}\n{error_details}")
             return {
                 "valid": False,
                 "error": f"Connection error: {str(e)}"

quash_mcp/device/adb_tools.py

@@ -1,10 +1,11 @@
 """
 ADB Tools - Basic Android device communication wrapper.
 Simplified version for device management without agent-specific functionality.
+Includes lightweight tool functions for executing backend-generated code.
 """
 
 import logging
-from typing import Optional
+from typing import Optional, List, Dict, Any
 from adbutils import adb
 import requests
 
@@ -13,7 +14,7 @@ PORTAL_DEFAULT_TCP_PORT = 8080
 
 
 class AdbTools:
-    """Basic ADB device communication wrapper."""
+    """Basic ADB device communication wrapper with tool execution functions."""
 
     def __init__(
         self,
@@ -32,6 +33,7 @@ class AdbTools:
         self.use_tcp = use_tcp
         self.remote_tcp_port = remote_tcp_port
         self.tcp_forwarded = False
+        self.clickable_elements_cache: List[Dict[str, Any]] = []
 
         # Set up TCP forwarding if requested
         if self.use_tcp:
@@ -144,6 +146,130 @@ class AdbTools:
             logger.error(f"Failed to get screenshot: {e}", exc_info=True)
             return b""
 
+    # === Tool Execution Functions ===
+    # These lightweight functions are used to execute backend-generated code
+
+    def update_state(self, a11y_tree: List[Dict[str, Any]]) -> None:
+        """Update clickable elements cache from accessibility tree."""
+        try:
+            elements = a11y_tree
+            filtered_elements = []
+            for element in elements:
+                filtered_element = {k: v for k, v in element.items() if k != "type"}
+                if "children" in filtered_element:
+                    filtered_element["children"] = [
+                        {k: v for k, v in child.items() if k != "type"}
+                        for child in filtered_element["children"]
+                    ]
+                filtered_elements.append(filtered_element)
+            self.clickable_elements_cache = filtered_elements
+        except Exception as e:
+            logger.error(f"Failed to update state: {e}")
+
+    def tap_by_index(self, index: int) -> str:
+        """Tap on element by index."""
+        try:
+            if not self.clickable_elements_cache:
+                return "Error: No UI elements cached"
+
+            def find_element_by_index(elements, target_idx):
+                for item in elements:
+                    if item.get("index") == target_idx:
+                        return item
+                    children = item.get("children", [])
+                    result = find_element_by_index(children, target_idx)
+                    if result:
+                        return result
+                return None
+
+            element = find_element_by_index(self.clickable_elements_cache, index)
+            if not element:
+                return f"Error: No element found with index {index}"
+
+            bounds_str = element.get("bounds")
+            if not bounds_str:
+                return f"Error: Element at index {index} has no bounds"
+
+            try:
+                left, top, right, bottom = map(int, bounds_str.split(","))
+                x = (left + right) // 2
+                y = (top + bottom) // 2
+                self.device.shell(f"input tap {x} {y}")
+                return f"Tapped on element at index {index}"
+            except Exception as e:
+                return f"Error parsing bounds: {e}"
+        except Exception as e:
+            logger.error(f"Failed to tap by index {index}: {e}")
+            return f"Error: {e}"
+
+    def swipe(self, start_x: int, start_y: int, end_x: int, end_y: int, duration: int = 500) -> str:
+        """Swipe from start to end coordinates."""
+        try:
+            self.device.shell(f"input swipe {start_x} {start_y} {end_x} {end_y} {duration}")
+            return "Swiped successfully"
+        except Exception as e:
+            logger.error(f"Failed to swipe: {e}")
+            return f"Error: {e}"
+
+    def input_text(self, text: str) -> str:
+        """Input text into the focused field."""
+        try:
+            escaped_text = text.replace('"', '\\"').replace('$', '\\$')
+            self.device.shell(f'input text "{escaped_text}"')
+            return f"Text entered: {text}"
+        except Exception as e:
+            logger.error(f"Failed to input text: {e}")
+            return f"Error: {e}"
+
+    def press_key(self, key: str) -> str:
+        """Press a key on the device."""
+        try:
+            key_map = {
+                "BACK": "4",
+                "HOME": "3",
+                "MENU": "82",
+                "SEARCH": "84",
+                "ENTER": "66",
+                "TAB": "61",
+                "SPACE": "62",
+            }
+            key_code = key_map.get(key.upper(), key)
+            self.device.shell(f"input keyevent {key_code}")
+            return f"Key pressed: {key}"
+        except Exception as e:
+            logger.error(f"Failed to press key: {e}")
+            return f"Error: {e}"
+
+    def start_app(self, package_name: str) -> str:
+        """Start an app by package name."""
+        try:
+            self.device.shell(f"monkey -p {package_name} 1")
+            return f"App started: {package_name}"
+        except Exception as e:
+            logger.error(f"Failed to start app: {e}")
+            return f"Error: {e}"
+
+    def complete(self, success: bool = True, reason: str = "") -> str:
+        """Signal task completion."""
+        status = "SUCCESS" if success else "FAILED"
+        return f"Task completed ({status}): {reason}"
+
+    def remember(self, text: str) -> str:
+        """Store text in memory."""
+        return f"Remembered: {text}"
+
+    def list_packages(self, filter_str: str = "") -> str:
+        """List installed packages."""
+        try:
+            result = self.device.shell("pm list packages")
+            packages = result.strip().split('\n')
+            if filter_str:
+                packages = [p for p in packages if filter_str.lower() in p.lower()]
+            return "\n".join(packages[:20])
+        except Exception as e:
+            logger.error(f"Failed to list packages: {e}")
+            return f"Error: {e}"
+
     def __del__(self):
         """Cleanup when the object is destroyed."""
         if hasattr(self, "tcp_forwarded") and self.tcp_forwarded:

quash_mcp/device/portal.py

@@ -124,6 +124,23 @@ def check_portal_accessibility(device: AdbDevice, debug: bool = False) -> bool:
     return True
 
 
+def is_portal_installed(device: AdbDevice, debug: bool = False) -> bool:
+    """
+    Check if Quash Portal package is installed on the device.
+    Does NOT check if accessibility service is enabled.
+    """
+    try:
+        packages = device.list_packages()
+        is_installed = PORTAL_PACKAGE_NAME in packages
+        if debug:
+            print(f"Portal installed: {is_installed}")
+        return is_installed
+    except Exception as e:
+        if debug:
+            print(f"Error checking packages: {e}")
+        return False
+
+
 def ping_portal(device: AdbDevice, debug: bool = False):
     """
     Ping the Quash Portal to check if it is installed and accessible.

quash_mcp/tools/connect.py

@@ -51,21 +51,42 @@ def check_portal_service(serial: str) -> bool:
 
 
 def setup_portal(serial: str) -> tuple[bool, str]:
-    """Setup Quash Portal on the device."""
+    """
+    Setup Quash Portal on the device.
+
+    If Portal is already installed, only enables the accessibility service.
+    If Portal is not installed, attempts to install and enable it.
+    """
     try:
         from adbutils import adb
-        from quash_mcp.device.portal import use_portal_apk, enable_portal_accessibility
+        from quash_mcp.device.portal import (
+            is_portal_installed,
+            enable_portal_accessibility,
+            use_portal_apk
+        )
 
         device = adb.device(serial)
 
-        # Install APK
-        with use_portal_apk(None, debug=False) as apk_path:
-            device.install(apk_path, uninstall=True, flags=["-g"], silent=True)
-
-        # Enable accessibility service
-        enable_portal_accessibility(device)
-
-        return True, "Portal installed and enabled successfully"
+        # Check if Portal is already installed
+        if is_portal_installed(device, debug=False):
+            # Portal already installed, just enable accessibility service
+            enable_portal_accessibility(device)
+            return True, "Portal accessibility service enabled"
+        else:
+            # Portal not installed, try to install it
+            try:
+                with use_portal_apk(None, debug=False) as apk_path:
+                    device.install(apk_path, uninstall=True, flags=["-g"], silent=True)
+
+                # Enable accessibility service after installation
+                enable_portal_accessibility(device)
+                return True, "Portal installed and enabled successfully"
+            except Exception as install_error:
+                # Installation failed, report that Portal needs to be manually installed
+                return False, (
+                    f"Portal not installed and auto-install failed: {str(install_error)}. "
+                    "Please manually install the Portal APK on the device."
+                )
     except Exception as e:
         return False, f"Failed to setup portal: {str(e)}"
 

quash_mcp/tools/execute_v3.py

@@ -17,7 +17,9 @@ from ..state import get_state
 from ..backend_client import get_backend_client
 from ..device.state_capture import get_device_state
 from ..device.adb_tools import AdbTools
+
 import logging
+logger = logging.getLogger(__name__)
 
 # Import mahoraga components for tool functions
 try:
@@ -268,16 +270,18 @@ async def execute_v3(
         last_action_completed=None  # Explicitly initialize the new field
     )
 
-    # Initialize a single, powerful ADB tools instance from Mahoraga
-    mahoraga_tools = None
+    # Initialize ADB tools for executing generated code
+    # Use the lightweight AdbTools from quash-mcp device module (no mahoraga dependency)
+    adb_tools = None
     try:
-        mahoraga_tools = MahoragaAdbTools(
+        adb_tools = AdbTools(
             serial=state.device_serial,
             use_tcp=True,
             remote_tcp_port=8080
         )
+        log_progress(f"✅ Initialized AdbTools for code execution")
     except Exception as e:
-        log_progress(f"⚠️ CRITICAL: Failed to initialize MahoragaAdbTools: {e}")
+        log_progress(f"⚠️ CRITICAL: Failed to initialize AdbTools: {e}")
         return {
             "status": "error",
             "message": f"💥 Failed to initialize ADB tools: {e}",
@@ -289,40 +293,41 @@ async def execute_v3(
     }
 
     # Add tool functions to executor namespace
-    try:
-        # Get all tool functions from the single mahoraga_tools instance
-        tool_list = describe_tools(mahoraga_tools, exclude_tools=None)
-
-        # Filter by allowed tools from DEFAULT persona
-        allowed_tool_names = DEFAULT.allowed_tools if hasattr(DEFAULT, 'allowed_tools') else []
-        filtered_tools = {name: func for name, func in tool_list.items() if name in allowed_tool_names}
-
-        # Add each tool function to executor globals with print wrapper
-        for tool_name, tool_function in filtered_tools.items():
-            # Convert async functions to sync if needed
-            if asyncio.iscoroutinefunction(tool_function):
-                if async_to_sync:
-                    tool_function = async_to_sync(tool_function)
-
-            # Wrap tool function to print its return value
-            def make_printing_wrapper(func):
-                """Wrap a tool function to print its return value."""
-                def wrapper(*args, **kwargs):
-                    result = func(*args, **kwargs)
-                    # Print the result so stdout captures it
-                    if result is not None:
-                        print(result)
-                    return result
-                return wrapper
-
-            # Add wrapped function to globals so code can call it directly
-            executor_globals[tool_name] = make_printing_wrapper(tool_function)
-
-        log_progress(f"🔧 Loaded {len(filtered_tools)} tool functions: {list(filtered_tools.keys())}")
-    except Exception as e:
-        log_progress(f"⚠️ Warning: Could not load tool functions: {e}")
-        import traceback
-        log_progress(f"Traceback: {traceback.format_exc()}")
+    # Use the lightweight tool functions from adb_tools (no mahoraga dependency needed)
+    if adb_tools:
+        try:
+            tool_functions = {
+                'tap_by_index': adb_tools.tap_by_index,
+                'swipe': adb_tools.swipe,
+                'input_text': adb_tools.input_text,
+                'press_key': adb_tools.press_key,
+                'start_app': adb_tools.start_app,
+                'complete': adb_tools.complete,
+                'remember': adb_tools.remember,
+                'list_packages': adb_tools.list_packages,
+                'update_state': adb_tools.update_state,
+            }
+
+            # Add each tool function to executor globals with print wrapper
+            for tool_name, tool_function in tool_functions.items():
+                def make_printing_wrapper(func):
+                    """Wrap a tool function to print its return value."""
+                    def wrapper(*args, **kwargs):
+                        result = func(*args, **kwargs)
+                        # Print the result so stdout captures it
+                        if result is not None:
+                            print(result)
+                        return result
+                    return wrapper
+
+                # Add wrapped function to globals so code can call it directly
+                executor_globals[tool_name] = make_printing_wrapper(tool_function)
+
+            log_progress(f"🔧 Loaded {len(tool_functions)} tool functions: {list(tool_functions.keys())}")
+        except Exception as e:
+            log_progress(f"⚠️ Warning: Could not load tool functions: {e}")
+            import traceback
+            log_progress(f"Traceback: {traceback.format_exc()}")
 
     executor_locals = {}
 
@@ -344,12 +349,12 @@ async def execute_v3(
                 session.ui_state = UIStateInfo(**ui_state_dict)
 
                 # Update local tools with new state
-                if mahoraga_tools and "a11y_tree" in ui_state_dict and isinstance(ui_state_dict["a11y_tree"], list):
+                if adb_tools and "a11y_tree" in ui_state_dict and isinstance(ui_state_dict["a11y_tree"], list):
                     try:
                         a11y_tree_obj = ui_state_dict["a11y_tree"]
-                        mahoraga_tools.update_state(a11y_tree_obj)
+                        adb_tools.update_state(a11y_tree_obj)
                     except Exception as e:
-                        log_progress(f"⚠️ Warning: Failed to update mahoraga_tools state: {e}")
+                        log_progress(f"⚠️ Warning: Failed to update adb_tools state: {e}")
 
                 if not config["vision"]:
                     screenshot_bytes = None
@@ -442,12 +447,10 @@ async def execute_v3(
                     execution_output = stdout.getvalue()
                     error_output = stderr.getvalue()
 
-                    # CRITICAL FIX: Check if complete() was actually called
-                    if mahoraga_tools and mahoraga_tools.finished:
-                        log_progress("✅ Agent has signaled task completion via complete()")
-                        session.last_action_completed = True
-                    else:
-                        session.last_action_completed = False
+                    # NOTE: Check if complete() was called in the executed code
+                    # For now, we rely on the backend to tell us when tasks are complete
+                    # via the action type, not through tool properties
+                    session.last_action_completed = False
 
                     log_progress(f"⏳ Waiting for UI state to update...")
                     try:
@@ -515,40 +518,13 @@ async def execute_v3(
                     ))
 
             # 4. Check if overall task is complete
-            # CRITICAL FIX: In reasoning mode with planning, DON'T exit on first complete() call
-            # The backend controls when all tasks are done via the "complete" action type
-            should_exit = False
-
-            if mahoraga_tools and mahoraga_tools.finished:
-                # Check if this is the FINAL completion from the backend
-                # In reasoning mode, the backend returns action.type="complete" when ALL tasks are done
-                action_type = action.get("type", "")
-
-                if action_type == "complete":
-                    # Backend explicitly says we're done with ALL tasks
-                    should_exit = True
-                    success = mahoraga_tools.success
-                    final_message = mahoraga_tools.reason
-                elif config["reasoning"] and session.current_plan:
-                    # In reasoning mode with a plan, a single complete() call is just for one sub-task
-                    # Continue the loop - the backend will advance to the next task
-                    log_progress(f"✅ Sub-task completed. Moving to next task...")
-                    should_exit = False
-                else:
-                    # Non-reasoning mode: first complete() means done
-                    should_exit = True
-                    success = mahoraga_tools.success
-                    final_message = mahoraga_tools.reason
-
-            if should_exit and mahoraga_tools and mahoraga_tools.finished:
-                success = mahoraga_tools.success
-                final_message = mahoraga_tools.reason
-                duration = time.time() - start_time
+            # The backend controls task completion via action.type == "complete"
+            action_type = action.get("type", "")
 
-                if success:
-                    log_progress(f"✅ Task completed successfully!")
-                else:
-                    log_progress(f"❌ Task marked as failed: {final_message}")
+            if action_type == "complete":
+                # Backend explicitly says we're done with ALL tasks
+                duration = time.time() - start_time
+                log_progress(f"✅ Task completed successfully!")
 
                 # Finalize session on backend
                 finalize_result = await backend.finalize_session(session=session)
@@ -558,10 +534,10 @@ async def execute_v3(
                 log_progress(f"💰 Usage: {total_tokens.get('total')} tokens, ${total_cost:.4f}")
 
                 return {
-                    "status": "success" if success else "failed",
+                    "status": "success",
                     "steps_taken": len(session.steps),
-                    "final_message": final_message,
-                    "message": f"✅ Success: {final_message}" if success else f"❌ Failed: {final_message}",
+                    "final_message": "Task completed successfully",
+                    "message": f"✅ Success: Task completed",
                     "tokens": total_tokens,
                     "cost": total_cost,
                     "duration_seconds": duration
@@ -621,5 +597,8 @@ async def execute_v3(
 
     finally:
         # Cleanup TCP forwarding
-        if mahoraga_tools:
-            mahoraga_tools.teardown_tcp_forward()
+        if adb_tools:
+            try:
+                adb_tools.teardown_tcp_forward()
+            except Exception as e:
+                logger.warning(f"Failed to cleanup TCP forwarding: {e}")

{quash_mcp-0.3.0.dist-info → quash_mcp-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.3.0
+Version: 0.3.3
 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

{quash_mcp-0.3.0.dist-info → quash_mcp-0.3.3.dist-info}/RECORD

@@ -1,24 +1,24 @@
 quash_mcp/__init__.py,sha256=LImiWCRgjAbb5DZXBq2DktUEAbftvnO61Vil4Ayun9A,39
 quash_mcp/__main__.py,sha256=WCg5OlnXhr6i0XJHAUGpbhliMy3qE2SJkFzVD4wO-lw,239
-quash_mcp/backend_client.py,sha256=_smBbhyJxN1dj89cJNVvqRZVX92oc1bw2SI1vzX2Rek,9979
+quash_mcp/backend_client.py,sha256=yxlzw5KPqlNTObDLumCxacrxZXz7T28mEHW9oEvXlNw,10082
 quash_mcp/models.py,sha256=zqi0-DCmgOaq4TiuJsb9QsQxMxcJ82B3NeRwbnrfJQc,1414
 quash_mcp/server.py,sha256=scUGnplxjsvyYLK2q6hrjl-5Chkdnat9pODDtLzsQFY,15519
 quash_mcp/state.py,sha256=Tnt795GnZcas-h62Y6KYyIZVopeoWPM0TbRwOeVFYj4,4394
 quash_mcp/device/__init__.py,sha256=6e8CtHolt-vJKPxZUU_Vsd6-QGqos9VrFykaLTT90rk,772
-quash_mcp/device/adb_tools.py,sha256=SsYnzGjG3XsfbiAHiC7PpgLdC149kRH-YkoXQZvxvWc,5439
-quash_mcp/device/portal.py,sha256=sDLJOruUwwNNxIDriiXB4vT0BZYILidgzVgdhHCEkDY,5241
+quash_mcp/device/adb_tools.py,sha256=N73iTnxoCRzLDegLbQfCrFj7GUisRdfuwfweH1h3sOo,10620
+quash_mcp/device/portal.py,sha256=qt2iC26ocPQF0L3oKnlOvG7dvgumKhW5WvN5Da8gbcE,5774
 quash_mcp/device/state_capture.py,sha256=NwuhjCBI576w9eexhdVOxfsOmABTW1A4SWRpcjadg-w,4016
 quash_mcp/tools/__init__.py,sha256=r4fMAjHDjHUbimRwYW7VYUDkQHs12UVsG_IBmWpeX9s,249
 quash_mcp/tools/build.py,sha256=M6tGXWrQNkdtCYYrK14gUaoufQvyoor_hNN0lBPSVHY,30321
 quash_mcp/tools/build_old.py,sha256=6M9gaqZ_dX4B7UFTxSMD8T1BX0zEwQUL7RJ8ItNfB54,6016
 quash_mcp/tools/configure.py,sha256=cv4RTolu6qae-XzyACSJUDrALfd0gYC-XE5s66_zfNk,4439
-quash_mcp/tools/connect.py,sha256=Kc7RGRUgtd2sR_bv6U4CB4kWSaLfsDc5kBo9u4FEjzs,4799
+quash_mcp/tools/connect.py,sha256=Etu4qhHCmGj_pQJ2TiD-vpLj5PHzzJnQop25PTk6jQM,5783
 quash_mcp/tools/execute.py,sha256=kR3VzIl31Lek-js4Hgxs-S_ls4YwKnbqkt79KFbvFuM,909
 quash_mcp/tools/execute_v2_backup.py,sha256=waWnaD0dEVcOJgRBbqZo3HnxME1s6YUOn8aRbm4R3X4,6081
-quash_mcp/tools/execute_v3.py,sha256=KMS7Zru2GiDcp1IqDvtGPhKlzbXEilCRp8hkvZShI2Q,24404
+quash_mcp/tools/execute_v3.py,sha256=g8qfGjXrZBc0n7Qm5xkqf_5zJ5h5JtgZ6Yb51kNLNTc,23062
 quash_mcp/tools/runsuite.py,sha256=gohLk9FpN8v7F0a69fspqOqUexTcslpYf3qU-iIZZ3s,7220
 quash_mcp/tools/usage.py,sha256=g76A6FO36fThoyRFG7q92QmS3Kh1pIKOrhYOzUdIubA,1155
-quash_mcp-0.3.0.dist-info/METADATA,sha256=wLT-0D39eXubj1b8LiX57vBUae0ITz_1x1yCozxFUwM,8423
-quash_mcp-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quash_mcp-0.3.0.dist-info/entry_points.txt,sha256=9sbDxrx0ApGDVRS-IE3mQgSao3DwKnnV_k-_ipFn9QI,52
-quash_mcp-0.3.0.dist-info/RECORD,,
+quash_mcp-0.3.3.dist-info/METADATA,sha256=Zn5e20vNUQ4ai5P3C5jL5Y8CgvEK9EXlakMBjx22dVg,8423
+quash_mcp-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quash_mcp-0.3.3.dist-info/entry_points.txt,sha256=9sbDxrx0ApGDVRS-IE3mQgSao3DwKnnV_k-_ipFn9QI,52
+quash_mcp-0.3.3.dist-info/RECORD,,