ouroboros-ai 0.40.2.dev6__tar.gz → 0.40.2.dev7__tar.gz

{ouroboros_ai-0.40.2.dev6 → ouroboros_ai-0.40.2.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.40.2.dev6
+Version: 0.40.2.dev7
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.40.2.dev6 → ouroboros_ai-0.40.2.dev7}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.40.2.dev6'
-__version_tuple__ = version_tuple = (0, 40, 2, 'dev6')
+__version__ = version = '0.40.2.dev7'
+__version_tuple__ = version_tuple = (0, 40, 2, 'dev7')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.40.2.dev6 → ouroboros_ai-0.40.2.dev7}/src/ouroboros/orchestrator/opencode_runtime.py

@@ -29,6 +29,7 @@ import os
 from pathlib import Path
 import re
 import shutil
+import subprocess
 from typing import Any
 
 from ouroboros.config import get_opencode_cli_path
@@ -566,6 +567,65 @@ class OpenCodeRuntime:
 
     # -- Process management ------------------------------------------------
 
+    def _cleanup_windows_child_processes(self, process: Any) -> bool:
+        """Best-effort cleanup for Windows children orphaned by Node CLIs.
+
+        OpenCode may leave session-server children behind after the parent
+        subprocess exits normally. Windows preserves the original parent PID
+        on those orphaned children, so a PPID-targeted cleanup can run even
+        after ``process.wait()`` has completed.
+        """
+        if os.name != "nt":
+            return True
+        pid = getattr(process, "pid", None)
+        if pid is None:
+            return True
+        try:
+            result = subprocess.run(
+                ["wmic", "process", "where", f"(ParentProcessId={pid})", "delete"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            returncode = getattr(result, "returncode", 0)
+            if isinstance(returncode, int) and returncode != 0:
+                log.warning(
+                    f"{self._log_namespace}.windows_child_cleanup_failed",
+                    pid=pid,
+                    returncode=returncode,
+                )
+                return False
+            return True
+        except Exception as exc:
+            log.warning(
+                f"{self._log_namespace}.windows_child_cleanup_failed",
+                pid=pid,
+                error=str(exc),
+            )
+            return False
+
+    async def _collect_stderr_after_windows_cleanup(
+        self,
+        stderr_task: asyncio.Task[list[str]] | None,
+        *,
+        cleanup_succeeded: bool,
+    ) -> list[str]:
+        """Drain stderr, but do not hang forever after failed Windows cleanup.
+
+        Windows child cleanup is best-effort. If it fails while an orphaned
+        child still owns the inherited stderr pipe, waiting for EOF can block
+        normal result emission. In that failure mode, cancel the stderr drain
+        and let the caller return the best available result/error message.
+        """
+        if stderr_task is None:
+            return []
+        if cleanup_succeeded or stderr_task.done():
+            return await stderr_task
+        stderr_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await stderr_task
+        return []
+
     async def _terminate_process(self, process: Any) -> None:
         """Best-effort subprocess shutdown.
 
@@ -1097,6 +1157,8 @@ class OpenCodeRuntime:
         process: Any | None = None
         process_finished = False
         process_terminated = False
+        windows_child_cleanup_done = False
+        windows_child_cleanup_succeeded = True
         control_state: dict[str, Any] | None = None
         stderr_task: asyncio.Task[list[str]] | None = None
 
@@ -1226,10 +1288,15 @@ class OpenCodeRuntime:
         except TimeoutError as e:
             if process is not None and control_state is not None:
                 await self._terminate_process(process)
+                windows_child_cleanup_succeeded = self._cleanup_windows_child_processes(process)
+                windows_child_cleanup_done = True
                 control_state["terminated"] = True
             process_terminated = True
             if stderr_task is not None:
-                stderr_lines = await stderr_task
+                stderr_lines = await self._collect_stderr_after_windows_cleanup(
+                    stderr_task,
+                    cleanup_succeeded=windows_child_cleanup_succeeded,
+                )
             final_message = "\n".join(stderr_lines).strip()
             if not final_message:
                 final_message = f"{self._display_name} became unresponsive and was terminated: {e}"
@@ -1259,7 +1326,12 @@ class OpenCodeRuntime:
                 process=process,
                 control_state=control_state,
             )
-            stderr_lines = await stderr_task
+            windows_child_cleanup_succeeded = self._cleanup_windows_child_processes(process)
+            windows_child_cleanup_done = True
+            stderr_lines = await self._collect_stderr_after_windows_cleanup(
+                stderr_task,
+                cleanup_succeeded=windows_child_cleanup_succeeded,
+            )
 
             if yielded_final:
                 return
@@ -1299,6 +1371,9 @@ class OpenCodeRuntime:
                     and getattr(process, "returncode", None) is None
                 ):
                     await self._terminate_process(process)
+                    process_terminated = True
+                if not windows_child_cleanup_done:
+                    self._cleanup_windows_child_processes(process)
             if stderr_task is not None and not stderr_task.done():
                 stderr_task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):

{ouroboros_ai-0.40.2.dev6 → ouroboros_ai-0.40.2.dev7}/tests/unit/orchestrator/test_opencode_runtime.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import asyncio
 import inspect
 import json
 from pathlib import Path
+from types import SimpleNamespace
 from unittest.mock import AsyncMock, patch
 
 import pytest
@@ -18,6 +20,10 @@ from ouroboros.router import Resolved, ResolveRequest
 from ouroboros.router import resolve_skill_dispatch as shared_resolve_skill_dispatch
 
 
+async def _collect_async(iterator):
+    return [item async for item in iterator]
+
+
 class _FakeStream:
     def __init__(self, lines: list[str]) -> None:
         encoded = "".join(f"{line}\n" for line in lines).encode()
@@ -35,6 +41,19 @@ class _FakeStream:
         return data
 
 
+class _WaitForCleanupStream:
+    def __init__(self, cleanup_started: asyncio.Event) -> None:
+        self._cleanup_started = cleanup_started
+        self._closed = False
+
+    async def read(self, _n: int = -1) -> bytes:
+        if self._closed:
+            return b""
+        await self._cleanup_started.wait()
+        self._closed = True
+        return b""
+
+
 class _FakeStdin:
     """Minimal stdin mock that supports write/drain/close/wait_closed."""
 
@@ -1225,6 +1244,223 @@ class TestOpenCodeRuntimeExecuteTask:
         assert len(text_msgs) >= 1
         assert "Task completed" in text_msgs[0].content
 
+    def test_windows_child_cleanup_invokes_wmic_for_parent_pid(self) -> None:
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+        process = _FakeProcess(stdout_lines=[], stderr_lines=[], returncode=0)
+        process.pid = 4242
+
+        with (
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(opencode_runtime_module.subprocess, "run") as mock_run,
+        ):
+            runtime._cleanup_windows_child_processes(process)
+
+        mock_run.assert_called_once_with(
+            ["wmic", "process", "where", "(ParentProcessId=4242)", "delete"],
+            capture_output=True,
+            timeout=5,
+            check=False,
+        )
+
+    def test_windows_child_cleanup_skips_non_windows(self) -> None:
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+        process = _FakeProcess(stdout_lines=[], stderr_lines=[], returncode=0)
+
+        with (
+            patch.object(opencode_runtime_module.os, "name", "posix"),
+            patch.object(opencode_runtime_module.subprocess, "run") as mock_run,
+        ):
+            runtime._cleanup_windows_child_processes(process)
+
+        mock_run.assert_not_called()
+
+    def test_windows_child_cleanup_logs_failures(self) -> None:
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+        process = _FakeProcess(stdout_lines=[], stderr_lines=[], returncode=0)
+
+        with (
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(
+                opencode_runtime_module.subprocess, "run", side_effect=TimeoutError("slow")
+            ),
+            patch.object(opencode_runtime_module.log, "warning") as mock_warning,
+        ):
+            runtime._cleanup_windows_child_processes(process)
+
+        mock_warning.assert_called_once()
+        assert mock_warning.call_args.args[0] == "opencode_runtime.windows_child_cleanup_failed"
+
+    @pytest.mark.asyncio
+    async def test_execute_task_windows_child_cleanup_runs_after_success(self) -> None:
+        text_event = json.dumps(
+            {
+                "type": "text",
+                "sessionID": "sess-windows-cleanup",
+                "part": {"type": "text", "text": "Done"},
+            }
+        )
+        process = _FakeProcess(stdout_lines=[text_event], stderr_lines=[], returncode=0)
+        process.pid = 6789
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+
+        with (
+            patch("asyncio.create_subprocess_exec", return_value=process),
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(opencode_runtime_module.subprocess, "run") as mock_run,
+        ):
+            messages = [msg async for msg in runtime.execute_task("Hello")]
+
+        assert any(msg.type == "result" for msg in messages)
+        mock_run.assert_called_once_with(
+            ["wmic", "process", "where", "(ParentProcessId=6789)", "delete"],
+            capture_output=True,
+            timeout=5,
+            check=False,
+        )
+
+    @pytest.mark.asyncio
+    async def test_execute_task_windows_child_cleanup_runs_before_success_stderr_drain(
+        self,
+    ) -> None:
+        text_event = json.dumps(
+            {
+                "type": "text",
+                "sessionID": "sess-windows-stderr-held",
+                "part": {"type": "text", "text": "Done"},
+            }
+        )
+        cleanup_started = asyncio.Event()
+        process = _FakeProcess(stdout_lines=[text_event], stderr_lines=[], returncode=0)
+        process.stderr = _WaitForCleanupStream(cleanup_started)
+        process.pid = 1357
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+
+        def cleanup_children(*_args: object, **_kwargs: object) -> None:
+            cleanup_started.set()
+
+        with (
+            patch("asyncio.create_subprocess_exec", return_value=process),
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(opencode_runtime_module.subprocess, "run", side_effect=cleanup_children),
+        ):
+            messages = await asyncio.wait_for(
+                _collect_async(runtime.execute_task("Hello")),
+                timeout=1,
+            )
+
+        assert cleanup_started.is_set()
+        assert any(msg.type == "result" for msg in messages)
+
+    @pytest.mark.asyncio
+    async def test_execute_task_windows_cleanup_failure_does_not_block_on_stderr(
+        self,
+    ) -> None:
+        text_event = json.dumps(
+            {
+                "type": "text",
+                "sessionID": "sess-windows-stderr-cleanup-fails",
+                "part": {"type": "text", "text": "Done"},
+            }
+        )
+        cleanup_started = asyncio.Event()
+        process = _FakeProcess(stdout_lines=[text_event], stderr_lines=[], returncode=0)
+        process.stderr = _WaitForCleanupStream(cleanup_started)
+        process.pid = 9753
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+
+        def cleanup_children(*_args: object, **_kwargs: object) -> None:
+            cleanup_started.set()
+            raise TimeoutError("wmic hung")
+
+        with (
+            patch("asyncio.create_subprocess_exec", return_value=process),
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(opencode_runtime_module.subprocess, "run", side_effect=cleanup_children),
+            patch.object(opencode_runtime_module.log, "warning") as mock_warning,
+        ):
+            messages = await asyncio.wait_for(
+                _collect_async(runtime.execute_task("Hello")),
+                timeout=1,
+            )
+
+        assert cleanup_started.is_set()
+        assert any(msg.type == "result" for msg in messages)
+        assert mock_warning.call_args.args[0] == "opencode_runtime.windows_child_cleanup_failed"
+
+    @pytest.mark.asyncio
+    async def test_execute_task_windows_cleanup_nonzero_exit_does_not_block_on_stderr(
+        self,
+    ) -> None:
+        text_event = json.dumps(
+            {
+                "type": "text",
+                "sessionID": "sess-windows-stderr-cleanup-nonzero",
+                "part": {"type": "text", "text": "Done"},
+            }
+        )
+        cleanup_started = asyncio.Event()
+        process = _FakeProcess(stdout_lines=[text_event], stderr_lines=[], returncode=0)
+        process.stderr = _WaitForCleanupStream(cleanup_started)
+        process.pid = 8642
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+
+        def cleanup_children(*_args: object, **_kwargs: object) -> SimpleNamespace:
+            cleanup_started.set()
+            return SimpleNamespace(returncode=1)
+
+        with (
+            patch("asyncio.create_subprocess_exec", return_value=process),
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(opencode_runtime_module.subprocess, "run", side_effect=cleanup_children),
+            patch.object(opencode_runtime_module.log, "warning") as mock_warning,
+        ):
+            messages = await asyncio.wait_for(
+                _collect_async(runtime.execute_task("Hello")),
+                timeout=1,
+            )
+
+        assert cleanup_started.is_set()
+        assert any(msg.type == "result" for msg in messages)
+        assert mock_warning.call_args.args[0] == "opencode_runtime.windows_child_cleanup_failed"
+        assert mock_warning.call_args.kwargs["returncode"] == 1
+
+    @pytest.mark.asyncio
+    async def test_execute_task_windows_child_cleanup_runs_after_aclose_termination(
+        self,
+    ) -> None:
+        text_event = json.dumps(
+            {
+                "type": "text",
+                "sessionID": "sess-windows-aclose",
+                "part": {"type": "text", "text": "Partial"},
+            }
+        )
+        process = _FakeProcess(stdout_lines=[text_event], stderr_lines=[], returncode=0)
+        process.pid = 2468
+        runtime = OpenCodeRuntime(cli_path="opencode", cwd="/tmp")
+        call_order: list[str] = []
+
+        async def terminate_process(proc: _FakeProcess) -> None:
+            call_order.append("terminate")
+            proc.terminate()
+
+        def cleanup_children(*_args: object, **_kwargs: object) -> None:
+            call_order.append("cleanup")
+
+        with (
+            patch("asyncio.create_subprocess_exec", return_value=process),
+            patch.object(opencode_runtime_module.os, "name", "nt"),
+            patch.object(runtime, "_terminate_process", side_effect=terminate_process),
+            patch.object(opencode_runtime_module.subprocess, "run", side_effect=cleanup_children),
+        ):
+            stream = runtime.execute_task("Hello")
+            first_message = await stream.__anext__()
+            await stream.aclose()
+
+        assert first_message.type == "assistant"
+        assert process.terminated
+        assert call_order == ["terminate", "cleanup"]
+
     @pytest.mark.asyncio
     async def test_execute_task_with_session_tracking(self) -> None:
         """Session ID from events is captured into the runtime handle."""