code-coordinator 0.5.302__tar.gz → 0.5.303__tar.gz

{code_coordinator-0.5.302 → code_coordinator-0.5.303}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.302",
+  "tag": "0.5.303",
   "distance": 0,
-  "node": "g4db839a79669e9ada2d3461267662cb4cefd6e52",
+  "node": "g0077891657f13dcf2fcd159e513b334616a0127b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-30"

{code_coordinator-0.5.302 → code_coordinator-0.5.303}/coord/prereqs.py

@@ -278,6 +278,102 @@ def _probe_playwright_browsers(prereq: Prereq, _timeout: float) -> ToolProbe:
     )
 
 
+# --- `windows` capability: the msvc cross-target lives per-toolchain (#2952) --
+#
+# dell64's Windows toolchain is a WSL-side cross-compile: `rustup target add
+# x86_64-pc-windows-msvc` plus `cargo install cargo-xwin` (for the MSVC
+# CRT/SDK cargo-xwin downloads and caches). `cargo-xwin` is an ordinary
+# binary probe, same shape as `cargo`/`opencode` below. The target is not —
+# `rustup target list --installed` is scoped to whichever toolchain is
+# *active*, and quadraui pins a specific one in `rust-toolchain.toml`
+# (`1.97.1` at the time of writing). Adding the target only to the default
+# toolchain leaves the pinned one without it, and a probe that only checked
+# the default would report MET while quadraui's own build still fails —
+# laundering an unbacked claim into a verified one, which is worse than no
+# probe at all. So this asserts the target against EVERY installed
+# toolchain and names the offending one in `what_breaks` when it's missing
+# from any of them.
+WINDOWS_MSVC_TARGET = "x86_64-pc-windows-msvc"
+
+
+def _rustup_toolchains(timeout: float) -> list[str]:
+    """Names of every installed rustup toolchain (`rustup toolchain list`).
+
+    Returns `[]` if `rustup` itself is missing or the call fails — the
+    caller treats that as "cannot confirm the target is installed" rather
+    than raising.
+    """
+    if shutil.which("rustup") is None:
+        return []
+    try:
+        result = subprocess.run(
+            ["rustup", "toolchain", "list"],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    if result.returncode != 0:
+        return []
+    toolchains = []
+    for line in (result.stdout or "").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # `rustup toolchain list` suffixes the active one with "(default)"
+        # (and possibly "(override)") — strip it, `--toolchain` wants the
+        # bare name.
+        toolchains.append(line.split()[0])
+    return toolchains
+
+
+def _toolchain_has_target(toolchain: str, target: str, timeout: float) -> bool:
+    try:
+        result = subprocess.run(
+            ["rustup", "target", "list", "--installed", "--toolchain", toolchain],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    if result.returncode != 0:
+        return False
+    installed = {line.strip() for line in (result.stdout or "").splitlines() if line.strip()}
+    return target in installed
+
+
+def _probe_windows_msvc_target(prereq: Prereq, timeout: float) -> ToolProbe:
+    """`custom_probe` backing the `windows` capability's cross-target check
+    (#2952). See the module comment above `WINDOWS_MSVC_TARGET` for why this
+    cannot be a plain binary probe."""
+    toolchains = _rustup_toolchains(timeout)
+    if not toolchains:
+        return ToolProbe(
+            tool=prereq.tool, capability=prereq.capability, found=False,
+            version=None, min_version=prereq.min_version, meets_floor=None,
+            what_breaks=(
+                "rustup reports no installed toolchains (or rustup itself "
+                f"is missing on PATH) — {prereq.what_breaks}"
+            ),
+        )
+    missing = [
+        tc for tc in toolchains
+        if not _toolchain_has_target(tc, WINDOWS_MSVC_TARGET, timeout)
+    ]
+    if missing:
+        return ToolProbe(
+            tool=prereq.tool, capability=prereq.capability, found=False,
+            version=None, min_version=prereq.min_version, meets_floor=None,
+            what_breaks=(
+                f"{WINDOWS_MSVC_TARGET} missing from toolchain(s) "
+                f"{', '.join(missing)} — {prereq.what_breaks}"
+            ),
+        )
+    return ToolProbe(
+        tool=prereq.tool, capability=prereq.capability, found=True,
+        version=", ".join(sorted(toolchains)), min_version=prereq.min_version,
+        meets_floor=None, what_breaks=prereq.what_breaks,
+    )
+
+
 # Required on every machine, no matter its declared capabilities — coord
 # itself doesn't function without these.
 BASELINE_PREREQS: tuple[Prereq, ...] = (
@@ -378,6 +474,33 @@ CAPABILITY_PREREQS: tuple[Prereq, ...] = (
         ),
         custom_probe=_probe_opencode,
     ),
+    # #2952: backs the `windows` capability — dell64's WSL-side cross-compile
+    # to `x86_64-pc-windows-msvc` via cargo-xwin, routing quadraui's
+    # `src/win/` (and vimcode's equivalent) Win-GUI work. Two independent
+    # things can silently regress in that one home directory: the
+    # `cargo-xwin` binary (`~/.cargo/bin`) and the rustup target (see
+    # `_probe_windows_msvc_target` above for why that one needs its own
+    # custom probe rather than a plain binary check).
+    Prereq(
+        tool="cargo-xwin", binary="cargo-xwin", version_args=("--version",),
+        version_re=r"(\d+\.\d+\.\d+\S*)", min_version=None, capability="windows",
+        what_breaks=(
+            "quadraui's `--target x86_64-pc-windows-msvc` cross-compile "
+            "cannot link against the MSVC CRT/SDK — `cargo install "
+            "cargo-xwin`"
+        ),
+    ),
+    Prereq(
+        tool="windows-msvc-target", binary="", version_args=(), version_re="",
+        min_version=None, capability="windows",
+        what_breaks=(
+            f"`rustup target add {WINDOWS_MSVC_TARGET}` is missing from an "
+            "installed toolchain — quadraui pins one in rust-toolchain.toml, "
+            "so add the target to it explicitly, not just the default "
+            "toolchain (#2952)"
+        ),
+        custom_probe=_probe_windows_msvc_target,
+    ),
 )
 
 ALL_PREREQS: tuple[Prereq, ...] = BASELINE_PREREQS + CAPABILITY_PREREQS

{code_coordinator-0.5.302 → code_coordinator-0.5.303}/tests/test_prereqs.py

@@ -534,6 +534,171 @@ class TestProviderOpencodeCapabilityManifest:
         assert "not found" in unmet["provider:opencode"][0]
 
 
+class TestWindowsCapabilityManifest:
+    """#2952: `windows` (dell64's WSL-side cross-compile to
+    x86_64-pc-windows-msvc) is backed by two independent prereqs — the
+    `cargo-xwin` binary and the rustup target, checked per-toolchain."""
+
+    def _windows_prereqs(self):
+        return [p for p in prereqs.CAPABILITY_PREREQS if p.capability == "windows"]
+
+    def test_backed_by_cargo_xwin_and_the_msvc_target(self) -> None:
+        assert {p.tool for p in self._windows_prereqs()} == {
+            "cargo-xwin", "windows-msvc-target",
+        }
+
+    def test_probe_all_covers_it_only_when_declared(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert {"cargo-xwin", "windows-msvc-target"} <= set(probes)
+        assert "cargo" not in probes
+
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes_undeclared = prereqs.probe_all(["rust"])
+        assert "cargo-xwin" not in probes_undeclared
+        assert "windows-msvc-target" not in probes_undeclared
+
+    def test_cargo_xwin_missing_binary_reports_not_found(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["cargo-xwin"].found is False
+        assert probes["cargo-xwin"].ok is False
+
+    def test_cargo_xwin_present_extracts_version(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value="/root/.cargo/bin/cargo-xwin"), \
+             patch(
+                 "coord.prereqs.subprocess.run",
+                 return_value=_Result(stdout="cargo-xwin 0.17.5\n", returncode=0),
+             ):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["cargo-xwin"].found is True
+        assert probes["cargo-xwin"].version == "0.17.5"
+        assert probes["cargo-xwin"].ok is True
+
+    def test_target_probe_is_a_custom_probe_not_a_binary_check(self) -> None:
+        """No single binary's `--version` answers "is the target
+        installed" — this prereq must delegate entirely to a custom probe,
+        never fall through to the generic `shutil.which` path."""
+        target_prereq = next(
+            p for p in self._windows_prereqs() if p.tool == "windows-msvc-target"
+        )
+        assert target_prereq.custom_probe is not None
+
+    def test_target_missing_when_rustup_itself_is_absent(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is False
+        assert "no installed toolchains" in probes["windows-msvc-target"].what_breaks
+
+    def test_target_present_on_the_only_installed_toolchain(self) -> None:
+        def fake_run(cmd, **kwargs):
+            if cmd[:2] == ["rustup", "toolchain"]:
+                return _Result(stdout="stable-x86_64-unknown-linux-gnu (default)\n", returncode=0)
+            if cmd[:2] == ["rustup", "target"]:
+                return _Result(
+                    stdout="x86_64-pc-windows-msvc\nx86_64-unknown-linux-gnu\n",
+                    returncode=0,
+                )
+            return _Result(returncode=0)
+
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch("coord.prereqs.subprocess.run", side_effect=fake_run):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is True
+        assert probes["windows-msvc-target"].ok is True
+
+    def test_target_missing_from_the_pinned_toolchain_reports_unmet(self) -> None:
+        """The #2952 trap: the target was added to the default toolchain
+        but not to quadraui's `rust-toolchain.toml` pin (1.97.1) — a probe
+        that only checked the default toolchain would report MET while
+        quadraui's own build still fails. Must check every toolchain and
+        name the offending one."""
+        def fake_run(cmd, **kwargs):
+            if cmd[:2] == ["rustup", "toolchain"]:
+                return _Result(
+                    stdout=(
+                        "stable-x86_64-unknown-linux-gnu (default)\n"
+                        "1.97.1-x86_64-unknown-linux-gnu\n"
+                    ),
+                    returncode=0,
+                )
+            if cmd[:2] == ["rustup", "target"]:
+                toolchain = cmd[cmd.index("--toolchain") + 1]
+                if toolchain == "1.97.1-x86_64-unknown-linux-gnu":
+                    return _Result(stdout="x86_64-unknown-linux-gnu\n", returncode=0)
+                return _Result(
+                    stdout="x86_64-pc-windows-msvc\nx86_64-unknown-linux-gnu\n",
+                    returncode=0,
+                )
+            return _Result(returncode=0)
+
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch("coord.prereqs.subprocess.run", side_effect=fake_run):
+            probes = prereqs.probe_all(["windows"])
+        result = probes["windows-msvc-target"]
+        assert result.found is False
+        assert result.ok is False
+        assert "1.97.1-x86_64-unknown-linux-gnu" in result.what_breaks
+
+    def test_target_probe_never_raises_on_a_broken_rustup(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch(
+                 "coord.prereqs.subprocess.run",
+                 side_effect=subprocess.TimeoutExpired(cmd="rustup", timeout=10),
+             ):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is False
+        assert probes["windows-msvc-target"].ok is False
+
+    def test_unmet_when_cargo_xwin_missing(self) -> None:
+        probes = {
+            "cargo-xwin": prereqs.ToolProbe(
+                tool="cargo-xwin", capability="windows", found=False, version=None,
+                min_version=None, meets_floor=None, what_breaks="",
+            ),
+            "windows-msvc-target": prereqs.ToolProbe(
+                tool="windows-msvc-target", capability="windows", found=True,
+                version="stable", min_version=None, meets_floor=None, what_breaks="",
+            ),
+        }
+        unmet = prereqs.unmet_capabilities(["windows"], probes)
+        assert "windows" in unmet
+        assert len(unmet["windows"]) == 1
+        assert "cargo-xwin not found" in unmet["windows"][0]
+
+    def test_unmet_when_target_missing(self) -> None:
+        probes = {
+            "cargo-xwin": prereqs.ToolProbe(
+                tool="cargo-xwin", capability="windows", found=True, version="0.17.5",
+                min_version=None, meets_floor=None, what_breaks="",
+            ),
+            "windows-msvc-target": prereqs.ToolProbe(
+                tool="windows-msvc-target", capability="windows", found=False,
+                version=None, min_version=None, meets_floor=None, what_breaks="",
+            ),
+        }
+        unmet = prereqs.unmet_capabilities(["windows"], probes)
+        assert "windows" in unmet
+        assert "windows-msvc-target not found" in unmet["windows"][0]
+
+    def test_met_when_both_probes_pass(self) -> None:
+        probes = {
+            tool: prereqs.ToolProbe(
+                tool=tool, capability="windows", found=True, version="x",
+                min_version=None, meets_floor=None, what_breaks="",
+            )
+            for tool in ("cargo-xwin", "windows-msvc-target")
+        }
+        assert prereqs.unmet_capabilities(["windows"], probes) == {}
+
+    def test_all_capability_names_includes_windows(self) -> None:
+        """#2952 acceptance: `ALL_CAPABILITY_NAMES` is derived from
+        `CAPABILITY_PREREQS`, so adding these two entries must pick
+        `windows` up automatically — no separate registration needed for a
+        config-free agent to probe it too (see TestAllCapabilityNames)."""
+        assert "windows" in prereqs.ALL_CAPABILITY_NAMES
+
+
 class TestGhFloorIsSingleSourceOfTruth:
     def test_baseline_gh_prereq_imports_the_floor(self) -> None:
         """#1564's constant stays the single source of truth — this module