code-puppy 0.0.302__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,56 +17,73 @@ 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():
@@ -89,16 +105,21 @@ 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:
@@ -108,13 +129,13 @@ class StderrFileCapture:
                                     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()
 
 
@@ -201,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_/config_wizard.py

@@ -9,6 +9,8 @@ import re
 from typing import Dict, Optional
 from urllib.parse import urlparse
 
+from rich.text import Text
+
 from code_puppy.mcp_.manager import ServerConfig, get_mcp_manager
 from code_puppy.messaging import (
     emit_error,
@@ -487,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_/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
@@ -203,7 +204,7 @@ class ManagedMCPServer:
                     **stdio_kwargs,
                     process_tool_call=process_tool_call,
                     tool_prefix=self.config.name,
-                    emit_stderr=True,  # Always emit stderr for now
+                    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

code_puppy/messaging/__init__.py

@@ -29,6 +29,13 @@ Example (new):
     >>> bus.emit(TextMessage(level=MessageLevel.INFO, text="Hello"))
 """
 
+# =============================================================================
+# Apply Rich Markdown patches (left-justified headers)
+# =============================================================================
+from .markdown_patches import patch_markdown_headings
+
+patch_markdown_headings()
+
 # =============================================================================
 # Legacy API (backward compatible)
 # =============================================================================
@@ -36,6 +43,11 @@ Example (new):
 # Message bus
 from .bus import (
     MessageBus,
+    emit_shell_line,
+    get_message_bus,
+    get_session_context,
+    reset_message_bus,
+    set_session_context,
 )
 from .bus import emit as bus_emit  # Convenience functions (new API versions)
 from .bus import emit_debug as bus_emit_debug
@@ -43,10 +55,6 @@ from .bus import emit_error as bus_emit_error
 from .bus import emit_info as bus_emit_info
 from .bus import emit_success as bus_emit_success
 from .bus import emit_warning as bus_emit_warning
-from .bus import (
-    get_message_bus,
-    reset_message_bus,
-)
 
 # Command types (UI -> Agent)
 from .commands import (  # Base; Agent control; User interaction responses; Union type
@@ -98,6 +106,7 @@ from .messages import (  # Enums, Base, Text, File ops, Diff, Shell, Agent, etc.
     MessageCategory,
     MessageLevel,
     SelectionRequest,
+    ShellLineMessage,
     ShellOutputMessage,
     ShellStartMessage,
     SpinnerControl,
@@ -177,7 +186,9 @@ __all__ = [
     "DiffLine",
     "DiffMessage",
     "ShellStartMessage",
+    "ShellLineMessage",
     "ShellOutputMessage",
+    "emit_shell_line",
     "AgentReasoningMessage",
     "AgentResponseMessage",
     "SubAgentInvocationMessage",
@@ -201,6 +212,9 @@ __all__ = [
     "MessageBus",
     "get_message_bus",
     "reset_message_bus",
+    # Session context
+    "set_session_context",
+    "get_session_context",
     # New API convenience functions (prefixed to avoid collision)
     "bus_emit",
     "bus_emit_info",
@@ -213,4 +227,6 @@ __all__ = [
     "RichConsoleRenderer",
     "DEFAULT_STYLES",
     "DIFF_STYLES",
+    # Markdown patches
+    "patch_markdown_headings",
 ]