code-coordinator 0.5.129__tar.gz → 0.5.130__tar.gz

{code_coordinator-0.5.129 → code_coordinator-0.5.130}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.129",
+  "tag": "0.5.130",
   "distance": 0,
-  "node": "g35ed648ce7ee944d0c954c511918f971ef413bef",
+  "node": "g14a2d9301195335040144bf7d82384aeddb54b2b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.129 → code_coordinator-0.5.130}/coord/agent.py

@@ -785,6 +785,44 @@ def _git(cwd: Path, *args: str, timeout: float = 15.0) -> str:
     return result.stdout.strip()
 
 
+def _remote_already_has_head(
+    wt_path: Path, remote: str, branch: str, *, timeout: float = 30.0
+) -> bool:
+    """True when *remote*'s copy of *branch* already contains the worktree's
+    current ``HEAD`` as an ancestor (#2356).
+
+    Used by `_reap`'s belt-and-suspenders push-failure handling: an
+    auth-shaped failure pushing to *remote* does NOT necessarily mean the
+    worker's commits never reached it — a worker that hit the same broken
+    write-credential wall (e.g. an HTTPS credential helper with nothing to
+    expand in a non-interactive shell) may have already worked around it by
+    pushing the same commit over a different remote/protocol, most commonly
+    an explicit ``git@github.com:...`` SSH URL (the #2269 incident). That
+    push landed on the SAME GitHub-hosted branch this function now checks —
+    it never touches a second remote name in the worktree's own git config.
+
+    Fetching *branch* is a READ operation (``git fetch`` invokes
+    upload-pack, not receive-pack), which commonly still succeeds — via
+    anonymous access on a public repo, or a still-valid read-scoped
+    credential — even when the WRITE credential that just failed the push
+    is broken or missing entirely. So this is a meaningfully independent
+    signal from the push that just failed, not a re-run of the same failing
+    operation.
+
+    Returns ``False`` — never raises — on any git failure: the branch
+    missing on the remote, a network error, or `merge-base` reporting "not
+    an ancestor" all resolve to "unknown/genuinely behind", and an unknown
+    remote state must never suppress the real #1797 failure signal (nothing
+    ever reached the remote).
+    """
+    try:
+        _git(wt_path, "fetch", remote, branch, timeout=timeout)
+        _git(wt_path, "merge-base", "--is-ancestor", "HEAD", "FETCH_HEAD")
+        return True
+    except (_GitError, subprocess.TimeoutExpired):
+        return False
+
+
 def _is_linked_worktree(repo_path: Path) -> bool:
     """True when *repo_path* is a linked ``git worktree`` rather than the
     checkout that owns its ``.git`` directory (#1729, H-6's guard 2).
@@ -2988,7 +3026,14 @@ class AgentAssignment:
     # alongside `status == FAILED`; `None` on every other outcome —
     # including a push failure for an unrelated reason (no `origin`
     # configured, network blip), which stays non-fatal exactly as before
-    # this field was introduced.
+    # this field was introduced, AND (#2356) including an auth-shaped
+    # failure on THIS push that turns out to be superseded: when
+    # `_remote_already_has_head` confirms the content already reached
+    # `origin` via some other remote/protocol (e.g. the #2269 SSH-
+    # workaround case), the push failure is logged but this field stays
+    # `None` and the assignment keeps its normal (non-FAILED) outcome —
+    # the work is where it needs to be, so the failed push here is a
+    # non-event, not a signal.
     #
     # Exists to keep an auth break from being silently absorbed into either
     # DONE (worker had local commits that never reached origin) or the
@@ -8146,12 +8191,54 @@ class AgentServer:
                         # against repos with no `origin` at all (every test
                         # fixture, and any local-only deployment), and that
                         # failure mode must stay non-fatal exactly as before.
+                        #
+                        # #2356: an auth-shaped failure on THIS push doesn't
+                        # necessarily mean the content never reached origin
+                        # — a worker that hit the same broken-credential
+                        # wall may have already landed the same commit via
+                        # an alternate remote/protocol (#2269: an explicit
+                        # SSH URL, worked around a missing HTTPS
+                        # credential). Before promoting to FAILED, check
+                        # whether origin already has local HEAD as an
+                        # ancestor (`_remote_already_has_head` fetches — a
+                        # read, which commonly still works even when the
+                        # write credential just failed). Only genuinely
+                        # missing content — origin behind local HEAD, or the
+                        # check itself failing — is promoted, so #1797's
+                        # original "nothing ever reached origin" case is
+                        # unaffected.
                         _reason = str(e)
+                        _suppressed_as_already_pushed = False
                         if _is_auth_push_failure(_reason):
-                            _push_failure_reason = _reason
+                            _branch_for_check = (
+                                head if head and head != "HEAD" else None
+                            )
+                            if _branch_for_check and _remote_already_has_head(
+                                wt_path, "origin", _branch_for_check
+                            ):
+                                _suppressed_as_already_pushed = True
+                            else:
+                                _push_failure_reason = _reason
                         try:
                             with open(assignment.log_path, "a") as reopen:
-                                reopen.write(f"# reap: push failed ({_reason})\n")
+                                if _suppressed_as_already_pushed:
+                                    # Deliberately NOT the generic "push
+                                    # failed" line below: that line reads as
+                                    # a live failure signal, which this
+                                    # isn't — origin already has HEAD, so
+                                    # the failed push here is a non-event
+                                    # (#2356).
+                                    reopen.write(
+                                        "# reap: push failed but origin "
+                                        "already has HEAD as an ancestor "
+                                        "(pushed via another remote/"
+                                        "protocol?) — treating as success "
+                                        f"({_reason}) (#2356)\n"
+                                    )
+                                else:
+                                    reopen.write(
+                                        f"# reap: push failed ({_reason})\n"
+                                    )
                         except OSError:
                             pass
 

{code_coordinator-0.5.129 → code_coordinator-0.5.130}/tests/test_agent_push_failure.py

@@ -31,6 +31,7 @@ from coord.agent import (
     AgentServer,
     AssignmentSpec,
     _is_auth_push_failure,
+    _remote_already_has_head,
 )
 
 
@@ -40,6 +41,42 @@ def _git(cwd: Path, *args: str) -> str:
     ).stdout.strip()
 
 
+def _write_always_failing_receive_pack(tmp_path: Path) -> Path:
+    """A `receive-pack` replacement that unconditionally fails every push
+    with an auth-shaped error, regardless of whether the push has anything
+    new to send (#2356 review).
+
+    A `pre-receive` hook is the WRONG tool for simulating "reap's own push
+    fails while the remote already has HEAD": git's client-side ref
+    negotiation short-circuits to `Everything up-to-date` (exit 0) whenever
+    local HEAD already matches what the remote advertises, and that
+    short-circuit happens BEFORE a pack is ever sent — so a `pre-receive`
+    hook, which only runs after `receive-pack` unpacks an incoming pack,
+    never gets invoked at all in that case. Verified independently: a
+    `pre-receive`-based rejecting remote lets a same-SHA `git push -u
+    origin HEAD` succeed silently, hook untouched.
+
+    Overriding `remote.<name>.receivepack` instead replaces the
+    `receive-pack` PROGRAM itself, which git invokes unconditionally at the
+    start of every `git push` (for ref advertisement) — before any
+    comparison against what the client already has. It fires every time,
+    including when there is nothing new to send, which is exactly the
+    shape this scenario needs. Deliberately leaves `uploadpack` untouched,
+    so `git fetch` (what `_remote_already_has_head` uses) keeps working
+    normally.
+    """
+    script = tmp_path / "fail_receive_pack.sh"
+    script.write_text(
+        "#!/bin/sh\n"
+        "echo 'remote: Invalid username or token.' >&2\n"
+        "echo 'remote: Password authentication is not supported for "
+        "Git operations.' >&2\n"
+        "exit 1\n"
+    )
+    script.chmod(script.stat().st_mode | stat.S_IEXEC)
+    return script
+
+
 class TestIsAuthPushFailure:
     """Direct unit tests for `_is_auth_push_failure` (#1797 review nit): the
     three FAILED-vs-non-fatal tests above only exercise it indirectly
@@ -98,6 +135,90 @@ class TestIsAuthPushFailure:
         assert _is_auth_push_failure(message) is False
 
 
+def _init_repo(d: Path) -> None:
+    d.mkdir()
+    _git(d, "init", "-b", "main")
+    _git(d, "config", "user.email", "t@t.com")
+    _git(d, "config", "user.name", "Test")
+
+
+def _commit_file(d: Path, name: str, contents: str, message: str) -> None:
+    (d / name).write_text(contents)
+    _git(d, "add", name)
+    _git(d, "commit", "-m", message)
+
+
+class TestRemoteAlreadyHasHead:
+    """Direct unit tests for `_remote_already_has_head` (#2356 review nit):
+    the full-round-trip tests only exercise it indirectly through an entire
+    `AgentServer`/`_reap` cycle, which proves the wiring but not the
+    ancestor-check logic itself in isolation. These pin down the four cases
+    the function's docstring promises: caught up, genuinely behind, branch
+    missing on the remote, and the remote unreachable outright — mirroring
+    `TestIsAuthPushFailure`'s role for `_is_auth_push_failure`.
+    """
+
+    def test_true_when_remote_already_has_head_as_ancestor(
+        self, tmp_path: Path
+    ) -> None:
+        origin = tmp_path / "origin.git"
+        origin.mkdir()
+        _git(origin, "init", "--bare", "-b", "main")
+
+        clone = tmp_path / "clone"
+        _init_repo(clone)
+        _git(clone, "remote", "add", "origin", str(origin))
+        _commit_file(clone, "f", "x\n", "c1")
+        _git(clone, "push", "-u", "origin", "main")
+
+        assert _remote_already_has_head(clone, "origin", "main") is True
+
+    def test_false_when_local_head_is_ahead_of_remote(
+        self, tmp_path: Path
+    ) -> None:
+        """The genuine #1797 shape: local HEAD moved on past whatever the
+        remote has, so the remote does NOT already have this content —
+        must return False so the real failure signal is never suppressed.
+        """
+        origin = tmp_path / "origin.git"
+        origin.mkdir()
+        _git(origin, "init", "--bare", "-b", "main")
+
+        clone = tmp_path / "clone"
+        _init_repo(clone)
+        _git(clone, "remote", "add", "origin", str(origin))
+        _commit_file(clone, "f", "x\n", "c1")
+        _git(clone, "push", "-u", "origin", "main")
+
+        # A second local commit that never reaches origin.
+        _commit_file(clone, "f", "y\n", "c2 (never reaches origin)")
+
+        assert _remote_already_has_head(clone, "origin", "main") is False
+
+    def test_false_when_remote_branch_does_not_exist(
+        self, tmp_path: Path
+    ) -> None:
+        origin = tmp_path / "origin.git"
+        origin.mkdir()
+        _git(origin, "init", "--bare", "-b", "main")
+
+        clone = tmp_path / "clone"
+        _init_repo(clone)
+        _git(clone, "remote", "add", "origin", str(origin))
+        _commit_file(clone, "f", "x\n", "c1")
+        # Never pushed anywhere — "main" doesn't exist on origin at all.
+
+        assert _remote_already_has_head(clone, "origin", "main") is False
+
+    def test_false_when_remote_is_unreachable(self, tmp_path: Path) -> None:
+        clone = tmp_path / "clone"
+        _init_repo(clone)
+        _git(clone, "remote", "add", "origin", str(tmp_path / "does-not-exist"))
+        _commit_file(clone, "f", "x\n", "c1")
+
+        assert _remote_already_has_head(clone, "origin", "main") is False
+
+
 @pytest.fixture
 def repo_with_rejecting_remote(tmp_path: Path) -> tuple[Path, Path]:
     """A working clone whose `origin` rejects every push with a git
@@ -222,6 +343,71 @@ def test_push_failure_with_zero_commits_is_failed_not_advisory(
     server.shutdown()
 
 
+def test_push_failure_when_already_on_origin_via_other_route_is_not_failed(
+    tmp_path: Path, repo_with_rejecting_remote: tuple[Path, Path]
+) -> None:
+    """#2356: a worker that hits the same broken-write-credential wall as
+    #1797 may work around it by landing the same commit on origin via some
+    other route (the #2269 incident: pushing over an explicit SSH URL when
+    the worktree's configured HTTPS remote had no usable credentials in a
+    non-interactive shell). Reap's own belt-and-suspenders push against
+    `origin` still fails with the exact same auth-shaped error in that case
+    — but the content is already on the remote branch.
+
+    The worker lands its own commit on `origin` first (hook briefly
+    lifted — standing in for "reached origin via another path"), THEN we
+    install `_write_always_failing_receive_pack`'s override so reap's own
+    subsequent push — which has nothing new to send, since the worker
+    already pushed this exact SHA — still fails with an auth-shaped error.
+    (A `pre-receive` hook cannot do this: see that helper's docstring for
+    why git's own "nothing to push" short-circuit bypasses it here.) The
+    assignment must land on DONE, not FAILED: the work is exactly where it
+    needs to be, however it got there.
+    """
+    clone, origin = repo_with_rejecting_remote
+    hook = origin / "hooks" / "pre-receive"
+    fail_receive_pack = _write_always_failing_receive_pack(tmp_path)
+
+    worker_sh = (
+        "git config user.email w@w.com && "
+        "git config user.name Worker && "
+        "echo change > change.txt && "
+        "git add change.txt && "
+        "git commit -m 'real work' && "
+        f"chmod -x {hook} && "
+        "git push origin HEAD && "
+        f"chmod +x {hook} && "
+        f"git config remote.origin.receivepack {fail_receive_pack}"
+    )
+    server = AgentServer(
+        machine_name="t",
+        repos=["api"],
+        repo_paths={"api": str(clone)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/sh", "-c", worker_sh],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(clone),
+        issue_number=4,
+        issue_title="already pushed elsewhere, origin push still broken",
+        briefing="b",
+        branch="main",
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == DONE, (
+        "origin already had HEAD (however it got there) — reap's own push "
+        f"failing on top of that must not be FAILED, got {final.status!r}"
+    )
+    assert final.push_failure_reason is None, (
+        "the auth-shaped failure must be suppressed once the fetch-based "
+        "check confirms origin already has HEAD as an ancestor"
+    )
+    server.shutdown()
+
+
 def test_successful_push_leaves_push_failure_reason_none(
     tmp_path: Path, repo_with_rejecting_remote: tuple[Path, Path]
 ) -> None: