code-puppy 0.0.316__py3-none-any.whl → 0.0.325__py3-none-any.whl

code_puppy/command_line/mcp/logs_command.py

@@ -1,14 +1,21 @@
 """
-MCP Logs Command - Shows recent events/logs for a server.
+MCP Logs Command - Shows server logs from persistent log files.
 """
 
 import logging
-from datetime import datetime
 from typing import List, Optional
 
-from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
 from rich.text import Text
 
+from code_puppy.mcp_.mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    list_servers_with_logs,
+    read_logs,
+)
 from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
@@ -22,105 +29,207 @@ class LogsCommand(MCPCommandBase):
     """
     Command handler for showing MCP server logs.
 
-    Shows recent events/logs for a specific MCP server with configurable limit.
+    Shows logs from persistent log files stored in ~/.code_puppy/mcp_logs/.
     """
 
     def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
         """
-        Show recent events/logs for a server.
+        Show logs for a server.
+
+        Usage:
+            /mcp logs                    - List servers with logs
+            /mcp logs <server_name>      - Show last 50 lines
+            /mcp logs <server_name> 100  - Show last 100 lines
+            /mcp logs <server_name> all  - Show all logs
+            /mcp logs <server_name> --clear - Clear logs for server
 
         Args:
-            args: Command arguments, expects [server_name] and optional [limit]
+            args: Command arguments
             group_id: Optional message group ID for grouping related messages
         """
         if group_id is None:
             group_id = self.generate_group_id()
 
+        # No args - list servers with logs
         if not args:
-            emit_info("Usage: /mcp logs <server_name> [limit]", message_group=group_id)
+            self._list_servers_with_logs(group_id)
             return
 
         server_name = args[0]
-        limit = 10  # Default limit
+
+        # Check for --clear flag
+        if len(args) > 1 and args[1] == "--clear":
+            self._clear_logs(server_name, group_id)
+            return
+
+        # Determine number of lines
+        lines = 50  # Default
+        show_all = False
 
         if len(args) > 1:
-            try:
-                limit = int(args[1])
-                if limit <= 0 or limit > 100:
+            if args[1].lower() == "all":
+                show_all = True
+            else:
+                try:
+                    lines = int(args[1])
+                    if lines <= 0:
+                        emit_info(
+                            "Lines must be positive, using default: 50",
+                            message_group=group_id,
+                        )
+                        lines = 50
+                except ValueError:
                     emit_info(
-                        "Limit must be between 1 and 100, using default: 10",
+                        f"Invalid number '{args[1]}', using default: 50",
                         message_group=group_id,
                     )
-                    limit = 10
-            except ValueError:
-                emit_info(
-                    f"Invalid limit '{args[1]}', using default: 10",
-                    message_group=group_id,
-                )
 
+        self._show_logs(server_name, lines if not show_all else None, group_id)
+
+    def _list_servers_with_logs(self, group_id: str) -> None:
+        """List all servers that have log files."""
+        servers = list_servers_with_logs()
+
+        if not servers:
+            emit_info(
+                "📋 No MCP server logs found.\n"
+                "Logs are created when servers are started.",
+                message_group=group_id,
+            )
+            return
+
+        lines = ["📋 **Servers with logs:**\n"]
+
+        for server in servers:
+            stats = get_log_stats(server)
+            size_kb = stats["total_size_bytes"] / 1024
+            size_str = (
+                f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
+            )
+            rotated = (
+                f" (+{stats['rotated_count']} rotated)"
+                if stats["rotated_count"]
+                else ""
+            )
+            lines.append(
+                f"  • **{server}** - {stats['line_count']} lines, {size_str}{rotated}"
+            )
+
+        lines.append("\n**Usage:** `/mcp logs <server_name> [lines|all]`")
+
+        emit_info("\n".join(lines), message_group=group_id)
+
+    def _show_logs(self, server_name: str, lines: Optional[int], group_id: str) -> None:
+        """
+        Show logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            lines: Number of lines to show, or None for all
+            group_id: Message group ID
+        """
         try:
-            # Find server by name
+            # Verify server exists in manager
             server_id = find_server_id_by_name(self.manager, server_name)
             if not server_id:
-                emit_info(f"Server '{server_name}' not found", message_group=group_id)
-                suggest_similar_servers(self.manager, server_name, group_id=group_id)
-                return
+                # Server not configured, but might have logs from before
+                stats = get_log_stats(server_name)
+                if not stats["exists"]:
+                    emit_info(
+                        f"Server '{server_name}' not found and has no logs.",
+                        message_group=group_id,
+                    )
+                    suggest_similar_servers(
+                        self.manager, server_name, group_id=group_id
+                    )
+                    return
 
-            # Get server status which includes recent events
-            status = self.manager.get_server_status(server_id)
+            # Read logs
+            log_lines = read_logs(server_name, lines=lines)
 
-            if not status.get("exists", True):
+            if not log_lines:
                 emit_info(
-                    f"Server '{server_name}' status not available",
+                    f"📋 No logs found for server: **{server_name}**\n"
+                    f"Log file: `{get_log_file_path(server_name)}`",
                     message_group=group_id,
                 )
                 return
 
-            recent_events = status.get("recent_events", [])
-
-            if not recent_events:
-                emit_info(
-                    f"No recent events for server: {server_name}",
-                    message_group=group_id,
+            # Get stats for header
+            stats = get_log_stats(server_name)
+            total_lines = stats["line_count"]
+            showing = len(log_lines)
+
+            # Format header
+            if lines is None:
+                header = f"📋 Logs for {server_name} (all {total_lines} lines)"
+            else:
+                header = (
+                    f"📋 Logs for {server_name} (last {showing} of {total_lines} lines)"
                 )
-                return
 
-            # Show events in a table
-            table = Table(title=f"📋 Recent Events for {server_name} (last {limit})")
-            table.add_column("Time", style="dim", no_wrap=True)
-            table.add_column("Event", style="cyan")
-            table.add_column("Details", style="dim")
+            # Format log content with syntax highlighting
+            log_content = "\n".join(log_lines)
+
+            # Create a panel with the logs
+            syntax = Syntax(
+                log_content,
+                "log",
+                theme="monokai",
+                word_wrap=True,
+                line_numbers=False,
+            )
 
-            # Take only the requested number of events
-            events_to_show = (
-                recent_events[-limit:] if len(recent_events) > limit else recent_events
+            panel = Panel(
+                syntax,
+                title=header,
+                subtitle=f"Log file: {get_log_file_path(server_name)}",
+                border_style="dim",
             )
 
-            for event in reversed(events_to_show):  # Show newest first
-                timestamp = datetime.fromisoformat(event["timestamp"])
-                time_str = timestamp.strftime("%H:%M:%S")
-                event_type = event["event_type"]
-
-                # Format details
-                details = event.get("details", {})
-                details_str = details.get("message", "")
-                if not details_str and "error" in details:
-                    details_str = str(details["error"])
-
-                # Color code event types
-                event_style = "cyan"
-                if "error" in event_type.lower():
-                    event_style = "red"
-                elif event_type in ["started", "enabled", "registered"]:
-                    event_style = "green"
-                elif event_type in ["stopped", "disabled"]:
-                    event_style = "yellow"
-
-                table.add_row(
-                    time_str, Text(event_type, style=event_style), details_str or "-"
+            emit_info(panel, message_group=group_id)
+
+            # Show hint for more options
+            if lines is not None and showing < total_lines:
+                emit_info(
+                    Text.from_markup(
+                        f"[dim]💡 Use `/mcp logs {server_name} all` to see all logs, "
+                        f"or `/mcp logs {server_name} <number>` for specific count[/dim]"
+                    ),
+                    message_group=group_id,
                 )
-            emit_info(table, message_group=group_id)
 
         except Exception as e:
             logger.error(f"Error getting logs for server '{server_name}': {e}")
             emit_error(f"Error getting logs: {e}", message_group=group_id)
+
+    def _clear_logs(self, server_name: str, group_id: str) -> None:
+        """
+        Clear logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            group_id: Message group ID
+        """
+        try:
+            stats = get_log_stats(server_name)
+
+            if not stats["exists"] and stats["rotated_count"] == 0:
+                emit_info(
+                    f"No logs to clear for server: {server_name}",
+                    message_group=group_id,
+                )
+                return
+
+            # Clear the logs
+            clear_logs(server_name, include_rotated=True)
+
+            cleared_count = 1 + stats["rotated_count"]
+            emit_info(
+                f"🗑️  Cleared {cleared_count} log file(s) for **{server_name}**",
+                message_group=group_id,
+            )
+
+        except Exception as e:
+            logger.error(f"Error clearing logs for server '{server_name}': {e}")
+            emit_error(f"Error clearing logs: {e}", message_group=group_id)

code_puppy/command_line/model_settings_menu.py

@@ -84,6 +84,12 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "default": 10000,
         "format": "{:.0f}",
     },
+    "interleaved_thinking": {
+        "name": "Interleaved Thinking",
+        "description": "Enable thinking between tool calls (Claude 4 only: Opus 4.5, Opus 4.1, Opus 4, Sonnet 4). Adds beta header. WARNING: On Vertex/Bedrock, this FAILS for non-Claude 4 models!",
+        "type": "boolean",
+        "default": False,
+    },
 }
 
 

code_puppy/keymap.py

@@ -86,9 +86,15 @@ def cancel_agent_uses_signal() -> bool:
     """Check if the cancel agent key uses SIGINT (Ctrl+C).
 
     Returns:
-        True if the cancel key is ctrl+c (uses SIGINT handler),
-        False if it uses keyboard listener approach.
+        True if the cancel key is ctrl+c AND we're not on Windows
+        (uses SIGINT handler), False if it uses keyboard listener approach.
     """
+    import sys
+
+    # On Windows, always use keyboard listener - SIGINT is unreliable
+    if sys.platform == "win32":
+        return False
+
     return get_cancel_agent_key() == "ctrl+c"
 
 

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")
 
-        # Start monitoring thread
+        # 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():
@@ -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()
 
 

code_puppy/mcp_/managed_server.py

@@ -204,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,
                 )