code-puppy 0.0.135__py3-none-any.whl → 0.0.137__py3-none-any.whl

code_puppy/command_line/mcp/status_command.py

@@ -0,0 +1,185 @@
+"""
+MCP Status Command - Shows detailed status for MCP servers.
+"""
+
+import logging
+from datetime import datetime
+from typing import List, Optional
+
+from rich.panel import Panel
+
+from code_puppy.mcp.managed_server import ServerState
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .list_command import ListCommand
+from .utils import (
+    find_server_id_by_name,
+    format_state_indicator,
+    format_uptime,
+    suggest_similar_servers,
+)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StatusCommand(MCPCommandBase):
+    """
+    Command handler for showing MCP server status.
+
+    Shows detailed status for a specific server or brief status for all servers.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Show detailed status for a specific server or all servers.
+
+        Args:
+            args: Command arguments, expects [server_name] (optional)
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            if args:
+                # Show detailed status for specific server
+                server_name = args[0]
+                server_id = find_server_id_by_name(self.manager, server_name)
+
+                if not server_id:
+                    emit_info(
+                        f"Server '{server_name}' not found", message_group=group_id
+                    )
+                    suggest_similar_servers(
+                        self.manager, server_name, group_id=group_id
+                    )
+                    return
+
+                self._show_detailed_server_status(server_id, server_name, group_id)
+            else:
+                # Show brief status for all servers
+                list_command = ListCommand()
+                list_command.execute([], group_id=group_id)
+
+        except Exception as e:
+            logger.error(f"Error showing server status: {e}")
+            emit_info(f"Failed to get server status: {e}", message_group=group_id)
+
+    def _show_detailed_server_status(
+        self, server_id: str, server_name: str, group_id: Optional[str] = None
+    ) -> None:
+        """
+        Show comprehensive status information for a specific server.
+
+        Args:
+            server_id: ID of the server
+            server_name: Name of the server
+            group_id: Optional message group ID
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            status = self.manager.get_server_status(server_id)
+
+            if not status.get("exists", True):
+                emit_info(
+                    f"Server '{server_name}' not found or not accessible",
+                    message_group=group_id,
+                )
+                return
+
+            # Create detailed status panel
+            status_lines = []
+
+            # Basic information
+            status_lines.append(f"[bold]Server:[/bold] {server_name}")
+            status_lines.append(f"[bold]ID:[/bold] {server_id}")
+            status_lines.append(
+                f"[bold]Type:[/bold] {status.get('type', 'unknown').upper()}"
+            )
+
+            # State and status
+            state = status.get("state", "unknown")
+            state_display = format_state_indicator(
+                ServerState(state)
+                if state in [s.value for s in ServerState]
+                else ServerState.STOPPED
+            )
+            status_lines.append(f"[bold]State:[/bold] {state_display}")
+
+            enabled = status.get("enabled", False)
+            status_lines.append(
+                f"[bold]Enabled:[/bold] {'✓ Yes' if enabled else '✗ No'}"
+            )
+
+            # Check async lifecycle manager status if available
+            try:
+                from code_puppy.mcp.async_lifecycle import get_lifecycle_manager
+
+                lifecycle_mgr = get_lifecycle_manager()
+                if lifecycle_mgr.is_running(server_id):
+                    status_lines.append(
+                        "[bold]Process:[/bold] [green]✓ Active (subprocess/connection running)[/green]"
+                    )
+                else:
+                    status_lines.append("[bold]Process:[/bold] [dim]Not active[/dim]")
+            except Exception:
+                pass  # Lifecycle manager not available
+
+            quarantined = status.get("quarantined", False)
+            if quarantined:
+                status_lines.append("[bold]Quarantined:[/bold] [yellow]⚠ Yes[/yellow]")
+
+            # Timing information
+            uptime = status.get("tracker_uptime")
+            if uptime:
+                uptime_str = format_uptime(
+                    uptime.total_seconds()
+                    if hasattr(uptime, "total_seconds")
+                    else uptime
+                )
+                status_lines.append(f"[bold]Uptime:[/bold] {uptime_str}")
+
+            # Error information
+            error_msg = status.get("error_message")
+            if error_msg:
+                status_lines.append(f"[bold]Error:[/bold] [red]{error_msg}[/red]")
+
+            # Event information
+            event_count = status.get("recent_events_count", 0)
+            status_lines.append(f"[bold]Recent Events:[/bold] {event_count}")
+
+            # Metadata
+            metadata = status.get("tracker_metadata", {})
+            if metadata:
+                status_lines.append(f"[bold]Metadata:[/bold] {len(metadata)} keys")
+
+            # Create and show the panel
+            panel_content = "\n".join(status_lines)
+            panel = Panel(
+                panel_content, title=f"🔌 {server_name} Status", border_style="cyan"
+            )
+
+            emit_info(panel, message_group=group_id)
+
+            # Show recent events if available
+            recent_events = status.get("recent_events", [])
+            if recent_events:
+                emit_info("\n📋 Recent Events:", message_group=group_id)
+                for event in recent_events[-5:]:  # Show last 5 events
+                    timestamp = datetime.fromisoformat(event["timestamp"])
+                    time_str = timestamp.strftime("%H:%M:%S")
+                    emit_info(
+                        f"  {time_str}: {event['message']}", message_group=group_id
+                    )
+
+        except Exception as e:
+            logger.error(
+                f"Error getting detailed status for server '{server_name}': {e}"
+            )
+            emit_info(
+                f"[red]Error getting server status: {e}[/red]", message_group=group_id
+            )

code_puppy/command_line/mcp/stop_all_command.py

@@ -0,0 +1,109 @@
+"""
+MCP Stop All Command - Stops all running MCP servers.
+"""
+
+import logging
+import time
+from typing import List, Optional
+
+from code_puppy.mcp.managed_server import ServerState
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StopAllCommand(MCPCommandBase):
+    """
+    Command handler for stopping all MCP servers.
+
+    Stops all running MCP servers and provides a summary of results.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Stop all running MCP servers.
+
+        Args:
+            args: Command arguments (unused)
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            servers = self.manager.list_servers()
+
+            if not servers:
+                emit_info("No servers registered", message_group=group_id)
+                return
+
+            stopped_count = 0
+            failed_count = 0
+
+            # Count running servers
+            running_servers = [s for s in servers if s.state == ServerState.RUNNING]
+
+            if not running_servers:
+                emit_info("No servers are currently running", message_group=group_id)
+                return
+
+            emit_info(
+                f"Stopping {len(running_servers)} running server(s)...",
+                message_group=group_id,
+            )
+
+            for server_info in running_servers:
+                server_id = server_info.id
+                server_name = server_info.name
+
+                # Try to stop the server
+                success = self.manager.stop_server_sync(server_id)
+
+                if success:
+                    stopped_count += 1
+                    emit_info(f"  ✓ Stopped: {server_name}", message_group=group_id)
+                else:
+                    failed_count += 1
+                    emit_info(f"  ✗ Failed: {server_name}", message_group=group_id)
+
+            # Summary
+            emit_info("", message_group=group_id)
+            if stopped_count > 0:
+                emit_info(f"Stopped {stopped_count} server(s)", message_group=group_id)
+            if failed_count > 0:
+                emit_info(
+                    f"Failed to stop {failed_count} server(s)", message_group=group_id
+                )
+
+            # Reload agent if any servers were stopped
+            if stopped_count > 0:
+                # Give async tasks a moment to complete before reloading agent
+                try:
+                    import asyncio
+
+                    asyncio.get_running_loop()  # Check if in async context
+                    # If we're in async context, wait a bit for servers to stop
+                    time.sleep(0.5)  # Small delay to let async tasks progress
+                except RuntimeError:
+                    pass  # No async loop, servers will stop when needed
+
+                try:
+                    from code_puppy.agents.runtime_manager import (
+                        get_runtime_agent_manager,
+                    )
+
+                    manager = get_runtime_agent_manager()
+                    manager.reload_agent()
+                    emit_info(
+                        "[dim]Agent reloaded with updated servers[/dim]",
+                        message_group=group_id,
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not reload agent: {e}")
+
+        except Exception as e:
+            logger.error(f"Error stopping all servers: {e}")
+            emit_info(f"Failed to stop servers: {e}", message_group=group_id)

code_puppy/command_line/mcp/stop_command.py

@@ -0,0 +1,79 @@
+"""
+MCP Stop Command - Stops a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StopCommand(MCPCommandBase):
+    """
+    Command handler for stopping MCP servers.
+
+    Stops a specific MCP server by name and reloads the agent.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Stop a specific MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info(
+                "[yellow]Usage: /mcp stop <server_name>[/yellow]",
+                message_group=group_id,
+            )
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(f"Server '{server_name}' not found", message_group=group_id)
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Stop the server (disable and stop process)
+            success = self.manager.stop_server_sync(server_id)
+
+            if success:
+                emit_info(f"✓ Stopped server: {server_name}", message_group=group_id)
+
+                # Reload the agent to remove the disabled server
+                try:
+                    from code_puppy.agents.runtime_manager import (
+                        get_runtime_agent_manager,
+                    )
+
+                    manager = get_runtime_agent_manager()
+                    manager.reload_agent()
+                    emit_info(
+                        "[dim]Agent reloaded with updated servers[/dim]",
+                        message_group=group_id,
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not reload agent: {e}")
+            else:
+                emit_info(
+                    f"✗ Failed to stop server: {server_name}", message_group=group_id
+                )
+
+        except Exception as e:
+            logger.error(f"Error stopping server '{server_name}': {e}")
+            emit_info(f"[red]Failed to stop server: {e}[/red]", message_group=group_id)

code_puppy/command_line/mcp/test_command.py

@@ -0,0 +1,107 @@
+"""
+MCP Test Command - Tests connectivity to a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class TestCommand(MCPCommandBase):
+    """
+    Command handler for testing MCP server connectivity.
+
+    Tests connectivity and basic functionality of a specific MCP server.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Test connectivity to a specific MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info("Usage: /mcp test <server_name>", message_group=group_id)
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(f"Server '{server_name}' not found", message_group=group_id)
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Get managed server
+            managed_server = self.manager.get_server(server_id)
+            if not managed_server:
+                emit_info(
+                    f"Server '{server_name}' not accessible", message_group=group_id
+                )
+                return
+
+            emit_info(
+                f"🔍 Testing connectivity to server: {server_name}",
+                message_group=group_id,
+            )
+
+            # Basic connectivity test - try to get the pydantic server
+            try:
+                managed_server.get_pydantic_server()  # Test server instantiation
+                emit_info(
+                    "✓ Server instance created successfully", message_group=group_id
+                )
+
+                # Try to get server info if available
+                emit_info(
+                    f"  • Server type: {managed_server.config.type}",
+                    message_group=group_id,
+                )
+                emit_info(
+                    f"  • Server enabled: {managed_server.is_enabled()}",
+                    message_group=group_id,
+                )
+                emit_info(
+                    f"  • Server quarantined: {managed_server.is_quarantined()}",
+                    message_group=group_id,
+                )
+
+                if not managed_server.is_enabled():
+                    emit_info(
+                        "  • Server is disabled - enable it with '/mcp start'",
+                        message_group=group_id,
+                    )
+
+                if managed_server.is_quarantined():
+                    emit_info(
+                        "  • Server is quarantined - may have recent errors",
+                        message_group=group_id,
+                    )
+
+                emit_info(
+                    f"✓ Connectivity test passed for: {server_name}",
+                    message_group=group_id,
+                )
+
+            except Exception as test_error:
+                emit_info(
+                    f"✗ Connectivity test failed: {test_error}", message_group=group_id
+                )
+
+        except Exception as e:
+            logger.error(f"Error testing server '{server_name}': {e}")
+            emit_info(f"[red]Error testing server: {e}[/red]", message_group=group_id)

code_puppy/command_line/mcp/utils.py

@@ -0,0 +1,129 @@
+"""
+MCP Command Utilities - Shared helper functions for MCP command handlers.
+
+Provides common utility functions used across multiple MCP command modules.
+"""
+
+from typing import Optional
+
+from rich.text import Text
+
+from code_puppy.mcp.managed_server import ServerState
+
+
+def format_state_indicator(state: ServerState) -> Text:
+    """
+    Format a server state with appropriate color and icon.
+
+    Args:
+        state: Server state to format
+
+    Returns:
+        Rich Text object with colored state indicator
+    """
+    state_map = {
+        ServerState.RUNNING: ("✓ Run", "green"),
+        ServerState.STOPPED: ("✗ Stop", "red"),
+        ServerState.STARTING: ("↗ Start", "yellow"),
+        ServerState.STOPPING: ("↙ Stop", "yellow"),
+        ServerState.ERROR: ("⚠ Err", "red"),
+        ServerState.QUARANTINED: ("⏸ Quar", "yellow"),
+    }
+
+    display, color = state_map.get(state, ("? Unk", "dim"))
+    return Text(display, style=color)
+
+
+def format_uptime(uptime_seconds: Optional[float]) -> str:
+    """
+    Format uptime in a human-readable format.
+
+    Args:
+        uptime_seconds: Uptime in seconds, or None
+
+    Returns:
+        Formatted uptime string
+    """
+    if uptime_seconds is None or uptime_seconds <= 0:
+        return "-"
+
+    # Convert to readable format
+    if uptime_seconds < 60:
+        return f"{int(uptime_seconds)}s"
+    elif uptime_seconds < 3600:
+        minutes = int(uptime_seconds // 60)
+        seconds = int(uptime_seconds % 60)
+        return f"{minutes}m {seconds}s"
+    else:
+        hours = int(uptime_seconds // 3600)
+        minutes = int((uptime_seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"
+
+
+def find_server_id_by_name(manager, server_name: str) -> Optional[str]:
+    """
+    Find a server ID by its name.
+
+    Args:
+        manager: MCP manager instance
+        server_name: Name of the server to find
+
+    Returns:
+        Server ID if found, None otherwise
+    """
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        servers = manager.list_servers()
+        for server in servers:
+            if server.name.lower() == server_name.lower():
+                return server.id
+        return None
+    except Exception as e:
+        logger.error(f"Error finding server by name '{server_name}': {e}")
+        return None
+
+
+def suggest_similar_servers(
+    manager, server_name: str, group_id: Optional[str] = None
+) -> None:
+    """
+    Suggest similar server names when a server is not found.
+
+    Args:
+        manager: MCP manager instance
+        server_name: The server name that was not found
+        group_id: Optional message group ID for grouping related messages
+    """
+    import logging
+
+    from code_puppy.messaging import emit_info
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        servers = manager.list_servers()
+        if not servers:
+            emit_info("No servers are registered", message_group=group_id)
+            return
+
+        # Simple suggestion based on partial matching
+        suggestions = []
+        server_name_lower = server_name.lower()
+
+        for server in servers:
+            if server_name_lower in server.name.lower():
+                suggestions.append(server.name)
+
+        if suggestions:
+            emit_info(f"Did you mean: {', '.join(suggestions)}", message_group=group_id)
+        else:
+            server_names = [s.name for s in servers]
+            emit_info(
+                f"Available servers: {', '.join(server_names)}", message_group=group_id
+            )
+
+    except Exception as e:
+        logger.error(f"Error suggesting similar servers: {e}")