code-puppy 0.0.131__py3-none-any.whl → 0.0.132__py3-none-any.whl

code_puppy/command_line/mcp_commands.py

@@ -1567,93 +1567,20 @@ class MCPCommandHandler:
         
         display, color = state_map.get(state, ("? Unk", "dim"))
         return Text(display, style=color)
-        
-    def _find_server_id_by_name(self, server_name: str) -> Optional[str]:
-        """
-        Find a server ID by its name.
-        
-        Args:
-            server_name: Name of the server to find
-            
-        Returns:
-            Server ID if found, None otherwise
-        """
-        try:
-            servers = self.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(self, server_name: str, group_id: str = None) -> None:
-        """
-        Suggest similar server names when a server is not found.
-        
-        Args:
-            server_name: The server name that was not found
-            group_id: Optional message group ID for grouping related messages
-        """
-        try:
-            servers = self.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}")
-    
-    def _format_state_indicator(self, 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(self, 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"
@@ -1665,7 +1592,7 @@ class MCPCommandHandler:
             hours = int(uptime_seconds // 3600)
             minutes = int((uptime_seconds % 3600) // 60)
             return f"{hours}h {minutes}m"
-    
+
     def _show_detailed_server_status(self, server_id: str, server_name: str, group_id: str = None) -> None:
         """
         Show comprehensive status information for a specific server.

code_puppy/mcp/blocking_startup.py

@@ -0,0 +1,404 @@
+"""
+MCP Server with blocking startup capability and stderr capture.
+
+This module provides MCP servers that:
+1. Capture stderr output from stdio servers
+2. Block until fully initialized before allowing operations
+3. Emit stderr to users via emit_info with message groups
+"""
+
+import asyncio
+import os
+import tempfile
+import threading
+import uuid
+from typing import Optional, Callable, List
+from contextlib import asynccontextmanager
+from pydantic_ai.mcp import MCPServerStdio
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.shared.session import SessionMessage
+from code_puppy.messaging import emit_info
+
+
+class StderrFileCapture:
+    """Captures stderr to a file and monitors it in a background thread."""
+    
+    def __init__(self, server_name: str, emit_to_user: bool = True, message_group: Optional[uuid.UUID] = None):
+        self.server_name = server_name
+        self.emit_to_user = emit_to_user
+        self.message_group = message_group or uuid.uuid4()
+        self.temp_file = None
+        self.temp_path = None
+        self.monitor_thread = None
+        self.stop_monitoring = threading.Event()
+        self.captured_lines = []
+        
+    def start(self):
+        """Start capture by creating temp file and monitor thread."""
+        # Create temp file
+        self.temp_file = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix='.err')
+        self.temp_path = self.temp_file.name
+        
+        # Start monitoring thread
+        self.stop_monitoring.clear()
+        self.monitor_thread = threading.Thread(target=self._monitor_file)
+        self.monitor_thread.daemon = True
+        self.monitor_thread.start()
+        
+        return self.temp_file
+        
+    def _monitor_file(self):
+        """Monitor the temp file for new content."""
+        if not self.temp_path:
+            return
+            
+        last_pos = 0
+        while not self.stop_monitoring.is_set():
+            try:
+                with open(self.temp_path, 'r') as f:
+                    f.seek(last_pos)
+                    new_content = f.read()
+                    if new_content:
+                        last_pos = f.tell()
+                        # Process new lines
+                        for line in new_content.splitlines():
+                            if line.strip():
+                                self.captured_lines.append(line)
+                                if self.emit_to_user:
+                                    emit_info(
+                                        f"[bold white on blue] MCP {self.server_name} [/bold white on blue] {line}", 
+                                        style="dim cyan",
+                                        message_group=self.message_group
+                                    )
+                                    
+            except Exception:
+                pass  # File might not exist yet or be deleted
+                
+            self.stop_monitoring.wait(0.1)  # Check every 100ms
+            
+    def stop(self):
+        """Stop monitoring and clean up."""
+        self.stop_monitoring.set()
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=1)
+            
+        if self.temp_file:
+            try:
+                self.temp_file.close()
+            except:
+                pass
+                
+        if self.temp_path and os.path.exists(self.temp_path):
+            try:
+                # Read any remaining content
+                with open(self.temp_path, 'r') as f:
+                    content = f.read()
+                    for line in content.splitlines():
+                        if line.strip() and line not in self.captured_lines:
+                            self.captured_lines.append(line)
+                            if self.emit_to_user:
+                                emit_info(
+                                    f"[bold white on blue] MCP {self.server_name} [/bold white on blue] {line}", 
+                                    style="dim cyan",
+                                    message_group=self.message_group
+                                )
+                                
+                os.unlink(self.temp_path)
+            except:
+                pass
+                
+    def get_captured_lines(self) -> List[str]:
+        """Get all captured lines."""
+        return self.captured_lines.copy()
+
+
+class SimpleCapturedMCPServerStdio(MCPServerStdio):
+    """
+    MCPServerStdio that captures stderr to a file and optionally emits to user.
+    """
+    
+    def __init__(
+        self,
+        command: str,
+        args=(),
+        env=None,
+        cwd=None,
+        emit_stderr: bool = True,
+        message_group: Optional[uuid.UUID] = None,
+        **kwargs
+    ):
+        super().__init__(command=command, args=args, env=env, cwd=cwd, **kwargs)
+        self.emit_stderr = emit_stderr
+        self.message_group = message_group or uuid.uuid4()
+        self._stderr_capture = None
+        
+    @asynccontextmanager
+    async def client_streams(self):
+        """Create streams with stderr capture."""
+        server = StdioServerParameters(
+            command=self.command,
+            args=list(self.args),
+            env=self.env,
+            cwd=self.cwd
+        )
+        
+        # Create stderr capture
+        server_name = getattr(self, 'tool_prefix', self.command)
+        self._stderr_capture = StderrFileCapture(server_name, self.emit_stderr, self.message_group)
+        stderr_file = self._stderr_capture.start()
+        
+        try:
+            async with stdio_client(server=server, errlog=stderr_file) as (read_stream, write_stream):
+                yield read_stream, write_stream
+        finally:
+            self._stderr_capture.stop()
+            
+    def get_captured_stderr(self) -> List[str]:
+        """Get captured stderr lines."""
+        if self._stderr_capture:
+            return self._stderr_capture.get_captured_lines()
+        return []
+
+
+class BlockingMCPServerStdio(SimpleCapturedMCPServerStdio):
+    """
+    MCP Server that blocks until fully initialized.
+    
+    This server ensures that initialization is complete before
+    allowing any operations, preventing race conditions.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._initialized = asyncio.Event()
+        self._init_error: Optional[Exception] = None
+        self._initialization_task = None
+        
+    async def __aenter__(self):
+        """Enter context and track initialization."""
+        try:
+            # Start initialization
+            result = await super().__aenter__()
+            
+            # Mark as initialized
+            self._initialized.set()
+            
+            # Emit success message
+            server_name = getattr(self, 'tool_prefix', self.command)
+            emit_info(
+                f"✅ MCP Server '{server_name}' initialized successfully", 
+                style="green",
+                message_group=self.message_group
+            )
+            
+            return result
+            
+        except Exception as e:
+            # Store error and mark as initialized (with error)
+            self._init_error = e
+            self._initialized.set()
+            
+            # Emit error message
+            server_name = getattr(self, 'tool_prefix', self.command)
+            emit_info(
+                f"❌ MCP Server '{server_name}' failed to initialize: {e}", 
+                style="red",
+                message_group=self.message_group
+            )
+            
+            raise
+            
+    async def wait_until_ready(self, timeout: float = 30.0) -> bool:
+        """
+        Wait until the server is ready.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            
+        Returns:
+            True if server is ready, False if timeout or error
+            
+        Raises:
+            TimeoutError: If server doesn't initialize within timeout
+            Exception: If server initialization failed
+        """
+        try:
+            await asyncio.wait_for(self._initialized.wait(), timeout=timeout)
+            
+            # Check if there was an initialization error
+            if self._init_error:
+                raise self._init_error
+                
+            return True
+            
+        except asyncio.TimeoutError:
+            server_name = getattr(self, 'tool_prefix', self.command)
+            raise TimeoutError(f"Server '{server_name}' initialization timeout after {timeout}s")
+            
+    async def ensure_ready(self, timeout: float = 30.0):
+        """
+        Ensure server is ready before proceeding.
+        
+        This is a convenience method that raises if not ready.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            
+        Raises:
+            TimeoutError: If server doesn't initialize within timeout
+            Exception: If server initialization failed
+        """
+        await self.wait_until_ready(timeout)
+        
+    def is_ready(self) -> bool:
+        """
+        Check if server is ready without blocking.
+        
+        Returns:
+            True if server is initialized and ready
+        """
+        return self._initialized.is_set() and self._init_error is None
+
+
+class StartupMonitor:
+    """
+    Monitor for tracking multiple server startups.
+    
+    This class helps coordinate startup of multiple MCP servers
+    and ensures all are ready before proceeding.
+    """
+    
+    def __init__(self, message_group: Optional[uuid.UUID] = None):
+        self.servers = {}
+        self.startup_times = {}
+        self.message_group = message_group or uuid.uuid4()
+        
+    def add_server(self, name: str, server: BlockingMCPServerStdio):
+        """Add a server to monitor."""
+        self.servers[name] = server
+        
+    async def wait_all_ready(self, timeout: float = 30.0) -> dict:
+        """
+        Wait for all servers to be ready.
+        
+        Args:
+            timeout: Maximum time to wait for all servers
+            
+        Returns:
+            Dictionary of server names to ready status
+        """
+        import time
+        results = {}
+        
+        # Create tasks for all servers
+        async def wait_server(name: str, server: BlockingMCPServerStdio):
+            start = time.time()
+            try:
+                await server.wait_until_ready(timeout)
+                self.startup_times[name] = time.time() - start
+                results[name] = True
+                emit_info(
+                    f"   {name}: Ready in {self.startup_times[name]:.2f}s", 
+                    style="dim green",
+                    message_group=self.message_group
+                )
+            except Exception as e:
+                self.startup_times[name] = time.time() - start
+                results[name] = False
+                emit_info(
+                    f"   {name}: Failed after {self.startup_times[name]:.2f}s - {e}", 
+                    style="dim red",
+                    message_group=self.message_group
+                )
+                
+        # Wait for all servers in parallel
+        emit_info(
+            f"⏳ Waiting for {len(self.servers)} MCP servers to initialize...", 
+            style="cyan",
+            message_group=self.message_group
+        )
+        
+        tasks = [
+            asyncio.create_task(wait_server(name, server))
+            for name, server in self.servers.items()
+        ]
+        
+        await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Report summary
+        ready_count = sum(1 for r in results.values() if r)
+        total_count = len(results)
+        
+        if ready_count == total_count:
+            emit_info(
+                f"✅ All {total_count} servers ready!", 
+                style="green bold",
+                message_group=self.message_group
+            )
+        else:
+            emit_info(
+                f"⚠️  {ready_count}/{total_count} servers ready", 
+                style="yellow",
+                message_group=self.message_group
+            )
+            
+        return results
+        
+    def get_startup_report(self) -> str:
+        """Get a report of startup times."""
+        lines = ["Server Startup Times:"]
+        for name, time_taken in self.startup_times.items():
+            status = "✅" if self.servers[name].is_ready() else "❌"
+            lines.append(f"  {status} {name}: {time_taken:.2f}s")
+        return "\n".join(lines)
+
+
+async def start_servers_with_blocking(*servers: BlockingMCPServerStdio, timeout: float = 30.0, message_group: Optional[uuid.UUID] = None):
+    """
+    Start multiple servers and wait for all to be ready.
+    
+    Args:
+        *servers: Variable number of BlockingMCPServerStdio instances
+        timeout: Maximum time to wait for all servers
+        message_group: Optional UUID for grouping log messages
+        
+    Returns:
+        List of ready servers
+        
+    Example:
+        server1 = BlockingMCPServerStdio(...)
+        server2 = BlockingMCPServerStdio(...)
+        ready = await start_servers_with_blocking(server1, server2)
+    """
+    monitor = StartupMonitor(message_group=message_group)
+    
+    for i, server in enumerate(servers):
+        name = getattr(server, 'tool_prefix', f"server-{i}")
+        monitor.add_server(name, server)
+        
+    # Start all servers
+    async def start_server(server):
+        async with server:
+            await asyncio.sleep(0.1)  # Keep context alive briefly
+            return server
+            
+    # Start servers in parallel
+    server_tasks = [
+        asyncio.create_task(start_server(server))
+        for server in servers
+    ]
+    
+    # Wait for all to be ready
+    results = await monitor.wait_all_ready(timeout)
+    
+    # Get the report
+    emit_info(monitor.get_startup_report(), message_group=monitor.message_group)
+    
+    # Return ready servers
+    ready_servers = [
+        server for name, server in monitor.servers.items()
+        if results.get(name, False)
+    ]
+    
+    return ready_servers

code_puppy/mcp/captured_stdio_server.py

@@ -0,0 +1,282 @@
+"""
+Custom MCPServerStdio that captures stderr output properly.
+
+This module provides a version of MCPServerStdio that captures subprocess
+stderr output and makes it available through proper logging channels.
+"""
+
+import asyncio
+import io
+import logging
+import os
+import sys
+import tempfile
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Sequence, Optional, Any
+from threading import Thread
+from queue import Queue, Empty
+
+from pydantic_ai.mcp import MCPServerStdio
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.shared.session import SessionMessage
+
+logger = logging.getLogger(__name__)
+
+
+class StderrCapture:
+    """
+    Captures stderr output using a pipe and background reader.
+    """
+    
+    def __init__(self, name: str, handler: Optional[callable] = None):
+        """
+        Initialize stderr capture.
+        
+        Args:
+            name: Name for this capture stream
+            handler: Optional function to call with captured lines
+        """
+        self.name = name
+        self.handler = handler or self._default_handler
+        self._captured_lines = []
+        self._reader_task = None
+        self._pipe_r = None
+        self._pipe_w = None
+        
+    def _default_handler(self, line: str):
+        """Default handler that logs to Python logging."""
+        if line.strip():
+            logger.debug(f"[MCP {self.name}] {line.rstrip()}")
+    
+    async def start_capture(self):
+        """Start capturing stderr by creating a pipe and reader task."""
+        # Create a pipe for capturing stderr
+        self._pipe_r, self._pipe_w = os.pipe()
+        
+        # Make the read end non-blocking
+        os.set_blocking(self._pipe_r, False)
+        
+        # Start background task to read from pipe
+        self._reader_task = asyncio.create_task(self._read_pipe())
+        
+        # Return the write end as the file descriptor for stderr
+        return self._pipe_w
+    
+    async def _read_pipe(self):
+        """Background task to read from the pipe."""
+        loop = asyncio.get_event_loop()
+        buffer = b''
+        
+        try:
+            while True:
+                # Use asyncio's add_reader for efficient async reading
+                future = asyncio.Future()
+                
+                def read_callback():
+                    try:
+                        data = os.read(self._pipe_r, 4096)
+                        future.set_result(data)
+                    except BlockingIOError:
+                        future.set_result(b'')
+                    except Exception as e:
+                        future.set_exception(e)
+                
+                loop.add_reader(self._pipe_r, read_callback)
+                try:
+                    data = await future
+                finally:
+                    loop.remove_reader(self._pipe_r)
+                
+                if not data:
+                    await asyncio.sleep(0.1)
+                    continue
+                
+                # Process the data
+                buffer += data
+                
+                # Look for complete lines
+                while b'\n' in buffer:
+                    line, buffer = buffer.split(b'\n', 1)
+                    line_str = line.decode('utf-8', errors='replace')
+                    if line_str:
+                        self._captured_lines.append(line_str)
+                        self.handler(line_str)
+                        
+        except asyncio.CancelledError:
+            # Process any remaining buffer
+            if buffer:
+                line_str = buffer.decode('utf-8', errors='replace')
+                if line_str:
+                    self._captured_lines.append(line_str)
+                    self.handler(line_str)
+            raise
+            
+    async def stop_capture(self):
+        """Stop capturing and clean up."""
+        if self._reader_task:
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except asyncio.CancelledError:
+                pass
+                
+        if self._pipe_r is not None:
+            os.close(self._pipe_r)
+        if self._pipe_w is not None:
+            os.close(self._pipe_w)
+            
+    def get_captured_lines(self) -> list[str]:
+        """Get all captured lines."""
+        return self._captured_lines.copy()
+
+
+class CapturedMCPServerStdio(MCPServerStdio):
+    """
+    Extended MCPServerStdio that captures and handles stderr output.
+    
+    This class captures stderr from the subprocess and makes it available
+    through proper logging channels instead of letting it pollute the console.
+    """
+    
+    def __init__(
+        self,
+        command: str,
+        args: Sequence[str] = (),
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+        stderr_handler: Optional[callable] = None,
+        **kwargs
+    ):
+        """
+        Initialize captured stdio server.
+        
+        Args:
+            command: The command to run
+            args: Arguments for the command
+            env: Environment variables
+            cwd: Working directory
+            stderr_handler: Optional function to handle stderr lines
+            **kwargs: Additional arguments for MCPServerStdio
+        """
+        super().__init__(command=command, args=args, env=env, cwd=cwd, **kwargs)
+        self.stderr_handler = stderr_handler
+        self._stderr_capture = None
+        self._captured_lines = []
+        
+    @asynccontextmanager
+    async def client_streams(
+        self,
+    ) -> AsyncIterator[
+        tuple[
+            MemoryObjectReceiveStream[SessionMessage | Exception],
+            MemoryObjectSendStream[SessionMessage],
+        ]
+    ]:
+        """Create the streams for the MCP server with stderr capture."""
+        server = StdioServerParameters(
+            command=self.command, 
+            args=list(self.args), 
+            env=self.env, 
+            cwd=self.cwd
+        )
+        
+        # Create stderr capture
+        def stderr_line_handler(line: str):
+            """Handle captured stderr lines."""
+            self._captured_lines.append(line)
+            
+            if self.stderr_handler:
+                self.stderr_handler(line)
+            else:
+                # Default: log at DEBUG level to avoid console spam
+                logger.debug(f"[MCP Server {self.command}] {line}")
+        
+        self._stderr_capture = StderrCapture(self.command, stderr_line_handler)
+        
+        # For now, use devnull for stderr to suppress output
+        # We'll capture it through other means if needed
+        with open(os.devnull, 'w') as devnull:
+            async with stdio_client(server=server, errlog=devnull) as (read_stream, write_stream):
+                yield read_stream, write_stream
+            
+    def get_captured_stderr(self) -> list[str]:
+        """
+        Get all captured stderr lines.
+        
+        Returns:
+            List of captured stderr lines
+        """
+        return self._captured_lines.copy()
+    
+    def clear_captured_stderr(self):
+        """Clear the captured stderr buffer."""
+        self._captured_lines.clear()
+
+
+class StderrCollector:
+    """
+    A centralized collector for stderr from multiple MCP servers.
+    
+    This can be used to aggregate stderr from all MCP servers in one place.
+    """
+    
+    def __init__(self):
+        """Initialize the collector."""
+        self.servers = {}
+        self.all_lines = []
+        
+    def create_handler(self, server_name: str, emit_to_user: bool = False):
+        """
+        Create a handler function for a specific server.
+        
+        Args:
+            server_name: Name to identify this server
+            emit_to_user: If True, emit stderr lines to user via emit_info
+            
+        Returns:
+            Handler function that can be passed to CapturedMCPServerStdio
+        """
+        def handler(line: str):
+            # Store with server identification
+            import time
+            entry = {
+                'server': server_name,
+                'line': line,
+                'timestamp': time.time()
+            }
+            
+            if server_name not in self.servers:
+                self.servers[server_name] = []
+            
+            self.servers[server_name].append(line)
+            self.all_lines.append(entry)
+            
+            # Emit to user if requested
+            if emit_to_user:
+                from code_puppy.messaging import emit_info
+                emit_info(f"[MCP {server_name}] {line}", style="dim cyan")
+            
+        return handler
+    
+    def get_server_output(self, server_name: str) -> list[str]:
+        """Get all output from a specific server."""
+        return self.servers.get(server_name, []).copy()
+    
+    def get_all_output(self) -> list[dict]:
+        """Get all output from all servers with metadata."""
+        return self.all_lines.copy()
+    
+    def clear(self, server_name: Optional[str] = None):
+        """Clear captured output."""
+        if server_name:
+            if server_name in self.servers:
+                self.servers[server_name].clear()
+                # Also clear from all_lines
+                self.all_lines = [
+                    entry for entry in self.all_lines 
+                    if entry['server'] != server_name
+                ]
+        else:
+            self.servers.clear()
+            self.all_lines.clear()

code_puppy/mcp/managed_server.py

@@ -19,6 +19,7 @@ from pydantic_ai import RunContext
 from pydantic_ai.mcp import MCPServerSSE, MCPServerStdio, MCPServerStreamableHTTP, CallToolFunc, ToolResult
 
 from code_puppy.messaging import emit_info
+from code_puppy.mcp.blocking_startup import BlockingMCPServerStdio
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -197,7 +198,16 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     stdio_kwargs["read_timeout"] = config["read_timeout"]
                 
-                self._pydantic_server = MCPServerStdio(**stdio_kwargs, process_tool_call=process_tool_call)
+                # Use BlockingMCPServerStdio for proper initialization blocking and stderr capture
+                # Create a unique message group for this server
+                message_group = uuid.uuid4()
+                self._pydantic_server = BlockingMCPServerStdio(
+                    **stdio_kwargs, 
+                    process_tool_call=process_tool_call, 
+                    tool_prefix=config["name"],
+                    emit_stderr=True,  # Always emit stderr for now
+                    message_group=message_group
+                )
             
             elif server_type == "http":
                 if "url" not in config:
@@ -308,6 +318,50 @@ class ManagedMCPServer:
         
         return True
     
+    def get_captured_stderr(self) -> list[str]:
+        """
+        Get captured stderr output if this is a stdio server.
+        
+        Returns:
+            List of captured stderr lines, or empty list if not applicable
+        """
+        if isinstance(self._pydantic_server, BlockingMCPServerStdio):
+            return self._pydantic_server.get_captured_stderr()
+        return []
+    
+    async def wait_until_ready(self, timeout: float = 30.0) -> bool:
+        """
+        Wait until the server is ready.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            
+        Returns:
+            True if server is ready, False otherwise
+        """
+        if isinstance(self._pydantic_server, BlockingMCPServerStdio):
+            try:
+                await self._pydantic_server.wait_until_ready(timeout)
+                return True
+            except Exception:
+                return False
+        # Non-stdio servers are considered ready immediately
+        return True
+    
+    async def ensure_ready(self, timeout: float = 30.0):
+        """
+        Ensure server is ready, raising exception if not.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            
+        Raises:
+            TimeoutError: If server doesn't initialize within timeout
+            Exception: If server initialization failed
+        """
+        if isinstance(self._pydantic_server, BlockingMCPServerStdio):
+            await self._pydantic_server.ensure_ready(timeout)
+    
     def get_status(self) -> Dict[str, Any]:
         """
         Return current status information.

{code_puppy-0.0.131.dist-info → code_puppy-0.0.132.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.131
+Version: 0.0.132
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.131.dist-info → code_puppy-0.0.132.dist-info}/RECORD

@@ -25,7 +25,7 @@ code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZ
 code_puppy/command_line/command_handler.py,sha256=IhDaDa0GmpW0BCFfmkgpL_6iQBJlXEKQC9SDmpj_XeI,20730
 code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
 code_puppy/command_line/load_context_completion.py,sha256=6eZxV6Bs-EFwZjN93V8ZDZUC-6RaWxvtZk-04Wtikyw,2240
-code_puppy/command_line/mcp_commands.py,sha256=YlBzJ9-skZy-anND6fHv4rFipbajhrUTVd50O-TLZEE,81156
+code_puppy/command_line/mcp_commands.py,sha256=X0Djmcr1ZAVZyr9DkQWb9uMrQDa4lBU28b4m_qteBvI,78406
 code_puppy/command_line/meta_command_handler.py,sha256=02NU4Lspf5qRMPTsrGiMRLSUshZhdmS0XQA26k8vUjw,5665
 code_puppy/command_line/model_picker_completion.py,sha256=xvwgthVmLRA9a8RJG6iFImxR2yD6rJYPJJav0YJoVCc,3599
 code_puppy/command_line/motd.py,sha256=PEdkp3ZnydVfvd7mNJylm8YyFNUKg9jmY6uwkA1em8c,2152
@@ -33,12 +33,14 @@ code_puppy/command_line/prompt_toolkit_completion.py,sha256=BKNw-DwacZPNTKjjXlxn
 code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
 code_puppy/mcp/__init__.py,sha256=LJd9mGStskhXYBEp1UhtHlrAQ3rCHnfTa7KSmqtZe34,1143
 code_puppy/mcp/async_lifecycle.py,sha256=45tw7ZcDV6LVBrTvvNkMCDhnTapgQCYcc01W8Gp9c5A,8064
+code_puppy/mcp/blocking_startup.py,sha256=R5XjDeIORd_jY5G0OF7GPFzSiDhjFDxMRcJJ-MCTFO8,14140
+code_puppy/mcp/captured_stdio_server.py,sha256=DHeLYCbOWwM_a47xEsacS8yz0eCQhGsUTK9JIpHhX78,9504
 code_puppy/mcp/circuit_breaker.py,sha256=TF0ukl_d4EithPQbiq1yDfFPkCZ7bRBe0jiEx_tnMR4,8630
 code_puppy/mcp/config_wizard.py,sha256=d0o29ZcnGLdpV778nwTUAPH7B8lHAC2XggU-ql37Fzo,16777
 code_puppy/mcp/dashboard.py,sha256=fHBdAVidQUWuhjMjF7hIy0SjrQlrz31zSqzqJv8H2eI,9396
 code_puppy/mcp/error_isolation.py,sha256=xw8DGTItT8-RY5TVYzORtrtfdI1s1ZfUUT88Pr7h_pI,12270
 code_puppy/mcp/health_monitor.py,sha256=oNgPyEwzkF61gNc7nk-FJU_yO2MERjASn4g5shcabic,20428
-code_puppy/mcp/managed_server.py,sha256=oeVNJIunn5IyT_Qy5j4rWfnIfAJgQyD3UKp9XRaYO-4,12905
+code_puppy/mcp/managed_server.py,sha256=z0uA9JFtThVxno0TZpa5nlsvRVe2tNnZrMJYymj600E,14932
 code_puppy/mcp/manager.py,sha256=ZfYoz3nmQqrkSnDzgr9s_QvGKFCthA1bvt3gQm0W6VI,27280
 code_puppy/mcp/registry.py,sha256=YJ-VPFjk1ZFrSftbu9bKVIWvGYX4zIk2TnrM_h_us1M,15841
 code_puppy/mcp/retry_manager.py,sha256=B4q1MyzZQ9RZRW3FKhyqhq-ebSG8Do01j4A70zHTxgA,10988
@@ -103,9 +105,9 @@ code_puppy/tui/tests/test_sidebar_history_navigation.py,sha256=JGiyua8A2B8dLfwiE
 code_puppy/tui/tests/test_status_bar.py,sha256=nYT_FZGdmqnnbn6o0ZuOkLtNUtJzLSmtX8P72liQ5Vo,1797
 code_puppy/tui/tests/test_timestamped_history.py,sha256=nVXt9hExZZ_8MFP-AZj4L4bB_1Eo_mc-ZhVICzTuw3I,1799
 code_puppy/tui/tests/test_tools.py,sha256=kgzzAkK4r0DPzQwHHD4cePpVNgrHor6cFr05Pg6DBWg,2687
-code_puppy-0.0.131.data/data/code_puppy/models.json,sha256=GpvtWnBKERm6T7HCZJQUIVAS5256-tZ_bFuRtnKXEsY,3128
-code_puppy-0.0.131.dist-info/METADATA,sha256=FrlQgWQL53BSHH9iHvCIarsXR2xPJFulj7QWDdv-_BQ,19873
-code_puppy-0.0.131.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.131.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.131.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.131.dist-info/RECORD,,
+code_puppy-0.0.132.data/data/code_puppy/models.json,sha256=GpvtWnBKERm6T7HCZJQUIVAS5256-tZ_bFuRtnKXEsY,3128
+code_puppy-0.0.132.dist-info/METADATA,sha256=0uc8Pfj8Q1TUbxKCS3woA3ezguSmOrMN_if4tEFQLIA,19873
+code_puppy-0.0.132.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.132.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.132.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.132.dist-info/RECORD,,