hermes-agent/tests/hermes_cli/test_plugin_private_repo_auth.py
ethernet 1e76db800c refactor(cli): split plugins_cmd.py into topical siblings
plugins_cmd.py had grown to 2,858 lines, past the ~2,000-line gate. Move
each verb family into a plugins_cmd_<topic>.py sibling: git (install
metadata + git plumbing), install, update (plus adopt / trust-update-url /
check-updates), remove, capabilities, toggle (composite UI) and listing.
The facade keeps the shared primitives, enable/disable selection,
discovery and the dispatch table, and re-exports the names other modules,
tests and the old-updater surface import (978 lines now).

Siblings never import the facade at module level; they read facade names
through _pc() at call time, so monkeypatching plugins_cmd.<name> still
intercepts calls made from a sibling. No behaviour change. Tests that
imported three sibling-only helpers now import them from the defining
module, and two subprocess.run patches target subprocess directly.
2026-09-24 11:50:29 -04:00

297 lines
15 KiB
Python

"""Private-repo plugin installs attach the user's stored HTTPS credential to git without persisting it.
Public-repo installs (the catalog default) must attempt the clone *anonymously* first and only fall
back to the stored credential when the server actually demands one — regression for #114526 where
injecting ``Authorization: basic`` against a public GitHub URL breaks the anonymous clone path
(GitHub rejects the Basic header on a public clone URL and git falls back to a Username prompt
that ``GIT_TERMINAL_PROMPT=0`` blocks with "could not read Username ... terminal prompts disabled").
"""
import base64
import subprocess
import sys
import pytest
from hermes_cli import git_credentials, plugins_cmd
from hermes_cli._subprocess_compat import noninteractive_git_env
def _auth_headers_for(env: dict, origin: str) -> list[str]:
"""``Authorization:`` extraheaders bound to *origin* in a git env block, in declared order."""
count = int(env.get("GIT_CONFIG_COUNT", "0") or 0)
out = []
for i in range(count):
if env.get(f"GIT_CONFIG_KEY_{i}") == f"http.{origin}/.extraheader":
out.append(env[f"GIT_CONFIG_VALUE_{i}"])
return out
def _seed_bare_upstream(tmp_path) -> None:
"""Spin up a local bare repo with one commit so anonymous clones can succeed when the test
redirects a public URL at it."""
upstream = tmp_path / "upstream.git"
subprocess.run(["git", "init", "-q", "--bare", str(upstream)], check=True)
work = tmp_path / "work"
subprocess.run(["git", "clone", "-q", str(upstream), str(work)], check=True)
(work / "plugin.yaml").write_text("name: probe\ndescription: d\nversion: '1'\n", encoding="utf-8")
subprocess.run(["git", "-C", str(work), "-c", "user.name=t", "-c", "user.email=t@t", "add", "."], check=True)
subprocess.run(["git", "-C", str(work), "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", "i"], check=True)
subprocess.run(["git", "-C", str(work), "push", "-q", "origin", "HEAD"], check=True)
def test_private_clone_falls_back_to_auth_after_credential_required_error(tmp_path, monkeypatch):
"""A clone from a remote that rejects anonymous access must (1) try anonymous first and
only (2) retry with the stored credential when the server asks for one. The installed
checkout carries no trace of the credential either way. (#114526 invariant for private remotes.)"""
_seed_bare_upstream(tmp_path)
clone_calls: list[list[str]] = []
real_run = subprocess.run
target_url = "https://git.example.test/acme/probe.git"
def spy_run(argv, *a, **kw):
env = kw.get("env") or {}
if "clone" in argv:
headers = _auth_headers_for(env, "https://git.example.test")
clone_calls.append(headers)
if len(clone_calls) == 1:
# First attempt is anonymous; the private remote refuses with the canonical
# "could not read Username ... terminal prompts disabled" message.
return subprocess.CompletedProcess(
argv, returncode=128, stdout="",
stderr="fatal: could not read Username for 'https://git.example.test': "
"terminal prompts disabled\n",
)
argv = [a_ if a_ != target_url else str(tmp_path / "upstream.git") for a_ in argv]
return real_run(argv, *a, **kw)
monkeypatch.setattr(subprocess, "run", spy_run)
monkeypatch.setattr(git_credentials, "resolve_git_basic_auth", lambda url: ("alice", "s3cret"))
dest = tmp_path / "clone"
plugins_cmd._clone_plugin_repo(dest, target_url, None)
expected = base64.b64encode(b"alice:s3cret").decode()
assert len(clone_calls) == 2, f"expected anonymous + auth fallback, got {len(clone_calls)} clone attempts"
assert clone_calls[0] == [], "first (anonymous) clone attempt must not carry an Authorization header"
assert clone_calls[1] == [f"Authorization: basic {expected}"], "fallback clone must inject the stored credential"
assert "s3cret" not in (dest / ".git" / "config").read_text(encoding="utf-8")
assert expected not in (dest / ".git" / "config").read_text(encoding="utf-8")
# Non-HTTPS URLs get no header; the hardened base env is otherwise untouched.
base = noninteractive_git_env()
assert git_credentials.with_git_auth(base, "[email protected]:acme/probe.git") == dict(base)
def test_public_clone_attempts_anonymously_when_credential_resolves(tmp_path, monkeypatch):
"""A public repo whose URL would resolve a stored GitHub credential via ``gh auth login`` must
still be cloned anonymously: the Basic header would otherwise break the public clone path
(see #114526). The fallback runs only when the server actually demands a credential."""
_seed_bare_upstream(tmp_path)
clone_calls: list[list[str]] = []
real_run = subprocess.run
target_url = "https://github.com/robbyczgw-cla/hermes-web-search-plus.git"
origin = "https://github.com"
def spy_run(argv, *a, **kw):
env = kw.get("env") or {}
if "clone" in argv:
clone_calls.append(_auth_headers_for(env, origin))
argv = [a_ if a_ != target_url else str(tmp_path / "upstream.git") for a_ in argv]
return real_run(argv, *a, **kw)
monkeypatch.setattr(subprocess, "run", spy_run)
# Simulate exactly the failing user state from #114526: ``gh auth login`` has populated the
# credential resolver, so for any https://github.com URL it returns a non-None basic auth pair.
monkeypatch.setattr(git_credentials, "resolve_git_basic_auth",
lambda url: ("x-access-token", "ghp_fake") if "github.com" in url else None)
dest = tmp_path / "clone"
plugins_cmd._clone_plugin_repo(dest, target_url, None)
assert len(clone_calls) == 1, (
f"public repo must clone in a single anonymous attempt, got {len(clone_calls)}: {clone_calls}"
)
assert clone_calls[0] == [], "public repo clone must not inject an Authorization header"
# No fallback ever ran, so the stored token must not have leaked through any extraheader.
assert "ghp_fake" not in str(clone_calls)
@pytest.mark.parametrize("verb", ["fetch", "pull"])
@pytest.mark.parametrize("outcome", ["ok", "refused", "not_found"])
def test_ref_fetch_and_update_pull_attach_credential_only_after_anonymous_refusal(
tmp_path, monkeypatch, verb, outcome):
"""The pinned-ref fetch (``--ref`` install) and ``hermes plugins update``'s pull are the
clone's siblings: with a stored GitHub credential resolvable they still run anonymously
against a public remote, attach the credential only after the remote refuses, and surface a
failure that is not about credentials (missing repo, bad commit, network) as-is — the stored
credential is then never even resolved, let alone sent."""
_seed_bare_upstream(tmp_path)
repo = tmp_path / "checkout"
subprocess.run(["git", "clone", "-q", str(tmp_path / "upstream.git"), str(repo)], check=True)
revision = subprocess.run(["git", "-C", str(repo), "rev-parse", "HEAD"], capture_output=True,
text=True, check=True).stdout.strip()
public_url = "https://github.com/acme/public-plugin.git"
subprocess.run(["git", "-C", str(repo), "remote", "set-url", "origin", public_url], check=True)
attempts: list[list[str]] = []
real_run = subprocess.run
def spy_run(argv, *a, **kw):
if verb not in argv:
return real_run(argv, *a, **kw)
attempts.append(_auth_headers_for(kw.get("env") or {}, "https://github.com"))
if outcome == "refused" and len(attempts) == 1:
return subprocess.CompletedProcess(
argv, 128, stdout="",
stderr="fatal: could not read Username for 'https://github.com': terminal prompts disabled\n")
if outcome == "not_found":
return subprocess.CompletedProcess(
argv, 128, stdout="", stderr=f"fatal: repository '{public_url}/' not found\n")
return subprocess.CompletedProcess(argv, 0, stdout="Already up to date.\n", stderr="")
monkeypatch.setattr(subprocess, "run", spy_run)
if outcome == "not_found":
monkeypatch.setattr(git_credentials, "resolve_git_basic_auth",
lambda url: pytest.fail("credential must not be resolved for a non-credential failure"))
else:
monkeypatch.setattr(git_credentials, "resolve_git_basic_auth", lambda url: ("x-access-token", "ghp_fake"))
if verb == "fetch" and outcome == "not_found":
with pytest.raises(plugins_cmd.PluginOperationError, match="not found"):
plugins_cmd._checkout_exact_revision(repo, "git", revision, source_url=public_url)
elif verb == "fetch":
plugins_cmd._checkout_exact_revision(repo, "git", revision, source_url=public_url)
else:
ok, message = plugins_cmd._git_pull_plugin_dir(repo)
assert ok is (outcome != "not_found"), message
assert ("not found" in message) is (outcome == "not_found")
expected = base64.b64encode(b"x-access-token:ghp_fake").decode()
assert attempts == ([[], [f"Authorization: basic {expected}"]] if outcome == "refused" else [[]])
@pytest.mark.platforms("posix") # POSIX shell askpass stub + local HTTP server
def test_anonymous_attempt_fails_fast_under_inherited_askpass(tmp_path, monkeypatch):
"""With an inherited ``GIT_ASKPASS`` (VS Code terminal, ksshaskpass) the anonymous attempt
against a remote answering 401 must still fail fast with the classifiable "could not read
Username" refusal so the credential fallback fires, instead of handing the prompt to an
askpass helper nobody answers and dying on the timeout with no second attempt."""
import threading
from http.server import BaseHTTPRequestHandler, HTTPServer
class Unauthorized(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(401)
self.send_header("WWW-Authenticate", 'Basic realm="probe"')
self.end_headers()
do_POST = do_GET
def log_message(self, *args):
pass
server = HTTPServer(("127.0.0.1", 0), Unauthorized)
threading.Thread(target=server.serve_forever, daemon=True).start()
try:
url = f"http://127.0.0.1:{server.server_port}/acme/private.git"
askpass = tmp_path / "askpass.sh"
askpass.write_text("#!/bin/sh\nsleep 30\n", encoding="utf-8")
askpass.chmod(0o755)
monkeypatch.setenv("GIT_ASKPASS", str(askpass))
# Plain-http local remote: stand in for the https credential lookup so the fallback's
# second attempt is observable without a TLS fixture.
monkeypatch.setattr(git_credentials, "with_git_auth",
lambda env, u: {**env, "HERMES_TEST_AUTH_ATTACHED": "1"})
attempts: list[dict] = []
real_run = subprocess.run
monkeypatch.setattr(git_credentials.subprocess, "run",
lambda argv, **kw: attempts.append(kw["env"]) or real_run(argv, **kw))
result = git_credentials.run_git_with_credential_fallback(
["git", "clone", url, str(tmp_path / "dest")], url, env=noninteractive_git_env(),
capture_output=True, text=True, timeout=10)
finally:
server.shutdown()
assert result.returncode != 0 and "could not read Username" in result.stderr
assert len(attempts) == 2, "anonymous refusal must be classified and the credential fallback must fire"
assert all("GIT_ASKPASS" not in env for env in attempts)
@pytest.mark.platforms("posix") # POSIX shell stub credential helper
def test_credential_fill_uses_stored_helper_and_never_prompts(tmp_path, monkeypatch):
helper = tmp_path / "helper.sh"
helper.write_text("#!/bin/sh\n[ \"$1\" = get ] && printf 'username=bob\\npassword=pw-from-helper\\n'\n", encoding="utf-8")
helper.chmod(0o755)
gitconfig = tmp_path / "gitconfig"
gitconfig.write_text(f'[credential "https://git.example.test"]\n\thelper = !{helper}\n', encoding="utf-8")
monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(gitconfig))
monkeypatch.setenv("GIT_ASKPASS", "/nonexistent/askpass-must-not-run")
assert git_credentials.resolve_git_basic_auth("https://git.example.test/acme/x.git") == ("bob", "pw-from-helper")
# Unknown host: no helper answers → None quickly, no prompt attempt escaped.
assert git_credentials.resolve_git_basic_auth("https://nothing.example.test/x.git") is None
def _refused(argv):
return subprocess.CompletedProcess(
argv, 128, stdout="",
stderr="fatal: could not read Username for 'https://github.com': terminal prompts disabled\n")
def test_rejected_env_token_falls_back_to_the_next_owned_credential(monkeypatch):
"""An expired GITHUB_TOKEN in .env must not shadow a live ``gh auth login`` (#115257): after
the remote refuses the first credential, the run retries with the next one and stops there."""
monkeypatch.setattr(git_credentials, "iter_git_basic_auth", lambda url: iter([
("GITHUB_TOKEN/GH_TOKEN", ("x-access-token", "ghp_dead")),
("gh auth token", ("x-access-token", "gho_live")),
("git credential helper", ("bob", "never-needed")),
]))
attempts: list[list[str]] = []
def fake_run(argv, **kw):
headers = _auth_headers_for(kw["env"], "https://github.com")
attempts.append(headers)
live = base64.b64encode(b"x-access-token:gho_live").decode()
if headers == [f"Authorization: basic {live}"]:
return subprocess.CompletedProcess(argv, 0, stdout="", stderr="")
return _refused(argv)
monkeypatch.setattr(git_credentials.subprocess, "run", fake_run)
url = "https://github.com/acme/private.git"
result = git_credentials.run_git_with_credential_fallback(
["git", "clone", url, "dest"], url, env=noninteractive_git_env(), capture_output=True, text=True)
dead = base64.b64encode(b"x-access-token:ghp_dead").decode()
live = base64.b64encode(b"x-access-token:gho_live").decode()
assert result.returncode == 0
assert attempts == [[], [f"Authorization: basic {dead}"], [f"Authorization: basic {live}"]]
def test_every_credential_rejected_names_the_dead_env_token(monkeypatch):
"""When GitHub refuses every owned credential the git error gains a hint naming the .env token,
and a failure that stops being about credentials ends the retries without one."""
monkeypatch.setattr(git_credentials, "iter_git_basic_auth", lambda url: iter([
("GITHUB_TOKEN/GH_TOKEN", ("x-access-token", "ghp_dead")),
("gh auth token", ("x-access-token", "gho_dead_too")),
]))
monkeypatch.setattr(git_credentials.subprocess, "run", lambda argv, **kw: _refused(argv))
url = "https://github.com/acme/private.git"
result = git_credentials.run_git_with_credential_fallback(
["git", "clone", url, "dest"], url, env=noninteractive_git_env(), capture_output=True, text=True)
assert result.returncode != 0 and "GITHUB_TOKEN/GH_TOKEN in your .env was rejected" in result.stderr
calls = []
def not_found_once_authed(argv, **kw):
calls.append(kw["env"])
if _auth_headers_for(kw["env"], "https://github.com"):
return subprocess.CompletedProcess(argv, 128, stdout="", stderr=f"fatal: repository '{url}/' not found\n")
return _refused(argv)
monkeypatch.setattr(git_credentials.subprocess, "run", not_found_once_authed)
result = git_credentials.run_git_with_credential_fallback(
["git", "clone", url, "dest"], url, env=noninteractive_git_env(), capture_output=True, text=True)
assert len(calls) == 2 and "not found" in result.stderr and "hint:" not in result.stderr