quash-mcp 0.2.0__py3-none-any.whl

quash_mcp/tools/build_old.py

@@ -0,0 +1,185 @@
+"""
+Build tool - Setup dependencies for Quash MCP.
+Checks and installs required dependencies on the user's machine.
+"""
+
+import sys
+import subprocess
+import shutil
+import platform
+from typing import Dict, Any, Tuple
+
+
+def check_python_version() -> Tuple[bool, str]:
+    """Check if Python version is >= 3.11."""
+    version = sys.version_info
+    if version.major >= 3 and version.minor >= 11:
+        return True, f"✓ Python {version.major}.{version.minor}.{version.micro}"
+    return False, f"✗ Python {version.major}.{version.minor}.{version.micro} (requires >= 3.11)"
+
+
+def check_adb() -> Tuple[bool, str]:
+    """Check if ADB is installed."""
+    if shutil.which("adb"):
+        try:
+            result = subprocess.run(
+                ["adb", "version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            version_line = result.stdout.split('\n')[0]
+            return True, f"✓ ADB installed ({version_line})"
+        except Exception:
+            return True, "✓ ADB installed"
+    return False, "✗ ADB not found"
+
+
+def install_adb() -> Tuple[bool, str]:
+    """Attempt to install ADB based on OS."""
+    system = platform.system()
+
+    try:
+        if system == "Darwin":  # macOS
+            # Check if Homebrew is available
+            if shutil.which("brew"):
+                subprocess.run(
+                    ["brew", "install", "android-platform-tools"],
+                    check=True,
+                    capture_output=True
+                )
+                return True, "✓ ADB installed via Homebrew"
+            else:
+                return False, "✗ Homebrew not found. Install from: https://brew.sh/"
+
+        elif system == "Linux":
+            # Try apt-get
+            if shutil.which("apt-get"):
+                subprocess.run(
+                    ["sudo", "apt-get", "install", "-y", "adb"],
+                    check=True,
+                    capture_output=True
+                )
+                return True, "✓ ADB installed via apt-get"
+            # Try dnf
+            elif shutil.which("dnf"):
+                subprocess.run(
+                    ["sudo", "dnf", "install", "-y", "android-tools"],
+                    check=True,
+                    capture_output=True
+                )
+                return True, "✓ ADB installed via dnf"
+            else:
+                return False, "✗ Package manager not found. Install ADB manually."
+
+        elif system == "Windows":
+            return False, "✗ Please install ADB manually from: https://developer.android.com/tools/releases/platform-tools"
+
+        else:
+            return False, f"✗ Unsupported OS: {system}"
+
+    except subprocess.CalledProcessError as e:
+        return False, f"✗ Installation failed: {str(e)}"
+    except Exception as e:
+        return False, f"✗ Error: {str(e)}"
+
+
+def check_mahoraga() -> Tuple[bool, str]:
+    """Check if Quash package is available."""
+    try:
+        import mahoraga
+        return True, "✓ Quash package ready"
+    except ImportError:
+        return False, "✗ Quash package not installed"
+
+
+def install_mahoraga() -> Tuple[bool, str]:
+    """Install Quash package."""
+    try:
+        # Get the path to mahoraga directory
+        import os
+        mahoraga_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))),
+            "mahoraga"
+        )
+
+        if os.path.exists(mahoraga_path):
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "-e", mahoraga_path],
+                check=True,
+                capture_output=True
+            )
+            return True, "✓ Quash installed successfully"
+        else:
+            return False, f"✗ Quash directory not found at: {mahoraga_path}"
+    except subprocess.CalledProcessError as e:
+        return False, f"✗ Installation failed: {e.stderr.decode() if e.stderr else str(e)}"
+    except Exception as e:
+        return False, f"✗ Error: {str(e)}"
+
+
+async def build() -> Dict[str, Any]:
+    """
+    Setup and verify all dependencies required for Quash.
+    Auto-installs missing dependencies where possible.
+
+    Returns:
+        Dict with status and details of all dependencies
+    """
+    details = {}
+    all_ok = True
+
+    # Check Python version
+    python_ok, python_msg = check_python_version()
+    details["python"] = python_msg
+    if not python_ok:
+        all_ok = False
+
+    # Check and install ADB
+    adb_ok, adb_msg = check_adb()
+    if not adb_ok:
+        # Try to auto-install
+        install_ok, install_msg = install_adb()
+        details["adb"] = install_msg
+        if not install_ok:
+            all_ok = False
+    else:
+        details["adb"] = adb_msg
+
+    # Check and install Quash
+    mahoraga_ok, mahoraga_msg = check_mahoraga()
+    if not mahoraga_ok:
+        # Try to auto-install
+        install_ok, install_msg = install_mahoraga()
+        details["mahoraga"] = install_msg
+        if not install_ok:
+            all_ok = False
+    else:
+        details["mahoraga"] = mahoraga_msg
+
+    # Check portal APK (just verify it exists in mahoraga)
+    try:
+        from mahoraga.portal import use_portal_apk
+        details["portal_apk"] = "✓ Portal APK available"
+    except Exception as e:
+        details["portal_apk"] = f"✗ Portal APK not found: {str(e)}"
+        all_ok = False
+
+    # Determine overall status
+    if all_ok:
+        status = "success"
+        message = "✅ All dependencies ready! You can now use Quash."
+    else:
+        failed_items = [k for k, v in details.items() if v.startswith("✗")]
+        if len(failed_items) == len(details):
+            status = "failed"
+            message = f"❌ Setup failed. Missing: {', '.join(failed_items)}"
+        else:
+            status = "partial"
+            message = f"⚠️ Partially ready. Issues with: {', '.join(failed_items)}"
+
+    return {
+        "status": status,
+        "details": details,
+        "message": message
+    }

quash_mcp/tools/configure.py

@@ -0,0 +1,140 @@
+"""
+Configure tool - Manage agent configuration parameters.
+Allows users to set and update Quash agent execution parameters.
+"""
+
+from typing import Dict, Any, Optional
+from ..state import get_state
+
+
+# Valid configuration parameters and their types
+VALID_PARAMS = {
+    "quash_api_key": str,
+    "model": str,
+    "temperature": float,
+    "max_steps": int,
+    "vision": bool,
+    "reasoning": bool,
+    "reflection": bool,
+    "debug": bool,
+}
+
+
+def validate_config(config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    """
+    Validate configuration parameters.
+
+    Returns:
+        (is_valid, error_message)
+    """
+    for key, value in config.items():
+        if key not in VALID_PARAMS:
+            return False, f"Invalid parameter: '{key}'. Valid parameters are: {', '.join(VALID_PARAMS.keys())}"
+
+        expected_type = VALID_PARAMS[key]
+        if not isinstance(value, expected_type):
+            return False, f"Parameter '{key}' must be of type {expected_type.__name__}, got {type(value).__name__}"
+
+    # Validate specific constraints
+    if "temperature" in config:
+        temp = config["temperature"]
+        if not 0 <= temp <= 2:
+            return False, "temperature must be between 0 and 2"
+
+    if "max_steps" in config:
+        steps = config["max_steps"]
+        if steps < 1:
+            return False, "max_steps must be at least 1"
+
+    if "model" in config:
+        model = config["model"]
+        # Basic model name validation
+        if not model or not isinstance(model, str) or len(model) < 3:
+            return False, "Invalid model name"
+
+    return True, None
+
+
+async def configure(
+    quash_api_key: Optional[str] = None,
+    model: Optional[str] = None,
+    temperature: Optional[float] = None,
+    max_steps: Optional[int] = None,
+    vision: Optional[bool] = None,
+    reasoning: Optional[bool] = None,
+    reflection: Optional[bool] = None,
+    debug: Optional[bool] = None,
+) -> Dict[str, Any]:
+    """
+    Configure agent execution parameters.
+    Only updates parameters that are provided (not None).
+
+    Args:
+        quash_api_key: Quash API key for authentication and access
+        model: LLM model name (e.g., "openai/gpt-4o")
+        temperature: Temperature for LLM (0-2)
+        max_steps: Maximum number of execution steps
+        vision: Enable vision capabilities (screenshots)
+        reasoning: Enable planning with reasoning
+        reflection: Enable reflection for self-improvement
+        debug: Enable verbose debug logging
+
+    Returns:
+        Dict with configuration status and current settings
+    """
+    state = get_state()
+
+    # Collect provided parameters
+    updates = {}
+    if quash_api_key is not None:
+        updates["api_key"] = quash_api_key
+    if model is not None:
+        updates["model"] = model
+    if temperature is not None:
+        updates["temperature"] = temperature
+    if max_steps is not None:
+        updates["max_steps"] = max_steps
+    if vision is not None:
+        updates["vision"] = vision
+    if reasoning is not None:
+        updates["reasoning"] = reasoning
+    if reflection is not None:
+        updates["reflection"] = reflection
+    if debug is not None:
+        updates["debug"] = debug
+
+    # If no updates provided, just return current config
+    if not updates:
+        return {
+            "status": "no_changes",
+            "current_config": state.get_config_summary(),
+            "message": "ℹ️ No parameters provided. Current configuration unchanged."
+        }
+
+    # Validate updates (map api_key back to quash_api_key for validation)
+    validation_updates = updates.copy()
+    if "api_key" in validation_updates:
+        validation_updates["quash_api_key"] = validation_updates.pop("api_key")
+
+    is_valid, error_msg = validate_config(validation_updates)
+    if not is_valid:
+        return {
+            "status": "error",
+            "message": f"❌ Configuration error: {error_msg}",
+            "current_config": state.get_config_summary()
+        }
+
+    # Apply updates
+    state.update_config(**updates)
+
+    # Prepare response
+    updated_keys = list(updates.keys())
+    if "api_key" in updated_keys:
+        updated_keys[updated_keys.index("api_key")] = "quash_api_key"
+
+    return {
+        "status": "configured",
+        "updated_parameters": updated_keys,
+        "current_config": state.get_config_summary(),
+        "message": f"✅ Configuration updated: {', '.join(updated_keys)}"
+    }

quash_mcp/tools/connect.py

@@ -0,0 +1,153 @@
+"""
+Connect tool - Manage Android device connectivity.
+Connects to Android devices/emulators and verifies accessibility service.
+"""
+
+import subprocess
+from typing import Dict, Any, Optional
+from ..state import get_state
+
+
+def list_devices() -> list:
+    """List all connected Android devices."""
+    try:
+        from adbutils import adb
+        devices = adb.list()
+        return [{"serial": d.serial, "state": d.state} for d in devices]
+    except Exception as e:
+        return []
+
+
+def get_device_info(serial: str) -> Optional[Dict[str, str]]:
+    """Get detailed information about a device."""
+    try:
+        from adbutils import adb
+        device = adb.device(serial)
+
+        # Get device properties
+        model = device.prop.get("ro.product.model", "Unknown")
+        android_version = device.prop.get("ro.build.version.release", "Unknown")
+
+        return {
+            "serial": serial,
+            "model": model,
+            "android_version": android_version
+        }
+    except Exception as e:
+        return None
+
+
+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
+
+        device = adb.device(serial)
+        ping_portal(device, debug=False)
+        return True
+    except Exception:
+        return False
+
+
+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
+
+        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"
+    except Exception as e:
+        return False, f"Failed to setup portal: {str(e)}"
+
+
+async def connect(device_serial: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Connect to an Android device or emulator.
+    If device_serial is not provided, auto-selects if only one device is connected.
+
+    Args:
+        device_serial: Optional device serial number
+
+    Returns:
+        Dict with connection status and device information
+    """
+    state = get_state()
+
+    # List available devices
+    devices = list_devices()
+
+    if not devices:
+        return {
+            "status": "failed",
+            "message": "❌ No Android devices found. Please connect a device or start an emulator.",
+            "instructions": [
+                "To start an emulator: Open Android Studio > AVD Manager > Start",
+                "To connect a physical device: Enable USB debugging and connect via USB",
+                "To connect over WiFi: Run 'adb tcpip 5555' then 'adb connect <device-ip>:5555'"
+            ]
+        }
+
+    # Select device
+    selected_serial = device_serial
+    if not selected_serial:
+        if len(devices) == 1:
+            selected_serial = devices[0]["serial"]
+        else:
+            return {
+                "status": "failed",
+                "message": f"❌ Multiple devices found ({len(devices)}). Please specify which one to use.",
+                "available_devices": devices
+            }
+
+    # Verify device exists
+    if not any(d["serial"] == selected_serial for d in devices):
+        return {
+            "status": "failed",
+            "message": f"❌ Device '{selected_serial}' not found.",
+            "available_devices": devices
+        }
+
+    # Get device info
+    device_info = get_device_info(selected_serial)
+    if not device_info:
+        return {
+            "status": "failed",
+            "message": f"❌ Failed to get information for device '{selected_serial}'."
+        }
+
+    # Check portal accessibility service
+    portal_ready = check_portal_service(selected_serial)
+
+    if not portal_ready:
+        # Attempt to setup portal
+        setup_success, setup_msg = setup_portal(selected_serial)
+        if setup_success:
+            portal_ready = True
+            portal_message = "✓ Portal setup completed"
+        else:
+            portal_message = f"⚠️ Portal not ready: {setup_msg}"
+    else:
+        portal_message = "✓ Portal already enabled"
+
+    # Update state
+    state.device_serial = selected_serial
+    state.device_info = device_info
+    state.portal_ready = portal_ready
+
+    return {
+        "status": "connected" if portal_ready else "partial",
+        "device": device_info,
+        "portal_ready": portal_ready,
+        "portal_message": portal_message,
+        "message": f"✅ Connected to {device_info['model']} ({selected_serial})"
+    }

quash_mcp/tools/execute.py

@@ -0,0 +1,177 @@
+"""
+Execute tool - Run automation tasks via backend API.
+All AI/agent logic runs on the backend to protect business logic.
+"""
+
+from typing import Dict, Any, Callable, Optional
+from ..state import get_state
+from ..backend_client import get_backend_client
+
+
+async def execute(
+    task: str,
+    progress_callback: Optional[Callable[[str], None]] = None
+) -> Dict[str, Any]:
+    """
+    Execute an automation task on the connected Android device.
+
+    All AI execution happens on the backend - this keeps proprietary logic private.
+
+    Args:
+        task: Natural language task description
+        progress_callback: Optional callback for progress updates (not used in V2)
+
+    Returns:
+        Dict with execution result and details
+    """
+    state = get_state()
+    backend = get_backend_client()
+
+    # Check prerequisites
+    if not state.is_device_connected():
+        return {
+            "status": "error",
+            "message": "❌ No device connected. Please run 'connect' first.",
+            "prerequisite": "connect"
+        }
+
+    if not state.is_configured():
+        return {
+            "status": "error",
+            "message": "❌ Configuration incomplete. Please run 'configure' with your Quash API key.",
+            "prerequisite": "configure"
+        }
+
+    if not state.portal_ready:
+        return {
+            "status": "error",
+            "message": "⚠️ Portal accessibility service not ready. Please ensure it's enabled on the device.",
+            "prerequisite": "connect"
+        }
+
+    # Get API key and config from state
+    quash_api_key = state.config["api_key"]
+
+    # Validate API key with backend
+    validation_result = await backend.validate_api_key(quash_api_key)
+
+    if not validation_result.get("valid", False):
+        error_msg = validation_result.get("error", "Invalid API key")
+        return {
+            "status": "error",
+            "message": f"❌ API Key validation failed: {error_msg}",
+            "prerequisite": "configure"
+        }
+
+    # Check user credits
+    user_info = validation_result.get("user", {})
+    credits = user_info.get("credits", 0)
+
+    if credits <= 0:
+        return {
+            "status": "error",
+            "message": f"❌ Insufficient credits. Current balance: ${credits:.2f}. Please add credits at https://quashbugs.com",
+            "user": user_info
+        }
+
+    # Progress callback (for backward compatibility)
+    def log_progress(message: str):
+        """Send progress updates."""
+        if progress_callback:
+            progress_callback(message)
+
+    log_progress(f"✅ API Key validated - Credits: ${credits:.2f}")
+    log_progress(f"👤 User: {user_info.get('name', 'Unknown')}")
+    log_progress(f"🚀 Starting task: {task}")
+    log_progress(f"📱 Device: {state.device_serial}")
+    log_progress(f"🧠 Model: {state.config['model']}")
+    log_progress("⚙️ Executing on backend...")
+
+    try:
+        # ============================================================
+        # EXECUTE ON BACKEND - ALL AI LOGIC IS PRIVATE
+        # The backend handles: LLM setup, agent initialization,
+        # execution, pricing, usage tracking, credit deduction
+        # ============================================================
+
+        result = await backend.execute_task(
+            api_key=quash_api_key,
+            task=task,
+            device_serial=state.device_serial,
+            config={
+                "model": state.config["model"],
+                "temperature": state.config["temperature"],
+                "vision": state.config["vision"],
+                "reasoning": state.config["reasoning"],
+                "reflection": state.config["reflection"],
+                "debug": state.config["debug"]
+            }
+        )
+
+        # Process result
+        status = result.get("status")
+        message = result.get("message", "")
+        steps_taken = result.get("steps_taken", 0)
+        final_message = result.get("final_message", "")
+        tokens = result.get("tokens", {})
+        cost = result.get("cost", 0.0)
+        duration = result.get("duration_seconds", 0.0)
+        error = result.get("error")
+
+        # Log usage info
+        if tokens and cost:
+            total_tokens = tokens.get("total", 0)
+            log_progress(f"💰 Usage: {total_tokens} tokens, ${cost:.4f}")
+
+        # Return formatted result
+        if status == "success":
+            log_progress(f"✅ Task completed successfully in {steps_taken} steps")
+            return {
+                "status": "success",
+                "steps_taken": steps_taken,
+                "final_message": final_message,
+                "message": message,
+                "tokens": tokens,
+                "cost": cost,
+                "duration_seconds": duration
+            }
+        elif status == "failed":
+            log_progress(f"❌ Task failed: {final_message}")
+            return {
+                "status": "failed",
+                "steps_taken": steps_taken,
+                "final_message": final_message,
+                "message": message,
+                "tokens": tokens,
+                "cost": cost,
+                "duration_seconds": duration
+            }
+        elif status == "interrupted":
+            log_progress("⏹️ Task interrupted")
+            return {
+                "status": "interrupted",
+                "message": message
+            }
+        else:  # error
+            log_progress(f"💥 Error: {error or message}")
+            return {
+                "status": "error",
+                "message": message,
+                "error": error or message
+            }
+
+    except KeyboardInterrupt:
+        log_progress("⏹️ Task interrupted by user")
+        return {
+            "status": "interrupted",
+            "message": "⏹️ Task execution interrupted"
+        }
+
+    except Exception as e:
+        error_msg = str(e)
+        log_progress(f"💥 Error: {error_msg}")
+        return {
+            "status": "error",
+            "message": f"💥 Execution error: {error_msg}",
+            "error": error_msg
+        }