Files
teknium1 605037755a fix(update-check): the passive check's git ls-remote dies with the CLI
`hermes chat` starts check_for_updates in a daemon thread. On an official
source checkout (stable by default since 6a92a2aa49) it verifies the
release tag with `git ls-remote --tags origin`, which forks
`git remote-https`. Spawned with a plain subprocess.run, it shared the
CLI's process group and nothing owned it: a /exit while GitHub was slow
abandoned the thread, and git + its helper reparented to init (the 0.23.2
release E2E caught them, test_terminal_transcript_pty[cli-turns]). Its
60s timeout also killed only git, not the helper.

Both remote-touching probes (the stable tag check and _branch_tip's
ls-remote) now go through source_check.remote_git_run ->
bounded_probe_run(owned=True): own process group, handed to the
owner-death supervisor while it runs, the whole group killed on timeout.

The PTY harness sandbox now sets updates.check: false, as tui_pty's
does: the attached `gateway run` (which outlives /exit by design) runs
the same check, and the E2E must not talk to real GitHub.
2026-11-16 10:12:09 -08:00

816 lines
40 KiB
Python

"""Exercise the passive checker with real linked worktrees and loopback HTTP."""
import json
import shutil
import subprocess
import threading
import urllib.request
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import urlsplit
from uuid import uuid4
import pytest
# The fixture below serves channel records over loopback; the reader's real HTTP path is the subject.
pytestmark = pytest.mark.real_release_channels
MAIN_CHANNEL = "/releases/channels/main.json"
def source_channel(name, repository, branch="main"):
return {"schema": 1, "name": name, "repository": repository, "policy": "source-branch",
"state": "active", "revision": 1, "nextSequence": 1, "identity": None, "head": None,
"delivery": {"kind": "source-branch", "branch": branch}}
class Installation(tuple):
"""The 8-tuple every test unpacks, plus the GitHub probe's request/response hooks."""
authorizations: list
response_headers: dict
@pytest.fixture
def installation(tmp_path, monkeypatch):
from hermes_cli import source_releases
root = tmp_path / "checkout"
root.mkdir()
home = tmp_path / "profile"
home.mkdir()
monkeypatch.setenv("HERMES_HOME", str(home))
monkeypatch.delenv("HERMES_REVISION", raising=False)
monkeypatch.delenv("HERMES_MANAGED", raising=False)
# Git probes may use real local remotes, never the external network.
monkeypatch.setenv("GIT_ALLOW_PROTOCOL", "file")
def git(*args, cwd=root):
return subprocess.check_output([
"git", "-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid",
"-c", "commit.gpgsign=false", *args,
], cwd=cwd, text=True).strip()
git("init", "-b", "main")
git("commit", "--allow-empty", "-m", "base")
base = git("rev-parse", "HEAD")
git("commit", "--allow-empty", "-m", "local")
head = git("rev-parse", "HEAD")
git("remote", "add", "origin", "https://github.com/fixture/fork.git")
linked = tmp_path / "linked"
git("worktree", "add", "-b", "feature/gui", str(linked))
responses = {MAIN_CHANNEL: (200, lambda: source_channel(
"main", source_releases.source_repository(["git"], root)))}
requests = []
# Authorization header of every api.github.com call, in request order (None when anonymous).
authorizations = []
# Optional extra response headers per path (rate-limit headers for the failure-copy tests).
response_headers = {}
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
requests.append(self.path)
authorizations.append(self.headers.get("Authorization"))
entry = responses.get(self.path, (404, {}))
# A callable entry decides per request (it sees the handler, hence the headers).
code, body = entry(self) if callable(entry) else entry
if callable(body):
body = body()
self.send_response(code)
for name, value in response_headers.get(self.path, {}).items():
self.send_header(name, value)
self.end_headers()
self.wfile.write((body if isinstance(body, str) else json.dumps(body)).encode())
def log_message(self, *args):
pass
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
monkeypatch.setattr(source_releases, "_PUBLIC_BASE", f"http://127.0.0.1:{server.server_port}")
original = urllib.request.urlopen
def local(request, *args, **kwargs):
url = urlsplit(request.full_url)
assert url.hostname in {"api.github.com", "hermes-assets.nousresearch.com", "raw.githubusercontent.com"}
rewritten = urllib.request.Request(
f"http://127.0.0.1:{server.server_port}{url.path}" + (f"?{url.query}" if url.query else ""),
headers=dict(request.header_items()))
return original(rewritten, *args, **kwargs)
monkeypatch.setattr(urllib.request, "urlopen", local)
# The credential ladder must not read this machine's gh login or env.
monkeypatch.delenv("GITHUB_TOKEN", raising=False)
monkeypatch.delenv("GH_TOKEN", raising=False)
from hermes_cli import github_api
monkeypatch.setattr(github_api, "_gh_cli_token", lambda: None)
fixture = Installation((root, linked, home, base, head, responses, requests, git))
fixture.authorizations = authorizations
fixture.response_headers = response_headers
yield fixture
server.shutdown()
server.server_close()
thread.join()
def test_target_worktree_owns_admission_and_fork_comparison(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
root, linked, home, _base, head, responses, requests, git = installation
(root / "install-stamp.json").write_text(json.dumps({"updateMechanism": "external"}))
(linked / "install-stamp.json").write_text(json.dumps({"updateMechanism": "self"}))
cache = home / "shared-cache.json"
target = "a" * 40
responses["/repos/fixture/fork/commits/feature%2Fgui"] = (200, target)
responses[f"/repos/fixture/fork/compare/{head}...{target}"] = (200, {"ahead_by": 3, "commits": []})
commands = []
original = subprocess.run
def record(args, **kwargs):
commands.append(args)
return original(args, **kwargs)
before = {str(p.relative_to(root)): p.read_bytes() for p in (root / ".git").rglob("*") if p.is_file()}
monkeypatch.setattr(subprocess, "run", record)
status = check_for_updates(install_root=linked, home=home, cache_path=cache)
assert status["supported"] is True
assert status["branch"] == "feature/gui"
assert status["behind"] == 3
assert status["hermesRoot"] == str(linked)
assert check_for_updates(install_root=root, home=home, cache_path=cache)["supported"] is False
assert requests == ["/repos/fixture/fork/commits/feature%2Fgui",
f"/repos/fixture/fork/compare/{head}...{target}"]
assert all(not any(arg in {"fetch", "checkout", "reset", "update-ref", "stash"} for arg in cmd) for cmd in commands)
assert git("rev-parse", "HEAD", cwd=linked) == head
assert {str(p.relative_to(root)): p.read_bytes() for p in (root / ".git").rglob("*") if p.is_file()} == before
def test_bare_git_off_path_reads_through_the_updaters_git(installation, monkeypatch, tmp_path):
"""Desktop passes a bare ``git`` when it found none; a Windows install's only git is PM's
store copy, off PATH outside ``hermes update``. The check must read HEAD through that git."""
import shutil
from hermes_cli import update_pause_record
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, head, responses, _requests, _git = installation
responses["/repos/fixture/fork/commits/main"] = (200, head)
store_git = shutil.which("git")
empty = tmp_path / "no-git-on-path"
empty.mkdir()
monkeypatch.setenv("PATH", str(empty))
monkeypatch.setattr(update_pause_record, "_git_executable", lambda: store_git)
status = check_for_updates(install_root=root, home=home, git="git", force=True)
assert status.get("error") is None, status
assert status["currentSha"] == head
assert status["behind"] == 0
@pytest.mark.parametrize("tip_kind,compare,expected", [
("head", None, 0), ("base", None, 0),
("unknown", {"ahead_by": 61}, 61), ("unknown", {"ahead_by": 0}, 0),
("unknown", None, -1), ("unknown", {"ahead_by": True}, -1),
])
def test_counts_are_honest_without_fetch(installation, tip_kind, compare, expected):
from hermes_cli.source_check import check_for_updates
root, _linked, home, base, head, responses, requests, _git = installation
target = {"head": head, "base": base, "unknown": "a" * 40}[tip_kind]
responses["/repos/fixture/fork/commits/main"] = (200, "\ufeff" + target)
if compare is not None:
responses[f"/repos/fixture/fork/compare/{head}...{target}"] = (200, "\ufeff" + json.dumps(compare))
status = check_for_updates(install_root=root, home=home)
assert status["behind"] == expected
assert status["updateAvailable"] is (expected != 0)
if tip_kind != "unknown":
assert requests == ["/repos/fixture/fork/commits/main"]
def test_cache_force_expiry_and_passive_opt_out(installation, monkeypatch):
from hermes_cli import source_check
root, _linked, home, _base, head, responses, requests, git = installation
clock = [1000000.0]
monkeypatch.setattr(source_check.time, "time", lambda: clock[0])
url = "/repos/fixture/fork/commits/main"
responses[url] = (200, head)
check = lambda **kw: source_check.check_for_updates(install_root=root, home=home, **kw)
assert check()["behind"] == 0
cache = next((home / "source-checks").glob("*.json"))
raw = cache.read_bytes()
assert not raw.startswith(b"\xef\xbb\xbf")
cache.write_bytes(b"\xef\xbb\xbf" + raw)
responses[url] = (503, {})
(root / "dirty.txt").write_text("carried work")
assert check()["dirty"] is True
assert requests.count(url) == 1
assert check(force=True)["error"] == "fetch-failed"
clock[0] += 3599
assert check()["error"] == "fetch-failed"
assert requests.count(url) == 2
clock[0] += 2
responses[url] = (200, head)
assert check()["behind"] == 0
assert requests.count(url) == 3
clock[0] += 86401
assert check()["behind"] == 0
assert requests.count(url) == 4
(home / "config.yaml").write_text("updates: {check: false}")
assert check(passive=True)["behind"] is None
assert check()["behind"] == 0
assert requests.count(url) == 4
git("commit", "--allow-empty", "-m", "moved")
responses[url] = (200, git("rev-parse", "HEAD"))
assert check()["behind"] == 0
assert requests.count(url) == 5
def test_explicit_and_current_branch_heal_only_after_confirmed_absence(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
root, linked, home, _base, _head, _responses, requests, git = installation
git("remote", "set-url", "origin", str(root))
# Use the same real linked worktree with a local origin. No GitHub fallback is involved.
assert check_for_updates(install_root=linked, home=home)["branch"] == "feature/gui"
assert check_for_updates(install_root=linked, home=home, branch="main")["branch"] == "main"
assert check_for_updates(install_root=linked, home=home, branch="deleted")["branch"] == "main"
git("remote", "set-url", "origin", str(home / "unreachable"))
failed = check_for_updates(install_root=linked, home=home, branch="deleted", force=True)
assert failed["branch"] == "deleted"
assert failed["error"] == "fetch-failed"
assert git("branch", "--show-current", cwd=linked) == "feature/gui"
assert requests == []
@pytest.mark.parametrize("selection", ["explicit", "configured", "current", "detached"])
def test_dynamic_source_channel_preserves_branch_precedence(installation, selection):
from hermes_cli.source_check import check_for_updates
_root, linked, home, _base, head, responses, requests, git = installation
name = "branch-" + uuid4().hex[:12]
channel_path = f"/releases/channels/{name}.json"
responses[channel_path] = (200, source_channel(name, "fixture/fork", "channel-default"))
branch_file = home / "desktop-update.json"
if selection in {"explicit", "configured"}:
branch_file.write_text(json.dumps({"branch": "desktop-choice"}))
if selection == "detached":
git("checkout", "--detach", cwd=linked)
expected = {"explicit": "explicit-choice", "configured": "desktop-choice",
"current": "feature/gui", "detached": "channel-default"}[selection]
branch_path = f"/repos/fixture/fork/commits/{expected.replace('/', '%2F')}"
responses[branch_path] = (200, head)
status = check_for_updates(install_root=linked, home=home, channel=name,
branch="explicit-choice" if selection == "explicit" else None,
branch_config_path=branch_file)
assert status.get("branch") == expected, status
assert status.get("targetSha") == head, status
assert status["behind"] == 0
assert requests == ([] if selection == "explicit" else [channel_path]) + [branch_path]
# An unpublished ``main`` record is not a channel failure: main IS the source
# branch, so the check keeps following a branch via git, with the usual branch
# precedence (test_unpublished_main_record_follows_the_branch below).
@pytest.mark.parametrize("name,failure", [
("canary", "missing"),
(None, "missing"), (None, "malformed"), (None, "foreign"), (None, "unpublished"),
])
def test_channel_failure_never_probes_or_heals_a_branch(installation, name, failure):
from hermes_cli.source_check import check_for_updates
_root, linked, home, _base, head, responses, requests, _git = installation
name = name or "preview-" + uuid4().hex[:12]
channel_path = f"/releases/channels/{name}.json"
body = source_channel(name, "fixture/fork")
code = 200
if failure == "missing":
code = 404
elif failure == "malformed":
body = "not JSON"
elif failure == "foreign":
body["repository"] = "NousResearch/hermes-agent"
else:
body["policy"] = "preview"
del body["delivery"]
body["identity"] = {
"token": "a" * 16, "displayName": "Fixture", "appNamePascal": "Fixture",
"artifactNamePascal": "Fixture", "appId": "ai.fixture.preview",
"msixAppIdWithOrg": "Fixture.Preview", "cliName": "fixture-preview",
"windowsExecutableName": "Fixture",
}
responses[channel_path] = (code, body)
responses["/repos/fixture/fork/commits/main"] = (200, head)
branch_file = home / "desktop-update.json"
branch_file.write_text(json.dumps({"branch": "deleted"}))
status = check_for_updates(install_root=linked, home=home, channel=name,
branch_config_path=branch_file)
assert status.get("error") == "release-unavailable", status
assert "targetSha" not in status
assert status["behind"] is None
assert requests == [channel_path]
assert json.loads(branch_file.read_text())["branch"] == "deleted"
def test_main_follows_the_branch_without_reading_a_channel_record(installation):
"""main IS the git branch: no R2 record is requested (a regional WAF can answer
it 403), the configured branch is probed, and the Desktop branch setting is left alone."""
from hermes_cli.source_check import check_for_updates
_root, linked, home, _base, head, responses, requests, _git = installation
# Even a record that would answer is never read.
responses[MAIN_CHANNEL] = (403, {"message": "blocked by WAF"})
branch_path = "/repos/fixture/fork/commits/desktop-choice"
responses[branch_path] = (200, head)
branch_file = home / "desktop-update.json"
branch_file.write_text(json.dumps({"branch": "desktop-choice"}))
status = check_for_updates(install_root=linked, home=home, channel="main",
branch_config_path=branch_file)
assert "error" not in status, status
assert status.get("branch") == "desktop-choice", status
assert status.get("targetSha") == head, status
assert status["behind"] == 0
assert requests == [branch_path]
assert json.loads(branch_file.read_text())["branch"] == "desktop-choice"
def test_running_revision_is_not_applied_to_an_explicit_target(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
root, linked, home, _base, head, responses, _requests, _git = installation
monkeypatch.setenv("HERMES_REVISION", "e" * 40)
monkeypatch.setenv("HERMES_INSTALL_ROOT", str(root))
responses["/repos/fixture/fork/commits/feature%2Fgui"] = (200, head)
assert check_for_updates(install_root=linked, home=home)["currentSha"] == head
# Default invocation retains the Nix revision probe even without a Git checkout.
monkeypatch.setattr("hermes_cli.config.get_project_root", lambda: home)
responses[MAIN_CHANNEL] = (200, source_channel("main", "NousResearch/hermes-agent"))
responses["/repos/NousResearch/hermes-agent/commits/main"] = (200, "e" * 40)
assert check_for_updates(home=home)["behind"] == 0
def test_deleted_desktop_branch_is_persisted_only_after_definitive_probe(installation):
from hermes_cli.source_check import check_for_updates
root, linked, home, _base, _head, _responses, _requests, git = installation
branch_file = home / "desktop-update.json"
branch_file.write_text(json.dumps({"branch": "deleted", "other": "café"}, ensure_ascii=False),
encoding="utf-8-sig")
git("remote", "set-url", "origin", str(home / "unreachable"))
status = check_for_updates(install_root=linked, home=home, branch_config_path=branch_file)
assert status["branch"] == "deleted"
assert json.loads(branch_file.read_bytes())["branch"] == "deleted"
git("remote", "set-url", "origin", str(root))
status = check_for_updates(install_root=linked, home=home, branch_config_path=branch_file)
assert status["branch"] == "main"
assert json.loads(branch_file.read_text(encoding="utf-8")) == {"branch": "main", "other": "café"}
assert not branch_file.read_bytes().startswith(b"\xef\xbb\xbf")
def _bare_origin(installation):
"""Point the checkout at a real bare remote holding main; no GitHub repository is involved."""
_root, _linked, home, _base, _head, _responses, _requests, git = installation
remote = home / "remote.git"
git("init", "--bare", "-b", "main", str(remote))
git("remote", "set-url", "origin", str(remote))
git("push", "-q", "origin", "main")
git("fetch", "-q", "origin")
def _commit_on(git, branch, message):
git("checkout", "-q", branch)
git("commit", "-q", "--allow-empty", "-m", message)
sha = git("rev-parse", "HEAD")
git("checkout", "-q", "main")
return sha
@pytest.mark.parametrize("pinned_by", ["desktop", "current"])
def test_never_pushed_branch_keeps_its_pin(installation, pinned_by):
"""#105042: an empty advertisement for a branch that was never pushed is not a deletion."""
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, _head, _responses, requests, git = installation
_bare_origin(installation)
git("branch", "local-work")
_commit_on(git, "local-work", "unpushed work")
branch_file = home / "desktop-update.json"
if pinned_by == "desktop":
branch_file.write_text(json.dumps({"branch": "local-work"}))
else:
git("checkout", "-q", "local-work")
status = check_for_updates(install_root=root, home=home, branch_config_path=branch_file)
assert status["branch"] == "local-work", status
assert status["error"] == "branch-local-only"
assert status["localOnly"] is True
assert "never been pushed" in status["message"]
assert "targetSha" not in status
if pinned_by == "desktop":
assert json.loads(branch_file.read_text()) == {"branch": "local-work"}
else:
assert not branch_file.exists()
assert requests == []
@pytest.mark.parametrize("merge", ["fast-forward", "rebase", "unmerged"])
def test_deleted_remote_branch_heals_only_when_its_commits_are_in_main(installation, merge):
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, _head, _responses, _requests, git = installation
_bare_origin(installation)
git("branch", "pushed")
work = _commit_on(git, "pushed", "published work")
git("push", "-q", "-u", "origin", "pushed")
if merge == "fast-forward":
git("merge", "-q", "--ff-only", "pushed")
elif merge == "rebase":
git("commit", "-q", "--allow-empty", "-m", "upstream moved on")
git("cherry-pick", "--allow-empty", work)
if merge != "unmerged":
git("push", "-q", "origin", "main")
# Upstream deletes the branch; the prune removes the tracking ref but keeps the upstream config.
git("push", "-q", "origin", "--delete", "pushed")
git("fetch", "-q", "--prune", "origin")
assert git("for-each-ref", "refs/remotes/origin/pushed") == ""
branch_file = home / "desktop-update.json"
branch_file.write_text(json.dumps({"branch": "pushed"}))
status = check_for_updates(install_root=root, home=home, branch_config_path=branch_file)
if merge == "unmerged":
assert status["branch"] == "pushed", status
assert status["error"] == "branch-local-only"
assert "not in main" in status["message"]
assert json.loads(branch_file.read_text())["branch"] == "pushed"
else:
assert "error" not in status, status
assert status["branch"] == "main"
assert status["targetSha"] == git("rev-parse", "origin/main")
assert json.loads(branch_file.read_text())["branch"] == "main"
def test_inherited_git_target_cannot_redirect_an_explicit_install(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
root, linked, home, _base, head, responses, _requests, _git = installation
responses["/repos/fixture/fork/commits/feature%2Fgui"] = (200, head)
monkeypatch.setenv("GIT_DIR", str(root / ".git"))
monkeypatch.setenv("GIT_WORK_TREE", str(root))
status = check_for_updates(install_root=linked, home=home)
assert status["currentBranch"] == "feature/gui"
assert status["behind"] == 0
@pytest.mark.parametrize("mechanism", ["external", "electron-updater", "app-installer", "microsoft-store", "self", None])
def test_source_admission_is_stamp_owned_not_path_owned(installation, mechanism):
from hermes_cli.source_check import check_for_updates
_root, linked, home, _base, head, responses, requests, _git = installation
if mechanism:
(linked / "install-stamp.json").write_text(json.dumps({"updateMechanism": mechanism, "distribution": "nix" if mechanism == "external" else "source"}))
responses["/repos/fixture/fork/commits/feature%2Fgui"] = (200, head)
status = check_for_updates(install_root=linked, home=home)
assert status["supported"] is (mechanism in ("self", None))
assert requests == (["/repos/fixture/fork/commits/feature%2Fgui"]
if status["supported"] else [])
empty = home / "no-source"
empty.mkdir()
(empty / "install-stamp.json").write_text(json.dumps({"updateMechanism": mechanism, "distribution": "nix" if mechanism == "external" else "source"}))
assert check_for_updates(install_root=empty, home=home)["reason"] == "not-a-git-checkout"
def test_embedded_revision_keeps_https_ref_advertisement_recovery(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
_root, _linked, home, _base, head, responses, _requests, _git = installation
monkeypatch.setenv("HERMES_REVISION", head)
monkeypatch.setattr("hermes_cli.config.get_project_root", lambda: home)
monkeypatch.setattr("hermes_cli.config.detect_install_method", lambda root: "nix")
responses[MAIN_CHANNEL] = (200, source_channel("main", "NousResearch/hermes-agent"))
probes = []
def advertise(args, **kwargs):
probes.append((args, kwargs))
return subprocess.CompletedProcess(args, 0, head + "\trefs/heads/main\n", "")
# The remote probe runs owned and bounded (stdin is always DEVNULL there).
monkeypatch.setattr("hermes_cli._subprocess_compat.bounded_probe_run", advertise)
assert check_for_updates(home=home)["behind"] == 0
assert len(probes) == 1
assert "ls-remote" in probes[0][0]
assert "https://github.com/NousResearch/hermes-agent.git" in probes[0][0]
assert probes[0][1]["owned"] is True
assert probes[0][1]["env"]["GIT_TERMINAL_PROMPT"] == "0"
def test_malformed_optional_changelog_and_cache_do_not_hide_the_update(installation):
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, head, responses, requests, _git = installation
cache = home / "cache.json"
responses["/repos/fixture/fork/commits/main"] = (200, "a" * 40)
responses[f"/repos/fixture/fork/compare/{head}...{'a' * 40}"] = (200, {
"ahead_by": 2, "commits": [{"sha": "b" * 40, "commit": 42}],
})
status = check_for_updates(install_root=root, home=home, cache_path=cache)
assert status["behind"] == 2
assert status["updateAvailable"] is True
data = json.loads(cache.read_text())
data["status"] = None
cache.write_text(json.dumps(data))
assert check_for_updates(install_root=root, home=home, cache_path=cache)["behind"] == 2
assert requests == ["/repos/fixture/fork/commits/main",
f"/repos/fixture/fork/compare/{head}...{'a' * 40}"] * 2
@pytest.mark.parametrize("repository,heals", [("NousResearch/hermes-agent", True), ("fixture/fork", False)])
def test_official_ssh_healing_uses_public_https_without_retargeting_forks(installation, monkeypatch, repository, heals):
from hermes_cli.source_check import check_for_updates
from hermes_cli.update_channel import set_install_channel
root, linked, home, _base, head, responses, _requests, git = installation
git("remote", "set-url", "origin", f"git@github.com:{repository}.git")
git("config", f"url.{root.as_uri()}.insteadOf", "https://github.com/NousResearch/hermes-agent.git")
# The branch heal is a main-channel concern; an official checkout's default is stable.
set_install_channel("main", linked)
monkeypatch.setenv("GIT_SSH_COMMAND", "false")
branch_file = home / "desktop-update.json"
branch_file.write_text(json.dumps({"branch": "deleted"}))
responses[f"/repos/{repository}/commits/main"] = (200, head)
status = check_for_updates(install_root=linked, home=home, branch_config_path=branch_file)
assert status["branch"] == ("main" if heals else "deleted")
assert json.loads(branch_file.read_text())["branch"] == status["branch"]
if heals:
assert status["behind"] == 0
else:
assert status["error"] == "fetch-failed"
def github_authorizations(installation, path):
"""Authorization header of each api.github.com call to ``path``, in order."""
return [auth for seen, auth in zip(installation[6], installation.authorizations) if seen == path]
def test_github_calls_carry_the_configured_token_and_retry_anonymously_on_401(installation, monkeypatch):
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, head, responses, _requests, _git = installation
url = "/repos/fixture/fork/commits/main"
responses[url] = (200, head)
monkeypatch.setenv("GITHUB_TOKEN", " ghp_fixture ")
assert check_for_updates(install_root=root, home=home)["behind"] == 0
assert github_authorizations(installation, url) == ["Bearer ghp_fixture"]
# A rejected token is not a failed check: the same request is retried without it.
responses[url] = lambda handler: (401, {}) if handler.headers.get("Authorization") else (200, head)
assert check_for_updates(install_root=root, home=home, force=True)["behind"] == 0
assert github_authorizations(installation, url)[-2:] == ["Bearer ghp_fixture", None]
def test_branch_tip_failure_names_the_cause(installation):
from hermes_cli.source_check import check_for_updates
root, _linked, home, _base, _head, responses, _requests, _git = installation
url = "/repos/fixture/fork/commits/main"
responses[url] = (403, {})
installation.response_headers[url] = {"X-RateLimit-Remaining": "0", "X-RateLimit-Reset": "4102444800"}
status = check_for_updates(install_root=root, home=home)
assert status["error"] == "fetch-failed"
assert "rate limit" in status["message"] and "GITHUB_TOKEN" in status["message"]
assert github_authorizations(installation, url) == [None]
installation.response_headers.pop(url)
responses[url] = (503, {})
status = check_for_updates(install_root=root, home=home, force=True)
assert status["error"] == "fetch-failed"
assert "HTTP 503" in status["message"]
@pytest.mark.parametrize("on,release,rollback", [("head", "base", True), ("base", "head", False)])
def test_stable_release_the_checkout_already_contains_is_a_rollback(installation, tmp_path, on, release, rollback):
"""A release HEAD contains is a move back (#137714); an older checkout is a real update."""
from hermes_cli.source_check import check_for_updates
root, _linked, home, base, head, responses, _requests, git = installation
shas = {"base": base, "head": head}
bare = tmp_path / "origin.git"
git("clone", "-q", "--bare", str(root), str(bare), cwd=tmp_path)
git("tag", "v1.2.3", shas[release], cwd=bare)
git("remote", "set-url", "origin", str(bare))
git("checkout", "-q", "--detach", shas[on])
api = "/repos/NousResearch/hermes-agent"
responses[f"{api}/releases/latest"] = (200, {"draft": False, "prerelease": False, "tag_name": "v1.2.3"})
responses[f"{api}/commits/v1.2.3"] = (200, {"sha": shas[release]})
status = check_for_updates(install_root=root, home=home, channel="stable", force=True)
assert status.get("targetSha") == shas[release], status
assert status["updateAvailable"] is True
assert status["rollback"] is rollback
@pytest.mark.parametrize("ledgered", [True, False])
@pytest.mark.parametrize("divergent", [True, False], ids=["beside-history", "in-history"])
def test_stable_release_the_updater_refuses_is_held_not_offered(
installation, tmp_path, monkeypatch, capsys, ledgered, divergent):
"""A pre-runtime release is held while a store has runtime history (#139099), even when the
checkout already contains it: neither an update offer nor a rollback promise is valid."""
from hermes_cli import _startup_fast
from hermes_cli.source_check import check_for_updates
from tests.hermes_cli.test_update_downgrade_guard import _ledgered_store
root, _linked, home, base, _head, responses, requests, git = installation
sibling = tmp_path / "sibling"
monkeypatch.setattr("hermes_cli.backup._sibling_profile_homes", lambda h: [("sibling", sibling)])
git("checkout", "-q", "-b", "release-line", base)
(root / "hermes_state_common.py").write_text("SCHEMA_SQL = 'CREATE TABLE IF NOT EXISTS sessions (id)'\n")
git("add", "hermes_state_common.py")
git("commit", "-q", "-m", "release from the older line")
release = git("rev-parse", "HEAD")
git("checkout", "-q", "main")
if not divergent:
git("merge", "--no-ff", "-qm", "release on main's history", "release-line")
(root / "hermes_state_common.py").write_text("SCHEMA_SQL = 'CREATE TABLE IF NOT EXISTS session_admissions (seq)'\n")
git("add", "hermes_state_common.py")
git("commit", "-q", "-m", "gateway runtime")
bare = tmp_path / "origin.git"
git("clone", "-q", "--bare", str(root), str(bare), cwd=tmp_path)
git("tag", "v1.2.3", release, cwd=bare)
git("remote", "set-url", "origin", str(bare))
git("checkout", "-q", "main")
if ledgered:
_ledgered_store(sibling)
api = "/repos/NousResearch/hermes-agent"
responses[f"{api}/releases/latest"] = (200, {"draft": False, "prerelease": False, "tag_name": "v1.2.3"})
responses[f"{api}/commits/v1.2.3"] = (200, {"sha": release})
status = check_for_updates(install_root=root, home=home, channel="stable", force=True)
assert status.get("targetSha") == release, status
assert status["updateAvailable"] is not ledgered
assert status.get("held") == ("downgrade" if ledgered else None)
held_status = status
if not ledgered:
# The first runtime turn lands after an offer was cached: the next passive check holds it.
_ledgered_store(sibling)
held_status = check_for_updates(install_root=root, home=home, channel="stable")
assert held_status["updateAvailable"] is False and held_status.get("held") == "downgrade", held_status
# --version consumes this status too, and checks rollback before the behind count.
with monkeypatch.context() as version:
version.setattr("hermes_cli.source_check.check_for_updates", lambda **kw: held_status)
_startup_fast.print_fast_version_info()
assert "moves back to it" not in capsys.readouterr().out
assert held_status["rollback"] is False
# Removing the only ledgered profile clears a cached hold without re-resolving the release.
shutil.rmtree(sibling)
seen = list(requests)
allowed = check_for_updates(install_root=root, home=home, channel="stable")
assert allowed["updateAvailable"] is True and allowed["behind"] == -1, allowed
assert allowed["rollback"] is not divergent
assert "held" not in allowed and allowed["fetchedAt"] == status["fetchedAt"]
assert requests == seen
@pytest.mark.parametrize("ledgered", [True, False])
def test_an_unfetched_release_is_judged_from_github(installation, tmp_path, monkeypatch, ledgered):
"""The usual install tracks only ``main``, so a release cut beside it is absent until `hermes
update` fetches it, and a local probe proves nothing. The check reads the release's state modules
from GitHub instead, so it still holds what the update would refuse (#140215 review)."""
from hermes_cli.source_check import check_for_updates
from tests.hermes_cli.test_update_downgrade_guard import _ledgered_store
root, _linked, home, base, _head, responses, requests, git = installation
monkeypatch.setattr("hermes_cli.backup._sibling_profile_homes", lambda h: [])
# The release lives on origin only: cut in a scratch clone, pushed there, never fetched here.
bare, cut = tmp_path / "origin.git", tmp_path / "cut"
git("clone", "-q", "--bare", str(root), str(bare), cwd=tmp_path)
git("clone", "-q", "--no-local", str(bare), str(cut), cwd=tmp_path)
git("checkout", "-q", "-b", "release-line", base, cwd=cut)
git("commit", "-q", "--allow-empty", "-m", "release from the older line", cwd=cut)
release = git("rev-parse", "HEAD", cwd=cut)
git("tag", "v1.2.3", release, cwd=cut)
git("push", "-q", "origin", "v1.2.3", cwd=cut)
git("remote", "set-url", "origin", str(bare))
assert subprocess.run(["git", "cat-file", "-e", f"{release}^{{commit}}"], cwd=root,
stderr=subprocess.DEVNULL, check=False).returncode != 0
api = "/repos/NousResearch/hermes-agent"
responses[f"{api}/releases/latest"] = (200, {"draft": False, "prerelease": False, "tag_name": "v1.2.3"})
responses[f"{api}/commits/v1.2.3"] = (200, {"sha": release})
responses[f"{api}/compare/{git('rev-parse', 'HEAD')}...{release}"] = (200, {"status": "diverged"})
responses[f"{api}/git/trees/{release}"] = (200, {"truncated": False, "tree": [
{"path": "hermes_state.py", "type": "blob"}, {"path": "hermes_state_common.py", "type": "blob"},
{"path": "run_agent.py", "type": "blob"}]})
responses[f"/NousResearch/hermes-agent/{release}/hermes_state.py"] = (200, "from hermes_state_common import *\n")
responses[f"/NousResearch/hermes-agent/{release}/hermes_state_common.py"] = (
200, "SCHEMA_SQL = 'CREATE TABLE IF NOT EXISTS sessions (id)'\n")
if ledgered:
_ledgered_store(home)
status = check_for_updates(install_root=root, home=home, channel="stable", force=True)
assert status.get("targetSha") == release, status
assert status["updateAvailable"] is not ledgered
assert status.get("held") == ("downgrade" if ledgered else None)
# Only a store with runtime history pays for the lookup, and a release tree is read once.
trees = [p for p in requests if "/git/trees/" in p]
assert len(trees) == int(ledgered)
if ledgered:
check_for_updates(install_root=root, home=home, channel="stable", force=True)
assert len([p for p in requests if "/git/trees/" in p]) == 1
@pytest.mark.parametrize("blocked", ["tree", "modules"])
def test_runtime_lookup_has_one_deadline_with_bounded_parallel_reads(installation, monkeypatch, blocked):
from hermes_cli import source_check
_root, _linked, home, _base, sha, responses, _requests, _git = installation
tree = f"/repos/fixture/fork/git/trees/{sha}"
paths = [f"hermes_state_{i}.py" for i in range(12)]
responses[tree] = (200, {"tree": [{"path": path, "type": "blob"} for path in paths]})
release = threading.Event()
overlapped = threading.Event()
finished = threading.Event()
lock = threading.Lock()
active = 0
peak = 0
verdicts = []
def stalled(_handler):
nonlocal active, peak
with lock:
active += 1
peak = max(peak, active)
if active == 4:
overlapped.set()
try:
release.wait(20)
return 200, "SCHEMA_SQL = 'old schema'"
finally:
with lock:
active -= 1
if blocked == "tree":
responses[tree] = stalled
for path in paths:
responses[f"/fixture/fork/{sha}/{path}"] = stalled
monkeypatch.setattr(source_check, "_RUNTIME_LOOKUP_SECONDS", 3.0)
def check():
try:
verdicts.append(source_check._github_predates_runtime("fixture/fork", sha, home / "runtime.json"))
finally:
finished.set()
checker = threading.Thread(target=check, daemon=True)
checker.start()
try:
if blocked == "modules":
assert overlapped.wait(5), "independent schema reads must overlap"
assert finished.wait(5), "a slow successful response must not extend the whole lookup deadline"
assert verdicts == [None]
assert peak <= 4
finally:
release.set()
checker.join(5)
@pytest.mark.parametrize("runtime", [True, False])
def test_a_release_with_the_state_store_inside_the_package_is_judged_by_its_package_modules(
installation, runtime):
"""After the state store moves under ``hermes_agent/`` a root compat shell stays behind. The
verdict must come from the package's modules, which a top-level tree listing does not show."""
from hermes_cli import source_check
from hermes_state_common import SCHEMA_SQL
_root, _linked, home, _base, sha, responses, requests, _git = installation
shell, store = "hermes_state.py", "hermes_agent/hermes_state/common.py"
trees = "/repos/fixture/fork/git/trees"
# A tree listing is one directory, as GitHub answers without ``recursive``; a release's full
# recursive listing is several MiB, beyond what the reader takes in one response.
responses[f"{trees}/{sha}"] = (200, {"truncated": False, "tree": [
{"path": shell, "type": "blob"}, {"path": "hermes_agent", "type": "tree", "sha": "t-pkg"},
{"path": "pad", "type": "blob", "size": 3 * 1024 * 1024}]})
responses[f"{trees}/t-pkg"] = (200, {"tree": [{"path": "hermes_state", "type": "tree", "sha": "t-state"}]})
responses[f"{trees}/t-state"] = (200, {"tree": [{"path": "common.py", "type": "blob"}]})
responses[f"/fixture/fork/{sha}/{shell}"] = (200, "from hermes_agent.compat import finder\n")
responses[f"/fixture/fork/{sha}/{store}"] = (200, SCHEMA_SQL if runtime else "SCHEMA_SQL = 'old schema'")
assert source_check._github_predates_runtime("fixture/fork", sha, home / "runtime.json") is (not runtime)
assert not any("recursive" in path for path in requests)
@pytest.mark.parametrize("failure", ["tree", "module"])
@pytest.mark.parametrize("runtime", [True, False])
def test_unknown_runtime_verdict_expires_but_definite_verdict_does_not(installation, monkeypatch, failure, runtime):
from hermes_cli import source_check
_root, _linked, home, _base, sha, responses, requests, _git = installation
clock = [1000000.0]
monkeypatch.setattr(source_check.time, "time", lambda: clock[0])
tree = f"/repos/fixture/fork/git/trees/{sha}"
module = f"/fixture/fork/{sha}/hermes_state_common.py"
responses[tree] = (200, {"tree": [{"path": "hermes_state_common.py", "type": "blob"}]})
from hermes_state_common import SCHEMA_SQL
responses[module] = (200, SCHEMA_SQL if runtime else "SCHEMA_SQL = 'old schema'")
failed_path = tree if failure == "tree" else module
good = responses[failed_path]
responses[failed_path] = (503, {})
check = lambda: source_check._github_predates_runtime("fixture/fork", sha, home / "runtime.json")
assert check() is None
seen = list(requests)
responses[failed_path] = good
assert check() is None
assert requests == seen, "cache hits must not retry an unreachable GitHub"
clock[0] += source_check._UPDATE_CHECK_FAILURE_CACHE_SECONDS + 1
assert check() is not runtime
seen = list(requests)
clock[0] += 10 * source_check._UPDATE_CHECK_CACHE_SECONDS
assert check() is not runtime
assert requests == seen