code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/mcp_/__init__.py

@@ -17,6 +17,15 @@ from .error_isolation import (
 )
 from .managed_server import ManagedMCPServer, ServerConfig, ServerState
 from .manager import MCPManager, ServerInfo, get_mcp_manager
+from .mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    get_mcp_logs_dir,
+    list_servers_with_logs,
+    read_logs,
+    write_log,
+)
 from .registry import ServerRegistry
 from .retry_manager import RetryManager, RetryStats, get_retry_manager, retry_mcp_call
 from .status_tracker import Event, ServerStatusTracker
@@ -46,4 +55,12 @@ __all__ = [
     "MCPDashboard",
     "MCPConfigWizard",
     "run_add_wizard",
+    # Log management
+    "get_mcp_logs_dir",
+    "get_log_file_path",
+    "read_logs",
+    "write_log",
+    "clear_logs",
+    "list_servers_with_logs",
+    "get_log_stats",
 ]

code_puppy/mcp_/async_lifecycle.py

@@ -108,10 +108,17 @@ class AsyncServerLifecycleManager:
 
         try:
             logger.info(f"Starting server lifecycle for {server_id}")
+            logger.info(
+                f"Server {server_id} _running_count before enter: {getattr(server, '_running_count', 'N/A')}"
+            )
 
             # Enter the server's context
             await exit_stack.enter_async_context(server)
 
+            logger.info(
+                f"Server {server_id} _running_count after enter: {getattr(server, '_running_count', 'N/A')}"
+            )
+
             # Store the managed context
             async with self._lock:
                 self._servers[server_id] = ManagedServerContext(
@@ -122,26 +129,50 @@ class AsyncServerLifecycleManager:
                     task=asyncio.current_task(),
                 )
 
-            logger.info(f"Server {server_id} started successfully")
+            logger.info(
+                f"Server {server_id} started successfully and stored in _servers"
+            )
 
             # Keep the task alive until cancelled
+            loop_count = 0
             while True:
                 await asyncio.sleep(1)
+                loop_count += 1
 
                 # Check if server is still running
-                if not server.is_running:
-                    logger.warning(f"Server {server_id} stopped unexpectedly")
+                running_count = getattr(server, "_running_count", "N/A")
+                is_running = server.is_running
+                logger.debug(
+                    f"Server {server_id} heartbeat #{loop_count}: "
+                    f"is_running={is_running}, _running_count={running_count}"
+                )
+
+                if not is_running:
+                    logger.warning(
+                        f"Server {server_id} stopped unexpectedly! "
+                        f"_running_count={running_count}"
+                    )
                     break
 
         except asyncio.CancelledError:
             logger.info(f"Server {server_id} lifecycle task cancelled")
             raise
         except Exception as e:
-            logger.error(f"Error in server {server_id} lifecycle: {e}")
+            logger.error(f"Error in server {server_id} lifecycle: {e}", exc_info=True)
         finally:
+            running_count = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} lifecycle ending, _running_count={running_count}"
+            )
+
             # Clean up the context
             await exit_stack.aclose()
 
+            running_count_after = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} context closed, _running_count={running_count_after}"
+            )
+
             # Remove from managed servers
             async with self._lock:
                 if server_id in self._servers:

code_puppy/mcp_/blocking_startup.py

@@ -2,14 +2,13 @@
 MCP Server with blocking startup capability and stderr capture.
 
 This module provides MCP servers that:
-1. Capture stderr output from stdio servers
+1. Capture stderr output from stdio servers to persistent log files
 2. Block until fully initialized before allowing operations
-3. Emit stderr to users via emit_info with message groups
+3. Optionally emit stderr to users (disabled by default to reduce console noise)
 """
 
 import asyncio
 import os
-import tempfile
 import threading
 import uuid
 from contextlib import asynccontextmanager
@@ -18,64 +17,80 @@ from typing import List, Optional
 from mcp.client.stdio import StdioServerParameters, stdio_client
 from pydantic_ai.mcp import MCPServerStdio
 
+from code_puppy.mcp_.mcp_logs import get_log_file_path, rotate_log_if_needed, write_log
 from code_puppy.messaging import emit_info
 
 
 class StderrFileCapture:
-    """Captures stderr to a file and monitors it in a background thread."""
+    """
+    Captures stderr to a persistent log file and optionally monitors it.
+
+    Logs are written to ~/.code_puppy/mcp_logs/<server_name>.log
+    """
 
     def __init__(
         self,
         server_name: str,
-        emit_to_user: bool = True,
+        emit_to_user: bool = False,  # Disabled by default to reduce console noise
         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.log_file = None
+        self.log_path = None
         self.monitor_thread = None
         self.stop_monitoring = threading.Event()
         self.captured_lines = []
+        self._last_read_pos = 0
 
     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 capture by opening persistent log file and monitor thread."""
+        # Rotate log if needed
+        rotate_log_if_needed(self.server_name)
+
+        # Get persistent log path
+        self.log_path = get_log_file_path(self.server_name)
 
-        # Start monitoring thread
+        # Write startup marker
+        write_log(self.server_name, "--- Server starting ---", "INFO")
+
+        # Open log file for appending stderr
+        self.log_file = open(self.log_path, "a", encoding="utf-8")
+
+        # Start monitoring thread only if we need to emit to user or capture lines
         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
+        return self.log_file
 
     def _monitor_file(self):
-        """Monitor the temp file for new content."""
-        if not self.temp_path:
+        """Monitor the log file for new content."""
+        if not self.log_path:
             return
 
-        last_pos = 0
+        # Start reading from current position (end of file before we started)
+        try:
+            self._last_read_pos = os.path.getsize(self.log_path)
+        except OSError:
+            self._last_read_pos = 0
+
         while not self.stop_monitoring.is_set():
             try:
-                with open(self.temp_path, "r") as f:
-                    f.seek(last_pos)
+                with open(self.log_path, "r", encoding="utf-8", errors="replace") as f:
+                    f.seek(self._last_read_pos)
                     new_content = f.read()
                     if new_content:
-                        last_pos = f.tell()
+                        self._last_read_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",
+                                        f"MCP {self.server_name}: {line}",
                                         message_group=self.message_group,
                                     )
 
@@ -90,33 +105,37 @@ class StderrFileCapture:
         if self.monitor_thread:
             self.monitor_thread.join(timeout=1)
 
-        if self.temp_file:
+        if self.log_file:
             try:
-                self.temp_file.close()
+                self.log_file.flush()
+                self.log_file.close()
             except Exception:
                 pass
 
-        if self.temp_path and os.path.exists(self.temp_path):
+        # Write shutdown marker
+        write_log(self.server_name, "--- Server stopped ---", "INFO")
+
+        # Read any remaining content for in-memory capture
+        if self.log_path and os.path.exists(self.log_path):
             try:
-                # Read any remaining content
-                with open(self.temp_path, "r") as f:
+                with open(self.log_path, "r", encoding="utf-8", errors="replace") as f:
+                    f.seek(self._last_read_pos)
                     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",
+                                    f"MCP {self.server_name}: {line}",
                                     message_group=self.message_group,
                                 )
-
-                os.unlink(self.temp_path)
             except Exception:
                 pass
 
+        # Note: We do NOT delete the log file - it's persistent now!
+
     def get_captured_lines(self) -> List[str]:
-        """Get all captured lines."""
+        """Get all captured lines from this session."""
         return self.captured_lines.copy()
 
 
@@ -193,25 +212,33 @@ class BlockingMCPServerStdio(SimpleCapturedMCPServerStdio):
             # 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,
-            )
+            # Success message removed to reduce console spam
+            # 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:
+        except BaseException as e:
             # Store error and mark as initialized (with error)
-            self._init_error = e
+            # Unwrap ExceptionGroup if present (Python 3.11+)
+            if type(e).__name__ == "ExceptionGroup" and hasattr(e, "exceptions"):
+                # Use the first exception as the primary cause
+                self._init_error = e.exceptions[0]
+                error_details = f"{e.exceptions[0]}"
+            else:
+                self._init_error = e
+                error_details = str(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}",
+                f"❌ MCP Server '{server_name}' failed to initialize: {error_details}",
                 style="red",
                 message_group=self.message_group,
             )

code_puppy/mcp_/captured_stdio_server.py

@@ -249,7 +249,7 @@ class StderrCollector:
             if emit_to_user:
                 from code_puppy.messaging import emit_info
 
-                emit_info(f"[MCP {server_name}] {line}", style="dim cyan")
+                emit_info(f"MCP {server_name}: {line}")
 
         return handler
 
@@ -265,7 +265,7 @@ class StderrCollector:
         """Clear captured output."""
         if server_name:
             if server_name in self.servers:
-                self.servers[server_name].clear()
+                del self.servers[server_name]
                 # Also clear from all_lines
                 self.all_lines = [
                     entry for entry in self.all_lines if entry["server"] != server_name

code_puppy/mcp_/config_wizard.py

@@ -9,7 +9,7 @@ import re
 from typing import Dict, Optional
 from urllib.parse import urlparse
 
-from rich.console import Console
+from rich.text import Text
 
 from code_puppy.mcp_.manager import ServerConfig, get_mcp_manager
 from code_puppy.messaging import (
@@ -20,8 +20,6 @@ from code_puppy.messaging import (
     emit_warning,
 )
 
-console = Console()
-
 
 def prompt_ask(
     prompt_text: str, default: Optional[str] = None, choices: Optional[list] = None
@@ -491,7 +489,9 @@ def run_add_wizard(group_id: str = None) -> bool:
                 json.dump(data, f, indent=2)
 
             emit_info(
-                f"[dim]Configuration saved to {MCP_SERVERS_FILE}[/dim]",
+                Text.from_markup(
+                    f"[dim]Configuration saved to {MCP_SERVERS_FILE}[/dim]"
+                ),
                 message_group=group_id,
             )
             return True

code_puppy/mcp_/dashboard.py

@@ -16,11 +16,16 @@ from .status_tracker import ServerState
 
 
 class MCPDashboard:
-    """Visual dashboard for MCP server status monitoring"""
+    """Visual dashboard for MCP server status monitoring.
+
+    Note: This class uses Rich Console directly for rendering Rich tables.
+    This is intentional - Rich tables require Console for proper formatting.
+    """
 
     def __init__(self):
-        """Initialize the MCP Dashboard"""
-        self.console = Console()
+        """Initialize the MCP Dashboard."""
+        # Note: Console is used here specifically for Rich table rendering
+        self._console = Console()
 
     def render_dashboard(self) -> Table:
         """
@@ -278,10 +283,14 @@ class MCPDashboard:
             return "error"
 
     def print_dashboard(self) -> None:
-        """Print the dashboard to console"""
+        """Print the dashboard to console.
+
+        Note: Uses Rich Console directly for table rendering - Rich tables
+        require Console for proper formatting with colors and borders.
+        """
         table = self.render_dashboard()
-        self.console.print(table)
-        self.console.print()  # Add spacing
+        self._console.print(table)
+        self._console.print()  # Add spacing
 
     def get_dashboard_string(self) -> str:
         """

code_puppy/mcp_/managed_server.py

@@ -6,7 +6,7 @@ that adds management capabilities while maintaining 100% compatibility.
 """
 
 import json
-import logging
+import os
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
@@ -27,8 +27,30 @@ from code_puppy.http_utils import create_async_client
 from code_puppy.mcp_.blocking_startup import BlockingMCPServerStdio
 from code_puppy.messaging import emit_info
 
-# Configure logging
-logger = logging.getLogger(__name__)
+
+def _expand_env_vars(value: Any) -> Any:
+    """
+    Recursively expand environment variables in config values.
+
+    Supports $VAR and ${VAR} syntax. Works with:
+    - Strings: expands env vars
+    - Dicts: recursively expands all string values
+    - Lists: recursively expands all string elements
+    - Other types: returned as-is
+
+    Args:
+        value: The value to expand env vars in
+
+    Returns:
+        The value with env vars expanded
+    """
+    if isinstance(value, str):
+        return os.path.expandvars(value)
+    elif isinstance(value, dict):
+        return {k: _expand_env_vars(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        return [_expand_env_vars(item) for item in value]
+    return value
 
 
 class ServerState(Enum):
@@ -62,7 +84,7 @@ async def process_tool_call(
     """A tool call processor that passes along the deps."""
     group_id = uuid.uuid4()
     emit_info(
-        f"\n[bold white on purple] MCP Tool Call - {name}[/bold white on purple]",
+        f"\nMCP Tool Call - {name}",
         message_group=group_id,
     )
     emit_info("\nArgs:", message_group=group_id)
@@ -114,7 +136,6 @@ class ManagedMCPServer:
             # Always start as STOPPED - servers must be explicitly started
             self._state = ServerState.STOPPED
         except Exception as e:
-            logger.error(f"Failed to create server {self.config.name}: {e}")
             self._state = ServerState.ERROR
             self._error_message = str(e)
 
@@ -157,9 +178,9 @@ class ManagedMCPServer:
                 if "url" not in config:
                     raise ValueError("SSE server requires 'url' in config")
 
-                # Prepare arguments for MCPServerSSE
+                # Prepare arguments for MCPServerSSE (expand env vars in URL)
                 sse_kwargs = {
-                    "url": config["url"],
+                    "url": _expand_env_vars(config["url"]),
                 }
 
                 # Add optional parameters if provided
@@ -181,23 +202,26 @@ class ManagedMCPServer:
                 if "command" not in config:
                     raise ValueError("Stdio server requires 'command' in config")
 
-                # Handle command and arguments
-                command = config["command"]
+                # Handle command and arguments (expand env vars)
+                command = _expand_env_vars(config["command"])
                 args = config.get("args", [])
                 if isinstance(args, str):
-                    # If args is a string, split it
-                    args = args.split()
+                    # If args is a string, split it then expand
+                    args = [_expand_env_vars(a) for a in args.split()]
+                else:
+                    args = _expand_env_vars(args)
 
                 # Prepare arguments for MCPServerStdio
                 stdio_kwargs = {"command": command, "args": list(args) if args else []}
 
-                # Add optional parameters if provided
+                # Add optional parameters if provided (expand env vars in env and cwd)
                 if "env" in config:
-                    stdio_kwargs["env"] = config["env"]
+                    stdio_kwargs["env"] = _expand_env_vars(config["env"])
                 if "cwd" in config:
-                    stdio_kwargs["cwd"] = config["cwd"]
-                if "timeout" in config:
-                    stdio_kwargs["timeout"] = config["timeout"]
+                    stdio_kwargs["cwd"] = _expand_env_vars(config["cwd"])
+                # Default timeout of 60s for stdio servers - some servers like Serena take a while to start
+                # Users can override this in their config
+                stdio_kwargs["timeout"] = config.get("timeout", 60)
                 if "read_timeout" in config:
                     stdio_kwargs["read_timeout"] = config["read_timeout"]
 
@@ -207,8 +231,8 @@ class ManagedMCPServer:
                 self._pydantic_server = BlockingMCPServerStdio(
                     **stdio_kwargs,
                     process_tool_call=process_tool_call,
-                    tool_prefix=config["name"],
-                    emit_stderr=True,  # Always emit stderr for now
+                    tool_prefix=self.config.name,
+                    emit_stderr=False,  # Logs go to file, not console (use /mcp logs to view)
                     message_group=message_group,
                 )
 
@@ -216,9 +240,9 @@ class ManagedMCPServer:
                 if "url" not in config:
                     raise ValueError("HTTP server requires 'url' in config")
 
-                # Prepare arguments for MCPServerStreamableHTTP
+                # Prepare arguments for MCPServerStreamableHTTP (expand env vars in URL)
                 http_kwargs = {
-                    "url": config["url"],
+                    "url": _expand_env_vars(config["url"]),
                 }
 
                 # Add optional parameters if provided
@@ -226,9 +250,15 @@ class ManagedMCPServer:
                     http_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
-                if "headers" in config:
-                    http_kwargs["headers"] = config.get("headers")
-                    # Create HTTP client if headers are provided but no client specified
+
+                # Pass headers directly instead of creating http_client
+                # Note: There's a bug in MCP 1.25.0 where passing http_client
+                # causes "'_AsyncGeneratorContextManager' object has no attribute 'stream'"
+                # The workaround is to pass headers directly and let pydantic-ai
+                # create the http_client internally.
+                if config.get("headers"):
+                    # Expand environment variables in headers
+                    http_kwargs["headers"] = _expand_env_vars(config["headers"])
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call
@@ -237,12 +267,7 @@ class ManagedMCPServer:
             else:
                 raise ValueError(f"Unsupported server type: {server_type}")
 
-            logger.info(f"Created {server_type} server: {self.config.name}")
-
-        except Exception as e:
-            logger.error(
-                f"Failed to create {server_type} server {self.config.name}: {e}"
-            )
+        except Exception:
             raise
 
     def _get_http_client(self) -> httpx.AsyncClient:
@@ -253,8 +278,18 @@ class ManagedMCPServer:
             Configured async HTTP client with custom headers
         """
         headers = self.config.config.get("headers", {})
+
+        # Expand environment variables in headers
+        resolved_headers = {}
+        if isinstance(headers, dict):
+            for k, v in headers.items():
+                if isinstance(v, str):
+                    resolved_headers[k] = os.path.expandvars(v)
+                else:
+                    resolved_headers[k] = v
+
         timeout = self.config.config.get("timeout", 30)
-        client = create_async_client(headers=headers, timeout=timeout)
+        client = create_async_client(headers=resolved_headers, timeout=timeout)
         return client
 
     def enable(self) -> None:
@@ -263,7 +298,6 @@ class ManagedMCPServer:
         if self._state == ServerState.STOPPED and self._pydantic_server is not None:
             self._state = ServerState.RUNNING
             self._start_time = datetime.now()
-            logger.info(f"Enabled server: {self.config.name}")
 
     def disable(self) -> None:
         """Disable server availability."""
@@ -271,7 +305,6 @@ class ManagedMCPServer:
         if self._state == ServerState.RUNNING:
             self._state = ServerState.STOPPED
             self._stop_time = datetime.now()
-            logger.info(f"Disabled server: {self.config.name}")
 
     def is_enabled(self) -> bool:
         """
@@ -290,12 +323,7 @@ class ManagedMCPServer:
             duration: Quarantine duration in seconds
         """
         self._quarantine_until = datetime.now() + timedelta(seconds=duration)
-        previous_state = self._state
         self._state = ServerState.QUARANTINED
-        logger.warning(
-            f"Quarantined server {self.config.name} for {duration} seconds "
-            f"(was {previous_state.value})"
-        )
 
     def is_quarantined(self) -> bool:
         """
@@ -315,7 +343,6 @@ class ManagedMCPServer:
                 self._state = (
                     ServerState.RUNNING if self._enabled else ServerState.STOPPED
                 )
-                logger.info(f"Released quarantine for server: {self.config.name}")
             return False
 
         return True