Fix Windows process tree termination by using shell=True for taskkill

The issue was that taskkill /T requires shell=True to work properly
on Windows. This was shown by the debug_process_flags.py output where
taskkill successfully terminated process trees when called directly.

Simplified the implementation:
- Use shell=True for taskkill commands on Windows
- Remove complex WMI fallback code that wasn't working
- Keep simple fallback for single process termination

This should fix the three failing Windows tests:
- test_stdio_client_child_process_cleanup
- test_stdio_client_early_parent_exit
- test_stdio_client_nested_process_tree

Author: felixweinberger

debug_process_tree.py

@@ -53,7 +53,7 @@ def test_process_tree():
 # Child script that writes continuously
 child_script = """
 import time
-with open({repr(marker_file)}, 'a') as f:
+with open(r'{marker_file}', 'a') as f:
     while True:
         f.write(f"{{time.time()}}")
         f.flush()

debug_windows_termination.py

@@ -0,0 +1,128 @@
+"""Debug Windows process termination - uses PowerShell instead of wmic"""
+import subprocess
+import sys
+import time
+import tempfile
+import os
+import json
+
+def get_process_tree_powershell(pid):
+    """Get process tree using PowerShell"""
+    ps_script = f"""
+    Get-WmiObject Win32_Process | Where-Object {{ $_.ProcessId -eq {pid} -or $_.ParentProcessId -eq {pid} }} | 
+    Select-Object ProcessId, ParentProcessId, Name | ConvertTo-Json
+    """
+    
+    try:
+        result = subprocess.run(
+            ["powershell", "-Command", ps_script],
+            capture_output=True,
+            text=True,
+            shell=True
+        )
+        if result.returncode == 0 and result.stdout:
+            return json.loads(result.stdout)
+        return []
+    except:
+        return []
+
+def test_termination():
+    # Create a marker file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+        marker_file = f.name
+    
+    print(f"Marker file: {marker_file}")
+    
+    # Simple child script
+    child_script = f"""
+import time
+print(f"Child PID: {{os.getpid()}}")
+with open(r'{marker_file}', 'a') as f:
+    while True:
+        f.write('x')
+        f.flush()
+        time.sleep(0.1)
+"""
+    
+    # Parent script that spawns child
+    parent_script = f"""
+import subprocess
+import sys
+import os
+print(f"Parent PID: {{os.getpid()}}")
+child = subprocess.Popen([sys.executable, '-c', r'''{child_script}'''])
+print(f"Started child with PID: {{child.pid}}")
+while True:
+    time.sleep(0.1)
+"""
+    
+    print("\n=== Starting test processes ===")
+    parent = subprocess.Popen([sys.executable, "-c", parent_script])
+    print(f"Parent PID: {parent.pid}")
+    
+    # Wait for processes to start
+    time.sleep(1.0)
+    
+    # Check file is being written
+    if os.path.exists(marker_file):
+        size1 = os.path.getsize(marker_file)
+        time.sleep(0.5)
+        size2 = os.path.getsize(marker_file)
+        print(f"File growing: {size1} -> {size2} bytes")
+    
+    # Show process tree
+    print("\n=== Process tree before termination ===")
+    processes = get_process_tree_powershell(parent.pid)
+    for proc in processes if isinstance(processes, list) else [processes]:
+        print(f"PID: {proc.get('ProcessId')} Parent: {proc.get('ParentProcessId')} Name: {proc.get('Name')}")
+    
+    # Test different termination methods
+    print("\n=== Test 1: parent.terminate() ===")
+    parent.terminate()
+    time.sleep(0.5)
+    
+    # Check if child stopped
+    if os.path.exists(marker_file):
+        size3 = os.path.getsize(marker_file)
+        time.sleep(0.5)
+        size4 = os.path.getsize(marker_file)
+        if size4 > size3:
+            print(f"FAILED: Child still writing ({size3} -> {size4})")
+            
+            # Try taskkill /T
+            print("\n=== Test 2: taskkill /T ===")
+            result = subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(parent.pid)],
+                capture_output=True,
+                text=True,
+                shell=True
+            )
+            print(f"Result: {result.returncode}")
+            print(f"Output: {result.stdout}")
+            
+            # Final check
+            time.sleep(0.5)
+            size5 = os.path.getsize(marker_file)
+            time.sleep(0.5)
+            size6 = os.path.getsize(marker_file)
+            if size6 > size5:
+                print(f"STILL FAILED: Child still writing ({size5} -> {size6})")
+                
+                # Show remaining processes
+                print("\n=== Remaining processes ===")
+                remaining = get_process_tree_powershell(parent.pid)
+                for proc in remaining if isinstance(remaining, list) else [remaining]:
+                    print(f"PID: {proc.get('ProcessId')} Parent: {proc.get('ParentProcessId')}")
+            else:
+                print("SUCCESS: Child stopped")
+        else:
+            print("SUCCESS: Child stopped with parent")
+    
+    # Cleanup
+    try:
+        os.unlink(marker_file)
+    except:
+        pass
+
+if __name__ == "__main__":
+    test_termination()

src/mcp/client/stdio/__init__.py

@@ -254,59 +254,28 @@ async def _create_platform_compatible_process(
 
 async def _kill_process_tree_windows(pid: int) -> None:
     """
-    Recursively kill a process and all its children on Windows.
-    Uses WMI to find child processes since taskkill /T doesn't always work.
+    Kill a process and all its children on Windows using taskkill /T.
     """
-    # First try taskkill with /T flag
+    # Use taskkill with /T flag to kill the process tree
+    # Note: shell=True is needed on Windows for taskkill to work properly
     result = await anyio.to_thread.run_sync(
         subprocess.run,
         ["taskkill", "/F", "/T", "/PID", str(pid)],
         capture_output=True,
-        shell=False,
+        shell=True,
         check=False,
     )
 
-    # If that worked, we're done
-    if result.returncode == 0:
-        return
-    
-    # Otherwise, try to find and kill children manually
-    # First, get all child processes
-    children_pids: set[int] = set()
-    
-    # Use wmic to get child processes
-    wmic_result = await anyio.to_thread.run_sync(
-        subprocess.run,
-        ["wmic", "process", "where", f"ParentProcessId={pid}", "get", "ProcessId", "/FORMAT:VALUE"],
-        capture_output=True,
-        shell=False,
-        check=False,
-        text=True,
-    )
-    
-    if wmic_result.returncode == 0 and wmic_result.stdout:
-        # Parse child PIDs
-        for line in wmic_result.stdout.strip().split('\n'):
-            if line.startswith('ProcessId='):
-                try:
-                    child_pid = int(line.split('=')[1].strip())
-                    if child_pid > 0:
-                        children_pids.add(child_pid)
-                except (ValueError, IndexError):
-                    pass
-    
-    # Recursively kill all children first
-    for child_pid in children_pids:
-        await _kill_process_tree_windows(child_pid)
-    
-    # Finally kill the parent process
-    await anyio.to_thread.run_sync(
-        subprocess.run,
-        ["taskkill", "/F", "/PID", str(pid)],
-        capture_output=True,
-        shell=False,
-        check=False,
-    )
+    # If taskkill failed, try without /T flag as a fallback
+    # This handles the case where the process might have already exited
+    if result.returncode != 0:
+        await anyio.to_thread.run_sync(
+            subprocess.run,
+            ["taskkill", "/F", "/PID", str(pid)],
+            capture_output=True,
+            shell=True,
+            check=False,
+        )
 
 
 async def _terminate_process_with_children(process: Process | FallbackProcess, timeout: float = 2.0) -> None:

test_simple_termination.py

@@ -0,0 +1,111 @@
+"""Simple test to understand Windows process termination"""
+import subprocess
+import sys
+import time
+import os
+import tempfile
+
+# Test with direct subprocess
+print("=== Direct subprocess test ===")
+
+# Create marker file
+with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+    marker_file = f.name
+
+# Start a simple child process
+child_code = f"""
+import time
+with open(r'{marker_file}', 'w') as f:
+    for i in range(100):
+        f.write(str(i) + ' ')
+        f.flush()
+        time.sleep(0.1)
+"""
+
+print("Starting child process...")
+child = subprocess.Popen([sys.executable, "-c", child_code])
+print(f"Child PID: {child.pid}")
+
+# Let it write for a bit
+time.sleep(0.5)
+size1 = os.path.getsize(marker_file)
+print(f"File size after 0.5s: {size1}")
+
+# Terminate child
+print("Terminating child...")
+child.terminate()
+child.wait()
+
+# Check if it stopped
+time.sleep(0.5)
+size2 = os.path.getsize(marker_file)
+print(f"File size after termination: {size2}")
+
+if size2 > size1:
+    print("SUCCESS: Direct child termination works")
+
+# Cleanup
+os.unlink(marker_file)
+
+print("\n=== Nested subprocess test ===")
+
+# Now test with nested processes (parent spawns child)
+with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+    marker_file = f.name
+
+parent_code = f"""
+import subprocess
+import sys
+import time
+
+child_code = '''
+import time
+with open(r'{marker_file}', 'w') as f:
+    for i in range(100):
+        f.write(str(i) + ' ')
+        f.flush()
+        time.sleep(0.1)
+'''
+
+# Start child
+child = subprocess.Popen([sys.executable, '-c', child_code])
+print(f'Parent started child with PID: {{child.pid}}')
+
+# Parent just waits
+while True:
+    time.sleep(0.1)
+"""
+
+print("Starting parent process...")
+parent = subprocess.Popen([sys.executable, "-c", parent_code])
+print(f"Parent PID: {parent.pid}")
+
+# Let child write
+time.sleep(1.0)
+size1 = os.path.getsize(marker_file)
+print(f"File size after 1s: {size1}")
+
+# Terminate parent only
+print("Terminating parent...")
+parent.terminate()
+
+# Check if child stopped
+time.sleep(0.5)
+size2 = os.path.getsize(marker_file)
+time.sleep(0.5)
+size3 = os.path.getsize(marker_file)
+
+if size3 > size2:
+    print(f"FAILED: Child still writing ({size2} -> {size3})")
+    print("This confirms that terminating parent doesn't kill children on Windows")
+else:
+    print("SUCCESS: Child stopped with parent")
+
+# Cleanup
+try:
+    # Kill any remaining processes
+    subprocess.run(["taskkill", "/F", "/IM", "python.exe", "/FI", f"PID ne {os.getpid()}"], 
+                   capture_output=True, shell=True)
+    os.unlink(marker_file)
+except:
+    pass