Fix Windows timeout mechanism in FallbackProcess.wait()

The FallbackProcess.wait() method was using to_thread.run_sync() with
subprocess.Popen.wait(), which is a blocking call that cannot be
interrupted by anyio's timeout mechanism. This caused the cleanup
sequence to wait indefinitely for processes to exit, ignoring the
2-second timeout.

The fix replaces the blocking wait with a polling approach that checks
process status every 0.1 seconds, allowing anyio.fail_after() to
properly interrupt the wait operation when the timeout expires.

This ensures the MCP spec-compliant shutdown sequence works correctly:
1. Close stdin and wait up to 2 seconds
2. If process doesn't exit, call terminate() and wait up to 2 seconds
3. If still running, force kill with taskkill

Reported-by: fweinberger

Author: felixweinberger

debug_windows_test.py

@@ -185,47 +185,29 @@ async def stdin_writer():
             # 1. Close input stream to server
             # 2. Wait for server to exit, or send SIGTERM if it doesn't exit in time
             # 3. Send SIGKILL if still not exited
-            import logging
-            logger = logging.getLogger("mcp.stdio_debug")
-            logger.info("Starting cleanup sequence...")
-            
             if process.stdin:
                 try:
-                    logger.info("Closing stdin...")
                     await process.stdin.aclose()
-                    logger.info("stdin closed")
-                except Exception as e:
+                except Exception:
                     # stdin might already be closed, which is fine
-                    logger.info(f"stdin close exception (ignored): {e}")
                     pass
 
             try:
                 # Give the process time to exit gracefully after stdin closes
-                logger.info("Waiting for process to exit after stdin closure...")
                 with anyio.fail_after(2.0):
                     await process.wait()
-                logger.info("Process exited gracefully")
             except TimeoutError:
                 # Process didn't exit from stdin closure, use our termination function
                 # that handles child processes properly
-                logger.info("Process didn't exit from stdin closure, terminating...")
                 await _terminate_process_with_children(process)
-                logger.info("Process terminated")
             except ProcessLookupError:
                 # Process already exited, which is fine
-                logger.info("Process already exited")
                 pass
 
-            logger.info("Closing streams...")
             await read_stream.aclose()
-            logger.info("read_stream closed")
             await write_stream.aclose()
-            logger.info("write_stream closed")
             await read_stream_writer.aclose()
-            logger.info("read_stream_writer closed")
             await write_stream_reader.aclose()
-            logger.info("write_stream_reader closed")
-            logger.info("Cleanup complete")
 
 
 def _get_executable_command(command: str) -> str:
@@ -283,9 +265,6 @@ async def _terminate_process_with_children(process: Process | FallbackProcess, t
         process: The process to terminate
         timeout: Time to wait for graceful termination before force killing
     """
-    import logging
-    logger = logging.getLogger("mcp.stdio_debug")
-    logger.info(f"_terminate_process_with_children called for process on {sys.platform}")
     if sys.platform != "win32":
         # POSIX: Kill entire process group to avoid orphaning children
         pid = getattr(process, "pid", None)
@@ -323,23 +302,17 @@ async def _terminate_process_with_children(process: Process | FallbackProcess, t
 
         # Try graceful termination first
         try:
-            logger.info(f"Calling terminate() on process with PID {pid}")
             process.terminate()
-            logger.info("Waiting for process to exit after terminate()...")
             with anyio.fail_after(timeout):
                 await process.wait()
-            logger.info("Process exited after terminate()")
         except TimeoutError:
             # Force kill using taskkill for tree termination
-            logger.info(f"Process didn't exit after terminate(), force killing with taskkill")
-            result = await anyio.to_thread.run_sync(
+            await anyio.to_thread.run_sync(
                 subprocess.run,
                 ["taskkill", "/F", "/T", "/PID", str(pid)],
                 capture_output=True,
                 shell=False,
                 check=False,
             )
-            logger.info(f"taskkill result: returncode={result.returncode}, stdout={result.stdout}, stderr={result.stderr}")
         except ProcessLookupError:
-            logger.info("Process already exited (ProcessLookupError)")
             pass

src/mcp/client/stdio/__init__.py

@@ -8,6 +8,7 @@
 from pathlib import Path
 from typing import BinaryIO, TextIO, cast
 
+import anyio
 from anyio import to_thread
 from anyio.streams.file import FileReadStream, FileWriteStream
 
@@ -92,7 +93,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."""