codepp 0.0.437__py3-none-any.whl

code_puppy/command_line/mcp/start_all_command.py

@@ -0,0 +1,135 @@
+"""
+MCP Start All Command - Starts all registered MCP servers.
+"""
+
+import logging
+import time
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
+from code_puppy.messaging import emit_info
+
+from ...agents import get_current_agent
+from .base import MCPCommandBase
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StartAllCommand(MCPCommandBase):
+    """
+    Command handler for starting all MCP servers.
+
+    Starts all registered MCP servers and provides a summary of results.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Start all registered 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(
+                    "[yellow]No servers registered[/yellow]", message_group=group_id
+                )
+                return
+
+            started_count = 0
+            failed_count = 0
+            already_running = 0
+
+            emit_info(f"Starting {len(servers)} servers...", message_group=group_id)
+
+            for server_info in servers:
+                server_id = server_info.id
+                server_name = server_info.name
+
+                # Skip if already running
+                if server_info.state == ServerState.RUNNING:
+                    already_running += 1
+                    emit_info(
+                        f"  • {server_name}: already running", message_group=group_id
+                    )
+                    continue
+
+                # Try to start the server
+                success = self.manager.start_server_sync(server_id)
+
+                if success:
+                    started_count += 1
+                    emit_info(
+                        Text.from_markup(f"  [green]✓ Started: {server_name}[/green]"),
+                        message_group=group_id,
+                    )
+                else:
+                    failed_count += 1
+                    emit_info(
+                        Text.from_markup(f"  [red]✗ Failed: {server_name}[/red]"),
+                        message_group=group_id,
+                    )
+
+            # Summary
+            emit_info("", message_group=group_id)
+            if started_count > 0:
+                emit_info(
+                    Text.from_markup(
+                        f"[green]Started {started_count} server(s)[/green]"
+                    ),
+                    message_group=group_id,
+                )
+            if already_running > 0:
+                emit_info(
+                    f"{already_running} server(s) already running",
+                    message_group=group_id,
+                )
+            if failed_count > 0:
+                emit_info(
+                    Text.from_markup(
+                        f"[yellow]Failed to start {failed_count} server(s)[/yellow]"
+                    ),
+                    message_group=group_id,
+                )
+
+            # Reload agent if any servers were started
+            if started_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 start
+                    time.sleep(0.5)  # Small delay to let async tasks progress
+                except RuntimeError:
+                    pass  # No async loop, servers will start when agent uses them
+
+                try:
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
+                    # Update MCP tool cache immediately so token counts reflect the change
+                    agent.update_mcp_tool_cache_sync()
+                    emit_info(
+                        Text.from_markup(
+                            "[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 starting all servers: {e}")
+            emit_info(
+                Text.from_markup(f"[red]Failed to start servers: {e}[/red]"),
+                message_group=group_id,
+            )

code_puppy/command_line/mcp/start_command.py

@@ -0,0 +1,117 @@
+"""
+MCP Start Command - Starts a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info, emit_success
+
+from ...agents import get_current_agent
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StartCommand(MCPCommandBase):
+    """
+    Command handler for starting MCP servers.
+
+    Starts a specific MCP server by name and reloads the agent.
+    The server subprocess starts asynchronously in the background.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Start 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(
+                Text.from_markup("[yellow]Usage: /mcp start <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_error(
+                    f"Server '{server_name}' not found",
+                    message_group=group_id,
+                )
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Get server info for better messaging (safely handle missing method)
+            server_type = "unknown"
+            try:
+                if hasattr(self.manager, "get_server_by_name"):
+                    server_config = self.manager.get_server_by_name(server_name)
+                    server_type = (
+                        getattr(server_config, "type", "unknown")
+                        if server_config
+                        else "unknown"
+                    )
+            except Exception:
+                pass  # Default to unknown type if we can't determine it
+
+            # Start the server (schedules async start in background)
+            success = self.manager.start_server_sync(server_id)
+
+            if success:
+                if server_type == "stdio":
+                    # Stdio servers start subprocess asynchronously
+                    emit_success(
+                        f"🚀 Starting server: {server_name} (subprocess starting in background)",
+                        message_group=group_id,
+                    )
+                    emit_info(
+                        Text.from_markup(
+                            "[dim]Tip: Use /mcp status to check if the server is fully initialized[/dim]"
+                        ),
+                        message_group=group_id,
+                    )
+                else:
+                    # SSE/HTTP servers connect on first use
+                    emit_success(
+                        f"✅ Enabled server: {server_name}",
+                        message_group=group_id,
+                    )
+
+                # Reload the agent to pick up the newly enabled server
+                # NOTE: We don't block or wait - the server will be ready
+                # when the next prompt runs (pydantic-ai handles connection)
+                try:
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
+                    # Clear MCP tool cache - it will be repopulated on next run
+                    agent.update_mcp_tool_cache_sync()
+                    emit_info(
+                        "Agent reloaded with updated servers",
+                        message_group=group_id,
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not reload agent: {e}")
+            else:
+                emit_error(
+                    f"Failed to start server: {server_name}",
+                    message_group=group_id,
+                )
+
+        except Exception as e:
+            logger.error(f"Error starting server '{server_name}': {e}")
+            emit_error(f"Failed to start server: {e}", message_group=group_id)

code_puppy/command_line/mcp/status_command.py

@@ -0,0 +1,184 @@
+"""
+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 rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
+from code_puppy.messaging import emit_error, 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 = Text.from_markup("\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_error(f"Error getting server status: {e}", message_group=group_id)

code_puppy/command_line/mcp/stop_all_command.py

@@ -0,0 +1,112 @@
+"""
+MCP Stop All Command - Stops all running MCP servers.
+"""
+
+import logging
+import time
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
+from code_puppy.messaging import emit_info
+
+from ...agents import get_current_agent
+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:
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
+                    # Update MCP tool cache immediately so token counts reflect the change
+                    agent.update_mcp_tool_cache_sync()
+                    emit_info(
+                        Text.from_markup(
+                            "[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,80 @@
+"""
+MCP Stop Command - Stops a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info
+
+from ...agents import get_current_agent
+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(
+                Text.from_markup("[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:
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
+                    # Update MCP tool cache immediately so token counts reflect the change
+                    agent.update_mcp_tool_cache_sync()
+                    emit_info(
+                        "Agent reloaded with updated servers",
+                        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_error(f"Failed to stop server: {e}", message_group=group_id)