code-puppy 0.0.127__py3-none-any.whl → 0.0.129__py3-none-any.whl

code_puppy/mcp/dashboard.py

@@ -0,0 +1,291 @@
+"""
+MCP Dashboard Implementation
+
+Provides visual status dashboard for MCP servers using Rich tables.
+"""
+
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+from rich.table import Table
+from rich.console import Console
+from rich import box
+
+from .status_tracker import ServerState, Event
+from .manager import get_mcp_manager
+
+
+class MCPDashboard:
+    """Visual dashboard for MCP server status monitoring"""
+    
+    def __init__(self):
+        """Initialize the MCP Dashboard"""
+        self.console = Console()
+    
+    def render_dashboard(self) -> Table:
+        """
+        Render the main MCP server status dashboard
+        
+        Returns:
+            Table: Rich table with server status information
+        """
+        # Create the main table
+        table = Table(
+            title="MCP Server Status Dashboard",
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold blue",
+            title_style="bold cyan"
+        )
+        
+        # Define columns
+        table.add_column("Name", style="white", no_wrap=True, min_width=10)
+        table.add_column("Type", style="white", no_wrap=True, width=8)
+        table.add_column("State", style="white", no_wrap=True, width=8)
+        table.add_column("Health", style="white", no_wrap=True, width=8)
+        table.add_column("Uptime", style="white", no_wrap=True, width=10)
+        table.add_column("Latency", style="white", no_wrap=True, width=10)
+        
+        # Get manager and server info
+        try:
+            manager = get_mcp_manager()
+            servers = manager.list_servers()
+            
+            if not servers:
+                # Empty state
+                table.add_row(
+                    "[dim]No servers configured[/dim]",
+                    "-", "-", "-", "-", "-"
+                )
+            else:
+                # Add row for each server
+                for server in servers:
+                    row_data = self.render_server_row(server)
+                    table.add_row(*row_data)
+                    
+        except Exception as e:
+            # Error state
+            table.add_row(
+                "[red]Error loading servers[/red]",
+                "-", "-", "-", "-", f"[red]{str(e)}[/red]"
+            )
+        
+        return table
+    
+    def render_server_row(self, server) -> List[str]:
+        """
+        Render a single server row for the dashboard
+        
+        Args:
+            server: ServerInfo object with server details
+            
+        Returns:
+            List[str]: Formatted row data for the table
+        """
+        # Server name
+        name = server.name or server.id[:8]
+        
+        # Server type
+        server_type = server.type.upper() if server.type else "UNK"
+        
+        # State indicator
+        state_indicator = self.render_state_indicator(server.state)
+        
+        # Health indicator
+        health_indicator = self.render_health_indicator(server.health)
+        
+        # Uptime
+        uptime_str = self.format_uptime(server.start_time) if server.start_time else "-"
+        
+        # Latency
+        latency_str = self.format_latency(server.latency_ms) if server.latency_ms is not None else "-"
+        
+        return [
+            name,
+            server_type,
+            state_indicator,
+            health_indicator,
+            uptime_str,
+            latency_str
+        ]
+    
+    def render_health_indicator(self, health: Optional[Dict]) -> str:
+        """
+        Render health status indicator
+        
+        Args:
+            health: Health status dictionary or None
+            
+        Returns:
+            str: Formatted health indicator with color
+        """
+        if not health:
+            return "[dim]?[/dim]"
+        
+        is_healthy = health.get('is_healthy', False)
+        error = health.get('error')
+        
+        if is_healthy:
+            return "[green]✓[/green]"
+        elif error:
+            return "[red]✗[/red]"
+        else:
+            return "[yellow]?[/yellow]"
+    
+    def render_state_indicator(self, state: ServerState) -> str:
+        """
+        Render server state indicator
+        
+        Args:
+            state: Current server state
+            
+        Returns:
+            str: Formatted state indicator with color and symbol
+        """
+        indicators = {
+            ServerState.RUNNING: "[green]✓ Run[/green]",
+            ServerState.STOPPED: "[red]✗ Stop[/red]",
+            ServerState.ERROR: "[red]⚠ Err[/red]",
+            ServerState.STARTING: "[yellow]⏳ Start[/yellow]",
+            ServerState.STOPPING: "[yellow]⏳ Stop[/yellow]",
+            ServerState.QUARANTINED: "[yellow]⏸ Quar[/yellow]",
+        }
+        
+        return indicators.get(state, "[dim]? Unk[/dim]")
+    
+    def render_metrics_summary(self, metrics: Dict) -> str:
+        """
+        Render a summary of server metrics
+        
+        Args:
+            metrics: Dictionary of server metrics
+            
+        Returns:
+            str: Formatted metrics summary
+        """
+        if not metrics:
+            return "No metrics"
+        
+        parts = []
+        
+        # Request count
+        if 'request_count' in metrics:
+            parts.append(f"Req: {metrics['request_count']}")
+        
+        # Error rate
+        if 'error_rate' in metrics:
+            error_rate = metrics['error_rate']
+            if error_rate > 0.1:  # 10%
+                parts.append(f"[red]Err: {error_rate:.1%}[/red]")
+            elif error_rate > 0.05:  # 5%
+                parts.append(f"[yellow]Err: {error_rate:.1%}[/yellow]")
+            else:
+                parts.append(f"[green]Err: {error_rate:.1%}[/green]")
+        
+        # Response time
+        if 'avg_response_time' in metrics:
+            avg_time = metrics['avg_response_time']
+            parts.append(f"Avg: {avg_time:.0f}ms")
+        
+        return " | ".join(parts) if parts else "No data"
+    
+    def format_uptime(self, start_time: datetime) -> str:
+        """
+        Format uptime duration in human readable format
+        
+        Args:
+            start_time: Server start timestamp
+            
+        Returns:
+            str: Formatted uptime string (e.g., "2h 15m")
+        """
+        if not start_time:
+            return "-"
+        
+        try:
+            uptime = datetime.now() - start_time
+            
+            # Handle negative uptime (clock skew, etc.)
+            if uptime.total_seconds() < 0:
+                return "0s"
+            
+            # Format based on duration
+            total_seconds = int(uptime.total_seconds())
+            
+            if total_seconds < 60:  # Less than 1 minute
+                return f"{total_seconds}s"
+            elif total_seconds < 3600:  # Less than 1 hour
+                minutes = total_seconds // 60
+                seconds = total_seconds % 60
+                if seconds > 0:
+                    return f"{minutes}m {seconds}s"
+                else:
+                    return f"{minutes}m"
+            elif total_seconds < 86400:  # Less than 1 day
+                hours = total_seconds // 3600
+                minutes = (total_seconds % 3600) // 60
+                if minutes > 0:
+                    return f"{hours}h {minutes}m"
+                else:
+                    return f"{hours}h"
+            else:  # 1 day or more
+                days = total_seconds // 86400
+                hours = (total_seconds % 86400) // 3600
+                if hours > 0:
+                    return f"{days}d {hours}h"
+                else:
+                    return f"{days}d"
+                    
+        except Exception:
+            return "?"
+    
+    def format_latency(self, latency_ms: float) -> str:
+        """
+        Format latency in human readable format
+        
+        Args:
+            latency_ms: Latency in milliseconds
+            
+        Returns:
+            str: Formatted latency string with color coding
+        """
+        if latency_ms is None:
+            return "-"
+        
+        try:
+            if latency_ms < 0:
+                return "invalid"
+            elif latency_ms < 50:  # Fast
+                return f"[green]{latency_ms:.0f}ms[/green]"
+            elif latency_ms < 200:  # Acceptable
+                return f"[yellow]{latency_ms:.0f}ms[/yellow]"
+            elif latency_ms < 1000:  # Slow
+                return f"[red]{latency_ms:.0f}ms[/red]"
+            elif latency_ms >= 30000:  # Timeout (30s+)
+                return "[red]timeout[/red]"
+            else:  # Very slow
+                seconds = latency_ms / 1000
+                return f"[red]{seconds:.1f}s[/red]"
+                
+        except (ValueError, TypeError):
+            return "error"
+    
+    def print_dashboard(self) -> None:
+        """Print the dashboard to console"""
+        table = self.render_dashboard()
+        self.console.print(table)
+        self.console.print()  # Add spacing
+    
+    def get_dashboard_string(self) -> str:
+        """
+        Get dashboard as a string for programmatic use
+        
+        Returns:
+            str: Dashboard rendered as plain text
+        """
+        # Create a console that captures output
+        console = Console(file=None, width=80)
+        
+        with console.capture() as capture:
+            console.print(self.render_dashboard())
+        
+        return capture.get()

code_puppy/mcp/error_isolation.py

@@ -0,0 +1,360 @@
+"""
+MCP Error Isolation System
+
+This module provides error isolation for MCP server calls to prevent
+server errors from crashing the application. It implements quarantine
+logic with exponential backoff for failed servers.
+"""
+
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Optional
+from enum import Enum
+import traceback
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ErrorStats:
+    """Statistics for MCP server errors and quarantine status."""
+    total_errors: int = 0
+    consecutive_errors: int = 0
+    last_error: Optional[datetime] = None
+    error_types: Dict[str, int] = field(default_factory=dict)
+    quarantine_count: int = 0
+    quarantine_until: Optional[datetime] = None
+
+
+class ErrorCategory(Enum):
+    """Categories of errors that can be isolated."""
+    NETWORK = "network"
+    PROTOCOL = "protocol"
+    SERVER = "server"
+    RATE_LIMIT = "rate_limit"
+    AUTHENTICATION = "authentication"
+    UNKNOWN = "unknown"
+
+
+class MCPErrorIsolator:
+    """
+    Isolates MCP server errors to prevent application crashes.
+    
+    Features:
+    - Quarantine servers after consecutive failures
+    - Exponential backoff for quarantine duration
+    - Error categorization and tracking
+    - Automatic recovery after successful calls
+    """
+    
+    def __init__(self, quarantine_threshold: int = 5, max_quarantine_minutes: int = 30):
+        """
+        Initialize the error isolator.
+        
+        Args:
+            quarantine_threshold: Number of consecutive errors to trigger quarantine
+            max_quarantine_minutes: Maximum quarantine duration in minutes
+        """
+        self.quarantine_threshold = quarantine_threshold
+        self.max_quarantine_duration = timedelta(minutes=max_quarantine_minutes)
+        self.server_stats: Dict[str, ErrorStats] = {}
+        self._lock = asyncio.Lock()
+        
+        logger.info(
+            f"MCPErrorIsolator initialized with threshold={quarantine_threshold}, "
+            f"max_quarantine={max_quarantine_minutes}min"
+        )
+    
+    async def isolated_call(self, server_id: str, func: Callable, *args, **kwargs) -> Any:
+        """
+        Execute a function call with error isolation.
+        
+        Args:
+            server_id: ID of the MCP server making the call
+            func: Function to execute
+            *args: Arguments for the function
+            **kwargs: Keyword arguments for the function
+            
+        Returns:
+            Result of the function call
+            
+        Raises:
+            Exception: If the server is quarantined or the call fails
+        """
+        async with self._lock:
+            # Check if server is quarantined
+            if self.is_quarantined(server_id):
+                quarantine_until = self.server_stats[server_id].quarantine_until
+                raise QuarantinedServerError(
+                    f"Server {server_id} is quarantined until {quarantine_until}"
+                )
+        
+        try:
+            # Execute the function
+            if asyncio.iscoroutinefunction(func):
+                result = await func(*args, **kwargs)
+            else:
+                result = func(*args, **kwargs)
+            
+            # Record success
+            async with self._lock:
+                await self._record_success(server_id)
+            
+            return result
+            
+        except Exception as error:
+            # Record and categorize the error
+            async with self._lock:
+                await self._record_error(server_id, error)
+            
+            # Re-raise the error
+            raise
+    
+    async def quarantine_server(self, server_id: str, duration: int) -> None:
+        """
+        Manually quarantine a server for a specific duration.
+        
+        Args:
+            server_id: ID of the server to quarantine
+            duration: Quarantine duration in seconds
+        """
+        async with self._lock:
+            stats = self._get_or_create_stats(server_id)
+            stats.quarantine_until = datetime.now() + timedelta(seconds=duration)
+            stats.quarantine_count += 1
+            
+            logger.warning(
+                f"Server {server_id} quarantined for {duration}s "
+                f"(count: {stats.quarantine_count})"
+            )
+    
+    def is_quarantined(self, server_id: str) -> bool:
+        """
+        Check if a server is currently quarantined.
+        
+        Args:
+            server_id: ID of the server to check
+            
+        Returns:
+            True if the server is quarantined, False otherwise
+        """
+        if server_id not in self.server_stats:
+            return False
+        
+        stats = self.server_stats[server_id]
+        if stats.quarantine_until is None:
+            return False
+        
+        # Check if quarantine has expired
+        if datetime.now() >= stats.quarantine_until:
+            stats.quarantine_until = None
+            return False
+        
+        return True
+    
+    async def release_quarantine(self, server_id: str) -> None:
+        """
+        Manually release a server from quarantine.
+        
+        Args:
+            server_id: ID of the server to release
+        """
+        async with self._lock:
+            if server_id in self.server_stats:
+                self.server_stats[server_id].quarantine_until = None
+                logger.info(f"Server {server_id} released from quarantine")
+    
+    def get_error_stats(self, server_id: str) -> ErrorStats:
+        """
+        Get error statistics for a server.
+        
+        Args:
+            server_id: ID of the server
+            
+        Returns:
+            ErrorStats object with current statistics
+        """
+        if server_id not in self.server_stats:
+            return ErrorStats()
+        
+        return self.server_stats[server_id]
+    
+    def should_quarantine(self, server_id: str) -> bool:
+        """
+        Check if a server should be quarantined based on error count.
+        
+        Args:
+            server_id: ID of the server to check
+            
+        Returns:
+            True if the server should be quarantined
+        """
+        if server_id not in self.server_stats:
+            return False
+        
+        stats = self.server_stats[server_id]
+        return stats.consecutive_errors >= self.quarantine_threshold
+    
+    def _get_or_create_stats(self, server_id: str) -> ErrorStats:
+        """Get or create error stats for a server."""
+        if server_id not in self.server_stats:
+            self.server_stats[server_id] = ErrorStats()
+        return self.server_stats[server_id]
+    
+    async def _record_success(self, server_id: str) -> None:
+        """Record a successful call and reset consecutive error count."""
+        stats = self._get_or_create_stats(server_id)
+        stats.consecutive_errors = 0
+        
+        logger.debug(f"Success recorded for server {server_id}, consecutive errors reset")
+    
+    async def _record_error(self, server_id: str, error: Exception) -> None:
+        """Record an error and potentially quarantine the server."""
+        stats = self._get_or_create_stats(server_id)
+        
+        # Update error statistics
+        stats.total_errors += 1
+        stats.consecutive_errors += 1
+        stats.last_error = datetime.now()
+        
+        # Categorize the error
+        error_category = self._categorize_error(error)
+        error_type = error_category.value
+        stats.error_types[error_type] = stats.error_types.get(error_type, 0) + 1
+        
+        logger.warning(
+            f"Error recorded for server {server_id}: {error_type} - {str(error)} "
+            f"(consecutive: {stats.consecutive_errors})"
+        )
+        
+        # Check if quarantine is needed
+        if self.should_quarantine(server_id):
+            quarantine_duration = self._calculate_quarantine_duration(stats.quarantine_count)
+            stats.quarantine_until = datetime.now() + timedelta(seconds=quarantine_duration)
+            stats.quarantine_count += 1
+            
+            logger.error(
+                f"Server {server_id} quarantined for {quarantine_duration}s "
+                f"after {stats.consecutive_errors} consecutive errors "
+                f"(quarantine count: {stats.quarantine_count})"
+            )
+    
+    def _categorize_error(self, error: Exception) -> ErrorCategory:
+        """
+        Categorize an error based on its type and properties.
+        
+        Args:
+            error: The exception to categorize
+            
+        Returns:
+            ErrorCategory enum value
+        """
+        error_type = type(error).__name__.lower()
+        error_message = str(error).lower()
+        
+        # Network errors
+        if any(keyword in error_type for keyword in [
+            'connection', 'timeout', 'network', 'socket', 'dns', 'ssl'
+        ]):
+            return ErrorCategory.NETWORK
+        
+        if any(keyword in error_message for keyword in [
+            'connection', 'timeout', 'network', 'unreachable', 'refused'
+        ]):
+            return ErrorCategory.NETWORK
+        
+        # Protocol errors
+        if any(keyword in error_type for keyword in [
+            'json', 'decode', 'parse', 'schema', 'validation', 'protocol'
+        ]):
+            return ErrorCategory.PROTOCOL
+        
+        if any(keyword in error_message for keyword in [
+            'json', 'decode', 'parse', 'invalid', 'malformed', 'schema'
+        ]):
+            return ErrorCategory.PROTOCOL
+        
+        # Authentication errors
+        if any(keyword in error_type for keyword in [
+            'auth', 'permission', 'unauthorized', 'forbidden'
+        ]):
+            return ErrorCategory.AUTHENTICATION
+        
+        if any(keyword in error_message for keyword in [
+            '401', '403', 'unauthorized', 'forbidden', 'authentication', 'permission'
+        ]):
+            return ErrorCategory.AUTHENTICATION
+        
+        # Rate limit errors
+        if any(keyword in error_type for keyword in ['rate', 'limit', 'throttle']):
+            return ErrorCategory.RATE_LIMIT
+        
+        if any(keyword in error_message for keyword in [
+            '429', 'rate limit', 'too many requests', 'throttle'
+        ]):
+            return ErrorCategory.RATE_LIMIT
+        
+        # Server errors (5xx responses)
+        if any(keyword in error_message for keyword in [
+            '500', '501', '502', '503', '504', '505', 'internal server error',
+            'bad gateway', 'service unavailable', 'gateway timeout'
+        ]):
+            return ErrorCategory.SERVER
+        
+        if any(keyword in error_type for keyword in ['server', 'internal']):
+            return ErrorCategory.SERVER
+        
+        # Default to unknown
+        return ErrorCategory.UNKNOWN
+    
+    def _calculate_quarantine_duration(self, quarantine_count: int) -> int:
+        """
+        Calculate quarantine duration using exponential backoff.
+        
+        Args:
+            quarantine_count: Number of times this server has been quarantined
+            
+        Returns:
+            Quarantine duration in seconds
+        """
+        # Base duration: 30 seconds
+        base_duration = 30
+        
+        # Exponential backoff: 30s, 60s, 120s, 240s, etc.
+        duration = base_duration * (2 ** quarantine_count)
+        
+        # Cap at maximum duration (convert to seconds)
+        max_seconds = int(self.max_quarantine_duration.total_seconds())
+        duration = min(duration, max_seconds)
+        
+        logger.debug(
+            f"Calculated quarantine duration: {duration}s "
+            f"(count: {quarantine_count}, max: {max_seconds}s)"
+        )
+        
+        return duration
+
+
+class QuarantinedServerError(Exception):
+    """Raised when attempting to call a quarantined server."""
+    pass
+
+
+# Global isolator instance
+_isolator_instance: Optional[MCPErrorIsolator] = None
+
+
+def get_error_isolator() -> MCPErrorIsolator:
+    """
+    Get the global MCPErrorIsolator instance.
+    
+    Returns:
+        MCPErrorIsolator instance
+    """
+    global _isolator_instance
+    if _isolator_instance is None:
+        _isolator_instance = MCPErrorIsolator()
+    return _isolator_instance