code-puppy 0.0.354__py3-none-any.whl → 0.0.356__py3-none-any.whl

code_puppy/api/websocket.py

@@ -0,0 +1,154 @@
+"""WebSocket endpoints for Code Puppy API.
+
+Provides real-time communication channels:
+- /ws/events - Server-sent events stream
+- /ws/terminal - Interactive PTY terminal sessions
+- /ws/health - Simple health check endpoint
+"""
+
+import asyncio
+import base64
+import logging
+import uuid
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+logger = logging.getLogger(__name__)
+
+
+def setup_websocket(app: FastAPI) -> None:
+    """Setup WebSocket endpoints for the application."""
+
+    @app.websocket("/ws/events")
+    async def websocket_events(websocket: WebSocket) -> None:
+        """Stream real-time events to connected clients."""
+        await websocket.accept()
+        logger.info("Events WebSocket client connected")
+
+        from code_puppy.plugins.frontend_emitter.emitter import (
+            get_recent_events,
+            subscribe,
+            unsubscribe,
+        )
+
+        event_queue = subscribe()
+
+        try:
+            recent_events = get_recent_events()
+            for event in recent_events:
+                await websocket.send_json(event)
+
+            while True:
+                try:
+                    event = await asyncio.wait_for(event_queue.get(), timeout=30.0)
+                    await websocket.send_json(event)
+                except asyncio.TimeoutError:
+                    try:
+                        await websocket.send_json({"type": "ping"})
+                    except Exception:
+                        break
+        except WebSocketDisconnect:
+            logger.info("Events WebSocket client disconnected")
+        except Exception as e:
+            logger.error(f"Events WebSocket error: {e}")
+        finally:
+            unsubscribe(event_queue)
+
+    @app.websocket("/ws/terminal")
+    async def websocket_terminal(websocket: WebSocket) -> None:
+        """Interactive terminal WebSocket endpoint."""
+        await websocket.accept()
+        logger.info("Terminal WebSocket client connected")
+
+        from code_puppy.api.pty_manager import get_pty_manager
+
+        manager = get_pty_manager()
+        session_id = str(uuid.uuid4())[:8]
+        session = None
+
+        # Get the current event loop for thread-safe scheduling
+        loop = asyncio.get_running_loop()
+
+        # Queue to receive PTY output in a thread-safe way
+        output_queue: asyncio.Queue[bytes] = asyncio.Queue()
+
+        # Output callback - called from thread pool, puts data in queue
+        def on_output(data: bytes) -> None:
+            try:
+                loop.call_soon_threadsafe(output_queue.put_nowait, data)
+            except Exception as e:
+                logger.error(f"on_output error: {e}")
+
+        async def output_sender() -> None:
+            """Coroutine that sends queued output to WebSocket."""
+            try:
+                while True:
+                    data = await output_queue.get()
+                    await websocket.send_json(
+                        {
+                            "type": "output",
+                            "data": base64.b64encode(data).decode("ascii"),
+                        }
+                    )
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"output_sender error: {e}")
+
+        sender_task = None
+
+        try:
+            # Create PTY session
+            session = await manager.create_session(
+                session_id=session_id,
+                on_output=on_output,
+            )
+
+            # Send session info
+            await websocket.send_json({"type": "session", "id": session_id})
+
+            # Start output sender task
+            sender_task = asyncio.create_task(output_sender())
+
+            # Handle incoming messages
+            while True:
+                try:
+                    msg = await websocket.receive_json()
+
+                    if msg.get("type") == "input":
+                        data = msg.get("data", "")
+                        if isinstance(data, str):
+                            data = data.encode("utf-8")
+                        await manager.write(session_id, data)
+                    elif msg.get("type") == "resize":
+                        cols = msg.get("cols", 80)
+                        rows = msg.get("rows", 24)
+                        await manager.resize(session_id, cols, rows)
+                except WebSocketDisconnect:
+                    break
+                except Exception as e:
+                    logger.error(f"Terminal WebSocket error: {e}")
+                    break
+        except Exception as e:
+            logger.error(f"Terminal session error: {e}")
+        finally:
+            if sender_task:
+                sender_task.cancel()
+                try:
+                    await sender_task
+                except asyncio.CancelledError:
+                    pass
+            if session:
+                await manager.close_session(session_id)
+            logger.info("Terminal WebSocket disconnected")
+
+    @app.websocket("/ws/health")
+    async def websocket_health(websocket: WebSocket) -> None:
+        """Simple WebSocket health check - echoes messages back."""
+        await websocket.accept()
+        try:
+            while True:
+                data = await websocket.receive_text()
+                await websocket.send_text(f"echo: {data}")
+        except WebSocketDisconnect:
+            pass

code_puppy/callbacks.py

@@ -18,6 +18,9 @@ PhaseType = Literal[
     "custom_command",
     "custom_command_help",
     "file_permission",
+    "pre_tool_call",
+    "post_tool_call",
+    "stream_event",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -36,6 +39,9 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "custom_command": [],
     "custom_command_help": [],
     "file_permission": [],
+    "pre_tool_call": [],
+    "post_tool_call": [],
+    "stream_event": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -271,3 +277,70 @@ def on_file_permission(
         message_group,
         operation_data,
     )
+
+
+async def on_pre_tool_call(
+    tool_name: str, tool_args: dict, context: Any = None
+) -> List[Any]:
+    """Trigger callbacks before a tool is called.
+
+    This allows plugins to inspect, modify, or log tool calls before
+    they are executed.
+
+    Args:
+        tool_name: Name of the tool being called
+        tool_args: Arguments being passed to the tool
+        context: Optional context data for the tool call
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks("pre_tool_call", tool_name, tool_args, context)
+
+
+async def on_post_tool_call(
+    tool_name: str,
+    tool_args: dict,
+    result: Any,
+    duration_ms: float,
+    context: Any = None,
+) -> List[Any]:
+    """Trigger callbacks after a tool completes.
+
+    This allows plugins to inspect tool results, log execution times,
+    or perform post-processing.
+
+    Args:
+        tool_name: Name of the tool that was called
+        tool_args: Arguments that were passed to the tool
+        result: The result returned by the tool
+        duration_ms: Execution time in milliseconds
+        context: Optional context data for the tool call
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks(
+        "post_tool_call", tool_name, tool_args, result, duration_ms, context
+    )
+
+
+async def on_stream_event(
+    event_type: str, event_data: Any, agent_session_id: str | None = None
+) -> List[Any]:
+    """Trigger callbacks for streaming events.
+
+    This allows plugins to react to streaming events in real-time,
+    such as tokens being generated, tool calls starting, etc.
+
+    Args:
+        event_type: Type of the streaming event
+        event_data: Data associated with the event
+        agent_session_id: Optional session ID of the agent emitting the event
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks(
+        "stream_event", event_type, event_data, agent_session_id
+    )

code_puppy/command_line/core_commands.py

@@ -772,6 +772,91 @@ def handle_mcp_command(command: str) -> bool:
     return handler.handle_mcp_command(command)
 
 
+@register_command(
+    name="api",
+    description="Manage the Code Puppy API server",
+    usage="/api [start|stop|status]",
+    category="core",
+    detailed_help="Start, stop, or check status of the local FastAPI server for GUI integration.",
+)
+def handle_api_command(command: str) -> bool:
+    """Handle the /api command."""
+    import os
+    import signal
+    import subprocess
+    import sys
+    from pathlib import Path
+
+    from code_puppy.config import STATE_DIR
+    from code_puppy.messaging import emit_error, emit_info, emit_success
+
+    parts = command.split()
+    subcommand = parts[1] if len(parts) > 1 else "status"
+
+    pid_file = Path(STATE_DIR) / "api_server.pid"
+
+    if subcommand == "start":
+        # Check if already running
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+                os.kill(pid, 0)  # Check if process exists
+                emit_info(f"API server already running (PID {pid})")
+                return True
+            except (OSError, ValueError):
+                pid_file.unlink(missing_ok=True)  # Stale PID file
+
+        # Start the server in background
+        emit_info("Starting API server on http://127.0.0.1:8765 ...")
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "code_puppy.api.main"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        pid_file.parent.mkdir(parents=True, exist_ok=True)
+        pid_file.write_text(str(proc.pid))
+        emit_success(f"API server started (PID {proc.pid})")
+        emit_info("Docs available at http://127.0.0.1:8765/docs")
+        return True
+
+    elif subcommand == "stop":
+        if not pid_file.exists():
+            emit_info("API server is not running")
+            return True
+
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, signal.SIGTERM)
+            pid_file.unlink()
+            emit_success(f"API server stopped (PID {pid})")
+        except (OSError, ValueError) as e:
+            pid_file.unlink(missing_ok=True)
+            emit_error(f"Error stopping server: {e}")
+        return True
+
+    elif subcommand == "status":
+        if not pid_file.exists():
+            emit_info("API server is not running")
+            return True
+
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)  # Check if process exists
+            emit_success(f"API server is running (PID {pid})")
+            emit_info("URL: http://127.0.0.1:8765")
+            emit_info("Docs: http://127.0.0.1:8765/docs")
+        except (OSError, ValueError):
+            pid_file.unlink(missing_ok=True)
+            emit_info("API server is not running (stale PID file removed)")
+        return True
+
+    else:
+        emit_error(f"Unknown subcommand: {subcommand}")
+        emit_info("Usage: /api [start|stop|status]")
+        return True
+
+
 @register_command(
     name="generate-pr-description",
     description="Generate comprehensive PR description",

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"]
 
@@ -208,6 +221,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 +253,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():
     """
@@ -1584,3 +1616,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/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/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/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)
     # =========================================================================
@@ -357,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
 
@@ -479,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:
@@ -493,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
@@ -573,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"}
@@ -617,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
@@ -701,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()