toolgraph 0.4.0__tar.gz → 0.4.1__tar.gz

{toolgraph-0.4.0 → toolgraph-0.4.1}/CHANGELOG.md

@@ -2,6 +2,92 @@
 
 All notable changes to Toolgraph are documented here.
 
+## 0.4.1 - 2026-11-09
+
+Sixth alpha, a patch release: diagnostics only. Nothing that 0.4.0 accepted
+is refused, and no command, flag, default, function signature or JSON key
+changes. Read **Upgrading from 0.4.0** below if a script or tool matches
+Toolgraph's error text, or reads the configuration path it reports: more of
+it is hidden or withheld whole.
+
+### Upgrading from 0.4.0
+
+- Diagnostics hide more, and more of them are withheld whole (#241, #245,
+  #262). An `Authorization` value is hidden to the end of the message
+  (`Authorization: Bearer abc; retrying in 5s` now reads
+  `Authorization=<redacted>`). A message whose URL ends in a credential name
+  that assigns a value after it is withheld, in each form the scrubber reads
+  as an assignment (`GET https://h/authorization=Basic returned 404`). A
+  credential-shaped path in a YAML, `policy propose` export, `doctor` or
+  Ladybug backend error reads `<path withheld: credential-shaped>`, and so
+  does the configuration `path` in `doctor --json`, where 0.4.0 showed a
+  partly scrubbed path or withheld the line.
+  `toolgraph.config.check_config_health()` returns that display value in
+  `path` and `detail` too, where 0.4.0 returned the path as given. Tooling
+  that matches stderr, MCP error text or `doctor` output should expect these
+  forms; the entries under Fixed give each one.
+
+### Changed
+
+- Scrubbing a diagnostic is faster (#263), with the same output as before
+  that change: a check that needs a `%`, a backslash, a quote or `://` is
+  skipped when the message holds none, and each repr literal is parsed once
+  instead of twice. Against 0.4.0, measured locally (CPU time, best of three),
+  19 of the 21 adversarial inputs in `tests/test_redaction.py` run at least
+  1.4 times faster and a short plain message about 4.5 times; the two
+  percent-encoded URL inputs run about 12% slower, the cost of the decoded
+  check #241 added.
+- Distributions are built with `hatchling` 1.33.0 (was 1.32.4); the sdist
+  pins it in `[build-system] requires`.
+
+### Fixed
+
+- A credential name at the end of a URL is caught in the forms the scrubber
+  reads as an assignment, not only those the refusal rule does (#241). 0.4.0
+  withheld `fetch http://h/password =secret` but printed
+  `http://h/authorization=Basic secret` as `http://h secret`, and likewise
+  `Authorization=Token`, `proxy_authorization=Basic`, `password :secret`,
+  `password:[a, secret]` and `credential:{a: secret}`. Such a message is now
+  withheld whole, and so is one where the name or its delimiter is
+  percent-encoded (`http://h/pass%77ord :secret`,
+  `http://h/password%3A[a, secret]`), judged against each URL where the
+  rewrite finds it. More diagnostics are withheld for the same reason: a URL
+  path ending in a credential name and a scheme word with text after it
+  (`GET https://h/authorization=Basic returned 404`), or a bracket opening
+  inside the URL after a `:` (`GET https://h/password:[id] returned 404`),
+  as one after `=` already was. Not caught: an encoded delimiter that joins
+  the text after a URL to the start of another one
+  (`http://h/password %3Ahunter2://host`); an encoded name before a URL's
+  scheme (`%70assword://hunter2`); and a repr-escaped URL followed by an
+  assignment (`'http://h/password\t':hunter2`) (#246).
+- Diagnostics hide everything after an `Authorization` name, not only the
+  first word of its value (#245). 0.4.0 knew only the `Bearer`, `Basic` and
+  `Token` schemes and took any other scheme word as the whole value, so
+  `Authorization: Digest username=alice, response=hunter2` printed
+  `Authorization=<redacted> username=alice, response=hunter2`; Negotiate,
+  AWS4-HMAC-SHA256 `Signature=`, OAuth, SCRAM and Hawk parameters showed the
+  same way, and so did a URL ending in the name
+  (`http://h/authorization=Digest username=alice,response=hunter2` printed
+  `http://h username=alice,response=hunter2`; it is now withheld). A name with
+  a prefix is scrubbed too: `proxy_authorization:hunter2` and
+  `HTTP_AUTHORIZATION:hunter2` were printed as given. Where such a value ends
+  cannot be told from the text, so the rest of the message goes with it:
+  `Authorization: Bearer abc; retrying in 5s` now prints
+  `Authorization=<redacted>`, and a URL holding an Authorization name with
+  text after it is withheld (`GET https://h/authorization=abc returned 404`).
+- More error lines show a credential-shaped path as
+  `<path withheld: credential-shaped>` and keep the rest of the line (#262):
+  a YAML file over the size limit or without a mapping at its root, a
+  `policy propose` export over the size limit or with a bad envelope or row,
+  the manifest digest hint for an export without an envelope, `doctor`'s
+  configuration check, and the `BACKEND_CORRUPT`, `BACKEND_UNAVAILABLE` and
+  `BACKEND_LOCKED` errors for a Ladybug database. 0.4.0 scrubbed these paths
+  along with the line, so a directory named `password=x` printed a path that
+  does not exist (`expected a YAML mapping at document root:
+  /tmp/password=<redacted>`; an export error lost its `:1:` line number with
+  it), and a percent-encoded name (`/tmp/?%74oken=x`) withheld the whole
+  line, error code included.
+
 ## 0.4.0 - 2026-10-21
 
 Fifth alpha. Read **Upgrading from 0.3.0** below before installing: it lists

{toolgraph-0.4.0 → toolgraph-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: toolgraph
-Version: 0.4.0
+Version: 0.4.1
 Summary: Graph-native MCP/tool registry, policy compiler, and impact analyzer
 Project-URL: Homepage, https://github.com/memtomem/toolgraph
 Project-URL: Documentation, https://github.com/memtomem/toolgraph/blob/main/docs/beginner-guide.md

{toolgraph-0.4.0 → toolgraph-0.4.1}/pyproject.toml

@@ -77,7 +77,7 @@ notebook = ["nbclient>=0.10", "ipykernel>=6"]
 # different bytes behind the same reviewed commit. `scripts/verify-artifacts.sh`
 # asserts the sdist rebuilds the wheel byte for byte, which only holds while
 # the backend is fixed. Bump deliberately, then rehearse.
-requires = ["hatchling==1.32.4"]
+requires = ["hatchling==1.33.0"]
 build-backend = "hatchling.build"
 
 [tool.hatch.version]

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/__init__.py

@@ -1,3 +1,3 @@
 """toolgraph — graph-native MCP/tool registry for advisory governance analysis."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/artifact_safety.py

@@ -73,9 +73,12 @@ def display_resource(value: str) -> str:
     one percent-decoded form; the output is never decoded.
     """
     end = value.find("://")
+    if end == -1 and "%" not in value:
+        return value
     # An encoded scheme separator before the first raw one (`neo4j%3A%2F%2F`)
     # marks a URI the checks below would not see.
-    if "://" in unquote(value if end == -1 else value[:end]):
+    prefix = value if end == -1 else value[:end]
+    if "%" in prefix and "://" in unquote(prefix):
         return _HIDDEN
     if end == -1:
         return value
@@ -93,12 +96,13 @@ def display_resource(value: str) -> str:
     quote = _QUOTE.search(uri, end + 3 - first)
     if quote is not None and uri.rfind("@") > quote.start():
         return hidden
-    decoded = unquote(uri)
-    if decoded.count("@") > uri.count("@"):
+    decoded = unquote(uri) if "%" in uri else uri
+    if decoded != uri and decoded.count("@") > uri.count("@"):
         return hidden
     try:
         parts = urlsplit(uri)
-        if any("@" in part for form in (parts, urlsplit(decoded)) for part in form[2:]):
+        forms = (parts,) if decoded == uri else (parts, urlsplit(decoded))
+        if any("@" in part for form in forms for part in form[2:]):
             return hidden
     except ValueError:
         return hidden
@@ -129,7 +133,7 @@ def _redact_text(text: str) -> str:
         while True:
             scheme = _SCHEME.search(word, position)
             head = word[position:] if scheme is None else word[position : scheme.start()]
-            if unquote(head).count("://") > head.count("://"):
+            if "%" in head and unquote(head).count("://") > head.count("://"):
                 return "".join(shown) + text[done : base + position] + _HIDDEN
             if scheme is None:
                 # A scheme with no letter (`+++://secret=x`) is left alone, so
@@ -166,10 +170,12 @@ _RESOURCE_LIST_KEYS = frozenset(
 def _redact_string(value: str, *, whole: bool) -> str:
     # A string that is one URI from its start (raw or decoded, whitespace
     # around it aside) is one value too, wherever it sits.
+    if "://" not in value and "%" not in value:
+        return value
     stripped = value.strip()
     if whole or (
         not any(char.isspace() for char in stripped)
-        and (_SCHEME.match(stripped) or _SCHEME.match(unquote(stripped)))
+        and (_SCHEME.match(stripped) or ("%" in stripped and _SCHEME.match(unquote(stripped))))
     ):
         return display_resource(value)
     return _redact_text(value)

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/cli.py

@@ -97,8 +97,8 @@ _DURABILITY_WARNINGS = (ArtifactDurabilityWarning, ReviewCandidateDurabilityWarn
 def _credential_shaped_argument(args: list[str]) -> bool:
     """Whether any command-line token is credential-shaped (the refusal rule).
 
-    Checked on the tokens as typed: Click and Typer print a value escaped
-    (`\\x09`, `\\xa0`) or quoted, a form the scrubber does not read. The
+    Checked on the tokens as typed, before Click and Typer quote or escape
+    them (`\\x09`, `\\xa0`) in the message. The
     tokens joined by spaces are checked too: Click prints unexpected extra
     arguments that way, so `password` and `<TAB>=value` make one assignment.
     """

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/config.py

@@ -33,16 +33,17 @@ def runtime_config_path() -> Path:
 def check_config_health() -> dict[str, Any]:
     """Inspect active configuration file existence, schema validity, and permissions."""
     path = runtime_config_path()
+    shown_path = display_path(path)
     exists = path.is_file()
     if not exists:
         return {
-            "path": str(path),
+            "path": shown_path,
             "exists": False,
             "valid_json": False,
             "permissions_ok": None,
             "permissions": None,
             "healthy": False,
-            "detail": f"configuration file not found at {path}",
+            "detail": f"configuration file not found at {shown_path}",
             "backend_source": backend_source(),
         }
 
@@ -64,7 +65,7 @@ def check_config_health() -> dict[str, Any]:
 
     healthy = exists and valid_json and (permissions_ok is not False)
     return {
-        "path": str(path),
+        "path": shown_path,
         "exists": exists,
         "valid_json": valid_json,
         "permissions_ok": permissions_ok,

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/graph/driver.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, Any
 
 from toolgraph import config
 from toolgraph.models import TOOL_HINT_FIELDS
+from toolgraph.redaction import display_path
 
 if TYPE_CHECKING:
     from neo4j import Driver, Session
@@ -349,7 +350,7 @@ def _not_a_database(path: Path) -> BackendConfigurationError:
     # Not retryable: waiting does not turn a foreign or corrupt file into a
     # database, so this must not read as an outage.
     return BackendConfigurationError(
-        f"BACKEND_CORRUPT: {path} is not a valid Ladybug database file; "
+        f"BACKEND_CORRUPT: {display_path(path)} is not a valid Ladybug database file; "
         "check file integrity and format",
         cause=ConfigurationCause.BACKEND_CORRUPT,
     )
@@ -357,7 +358,8 @@ def _not_a_database(path: Path) -> BackendConfigurationError:
 
 def _missing_database(path: Path) -> BackendUnavailableError:
     return BackendUnavailableError(
-        f"BACKEND_UNAVAILABLE: Ladybug database {path} does not exist or is not a file"
+        f"BACKEND_UNAVAILABLE: Ladybug database {display_path(path)} "
+        "does not exist or is not a file"
     )
 
 
@@ -381,7 +383,7 @@ def _open_ladybug_database(path: Path, *, create: bool) -> Any:
         message = str(exc)
         if "lock" in message.lower() or "another process" in message.lower():
             raise BackendLockedError(
-                f"BACKEND_LOCKED: Ladybug database {path} already has an owner"
+                f"BACKEND_LOCKED: Ladybug database {display_path(path)} already has an owner"
             ) from exc
         if _NOT_A_DATABASE in message:
             raise _not_a_database(path) from exc
@@ -535,11 +537,12 @@ def acquire_readonly_session() -> Iterator[Session | LadybugSession]:
             except RuntimeError as exc:
                 if "lock" in str(exc).lower() or "another process" in str(exc).lower():
                     raise BackendLockedError(
-                        f"BACKEND_LOCKED: Ladybug database {path} already has an owner"
+                        f"BACKEND_LOCKED: Ladybug database {display_path(path)} "
+                        "already has an owner"
                     ) from exc
                 if not path.is_file():
                     raise BackendUnavailableError(
-                        f"BACKEND_UNAVAILABLE: Ladybug database {path} does not exist"
+                        f"BACKEND_UNAVAILABLE: Ladybug database {display_path(path)} does not exist"
                     ) from exc
                 if _NOT_A_DATABASE in str(exc):
                     raise _not_a_database(path) from exc

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/policy_propose.py

@@ -16,7 +16,12 @@ from toolgraph.artifact_safety import validate_identity
 from toolgraph.graph import driver, queries, selector
 from toolgraph.graph.selector import PROFILES
 from toolgraph.manifest.parser import Governance, governance_digest, load_governance
-from toolgraph.redaction import is_credential_shaped, is_credential_shaped_identity, redact_text
+from toolgraph.redaction import (
+    display_path,
+    is_credential_shaped,
+    is_credential_shaped_identity,
+    redact_text,
+)
 
 
 class PolicyProposeError(Exception):
@@ -273,11 +278,12 @@ MAX_EXPORT_BYTES = 50_000_000
 
 def load_export(path: Path) -> tuple[dict | None, list[dict]]:
     # One open descriptor: a stat-then-read pair is a TOCTOU.
+    shown_path = display_path(path)
     with path.open("rb") as handle:
         raw = handle.read(MAX_EXPORT_BYTES + 1)
     if len(raw) > MAX_EXPORT_BYTES:
         raise PolicyProposeError(
-            f"refusing to load {path}: exceeds the {MAX_EXPORT_BYTES}-byte limit"
+            f"refusing to load {shown_path}: exceeds the {MAX_EXPORT_BYTES}-byte limit"
         )
     lines = raw.decode("utf-8").splitlines()
     envelope: dict | None = None
@@ -292,10 +298,10 @@ def load_export(path: Path) -> tuple[dict | None, list[dict]]:
                 first = None
             if isinstance(first, dict) and ENVELOPE_KEY in first:
                 if not isinstance(first[ENVELOPE_KEY], dict):
-                    raise ProvenanceError(f"{path}:{lineno}: envelope must be a JSON object")
+                    raise ProvenanceError(f"{shown_path}:{lineno}: envelope must be a JSON object")
                 if set(first) != {ENVELOPE_KEY}:
                     raise ProvenanceError(
-                        f"{path}:{lineno}: the envelope line carries only "
+                        f"{shown_path}:{lineno}: the envelope line carries only "
                         f"{ENVELOPE_KEY!r}; observation fields belong on their own rows"
                     )
                 envelope = first[ENVELOPE_KEY]
@@ -307,9 +313,10 @@ def load_export(path: Path) -> tuple[dict | None, list[dict]]:
 def _load_rows(path: Path, lines: list[tuple[int, str]]) -> list[dict]:
     rows: list[dict] = []
     seen: set[tuple[str, str]] = set()
+    shown_path = display_path(path)
     for lineno, raw in lines:
         line = raw.strip()
-        where = f"{path}:{lineno}"
+        where = f"{shown_path}:{lineno}"
         try:
             row = json.loads(line)
         except json.JSONDecodeError as exc:
@@ -698,7 +705,7 @@ def run_propose(
             "Re-export with an envelope line:\n"
             '  {"envelope": {"governance_digest": "<64 hex>", "graph_generation": 0, '
             '"profile": "strict", "window_start": "...", "window_end": "..."}}\n'
-            f"The digest for {governance_path} right now is {expected_digest}.\n"
+            f"The digest for {display_path(governance_path)} right now is {expected_digest}.\n"
             "Or pass --unverified-provenance to proceed without envelope verification."
         )
 

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/redaction.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import ast
 import re
 import shlex
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from itertools import islice
 from pathlib import Path, PureWindowsPath
 from typing import TYPE_CHECKING
@@ -37,12 +37,13 @@ _AUTHORIZATION = re.compile(
     r"(?i)\bauthorization['\"]?\s*[:=]\s*['\"]?"
     r"(?:(?:bearer|basic|token)\s+)?[^\s,'\"}\]]+"
 )
-# The scrubbing form: a quoted or bracketed value is hidden through the end of
-# the text, as for _SCRUB_VALUE below.
-_AUTHORIZATION_SCRUB = re.compile(
-    r"(?i)\bauthorization['\"]?\s*[:=]\s*"
-    r"(?:['\"\[{][\s\S]*|(?:(?:bearer|basic|token)\s+)?[^\s,'\"}\]]+)"
-)
+# The scrubbing form hides everything after the name through the end of the
+# text. Where an Authorization value ends cannot be told from prose: a scheme
+# may take a parameter list (`Digest username=a, response=x failed`), a value
+# may be malformed (`Basic user x`), and a header dump may hold another
+# Authorization header after it. No `\b`, so `proxy_authorization` and
+# `HTTP_AUTHORIZATION` count, as the credential names below do.
+_AUTHORIZATION_SCRUB = re.compile(r"(?i)authorization['\"]?\s*[:=]\s*\S[\s\S]*")
 # The names every credential detector treats as a secret when assigned. One
 # list, so a name refused in one place is refused in artifact identities,
 # review notes and control plans alike. Scrubbing (_CREDENTIAL below) keeps the
@@ -171,10 +172,31 @@ def _inspected(text: str) -> tuple[str, ...]:
     # One percent-decoding pass, for inspection only: the value itself is
     # never rewritten. `+` stays literal, and a doubly encoded key such as
     # `%2574oken` is not decoded a second time.
+    if "%" not in text:
+        return (text,)
     decoded = unquote(text)
     return (text,) if decoded == text else (text, decoded)
 
 
+def _form_is_credential_shaped(form: str) -> bool:
+    has_colon = ":" in form
+    has_equals = "=" in form
+    if has_colon and "://" in form and (at := form.rfind("@")) != -1:
+        if CREDENTIAL_URI.search(form):
+            return True
+        if ("'" in form or '"' in form) and any(
+            pattern.search(form, 0, at) for pattern in _QUOTED_USERINFO
+        ):
+            return True
+    if has_equals and CREDENTIAL_QUERY.search(form):
+        return True
+    if (has_colon or has_equals) and _REFUSED_ASSIGNMENT.search(form):
+        return True
+    if has_colon and _REFUSED_AUTHORIZATION.search(form):
+        return True
+    return bool(_BEARER.search(form))
+
+
 def is_credential_shaped(text: str) -> bool:
     """True when a value that is stored or emitted as given holds a credential.
 
@@ -192,15 +214,7 @@ def is_credential_shaped(text: str) -> bool:
     userinfo whose unquoted part holds whitespace (``neo4j://u v:"p w"@h``
     reads as a URL followed by text), so only identities refuse that.
     """
-    return any(
-        CREDENTIAL_URI.search(form)
-        or any(pattern.search(form, 0, form.rfind("@")) for pattern in _QUOTED_USERINFO)
-        or CREDENTIAL_QUERY.search(form)
-        or _REFUSED_ASSIGNMENT.search(form)
-        or _REFUSED_AUTHORIZATION.search(form)
-        or _BEARER.search(form)
-        for form in _inspected(text)
-    )
+    return any(_form_is_credential_shaped(form) for form in _inspected(text))
 
 
 def is_credential_shaped_identity(text: str) -> bool:
@@ -223,6 +237,8 @@ def _uri_origin_keeping_prefix(value: str) -> str:
     # stay as they are, so a credential name the URI's host position holds
     # (`1https://password : x`) is still there for credential scrubbing. A
     # scheme without a letter (`123://`) is not a URI and is left alone.
+    if value[0].isalpha():
+        return _diagnostic_uri_origin(value)
     scheme = value[: value.index("://")]
     first = next((i for i, char in enumerate(scheme) if char.isalpha()), None)
     if first is None:
@@ -236,7 +252,11 @@ def _hide_quoted_userinfo(text: str) -> str:
     # wherever the refusal rule refuses one. The hidden span starts at the
     # beginning of the whitespace-delimited token: cutting at a nested scheme
     # (`https://user:x://"pw"@host`) would leave a prefix that reads as a URI.
+    if "'" not in text and '"' not in text:
+        return text
     end = text.rfind("@")
+    if end == -1:
+        return text
     matches = [match for pattern in _QUOTED_USERINFO if (match := pattern.search(text, 0, end))]
     if not matches:
         return text
@@ -251,7 +271,16 @@ def _hide_quoted_userinfo(text: str) -> str:
 # would go with the URI rewrite and leave its value readable. The search is
 # zero-width, so names that share letters (`secretoken`) are each tried.
 _NAME_START = re.compile(rf"(?i)(?=(?:{CREDENTIAL_KEYWORDS}|authorization|bearer))")
-_NAME_RULES = (_REFUSED_ASSIGNMENT, _REFUSED_AUTHORIZATION, _BEARER)
+# What the scrubbers take as an assignment, up to where the value starts: the
+# first group of _SCRUB_VALUE after any name. Matching no value keeps each try
+# bounded. The refusal patterns accept fewer forms (`password :x`,
+# `authorization=Basic x`), and every form the scrubbers accept beyond them
+# leaked here.
+_SCRUB_ASSIGNMENT = re.compile(rf"(?i)(?:{CREDENTIAL_KEYWORDS}|authorization)['\"]?\s*[:=]\s*")
+# _AUTHORIZATION_SCRUB's value runs to the end of the text, so an Authorization
+# name inside a URI assigns past it whenever any text follows the URI.
+_AUTHORIZATION_NAME = re.compile(r"(?i)authorization['\"]?\s*[:=]")
+_NAME_RULES = (_SCRUB_ASSIGNMENT, _BEARER)
 _NON_SPACE = re.compile(r"\S")
 
 
@@ -259,8 +288,8 @@ def _assigns_past(text: str, uri_end: int, match: re.Match[str]) -> bool:
     # Whether rewriting a URI that ends at `uri_end` would hide the name
     # `match` starts with but not what it assigns.
     end = match.end()
-    if match.re is not _REFUSED_ASSIGNMENT:
-        # Authorization and Bearer matches hold the credential itself.
+    if match.re is _BEARER:
+        # A Bearer match holds the credential itself.
         return end > uri_end
     if end < uri_end:
         # A bracketed value runs to the end of the text.
@@ -269,26 +298,73 @@ def _assigns_past(text: str, uri_end: int, match: re.Match[str]) -> bool:
     return _NON_SPACE.search(text, end) is not None
 
 
-def _assignment_crosses_uri(text: str) -> bool:
-    """True when a credential name inside a URI assigns a value past its end."""
-    # Names are found in text order, so one pointer walks the URIs once.
-    uris = _URI.finditer(text)
+def _crosses(text: str, spans: Iterable[tuple[int, int]]) -> bool:
+    # Names are found in text order, so one pointer walks the spans once. The
+    # end of the text without trailing whitespace is found once too: searching
+    # past each URI for every name would be quadratic.
+    uris = iter(spans)
     uri = next(uris, None)
-    for name in _NAME_START.finditer(text):
+    if uri is None:
+        return False
+    last = len(text.rstrip())
+    for name in _NAME_START.finditer(text, uri[0]):
         at = name.start()
-        while uri is not None and uri.end() <= at:
+        while uri is not None and uri[1] <= at:
             uri = next(uris, None)
         if uri is None:
             return False
-        if at < uri.start():
+        if at < uri[0]:
             continue
-        for rule in _NAME_RULES:
-            match = rule.match(text, at)
-            if match and _assigns_past(text, uri.end(), match):
+        if text[at] in "bB":
+            match = _BEARER.match(text, at)
+            if match and _assigns_past(text, uri[1], match):
+                return True
+        else:
+            match = _SCRUB_ASSIGNMENT.match(text, at)
+            if match and (
+                (last > uri[1] and text[at] in "aA" and _AUTHORIZATION_NAME.match(text, at))
+                or _assigns_past(text, uri[1], match)
+            ):
                 return True
     return False
 
 
+def _decoded_keeping_uris(text: str) -> tuple[str, list[tuple[int, int]]]:
+    # Each URI and each gap between URIs is decoded on its own, so a URI keeps
+    # the bounds the rewrite will use: decoding the whole text would let a
+    # `%20` end a URI early and move a name out of it.
+    parts: list[str] = []
+    spans: list[tuple[int, int]] = []
+    length = consumed = 0
+    for uri in _URI.finditer(text):
+        gap = unquote(text[consumed : uri.start()])
+        value = unquote(uri.group(0))
+        start = length + len(gap)
+        parts += [gap, value]
+        spans.append((start, start + len(value)))
+        length = start + len(value)
+        consumed = uri.end()
+    parts.append(unquote(text[consumed:]))
+    return "".join(parts), spans
+
+
+def _assignment_crosses_uri(text: str) -> bool:
+    """True when a credential name inside a URI assigns a value past its end.
+
+    Checked on the text as given and on its percent-decoded form, with each
+    URI where the rewrite will find it.
+    """
+    if "://" not in text:
+        return False
+    if _crosses(text, (uri.span() for uri in _URI.finditer(text))):
+        return True
+    if "%" not in text:
+        # Nothing to decode, and building the copy slows a URI-heavy text.
+        return False
+    decoded, spans = _decoded_keeping_uris(text)
+    return decoded != text and _crosses(decoded, spans)
+
+
 # `repr`, `ascii`, `%r`, a container's `str()` and many library errors
 # (`int('…')`) print a tab or a no-break space as an escape (`\t`, `\xa0`), so
 # `password<TAB>=value` no longer reads as an assignment. Such output is a
@@ -299,6 +375,7 @@ def _assignment_crosses_uri(text: str) -> bool:
 # quote. The repeat is possessive: the two branches never overlap, so giving
 # characters back could not find another match, and a backtracking repeat
 # keeps state for every character (about 180 MiB for a 1 MB literal).
+_QUOTE_CHAR = re.compile(r"""['"]""")
 _LITERAL = re.compile(r"""(['"])((?:\\.|(?!\1)[^\\\n])*+)\1""")
 # The escapes repr and ascii print. A candidate holding any other backslash
 # sequence is not their output and never reaches the parser, which would
@@ -350,8 +427,9 @@ def _repr_literals(text: str) -> Iterator[list[tuple[int, int, str]]]:
     an odd run of backslashes (`C:\\` followed by repr output) is therefore
     not read.
     """
-    for index, char in enumerate(text):
-        if char not in "'\"" or _escaped(text, index):
+    for quote in _QUOTE_CHAR.finditer(text):
+        index = quote.start()
+        if _escaped(text, index):
             continue
         match = _LITERAL.match(text, index)
         if not match or "\\" not in match[2]:
@@ -366,11 +444,14 @@ def _repr_reads_as_credential(text: str) -> bool:
     # Counted first, so a text over the limit costs one scan and no checks.
     # Each form is then built and checked on its own: holding them all would
     # copy the whole text twice per reading.
-    if sum(1 for _ in islice(_repr_literals(text), _MAX_LITERALS + 1)) > _MAX_LITERALS:
+    if "\\" not in text:
+        return False
+    literals = list(islice(_repr_literals(text), _MAX_LITERALS + 1))
+    if len(literals) > _MAX_LITERALS:
         return True
     return any(
         is_credential_shaped(value) or is_credential_shaped(text[:start] + value + text[end:])
-        for readings in _repr_literals(text)
+        for readings in literals
         for start, end, value in readings
     )
 
@@ -398,25 +479,29 @@ def redact_text(value: object) -> str:
     is credential-shaped, alone or in place in the message, and when it holds
     more than ``_MAX_LITERALS`` such literals. Both checks read the message
     as given, before anything rewrites it. A message where a credential name
-    inside a URI assigns a value after the URI's end (`https://h/password =x`)
-    is withheld too: rewriting the URI to its origin would remove the name
-    and leave the value. After scrubbing, the text without the placeholders
-    the scrubbers inserted is checked with the refusal rule, and withheld if
-    it is still credential-shaped. A placeholder the input itself carries is
-    shown as `\u2039redacted`.
+    inside a URI, as given or percent-decoded, assigns a value after the
+    URI's end (`https://h/password :x`) is withheld too: rewriting the URI to
+    its origin would remove the name and leave the value. After scrubbing,
+    the text without the placeholders the scrubbers inserted is checked with
+    the refusal rule, and withheld if it is still credential-shaped. A
+    placeholder the input itself carries is shown as `\u2039redacted`.
     """
     raw = str(value)
-    decoded = unquote(raw)
-    if decoded != raw and is_credential_shaped(decoded):
-        return WITHHELD
-    if _repr_reads_as_credential(raw):
-        return WITHHELD
-    text = _hide_quoted_userinfo(_INPUT_PLACEHOLDER.sub("\u2039", raw))
-    if _assignment_crosses_uri(text):
+    if "%" in raw:
+        decoded = unquote(raw)
+        if decoded != raw and is_credential_shaped(decoded):
+            return WITHHELD
+    if "\\" in raw and _repr_reads_as_credential(raw):
         return WITHHELD
-    text = _URI.sub(lambda match: _uri_origin_keeping_prefix(match.group(0)), text)
+    text = _INPUT_PLACEHOLDER.sub("\u2039", raw) if "<" in raw else raw
+    if "://" in text:
+        text = _hide_quoted_userinfo(text)
+        if _assignment_crosses_uri(text):
+            return WITHHELD
+        text = _URI.sub(lambda match: _uri_origin_keeping_prefix(match.group(0)), text)
     text = redact_credentials(text)
-    if is_credential_shaped(_INSERTED.sub(" ", text)):
+    without_inserted = _INSERTED.sub(" ", text) if "<redacted" in text else text
+    if is_credential_shaped(without_inserted):
         return WITHHELD
     return text
 

{toolgraph-0.4.0 → toolgraph-0.4.1}/toolgraph/yaml_loader.py

@@ -7,6 +7,8 @@ from typing import Any
 
 import yaml
 
+from toolgraph.redaction import display_path
+
 
 class UniqueKeySafeLoader(yaml.SafeLoader):
     """SafeLoader variant that rejects duplicate mapping keys at any depth."""
@@ -73,7 +75,9 @@ def load_yaml_mapping(path: Path) -> dict[str, Any]:
     with path.open("rb") as handle:
         raw = handle.read(MAX_YAML_BYTES + 1)
     if len(raw) > MAX_YAML_BYTES:
-        raise ValueError(f"refusing to load {path}: exceeds the {MAX_YAML_BYTES}-byte limit")
+        raise ValueError(
+            f"refusing to load {display_path(path)}: exceeds the {MAX_YAML_BYTES}-byte limit"
+        )
     try:
         loader = UniqueKeySafeLoader(raw.decode("utf-8"))
         try:
@@ -93,5 +97,5 @@ def load_yaml_mapping(path: Path) -> dict[str, Any]:
     if value is None:
         return {}
     if not isinstance(value, dict):
-        raise ValueError(f"expected a YAML mapping at document root: {path}")
+        raise ValueError(f"expected a YAML mapping at document root: {display_path(path)}")
     return value