code-puppy 0.0.287__py3-none-any.whl → 0.0.323__py3-none-any.whl

code_puppy/tools/command_runner.py

@@ -1,7 +1,10 @@
+import ctypes
 import os
+import select
 import signal
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 import traceback
@@ -10,18 +13,19 @@ from typing import Callable, Literal, Optional, Set
 
 from pydantic import BaseModel
 from pydantic_ai import RunContext
-from rich.markdown import Markdown
 from rich.text import Text
 
-from code_puppy.messaging import (
-    emit_divider,
+from code_puppy.messaging import (  # Structured messaging types
+    AgentReasoningMessage,
+    ShellOutputMessage,
+    ShellStartMessage,
     emit_error,
     emit_info,
-    emit_system_message,
+    emit_shell_line,
     emit_warning,
+    get_message_bus,
 )
 from code_puppy.tools.common import generate_group_id, get_user_approval_async
-from code_puppy.tui_state import is_tui_mode
 
 # Maximum line length for shell command output to prevent massive token usage
 # This helps avoid exceeding model context limits when commands produce very long lines
@@ -35,6 +39,60 @@ def _truncate_line(line: str) -> str:
     return line
 
 
+# Windows-specific: Check if pipe has data available without blocking
+# This is needed because select() doesn't work on pipes on Windows
+if sys.platform.startswith("win"):
+    import msvcrt
+
+    # Load kernel32 for PeekNamedPipe
+    _kernel32 = ctypes.windll.kernel32
+
+    def _win32_pipe_has_data(pipe) -> bool:
+        """Check if a Windows pipe has data available without blocking.
+
+        Uses PeekNamedPipe from kernel32.dll to check if there's data
+        in the pipe buffer without actually reading it.
+
+        Args:
+            pipe: A file object with a fileno() method (e.g., process.stdout)
+
+        Returns:
+            True if data is available, False otherwise (including on error)
+        """
+        try:
+            # Get the Windows handle from the file descriptor
+            handle = msvcrt.get_osfhandle(pipe.fileno())
+
+            # PeekNamedPipe parameters:
+            # - hNamedPipe: handle to the pipe
+            # - lpBuffer: buffer to receive data (NULL = don't read)
+            # - nBufferSize: size of buffer (0 = don't read)
+            # - lpBytesRead: receives bytes read (NULL)
+            # - lpTotalBytesAvail: receives total bytes available
+            # - lpBytesLeftThisMessage: receives bytes left (NULL)
+            bytes_available = ctypes.c_ulong(0)
+
+            result = _kernel32.PeekNamedPipe(
+                handle,
+                None,  # Don't read data
+                0,  # Buffer size 0
+                None,  # Don't care about bytes read
+                ctypes.byref(bytes_available),  # Get bytes available
+                None,  # Don't care about bytes left in message
+            )
+
+            if result:
+                return bytes_available.value > 0
+            return False
+        except (ValueError, OSError, ctypes.ArgumentError):
+            # Handle closed, invalid, or other errors
+            return False
+else:
+    # POSIX stub - not used, but keeps the code clean
+    def _win32_pipe_has_data(pipe) -> bool:
+        return False
+
+
 _AWAITING_USER_INPUT = False
 
 _CONFIRMATION_LOCK = threading.Lock()
@@ -49,6 +107,9 @@ _SHELL_CTRL_X_STOP_EVENT: Optional[threading.Event] = None
 _SHELL_CTRL_X_THREAD: Optional[threading.Thread] = None
 _ORIGINAL_SIGINT_HANDLER = None
 
+# Stop event to signal reader threads to terminate
+_READER_STOP_EVENT: Optional[threading.Event] = None
+
 
 def _register_process(proc: subprocess.Popen) -> None:
     with _RUNNING_PROCESSES_LOCK:
@@ -128,23 +189,67 @@ def _kill_process_group(proc: subprocess.Popen) -> None:
 
 
 def kill_all_running_shell_processes() -> int:
-    """Kill all currently tracked running shell processes.
+    """Kill all currently tracked running shell processes and stop reader threads.
 
     Returns the number of processes signaled.
+
+    Implementation notes:
+    - Atomically snapshot and clear the registry to prevent race conditions
+    - Deduplicate by PID to ensure each process is killed at most once
+    - Let exceptions from _kill_process_group propagate (tests expect this)
     """
-    procs: list[subprocess.Popen]
+    global _READER_STOP_EVENT
+
+    # Signal reader threads to stop
+    if _READER_STOP_EVENT:
+        _READER_STOP_EVENT.set()
+
+    # Atomically take snapshot and clear registry
+    # This prevents other threads from seeing/processing the same processes
     with _RUNNING_PROCESSES_LOCK:
-        procs = list(_RUNNING_PROCESSES)
-    count = 0
-    for p in procs:
+        procs_snapshot = list(_RUNNING_PROCESSES)
+        _RUNNING_PROCESSES.clear()
+
+    # Deduplicate by pid to ensure at-most-one kill per process
+    seen_pids: set = set()
+    killed_count = 0
+
+    for proc in procs_snapshot:
+        if proc is None:
+            continue
+
+        pid = getattr(proc, "pid", None)
+        key = pid if pid is not None else id(proc)
+
+        if key in seen_pids:
+            continue
+        seen_pids.add(key)
+
+        # Close pipes first to unblock readline()
         try:
-            if p.poll() is None:
-                _kill_process_group(p)
-                count += 1
-                _USER_KILLED_PROCESSES.add(p.pid)
-        finally:
-            _unregister_process(p)
-    return count
+            if proc.stdout and not proc.stdout.closed:
+                proc.stdout.close()
+            if proc.stderr and not proc.stderr.closed:
+                proc.stderr.close()
+            if proc.stdin and not proc.stdin.closed:
+                proc.stdin.close()
+        except (OSError, ValueError):
+            pass
+
+        # Only attempt to kill processes that are still running
+        if proc.poll() is None:
+            # Let exceptions bubble up (tests expect this behavior)
+            _kill_process_group(proc)
+            killed_count += 1
+
+            # Track user-killed PIDs
+            if pid is not None:
+                try:
+                    _USER_KILLED_PROCESSES.add(pid)
+                except Exception:
+                    pass  # Non-fatal bookkeeping
+
+    return killed_count
 
 
 def get_running_shell_process_count() -> int:
@@ -205,6 +310,9 @@ class ShellCommandOutput(BaseModel):
     timeout: bool | None = False
     user_interrupted: bool | None = False
     user_feedback: str | None = None  # User feedback when command is rejected
+    background: bool = False  # True if command was run in background mode
+    log_file: str | None = None  # Path to temp log file for background commands
+    pid: int | None = None  # Process ID for background commands
 
 
 class ShellSafetyAssessment(BaseModel):
@@ -214,15 +322,18 @@ class ShellSafetyAssessment(BaseModel):
     It provides a risk level classification and reasoning for that assessment.
 
     Attributes:
-        risk: Risk level classification. Can be None (unknown/error), or one of:
+        risk: Risk level classification. Can be one of:
               'none' (completely safe), 'low' (minimal risk), 'medium' (moderate risk),
               'high' (significant risk), 'critical' (severe/destructive risk).
         reasoning: Brief explanation (max 1-2 sentences) of why this risk level
                    was assigned. Should be concise and actionable.
+        is_fallback: Whether this assessment is a fallback due to parsing failure.
+                     Fallback assessments are not cached to allow retry with fresh LLM responses.
     """
 
-    risk: Literal["none", "low", "medium", "high", "critical"] | None
+    risk: Literal["none", "low", "medium", "high", "critical"]
     reasoning: str
+    is_fallback: bool = False
 
 
 def _listen_for_ctrl_x_windows(
@@ -354,11 +465,6 @@ def _shell_command_keyboard_context():
     """
     global _SHELL_CTRL_X_STOP_EVENT, _SHELL_CTRL_X_THREAD, _ORIGINAL_SIGINT_HANDLER
 
-    # Skip all this in TUI mode
-    if is_tui_mode():
-        yield
-        return
-
     # Handler for Ctrl-X: kill all running shell processes
     def handle_ctrl_x_press() -> None:
         emit_warning("\n🛑 Ctrl-X detected! Interrupting shell command...")
@@ -416,6 +522,9 @@ def run_shell_command_streaming(
     command: str = "",
     group_id: str = None,
 ):
+    global _READER_STOP_EVENT
+    _READER_STOP_EVENT = threading.Event()
+
     start_time = time.time()
     last_output_time = [start_time]
 
@@ -429,27 +538,132 @@ def run_shell_command_streaming(
 
     def read_stdout():
         try:
-            for line in iter(process.stdout.readline, ""):
-                if line:
-                    line = line.rstrip("\n\r")
-                    # Limit line length to prevent massive token usage
-                    line = _truncate_line(line)
-                    stdout_lines.append(line)
-                    emit_system_message(line, message_group=group_id)
-                    last_output_time[0] = time.time()
+            fd = process.stdout.fileno()
+        except (ValueError, OSError):
+            return
+
+        try:
+            while True:
+                # Check stop event first
+                if _READER_STOP_EVENT and _READER_STOP_EVENT.is_set():
+                    break
+
+                # Use select to check if data is available (with timeout)
+                if sys.platform.startswith("win"):
+                    # Windows doesn't support select on pipes
+                    # Use PeekNamedPipe via _win32_pipe_has_data() to check
+                    # if data is available without blocking
+                    try:
+                        if _win32_pipe_has_data(process.stdout):
+                            line = process.stdout.readline()
+                            if not line:  # EOF
+                                break
+                            line = line.rstrip("\n\r")
+                            line = _truncate_line(line)
+                            stdout_lines.append(line)
+                            emit_shell_line(line, stream="stdout")
+                            last_output_time[0] = time.time()
+                        else:
+                            # No data available, check if process has exited
+                            if process.poll() is not None:
+                                # Process exited, do one final drain
+                                try:
+                                    remaining = process.stdout.read()
+                                    if remaining:
+                                        for line in remaining.splitlines():
+                                            line = _truncate_line(line)
+                                            stdout_lines.append(line)
+                                            emit_shell_line(line, stream="stdout")
+                                except (ValueError, OSError):
+                                    pass
+                                break
+                            # Sleep briefly to avoid busy-waiting (100ms like POSIX)
+                            time.sleep(0.1)
+                    except (ValueError, OSError):
+                        break
+                else:
+                    # POSIX: use select with timeout
+                    try:
+                        ready, _, _ = select.select([fd], [], [], 0.1)  # 100ms timeout
+                    except (ValueError, OSError, select.error):
+                        break
+
+                    if ready:
+                        line = process.stdout.readline()
+                        if not line:  # EOF
+                            break
+                        line = line.rstrip("\n\r")
+                        line = _truncate_line(line)
+                        stdout_lines.append(line)
+                        emit_shell_line(line, stream="stdout")
+                        last_output_time[0] = time.time()
+                    # If not ready, loop continues and checks stop event again
+        except (ValueError, OSError):
+            pass
         except Exception:
             pass
 
     def read_stderr():
         try:
-            for line in iter(process.stderr.readline, ""):
-                if line:
-                    line = line.rstrip("\n\r")
-                    # Limit line length to prevent massive token usage
-                    line = _truncate_line(line)
-                    stderr_lines.append(line)
-                    emit_system_message(line, message_group=group_id)
-                    last_output_time[0] = time.time()
+            fd = process.stderr.fileno()
+        except (ValueError, OSError):
+            return
+
+        try:
+            while True:
+                # Check stop event first
+                if _READER_STOP_EVENT and _READER_STOP_EVENT.is_set():
+                    break
+
+                if sys.platform.startswith("win"):
+                    # Windows doesn't support select on pipes
+                    # Use PeekNamedPipe via _win32_pipe_has_data() to check
+                    # if data is available without blocking
+                    try:
+                        if _win32_pipe_has_data(process.stderr):
+                            line = process.stderr.readline()
+                            if not line:  # EOF
+                                break
+                            line = line.rstrip("\n\r")
+                            line = _truncate_line(line)
+                            stderr_lines.append(line)
+                            emit_shell_line(line, stream="stderr")
+                            last_output_time[0] = time.time()
+                        else:
+                            # No data available, check if process has exited
+                            if process.poll() is not None:
+                                # Process exited, do one final drain
+                                try:
+                                    remaining = process.stderr.read()
+                                    if remaining:
+                                        for line in remaining.splitlines():
+                                            line = _truncate_line(line)
+                                            stderr_lines.append(line)
+                                            emit_shell_line(line, stream="stderr")
+                                except (ValueError, OSError):
+                                    pass
+                                break
+                            # Sleep briefly to avoid busy-waiting (100ms like POSIX)
+                            time.sleep(0.1)
+                    except (ValueError, OSError):
+                        break
+                else:
+                    try:
+                        ready, _, _ = select.select([fd], [], [], 0.1)
+                    except (ValueError, OSError, select.error):
+                        break
+
+                    if ready:
+                        line = process.stderr.readline()
+                        if not line:  # EOF
+                            break
+                        line = line.rstrip("\n\r")
+                        line = _truncate_line(line)
+                        stderr_lines.append(line)
+                        emit_shell_line(line, stream="stderr")
+                        last_output_time[0] = time.time()
+        except (ValueError, OSError):
+            pass
         except Exception:
             pass
 
@@ -460,6 +674,10 @@ def run_shell_command_streaming(
             _kill_process_group(proc)
 
         try:
+            # Signal reader threads to stop first
+            if _READER_STOP_EVENT:
+                _READER_STOP_EVENT.set()
+
             if process.poll() is None:
                 nuclear_kill(process)
 
@@ -520,19 +738,17 @@ def run_shell_command_streaming(
             current_time = time.time()
 
             if current_time - start_time > ABSOLUTE_TIMEOUT_SECONDS:
-                error_msg = Text()
-                error_msg.append(
-                    "Process killed: inactivity timeout reached", style="bold red"
+                emit_error(
+                    "Process killed: absolute timeout reached",
+                    message_group=group_id,
                 )
-                emit_error(error_msg, message_group=group_id)
                 return cleanup_process_and_threads("absolute")
 
             if current_time - last_output_time[0] > timeout:
-                error_msg = Text()
-                error_msg.append(
-                    "Process killed: inactivity timeout reached", style="bold red"
+                emit_error(
+                    "Process killed: inactivity timeout reached",
+                    message_group=group_id,
                 )
-                emit_error(error_msg, message_group=group_id)
                 return cleanup_process_and_threads("inactivity")
 
             time.sleep(0.1)
@@ -557,16 +773,25 @@ def run_shell_command_streaming(
 
         _unregister_process(process)
 
+        # Apply line length limits to stdout/stderr before returning
+        truncated_stdout = [_truncate_line(line) for line in stdout_lines[-256:]]
+        truncated_stderr = [_truncate_line(line) for line in stderr_lines[-256:]]
+
+        # Emit structured ShellOutputMessage for the UI
+        shell_output_msg = ShellOutputMessage(
+            command=command,
+            stdout="\n".join(truncated_stdout),
+            stderr="\n".join(truncated_stderr),
+            exit_code=exit_code,
+            duration_seconds=execution_time,
+        )
+        get_message_bus().emit(shell_output_msg)
+
+        # Reset the stop event now that we're done
+        _READER_STOP_EVENT = None
+
         if exit_code != 0:
-            emit_error(
-                f"Command failed with exit code {exit_code}", message_group=group_id
-            )
-            emit_info(f"Took {execution_time:.2f}s", message_group=group_id)
             time.sleep(1)
-            # Apply line length limits to stdout/stderr before returning
-            truncated_stdout = [_truncate_line(line) for line in stdout_lines[-256:]]
-            truncated_stderr = [_truncate_line(line) for line in stderr_lines[-256:]]
-
             return ShellCommandOutput(
                 success=False,
                 command=command,
@@ -579,12 +804,9 @@ def run_shell_command_streaming(
                 timeout=False,
                 user_interrupted=process.pid in _USER_KILLED_PROCESSES,
             )
-        # Apply line length limits to stdout/stderr before returning
-        truncated_stdout = [_truncate_line(line) for line in stdout_lines[-256:]]
-        truncated_stderr = [_truncate_line(line) for line in stderr_lines[-256:]]
 
         return ShellCommandOutput(
-            success=exit_code == 0,
+            success=True,
             command=command,
             stdout="\n".join(truncated_stdout),
             stderr="\n".join(truncated_stderr),
@@ -594,6 +816,8 @@ def run_shell_command_streaming(
         )
 
     except Exception as e:
+        # Reset the stop event on exception too
+        _READER_STOP_EVENT = None
         return ShellCommandOutput(
             success=False,
             command=command,
@@ -606,18 +830,18 @@ def run_shell_command_streaming(
 
 
 async def run_shell_command(
-    context: RunContext, command: str, cwd: str = None, timeout: int = 60
+    context: RunContext,
+    command: str,
+    cwd: str = None,
+    timeout: int = 60,
+    background: bool = False,
 ) -> ShellCommandOutput:
     command_displayed = False
+    start_time = time.time()
 
     # Generate unique group_id for this command execution
     group_id = generate_group_id("shell_command", command)
 
-    emit_info(
-        f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] 📂 [bold green]$ {command}[/bold green]",
-        message_group=group_id,
-    )
-
     # Invoke safety check callbacks (only active in yolo_mode)
     # This allows plugins to intercept and assess commands before execution
     from code_puppy.callbacks import on_run_shell_command
@@ -639,6 +863,86 @@ async def run_shell_command(
                 execution_time=None,
             )
 
+    # Handle background execution - runs command detached and returns immediately
+    # This happens BEFORE user confirmation since we don't wait for the command
+    if background:
+        # Create temp log file for output
+        log_file = tempfile.NamedTemporaryFile(
+            mode="w",
+            prefix="shell_bg_",
+            suffix=".log",
+            delete=False,  # Keep file so agent can read it later
+        )
+
+        try:
+            # Platform-specific process detachment
+            if sys.platform.startswith("win"):
+                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+                process = subprocess.Popen(
+                    command,
+                    shell=True,
+                    stdout=log_file,
+                    stderr=subprocess.STDOUT,
+                    stdin=subprocess.DEVNULL,
+                    cwd=cwd,
+                    creationflags=creationflags,
+                )
+            else:
+                process = subprocess.Popen(
+                    command,
+                    shell=True,
+                    stdout=log_file,
+                    stderr=subprocess.STDOUT,
+                    stdin=subprocess.DEVNULL,
+                    cwd=cwd,
+                    start_new_session=True,  # Fully detach on POSIX
+                )
+
+            log_file.close()  # Close our handle, process keeps writing
+
+            # Emit UI messages so user sees what happened
+            bus = get_message_bus()
+            bus.emit(
+                ShellStartMessage(
+                    command=command,
+                    cwd=cwd,
+                    timeout=0,  # No timeout for background processes
+                )
+            )
+
+            # Emit info about background execution
+            emit_info(
+                f"🚀 Background process started (PID: {process.pid}) - no timeout, runs until complete"
+            )
+            emit_info(f"📄 Output logging to: {log_file.name}")
+
+            # Return immediately - don't wait, don't block
+            return ShellCommandOutput(
+                success=True,
+                command=command,
+                stdout=None,
+                stderr=None,
+                exit_code=None,
+                execution_time=0.0,
+                background=True,
+                log_file=log_file.name,
+                pid=process.pid,
+            )
+        except Exception as e:
+            log_file.close()
+            # Emit error message so user sees what happened
+            emit_error(f"❌ Failed to start background process: {e}")
+            return ShellCommandOutput(
+                success=False,
+                command=command,
+                error=f"Failed to start background process: {e}",
+                stdout=None,
+                stderr=None,
+                exit_code=None,
+                execution_time=None,
+                background=True,
+            )
+
     # Rest of the existing function continues...
     if not command or not command.strip():
         emit_error("Command cannot be empty", message_group=group_id)
@@ -721,6 +1025,16 @@ async def run_shell_command(
 
     # Now that approval is done, activate the Ctrl-X listener and disable agent Ctrl-C
     with _shell_command_keyboard_context():
+        # Emit structured ShellStartMessage for the UI
+        bus = get_message_bus()
+        bus.emit(
+            ShellStartMessage(
+                command=command,
+                cwd=cwd,
+                timeout=timeout,
+            )
+        )
+
         try:
             creationflags = 0
             preexec_fn = None
@@ -792,26 +1106,14 @@ class ReasoningOutput(BaseModel):
 def share_your_reasoning(
     context: RunContext, reasoning: str, next_steps: str | None = None
 ) -> ReasoningOutput:
-    # Generate unique group_id for this reasoning session
-    group_id = generate_group_id(
-        "agent_reasoning", reasoning[:50]
-    )  # Use first 50 chars for context
-
-    if not is_tui_mode():
-        emit_divider(message_group=group_id)
-        emit_info(
-            "\n[bold white on purple] AGENT REASONING [/bold white on purple]",
-            message_group=group_id,
-        )
-    emit_info("[bold cyan]Current reasoning:[/bold cyan]", message_group=group_id)
-    emit_system_message(Markdown(reasoning), message_group=group_id)
-    if next_steps is not None and next_steps.strip():
-        emit_info(
-            "\n[bold cyan]Planned next steps:[/bold cyan]", message_group=group_id
-        )
-        emit_system_message(Markdown(next_steps), message_group=group_id)
-    emit_info("[dim]" + "-" * 60 + "[/dim]\n", message_group=group_id)
-    return ReasoningOutput(**{"success": True})
+    # Emit structured AgentReasoningMessage for the UI
+    reasoning_msg = AgentReasoningMessage(
+        reasoning=reasoning,
+        next_steps=next_steps if next_steps and next_steps.strip() else None,
+    )
+    get_message_bus().emit(reasoning_msg)
+
+    return ReasoningOutput(success=True)
 
 
 def register_agent_run_shell_command(agent):
@@ -819,7 +1121,11 @@ def register_agent_run_shell_command(agent):
 
     @agent.tool
     async def agent_run_shell_command(
-        context: RunContext, command: str = "", cwd: str = None, timeout: int = 60
+        context: RunContext,
+        command: str = "",
+        cwd: str = None,
+        timeout: int = 60,
+        background: bool = False,
     ) -> ShellCommandOutput:
         """Execute a shell command with comprehensive monitoring and safety features.
 
@@ -835,6 +1141,14 @@ def register_agent_run_shell_command(agent):
             timeout: Inactivity timeout in seconds. If no output is
                 produced for this duration, the process will be terminated.
                 Defaults to 60 seconds.
+            background: If True, run the command in the background and return immediately.
+                The command output will be written to a temporary log file.
+                Use this for long-running processes like servers (npm run dev, python -m http.server),
+                or any command you don't need to wait for.
+                When background=True, the response includes:
+                - log_file: Path to temp file containing stdout/stderr (read with read_file tool)
+                - pid: Process ID of the background process
+                Defaults to False.
 
         Returns:
             ShellCommandOutput: A structured response containing:
@@ -847,6 +1161,9 @@ def register_agent_run_shell_command(agent):
                 - execution_time (float | None): Total execution time in seconds
                 - timeout (bool | None): True if command was terminated due to timeout
                 - user_interrupted (bool | None): True if user killed the process
+                - background (bool): True if command was run in background mode
+                - log_file (str | None): Path to temp log file for background commands
+                - pid (int | None): Process ID for background commands
 
         Examples:
             >>> # Basic command execution
@@ -863,11 +1180,16 @@ def register_agent_run_shell_command(agent):
             >>> if result.timeout:
             ...     print("Command timed out")
 
+            >>> # Background command for long-running server
+            >>> result = agent_run_shell_command(ctx, "npm run dev", background=True)
+            >>> print(f"Server started with PID {result.pid}")
+            >>> print(f"Logs available at: {result.log_file}")
+
         Warning:
             This tool can execute arbitrary shell commands. Exercise caution when
             running untrusted commands, especially those that modify system state.
         """
-        return await run_shell_command(context, command, cwd, timeout)
+        return await run_shell_command(context, command, cwd, timeout, background)
 
 
 def register_agent_share_your_reasoning(agent):