code-puppy 0.0.302__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
@@ -17,7 +20,8 @@ from code_puppy.messaging import (  # Structured messaging types
     ShellOutputMessage,
     ShellStartMessage,
     emit_error,
-    emit_system_message,
+    emit_info,
+    emit_shell_line,
     emit_warning,
     get_message_bus,
 )
@@ -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):
@@ -414,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]
 
@@ -427,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
 
@@ -458,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)
 
@@ -567,6 +787,9 @@ def run_shell_command_streaming(
         )
         get_message_bus().emit(shell_output_msg)
 
+        # Reset the stop event now that we're done
+        _READER_STOP_EVENT = None
+
         if exit_code != 0:
             time.sleep(1)
             return ShellCommandOutput(
@@ -593,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,
@@ -605,7 +830,11 @@ 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()
@@ -634,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)
@@ -812,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.
 
@@ -828,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:
@@ -840,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
@@ -856,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):

code_puppy/tools/file_operations.py

@@ -18,11 +18,8 @@ from code_puppy.messaging import (  # New structured messaging types
     FileListingMessage,
     GrepMatch,
     GrepResultMessage,
-    emit_error,
-    emit_warning,
     get_message_bus,
 )
-from code_puppy.tools.common import generate_group_id
 
 
 # Pydantic models for tool return types
@@ -53,6 +50,7 @@ class MatchInfo(BaseModel):
 
 class GrepOutput(BaseModel):
     matches: List[MatchInfo]
+    error: str | None = None
 
 
 def is_likely_home_directory(directory):
@@ -582,9 +580,7 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
 
     directory = os.path.abspath(os.path.expanduser(directory))
     matches: List[MatchInfo] = []
-
-    # Generate group_id for this tool execution
-    group_id = generate_group_id("grep", f"{directory}_{search_string}")
+    error_message: str | None = None
 
     # Create a temporary ignore file with our ignore patterns
     ignore_file = None
@@ -616,11 +612,10 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
                     break
 
         if not rg_path:
-            emit_error(
-                "ripgrep (rg) not found. Please install ripgrep to use this tool.",
-                message_group=group_id,
+            error_message = (
+                "ripgrep (rg) not found. Please install ripgrep to use this tool."
             )
-            return GrepOutput(matches=[])
+            return GrepOutput(matches=[], error=error_message)
 
         cmd = [
             rg_path,
@@ -688,50 +683,43 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
                 # Skip lines that aren't valid JSON
                 continue
 
-        # Build structured GrepMatch objects for the UI
-        grep_matches = [
-            GrepMatch(
-                file_path=m.file_path or "",
-                line_number=m.line_number or 1,
-                line_content=m.line_content or "",
-            )
-            for m in matches
-        ]
-
-        # Count unique files searched (approximation based on matches)
-        unique_files = len(set(m.file_path for m in matches)) if matches else 0
-
-        # Emit structured message for the UI
-        grep_result_msg = GrepResultMessage(
-            search_term=search_string,
-            directory=directory,
-            matches=grep_matches,
-            total_matches=len(matches),
-            files_searched=unique_files,
-        )
-        get_message_bus().emit(grep_result_msg)
-
-        if not matches:
-            emit_warning(
-                f"No matches found for '{search_string}' in {directory}",
-                message_group=group_id,
-            )
-
     except subprocess.TimeoutExpired:
-        emit_error("Grep command timed out after 30 seconds", message_group=group_id)
+        error_message = "Grep command timed out after 30 seconds"
     except FileNotFoundError:
-        emit_error(
-            "ripgrep (rg) not found. Please install ripgrep to use this tool.",
-            message_group=group_id,
+        error_message = (
+            "ripgrep (rg) not found. Please install ripgrep to use this tool."
         )
     except Exception as e:
-        emit_error(f"Error during grep operation: {e}", message_group=group_id)
+        error_message = f"Error during grep operation: {e}"
     finally:
         # Clean up the temporary ignore file
         if ignore_file and os.path.exists(ignore_file):
             os.unlink(ignore_file)
 
-    return GrepOutput(matches=matches)
+    # Build structured GrepMatch objects for the UI
+    grep_matches = [
+        GrepMatch(
+            file_path=m.file_path or "",
+            line_number=m.line_number or 1,
+            line_content=m.line_content or "",
+        )
+        for m in matches
+    ]
+
+    # Count unique files searched (approximation based on matches)
+    unique_files = len(set(m.file_path for m in matches)) if matches else 0
+
+    # Emit structured message for the UI (only once, at the end)
+    grep_result_msg = GrepResultMessage(
+        search_term=search_string,
+        directory=directory,
+        matches=grep_matches,
+        total_matches=len(matches),
+        files_searched=unique_files,
+    )
+    get_message_bus().emit(grep_result_msg)
+
+    return GrepOutput(matches=matches, error=error_message)
 
 
 def register_list_files(agent):