code-puppy 0.0.341__py3-none-any.whl → 0.0.361__py3-none-any.whl

code_puppy/mcp_/managed_server.py

@@ -28,6 +28,31 @@ from code_puppy.mcp_.blocking_startup import BlockingMCPServerStdio
 from code_puppy.messaging import emit_info
 
 
+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):
     """Enumeration of possible server states."""
 
@@ -153,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
@@ -177,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"]
 
@@ -212,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
@@ -223,13 +251,14 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
 
-                # Handle http_client vs headers (mutually exclusive)
-                if "http_client" in config:
-                    # Use provided http_client
-                    http_kwargs["http_client"] = config["http_client"]
-                elif config.get("headers"):
-                    # Create HTTP client if headers are provided but no client specified
-                    http_kwargs["http_client"] = self._get_http_client()
+                # 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

code_puppy/mcp_/manager.py

@@ -469,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!
+
+            # 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)
 
-            # Use run_in_executor to run the async function synchronously
-            async def run_async():
-                return await self.start_server(server_id)
+            # 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
 
-            # Schedule the task and wait briefly for it to complete
-            task = asyncio.create_task(run_async())
+            # 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
@@ -582,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/messaging/__init__.py

@@ -113,6 +113,7 @@ from .messages import (  # Enums, Base, Text, File ops, Diff, Shell, Agent, etc.
     StatusPanelMessage,
     SubAgentInvocationMessage,
     SubAgentResponseMessage,
+    SubAgentStatusMessage,
     TextMessage,
     UserInputRequest,
     VersionCheckMessage,
@@ -120,6 +121,14 @@ from .messages import (  # Enums, Base, Text, File ops, Diff, Shell, Agent, etc.
 from .queue_console import QueueConsole, get_queue_console
 from .renderers import InteractiveRenderer, SynchronousInteractiveRenderer
 
+# Sub-agent console manager
+from .subagent_console import (
+    AgentState,
+    SubAgentConsoleManager,
+    get_subagent_console_manager,
+    STATUS_STYLES as SUBAGENT_STATUS_STYLES,
+)
+
 # Renderer
 from .rich_renderer import (
     DEFAULT_STYLES,
@@ -193,6 +202,7 @@ __all__ = [
     "AgentResponseMessage",
     "SubAgentInvocationMessage",
     "SubAgentResponseMessage",
+    "SubAgentStatusMessage",
     "UserInputRequest",
     "ConfirmationRequest",
     "SelectionRequest",
@@ -229,4 +239,9 @@ __all__ = [
     "DIFF_STYLES",
     # Markdown patches
     "patch_markdown_headings",
+    # Sub-agent console manager
+    "AgentState",
+    "SubAgentConsoleManager",
+    "get_subagent_console_manager",
+    "SUBAGENT_STATUS_STYLES",
 ]

code_puppy/messaging/message_queue.py

@@ -329,31 +329,19 @@ def emit_divider(content: str = "─" * 100 + "\n", **metadata):
 
 
 def emit_prompt(prompt_text: str, timeout: float = None) -> str:
-    """Emit a human input request and wait for response."""
-    # TUI mode has been removed, always use interactive mode input
-    if True:
-        # Emit the prompt as a message for display
-        from code_puppy.messaging import emit_info
+    """Emit a human input request and wait for response.
 
-        emit_info(prompt_text)
+    Uses safe_input for cross-platform compatibility, especially on Windows
+    where raw input() can fail after prompt_toolkit Applications.
+    """
+    from code_puppy.command_line.utils import safe_input
+    from code_puppy.messaging import emit_info
 
-        # Get input directly
-        try:
-            # Try to use rich console for better formatting
-            from rich.console import Console
-
-            console = Console()
-            response = console.input("[cyan]>>> [/cyan]")
-            return response
-        except Exception:
-            # Fallback to basic input
-            response = input(">>> ")
-            return response
-
-    # In TUI mode, use the queue system
-    queue = get_global_queue()
-    prompt_id = queue.create_prompt_request(prompt_text)
-    return queue.wait_for_prompt_response(prompt_id, timeout)
+    emit_info(prompt_text)
+
+    # Use safe_input which resets Windows console state before reading
+    response = safe_input(">>> ")
+    return response
 
 
 def provide_prompt_response(prompt_id: str, response: str):

code_puppy/messaging/messages.py

@@ -292,6 +292,31 @@ class SubAgentResponseMessage(BaseMessage):
     )
 
 
+class SubAgentStatusMessage(BaseMessage):
+    """Real-time status update for a running sub-agent."""
+
+    category: MessageCategory = MessageCategory.AGENT
+    session_id: str = Field(description="Unique session ID of the sub-agent")
+    agent_name: str = Field(description="Name of the agent (e.g., 'code-puppy')")
+    model_name: str = Field(description="Model being used by this agent")
+    status: Literal[
+        "starting", "running", "thinking", "tool_calling", "completed", "error"
+    ] = Field(description="Current status of the agent")
+    tool_call_count: int = Field(
+        default=0, ge=0, description="Number of tools called so far"
+    )
+    token_count: int = Field(default=0, ge=0, description="Estimated tokens in context")
+    current_tool: Optional[str] = Field(
+        default=None, description="Name of tool currently being called"
+    )
+    elapsed_seconds: float = Field(
+        default=0.0, ge=0, description="Time since agent started"
+    )
+    error_message: Optional[str] = Field(
+        default=None, description="Error message if status is 'error'"
+    )
+
+
 # =============================================================================
 # User Interaction Messages (Agent → User)
 # =============================================================================
@@ -417,6 +442,7 @@ AnyMessage = Union[
     AgentResponseMessage,
     SubAgentInvocationMessage,
     SubAgentResponseMessage,
+    SubAgentStatusMessage,
     UserInputRequest,
     ConfirmationRequest,
     SelectionRequest,
@@ -458,6 +484,7 @@ __all__ = [
     "AgentResponseMessage",
     "SubAgentInvocationMessage",
     "SubAgentResponseMessage",
+    "SubAgentStatusMessage",
     # User interaction
     "UserInputRequest",
     "ConfirmationRequest",

code_puppy/messaging/queue_console.py

@@ -239,7 +239,7 @@ class QueueConsole:
             # Show the user's response in the chat as well
             if user_response:
                 self.queue.emit_simple(
-                    MessageType.USER, f"User response: {user_response}"
+                    MessageType.INFO, f"User response: {user_response}"
                 )
 
             return user_response

code_puppy/messaging/rich_renderer.py

@@ -18,7 +18,9 @@ from rich.rule import Rule
 # Note: Syntax import removed - file content not displayed, only header
 from rich.table import Table
 
+from code_puppy.config import get_subagent_verbose
 from code_puppy.tools.common import format_diff_with_colors
+from code_puppy.tools.subagent_context import is_subagent
 
 from .bus import MessageBus
 from .commands import (
@@ -159,6 +161,14 @@ class RichConsoleRenderer:
         color = self._get_banner_color(banner_name)
         return f"[bold white on {color}] {text} [/bold white on {color}]"
 
+    def _should_suppress_subagent_output(self) -> bool:
+        """Check if sub-agent output should be suppressed.
+
+        Returns:
+            True if we're in a sub-agent context and verbose mode is disabled
+        """
+        return is_subagent() and not get_subagent_verbose()
+
     # =========================================================================
     # Lifecycle (Synchronous - for compatibility with main.py)
     # =========================================================================
@@ -275,7 +285,8 @@ class RichConsoleRenderer:
         elif isinstance(message, SubAgentInvocationMessage):
             self._render_subagent_invocation(message)
         elif isinstance(message, SubAgentResponseMessage):
-            self._render_subagent_response(message)
+            # Skip rendering - we now display sub-agent responses via display_non_streamed_result
+            pass
         elif isinstance(message, UserInputRequest):
             # Can't handle async user input in sync context - skip
             self._console.print("[dim]User input requested (requires async)[/dim]")
@@ -356,6 +367,10 @@ class RichConsoleRenderer:
         - Total size
         - Number of subdirectories
         """
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
         import os
         from collections import defaultdict
 
@@ -478,6 +493,10 @@ class RichConsoleRenderer:
 
         The file content is for the LLM only, not for display in the UI.
         """
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
         # Build line info
         line_info = ""
         if msg.start_line is not None and msg.num_lines is not None:
@@ -492,6 +511,10 @@ class RichConsoleRenderer:
 
     def _render_grep_result(self, msg: GrepResultMessage) -> None:
         """Render grep results grouped by file matching old format."""
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
         import re
 
         # Header
@@ -572,6 +595,10 @@ class RichConsoleRenderer:
 
     def _render_diff(self, msg: DiffMessage) -> None:
         """Render a diff with beautiful syntax highlighting."""
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
         # Operation-specific styling
         op_icons = {"create": "✨", "modify": "✏️", "delete": "🗑️"}
         op_colors = {"create": "green", "modify": "yellow", "delete": "red"}
@@ -616,6 +643,10 @@ class RichConsoleRenderer:
 
     def _render_shell_start(self, msg: ShellStartMessage) -> None:
         """Render shell command start notification."""
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
         # Escape command to prevent Rich markup injection
         safe_command = escape_rich_markup(msg.command)
         # Header showing command is starting
@@ -700,6 +731,10 @@ class RichConsoleRenderer:
 
     def _render_subagent_invocation(self, msg: SubAgentInvocationMessage) -> None:
         """Render sub-agent invocation header with nice formatting."""
+        # Skip for sub-agents unless verbose mode (avoid nested invocation banners)
+        if self._should_suppress_subagent_output():
+            return
+
         # Header with agent name and session
         session_type = (
             "New session"

code_puppy/messaging/spinner/__init__.py

@@ -24,7 +24,16 @@ def unregister_spinner(spinner):
 
 
 def pause_all_spinners():
-    """Pause all active spinners."""
+    """Pause all active spinners.
+
+    No-op when called from a sub-agent context to prevent
+    parallel sub-agents from interfering with the main spinner.
+    """
+    # Lazy import to avoid circular dependency
+    from code_puppy.tools.subagent_context import is_subagent
+
+    if is_subagent():
+        return  # Sub-agents don't control the main spinner
     for spinner in _active_spinners:
         try:
             spinner.pause()
@@ -34,7 +43,16 @@ def pause_all_spinners():
 
 
 def resume_all_spinners():
-    """Resume all active spinners."""
+    """Resume all active spinners.
+
+    No-op when called from a sub-agent context to prevent
+    parallel sub-agents from interfering with the main spinner.
+    """
+    # Lazy import to avoid circular dependency
+    from code_puppy.tools.subagent_context import is_subagent
+
+    if is_subagent():
+        return  # Sub-agents don't control the main spinner
     for spinner in _active_spinners:
         try:
             spinner.resume()