quash-mcp 0.2.13__tar.gz → 0.2.15__tar.gz

{quash_mcp-0.2.13 → quash_mcp-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quash-mcp
-Version: 0.2.13
+Version: 0.2.15
 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.13 → quash_mcp-0.2.15}/local_test.py

@@ -13,13 +13,15 @@ from quash_mcp.models import SessionDTO, ConfigInfo, UIStateInfo
 async def main():
     # Initialize the session state
     state = get_state()
-    state.config["api_key"] = "mhg_7S01mxJUB7q6k-sbFQeScYTX6ae3pehI"
+    state.config["api_key"] = "mhg_AMncG3jkTtEntd8vTqJk3nHl6rnxceRr"
     state.device_serial = "emulator-5554"
     state.portal_ready = True  # Assume portal is ready for local testing
 
     # Define the task
-    task = "Open chrome and open quashbugs.com website"
-    # task = "Open settings and scroll 3 times."
+    # task = "Open the google search app and search for bakeries."
+    task = "Open settings and scroll 3 times."
+    # task = "Go home"
+    # task = "Open chrome, search for quashbugs.com and scroll down."
 
     # Define a progress callback
     def progress_callback(message):

{quash_mcp-0.2.13 → quash_mcp-0.2.15}/pyproject.toml

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

{quash_mcp-0.2.13 → quash_mcp-0.2.15}/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", "https://mcpbe.quashbugs.com")
+        self.base_url = os.getenv("MAHORAGA_BACKEND_URL", "http://localhost:8000")
         self.timeout = 300.0  # 5 minutes for long-running LLM calls
         logger.info(f"🔧 Backend client initialized: URL={self.base_url}")
 
@@ -35,7 +35,8 @@ class BackendClient:
             Dict with validation result:
             {
                 "valid": bool,
-                "user": {"email": str, "name": str, "credits": float},
+                "user": {"email": str, "name": str},
+                "organization_credits": float,
                 "openrouter_api_key": str,
                 "error": str (if invalid)
             }

{quash_mcp-0.2.13 → quash_mcp-0.2.15}/quash_mcp/tools/execute_v3.py

@@ -17,6 +17,7 @@ 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
 
 # Import mahoraga components for tool functions
 try:
@@ -236,12 +237,12 @@ async def execute_v3(
 
     # Check credits
     user_info = validation_result.get("user", {})
-    credits = user_info.get("credits", 0)
+    organization_credits = validation_result.get("organization_credits", 0)
 
-    if credits <= 0:
+    if organization_credits <= 0:
         return {
             "status": "error",
-            "message": f"❌ Insufficient credits. Current balance: ${credits:.2f}",
+            "message": f"❌ Insufficient credits. Current balance: ${organization_credits:.2f}",
             "user": user_info
         }
 
@@ -250,7 +251,7 @@ async def execute_v3(
         if progress_callback:
             progress_callback(message)
 
-    log_progress(f"✅ API Key validated - Credits: ${credits:.2f}")
+    log_progress(f"✅ API Key validated - Credits: ${organization_credits:.2f}")
     log_progress(f"👤 User: {user_info.get('name', 'Unknown')}")
     log_progress(f"🚀 Starting task: {task}")
     log_progress(f"📱 Device: {state.device_serial}")
@@ -315,6 +316,15 @@ async def execute_v3(
                 # Add wrapped function to globals so code can call it directly
                 executor_globals[tool_name] = make_printing_wrapper(tool_function)
 
+            # Override the 'complete' function to be a no-op
+            # The backend already handles completion via the 'completed' flag
+            def complete_no_op(success=True, reason=""):
+                """No-op wrapper for complete() - completion is handled by backend."""
+                print(f"complete() called: success={success}, reason='{reason}'")
+                return None
+
+            executor_globals['complete'] = complete_no_op
+
             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}")
@@ -402,50 +412,8 @@ async def execute_v3(
                 log_progress(f"🤔 Reasoning: {reasoning}")
 
 
-            # 3. Check if task is complete BEFORE executing action
-            if step_result.get("completed", False):
-                success = step_result.get("success", False)
-                final_message = step_result.get("final_message", "Task completed")
-
-                duration = time.time() - start_time
-
-                if success:
-                    log_progress(f"✅ Task completed successfully!")
-                else:
-                    log_progress(f"❌ Task marked as failed")
-
-                # Finalize session on backend
-                finalize_result = await backend.finalize_session(session=session)
-
-                if success:
-                    log_progress(f"✅ Task completed successfully in {len(session.steps)} steps")
-                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
-
-                    return {
-                        "status": "success",
-                        "steps_taken": len(session.steps),
-                        "final_message": final_message,
-                        "message": f"✅ Success: {final_message}",
-                        "tokens": finalize_result.get("total_tokens"),
-                        "cost": finalize_result.get("total_cost"),
-                        "duration_seconds": duration
-                    }
-                else:
-                    log_progress(f"❌ Task failed: {final_message}")
-                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
-
-                    return {
-                        "status": "failed",
-                        "steps_taken": len(session.steps),
-                        "final_message": final_message,
-                        "message": f"❌ Failed: {final_message}",
-                        "tokens": finalize_result.get("total_tokens"),
-                        "cost": finalize_result.get("total_cost"),
-                        "duration_seconds": duration
-                    }
-
-
-            # 4. Execute action locally (only if task is not complete)
+            # 3. Execute action locally FIRST (if provided)
+            # NOTE: Backend should have already removed complete() from the code
             if code and action_type == "execute_code":
                 log_progress(f"⚡ Executing action...")
 
@@ -514,6 +482,8 @@ async def execute_v3(
 
                     session.chat_history.append(ChatHistoryMessage(role="user", content=f"Execution Result:\n```\n{feedback}\n```"))
 
+                    # Introduce a small delay to allow UI effects to settle before checking completion
+                    time.sleep(1.0) # Added delay
 
                 except Exception as e:
                     error_msg = f"Error during execution: {str(e)}"
@@ -526,6 +496,48 @@ async def execute_v3(
                 session.chat_history.append(ChatHistoryMessage(role="user", content="No code was provided. Please provide code to execute."))
 
 
+            # 4. Check if task is complete AFTER executing action
+            if step_result.get("completed", False):
+                success = step_result.get("success", False)
+                final_message = step_result.get("final_message", "Task completed")
+
+                duration = time.time() - start_time
+
+                if success:
+                    log_progress(f"✅ Task completed successfully!")
+                else:
+                    log_progress(f"❌ Task marked as failed")
+
+                # Finalize session on backend
+                finalize_result = await backend.finalize_session(session=session)
+
+                if success:
+                    log_progress(f"✅ Task completed successfully in {len(session.steps)} steps")
+                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
+
+                    return {
+                        "status": "success",
+                        "steps_taken": len(session.steps),
+                        "final_message": final_message,
+                        "message": f"✅ Success: {final_message}",
+                        "tokens": finalize_result.get("total_tokens"),
+                        "cost": finalize_result.get("total_cost"),
+                        "duration_seconds": duration
+                    }
+                else:
+                    log_progress(f"❌ Task failed: {final_message}")
+                    log_progress(f"💰 Usage: {finalize_result.get('total_tokens', {}).get('total')} tokens, ${finalize_result.get('total_cost', 0):.4f}")
+
+                    return {
+                        "status": "failed",
+                        "steps_taken": len(session.steps),
+                        "final_message": final_message,
+                        "message": f"❌ Failed: {final_message}",
+                        "tokens": finalize_result.get("total_tokens"),
+                        "cost": finalize_result.get("total_cost"),
+                        "duration_seconds": duration
+                    }
+
 
         # Max steps reached
         log_progress(f"⚠️ Reached maximum steps ({max_steps})")

quash_mcp-0.2.13/test_backend_integration.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify MCP -> Backend integration.
-Tests API key validation and execution logging with real backend.
-"""
-
-import asyncio
-import os
-import sys
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load .env file from project root
-project_root = Path(__file__).parent.parent
-env_file = project_root / ".env"
-load_dotenv(env_file)
-
-# Add src to path
-sys.path.insert(0, str(Path(__file__).parent / "src"))
-
-from backend_client import get_backend_client
-
-
-async def test_integration():
-    """Test MCP backend integration."""
-
-    print("=" * 60)
-    print("🧪 Testing Mahoraga MCP -> Backend Integration")
-    print("=" * 60)
-
-    # Check environment
-    mock_mode = os.getenv("MAHORAGA_MOCK_BACKEND", "true")
-    backend_url = os.getenv("MAHORAGA_BACKEND_URL", "http://localhost:8000")
-
-    print(f"\n📋 Configuration:")
-    print(f"   Mock Mode: {mock_mode}")
-    print(f"   Backend URL: {backend_url}")
-
-    # Get backend client
-    client = get_backend_client()
-
-    # Test API key from database
-    test_api_key = "mah_test1234567890abcdef"
-
-    print(f"\n🔑 Testing API Key Validation...")
-    print(f"   API Key: {test_api_key}")
-
-    # Test validation
-    result = await client.validate_api_key(test_api_key)
-
-    if result.get("valid"):
-        print("   ✅ API Key Valid!")
-        user = result.get("user", {})
-        print(f"   👤 User: {user.get('name')} ({user.get('email')})")
-        print(f"   💰 Credits: ${user.get('credits', 0):.2f}")
-    else:
-        print(f"   ❌ API Key Invalid: {result.get('error')}")
-        return False
-
-    # Test execution logging
-    print(f"\n📊 Testing Execution Logging...")
-
-    log_result = await client.log_execution(
-        api_key=test_api_key,
-        execution_id="test_exec_integration_001",
-        status="completed",
-        tokens={"prompt": 150, "completion": 75, "total": 225},
-        cost=0.05
-    )
-
-    if log_result.get("logged"):
-        print("   ✅ Execution Logged!")
-        print(f"   💸 Credits Deducted: ${log_result.get('credits_deducted', 0):.2f}")
-        print(f"   💰 New Balance: ${log_result.get('new_balance', 0):.2f}")
-    else:
-        print(f"   ❌ Logging Failed: {log_result.get('error')}")
-        return False
-
-    # Verify credits were deducted
-    print(f"\n🔍 Verifying Credit Deduction...")
-
-    verify_result = await client.validate_api_key(test_api_key)
-    if verify_result.get("valid"):
-        new_credits = verify_result.get("user", {}).get("credits", 0)
-        print(f"   ✅ Credits Updated: ${new_credits:.2f}")
-
-    print(f"\n" + "=" * 60)
-    print("✅ All Integration Tests Passed!")
-    print("=" * 60)
-    print("\n💡 Next Steps:")
-    print("   1. MCP is now connected to real backend")
-    print("   2. Test with actual MCP execute command")
-    print("   3. Build web portal for user management")
-
-    return True
-
-
-if __name__ == "__main__":
-    success = asyncio.run(test_integration())
-    sys.exit(0 if success else 1)

quash_mcp-0.2.13/test_tools_loading.py

@@ -1,81 +0,0 @@
-"""
-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)