code-coordinator 0.5.585__tar.gz → 0.5.586__tar.gz

{code_coordinator-0.5.585 → code_coordinator-0.5.586}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.585",
+  "tag": "0.5.586",
   "distance": 0,
-  "node": "g6570ba34fa9c63377f21997b6b8a6170f499b760",
+  "node": "g0116991dbca373e8070feb4ac61ffb9d26cfe533",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.585 → code_coordinator-0.5.586}/coord/prereqs.py

@@ -380,9 +380,15 @@ def _probe_comtypes(prereq: Prereq, timeout: float) -> ToolProbe:
     bootstraps instead (`import comtypes` run on THAT interpreter via a
     direct subprocess call, never the bootstrap itself — a probe must not
     have the side effect of installing something on every `/health` poll).
-    A missing Windows-side venv (never bootstrapped, or `python.exe`
-    unreachable through interop) degrades to `found=False`, the same honest
-    "not met yet" every other prereq in this module reports, never a crash.
+    `windows_venv_python` returns a Windows-path-shaped executable
+    (`C:\\...`), which Linux's own `exec` can never resolve directly, so the
+    `argv[0]` is translated WSL-ward through
+    `coord.win_native_bridge._windows_exec_argv` first (#3519's fix,
+    originally missed here — #3550) before the subprocess call. A missing
+    Windows-side venv (never bootstrapped, `python.exe` unreachable through
+    interop, or the `wslpath` translation itself failing) degrades to
+    `found=False`, the same honest "not met yet" every other prereq in this
+    module reports, never a crash.
 
     Everywhere else (native Windows, or a test harness with no `windows`
     capability in play at all) this is exactly
@@ -390,6 +396,8 @@ def _probe_comtypes(prereq: Prereq, timeout: float) -> ToolProbe:
     """
     from coord.win_native_bridge import (  # noqa: PLC0415 — avoid an import cycle
         DEFAULT_WINDOWS_VENV_DIR,
+        WinNativeBridgeError,
+        _windows_exec_argv,
         is_wsl_host,
         windows_venv_python,
     )
@@ -399,12 +407,21 @@ def _probe_comtypes(prereq: Prereq, timeout: float) -> ToolProbe:
 
     venv_python = windows_venv_python(DEFAULT_WINDOWS_VENV_DIR)
     try:
+        # `venv_python` is Windows-path-shaped (`C:\...`) — Linux `exec`
+        # can't resolve that directly, so translate `argv[0]` WSL-ward
+        # first (#3519's fix, missed here originally — #3550). A
+        # translation failure (e.g. `wslpath` missing) degrades to
+        # `found=False` exactly like the OSError/TimeoutExpired cases
+        # below, never a crash.
+        exec_argv = _windows_exec_argv(
+            [venv_python, "-c", "import comtypes"], run=subprocess.run,
+        )
         result = subprocess.run(
-            [venv_python, "-c", "import comtypes"],
+            exec_argv,
             capture_output=True, text=True, timeout=timeout,
         )
         found = result.returncode == 0
-    except (OSError, subprocess.TimeoutExpired):
+    except (OSError, subprocess.TimeoutExpired, WinNativeBridgeError):
         found = False
     return ToolProbe(
         tool=prereq.tool, capability=prereq.capability, found=found,

{code_coordinator-0.5.585 → code_coordinator-0.5.586}/tests/test_prereqs.py

@@ -782,44 +782,99 @@ class TestLaneDriverDependencyPrereqs:
         import in THIS process no matter what's installed — the probe must
         check the real Windows-side bridge venv
         (`coord.win_native_bridge.ensure_windows_win_native_venv` bootstraps)
-        instead of this interpreter's own `find_spec`."""
+        instead of this interpreter's own `find_spec`.
+
+        #3550: the bridge venv's `python.exe` is Windows-path-shaped
+        (`C:\\...`) — Linux `exec` can't resolve that directly, so the
+        probe must translate `argv[0]` WSL-ward (`wslpath -u`, via
+        `_windows_exec_argv`) before actually exec'ing it. The scripted
+        `run` below answers the `wslpath` call and the real exec call
+        differently, so this also asserts the exec'd path is the
+        `/mnt/c/...` form, never the raw `C:\\...` one."""
         import coord.win_native_bridge as win_native_bridge
 
         comtypes_prereq = next(
             p for p in prereqs.CAPABILITY_PREREQS if p.tool == "comtypes"
         )
+        windows_python = win_native_bridge.windows_venv_python(
+            win_native_bridge.DEFAULT_WINDOWS_VENV_DIR
+        )
+        wsl_python = "/mnt/c/ProgramData/coord-win-native-venv/Scripts/python.exe"
+
+        def fake_run(argv: list[str], **_kwargs: object) -> MagicMock:
+            if argv[0] == "wslpath":
+                assert argv == ["wslpath", "-u", windows_python]
+                return MagicMock(returncode=0, stdout=f"{wsl_python}\n", stderr="")
+            return MagicMock(returncode=0, stdout="", stderr="")
+
         with (
             patch.object(win_native_bridge, "is_wsl_host", return_value=True),
             patch(
-                "coord.prereqs.subprocess.run",
-                return_value=MagicMock(returncode=0),
+                "coord.prereqs.subprocess.run", side_effect=fake_run,
             ) as mock_run,
         ):
             probe = comtypes_prereq.custom_probe(comtypes_prereq, 5.0)
         assert probe.found is True
         assert probe.ok is True
-        # Checks the BRIDGE venv's python, never this process's own.
-        argv = mock_run.call_args[0][0]
-        assert argv[0] == win_native_bridge.windows_venv_python(
-            win_native_bridge.DEFAULT_WINDOWS_VENV_DIR
-        )
+        # The actual exec call (the last one) used the WSL-translated path,
+        # never the raw Windows-path-shaped one.
+        exec_argv = mock_run.call_args_list[-1][0][0]
+        assert exec_argv[0] == wsl_python
+        assert exec_argv[0] != windows_python
 
     def test_comtypes_probe_on_wsl_is_unmet_when_bridge_venv_missing(self) -> None:
+        """Translation succeeds (the host's `wslpath` works fine), but the
+        bridge venv itself was never bootstrapped — the real exec of the
+        translated path is what fails here, same `found=False` degrade as
+        every other prereq miss."""
+        import coord.win_native_bridge as win_native_bridge
+
+        comtypes_prereq = next(
+            p for p in prereqs.CAPABILITY_PREREQS if p.tool == "comtypes"
+        )
+
+        def fake_run(argv: list[str], **_kwargs: object) -> MagicMock:
+            if argv[0] == "wslpath":
+                return MagicMock(
+                    returncode=0,
+                    stdout="/mnt/c/ProgramData/coord-win-native-venv/Scripts/python.exe\n",
+                    stderr="",
+                )
+            raise FileNotFoundError("no such venv")
+
+        with (
+            patch.object(win_native_bridge, "is_wsl_host", return_value=True),
+            patch("coord.prereqs.subprocess.run", side_effect=fake_run),
+        ):
+            probe = comtypes_prereq.custom_probe(comtypes_prereq, 5.0)
+        assert probe.found is False
+        assert probe.ok is False
+
+    def test_comtypes_probe_wsl_path_translation_failure_is_unmet(self) -> None:
+        """#3550 regression: if `wslpath` itself isn't runnable (missing,
+        times out, or exits non-zero), `_windows_exec_argv` raises
+        `WinNativeBridgeError` — the probe must degrade that to
+        `found=False` exactly like an `OSError`/`TimeoutExpired`, never let
+        it bubble up and take down the whole `/health` sweep. The real
+        exec must never even be attempted once translation fails."""
         import coord.win_native_bridge as win_native_bridge
 
         comtypes_prereq = next(
             p for p in prereqs.CAPABILITY_PREREQS if p.tool == "comtypes"
         )
+
         with (
             patch.object(win_native_bridge, "is_wsl_host", return_value=True),
             patch(
                 "coord.prereqs.subprocess.run",
-                side_effect=FileNotFoundError("no such venv"),
-            ),
+                side_effect=FileNotFoundError("wslpath: command not found"),
+            ) as mock_run,
         ):
             probe = comtypes_prereq.custom_probe(comtypes_prereq, 5.0)
         assert probe.found is False
         assert probe.ok is False
+        # Never got past the (failed) translation to attempt the real exec.
+        assert mock_run.call_count == 1
 
     def test_comtypes_probe_on_non_wsl_falls_back_to_find_spec(self) -> None:
         """Native Windows (or any non-WSL host, including every other test