fix: restructure export_tar to properly stream without blocking

- Use async_docker_call to wrap exec_run call instead of asyncio.to_thread
- Implement proper async streaming using async generator
- Process chunks individually without loading entire stream into memory
- Fix unused variable linting error
- All 229 unit tests passing

Co-authored-by: pvliesdonk <22190282+pvliesdonk@users.noreply.github.com>

Author: Copilot

src/mcp_devbench/managers/filesystem_manager.py

@@ -923,28 +923,35 @@ async def export_tar(
                 tar_flags = "czf" if compress else "cf"
                 full_cmd = f"tar -{tar_flags} - -C {shlex.quote(normalized_path)} ."
 
-            # Execute tar command and stream output - wrap in thread pool
-            # Note: We need to handle streaming properly
-            def run_tar_stream():
-                return container.exec_run(
-                    ["sh", "-c", full_cmd],
-                    user="1000:1000",
-                    stream=True,
-                    demux=False,
-                )
-
-            exec_result = await asyncio.to_thread(run_tar_stream)
+            # Execute tar command with streaming - wrap exec_run in thread pool
+            exec_result = await async_docker_call(
+                container.exec_run,
+                ["sh", "-c", full_cmd],
+                user="1000:1000",
+                stream=True,
+                demux=False,
+            )
 
-            # Stream the output in chunks (Docker handles chunking)
-            # Wrap the iteration in a thread to avoid blocking
-            def iter_chunks():
-                for chunk in exec_result.output:
+            # Stream the output in chunks without loading all into memory
+            # The iteration over exec_result.output is blocking, so wrap it
+            async def stream_chunks():
+                """Async generator that yields chunks from the blocking iterator."""
+                def get_next_chunk(iterator):
+                    """Get the next chunk from iterator in a thread-safe way."""
+                    try:
+                        return next(iterator), False  # (chunk, done)
+                    except StopIteration:
+                        return None, True  # (None, done)
+
+                iterator = iter(exec_result.output)
+                while True:
+                    chunk, done = await asyncio.to_thread(get_next_chunk, iterator)
+                    if done:
+                        break
                     if chunk:
                         yield chunk
 
-            # Stream chunks from the thread to avoid blocking the event loop
-            loop = asyncio.get_running_loop()
-            for chunk in await asyncio.to_thread(lambda: list(iter_chunks())):
+            async for chunk in stream_chunks():
                 yield chunk
 
             logger.info(f"Exported tar from {normalized_path} in container {container_id}")