code-puppy 0.0.287__py3-none-any.whl → 0.0.323__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_/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)
+
+        # 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
+        # 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()
 
 
@@ -203,15 +222,23 @@ class BlockingMCPServerStdio(SimpleCapturedMCPServerStdio):
 
             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
 

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,6 +6,7 @@ that adds management capabilities while maintaining 100% compatibility.
 """
 
 import json
+import os
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
@@ -58,7 +59,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)
@@ -202,8 +203,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,
                 )
 
@@ -222,7 +223,16 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
                 if "headers" in config:
-                    http_kwargs["headers"] = config.get("headers")
+                    # Expand environment variables in headers
+                    headers = config.get("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
+                    http_kwargs["headers"] = resolved_headers
                     # Create HTTP client if headers are provided but no client specified
 
                 self._pydantic_server = MCPServerStreamableHTTP(
@@ -243,8 +253,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:

code_puppy/mcp_/manager.py

@@ -78,11 +78,76 @@ class MCPManager:
         # Active managed servers (server_id -> ManagedMCPServer)
         self._managed_servers: Dict[str, ManagedMCPServer] = {}
 
+        # Sync servers from mcp_servers.json into registry
+        self.sync_from_config()
+
         # Load existing servers from registry
         self._initialize_servers()
 
         logger.info("MCPManager initialized with core components")
 
+    def sync_from_config(self) -> None:
+        """Sync servers from mcp_servers.json into the registry.
+
+        This public method ensures that servers defined in the user's
+        configuration file are automatically registered with the manager.
+        It can be called during initialization or manually to reload
+        server configurations.
+
+        This is the single source of truth for syncing mcp_servers.json
+        into the registry, avoiding duplication with base_agent.py.
+        """
+        try:
+            from code_puppy.config import load_mcp_server_configs
+
+            configs = load_mcp_server_configs()
+            if not configs:
+                logger.debug("No servers found in mcp_servers.json")
+                return
+
+            synced_count = 0
+            updated_count = 0
+
+            for name, conf in configs.items():
+                try:
+                    # Create ServerConfig from the loaded configuration
+                    server_config = ServerConfig(
+                        id=conf.get("id", ""),  # Empty ID will be auto-generated
+                        name=name,
+                        type=conf.get("type", "sse"),
+                        enabled=conf.get("enabled", True),
+                        config=conf,
+                    )
+
+                    # Check if server already exists by name
+                    existing = self.registry.get_by_name(name)
+
+                    if not existing:
+                        # Register new server
+                        self.registry.register(server_config)
+                        synced_count += 1
+                        logger.debug(f"Synced new server from config: {name}")
+                    else:
+                        # Update existing server if config has changed
+                        if existing.config != server_config.config:
+                            server_config.id = existing.id  # Keep existing ID
+                            self.registry.update(existing.id, server_config)
+                            updated_count += 1
+                            logger.debug(f"Updated server from config: {name}")
+
+                except Exception as e:
+                    logger.warning(f"Failed to sync server '{name}' from config: {e}")
+                    continue
+
+            if synced_count > 0 or updated_count > 0:
+                logger.info(
+                    f"Synced {synced_count} new and updated {updated_count} servers from mcp_servers.json"
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to sync from mcp_servers.json: {e}")
+            # Don't fail initialization if sync fails
+
     def _initialize_servers(self) -> None:
         """Initialize managed servers from registry configurations."""
         configs = self.registry.list_all()

code_puppy/mcp_/mcp_logs.py

@@ -0,0 +1,224 @@
+"""
+MCP Server Log Management.
+
+This module provides persistent log file management for MCP servers.
+Logs are stored in STATE_DIR/mcp_logs/<server_name>.log
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from code_puppy.config import STATE_DIR
+
+# Maximum log file size in bytes (5MB)
+MAX_LOG_SIZE = 5 * 1024 * 1024
+
+# Number of rotated logs to keep
+MAX_ROTATED_LOGS = 3
+
+
+def get_mcp_logs_dir() -> Path:
+    """
+    Get the directory for MCP server logs.
+
+    Creates the directory if it doesn't exist.
+
+    Returns:
+        Path to the MCP logs directory
+    """
+    logs_dir = Path(STATE_DIR) / "mcp_logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    return logs_dir
+
+
+def get_log_file_path(server_name: str) -> Path:
+    """
+    Get the log file path for a specific server.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Path to the server's log file
+    """
+    # Sanitize server name for filesystem
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+    return get_mcp_logs_dir() / f"{safe_name}.log"
+
+
+def rotate_log_if_needed(server_name: str) -> None:
+    """
+    Rotate log file if it exceeds MAX_LOG_SIZE.
+
+    Args:
+        server_name: Name of the MCP server
+    """
+    log_path = get_log_file_path(server_name)
+
+    if not log_path.exists():
+        return
+
+    # Check if rotation is needed
+    if log_path.stat().st_size < MAX_LOG_SIZE:
+        return
+
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    # Remove oldest rotated log if we're at the limit
+    oldest = logs_dir / f"{safe_name}.log.{MAX_ROTATED_LOGS}"
+    if oldest.exists():
+        oldest.unlink()
+
+    # Shift existing rotated logs
+    for i in range(MAX_ROTATED_LOGS - 1, 0, -1):
+        old_path = logs_dir / f"{safe_name}.log.{i}"
+        new_path = logs_dir / f"{safe_name}.log.{i + 1}"
+        if old_path.exists():
+            old_path.rename(new_path)
+
+    # Rotate current log
+    rotated_path = logs_dir / f"{safe_name}.log.1"
+    log_path.rename(rotated_path)
+
+
+def write_log(server_name: str, message: str, level: str = "INFO") -> None:
+    """
+    Write a log message for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        message: Log message to write
+        level: Log level (INFO, ERROR, WARN, DEBUG)
+    """
+    rotate_log_if_needed(server_name)
+
+    log_path = get_log_file_path(server_name)
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(f"[{timestamp}] [{level}] {message}\n")
+
+
+def read_logs(
+    server_name: str, lines: Optional[int] = None, include_rotated: bool = False
+) -> List[str]:
+    """
+    Read log lines for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        lines: Number of lines to return (from end). None means all lines.
+        include_rotated: Whether to include rotated log files
+
+    Returns:
+        List of log lines (most recent last)
+    """
+    all_lines = []
+
+    # Read rotated logs first (oldest to newest)
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(MAX_ROTATED_LOGS, 0, -1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                with open(rotated_path, "r", encoding="utf-8", errors="replace") as f:
+                    all_lines.extend(f.read().splitlines())
+
+    # Read current log
+    log_path = get_log_file_path(server_name)
+    if log_path.exists():
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            all_lines.extend(f.read().splitlines())
+
+    # Return requested number of lines
+    if lines is not None and lines > 0:
+        return all_lines[-lines:]
+
+    return all_lines
+
+
+def clear_logs(server_name: str, include_rotated: bool = True) -> None:
+    """
+    Clear logs for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        include_rotated: Whether to also clear rotated log files
+    """
+    log_path = get_log_file_path(server_name)
+
+    if log_path.exists():
+        log_path.unlink()
+
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(1, MAX_ROTATED_LOGS + 1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                rotated_path.unlink()
+
+
+def list_servers_with_logs() -> List[str]:
+    """
+    List all servers that have log files.
+
+    Returns:
+        List of server names with log files
+    """
+    logs_dir = get_mcp_logs_dir()
+    servers = set()
+
+    for path in logs_dir.glob("*.log*"):
+        # Extract server name from filename
+        name = path.stem
+        # Remove .log suffix and rotation numbers
+        name = name.replace(".log", "").rstrip(".0123456789")
+        if name:
+            servers.add(name)
+
+    return sorted(servers)
+
+
+def get_log_stats(server_name: str) -> dict:
+    """
+    Get statistics about a server's logs.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Dictionary with log statistics
+    """
+    log_path = get_log_file_path(server_name)
+
+    stats = {
+        "exists": log_path.exists(),
+        "size_bytes": 0,
+        "line_count": 0,
+        "rotated_count": 0,
+        "total_size_bytes": 0,
+    }
+
+    if log_path.exists():
+        stats["size_bytes"] = log_path.stat().st_size
+        stats["total_size_bytes"] = stats["size_bytes"]
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            stats["line_count"] = sum(1 for _ in f)
+
+    # Count rotated logs
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    for i in range(1, MAX_ROTATED_LOGS + 1):
+        rotated_path = logs_dir / f"{safe_name}.log.{i}"
+        if rotated_path.exists():
+            stats["rotated_count"] += 1
+            stats["total_size_bytes"] += rotated_path.stat().st_size
+
+    return stats