code-puppy 0.0.894__tar.gz → 0.0.896__tar.gz

{code_puppy-0.0.894 → code_puppy-0.0.896}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.894
+Version: 0.0.896
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.894 → code_puppy-0.0.896}/code_puppy/mcp_/managed_server.py

@@ -77,6 +77,36 @@ def _httpx_client_factory(
     return factory
 
 
+def _with_inherited_windows_system_paths(
+    env: Optional[Dict[str, str]],
+) -> Optional[Dict[str, str]]:
+    """Propagate Windows system paths required by some stdio launchers.
+
+    The MCP SDK gives stdio children a deliberately restricted environment.
+    Its Windows allowlist omits ``PROGRAMW6432`` and ``ProgramData``. Docker's
+    CLI needs the former to discover CLI plugins, while Docker MCP Gateway
+    needs the latter to locate Docker Desktop state. Missing either can cause
+    misleading argument errors or a startup panic.
+
+    Preserve the SDK's restricted-environment behavior on other platforms and
+    let explicit server configuration override inherited values.
+    """
+    if os.name != "nt":
+        return env
+
+    inherited = {
+        key: value
+        for key in ("PROGRAMW6432", "ProgramData")
+        if (value := os.environ.get(key))
+    }
+    if not inherited:
+        return env
+
+    out: Dict[str, str] = inherited
+    out.update(env or {})
+    return out
+
+
 def _with_inherited_ca_bundle(
     env: Optional[Dict[str, str]],
 ) -> Optional[Dict[str, str]]:
@@ -336,6 +366,7 @@ class ManagedMCPServer:
                 args = _expand_env_vars(args)
 
             env = _expand_env_vars(config["env"]) if "env" in config else None
+            env = _with_inherited_windows_system_paths(env)
             # Always run (even with no configured env) so the child trusts
             # our CA bundle; see _with_inherited_ca_bundle for why.
             env = _with_inherited_ca_bundle(env)

{code_puppy-0.0.894 → code_puppy-0.0.896}/code_puppy/tools/command_runner.py

@@ -1,5 +1,4 @@
 import asyncio
-import ctypes
 import os
 import select
 import signal
@@ -37,6 +36,13 @@ from code_puppy.tools.shell_backgrounding import (
     request_background_all,
 )
 from code_puppy.tools.subagent_context import is_subagent
+from code_puppy.tools.win_shell_io import (
+    IS_WINDOWS,
+    NonBlockingPipeReader,
+    attach_job,
+    release_job,
+    terminate_job,
+)
 
 # 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
@@ -50,52 +56,23 @@ 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: NULL buffer/0 size = peek only; grab lpTotalBytesAvail.
-            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
-            )
+def _close_pipes(process: subprocess.Popen, readers=()) -> bool:
+    """Close the child's pipes, unless a reader thread is still alive.
 
-            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:
+    Closing under a live reader can deadlock: on Windows ``close()`` waits
+    for the CRT fd lock a blocked read holds, and buffered streams wait on
+    their own lock everywhere. A leaked fd beats a bricked puppy, so if a
+    reader is alive we skip the close and leave cleanup to GC.
+    """
+    if any(t is not None and t.is_alive() for t in readers):
         return False
+    for pipe in (process.stdout, process.stderr, process.stdin):
+        try:
+            if pipe and not pipe.closed:
+                pipe.close()
+        except (OSError, ValueError):
+            pass
+    return True
 
 
 _AWAITING_USER_INPUT = threading.Event()
@@ -153,11 +130,13 @@ def _unregister_process(proc: subprocess.Popen) -> None:
 def _kill_process_group(proc: subprocess.Popen) -> None:
     """Attempt to aggressively terminate a process and its group.
 
-    Cross-platform best-effort. On POSIX, uses process groups. On Windows, tries taskkill with /T flag for tree kill.
+    Cross-platform best-effort. On POSIX, uses process groups. On Windows,
+    terminates the shell's Job Object (this reaches orphans whose parent
+    already exited), then runs taskkill /T for anything outside the job.
     """
     try:
-        if sys.platform.startswith("win"):
-            # On Windows, use taskkill to kill the process tree
+        if IS_WINDOWS:
+            terminate_job(proc)
             # /F = force, /T = kill tree (children), /PID = process ID
             try:
                 import subprocess as sp
@@ -238,17 +217,11 @@ def kill_all_running_shell_processes() -> int:
     count = 0
     for p in procs:
         try:
-            # Close pipes first to unblock readline()
-            try:
-                if p.stdout and not p.stdout.closed:
-                    p.stdout.close()
-                if p.stderr and not p.stderr.closed:
-                    p.stderr.close()
-                if p.stdin and not p.stdin.closed:
-                    p.stdin.close()
-            except (OSError, ValueError):
-                pass
-
+            # Deliberately NO pipe closing here: a reader may be mid-read,
+            # and close() then blocks this (Ctrl+C) thread forever, which is
+            # exactly how a stray `start` used to brick cancellation. The
+            # stop events above end the readers, and the streaming pump
+            # closes the pipes once they're gone.
             if p.poll() is None:
                 _kill_process_group(p)
                 count += 1
@@ -707,134 +680,51 @@ def run_shell_command_streaming(
         if not silent:
             emit_shell_line(line, stream=stream)
 
-    def read_stdout():
-        try:
-            fd = process.stdout.fileno()
-        except (ValueError, OSError):
-            return
-
-        try:
-            while True:
-                # Check stop event first
-                if stop_event.is_set():
+    def _emit(line, lines_list, stream):
+        # Strip CR/LF: a stray \r would retrigger the renderer's redraw bypass.
+        _sink(_truncate_line(line.rstrip("\r\n")), lines_list, stream)
+        last_output_time[0] = time.time()
+
+    def _pump_windows(pipe, lines_list, stream):
+        # Never blocks (see win_shell_io), so stop_event is always honoured
+        # and nobody ends up holding the CRT fd lock that close() needs.
+        reader = NonBlockingPipeReader(pipe)
+        while not stop_event.is_set():
+            # Check exit BEFORE reading, so the read that follows sees
+            # everything the shell wrote before it died.
+            exited = process.poll() is not None
+            for line in reader.read_available():
+                _emit(line, lines_list, stream)
+            # Once the shell is gone and the pipe is empty we're done. Don't
+            # wait for EOF: a `start`ed orphan may hold the write-end forever.
+            if reader.eof or (exited and reader.drained):
+                break
+            if reader.drained:
+                time.sleep(0.1)
+        for line in reader.finish():
+            _emit(line, lines_list, stream)
+
+    def _pump_posix(pipe, lines_list, stream):
+        fd = pipe.fileno()
+        while not stop_event.is_set():
+            try:
+                ready, _, _ = select.select([fd], [], [], 0.1)
+            except (ValueError, OSError, select.error):
+                break
+            if ready:
+                line = pipe.readline()
+                if not line:  # EOF
                     break
+                _emit(line, lines_list, stream)
 
-                # Use select to check if data is available (with timeout)
-                if sys.platform.startswith("win"):
-                    # Windows: no select on pipes — PeekNamedPipe to check availability
-                    try:
-                        if _win32_pipe_has_data(process.stdout):
-                            line = process.stdout.readline()
-                            if not line:  # EOF
-                                break
-                            line = line.rstrip("\r\n")
-                            line = _truncate_line(line)
-                            _sink(line, stdout_lines, "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.split("\n"):
-                                            # Strip CR/LF like the readline path —
-                                            # Windows CRLF's stray \r would retrigger
-                                            # the renderer's redraw bypass.
-                                            line = line.rstrip("\r\n")
-                                            line = _truncate_line(line)
-                                            _sink(line, stdout_lines, "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("\r\n")
-                        line = _truncate_line(line)
-                        _sink(line, stdout_lines, "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:
-            fd = process.stderr.fileno()
-        except (ValueError, OSError):
-            return
-
+    def pump(pipe, lines_list, stream):
         try:
-            while True:
-                # Check stop event first
-                if stop_event.is_set():
-                    break
-
-                if sys.platform.startswith("win"):
-                    # Windows: no select on pipes — PeekNamedPipe to check availability
-                    try:
-                        if _win32_pipe_has_data(process.stderr):
-                            line = process.stderr.readline()
-                            if not line:  # EOF
-                                break
-                            line = line.rstrip("\r\n")
-                            line = _truncate_line(line)
-                            _sink(line, stderr_lines, "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.split("\n"):
-                                            # Strip CR/LF like the readline path —
-                                            # Windows CRLF's stray \r would retrigger
-                                            # the renderer's redraw bypass.
-                                            line = line.rstrip("\r\n")
-                                            line = _truncate_line(line)
-                                            _sink(line, stderr_lines, "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("\r\n")
-                        line = _truncate_line(line)
-                        _sink(line, stderr_lines, "stderr")
-                        last_output_time[0] = time.time()
-        except (ValueError, OSError):
-            pass
+            if IS_WINDOWS:
+                _pump_windows(pipe, lines_list, stream)
+            else:
+                _pump_posix(pipe, lines_list, stream)
         except Exception:
-            pass
+            pass  # closed/invalid pipe: nothing left to read
 
     def cleanup_process_and_threads(timeout_type: str = "unknown"):
         nonlocal stdout_thread, stderr_thread
@@ -849,17 +739,6 @@ def run_shell_command_streaming(
             if process.poll() is None:
                 nuclear_kill(process)
 
-            try:
-                if process.stdout and not process.stdout.closed:
-                    process.stdout.close()
-                if process.stderr and not process.stderr.closed:
-                    process.stderr.close()
-                if process.stdin and not process.stdin.closed:
-                    process.stdin.close()
-            except (OSError, ValueError):
-                pass
-
-            # Unregister once we're done cleaning up
             _unregister_process(process)
 
             if stdout_thread and stdout_thread.is_alive():
@@ -878,6 +757,9 @@ def run_shell_command_streaming(
                         message_group=group_id,
                     )
 
+            # Only after the joins: closing under a live reader can deadlock.
+            _close_pipes(process, (stdout_thread, stderr_thread))
+
         except Exception as e:
             if not silent:
                 emit_warning(
@@ -945,8 +827,12 @@ def run_shell_command_streaming(
         )
 
     try:
-        stdout_thread = threading.Thread(target=read_stdout, daemon=True)
-        stderr_thread = threading.Thread(target=read_stderr, daemon=True)
+        stdout_thread = threading.Thread(
+            target=pump, args=(process.stdout, stdout_lines, "stdout"), daemon=True
+        )
+        stderr_thread = threading.Thread(
+            target=pump, args=(process.stderr, stderr_lines, "stderr"), daemon=True
+        )
 
         stdout_thread.start()
         stderr_thread.start()
@@ -978,17 +864,8 @@ def run_shell_command_streaming(
         exit_code = process.returncode
         execution_time = time.time() - start_time
 
-        try:
-            if process.stdout and not process.stdout.closed:
-                process.stdout.close()
-            if process.stderr and not process.stderr.closed:
-                process.stderr.close()
-            if process.stdin and not process.stdin.closed:
-                process.stdin.close()
-        except (OSError, ValueError):
-            pass
-
         _unregister_process(process)
+        _close_pipes(process, (stdout_thread, stderr_thread))
 
         # Apply line length limits to stdout/stderr before returning
         truncated_stdout = stdout_lines[-256:]
@@ -1431,7 +1308,7 @@ def _run_command_sync(
     """
     creationflags = 0
     preexec_fn = None
-    if sys.platform.startswith("win"):
+    if IS_WINDOWS:
         try:
             creationflags = (
                 subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore[attr-defined]
@@ -1456,6 +1333,8 @@ def _run_command_sync(
         preexec_fn=preexec_fn,
         creationflags=creationflags,
     )
+    # Windows: job-wrap the shell so a kill reaches orphaned grandchildren.
+    attach_job(process)
 
     # Wrap pipes with TextIOWrapper that preserves \r (newline='' disables translation)
     process.stdout = io.TextIOWrapper(
@@ -1472,6 +1351,7 @@ def _run_command_sync(
     finally:
         # Ensure unregistration in case streaming returned early or raised
         _unregister_process(process)
+        release_job(process)  # no KILL_ON_JOB_CLOSE: survivors keep running
 
 
 async def _run_command_inner(

code_puppy-0.0.896/code_puppy/tools/win_shell_io.py

@@ -0,0 +1,161 @@
+"""Windows shell-pipe I/O and process-tree control that cannot wedge the puppy.
+
+Split from ``command_runner`` (600-line cap). It handles two Windows hazards:
+
+1. **Inherited pipe handles.** ``cmd /c "build && start server"`` exits at
+   once, but ``start``'s child inherits our pipe write-ends, so EOF never
+   arrives. A blocking ``read()``/``readline()`` then hangs forever. Worse,
+   ``close()`` on that fd blocks too: it needs the CRT per-fd lock that the
+   stuck read holds. That wedges both the tool call and the Ctrl+C kill
+   path. ``NonBlockingPipeReader`` only ``ReadFile``s the bytes that
+   ``PeekNamedPipe`` already reports as available, and goes through
+   ``_winapi`` on the raw OS handle, so it never blocks and never takes the
+   CRT lock.
+
+2. **Orphaned grandchildren.** ``taskkill /T`` walks parent PIDs, so once an
+   intermediate shell exits, its children can't be reached. The ``*_job``
+   helpers put each shell in a Job Object so a kill reaches the whole tree.
+   There is deliberately no ``KILL_ON_JOB_CLOSE``: releasing the job after a
+   normal finish must leave processes the user started on purpose alone.
+   Small race: anything the shell spawns before ``attach_job`` runs (a few
+   ms after ``CreateProcess``) stays outside the job, and ``taskkill /T``
+   still covers those.
+
+Every helper is a safe no-op off Windows, so callers don't need to branch.
+"""
+
+from __future__ import annotations
+
+import codecs
+import io
+import subprocess
+import sys
+import threading
+
+IS_WINDOWS = sys.platform.startswith("win")
+
+if IS_WINDOWS:
+    import ctypes
+    import msvcrt
+    from ctypes import wintypes
+
+    import _winapi
+
+    # Private WinDLL: setting argtypes on the shared ctypes.windll would leak
+    # into every other module that uses kernel32.
+    _kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    _kernel32.CreateJobObjectW.argtypes = (wintypes.LPVOID, wintypes.LPCWSTR)
+    _kernel32.CreateJobObjectW.restype = wintypes.HANDLE
+    _kernel32.AssignProcessToJobObject.argtypes = (wintypes.HANDLE, wintypes.HANDLE)
+    _kernel32.AssignProcessToJobObject.restype = wintypes.BOOL
+    _kernel32.TerminateJobObject.argtypes = (wintypes.HANDLE, wintypes.UINT)
+    _kernel32.TerminateJobObject.restype = wintypes.BOOL
+    _kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
+    _kernel32.CloseHandle.restype = wintypes.BOOL
+
+
+class NonBlockingPipeReader:
+    """Line reader over a Windows anonymous pipe that never blocks.
+
+    Splits on ``\\r\\n``, ``\\r`` and ``\\n``, the same as the
+    ``TextIOWrapper(newline="")`` readline it replaces, and keeps a trailing
+    ``\\r`` that lands at a chunk boundary until the next chunk arrives.
+    Decodes as UTF-8 with replacement characters.
+    """
+
+    _CHUNK = 64 * 1024
+    #: Bounded so a firehose writer can't keep us from rechecking stop_event.
+    _MAX_CHUNKS_PER_CALL = 16
+
+    def __init__(self, pipe) -> None:
+        self._handle = msvcrt.get_osfhandle(pipe.fileno())
+        utf8 = codecs.getincrementaldecoder("utf-8")(errors="replace")
+        self._decoder = io.IncrementalNewlineDecoder(utf8, translate=True)
+        self._partial = ""
+        self._finished = False
+        #: Every write-end is closed (or our handle is gone).
+        self.eof = False
+        #: The last ``read_available`` call emptied the pipe.
+        self.drained = False
+
+    def read_available(self) -> list[str]:
+        """Return the complete lines in the pipe right now. Never blocks."""
+        chunks: list[str] = []
+        self.drained = False
+        for _ in range(self._MAX_CHUNKS_PER_CALL):
+            try:
+                available, _left = _winapi.PeekNamedPipe(self._handle)
+                if not available:
+                    self.drained = True
+                    break
+                data, _err = _winapi.ReadFile(self._handle, min(available, self._CHUNK))
+            except OSError:  # ERROR_BROKEN_PIPE: no writers left. Real EOF.
+                self.eof = self.drained = True
+                break
+            chunks.append(self._decoder.decode(data))
+        lines = self._split("".join(chunks))
+        return lines + self.finish() if self.eof else lines
+
+    def finish(self) -> list[str]:
+        """Flush the decoder and the trailing partial line. Idempotent."""
+        if self._finished:
+            return []
+        self._finished = True
+        lines = self._split(self._decoder.decode(b"", final=True))
+        if self._partial:
+            lines.append(self._partial)
+            self._partial = ""
+        return lines
+
+    def _split(self, text: str) -> list[str]:
+        lines = (self._partial + text).split("\n")
+        self._partial = lines.pop()
+        return lines
+
+
+# Job handles keyed by Popen, held only while the shell is in the foreground.
+_JOBS: dict[subprocess.Popen, int] = {}
+_JOBS_LOCK = threading.Lock()
+
+
+def attach_job(proc: subprocess.Popen) -> None:
+    """Put ``proc`` (and everything it spawns afterwards) in a fresh Job Object."""
+    if not IS_WINDOWS:
+        return
+    job = _kernel32.CreateJobObjectW(None, None)
+    if not job:
+        return
+    # Popen._handle is the real process handle, which avoids any PID-reuse race.
+    if not _kernel32.AssignProcessToJobObject(job, int(proc._handle)):
+        _kernel32.CloseHandle(job)  # e.g. the process already exited
+        return
+    with _JOBS_LOCK:
+        _JOBS[proc] = job
+
+
+def terminate_job(proc: subprocess.Popen) -> bool:
+    """Kill every process in ``proc``'s job, orphans included."""
+    if not IS_WINDOWS:
+        return False
+    with _JOBS_LOCK:
+        job = _JOBS.get(proc)
+    return bool(job) and bool(_kernel32.TerminateJobObject(job, 1))
+
+
+def release_job(proc: subprocess.Popen) -> None:
+    """Drop our job handle. Doesn't kill anything (no KILL_ON_JOB_CLOSE)."""
+    if not IS_WINDOWS:
+        return
+    with _JOBS_LOCK:
+        job = _JOBS.pop(proc, None)
+    if job:
+        _kernel32.CloseHandle(job)
+
+
+__all__ = [
+    "IS_WINDOWS",
+    "NonBlockingPipeReader",
+    "attach_job",
+    "release_job",
+    "terminate_job",
+]

{code_puppy-0.0.894 → code_puppy-0.0.896}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.894"
+version = "0.0.896"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"