Fix FallbackProcess.wait() to use polling instead of blocking

- Replace blocking wait with polling loop in FallbackProcess.wait()
- This allows anyio timeouts to work properly on Windows
- Update test_stdio_client_universal_cleanup to use consistent Python script
- Adjust timeout thresholds to account for Windows process termination overhead

The polling approach prevents the wait() call from blocking indefinitely
when used with anyio's timeout mechanisms, ensuring that cleanup operations
can be properly interrupted if they take too long.

Reported-by: Felix Weinberger

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: felixweinberger

src/mcp/client/stdio/win32.py

@@ -8,7 +8,7 @@
 from pathlib import Path
 from typing import BinaryIO, TextIO, cast
 
-from anyio import to_thread
+import anyio
 from anyio.streams.file import FileReadStream, FileWriteStream
 
 
@@ -91,7 +91,11 @@ async def __aexit__(
 
     async def wait(self):
         """Async wait for process completion."""
-        return await to_thread.run_sync(self.popen.wait)
+        # Poll the process status instead of blocking wait
+        # This allows anyio timeouts to work properly
+        while self.popen.poll() is None:
+            await anyio.sleep(0.1)
+        return self.popen.returncode
 
     def terminate(self):
         """Terminate the subprocess immediately."""

tests/client/test_stdio.py

@@ -105,42 +105,49 @@ async def test_stdio_client_universal_cleanup():
     even when connected to processes that exit slowly.
     """
 
-    # Use a simple sleep command that's available on all platforms
-    # This simulates a process that takes time to terminate
-    if sys.platform == "win32":
-        # Windows: use ping with timeout to simulate a running process
-        server_params = StdioServerParameters(
-            command="ping",
-            args=["127.0.0.1", "-n", "10"],  # Ping 10 times, takes ~10 seconds
-        )
-    else:
-        # Unix: use sleep command
-        server_params = StdioServerParameters(
-            command="sleep",
-            args=["10"],  # Sleep for 10 seconds
-        )
+    # Use a Python script that simulates a long-running process
+    # This ensures consistent behavior across platforms
+    long_running_script = textwrap.dedent(
+        """
+        import time
+        import sys
+        
+        # Simulate a long-running process
+        for i in range(100):
+            time.sleep(0.1)
+            # Flush to ensure output is visible
+            sys.stdout.flush()
+            sys.stderr.flush()
+        """
+    )
+
+    server_params = StdioServerParameters(
+        command="python",
+        args=["-c", long_running_script],
+    )
 
     start_time = time.time()
 
-    # Use move_on_after which is more reliable for cleanup scenarios
-    with anyio.move_on_after(6.0) as cancel_scope:
+    # Increased timeout to account for Windows process termination overhead
+    with anyio.move_on_after(8.0) as cancel_scope:
         async with stdio_client(server_params) as (read_stream, write_stream):
             # Immediately exit - this triggers cleanup while process is still running
             pass
 
         end_time = time.time()
         elapsed = end_time - start_time
 
-        # Key assertion: Should complete quickly due to timeout mechanism
-        assert elapsed < 5.0, (
-            f"stdio_client cleanup took {elapsed:.1f} seconds, expected < 5.0 seconds. "
+        # Key assertion: Should complete within reasonable time due to timeout mechanism
+        # On Windows: 2s (stdin wait) + 2s (terminate wait) + overhead = ~5s expected
+        assert elapsed < 6.0, (
+            f"stdio_client cleanup took {elapsed:.1f} seconds, expected < 6.0 seconds. "
             f"This suggests the timeout mechanism may not be working properly."
         )
 
     # Check if we timed out
     if cancel_scope.cancelled_caught:
         pytest.fail(
-            "stdio_client cleanup timed out after 6.0 seconds. "
+            "stdio_client cleanup timed out after 8.0 seconds. "
             "This indicates the cleanup mechanism is hanging and needs fixing."
         )