quash-mcp 0.2.4__tar.gz → 0.2.6__tar.gz

{quash_mcp-0.2.4 → quash_mcp-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.2.4
+Version: 0.2.6
 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.2.4 → quash_mcp-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quash-mcp"
-version = "0.2.4"
+version = "0.2.6"
 description = "Model Context Protocol server for Quash - AI-powered mobile automation agent"
 readme = "README.md"
 license = {text = "MIT"}

{quash_mcp-0.2.4 → quash_mcp-0.2.6}/quash_mcp/tools/execute_v3.py

@@ -7,12 +7,27 @@ This hybrid approach keeps proprietary code private while allowing local device
 
 import time
 import uuid
+import asyncio
 from typing import Dict, Any, Callable, Optional
 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 mahoraga components for tool functions
+try:
+    from mahoraga.tools import Tools, describe_tools
+    from mahoraga.tools.adb import AdbTools as MahoragaAdbTools
+    from mahoraga.agent.context.personas import DEFAULT
+    from mahoraga.agent.utils.async_utils import async_to_sync
+except ImportError as e:
+    print(f"Warning: Could not import mahoraga components: {e}")
+    Tools = None
+    describe_tools = None
+    MahoragaAdbTools = None
+    DEFAULT = None
+    async_to_sync = None
+
 
 async def execute_v3(
     task: str,
@@ -114,11 +129,46 @@ async def execute_v3(
     # Initialize local ADB tools for code execution
     adb_tools = AdbTools(serial=state.device_serial, use_tcp=True)
 
-    # Code executor namespace
+    # Code executor namespace - add tool functions so generated code can call them
     executor_globals = {
         "__builtins__": __builtins__,
         "adb_tools": adb_tools
     }
+
+    # Add tool functions to executor namespace (like start_app, swipe, etc.)
+    if describe_tools and DEFAULT and MahoragaAdbTools:
+        try:
+            # Create a mahoraga AdbTools instance for tool execution
+            # This instance has all the tool methods like swipe, start_app, etc.
+            mahoraga_tools = MahoragaAdbTools(
+                serial=state.device_serial,
+                use_tcp=True,
+                remote_tcp_port=8080
+            )
+
+            # Get all tool functions from mahoraga AdbTools 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
+            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)
+
+                # Add to globals so code can call it directly
+                executor_globals[tool_name] = 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()}")
+
     executor_locals = {}
 
     try:

quash_mcp-0.2.6/test_tools_loading.py

@@ -0,0 +1,81 @@
+"""
+Test script to verify tool functions are loaded correctly.
+"""
+
+import sys
+sys.path.insert(0, '/Users/abhinavsai/POC/mahoraga-mac/quash-mcp')
+sys.path.insert(0, '/Users/abhinavsai/POC/mahoraga-mac/mahoraga')
+
+def test_tool_loading():
+    print("Testing tool loading...")
+
+    try:
+        # Import mahoraga components
+        from mahoraga.tools import Tools, describe_tools
+        from mahoraga.tools.adb import AdbTools as MahoragaAdbTools
+        from mahoraga.agent.context.personas import DEFAULT
+        from mahoraga.agent.utils.async_utils import async_to_sync
+
+        print("✅ All imports successful")
+
+        # Create a mahoraga AdbTools instance
+        print("\nCreating mahoraga AdbTools instance...")
+        mahoraga_tools = MahoragaAdbTools(
+            serial="emulator-5554",  # Use your device serial
+            use_tcp=True,
+            remote_tcp_port=8080
+        )
+        print(f"✅ Created mahoraga AdbTools instance")
+        print(f"   - Serial: {mahoraga_tools.device.serial}")
+        print(f"   - TCP forwarded: {mahoraga_tools.tcp_forwarded}")
+
+        # Get tool list
+        print("\nGetting tool list...")
+        tool_list = describe_tools(mahoraga_tools, exclude_tools=None)
+        print(f"✅ Got {len(tool_list)} tools:")
+        for tool_name, tool_func in tool_list.items():
+            print(f"   - {tool_name}: {tool_func}")
+
+        # Filter by allowed tools
+        print(f"\nFiltering by DEFAULT persona allowed tools...")
+        allowed_tool_names = DEFAULT.allowed_tools
+        print(f"   Allowed tools: {allowed_tool_names}")
+
+        filtered_tools = {name: func for name, func in tool_list.items() if name in allowed_tool_names}
+        print(f"✅ Filtered to {len(filtered_tools)} tools:")
+        for tool_name in filtered_tools.keys():
+            print(f"   - {tool_name}")
+
+        # Test executor globals setup
+        print("\nSetting up executor globals...")
+        executor_globals = {"__builtins__": __builtins__}
+
+        for tool_name, tool_function in filtered_tools.items():
+            import asyncio
+            if asyncio.iscoroutinefunction(tool_function):
+                tool_function = async_to_sync(tool_function)
+            executor_globals[tool_name] = tool_function
+
+        print(f"✅ Executor globals set up with {len(executor_globals)} items")
+
+        # Test that functions are callable
+        print("\nTesting function availability...")
+        test_functions = ['start_app', 'swipe', 'press_key', 'tap_by_index']
+        for func_name in test_functions:
+            if func_name in executor_globals:
+                print(f"   ✅ {func_name} is available")
+            else:
+                print(f"   ❌ {func_name} is NOT available")
+
+        print("\n✅ All tests passed!")
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = test_tool_loading()
+    sys.exit(0 if success else 1)