mcpgawk 0.1.63__tar.gz → 0.1.64__tar.gz

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpgawk
-Version: 0.1.63
+Version: 0.1.64
 Summary: One gateway in front of every MCP server your agents can reach — every call checked against a baseline you approved. Local-first: nothing leaves your machine.
 Project-URL: Homepage, https://mcp.gawk.dev
 Project-URL: Documentation, https://mcp.gawk.dev/docs

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcpgawk"
-version = "0.1.63"
+version = "0.1.64"
 description = "One gateway in front of every MCP server your agents can reach — every call checked against a baseline you approved. Local-first: nothing leaves your machine."
 readme = "README.md"
 requires-python = ">=3.10"

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/src/mcpgawk/cli.py

@@ -1740,7 +1740,7 @@ def _record_sighting(sn, m, *, now: str, collided=frozenset(),
     # load()/save() pair, two concurrent scans each diff against a baseline the other has already
     # replaced, and one server's drift history is silently lost.
     current = drift.build_record(sn, m, measured_at=now)
-    asserted = history.key_for(sn)
+    asserted = history.key_for(sn, target=alias)
     key = history.legacy_key_for(sn) if asserted in collided else asserted
     store = history.load()
     # `migrate_from` carries every key this server could already be recorded under — the legacy
@@ -2301,7 +2301,7 @@ def _dispatch(argv: list[str] | None = None) -> int:
         if new_baselines:
             n = len(new_baselines)
             print(f"\n  ✓ Baseline recorded for {n} server{'s' if n > 1 else ''}: "
-                  f"{', '.join(sorted(new_baselines))}")
+                  f"{', '.join(sorted(display_name(lab, _adhoc_name(lab['name'], entries.get(lab['name']))) for lab in labels if lab['name'] in new_baselines))}")
             print("    From now on a scan reports what CHANGED — the one thing looking at your "
                   "machine today can never tell you.")
         print()
@@ -2355,12 +2355,13 @@ def _dispatch(argv: list[str] | None = None) -> int:
     lead_view = args.track and not (args.full or args.verbose or args.detail)
     for lab in labels:
         name = lab["name"]
-        shown = display_name(lab)     # what a person reads; `name` stays the join key
+        # what a person reads; `name` stays the join key
+        shown = display_name(lab, _adhoc_name(name, entries.get(name)))
         caveats = bool(lab["x-mcpgawk"].get("caveats"))
         any_error = any_error or caveats
         rep = drift_reports.get(name)
         if not lead_view:
-            print("\n" + render_cli(lab, verbose=args.verbose))
+            print("\n" + render_cli(lab, verbose=args.verbose, shown=shown))
             if rep:
                 print(drift.render(shown, rep))
                 _print_accept(drift_keys.get(name))
@@ -2369,7 +2370,7 @@ def _dispatch(argv: list[str] | None = None) -> int:
             print(f"\n  ⛔ {shown} now identifies itself as a DIFFERENT server "
                   f"(was {reidentified[name]}). Its baseline does not carry over — treat it "
                   f"as unreviewed.")
-            print("\n" + render_cli(lab, verbose=False))
+            print("\n" + render_cli(lab, verbose=False, shown=shown))
         elif rep:
             # The change IS the report. What it gained/lost is quoted in the drift block; the
             # rest of the surface — unchanged since approval — stays behind --full.
@@ -2378,9 +2379,9 @@ def _dispatch(argv: list[str] | None = None) -> int:
         elif name in new_baselines:
             print(f"\n  ✓ {shown}: first scan — baseline recorded. Scan it again later and "
                   f"mcpgawk tells you if anything changed. What it can do:")
-            print("\n" + render_cli(lab, verbose=False))
+            print("\n" + render_cli(lab, verbose=False, shown=shown))
         elif caveats:
-            print("\n" + render_cli(lab, verbose=False))   # a failure is never summarised away
+            print("\n" + render_cli(lab, verbose=False, shown=shown))   # a failure is never summarised away
         else:
             n = lab["x-mcpgawk"]["tool_count"]
             signals = lab["x-mcpgawk"].get("bounded_signals") or []
@@ -2399,7 +2400,7 @@ def _dispatch(argv: list[str] | None = None) -> int:
                 print(f"\n  ⚠ {shown}: no change since your baseline, but it was never clean — "
                       f"{len(live)} live finding{'s' if len(live) != 1 else ''} still "
                       f"{'stand' if len(live) != 1 else 'stands'}:")
-                print("\n" + render_cli(lab, verbose=False))
+                print("\n" + render_cli(lab, verbose=False, shown=shown))
             else:
                 muted_note = f", {muted_n} finding{'s' if muted_n != 1 else ''} muted by you" \
                     if muted_n else ""

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/src/mcpgawk/fleet.py

@@ -121,6 +121,8 @@ def state_of(label: dict[str, Any]) -> tuple[str, str]:
             # so anything that later appears at that path is executed without being asked about
             # again. That is a standing invitation, not a dead link.
             return "UNREACHABLE", "its program no longer exists — still configured, so anything at that path would run"
+        if x.get("error_kind") == "host-not-found":
+            return "UNREACHABLE", "its host name does not resolve — check the spelling, DNS or VPN"
         if x.get("error_kind") == "nothing-listening":
             # The loopback twin of command-missing, and the worse one: a missing program needs a
             # file planted at a known path before anything runs; a free loopback port needs only a

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/src/mcpgawk/history.py

@@ -615,6 +615,8 @@ def record(key: str, rec: dict[str, Any], path: str | None = None,
     # the baseline this function returns. Masking only on the way to disk would diff a raw `current`
     # against a masked baseline and report a rename on every scan of a credentialled server.
     redact_record(rec)
+    if alias and _is_adhoc_target(alias):
+        alias = adhoc_target(alias)      # at the write, so no caller can store a key in a URL
     with locked(path):
         store = load(path)
         adopted = _migrate(store, key, migrate_from, alias)
@@ -849,7 +851,10 @@ def resolve_all(store: dict[str, Any], wanted: str) -> list[str]:
         # `cli-stdio` on a single record would otherwise single-match, and `approve cli-stdio`
         # would move a baseline the operator never named.
         return []
-    return [key for key, entry in servers.items() if wanted in (entry.get("aliases") or [])]
+    # An ad-hoc alias is stored masked (`adhoc_target`); the person may paste the raw URL.
+    names = {wanted, adhoc_target(wanted)} if _is_adhoc_target(wanted) else {wanted}
+    return [key for key, entry in servers.items()
+            if names & set(entry.get("aliases") or [])]
 
 
 def identity_change(store: dict[str, Any], key: str, alias: str | None) -> str | None:
@@ -883,6 +888,22 @@ def _is_adhoc_target(alias: str) -> bool:
     return "/" in head or (head in _LAUNCHERS and len(alias.split()) > 1)
 
 
+def adhoc_target(target: str) -> str:
+    """The form an AD-HOC target (a URL or command you typed) is stored and printed in.
+
+    Credential shapes masked, everything else kept: this is an identity, so the host, path, package
+    and version must survive (the diagnostics masker `report_redact.redact_command` drops them). A
+    raw `?apiKey=` URL used to land verbatim in history.json as an alias, and now also forms the key
+    of a nameless server, which the drift block prints as the `approve` command (2026-09-26)."""
+    from .redact import redact, redact_url, redact_urls_in_text
+    if "://" in target and " " not in target.strip():
+        return redact(redact_url(target) or target) or target
+    # A COMMAND gets only its URLs masked (`mcp-remote <url?key=…>`, the credential shape seen in
+    # launch lines). `redact()` reads `name@version` as an address: `npx -y a@1.0.0` and
+    # `npx -y b@2.0.0` both became `npx -y [REDACTED]`, one key for two servers again.
+    return redact_urls_in_text(target) or target
+
+
 def display_name(store: dict[str, Any], key: str) -> str:
     """What the USER calls this server — the name in their own config, not our internal key.
 
@@ -1065,6 +1086,12 @@ def _may_adopt(record: dict[str, Any], old_key: str, alias: str | None) -> bool:
     genuinely conflated pre-upgrade record does (every `--track` scan records `alias=sn.name`); a
     stranger's live record does not.
     """
+    if old_key.split(":", 1)[-1] in SYNTHETIC_NAMES:
+        # `http:cli-http` was the key of EVERY nameless ad-hoc target, so one record can hold
+        # several servers' history (bureau's tools "removed", inference's "added", 2026-09-26).
+        # Reclaim it only when this target is the one server it ever answered to.
+        names = {adhoc_target(a) for a in (record.get("aliases") or []) if isinstance(a, str)}
+        return bool(alias) and names == {alias}
     if not old_key.startswith("mcp:"):
         return True
     return bool(alias) and alias in (record.get("aliases") or [])
@@ -1079,7 +1106,7 @@ def should_record(snap: ServerSnapshot) -> bool:
     return not snap.error
 
 
-def key_for(snap: ServerSnapshot) -> str:
+def key_for(snap: ServerSnapshot, target: str | None = None) -> str:
     """Stable identity for a server across config edits.
 
     Prefers what the server asserts about itself in `initialize` (`serverInfo.name`), so renaming an
@@ -1103,6 +1130,12 @@ def key_for(snap: ServerSnapshot) -> str:
         # A nameless server already keys by its CONFIG name (`transport:name`), which is distinct
         # per entry — the conflation is only possible under a shared asserted name.
         return f"{key}#{snap.credential_fingerprint}" if snap.credential_fingerprint else key
+    if target and snap.name in SYNTHETIC_NAMES:
+        # A NAMELESS AD-HOC TARGET is keyed by what was typed. Its label is a placeholder shared by
+        # every `--http` (or `--stdio`) scan, so `transport:name` put every such server on ONE record
+        # and the second reported the first's tools as drift. Every server on the 2026-07-28
+        # revision is nameless: `server/discover` carries no serverInfo (probe._snapshot).
+        return f"{snap.transport}:{adhoc_target(target)}"
     return legacy_key_for(snap)
 
 

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/src/mcpgawk/label.py

@@ -630,7 +630,7 @@ def lead_concern(labels: list[dict[str, Any]]) -> tuple[str, str] | None:
     return ranked[0][3], ranked[0][4]
 
 
-def display_name(label: dict[str, Any]) -> str:
+def display_name(label: dict[str, Any], target: str | None = None) -> str:
     """The name a PERSON reads for this server. An ad-hoc scan is labelled `cli-stdio` / `cli-http`
     for the run, and that label is deliberately never an identity (history.SYNTHETIC_NAMES), so the
     report showed a word `approve` refuses. Where the server asserts its own name, show that: it is
@@ -642,6 +642,11 @@ def display_name(label: dict[str, Any]) -> str:
         asserted = (label.get("serverInfo") or {}).get("name")
         if isinstance(asserted, str) and asserted.strip():
             return asserted.strip()
+        if target:
+            # NAMELESS (every 2026-07-28 server is: `server/discover` has no serverInfo). Show what
+            # was typed, masked as the store keys it, or two such servers both read `cli-http`.
+            from .history import adhoc_target
+            return adhoc_target(target)
     return name
 
 
@@ -689,7 +694,7 @@ def _tool_list(tools: list[dict[str, Any]], n: int, visible_only: bool = False)
     return out
 
 
-def render_cli(label: dict[str, Any], verbose: bool = False) -> str:
+def render_cli(label: dict[str, Any], verbose: bool = False, shown: str | None = None) -> str:
     x = label["x-mcpgawk"]
     ts = x["trust_surface"]
     tools = x["tools"]
@@ -708,7 +713,7 @@ def render_cli(label: dict[str, Any], verbose: bool = False) -> str:
     failed = nar["state"] in ("unreachable", "auth-required")
     has_dispatch = nar["dispatch"]
 
-    lines = [f"● {display_name(label)}   [{label['transport']}]   {verdict}"]
+    lines = [f"● {shown or display_name(label)}   [{label['transport']}]   {verdict}"]
 
     if failed:
         detail = nar["failure"]["detail"]
@@ -731,6 +736,10 @@ def render_cli(label: dict[str, Any], verbose: bool = False) -> str:
                          "remove this entry:")
             lines.append("      until then, any process that binds the port answers as this server "
                          "to every client that trusts the name.")
+        elif x.get("error_kind") == "host-not-found":
+            # Nothing answered, so nothing can have been "a docs page": the name itself is the issue.
+            lines.append("      Check the host name's spelling. If it is right, your network, DNS or a")
+            lines.append("      company VPN (an internal host resolves only on it) is the next place to look.")
         elif x.get("error_kind") == "server-failed":
             # It launched and printed a reason (already in `detail` above). Asking whether the URL
             # is really an MCP endpoint would be absurd here — there is no URL, and the server ran.

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/src/mcpgawk/probe.py

@@ -426,11 +426,34 @@ def _kind_of(exc: BaseException, status: int | None = None, transport: str | Non
         if isinstance(exc, (FileNotFoundError, PermissionError)):
             return "command-missing"
         return "server-failed"
+    if _host_not_found(exc):
+        return "host-not-found"
     if _connect_failed(exc):
         return "connect-failed"
     return "unreachable"
 
 
+def _host_not_found(exc: BaseException) -> bool:
+    """Did the host NAME fail to resolve? A `socket.gaierror` in the cause chain, by type: the SDK
+    raises httpx2.ConnectError <- httpcore2.ConnectError <- gaierror (measured 2026-09-26), the same
+    outer type as a refused connection. Nothing was contacted, so "no MCP endpoint found" and the
+    docs-URL hint were guesses about a server nobody reached (docfork, sweep 2026-09-25)."""
+    import socket
+    seen: set[int] = set()
+
+    def _walk(e: BaseException | None) -> bool:
+        if e is None or id(e) in seen:
+            return False
+        seen.add(id(e))
+        if isinstance(e, socket.gaierror):
+            return True
+        if isinstance(e, BaseExceptionGroup) and any(_walk(sub) for sub in e.exceptions):
+            return True
+        return _walk(e.__cause__) or _walk(e.__context__)
+
+    return _walk(exc)
+
+
 def _connect_failed(exc: BaseException) -> bool:
     """Did the connection never get made — nothing accepted it? By type, as above: a
     `ConnectionRefusedError` anywhere in the cause chain (anyio folds several into an
@@ -756,6 +779,10 @@ def _aggregate_failure(name: str, declared: str, attempts: list[tuple[str, Serve
         # trusts the name. No planted file, no privilege, a free port. A dangling COMMAND at least
         # needs a file written at a known path; this needs nothing. Named so the row can say it.
         kind = "nothing-listening"
+    elif kinds == {"host-not-found"}:
+        # Every attempt failed to resolve the name. One host is tried, so a mix means something
+        # did answer, and the rules above decide.
+        kind = "host-not-found"
     else:
         kind = "unreachable"
 
@@ -804,6 +831,10 @@ def _aggregate_failure(name: str, declared: str, attempts: list[tuple[str, Serve
         where = urlsplit(url or "").netloc or "its loopback address"
         head = (f"nothing is listening on {where} — every attempt was refused. The entry is still "
                 f"configured, so whatever binds that port next answers as this server")
+    elif kind == "host-not-found":
+        from urllib.parse import urlsplit
+        where = urlsplit(url or "").hostname or "its host"
+        head = f"the host name {where} does not resolve — nothing was contacted"
     else:
         head = (f"no MCP endpoint found — tried {len(attempts)} transport/path permutation"
                 f"{'s' if len(attempts) != 1 else ''}")

mcpgawk-0.1.64/tests/test_a_host_that_does_not_resolve_says_so.py

@@ -0,0 +1,81 @@
+"""A URL whose host name does not resolve is a typo, a DNS problem or a missing VPN — say that.
+
+Sweep of unseen servers, 2026-09-25 (docfork): every attempt failed with
+`ConnectError: [Errno 8] nodename nor servname provided`, and the report headed it "no MCP
+endpoint found" with the catch-all hint "A docs / repo / package URL is not one". Nothing was
+contacted, so nothing can have answered as a docs page; the hint sent the reader to the wrong
+fix. Typed by the `socket.gaierror` in the cause chain, never by the message text.
+
+`.invalid` is reserved never to resolve (RFC 6761), so these tests need no live host.
+"""
+from __future__ import annotations
+
+import asyncio
+import socket
+
+from mcpgawk import cli
+from mcpgawk.fleet import state_of
+from mcpgawk.label import build_label, render_cli
+from mcpgawk.measure import measure
+from mcpgawk.probe import ServerSnapshot, _aggregate_failure, _kind_of, probe
+
+URL = "https://mcp-nothing-here.invalid/mcp"
+
+
+def _dns_failure() -> BaseException:
+    """The chain the SDK raises (measured): httpx2.ConnectError <- httpcore2.ConnectError <-
+    socket.gaierror. The outer type is the same one a refused connection raises."""
+    import httpx2
+    inner = socket.gaierror(8, "nodename nor servname provided, or not known")
+    outer = httpx2.ConnectError(str(inner))
+    outer.__cause__ = inner
+    return outer
+
+
+def test_a_dns_failure_is_typed_by_its_cause_not_its_wording():
+    assert _kind_of(_dns_failure(), transport="http") == "host-not-found"
+    refused = __import__("httpx2").ConnectError("[Errno 61] Connection refused")
+    refused.__cause__ = ConnectionRefusedError(61, "Connection refused")
+    assert _kind_of(refused, transport="http") == "connect-failed", "a refusal is not a DNS miss"
+
+
+def test_the_real_probe_names_the_host_that_does_not_resolve():
+    snap = asyncio.run(probe({"url": URL}, "typo"))
+    assert snap.is_failure
+    assert snap.error_kind == "host-not-found", snap.error
+    assert "mcp-nothing-here.invalid" in (snap.error or "")
+    assert "no MCP endpoint found" not in (snap.error or "")
+
+
+def test_the_row_and_the_report_point_at_the_name_not_at_a_docs_page():
+    snap = asyncio.run(probe({"url": URL}, "typo"))
+    label = build_label(snap, measure(snap))
+    state, detail = state_of(label)
+    assert state == "UNREACHABLE"            # an existing state: the IDE FleetState union is closed
+    assert "does not resolve" in detail
+    text = render_cli(label, verbose=False)
+    assert "A docs / repo / package URL is not one" not in text
+    assert "spelling" in text and "VPN" in text
+
+
+def _attempt(label: str, kind: str) -> tuple[str, ServerSnapshot]:
+    return label, ServerSnapshot(name="x", transport="http", protocol_version=None,
+                                 error="ConnectError: ...", error_kind=kind)
+
+
+def test_one_path_answering_outranks_the_name_not_resolving():
+    """Only when EVERY attempt failed to resolve is the name the problem. The ladder tries one
+    host, so a mix means something else answered; the other rules decide."""
+    snap = _aggregate_failure("x", "http", [_attempt("http /mcp", "host-not-found"),
+                                            _attempt("sse /sse", "timed-out")], [], url=URL)
+    assert snap.error_kind == "timed-out"
+
+
+def test_a_scan_of_a_mistyped_host_says_so(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("MCPGAWK_NO_UPDATE_CHECK", "1")
+    cli.main(["scan", "--http", URL, "--no-track"])
+    out = capsys.readouterr()
+    text = out.out + out.err
+    assert "does not resolve" in text, text
+    assert "Is it a live MCP endpoint?" not in text

mcpgawk-0.1.64/tests/test_two_nameless_servers_keep_two_records.py

@@ -0,0 +1,177 @@
+"""Two different servers scanned ad hoc must never share one record.
+
+Found 2026-09-26 on live servers: `scan --http` bureau, then `scan --http` inference, in one home.
+Neither asserts a name (both speak only the 2026-07-28 revision, whose `server/discover` carries no
+serverInfo), so both keyed `http:cli-http`, the placeholder every ad-hoc `--http` scan shares. The
+second scan reported DRIFT: bureau's 5 tools "removed", inference's 35 "added", and printed
+`mcpgawk approve http:cli-http`, which would have approved one server's tools as the other's.
+Every server that moves to the new revision becomes nameless, so this grows with the upgrade.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+from mcpgawk import cli, history
+from mcpgawk.probe import ServerSnapshot
+
+FIXTURES = Path(__file__).parent / "fixtures"
+CANARY = "CANARYnameless0123456789"
+
+
+def _tool(name):
+    return {"name": name, "description": f"Get {name}.", "inputSchema": {"type": "object"}}
+
+
+@pytest.fixture()
+def home(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path / "home"))
+    (tmp_path / "home").mkdir()
+    monkeypatch.setenv("MCPGAWK_HISTORY", str(tmp_path / "history.json"))
+    monkeypatch.setenv("GAWK_BEHAVIOUR_PROFILE", str(tmp_path / "behaviour.json"))
+    monkeypatch.setenv("MCPGAWK_NO_UPDATE_CHECK", "1")
+    return tmp_path
+
+
+@pytest.fixture()
+def nameless_http(monkeypatch):
+    """`probe_url` answering as a nameless server whose tools depend on the URL."""
+    tools = {"https://bureau.example/mcp": ["bureau_get_case"],
+             "https://inference.example/mcp": ["app_run", "task_get"]}
+
+    async def fake_probe_url(name, url, headers, timeout, auth=None, **kw):
+        base = url.split("?", 1)[0]
+        return ServerSnapshot(name=name, transport="http", protocol_version="2026-07-28",
+                              tools=[_tool(t) for t in tools.get(base, ["other"])],
+                              server_info={})
+
+    monkeypatch.setattr(cli, "probe_url", fake_probe_url)
+
+
+def _scan(capsys, *argv):
+    code = cli.main(["scan", *argv])
+    out = capsys.readouterr()
+    return code, out.out + out.err
+
+
+def test_two_nameless_urls_keep_two_records_and_neither_drifts(home, nameless_http, capsys):
+    _scan(capsys, "--http", "https://bureau.example/mcp")
+    code, text = _scan(capsys, "--http", "https://inference.example/mcp")
+
+    assert "DRIFT" not in text, f"the second server was diffed against the first:\n{text}"
+    assert "first scan" in text
+    # and the report names it by what was typed, not the placeholder both servers share
+    assert "cli-http" not in text, text
+    assert "● https://inference.example/mcp" in text, text
+    store = history.load()
+    assert "http:cli-http" not in store["servers"]
+    a = history.resolve_all(store, "https://bureau.example/mcp")
+    b = history.resolve_all(store, "https://inference.example/mcp")
+    assert len(a) == 1 and len(b) == 1 and a != b, (a, b)
+
+
+def test_a_rescan_of_the_same_nameless_url_still_finds_its_baseline(home, nameless_http, capsys):
+    _scan(capsys, "--http", "https://bureau.example/mcp")
+    _, text = _scan(capsys, "--http", "https://bureau.example/mcp")
+    assert "first scan" not in text and "DRIFT" not in text
+    assert len(history.load()["servers"]) == 1
+
+
+def test_a_credential_in_the_url_reaches_neither_the_key_nor_the_alias(home, nameless_http,
+                                                                       capsys):
+    raw = f"https://bureau.example/mcp?apiKey={CANARY}"
+    _, text = _scan(capsys, "--http", raw)
+    assert CANARY not in text
+    # every file the scan wrote (history, guard baseline, run log, …), not only the one we expect
+    for f in Path(home).rglob("*"):
+        if f.is_file():
+            assert CANARY.encode() not in f.read_bytes(), f"the key is stored in {f.name}"
+    store = history.load()
+    assert len(history.resolve_all(store, raw)) == 1, "the URL as typed no longer resolves"
+
+
+def test_the_printed_approve_command_survives_the_shell(home, monkeypatch, capsys):
+    """A masked key carries `?` and `*`, which zsh globs: the printed line must quote it, and the
+    word the shell hands `approve` must be the stored key."""
+    import shlex
+    tools = [["get_a"]]
+
+    async def fake_probe_url(name, url, headers, timeout, auth=None, **kw):
+        return ServerSnapshot(name=name, transport="http", protocol_version="2026-07-28",
+                              tools=[_tool(t) for t in tools[0]], server_info={})
+
+    monkeypatch.setattr(cli, "probe_url", fake_probe_url)
+    raw = f"https://bureau.example/mcp?apiKey={CANARY}"
+    _scan(capsys, "--http", raw)
+    tools[0] = ["get_a", "get_b"]                       # the same server changes: drift
+    _, text = _scan(capsys, "--http", raw)
+    [line] = [ln for ln in text.splitlines() if "mcpgawk approve" in ln]
+    argv = shlex.split(line.split("?", 1)[1])          # after "Reviewed it and it is fine?"
+    key = argv[argv.index("approve") + 1]
+    assert "*" in key and CANARY not in key
+    assert key in history.load()["servers"], (key, line)
+    # shlex.split does not glob, so check the quoting itself: unquoted, zsh expands the `*`
+    assert line.rstrip().endswith(shlex.quote(key)) and shlex.quote(key) != key, line
+
+
+ORDINARY_TARGETS = [
+    "npx -y example-unknown@1.0.0",
+    "npx -y @modelcontextprotocol/server-filesystem /tmp",
+    "/opt/homebrew/opt/python@3.13/bin/python3 server.py",
+    "uvx mcp-server-fetch",
+    "npx mcp-remote@0.8.4 https://mcp.kite.trade/mcp",
+    "docker run -i --rm ghcr.io/github/github-mcp-server",
+    "https://thebureauoflostcontext.agency/mcp",
+    "https://api.inference.sh/mcp",
+    "https://mcp.example.com/@scope/server/mcp",
+]
+
+
+@pytest.mark.parametrize("target", ORDINARY_TARGETS)
+def test_an_ordinary_target_is_its_own_key(target):
+    """The key IS the masked target, so an over-eager masker merges servers: `redact()` once
+    turned `npx -y a@1.0.0` and `npx -y b@2.0.0` into the same `npx -y [REDACTED]`."""
+    assert history.adhoc_target(target) == target
+
+
+def test_two_versions_of_one_package_are_two_keys():
+    assert history.adhoc_target("npx -y a@1.0.0") != history.adhoc_target("npx -y b@2.0.0")
+
+
+def _old_store(home, aliases):
+    """A store written before the fix: every nameless --http target on `http:cli-http`."""
+    rec = {"tools": {"old_tool": {"sha": "x"}}}
+    Path(home / "history.json").write_text(json.dumps({"servers": {"http:cli-http": {
+        "approved": rec, "approved_via": "first-sighting", "aliases": aliases,
+        "history": [rec]}}}), encoding="utf-8")
+
+
+def test_an_old_placeholder_record_of_one_server_carries_over(home, nameless_http, capsys):
+    _old_store(home, ["https://bureau.example/mcp"])
+    _, text = _scan(capsys, "--http", "https://bureau.example/mcp")
+    store = history.load()
+    assert "http:cli-http" not in store["servers"], "the server's own record was not reclaimed"
+    assert "first scan" not in text, "the baseline was silently reset on upgrade"
+
+
+def test_an_old_conflated_record_is_not_adopted_by_either_server(home, nameless_http, capsys):
+    _old_store(home, ["https://bureau.example/mcp", "https://inference.example/mcp"])
+    _, text = _scan(capsys, "--http", "https://inference.example/mcp")
+    assert "DRIFT" not in text, f"adopted a record that holds another server's history:\n{text}"
+    assert "first scan" in text
+    assert "http:cli-http" in history.load()["servers"], "left in place, not deleted"
+
+
+def test_two_real_modern_only_servers_over_stdio_keep_two_records(home, capsys):
+    """The customer's path end to end: the real probe, a real server refusing `initialize`."""
+    server = str(FIXTURES / "mcp2_only_server.py")
+    one = f"{sys.executable} {server}"
+    two = f"{sys.executable} {server} --second"      # a different target, same nameless server
+    _scan(capsys, "--stdio", one)
+    _, text = _scan(capsys, "--stdio", two)
+    assert "DRIFT" not in text and "first scan" in text, text
+    keys = [k for k in history.load()["servers"]]
+    assert len(keys) == 2 and "stdio:cli-stdio" not in keys, keys

{mcpgawk-0.1.63 → mcpgawk-0.1.64}/tests/test_url_credentials_are_not_printed.py

@@ -119,6 +119,7 @@ def test_the_panel_action_banner_masks_a_url_in_a_failure_message(tmp_path, monk
 
     monkeypatch.setattr(panel, "_run_login_cli", times_out)
     panel._ACTION.update(running=False, label="", message="", rows=[], at="")
+    panel._QUEUED.clear()    # a press queued by an earlier test would run after ours and overwrite the banner
 
     panel._run_action_bg("login", "wrapped")
     for _ in range(600):