Add Windows process termination debug scripts

felixweinberger · felixweinberger · commit b4a2bf9b9a82 · 2025-07-01T12:58:44.000+01:00
These scripts help investigate why process tree termination
is failing on Windows for the three failing tests:
- test_stdio_client_child_process_cleanup
- test_stdio_client_early_parent_exit
- test_stdio_client_nested_process_tree

The scripts test different scenarios:
1. debug_process_tree.py - Tests taskkill /T and our recursive WMI approach
2. debug_process_flags.py - Tests different process creation flags
3. debug_process_hierarchy.py - Shows process parent-child relationships
diff --git a/debug_process_flags.py b/debug_process_flags.py
@@ -0,0 +1,83 @@
+"""Debug script to test Windows process creation flags"""
+import subprocess
+import sys
+import time
+import tempfile
+import os
+
+def test_process_flags():
+    # 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
+with open({repr(marker_file)}, 'a') as f:
+    while True:
+        f.write(f"{{time.time()}} ")
+        f.flush()
+        time.sleep(0.1)
+'''
+    
+    # Test 1: Default creation (inherits console)
+    print("\n=== Test 1: Default process creation ===")
+    proc1 = subprocess.Popen([sys.executable, "-c", child_script])
+    print(f"Started process with PID: {proc1.pid}")
+    time.sleep(0.5)
+    
+    # Try taskkill /T
+    result = subprocess.run(
+        ["taskkill", "/F", "/T", "/PID", str(proc1.pid)],
+        capture_output=True,
+        text=True
+    )
+    print(f"taskkill result: {result.returncode}")
+    print(f"Output: {result.stdout}")
+    
+    # Test 2: With CREATE_NEW_PROCESS_GROUP
+    print("\n=== Test 2: With CREATE_NEW_PROCESS_GROUP ===")
+    proc2 = subprocess.Popen(
+        [sys.executable, "-c", child_script],
+        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP
+    )
+    print(f"Started process with PID: {proc2.pid}")
+    time.sleep(0.5)
+    
+    # Try taskkill /T
+    result = subprocess.run(
+        ["taskkill", "/F", "/T", "/PID", str(proc2.pid)],
+        capture_output=True,
+        text=True
+    )
+    print(f"taskkill result: {result.returncode}")
+    print(f"Output: {result.stdout}")
+    
+    # Test 3: With CREATE_NO_WINDOW
+    print("\n=== Test 3: With CREATE_NO_WINDOW ===")
+    proc3 = subprocess.Popen(
+        [sys.executable, "-c", child_script],
+        creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    )
+    print(f"Started process with PID: {proc3.pid}")
+    time.sleep(0.5)
+    
+    # Try taskkill /T
+    result = subprocess.run(
+        ["taskkill", "/F", "/T", "/PID", str(proc3.pid)],
+        capture_output=True,
+        text=True
+    )
+    print(f"taskkill result: {result.returncode}")
+    print(f"Output: {result.stdout}")
+    
+    # Clean up
+    try:
+        os.unlink(marker_file)
+    except:
+        pass
+
+if __name__ == "__main__":
+    test_process_flags()
diff --git a/debug_process_hierarchy.py b/debug_process_hierarchy.py
@@ -0,0 +1,117 @@
+"""Debug script to understand Windows process hierarchy"""
+import subprocess
+import sys
+import time
+import os
+
+def show_process_tree():
+    """Show the full process tree for Python processes"""
+    print("\n=== Full Python Process Tree ===")
+    
+    # Get all python processes
+    result = subprocess.run(
+        ["wmic", "process", "where", "Name='python.exe'", "get", "ProcessId,ParentProcessId,CommandLine", "/FORMAT:LIST"],
+        capture_output=True,
+        text=True
+    )
+    
+    processes = []
+    current = {}
+    
+    for line in result.stdout.strip().split('\n'):
+        line = line.strip()
+        if not line:
+            if current and 'ProcessId' in current:
+                processes.append(current)
+            current = {}
+        elif '=' in line:
+            key, value = line.split('=', 1)
+            current[key] = value
+    
+    if current and 'ProcessId' in current:
+        processes.append(current)
+    
+    # Build tree
+    print("\nProcess Hierarchy:")
+    for proc in processes:
+        pid = proc.get('ProcessId', '')
+        ppid = proc.get('ParentProcessId', '')
+        cmd = proc.get('CommandLine', '')[:100] + '...' if len(proc.get('CommandLine', '')) > 100 else proc.get('CommandLine', '')
+        print(f"PID: {pid} <- Parent: {ppid}")
+        print(f"  Cmd: {cmd}")
+        print()
+
+def test_nested_hierarchy():
+    """Create a nested process hierarchy and show relationships"""
+    
+    # Grandchild script
+    grandchild_script = '''
+import os
+import time
+print(f"Grandchild PID: {os.getpid()}")
+while True:
+    time.sleep(0.1)
+'''
+    
+    # Child script that spawns grandchild
+    child_script = f'''
+import subprocess
+import sys
+import os
+import time
+
+print(f"Child PID: {{os.getpid()}}")
+
+# Spawn grandchild
+grandchild = subprocess.Popen([sys.executable, '-c', {repr(grandchild_script)}])
+
+while True:
+    time.sleep(0.1)
+'''
+    
+    # Parent script that spawns child
+    parent_script = f'''
+import subprocess
+import sys
+import os
+import time
+
+print(f"Parent PID: {{os.getpid()}}")
+
+# Spawn child
+child = subprocess.Popen([sys.executable, '-c', {repr(child_script)}])
+
+while True:
+    time.sleep(0.1)
+'''
+    
+    print("Creating nested process hierarchy...")
+    
+    # Start parent
+    parent = subprocess.Popen([sys.executable, "-c", parent_script])
+    print(f"Top-level parent PID: {parent.pid}")
+    
+    # Wait for all processes to start
+    time.sleep(1.0)
+    
+    # Show the tree
+    show_process_tree()
+    
+    # Test taskkill on parent
+    print("\n=== Testing taskkill /T on parent ===")
+    result = subprocess.run(
+        ["taskkill", "/F", "/T", "/PID", str(parent.pid)],
+        capture_output=True,
+        text=True
+    )
+    print(f"Result: {result.returncode}")
+    print(f"Output: {result.stdout}")
+    print(f"Error: {result.stderr}")
+    
+    # Show tree after
+    time.sleep(0.5)
+    print("\n=== Process tree after taskkill ===")
+    show_process_tree()
+
+if __name__ == "__main__":
+    test_nested_hierarchy()
diff --git a/debug_process_tree.py b/debug_process_tree.py
@@ -0,0 +1,151 @@
+"""Debug script to test Windows process tree termination"""
+import subprocess
+import sys
+import time
+import tempfile
+import os
+import asyncio
+
+async def test_recursive_kill(pid):
+    """Test our recursive kill implementation"""
+    print(f"\n=== Testing recursive kill for PID {pid} ===")
+    
+    # First, show process tree before
+    print("\nProcess tree before kill:")
+    wmic_result = subprocess.run(
+        ["wmic", "process", "where", f"ParentProcessId={pid} or ProcessId={pid}", "get", "ProcessId,ParentProcessId,Name"],
+        capture_output=True,
+        text=True
+    )
+    print(wmic_result.stdout)
+    
+    # Import and test our function
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+    from mcp.client.stdio import _kill_process_tree_windows
+    
+    # Run the kill function
+    await _kill_process_tree_windows(pid)
+    
+    # Show process tree after
+    time.sleep(0.5)
+    print("\nProcess tree after kill:")
+    wmic_result = subprocess.run(
+        ["wmic", "process", "where", f"ParentProcessId={pid} or ProcessId={pid}", "get", "ProcessId,ParentProcessId,Name"],
+        capture_output=True,
+        text=True
+    )
+    print(wmic_result.stdout)
+
+def test_process_tree():
+    # Create a marker file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+        marker_file = f.name
+    
+    print(f"Marker file: {marker_file}")
+    
+    # Parent script that spawns a child
+    parent_script = f'''
+import subprocess
+import sys
+import time
+import os
+
+# Child script that writes continuously
+child_script = """
+import time
+with open({repr(marker_file)}, 'a') as f:
+    while True:
+        f.write(f"{{time.time()}}")
+        f.flush()
+        time.sleep(0.1)
+"""
+
+# Start the child process
+print(f"Parent PID: {{os.getpid()}}")
+child = subprocess.Popen([sys.executable, '-c', child_script])
+print(f"Child PID: {{child.pid}}")
+
+# Parent just sleeps
+while True:
+    time.sleep(0.1)
+'''
+    
+    # Start parent process
+    print("Starting parent process...")
+    parent = subprocess.Popen([sys.executable, "-c", parent_script])
+    print(f"Parent started with PID: {parent.pid}")
+    
+    # Wait for child to start writing
+    time.sleep(1.0)
+    
+    # Check if 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 is growing: {size1} -> {size2} bytes")
+    
+    # Show initial process tree
+    print("\n=== Initial process tree ===")
+    wmic_result = subprocess.run(
+        ["wmic", "process", "where", f"ProcessId={parent.pid}", "get", "ProcessId,ParentProcessId,Name", "/FORMAT:VALUE"],
+        capture_output=True,
+        text=True
+    )
+    print("Parent process info:")
+    print(wmic_result.stdout)
+    
+    # Try different termination methods
+    print("\n=== Method 1: taskkill /T ===")
+    result = subprocess.run(
+        ["taskkill", "/F", "/T", "/PID", str(parent.pid)],
+        capture_output=True,
+        text=True
+    )
+    print(f"Return code: {result.returncode}")
+    print(f"Stdout: {result.stdout}")
+    print(f"Stderr: {result.stderr}")
+    
+    # Check if processes stopped
+    time.sleep(0.5)
+    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: File still growing: {size3} -> {size4} bytes")
+            
+            # Try to find child processes
+            print("\n=== Finding child processes with wmic ===")
+            wmic_result = subprocess.run(
+                ["wmic", "process", "where", f"ParentProcessId={parent.pid}", "get", "ProcessId,ParentProcessId,Name", "/FORMAT:VALUE"],
+                capture_output=True,
+                text=True
+            )
+            print("Child processes still running:")
+            print(wmic_result.stdout)
+            
+            # Test our recursive approach
+            print("\n=== Testing recursive kill approach ===")
+            asyncio.run(test_recursive_kill(parent.pid))
+            
+            # 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: File still growing after recursive kill: {size5} -> {size6} bytes")
+            else:
+                print(f"SUCCESS with recursive kill: File stopped growing at {size6} bytes")
+        else:
+            print(f"SUCCESS: File stopped growing at {size4} bytes")
+    
+    # Clean up
+    try:
+        os.unlink(marker_file)
+    except:
+        pass
+
+if __name__ == "__main__":
+    test_process_tree()
