code-coordinator 0.5.566__tar.gz → 0.5.568__tar.gz

{code_coordinator-0.5.566 → code_coordinator-0.5.568}/.github/workflows/test.yml

@@ -19,6 +19,8 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: pyproject.toml
       - run: pip install -e ".[dev]"
       # #2180: `--ignore=tests/acceptance` — the sealed oracle-loop suite
       # (tests/acceptance/ms-NN/) is split out of the ordinary suite and
@@ -32,7 +34,24 @@ jobs:
       # never swept in here; ms-37 (plain .py files under
       # testpaths=["tests"]) was the one accidental gap. (ms-51 — Playwright,
       # never .py either — left this repo entirely with the webapp, #2009.)
-      - run: pytest --ignore=tests/acceptance
+      #
+      # #3537: `-n auto`, no explicit `--dist`, matches
+      # `scripts/coord-test-runner.sh`'s `run_python()` exactly (same
+      # `import xdist` gate, same bare `-n auto` — pytest-xdist's default
+      # `--dist=load`) so CI and the fleet's own Test stage answer "does this
+      # suite pass" through the same invocation shape rather than two
+      # independently-maintained ones that could silently disagree (one
+      # question, one answer). pytest-xdist is already a `[dev]` extra
+      # (pyproject.toml), installed by the `pip install` above — no new
+      # dependency. There is no predetermined "must run serial" test set in
+      # this repo today (checked: no xdist-unsafe markers, no `-p no:xdist`
+      # anywhere) — `tests/backends.py` already shards its schema names by
+      # `PYTEST_XDIST_WORKER` precisely so the whole suite is safe under
+      # `-n auto`, so there is nothing to split into a separate serial step.
+      # If a future test needs to be serial-only, give it the same
+      # `@pytest.mark.posix_only`-style registered marker and exclude it
+      # here AND in `coord-test-runner.sh` together, not just one of them.
+      - run: pytest -n auto --ignore=tests/acceptance
       # #2899: the `COORD_TUI_SRC=. python scripts/codegen.py --rust --check`
       # step that used to live here is GONE. It was #2897's explicit stand-in
       # for the byte-comparison, held here only for as long as the crate did

{code_coordinator-0.5.566 → code_coordinator-0.5.568}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.566
+Version: 0.5.568
 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.566 → code_coordinator-0.5.568}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.566
+Version: 0.5.568
 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.566 → code_coordinator-0.5.568}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.566",
+  "tag": "0.5.568",
   "distance": 0,
-  "node": "g17554137715ba9508260794b6ffb9ccdd0cd3906",
+  "node": "ga29606616d9c2f7c7cb18d7b03d067f043ccbc97",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-02"

{code_coordinator-0.5.566 → code_coordinator-0.5.568}/coord/win_native_driver.py

@@ -814,7 +814,18 @@ class Win32Calls:
         desktop exists to open at all), ``WTSGetActiveConsoleSessionId``
         reports a real console session, and no ``LogonUI.exe`` is running
         in that session (the lock-screen host process). Any one of these
-        failing means the host's desktop is locked or absent."""
+        failing means the host's desktop is locked or absent.
+
+        Defensive by design: this gates every ``win-native`` run (#3510), so
+        a probe that raises (e.g. a lookup error on a function that doesn't
+        live where expected — #3521) must report "unavailable, here's why"
+        rather than take the whole lane down with an uncaught exception."""
+        try:
+            return self._session_available_unchecked()
+        except Exception as exc:  # noqa: BLE001 - must never crash the lane
+            return False, f"session_available probe failed: {exc}"
+
+    def _session_available_unchecked(self) -> tuple[bool, str]:
         ctypes = self._ctypes
         DESKTOP_READOBJECTS = 0x0001
         hdesk = self._user32.OpenInputDesktop(0, False, DESKTOP_READOBJECTS)
@@ -825,9 +836,12 @@ class Win32Calls:
             )
         self._user32.CloseDesktop(hdesk)
 
-        wtsapi32 = ctypes.windll.wtsapi32
+        # WTSGetActiveConsoleSessionId is exported by kernel32, not
+        # wtsapi32 (#3521) — it's the one WTS* function that lives there;
+        # the rest of the WTS family (WTSQuerySessionInformation etc.) is
+        # genuinely in wtsapi32, which is the likely source of the mix-up.
         INVALID_SESSION_ID = 0xFFFFFFFF
-        session_id = wtsapi32.WTSGetActiveConsoleSessionId()
+        session_id = self._kernel32.WTSGetActiveConsoleSessionId()
         if session_id == INVALID_SESSION_ID:
             return False, (
                 "WTSGetActiveConsoleSessionId reports no active console "

{code_coordinator-0.5.566 → code_coordinator-0.5.568}/scripts/coord-test-runner.sh

@@ -964,6 +964,18 @@ run_python() {
     # 5m49s → 1m36s on a 4642-test suite, identical results). Detected rather
     # than assumed, because the venv is built from the branch under test and
     # any branch predating the dev-dep would die on an unknown -n flag.
+    #
+    # #3537: `.github/workflows/test.yml`'s `test` job runs the exact same
+    # `pytest -n auto --ignore=tests/acceptance` shape (no explicit --dist,
+    # so both land on pytest-xdist's default `--dist=load`) — one question
+    # ("does the suite pass under xdist"), one answer, rather than CI and
+    # the fleet's Test stage silently drifting into two invocations that
+    # could disagree. There is no serial-only test subset in this repo
+    # (checked at authoring time: no xdist-unsafe markers, no `-p no:xdist`
+    # anywhere, and `tests/backends.py` already shards schema names by
+    # `PYTEST_XDIST_WORKER` so the whole suite is xdist-safe) — if one is
+    # ever introduced, exclude it from BOTH this invocation and
+    # `test.yml`'s together, not just one of them.
     local par=()
     if "$venv/bin/python" -c "import xdist" 2>/dev/null; then
         par=(-n auto)

{code_coordinator-0.5.566 → code_coordinator-0.5.568}/tests/test_win_native_driver.py

@@ -14,6 +14,7 @@ here) and is exercised at the operator level instead — the same split
 from __future__ import annotations
 
 import base64
+import ctypes
 import os
 import time
 
@@ -797,6 +798,153 @@ class TestWin32CallsPlatformGuard:
             Win32Calls()
 
 
+class _FakeUser32:
+    """``OpenInputDesktop``/``CloseDesktop`` stand-in — desktop unlocked."""
+
+    def OpenInputDesktop(self, *_args, **_kwargs):
+        return 0x1234  # truthy handle
+
+    def CloseDesktop(self, _hdesk) -> None:
+        pass
+
+
+class _ProcessEntry32Mirror(ctypes.Structure):
+    """Field-for-field mirror of the ``PROCESSENTRY32`` defined inline in
+    :meth:`Win32Calls._logonui_running_in_session` — not the same Python
+    class, but same layout, so ``ctypes.cast`` on the ``byref`` pointer the
+    real method passes in reads/writes the same memory the fakes below
+    populate."""
+
+    _fields_ = [
+        ("dwSize", ctypes.c_uint32), ("cntUsage", ctypes.c_uint32),
+        ("th32ProcessID", ctypes.c_uint32),
+        ("th32DefaultHeapID", ctypes.c_void_p),
+        ("th32ModuleID", ctypes.c_uint32), ("cntThreads", ctypes.c_uint32),
+        ("th32ParentProcessID", ctypes.c_uint32),
+        ("pcPriClassBase", ctypes.c_long), ("dwFlags", ctypes.c_uint32),
+        ("szExeFile", ctypes.c_char * 260),
+    ]
+
+
+class _FakeKernel32NoSession:
+    """Mimics the *real* kernel32 (#3521): ``WTSGetActiveConsoleSessionId``
+    is present and callable here — unlike the old, wrong ``wtsapi32``
+    lookup, which would raise ``AttributeError`` on real Windows."""
+
+    exe_name = b"explorer.exe"
+
+    def __init__(self, session_id: int = 1) -> None:
+        self._session_id = session_id
+
+    def WTSGetActiveConsoleSessionId(self) -> int:
+        return self._session_id
+
+    def CreateToolhelp32Snapshot(self, *_args, **_kwargs):
+        return 1  # non-zero, non -1 "handle"
+
+    def Process32First(self, _snapshot, entry_ref) -> bool:
+        entry = ctypes.cast(entry_ref, ctypes.POINTER(_ProcessEntry32Mirror)).contents
+        entry.szExeFile = self.exe_name
+        return True
+
+    def Process32Next(self, _snapshot, _entry_ref) -> bool:
+        return False  # only the one process — no LogonUI.exe
+
+    def ProcessIdToSessionId(self, _pid, session_ref) -> bool:
+        session_ref._obj.value = self._session_id
+        return True
+
+    def CloseHandle(self, _handle) -> None:
+        pass
+
+
+def _ensure_mbcs_codec_available() -> None:
+    """``_logonui_running_in_session`` decodes ``szExeFile`` with Windows'
+    ``mbcs`` codec, which only exists on real Windows. Register an
+    ascii-compatible alias off-Windows so these tests can exercise that
+    real decode path (all the fake exe names here are ASCII) instead of
+    mocking around it — a no-op if ``mbcs`` is already natively available."""
+    import codecs
+
+    try:
+        codecs.lookup("mbcs")
+    except LookupError:
+        codecs.register(lambda name: codecs.lookup("ascii") if name == "mbcs" else None)
+
+
+def _make_win32_calls(user32, kernel32) -> Win32Calls:
+    """Build a :class:`Win32Calls` bypassing ``__init__``'s platform guard
+    (construction requires real Windows) with real ``ctypes``/``ctypes.
+    wintypes`` — both work fine off-Windows — but faked ``user32``/
+    ``kernel32`` handles, exactly mirroring what ``__init__`` would have
+    set on a real Windows host."""
+    import ctypes.wintypes  # noqa: F401 - imported for side effect, used by the class
+
+    _ensure_mbcs_codec_available()
+    calls = object.__new__(Win32Calls)
+    calls._ctypes = ctypes
+    calls._user32 = user32
+    calls._kernel32 = kernel32
+    return calls
+
+
+class TestSessionAvailable:
+    """#3521: ``WTSGetActiveConsoleSessionId`` lives on kernel32, not
+    wtsapi32 — the old code crashed every win-native run with an
+    uncaught ``AttributeError`` before this fix. These tests fake
+    ``Win32Calls`` so the wtsapi32-shaped mistake would raise if
+    reintroduced, and confirm the probe is defensive end to end."""
+
+    def test_uses_kernel32_and_reports_available_when_unlocked(self) -> None:
+        calls = _make_win32_calls(_FakeUser32(), _FakeKernel32NoSession())
+        available, reason = calls.session_available()
+        assert available is True
+        assert reason == ""
+
+    def test_a_raising_probe_yields_unavailable_with_reason_not_an_exception(
+        self,
+    ) -> None:
+        class _ExplodingUser32:
+            def OpenInputDesktop(self, *_args, **_kwargs):
+                raise AttributeError(
+                    "function 'WTSGetActiveConsoleSessionId' not found"
+                )
+
+        calls = _make_win32_calls(_ExplodingUser32(), _FakeKernel32NoSession())
+        available, reason = calls.session_available()
+        assert available is False
+        assert "failed" in reason.lower()
+        assert "WTSGetActiveConsoleSessionId" in reason
+
+    def test_invalid_session_id_reports_unavailable(self) -> None:
+        INVALID_SESSION_ID = 0xFFFFFFFF
+        calls = _make_win32_calls(
+            _FakeUser32(), _FakeKernel32NoSession(session_id=INVALID_SESSION_ID),
+        )
+        available, reason = calls.session_available()
+        assert available is False
+        assert "no active console session" in reason
+
+    def test_logonui_running_reports_locked(self) -> None:
+        class _FakeKernel32Locked(_FakeKernel32NoSession):
+            exe_name = b"LogonUI.exe"
+
+        calls = _make_win32_calls(_FakeUser32(), _FakeKernel32Locked())
+        available, reason = calls.session_available()
+        assert available is False
+        assert "LogonUI.exe" in reason
+
+    def test_open_input_desktop_failure_reports_unavailable(self) -> None:
+        class _FakeUser32Locked:
+            def OpenInputDesktop(self, *_args, **_kwargs):
+                return 0  # falsy handle — no interactive desktop
+
+        calls = _make_win32_calls(_FakeUser32Locked(), _FakeKernel32NoSession())
+        available, reason = calls.session_available()
+        assert available is False
+        assert "OpenInputDesktop" in reason
+
+
 class TestImportUia:
     def test_missing_comtypes_raises_actionable_error(self, monkeypatch) -> None:
         import builtins