Replace psutil with platform-specific process termination

- Remove psutil dependency entirely
- Unix: Use os.killpg() for atomic process group termination
- Windows: Use pywin32 Job Objects for reliable child process cleanup
- Job Objects ensure all child processes are terminated even if parent crashes
- Fixes race conditions in process tree termination on both platforms

Author: felixweinberger

pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
     "pydantic-settings>=2.5.2",
     "uvicorn>=0.23.1; sys_platform != 'emscripten'",
     "jsonschema>=4.20.0",
-    "psutil>=5.9.0,<6.0.0",
+    "pywin32>=300; sys_platform == 'win32'",
 ]
 
 [project.optional-dependencies]

src/mcp/client/stdio/__init__.py

@@ -1,13 +1,12 @@
 import os
+import signal
 import sys
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Literal, TextIO
 
 import anyio
 import anyio.lowlevel
-import anyio.to_thread
-import psutil
 from anyio.abc import Process
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from anyio.streams.text import TextReceiveStream
@@ -20,6 +19,7 @@
     FallbackProcess,
     create_windows_process,
     get_windows_executable_command,
+    terminate_windows_process_tree,
 )
 
 # Environment variables to inherit by default
@@ -223,11 +223,15 @@ async def _create_platform_compatible_process(
 ):
     """
     Creates a subprocess in a platform-compatible way.
-    Returns a process handle.
+
+    Unix: Creates process in a new session/process group for killpg support
+    Windows: Creates process in a Job Object for reliable child termination
     """
     if sys.platform == "win32":
+        # Windows: Use Job Objects for proper process tree management
         process = await create_windows_process(command, args, env, errlog, cwd)
     else:
+        # Unix: Create process in new session for process group termination
         process = await anyio.open_process(
             [command, *args],
             env=env,
@@ -241,57 +245,58 @@ async def _create_platform_compatible_process(
 
 async def _terminate_process_with_children(process: Process | FallbackProcess, timeout: float = 2.0) -> None:
     """
-    Terminate a process and all its children using psutil.
-
-    This provides consistent behavior across platforms and properly
-    handles process trees without shell commands.
+    Terminate a process and all its children using platform-specific methods.
 
-    Platform behavior:
-    - On Unix: psutil.terminate() sends SIGTERM, allowing graceful shutdown
-    - On Windows: psutil.terminate() calls TerminateProcess() which is immediate
-      and doesn't allow cleanup handlers to run. This can cause ResourceWarnings
-      for subprocess.Popen objects that don't get to clean up.
+    Unix: Uses os.killpg() for atomic process group termination
+    Windows: Uses Job Objects via pywin32 for reliable child process cleanup
     """
-    pid = getattr(process, "pid", None)
-    if pid is None:
-        popen = getattr(process, "popen", None)
-        if popen:
-            pid = getattr(popen, "pid", None)
-
-    if not pid:
-        # Process has no PID, cannot terminate
-        return
-
-    try:
-        parent = psutil.Process(pid)
-        children = parent.children(recursive=True)
-
-        # First, try graceful termination for all children
-        for child in children:
-            try:
-                child.terminate()
-            except psutil.NoSuchProcess:
-                pass
-
-        # Then, also terminate the parent process
-        try:
-            parent.terminate()
-        except psutil.NoSuchProcess:
+    if sys.platform == "win32":
+        # Windows: Use Job Object termination
+        await terminate_windows_process_tree(process)
+    else:
+        # Unix: Use process groups for atomic termination
+        pid = getattr(process, "pid", None)
+        if pid is None:
+            popen = getattr(process, "popen", None)
+            if popen:
+                pid = getattr(popen, "pid", None)
+
+        if not pid:
             return
 
-        # Wait for processes to exit gracefully, force kill any that remain
-        all_procs = children + [parent]
-        _, alive = await anyio.to_thread.run_sync(lambda: psutil.wait_procs(all_procs, timeout=timeout))
-        for proc in alive:
+        try:
+            # Get process group ID (we use start_new_session=True)
+            pgid = os.getpgid(pid)
+
+            # Send SIGTERM to entire process group atomically
+            os.killpg(pgid, signal.SIGTERM)
+
+            # Wait for graceful termination
+            deadline = anyio.current_time() + timeout
+            while anyio.current_time() < deadline:
+                try:
+                    # Check if process group still exists (signal 0 = check only)
+                    os.killpg(pgid, 0)
+                    await anyio.sleep(0.1)
+                except ProcessLookupError:
+                    # Process group terminated successfully
+                    return
+
+            # Force kill if still alive after timeout
             try:
-                proc.kill()
-            except psutil.NoSuchProcess:
+                os.killpg(pgid, signal.SIGKILL)
+            except ProcessLookupError:
+                # Already dead
                 pass
 
-        # Wait a bit more for force-killed processes
-        if alive:
-            await anyio.to_thread.run_sync(lambda: psutil.wait_procs(alive, timeout=0.5))
-
-    except psutil.NoSuchProcess:
-        # Process already terminated
-        pass
+        except (ProcessLookupError, PermissionError, OSError):
+            # Fall back to simple terminate if process group approach fails
+            try:
+                process.terminate()
+                with anyio.fail_after(timeout):
+                    await process.wait()
+            except Exception:
+                try:
+                    process.kill()
+                except Exception:
+                    pass