code-coordinator 0.5.570__tar.gz → 0.5.571__tar.gz

{code_coordinator-0.5.570 → code_coordinator-0.5.571}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.570
+Version: 0.5.571
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.570 → code_coordinator-0.5.571}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.570
+Version: 0.5.571
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.570 → code_coordinator-0.5.571}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.570",
+  "tag": "0.5.571",
   "distance": 0,
-  "node": "g29bd794d5c1bbedb62f22cdd0bef36e1a1cddd33",
+  "node": "g0b8e275348da7bd146b160ece1e4c28c9c8274da",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.570 → code_coordinator-0.5.571}/coord/win_native_driver.py

@@ -370,11 +370,18 @@ class WinCalls(Protocol):
     def launch_in_terminal(self, command: str, cwd: str, terminal_app: str) -> int: ...
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
-        """Poll for the launched process's real top-level window, returning
-        its handle once found. Raises :class:`WinNativeRuntimeError` if none
-        appears within *timeout_s* — this is the "launch" step's own
-        confirmation that the process didn't just start, but actually
-        produced a window (#2096)."""
+        """Poll for *pid*'s (or one of its descendant processes') real
+        top-level window, returning its handle once found. Raises
+        :class:`WinNativeRuntimeError` if none appears within *timeout_s* —
+        this is the "launch" step's own confirmation that the process
+        didn't just start, but actually produced a window (#2096).
+
+        *pid* is not always the real app's own pid: ``subprocess.Popen(...,
+        shell=True)`` on Windows spawns ``cmd.exe`` as the immediate child
+        and returns *its* pid, while the real app (e.g. ``vimcode.exe``) is
+        a grandchild with a different pid that ``cmd.exe`` itself never
+        owns a window for (#3542). Implementations must search *pid*'s
+        whole descendant-process tree, not just *pid* itself."""
         ...
 
     def move_window(self, hwnd: int, x: int, y: int, width: int, height: int) -> None: ...
@@ -857,12 +864,28 @@ class Win32Calls:
 
     def _logonui_running_in_session(self, session_id: int) -> bool:
         """``True`` iff ``LogonUI.exe`` (the Windows lock-screen host
-        process) is running in *session_id* — walked via a
-        ``CreateToolhelp32Snapshot`` process snapshot, the same mechanism
-        Task Manager itself uses, rather than anything that could be
-        confused by a differently-named process (the module docstring's
-        "kill only the PID this driver itself launched" safety note applies
-        equally here: this is read-only enumeration, never a kill)."""
+        process) is running in *session_id* — walked via
+        :meth:`_snapshot_processes`, the same mechanism Task Manager itself
+        uses, rather than anything that could be confused by a differently-
+        named process (the module docstring's "kill only the PID this
+        driver itself launched" safety note applies equally here: this is
+        read-only enumeration, never a kill)."""
+        ctypes = self._ctypes
+        for pid, _ppid, name in self._snapshot_processes():
+            if name.lower() == "logonui.exe":
+                proc_session = ctypes.wintypes.DWORD()
+                self._kernel32.ProcessIdToSessionId(pid, ctypes.byref(proc_session))
+                if proc_session.value == session_id:
+                    return True
+        return False
+
+    def _snapshot_processes(self) -> list[tuple[int, int, str]]:
+        """Every currently running process as ``(pid, parent_pid,
+        exe_name)``, via a single ``CreateToolhelp32Snapshot`` walk — the
+        same mechanism Task Manager itself uses. Read-only enumeration,
+        shared by :meth:`_logonui_running_in_session` (#3510) and
+        :meth:`_descendant_pids` (#3542); never used to kill (see the
+        module docstring's safety note)."""
         ctypes = self._ctypes
         kernel32 = self._kernel32
         TH32CS_SNAPPROCESS = 0x00000002
@@ -880,48 +903,81 @@ class Win32Calls:
 
         snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
         if not snapshot or snapshot == -1:
-            return False
+            return []
+        out: list[tuple[int, int, str]] = []
         try:
             entry = PROCESSENTRY32()
             entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
             if not kernel32.Process32First(snapshot, ctypes.byref(entry)):
-                return False
+                return []
             while True:
                 name = entry.szExeFile.decode("mbcs", errors="ignore")
-                if name.lower() == "logonui.exe":
-                    proc_session = ctypes.wintypes.DWORD()
-                    kernel32.ProcessIdToSessionId(
-                        entry.th32ProcessID, ctypes.byref(proc_session),
-                    )
-                    if proc_session.value == session_id:
-                        return True
+                out.append((entry.th32ProcessID, entry.th32ParentProcessID, name))
                 if not kernel32.Process32Next(snapshot, ctypes.byref(entry)):
-                    return False
+                    break
         finally:
             kernel32.CloseHandle(snapshot)
+        return out
+
+    def _descendant_pids(self, root_pid: int) -> set[int]:
+        """*root_pid* plus every process it transitively spawned (child,
+        grandchild, ...) — a fresh :meth:`_snapshot_processes` walk each
+        call, since the real app may not have started yet the first time
+        this is polled.
+
+        #3542: ``launch``/``launch_in_terminal`` don't always return the
+        real app's own pid — ``subprocess.Popen(..., shell=True)`` returns
+        ``cmd.exe``'s pid, with the real app (``vimcode.exe``) a grandchild
+        that ``cmd.exe`` itself never owns a window for. Searching the
+        whole descendant tree finds the real app's window regardless of
+        how many shell/console hosts sit between the returned pid and it.
+        """
+        children: dict[int, list[int]] = {}
+        for pid, ppid, _name in self._snapshot_processes():
+            children.setdefault(ppid, []).append(pid)
+        result = {root_pid}
+        frontier = [root_pid]
+        while frontier:
+            current = frontier.pop()
+            for child in children.get(current, ()):
+                if child not in result:
+                    result.add(child)
+                    frontier.append(child)
+        return result
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
         ctypes = self._ctypes
         deadline = time.monotonic() + timeout_s
         found: list[int] = []
-
-        @ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+        candidate_pids: set[int] = {pid}
+        # `WINFUNCTYPE` (stdcall) only exists in ctypes on real Windows —
+        # real runs always go through it (Win32Calls.__init__ guards
+        # off-Windows construction), but falling back to `CFUNCTYPE` off-
+        # Windows is what lets this method's descendant-walk logic be
+        # exercised by a scripted fake on Linux/macOS too (#3542), the same
+        # "unit-testable on any platform" seam the module docstring
+        # describes for the rest of this class.
+        win_functype = getattr(ctypes, "WINFUNCTYPE", ctypes.CFUNCTYPE)
+
+        @win_functype(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
         def _enum_proc(hwnd, _lparam):
             owner_pid = ctypes.wintypes.DWORD()
             self._user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
-            if owner_pid.value == pid and self._user32.IsWindowVisible(hwnd):
+            if owner_pid.value in candidate_pids and self._user32.IsWindowVisible(hwnd):
                 found.append(hwnd)
                 return False
             return True
 
         while time.monotonic() < deadline:
+            candidate_pids = self._descendant_pids(pid)
             found.clear()
             self._user32.EnumWindows(_enum_proc, 0)
             if found:
                 return found[0]
             time.sleep(0.1)
         raise WinNativeRuntimeError(
-            f"no visible top-level window appeared for pid={pid} within {timeout_s}s"
+            f"no visible top-level window appeared for pid={pid} or any of "
+            f"its child processes within {timeout_s}s"
         )
 
     def is_window_alive(self, hwnd: int) -> bool:

{code_coordinator-0.5.570 → code_coordinator-0.5.571}/tests/test_win_native_driver.py

@@ -888,6 +888,162 @@ def _make_win32_calls(user32, kernel32) -> Win32Calls:
     return calls
 
 
+class _FakeKernel32ProcessTree:
+    """``CreateToolhelp32Snapshot``/``Process32First``/``Process32Next``
+    stand-in that replays a scripted list of ``(pid, parent_pid,
+    exe_name)`` rows — enough for :meth:`Win32Calls._snapshot_processes`
+    and :meth:`Win32Calls._descendant_pids` (#3542) to walk a fake process
+    tree exactly the way they'd walk a real one."""
+
+    def __init__(self, processes: list[tuple[int, int, bytes]]) -> None:
+        self._processes = processes
+        self._iter = iter(())
+
+    def CreateToolhelp32Snapshot(self, *_args, **_kwargs):
+        return 1  # non-zero, non -1 "handle"
+
+    def Process32First(self, _snapshot, entry_ref) -> bool:
+        self._iter = iter(self._processes)
+        return self._advance(entry_ref)
+
+    def Process32Next(self, _snapshot, entry_ref) -> bool:
+        return self._advance(entry_ref)
+
+    def _advance(self, entry_ref) -> bool:
+        try:
+            pid, ppid, name = next(self._iter)
+        except StopIteration:
+            return False
+        entry = ctypes.cast(entry_ref, ctypes.POINTER(_ProcessEntry32Mirror)).contents
+        entry.th32ProcessID = pid
+        entry.th32ParentProcessID = ppid
+        entry.szExeFile = name
+        return True
+
+    def CloseHandle(self, _handle) -> None:
+        pass
+
+
+class _FakeUser32Windows:
+    """``EnumWindows``/``GetWindowThreadProcessId``/``IsWindowVisible``
+    stand-in: *windows* maps a fake ``hwnd`` to ``(owner_pid, visible)``.
+    ``EnumWindows`` replays them in insertion order and stops as soon as
+    the real callback returns ``False`` (a match), exactly like the real
+    Win32 ``EnumWindows`` short-circuiting on its callback's return value.
+    """
+
+    def __init__(self, windows: dict[int, tuple[int, bool]]) -> None:
+        self._windows = windows
+
+    def EnumWindows(self, callback, lparam) -> None:
+        for hwnd, (_owner_pid, _visible) in self._windows.items():
+            if not callback(hwnd, lparam):
+                break
+
+    def GetWindowThreadProcessId(self, hwnd, owner_pid_ref) -> None:
+        owner_pid_ref._obj.value = self._windows[hwnd][0]
+
+    def IsWindowVisible(self, hwnd) -> bool:
+        return self._windows[hwnd][1]
+
+
+class TestFindTopWindowFollowsDescendantProcesses:
+    """#3542: ``Win32Calls.launch()`` is ``subprocess.Popen(command,
+    shell=True)``, which on Windows always spawns ``cmd.exe`` as the
+    immediate child and returns *its* pid — the real GUI app
+    (``vimcode.exe``) is a grandchild with a different pid, and ``cmd.exe``
+    itself never owns a window. These tests reproduce that exact shape with
+    a fake process tree + fake window table and confirm
+    ``find_top_window`` now searches the whole descendant tree rather than
+    matching the returned pid alone."""
+
+    def test_follows_shell_wrapped_launch_to_the_real_apps_window(self) -> None:
+        cmd_pid, vimcode_pid = 4242, 4321
+        kernel32 = _FakeKernel32ProcessTree([
+            (1, 0, b"System"),
+            (cmd_pid, 1, b"cmd.exe"),
+            (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        # cmd.exe (cmd_pid) owns no window at all — only its child does.
+        user32 = _FakeUser32Windows({777: (vimcode_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(cmd_pid, timeout_s=1.0) == 777
+
+    def test_follows_a_grandchild_process_two_levels_deep(self) -> None:
+        wt_pid, conhost_pid, app_pid = 10, 20, 30
+        kernel32 = _FakeKernel32ProcessTree([
+            (wt_pid, 1, b"wt.exe"),
+            (conhost_pid, wt_pid, b"OpenConsole.exe"),
+            (app_pid, conhost_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({99: (app_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(wt_pid, timeout_s=1.0) == 99
+
+    def test_still_matches_when_the_launched_pid_owns_the_window_directly(
+        self,
+    ) -> None:
+        """Backward-compatible: an exe launched without an intervening
+        shell still has its own pid in its own descendant set (the root is
+        always included), so the pre-#3542 direct-match case keeps
+        working."""
+        pid = 555
+        kernel32 = _FakeKernel32ProcessTree([(pid, 1, b"vimcode.exe")])
+        user32 = _FakeUser32Windows({1: (pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(pid, timeout_s=1.0) == 1
+
+    def test_ignores_invisible_windows_even_on_a_matching_descendant(
+        self,
+    ) -> None:
+        cmd_pid, vimcode_pid = 1, 2
+        kernel32 = _FakeKernel32ProcessTree([
+            (cmd_pid, 0, b"cmd.exe"), (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({9: (vimcode_pid, False)})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError, match="no visible top-level window"):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+    def test_raises_when_no_descendant_owns_any_window(self) -> None:
+        cmd_pid = 1
+        kernel32 = _FakeKernel32ProcessTree([(cmd_pid, 0, b"cmd.exe")])
+        user32 = _FakeUser32Windows({})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError, match=f"pid={cmd_pid}"):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+    def test_unrelated_processes_window_is_not_matched(self) -> None:
+        """A visible window owned by some other, unrelated process must
+        never be treated as a match just because it exists."""
+        cmd_pid, vimcode_pid, unrelated_pid = 1, 2, 999
+        kernel32 = _FakeKernel32ProcessTree([
+            (cmd_pid, 0, b"cmd.exe"), (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({8: (unrelated_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+
+class TestDescendantPids:
+    def test_includes_root_and_all_transitive_children(self) -> None:
+        kernel32 = _FakeKernel32ProcessTree([
+            (1, 0, b"System"),
+            (10, 1, b"cmd.exe"),
+            (20, 10, b"vimcode.exe"),
+            (30, 20, b"helper.exe"),
+            (999, 1, b"unrelated.exe"),
+        ])
+        calls = _make_win32_calls(_FakeUser32Windows({}), kernel32)
+        assert calls._descendant_pids(10) == {10, 20, 30}
+
+    def test_pid_with_no_children_returns_itself_only(self) -> None:
+        kernel32 = _FakeKernel32ProcessTree([(10, 1, b"vimcode.exe")])
+        calls = _make_win32_calls(_FakeUser32Windows({}), kernel32)
+        assert calls._descendant_pids(10) == {10}
+
+
 class TestSessionAvailable:
     """#3521: ``WTSGetActiveConsoleSessionId`` lives on kernel32, not
     wtsapi32 — the old code crashed every win-native run with an