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

code_puppy/command_line/mcp/custom_server_installer.py

@@ -7,6 +7,7 @@ custom MCP servers with JSON configuration.
 import json
 import os
 
+from code_puppy.command_line.utils import safe_input
 from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 
 # Example configurations for each server type
@@ -24,7 +25,7 @@ CUSTOM_SERVER_EXAMPLES = {
   "type": "http",
   "url": "http://localhost:8080/mcp",
   "headers": {
-    "Authorization": "Bearer YOUR_API_KEY",
+    "Authorization": "Bearer $MY_API_KEY",
     "Content-Type": "application/json"
   },
   "timeout": 30
@@ -33,7 +34,7 @@ CUSTOM_SERVER_EXAMPLES = {
   "type": "sse",
   "url": "http://localhost:8080/sse",
   "headers": {
-    "Authorization": "Bearer YOUR_API_KEY"
+    "Authorization": "Bearer $MY_API_KEY"
   }
 }""",
 }
@@ -58,7 +59,7 @@ def prompt_and_install_custom_server(manager) -> bool:
 
     # Get server name
     try:
-        server_name = input("  Server name: ").strip()
+        server_name = safe_input("  Server name: ")
         if not server_name:
             emit_warning("Server name is required")
             return False
@@ -71,9 +72,7 @@ def prompt_and_install_custom_server(manager) -> bool:
     existing = find_server_id_by_name(manager, server_name)
     if existing:
         try:
-            override = input(
-                f"  Server '{server_name}' exists. Override? [y/N]: "
-            ).strip()
+            override = safe_input(f"  Server '{server_name}' exists. Override? [y/N]: ")
             if not override.lower().startswith("y"):
                 emit_warning("Cancelled")
                 return False
@@ -89,7 +88,7 @@ def prompt_and_install_custom_server(manager) -> bool:
     emit_info("    3. 📡 sse    - Server-Sent Events\n")
 
     try:
-        type_choice = input("  Enter choice [1-3]: ").strip()
+        type_choice = safe_input("  Enter choice [1-3]: ")
     except (KeyboardInterrupt, EOFError):
         emit_info("")
         emit_warning("Cancelled")
@@ -115,8 +114,8 @@ def prompt_and_install_custom_server(manager) -> bool:
     empty_count = 0
     try:
         while True:
-            line = input()
-            if line.strip() == "":
+            line = safe_input("")
+            if line == "":
                 empty_count += 1
                 if empty_count >= 2:
                     break

code_puppy/command_line/mcp/handler.py

@@ -12,7 +12,6 @@ from rich.text import Text
 
 from code_puppy.messaging import emit_info
 
-from .add_command import AddCommand
 from .base import MCPCommandBase
 from .edit_command import EditCommand
 from .help_command import HelpCommand
@@ -63,7 +62,6 @@ class MCPCommandHandler(MCPCommandBase):
             "restart": RestartCommand(),
             "status": StatusCommand(),
             "test": TestCommand(),
-            "add": AddCommand(),
             "edit": EditCommand(),
             "remove": RemoveCommand(),
             "logs": LogsCommand(),

code_puppy/command_line/mcp/help_command.py

@@ -101,10 +101,6 @@ class HelpCommand(MCPCommandBase):
                 Text("/mcp logs", style="cyan")
                 + Text(" <name> [limit] Show recent events (default limit: 10)")
             )
-            help_lines.append(
-                Text("/mcp add", style="cyan")
-                + Text(" [json]         Add new server (JSON or wizard)")
-            )
             help_lines.append(
                 Text("/mcp edit", style="cyan")
                 + Text(" <name>        Edit existing server config")
@@ -134,7 +130,7 @@ class HelpCommand(MCPCommandBase):
 /mcp start-all           # Start all servers at once
 /mcp stop-all            # Stop all running servers
 /mcp edit filesystem     # Edit an existing server config
-/mcp add {"name": "test", "type": "stdio", "command": "echo"}"""
+/mcp remove filesystem # Remove a server"""
             help_lines.append(Text(examples_text, style="dim"))
 
             # Combine all lines

code_puppy/command_line/mcp/start_command.py

@@ -3,7 +3,6 @@ MCP Start Command - Starts a specific MCP server.
 """
 
 import logging
-import time
 from typing import List, Optional
 
 from rich.text import Text
@@ -23,6 +22,7 @@ class StartCommand(MCPCommandBase):
     Command handler for starting MCP servers.
 
     Starts a specific MCP server by name and reloads the agent.
+    The server subprocess starts asynchronously in the background.
     """
 
     def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
@@ -56,31 +56,49 @@ class StartCommand(MCPCommandBase):
                 suggest_similar_servers(self.manager, server_name, group_id=group_id)
                 return
 
-            # Start the server (enable and start process)
+            # Get server info for better messaging (safely handle missing method)
+            server_type = "unknown"
+            try:
+                if hasattr(self.manager, "get_server_by_name"):
+                    server_config = self.manager.get_server_by_name(server_name)
+                    server_type = (
+                        getattr(server_config, "type", "unknown")
+                        if server_config
+                        else "unknown"
+                    )
+            except Exception:
+                pass  # Default to unknown type if we can't determine it
+
+            # Start the server (schedules async start in background)
             success = self.manager.start_server_sync(server_id)
 
             if success:
-                # This and subsequent messages will auto-group with the first message
-                emit_success(
-                    f"Started server: {server_name}",
-                    message_group=group_id,
-                )
-
-                # Give async tasks a moment to complete
-                try:
-                    import asyncio
-
-                    asyncio.get_running_loop()  # Check if in async context
-                    # If we're in async context, wait a bit for server to start
-                    time.sleep(0.5)  # Small delay to let async tasks progress
-                except RuntimeError:
-                    pass  # No async loop, server will start when agent uses it
+                if server_type == "stdio":
+                    # Stdio servers start subprocess asynchronously
+                    emit_success(
+                        f"🚀 Starting server: {server_name} (subprocess starting in background)",
+                        message_group=group_id,
+                    )
+                    emit_info(
+                        Text.from_markup(
+                            "[dim]Tip: Use /mcp status to check if the server is fully initialized[/dim]"
+                        ),
+                        message_group=group_id,
+                    )
+                else:
+                    # SSE/HTTP servers connect on first use
+                    emit_success(
+                        f"✅ Enabled server: {server_name}",
+                        message_group=group_id,
+                    )
 
                 # Reload the agent to pick up the newly enabled server
+                # NOTE: We don't block or wait - the server will be ready
+                # when the next prompt runs (pydantic-ai handles connection)
                 try:
                     agent = get_current_agent()
                     agent.reload_code_generation_agent()
-                    # Update MCP tool cache immediately so token counts reflect the change
+                    # Clear MCP tool cache - it will be repopulated on next run
                     agent.update_mcp_tool_cache_sync()
                     emit_info(
                         "Agent reloaded with updated servers",

code_puppy/command_line/onboarding_slides.py

@@ -122,7 +122,6 @@ def slide_mcp() -> str:
     content += "[white]Supercharge with external tools![/white]\n\n"
     content += "[green]Commands:[/green]\n"
     content += "  [cyan]/mcp install[/cyan]  Browse catalog\n"
-    content += "  [cyan]/mcp add[/cyan]      Add custom server\n"
     content += "  [cyan]/mcp list[/cyan]     See your servers\n\n"
     content += "[yellow]🌟 Popular picks:[/yellow]\n"
     content += "  • GitHub integration\n"

code_puppy/command_line/prompt_toolkit_completion.py

@@ -648,30 +648,36 @@ async def get_input_with_combined_completion(
         else:
             event.current_buffer.validate_and_handle()
 
-    # Handle bracketed paste (triggered by most terminal Cmd+V / Ctrl+V)
-    # This is the PRIMARY paste handler - works with Cmd+V on macOS terminals
+    # Handle bracketed paste - smart detection for text vs images.
+    # Most terminals (Windows included!) send Ctrl+V through bracketed paste.
+    # - If there's meaningful text content → paste as text (drag-and-drop file paths, copied text)
+    # - If text is empty/whitespace → check for clipboard image (image paste on Windows)
     @bindings.add(Keys.BracketedPaste)
     def handle_bracketed_paste(event):
-        """Handle bracketed paste - works with Cmd+V on macOS terminals."""
-        # The pasted data is in event.data
+        """Handle bracketed paste - smart text vs image detection."""
         pasted_data = event.data
 
-        # Check if clipboard has an image (the pasted text might just be empty or a file path)
+        # If we have meaningful text content, paste it (don't check for images)
+        # This handles drag-and-drop file paths and normal text paste
+        if pasted_data and pasted_data.strip():
+            # Normalize Windows line endings to Unix style
+            sanitized_data = pasted_data.replace("\r\n", "\n").replace("\r", "\n")
+            event.app.current_buffer.insert_text(sanitized_data)
+            return
+
+        # No meaningful text - check if clipboard has an image (Windows image paste!)
         try:
             if has_image_in_clipboard():
                 placeholder = capture_clipboard_image_to_pending()
                 if placeholder:
                     event.app.current_buffer.insert_text(placeholder + " ")
-                    # The placeholder itself is visible feedback - no need for extra output
-                    # Use bell for audible feedback (works in most terminals)
                     event.app.output.bell()
-                    return  # Don't also paste the text data
+                    return
         except Exception:
             pass
 
-        # No image - insert the pasted text as normal, sanitizing Windows newlines
+        # Fallback: if there was whitespace-only data, paste it
         if pasted_data:
-            # Normalize Windows line endings to Unix style
             sanitized_data = pasted_data.replace("\r\n", "\n").replace("\r", "\n")
             event.app.current_buffer.insert_text(sanitized_data)
 

code_puppy/command_line/utils.py

@@ -37,3 +37,57 @@ def make_directory_table(path: str = None) -> Table:
     for f in sorted(files):
         table.add_row("[yellow]file[/yellow]", f"{f}")
     return table
+
+
+def _reset_windows_console() -> None:
+    """Reset Windows console to normal input mode.
+
+    After a prompt_toolkit Application exits on Windows, the console can be
+    left in a weird state where Enter doesn't work properly. This resets it.
+    """
+    import sys
+
+    if sys.platform != "win32":
+        return
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+        # Get handle to stdin
+        STD_INPUT_HANDLE = -10
+        handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Enable line input and echo (normal console mode)
+        # ENABLE_LINE_INPUT = 0x0002
+        # ENABLE_ECHO_INPUT = 0x0004
+        # ENABLE_PROCESSED_INPUT = 0x0001
+        NORMAL_MODE = 0x0007  # Line input + echo + processed
+        kernel32.SetConsoleMode(handle, NORMAL_MODE)
+    except Exception:
+        pass  # Silently ignore errors - this is best-effort
+
+
+def safe_input(prompt_text: str = "") -> str:
+    """Cross-platform safe input that works after prompt_toolkit Applications.
+
+    On Windows, raw input() can fail after a prompt_toolkit Application exits
+    because the terminal can be left in a weird state. This function resets
+    the Windows console mode before calling input().
+
+    Args:
+        prompt_text: The prompt to display to the user
+
+    Returns:
+        The user's input string (stripped)
+
+    Raises:
+        KeyboardInterrupt: If user presses Ctrl+C
+        EOFError: If user presses Ctrl+D/Ctrl+Z
+    """
+    # Reset Windows console to normal mode before reading input
+    _reset_windows_console()
+
+    # Use standard input() - now that console is reset, it should work
+    result = input(prompt_text)
+    return result.strip() if result else ""

code_puppy/config.py

@@ -75,6 +75,19 @@ def get_use_dbos() -> bool:
     return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
 
 
+def get_subagent_verbose() -> bool:
+    """Return True if sub-agent verbose output is enabled (default False).
+
+    When False (default), sub-agents produce quiet, sparse output suitable
+    for parallel execution. When True, sub-agents produce full verbose output
+    like the main agent (useful for debugging).
+    """
+    cfg_val = get_value("subagent_verbose")
+    if cfg_val is None:
+        return False
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
@@ -85,7 +98,6 @@ _CURRENT_AUTOSAVE_ID: Optional[str] = None
 _model_validation_cache = {}
 _default_model_cache = None
 _default_vision_model_cache = None
-_default_vqa_model_cache = None
 
 
 def ensure_config_exists():
@@ -208,6 +220,9 @@ def get_config_keys():
         "diff_context_lines",
         "default_agent",
         "temperature",
+        "frontend_emitter_enabled",
+        "frontend_emitter_max_recent_events",
+        "frontend_emitter_queue_size",
     ]
     # Add DBOS control key
     default_keys.append("enable_dbos")
@@ -237,6 +252,22 @@ def set_config_value(key: str, value: str):
         config.write(f)
 
 
+# Alias for API compatibility
+def set_value(key: str, value: str) -> None:
+    """Set a config value. Alias for set_config_value."""
+    set_config_value(key, value)
+
+
+def reset_value(key: str) -> None:
+    """Remove a key from the config file, resetting it to default."""
+    config = configparser.ConfigParser()
+    config.read(CONFIG_FILE)
+    if DEFAULT_SECTION in config and key in config[DEFAULT_SECTION]:
+        del config[DEFAULT_SECTION][key]
+        with open(CONFIG_FILE, "w") as f:
+            config.write(f)
+
+
 # --- MODEL STICKY EXTENSION STARTS HERE ---
 def load_mcp_server_configs():
     """
@@ -326,47 +357,6 @@ def _default_vision_model_from_models_json() -> str:
         return "gpt-4.1"
 
 
-def _default_vqa_model_from_models_json() -> str:
-    """Select a default VQA-capable model, preferring vision-ready options."""
-    global _default_vqa_model_cache
-
-    if _default_vqa_model_cache is not None:
-        return _default_vqa_model_cache
-
-    try:
-        from code_puppy.model_factory import ModelFactory
-
-        models_config = ModelFactory.load_config()
-        if models_config:
-            # Allow explicit VQA hints if present
-            for name, config in models_config.items():
-                if config.get("supports_vqa"):
-                    _default_vqa_model_cache = name
-                    return name
-
-            # Reuse multimodal heuristics before falling back to generic default
-            preferred_candidates = (
-                "gpt-4.1",
-                "gpt-4.1-mini",
-                "claude-4-0-sonnet",
-                "gemini-2.5-flash-preview-05-20",
-                "gpt-4.1-nano",
-            )
-            for candidate in preferred_candidates:
-                if candidate in models_config:
-                    _default_vqa_model_cache = candidate
-                    return candidate
-
-            _default_vqa_model_cache = _default_model_from_models_json()
-            return _default_vqa_model_cache
-
-        _default_vqa_model_cache = "gpt-4.1"
-        return "gpt-4.1"
-    except Exception:
-        _default_vqa_model_cache = "gpt-4.1"
-        return "gpt-4.1"
-
-
 def _validate_model_exists(model_name: str) -> bool:
     """Check if a model exists in models.json with caching to avoid redundant calls."""
     global _model_validation_cache
@@ -392,15 +382,10 @@ def _validate_model_exists(model_name: str) -> bool:
 
 def clear_model_cache():
     """Clear the model validation cache. Call this when models.json changes."""
-    global \
-        _model_validation_cache, \
-        _default_model_cache, \
-        _default_vision_model_cache, \
-        _default_vqa_model_cache
+    global _model_validation_cache, _default_model_cache, _default_vision_model_cache
     _model_validation_cache.clear()
     _default_model_cache = None
     _default_vision_model_cache = None
-    _default_vqa_model_cache = None
 
 
 def model_supports_setting(model_name: str, setting: str) -> bool:
@@ -471,20 +456,6 @@ def set_model_name(model: str):
     clear_model_cache()
 
 
-def get_vqa_model_name() -> str:
-    """Return the configured VQA model, falling back to an inferred default."""
-    stored_model = get_value("vqa_model_name")
-    if stored_model and _validate_model_exists(stored_model):
-        return stored_model
-    return _default_vqa_model_from_models_json()
-
-
-def set_vqa_model_name(model: str):
-    """Persist the configured VQA model name and refresh caches."""
-    set_config_value("vqa_model_name", model or "")
-    clear_model_cache()
-
-
 def get_puppy_token():
     """Returns the puppy_token from config, or None if not set."""
     return get_value("puppy_token")
@@ -1291,6 +1262,8 @@ DEFAULT_BANNER_COLORS = {
     "invoke_agent": "deep_pink4",  # Ruby - agent invocation
     "subagent_response": "sea_green3",  # Emerald - sub-agent success
     "list_agents": "dark_slate_gray3",  # Slate - neutral listing
+    # Browser/Terminal tools - same color as edit_file (gold)
+    "terminal_tool": "dark_goldenrod",  # Gold - browser terminal operations
 }
 
 
@@ -1584,3 +1557,34 @@ def set_default_agent(agent_name: str) -> None:
         agent_name: The name of the agent to set as default.
     """
     set_config_value("default_agent", agent_name)
+
+
+# --- FRONTEND EMITTER CONFIGURATION ---
+def get_frontend_emitter_enabled() -> bool:
+    """Check if frontend emitter is enabled."""
+    val = get_value("frontend_emitter_enabled")
+    if val is None:
+        return True  # Enabled by default
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
+def get_frontend_emitter_max_recent_events() -> int:
+    """Get max number of recent events to buffer."""
+    val = get_value("frontend_emitter_max_recent_events")
+    if val is None:
+        return 100
+    try:
+        return int(val)
+    except ValueError:
+        return 100
+
+
+def get_frontend_emitter_queue_size() -> int:
+    """Get max subscriber queue size."""
+    val = get_value("frontend_emitter_queue_size")
+    if val is None:
+        return 100
+    try:
+        return int(val)
+    except ValueError:
+        return 100

code_puppy/mcp_/async_lifecycle.py

@@ -108,10 +108,17 @@ class AsyncServerLifecycleManager:
 
         try:
             logger.info(f"Starting server lifecycle for {server_id}")
+            logger.info(
+                f"Server {server_id} _running_count before enter: {getattr(server, '_running_count', 'N/A')}"
+            )
 
             # Enter the server's context
             await exit_stack.enter_async_context(server)
 
+            logger.info(
+                f"Server {server_id} _running_count after enter: {getattr(server, '_running_count', 'N/A')}"
+            )
+
             # Store the managed context
             async with self._lock:
                 self._servers[server_id] = ManagedServerContext(
@@ -122,26 +129,50 @@ class AsyncServerLifecycleManager:
                     task=asyncio.current_task(),
                 )
 
-            logger.info(f"Server {server_id} started successfully")
+            logger.info(
+                f"Server {server_id} started successfully and stored in _servers"
+            )
 
             # Keep the task alive until cancelled
+            loop_count = 0
             while True:
                 await asyncio.sleep(1)
+                loop_count += 1
 
                 # Check if server is still running
-                if not server.is_running:
-                    logger.warning(f"Server {server_id} stopped unexpectedly")
+                running_count = getattr(server, "_running_count", "N/A")
+                is_running = server.is_running
+                logger.debug(
+                    f"Server {server_id} heartbeat #{loop_count}: "
+                    f"is_running={is_running}, _running_count={running_count}"
+                )
+
+                if not is_running:
+                    logger.warning(
+                        f"Server {server_id} stopped unexpectedly! "
+                        f"_running_count={running_count}"
+                    )
                     break
 
         except asyncio.CancelledError:
             logger.info(f"Server {server_id} lifecycle task cancelled")
             raise
         except Exception as e:
-            logger.error(f"Error in server {server_id} lifecycle: {e}")
+            logger.error(f"Error in server {server_id} lifecycle: {e}", exc_info=True)
         finally:
+            running_count = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} lifecycle ending, _running_count={running_count}"
+            )
+
             # Clean up the context
             await exit_stack.aclose()
 
+            running_count_after = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} context closed, _running_count={running_count_after}"
+            )
+
             # Remove from managed servers
             async with self._lock:
                 if server_id in self._servers: