open-code-review-toolkit 0.1.0__py3-none-any.whl

ocr_toolkit/__init__.py

@@ -0,0 +1 @@
+"""Open Code Review CI helper package."""

ocr_toolkit/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

ocr_toolkit/cli.py

@@ -0,0 +1,56 @@
+"""Unified command-line interface for Open Code Review CI helpers."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+
+from ocr_toolkit import configure, mcp_config, preflight
+from ocr_toolkit.context import render as context_render
+from ocr_toolkit.posting.workflow import main as posting_main
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the stable top-level parser and subcommand surface."""
+
+    parser = argparse.ArgumentParser(
+        prog="ocr-ci",
+        description="Safe CI integration helpers for Open Code Review.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("preflight", help="Validate OCR, GitLab, and LLM access.")
+    subparsers.add_parser("configure", help="Write the OCR runtime configuration.")
+    subparsers.add_parser("mcp-config", help="Write OCR MCP server configuration.")
+
+    context_parser = subparsers.add_parser(
+        "context", help="Generate bounded repository review context."
+    )
+    context_parser.add_argument(
+        "--output",
+        default=".review-context/dependencies.md",
+        help="Output markdown path.",
+    )
+
+    post_parser = subparsers.add_parser("post", help="Publish an OCR result artifact to GitLab.")
+    post_parser.add_argument(
+        "--result", default="/tmp/ocr-result.json", help="OCR JSON result path."
+    )
+    post_parser.add_argument("--stderr", default="/tmp/ocr-stderr.log", help="OCR stderr log path.")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Dispatch one public subcommand and return its process exit code."""
+
+    args = build_parser().parse_args(argv)
+    if args.command == "preflight":
+        return preflight.main()
+    if args.command == "configure":
+        return configure.main()
+    if args.command == "mcp-config":
+        return mcp_config.configure_mcp_servers()
+    if args.command == "context":
+        return context_render.main(["--output", args.output])
+    if args.command == "post":
+        return posting_main([args.result, args.stderr])
+    raise AssertionError(f"unhandled command: {args.command}")

ocr_toolkit/common/__init__.py

@@ -0,0 +1 @@
+"""Open Code Review CI helper package."""

ocr_toolkit/common/language.py

@@ -0,0 +1,60 @@
+"""Resolve the single public language setting used by OCR review flows."""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+DEFAULT_REVIEW_LANGUAGE = "English"
+REVIEW_LANGUAGE_ENV = "OCR_REVIEW_LANGUAGE"
+
+KNOWN_LANGUAGES = frozenset(
+    {
+        "arabic",
+        "chinese",
+        "czech",
+        "danish",
+        "dutch",
+        "english",
+        "english (uk)",
+        "english (us)",
+        "finnish",
+        "french",
+        "german",
+        "hebrew",
+        "hindi",
+        "indonesian",
+        "italian",
+        "japanese",
+        "korean",
+        "norwegian",
+        "polish",
+        "portuguese",
+        "russian",
+        "spanish",
+        "swedish",
+        "thai",
+        "turkish",
+        "ukrainian",
+        "vietnamese",
+    }
+)
+BCP47_RE = re.compile(r"^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$")
+
+
+def resolve_review_language(value: str | None = None) -> str:
+    """Return one safe language label for OCR config and review context."""
+
+    raw = (os.environ.get(REVIEW_LANGUAGE_ENV, "") if value is None else value).strip()
+    if not raw:
+        return DEFAULT_REVIEW_LANGUAGE
+    if raw.lower() in KNOWN_LANGUAGES or BCP47_RE.fullmatch(raw):
+        return raw
+
+    print(
+        f"{REVIEW_LANGUAGE_ENV} is not an allowed language label or BCP-47 tag; "
+        f"falling back to {DEFAULT_REVIEW_LANGUAGE}.",
+        file=sys.stderr,
+    )
+    return DEFAULT_REVIEW_LANGUAGE

ocr_toolkit/common/markdown.py

@@ -0,0 +1,214 @@
+"""Markdown formatting helpers for OCR CI output."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+SAFE_CODE_BLOCK_LANGUAGE_RE = re.compile(r"^[A-Za-z0-9_+.#-]{1,40}$")
+FENCE_LINE_RE = re.compile(r"^ {0,3}(`{3,}|~{3,})([^\n]*)$")
+
+
+def markdown_fence_transition(line: str, open_fence: str | None) -> tuple[str | None, bool]:
+    """Return updated fenced-code marker and whether this line is a fence."""
+
+    match = FENCE_LINE_RE.match(line)
+    if not match:
+        return open_fence, False
+
+    fence = match.group(1)
+    suffix = match.group(2)
+    marker = fence[0]
+    if open_fence is None:
+        if marker == "`" and "`" in suffix:
+            return open_fence, False
+        return marker * len(fence), True
+
+    if marker != open_fence[0] or len(fence) < len(open_fence):
+        return open_fence, False
+    if suffix.strip():
+        return open_fence, False
+    return None, True
+
+
+def open_markdown_fence(markdown: str) -> str | None:
+    """Return the currently open CommonMark fenced-code marker, if any."""
+
+    open_fence: str | None = None
+    for line in markdown.splitlines():
+        open_fence, _ = markdown_fence_transition(line, open_fence)
+    return open_fence
+
+
+def neutralize_suggestion_fences(text: str) -> str:
+    """Prevent OCR-controlled prose from creating GitLab suggestion blocks."""
+
+    neutralized: list[str] = []
+    for raw_line in text.splitlines(keepends=True):
+        line = raw_line.rstrip("\r\n")
+        line_ending = raw_line[len(line) :]
+        stripped = line.lstrip(" ")
+        indent = line[: len(line) - len(stripped)]
+        match = FENCE_LINE_RE.match(line)
+        if (
+            len(indent) <= 3
+            and match
+            and match.group(1).startswith("`")
+            and "`" not in match.group(2)
+            and match.group(2).lstrip().lower().startswith("suggestion")
+        ):
+            neutralized.append(f"{indent}{match.group(1)}text{line_ending}")
+        else:
+            neutralized.append(raw_line)
+    return "".join(neutralized)
+
+
+def max_backtick_run(text: str) -> int:
+    """Return the longest consecutive backtick run in text."""
+
+    longest = 0
+    current = 0
+
+    for char in text:
+        if char == "`":
+            current += 1
+            longest = max(longest, current)
+        else:
+            current = 0
+
+    return longest
+
+
+def escape_code_block_control_chars(value: str) -> str:
+    """Escape invisible controls while preserving code-block layout."""
+
+    escaped: list[str] = []
+    for char in value:
+        codepoint = ord(char)
+        if char in {"\n", "\t"}:
+            escaped.append(char)
+            continue
+        category = unicodedata.category(char)
+        if category == "Cc":
+            escaped.append(f"\\x{codepoint:02x}")
+        elif category in {"Cf", "Zl", "Zp"}:
+            if codepoint <= 0xFFFF:
+                escaped.append(f"\\u{codepoint:04x}")
+            else:
+                escaped.append(f"\\U{codepoint:08x}")
+        else:
+            escaped.append(char)
+
+    return "".join(escaped)
+
+
+def markdown_code_block(language: str, content: str, escape_controls: bool = True) -> str:
+    """Return a Markdown code block safe for embedded fences."""
+
+    if escape_controls:
+        content = escape_code_block_control_chars(content)
+
+    fence_len = max(3, max_backtick_run(content) + 1)
+    fence = "`" * fence_len
+    lang = language.strip()
+    if not SAFE_CODE_BLOCK_LANGUAGE_RE.fullmatch(lang):
+        lang = ""
+
+    closing_separator = "" if content.endswith("\n") else "\n"
+    if lang:
+        return f"{fence}{lang}\n{content}{closing_separator}{fence}"
+
+    return f"{fence}\n{content}{closing_separator}{fence}"
+
+
+def escape_control_chars(value: str) -> str:
+    """Return text with control/format characters escaped for Markdown output.
+
+    Unicode control characters (category ``Cc``), format controls
+    (category ``Cf``), and Unicode line/paragraph separators (``Zl``/``Zp``)
+    can make rendered Markdown differ from the underlying value. Keep ordinary
+    printable Unicode unchanged.
+    """
+
+    escaped: list[str] = []
+    for char in value:
+        codepoint = ord(char)
+        if char == "\n":
+            escaped.append("\\n")
+            continue
+        elif char == "\r":
+            escaped.append("\\r")
+            continue
+        elif char == "\t":
+            escaped.append("\\t")
+            continue
+        category = unicodedata.category(char)
+        if category == "Cc":
+            escaped.append(f"\\x{codepoint:02x}")
+        elif category in {"Cf", "Zl", "Zp"}:
+            if codepoint <= 0xFFFF:
+                escaped.append(f"\\u{codepoint:04x}")
+            else:
+                escaped.append(f"\\U{codepoint:08x}")
+        else:
+            escaped.append(char)
+
+    return "".join(escaped)
+
+
+def inline_code(value: str, escape_controls: bool = True) -> str:
+    """Return a Markdown inline-code representation safe for backticks.
+
+    Control/format escaping is the default because most callers render
+    MR-controlled paths, CI values, manifest strings, or OCR output. Callers
+    that render compile-time literal identifiers may opt out explicitly.
+
+    An empty input is rendered as an italic ``_(unset)_`` so a missing
+    branch name or commit SHA is visually obvious instead of collapsing
+    into two adjacent backticks that GitLab renders ambiguously.
+    """
+
+    if not value:
+        return "_(unset)_"
+
+    if escape_controls:
+        value = escape_control_chars(value)
+
+    padded_span = bool(value.strip()) and value.startswith(" ") and value.endswith(" ")
+    if "`" not in value and not padded_span:
+        return f"`{value}`"
+
+    fence = "`" * (max_backtick_run(value) + 1)
+    return f"{fence} {value} {fence}"
+
+
+def neutralize_quick_actions(text: str) -> str:
+    """Prevent GitLab quick actions from executing in bot-created notes.
+
+    GitLab treats lines starting with '/' as quick actions in comments.
+    Prefix such lines with a backslash so the text remains readable but
+    is not executed. This is a raw GitLab-note safety boundary, so it
+    intentionally escapes slash-prefixed lines even inside Markdown code
+    blocks rather than relying on GitLab quick-action parsing to honor
+    the same Markdown boundaries as this local parser.
+    """
+
+    neutralized_lines: list[str] = []
+    open_fence: str | None = None  # currently open fence marker, or None
+    for raw_line in text.splitlines(keepends=True):
+        line = raw_line.rstrip("\r\n")
+        line_ending = raw_line[len(line) :]
+        next_open_fence, is_fence = markdown_fence_transition(line, open_fence)
+        if is_fence:
+            open_fence = next_open_fence
+            neutralized_lines.append(line + line_ending)
+            continue
+
+        stripped = line.lstrip()
+        if stripped.startswith("/"):
+            leading = line[: len(line) - len(stripped)]
+            neutralized_lines.append(f"{leading}\\{stripped}{line_ending}")
+        else:
+            neutralized_lines.append(line + line_ending)
+
+    return "".join(neutralized_lines)

ocr_toolkit/common/redaction.py

@@ -0,0 +1,324 @@
+"""Redaction helpers for data sent to logs, GitLab, or LLM context."""
+
+from __future__ import annotations
+
+import os
+import re
+import unicodedata
+import urllib.parse
+from typing import Any
+
+SENSITIVE_KEY_PATTERN = (
+    r"x-api-key|api[_-]?key|access[_-]?token|auth[_-]?token|"
+    r"secret[_-]?key|refresh[_-]?token|private[_-]?token|"
+    r"client[_-]?secret|aws[_-]?secret[_-]?access[_-]?key|password"
+)
+
+
+SENSITIVE_NAMED_KEY_PATTERN = (
+    rf"(?:(?:[A-Za-z0-9]+[_.-])*(?:{SENSITIVE_KEY_PATTERN})|"
+    r"(?:[A-Za-z0-9]+[_.-])*token)"
+)
+
+
+SENSITIVE_ENV_NAMES = (
+    "OCR_LLM_TOKEN",
+    "OCR_LLM_AUTH_TOKEN",
+    "OCR_LLM_EXTRA_HEADERS",
+    "GITLAB_API_TOKEN",
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+)
+
+SECRET_SHAPED_ENV_NAME_RE = re.compile(
+    r"(?:^|_)(?:API_?KEY|AUTH_?TOKEN|ACCESS_?TOKEN|BEARER|CREDENTIAL|"
+    r"PASSWORD|PRIVATE_?KEY|SECRET|TOKEN)(?:$|_)",
+    flags=re.IGNORECASE,
+)
+MIN_DISCOVERED_SECRET_LENGTH = 16
+
+
+REDACTION_TOKEN_SEPARATOR = r"[-_\s\u200b-\u200f\u202a-\u202e\u2060-\u206f]*"
+REDACTION_TOKEN_ALIASES = {
+    "authorization": "authorization",
+    "proxyauthorization": "proxy-authorization",
+    "bearer": "bearer",
+    "xapikey": "x-api-key",
+    "apikey": "api_key",
+    "accesstoken": "access_token",
+    "authtoken": "auth_token",
+    "secretkey": "secret_key",
+    "refreshtoken": "refresh_token",
+    "privatetoken": "private_token",
+    "clientsecret": "client_secret",
+    "password": "password",
+}
+REDACTION_TOKEN_PATTERNS = tuple(
+    (
+        re.compile(
+            r"(?i)(?<![A-Za-z0-9])"
+            + REDACTION_TOKEN_SEPARATOR.join(re.escape(char) for char in compact)
+            + r"(?![A-Za-z0-9])"
+        ),
+        canonical,
+    )
+    for compact, canonical in REDACTION_TOKEN_ALIASES.items()
+)
+
+
+def normalize_redaction_tokens(text: str) -> str:
+    """Collapse invisible separators only inside sensitive token names.
+
+    Preserving normal line breaks keeps diagnostics readable and prevents an
+    ``Authorization`` header sweep from consuming subsequent Markdown lines.
+    """
+
+    normalized = text
+    for pattern, canonical in REDACTION_TOKEN_PATTERNS:
+        normalized = pattern.sub(
+            lambda match: (
+                canonical
+                if any(
+                    char.isspace() or unicodedata.category(char) in {"Cf", "Zl", "Zp"}
+                    for char in match.group(0)
+                )
+                else match.group(0)
+            ),
+            normalized,
+        )
+    return normalized
+
+
+def strip_redaction_bypass_controls(text: str) -> str:
+    """Remove invisible controls that can split secret keys or values."""
+
+    return "".join(
+        char
+        for char in text
+        if unicodedata.category(char) not in {"Cc", "Cf", "Zl", "Zp"} or char in "\n\r\t"
+    )
+
+
+def strip_path_controls(text: str) -> str:
+    """Remove every Unicode control/format separator from a display path."""
+
+    return "".join(
+        char for char in text if unicodedata.category(char) not in {"Cc", "Cf", "Cs", "Zl", "Zp"}
+    )
+
+
+def redact_env_secret_values(text: str) -> str:
+    """Replace configured secret values without generic key/value sweeps."""
+
+    if not text:
+        return text
+
+    redacted = text
+    variants: set[str] = set()
+    candidate_names = set(SENSITIVE_ENV_NAMES)
+    candidate_names.update(
+        name
+        for name, value in os.environ.items()
+        if len(value.strip()) >= MIN_DISCOVERED_SECRET_LENGTH
+        and SECRET_SHAPED_ENV_NAME_RE.search(name)
+    )
+    for name in candidate_names:
+        value = os.environ.get(name)
+        if not value or len(value) < 4:
+            continue
+        normalized_value = strip_redaction_bypass_controls(value)
+        for variant in (value, normalized_value):
+            if not variant:
+                continue
+            variants.update(
+                {
+                    variant,
+                    urllib.parse.quote(variant, safe=""),
+                    urllib.parse.quote_plus(variant),
+                }
+            )
+
+    for variant in sorted(variants, key=len, reverse=True):
+        redacted = redacted.replace(variant, "***")
+
+    return redacted
+
+
+def redact_sensitive(text: str) -> str:
+    """Replace known secret values from the process environment with `***`.
+
+    Used before publishing OCR-controlled text to the merge request, including
+    stderr excerpts from `OCR_POST_ERROR_DETAILS=1` and structured OCR JSON
+    fields. Performs two passes:
+
+    1. Replace each known env value (length >= 4). This is exact-match
+       replacement over a small allowlist of secret-bearing environment
+       variables, so short bot/MCP secrets still get redacted without
+       broadening arbitrary text rewrites. URL-encoded forms are covered.
+    2. Sweep generic patterns: whole Authorization header values regardless
+       of auth scheme, `Bearer ...`, `x-api-key: ...`, JSON/key-value secrets,
+       JWT-shaped values, and `token=...`. This catches values OCR may have
+       logged or copied into structured JSON that did not come straight from
+       one of our env vars.
+    """
+
+    if not text:
+        return text
+
+    redacted = normalize_redaction_tokens(strip_redaction_bypass_controls(text))
+    redacted = redact_url_userinfo(redacted)
+    redacted = redact_env_secret_values(redacted)
+
+    # Generic high-entropy sweeps. Order matters: stricter patterns
+    # first so the looser key/value pass doesn't double-redact.
+    # Authorization headers are credentials regardless of auth scheme
+    # (`Basic`, `ApiKey`, `Digest`, custom gateway schemes, or bare values),
+    # so redact the complete header value rather than trying to parse it.
+    redacted = re.sub(
+        r'(?i)("(?:proxy-)?authorization"\s*:\s*")(?:[^"\\]|\\.)*(")',
+        r"\1***\2",
+        redacted,
+    )
+    redacted = re.sub(
+        r"(?i)('(?:proxy-)?authorization'\s*:\s*')(?:[^'\\]|\\.)*(')",
+        r"\1***\2",
+        redacted,
+    )
+    redacted = re.sub(
+        r"(?im)(\b(?:proxy-)?authorization\s*[:=]\s*)[^\r\n]+",
+        r"\1***",
+        redacted,
+    )
+    redacted = re.sub(
+        r"(?i)\bbearer\s+[A-Za-z0-9_.\-+/=~]{12,}",
+        "Bearer ***",
+        redacted,
+    )
+    # JSON-quoted form: `"token": "value"`, `"api_key": "value"`. OCR or
+    # SDK error logs often serialize requests/responses this way. Redact even
+    # short values because the key name already identifies the field as secret.
+    redacted = re.sub(
+        rf'(?i)("{SENSITIVE_NAMED_KEY_PATTERN}"\s*:\s*")' r'(?:[^"\\]|\\.)*(")',
+        r"\1***\2",
+        redacted,
+    )
+    # Named key/value form: `password=...`, `client_secret: ...`,
+    # `private_token=...`. Do not require high entropy for these keys: the
+    # field name itself carries enough signal, and this path is used only for
+    # failure diagnostics. Handle quoted values before unquoted values so
+    # spaces inside `password="..."` are not leaked.
+    redacted = re.sub(
+        rf'(?i)\b({SENSITIVE_NAMED_KEY_PATTERN})(\s*[:=]\s*)"(?:[^"\\]|\\.)*"',
+        r'\1\2"***"',
+        redacted,
+    )
+    redacted = re.sub(
+        rf"(?i)\b({SENSITIVE_NAMED_KEY_PATTERN})(\s*[:=]\s*)'(?:[^'\\]|\\.)*'",
+        r"\1\2'***'",
+        redacted,
+    )
+    redacted = re.sub(
+        rf"(?i)\b({SENSITIVE_NAMED_KEY_PATTERN})(\s*[:=]\s*)[^\"'\s,;&]+",
+        r"\1\2***",
+        redacted,
+    )
+    # Structured logs and URLs often use a bare `token=...` key. Keep it
+    # bounded to query/CLI-like contexts so ordinary prose mentioning
+    # "token" is not aggressively rewritten.
+    redacted = re.sub(
+        r"(?i)(^|[?&;\s])(token=)[A-Za-z0-9_.\-+/=~]{8,}",
+        r"\1\2***",
+        redacted,
+    )
+    # JWT pattern: three base64url segments separated by dots. The
+    # header always starts with `eyJ` (base64 of `{"`); the other two
+    # segments are bounded loosely — real-world JWTs always exceed this.
+    redacted = re.sub(
+        r"\beyJ[A-Za-z0-9_\-]{5,}\.[A-Za-z0-9_\-]{5,}\.[A-Za-z0-9_\-]{5,}\b",
+        "***",
+        redacted,
+    )
+    return redacted
+
+
+def sanitize_ocr_value(value: Any) -> Any:
+    """Recursively redact OCR-controlled strings before MR publication.
+
+    OCR JSON is model/provider-controlled output. Treat every string as
+    publishable until proven otherwise: comments, warnings, tool metadata,
+    and future fields all pass through this sanitizer before any formatting,
+    fingerprinting, or GitLab posting logic consumes them.
+    """
+
+    if isinstance(value, str):
+        return redact_sensitive(value)
+    if isinstance(value, list):
+        return [sanitize_ocr_value(item) for item in value]
+    if isinstance(value, dict):
+        sanitized: dict[Any, Any] = {}
+        for key, item in value.items():
+            sanitized_key = sanitize_ocr_value(key) if isinstance(key, str) else key
+            sanitized[sanitized_key] = sanitize_ocr_value(item)
+        return sanitized
+    return value
+
+
+def redact_url_userinfo_only(value: str) -> str:
+    """Redact only URL userinfo, leaving path/query text unchanged."""
+
+    def replace(match: re.Match[str]) -> str:
+        prefix, userinfo = match.group(1), match.group(2)
+        if not _is_url_userinfo_candidate(userinfo):
+            return match.group(0)
+        return f"{prefix}***@"
+
+    return re.sub(
+        r"(?i)([a-z][a-z0-9+.-]*://)([^/?#@]+)@"
+        r"(?=[^/?#\s@]+(?:[/?#]|[\s,;.!)]|$))",
+        replace,
+        value,
+    )
+
+
+def _is_url_userinfo_candidate(userinfo: str) -> bool:
+    """Return whether text before `@host` is plausibly URL userinfo."""
+
+    normalized = "".join(
+        char for char in userinfo if unicodedata.category(char) not in {"Cc", "Cf", "Zl", "Zp"}
+    )
+    decoded = urllib.parse.unquote(normalized)
+    if not decoded or any(char in decoded for char in "/?#@"):
+        return False
+    if any(char.isspace() for char in userinfo):
+        return ":" in decoded
+    return True
+
+
+def _query_key_is_sensitive(raw_key: str) -> bool:
+    """Return whether a URL query key names a credential."""
+
+    decoded = urllib.parse.unquote_plus(raw_key)
+    decoded = "".join(
+        char for char in decoded if unicodedata.category(char) not in {"Cc", "Cf", "Zl", "Zp"}
+    )
+    decoded = normalize_redaction_tokens(decoded)
+    return re.fullmatch(SENSITIVE_NAMED_KEY_PATTERN, decoded, re.IGNORECASE) is not None
+
+
+def _redact_sensitive_query_values(value: str) -> str:
+    """Redact sensitive query-like key values, including encoded key names."""
+
+    def replace(match: re.Match[str]) -> str:
+        prefix, key, suffix = match.group(1), match.group(2), match.group(4) or ""
+        if not _query_key_is_sensitive(key):
+            return match.group(0)
+        return f"{prefix}{key}=***{suffix}"
+
+    return re.sub(r"(?i)(^|[?&;])([^=?#&;]+)=([^&#;\s]+)(#[^&;\s]*)?", replace, value)
+
+
+def redact_url_userinfo(value: str) -> str:
+    """Redact credentials embedded in URL-like manifest values."""
+
+    value = redact_url_userinfo_only(value)
+    return _redact_sensitive_query_values(value)