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

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()
@@ -404,41 +469,57 @@ class MCPManager:
     def start_server_sync(self, server_id: str) -> bool:
         """
         Synchronous wrapper for start_server.
+
+        IMPORTANT: This schedules the server start as a background task.
+        The server subprocess will start asynchronously - it may not be
+        immediately ready when this function returns.
         """
         try:
-            asyncio.get_running_loop()
-            # We're in an async context, but we need to wait for completion
-            # Create a future and schedule the coroutine
+            loop = asyncio.get_running_loop()
+            # We're in an async context - schedule the server start as a background task
+            # DO NOT use blocking time.sleep() here as it freezes the event loop!
 
-            # Use run_in_executor to run the async function synchronously
-            async def run_async():
-                return await self.start_server(server_id)
+            # First, enable the server immediately so it's recognized as "starting"
+            managed_server = self._managed_servers.get(server_id)
+            if managed_server:
+                managed_server.enable()
+                self.status_tracker.set_status(server_id, ServerState.STARTING)
+                self.status_tracker.record_start_time(server_id)
 
-            # Schedule the task and wait briefly for it to complete
-            task = asyncio.create_task(run_async())
+            # Schedule the async start_server to run in the background
+            # This will properly start the subprocess and lifecycle task
+            async def start_server_background():
+                try:
+                    result = await self.start_server(server_id)
+                    if result:
+                        logger.info(f"Background server start completed: {server_id}")
+                    else:
+                        logger.warning(f"Background server start failed: {server_id}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Background server start error for {server_id}: {e}")
+                    self.status_tracker.set_status(server_id, ServerState.ERROR)
+                    return False
+
+            # Create the task - it will run when the event loop gets control
+            task = loop.create_task(
+                start_server_background(), name=f"start_server_{server_id}"
+            )
 
-            # Give it a moment to complete - this fixes the race condition
-            import time
+            # Store task reference to prevent garbage collection
+            if not hasattr(self, "_pending_start_tasks"):
+                self._pending_start_tasks = {}
+            self._pending_start_tasks[server_id] = task
 
-            time.sleep(0.1)  # Small delay to let async tasks progress
+            # Add callback to clean up task reference when done
+            def cleanup_task(t):
+                if hasattr(self, "_pending_start_tasks"):
+                    self._pending_start_tasks.pop(server_id, None)
 
-            # Check if task completed, if not, fall back to sync enable
-            if task.done():
-                try:
-                    result = task.result()
-                    return result
-                except Exception:
-                    pass
+            task.add_done_callback(cleanup_task)
 
-            # If async didn't complete, enable synchronously
-            managed_server = self._managed_servers.get(server_id)
-            if managed_server:
-                managed_server.enable()
-                self.status_tracker.set_status(server_id, ServerState.RUNNING)
-                self.status_tracker.record_start_time(server_id)
-                logger.info(f"Enabled server synchronously: {server_id}")
-                return True
-            return False
+            logger.info(f"Scheduled background start for server: {server_id}")
+            return True  # Return immediately - server will start in background
 
         except RuntimeError:
             # No async loop, just enable the server
@@ -517,39 +598,52 @@ class MCPManager:
     def stop_server_sync(self, server_id: str) -> bool:
         """
         Synchronous wrapper for stop_server.
+
+        IMPORTANT: This schedules the server stop as a background task.
+        The server subprocess will stop asynchronously.
         """
         try:
-            asyncio.get_running_loop()
+            loop = asyncio.get_running_loop()
+            # We're in an async context - schedule the server stop as a background task
+            # DO NOT use blocking time.sleep() here as it freezes the event loop!
 
-            # We're in an async context, but we need to wait for completion
-            async def run_async():
-                return await self.stop_server(server_id)
+            # First, disable the server immediately
+            managed_server = self._managed_servers.get(server_id)
+            if managed_server:
+                managed_server.disable()
+                self.status_tracker.set_status(server_id, ServerState.STOPPING)
+                self.status_tracker.record_stop_time(server_id)
 
-            # Schedule the task and wait briefly for it to complete
-            task = asyncio.create_task(run_async())
+            # Schedule the async stop_server to run in the background
+            async def stop_server_background():
+                try:
+                    result = await self.stop_server(server_id)
+                    if result:
+                        logger.info(f"Background server stop completed: {server_id}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Background server stop error for {server_id}: {e}")
+                    return False
 
-            # Give it a moment to complete - this fixes the race condition
-            import time
+            # Create the task - it will run when the event loop gets control
+            task = loop.create_task(
+                stop_server_background(), name=f"stop_server_{server_id}"
+            )
 
-            time.sleep(0.1)  # Small delay to let async tasks progress
+            # Store task reference to prevent garbage collection
+            if not hasattr(self, "_pending_stop_tasks"):
+                self._pending_stop_tasks = {}
+            self._pending_stop_tasks[server_id] = task
 
-            # Check if task completed, if not, fall back to sync disable
-            if task.done():
-                try:
-                    result = task.result()
-                    return result
-                except Exception:
-                    pass
+            # Add callback to clean up task reference when done
+            def cleanup_task(t):
+                if hasattr(self, "_pending_stop_tasks"):
+                    self._pending_stop_tasks.pop(server_id, None)
 
-            # If async didn't complete, disable synchronously
-            managed_server = self._managed_servers.get(server_id)
-            if managed_server:
-                managed_server.disable()
-                self.status_tracker.set_status(server_id, ServerState.STOPPED)
-                self.status_tracker.record_stop_time(server_id)
-                logger.info(f"Disabled server synchronously: {server_id}")
-                return True
-            return False
+            task.add_done_callback(cleanup_task)
+
+            logger.info(f"Scheduled background stop for server: {server_id}")
+            return True  # Return immediately - server will stop in background
 
         except RuntimeError:
             # No async loop, just disable the server

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/mcp_/registry.py

@@ -12,6 +12,7 @@ import uuid
 from pathlib import Path
 from typing import Dict, List, Optional
 
+from code_puppy import config
 from .managed_server import ServerConfig
 
 # Configure logging
@@ -23,7 +24,7 @@ class ServerRegistry:
     Registry for managing MCP server configurations.
 
     Provides CRUD operations for server configurations with thread-safe access,
-    validation, and persistent storage to ~/.code_puppy/mcp_registry.json.
+    validation, and persistent storage to XDG_DATA_HOME/code_puppy/mcp_registry.json.
 
     All operations are thread-safe and use JSON serialization for ServerConfig objects.
     Handles file not existing gracefully and validates configurations according to
@@ -36,13 +37,12 @@ class ServerRegistry:
 
         Args:
             storage_path: Optional custom path for registry storage.
-                         Defaults to ~/.code_puppy/mcp_registry.json
+                         Defaults to XDG_DATA_HOME/code_puppy/mcp_registry.json
         """
         if storage_path is None:
-            home_dir = Path.home()
-            code_puppy_dir = home_dir / ".code_puppy"
-            code_puppy_dir.mkdir(exist_ok=True)
-            self._storage_path = code_puppy_dir / "mcp_registry.json"
+            data_dir = Path(config.DATA_DIR)
+            data_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+            self._storage_path = data_dir / "mcp_registry.json"
         else:
             self._storage_path = Path(storage_path)
 

code_puppy/mcp_/server_registry_catalog.py

@@ -121,13 +121,13 @@ class MCPServerTemplate:
         if "env" in config:
             for env_key, env_value in config["env"].items():
                 if isinstance(env_value, str) and "${" in env_value:
-                    # Replace placeholders in env values
+                    # Replace all placeholders in env values
+                    new_value = env_value
                     for key, value in cmd_args.items():
                         placeholder = f"${{{key}}}"
-                        if placeholder in env_value:
-                            config["env"][env_key] = env_value.replace(
-                                placeholder, str(value)
-                            )
+                        if placeholder in new_value:
+                            new_value = new_value.replace(placeholder, str(value))
+                    config["env"][env_key] = new_value
 
         return config
 
@@ -803,6 +803,25 @@ MCP_SERVER_REGISTRY: List[MCPServerTemplate] = [
         ),
         example_usage="Cloud-based service - no local setup required",
     ),
+    MCPServerTemplate(
+        id="sse-example",
+        name="sse-example",
+        display_name="SSE Example Server",
+        description="Example Server-Sent Events MCP server for testing SSE connections",
+        category="Development",
+        tags=["sse", "example", "testing", "events"],
+        type="sse",
+        config={
+            "url": "http://localhost:8080/sse",
+            "headers": {"Authorization": "Bearer $SSE_API_KEY"},
+        },
+        verified=False,
+        popular=False,
+        requires=MCPServerRequirements(
+            environment_vars=["SSE_API_KEY"],
+        ),
+        example_usage="Example SSE server - for testing purposes",
+    ),
     MCPServerTemplate(
         id="confluence",
         name="confluence",