mostlyright-data 0.31.2__tar.gz → 0.31.3__tar.gz

{mostlyright_data-0.31.2 → mostlyright_data-0.31.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.31.2
+Version: 0.31.3
 Summary: Mostly Right hosted CLI for reviewed datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.31.2 → mostlyright_data-0.31.3}/src/mostlyright/data_harness/thin/transport.py

@@ -10,14 +10,20 @@ to relax any of it.
 
 from __future__ import annotations
 
+import hashlib
 import http.client
 import ipaddress
 import math
+import re
 import ssl
 import threading
 import time
 from collections.abc import Callable, Iterator, Mapping
 from contextlib import contextmanager
+from email.message import Message
+from email.utils import parsedate_to_datetime
+from http.cookiejar import Cookie, CookieJar, DefaultCookiePolicy
+from http.cookies import CookieError, SimpleCookie
 from typing import Any, Protocol
 from urllib.error import HTTPError
 from urllib.parse import urlsplit
@@ -176,6 +182,78 @@ class UrlLibTransport:
             response.close()
 
 
+class _RoutingCookiePolicy(DefaultCookiePolicy):
+    """Only Cloud Run's observed host-only routing cookie is retained."""
+
+    def set_ok(self, cookie: Cookie, request: Request) -> bool:
+        if (
+            cookie.name != "GAESA"
+            or cookie.domain_specified
+            or not cookie.path_specified
+            or cookie.path != "/"
+            or len(cookie.value or "") > 4096
+        ):
+            return False
+        # Cloud Run emits this without Secure. The transport accepts only
+        # verified HTTPS, and the stored form must never permit an HTTP send.
+        cookie.secure = True
+        return super().set_ok(cookie, request)
+
+
+class _RoutingCookieResponse:
+    def __init__(self, header: str) -> None:
+        self.headers = Message()
+        self.headers["Set-Cookie"] = header
+
+    def info(self) -> Message:
+        return self.headers
+
+
+def _remember_routing_cookie(
+    jar: CookieJar, response: http.client.HTTPResponse, request: Request
+) -> None:
+    candidates = [
+        value
+        for key, value in response.getheaders()
+        if key.lower() == "set-cookie" and value.partition("=")[0].strip() == "GAESA"
+    ]
+    if len(candidates) != 1:
+        return
+    header = candidates[0]
+    if (
+        len(header) > 8192
+        or "\r" in header
+        or "\n" in header
+        or len(re.findall(r"(?:^|[;,])\s*GAESA\s*=", header)) != 1
+    ):
+        return
+    parsed = SimpleCookie()
+    try:
+        parsed.load(header)
+        if set(parsed) != {"GAESA"}:
+            return
+        routing = parsed["GAESA"]
+        if not re.fullmatch(r"[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*", routing.value):
+            return
+        if routing["max-age"]:
+            age = routing["max-age"]
+            if (
+                not re.fullmatch(r"-?\d+", age)
+                or len(age.lstrip("-")) > 10
+                or abs(int(age)) > 2_147_483_647
+            ):
+                return
+        if routing["expires"]:
+            parsedate_to_datetime(routing["expires"])
+    except (CookieError, ValueError, OverflowError):
+        return
+    try:
+        jar.extract_cookies(_RoutingCookieResponse(header), request)
+    except (ValueError, OverflowError):
+        # Optional routing metadata must never invalidate a complete answer.
+        return
+
+
 class ReusableHttpsTransport(UrlLibTransport):
     """One serialized, verified HTTPS connection for repeated query requests.
 
@@ -183,6 +261,8 @@ class ReusableHttpsTransport(UrlLibTransport):
     own connection instead, never a global credential-bearing pool. Changing
     origin closes the old socket. Responses are bounded and fully framed;
     any failure discards the socket and is raised without replaying a POST.
+    Only the host-only root GAESA routing cookie is retained in memory, bound
+    to this client's exact origin and authorization context, never login cookies.
     Streams retain the original urllib/proxy-free/redirect-free behavior.
     """
 
@@ -191,6 +271,8 @@ class ReusableHttpsTransport(UrlLibTransport):
         self._lock = threading.Lock()
         self._connection: http.client.HTTPSConnection | None = None
         self._connection_origin: tuple[str, str, int] | None = None
+        self._routing = CookieJar(policy=_RoutingCookiePolicy())
+        self._routing_context: tuple[tuple[str, str, int], bytes] | None = None
 
     def _discard(self) -> None:
         connection, self._connection = self._connection, None
@@ -201,6 +283,8 @@ class ReusableHttpsTransport(UrlLibTransport):
     def close(self) -> None:
         with self._lock:
             self._discard()
+            self._routing.clear()
+            self._routing_context = None
 
     def __enter__(self) -> ReusableHttpsTransport:
         return self
@@ -248,6 +332,19 @@ class ReusableHttpsTransport(UrlLibTransport):
             return value
 
         try:
+            context_headers = sorted(
+                (name.lower(), value)
+                for name, value in headers.items()
+                if name.lower() in {"authorization", "proxy-authorization", "cookie", "x-api-key"}
+            )
+            context = (origin, hashlib.sha256(repr(context_headers).encode()).digest())
+            if context != self._routing_context:
+                self._routing.clear()
+                self._routing_context = context
+            caller_cookie = any(name.lower() == "cookie" for name in headers)
+            cookie_request = Request(url, headers=dict(with_user_agent(headers)), method=method)
+            if not caller_cookie:
+                self._routing.add_cookie_header(cookie_request)
             if self._connection_origin != origin:
                 self._discard()
             if self._connection is None:
@@ -262,7 +359,7 @@ class ReusableHttpsTransport(UrlLibTransport):
             path = parts.path or "/"
             if parts.query:
                 path += "?" + parts.query
-            connection.request(method, path, body=body, headers=dict(with_user_agent(headers)))
+            connection.request(method, path, body=body, headers=dict(cookie_request.header_items()))
             if connection.sock is not None:
                 connection.sock.settimeout(remaining())
             response = connection.getresponse()
@@ -285,6 +382,8 @@ class ReusableHttpsTransport(UrlLibTransport):
                 )
             if expected is not None and length != expected:
                 raise http.client.IncompleteRead(raw, expected - length)
+            if not caller_cookie:
+                _remember_routing_cookie(self._routing, response, cookie_request)
             status = int(response.status)
             response_headers = {key.lower(): value for key, value in response.headers.items()}
             response.close()