| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118 |
- """The plane credential (design §4.4 step 2, D26, D31, D32).
- Cloud: the Nous access token from the profile's ``auth.json`` (``resolve_nous_access_token``).
- On-prem: an IdP workload token from the OAuth2 client-credentials grant, configured by
- ``GATEWAY_RELAY_IDP_*`` values in ``.env``. Never from config.yaml (the config is what this token
- fetches) and never from a secret source: :data:`PLANE_CREDENTIAL_ENV_NAMES` lists every env name
- that decides which token is sent where, and boot refuses a secret source that supplies one.
- """
- from __future__ import annotations
- import hashlib
- import json
- import os
- import threading
- import time
- import urllib.parse
- import urllib.request
- from pathlib import Path
- from typing import Dict, Tuple
- IDP_ENV_PREFIX = "GATEWAY_RELAY_IDP_"
- _IDP_KEYS = ("token_url", "client_id", "client_secret", "scope")
- PLANE_CREDENTIAL_ENV_NAMES = frozenset({
- # which backend, which plane, which agent record
- "HERMES_CONFIG_BACKEND", "HERMES_CONFIG_REMOTE_URL", "HERMES_CONFIG_INSTANCE_ID",
- # on-prem workload identity
- *(IDP_ENV_PREFIX + k.upper() for k in _IDP_KEYS),
- # Cloud: where auth.json lives and where its refresh token is sent
- "HERMES_SHARED_AUTH_DIR", "HERMES_PORTAL_BASE_URL", "NOUS_PORTAL_BASE_URL",
- })
- _HTTP_TIMEOUT_S = 15.0
- class PlaneCredentialError(RuntimeError):
- """No plane credential could be obtained. ``retryable`` is False for a missing or partial
- configuration (retrying cannot help)."""
- def __init__(self, message: str, *, retryable: bool) -> None:
- super().__init__(message)
- self.retryable = retryable
- _IDP_CACHE: dict[tuple[str, str, str, str], tuple[float, str]] = {}
- _IDP_LOCK = threading.Lock()
- def _idp_env() -> dict[str, str]:
- return {k: os.environ.get(IDP_ENV_PREFIX + k.upper(), "").strip() for k in _IDP_KEYS}
- def credential_kind() -> str:
- return "idp" if _idp_env()["token_url"] else "nous"
- def plane_token(home: Path) -> str:
- """A fresh bearer for ``home``'s requests (re-resolved per request, contract §10.2)."""
- return _idp_token() if credential_kind() == "idp" else _nous_token(home)
- def _nous_token(home: Path) -> str:
- from hermes_constants import reset_hermes_home_override, set_hermes_home_override
- try:
- from hermes_cli.auth import resolve_nous_access_token
- except Exception as exc:
- raise PlaneCredentialError(f"cannot load the Nous auth module: {exc}", retryable=False) from exc
- token = set_hermes_home_override(home) # auth.json is per profile home
- try:
- return resolve_nous_access_token()
- except Exception as exc:
- # A missing login or a revoked session needs a human; a refresh that hit the network can retry.
- fatal = bool(getattr(exc, "relogin_required", False)) or getattr(exc, "code", None) == "nous_auth_missing"
- raise PlaneCredentialError(
- f"no Nous access token for {home} (auth.json): {exc}", retryable=not fatal) from exc
- finally:
- reset_hermes_home_override(token)
- def _idp_token() -> str:
- env = _idp_env()
- token_url, client_id, client_secret, scope = (env[k] for k in _IDP_KEYS)
- if not client_id or not client_secret:
- raise PlaneCredentialError(
- f"{IDP_ENV_PREFIX}TOKEN_URL is set but {IDP_ENV_PREFIX}CLIENT_ID / {IDP_ENV_PREFIX}CLIENT_SECRET "
- "are not: Remote Config needs the OAuth2 client-credentials grant (both values in .env).",
- retryable=False)
- from .destination import CredentialDestinationError, checked_url, display_url, open_credentialed
- checked_url(token_url, env_name=f"{IDP_ENV_PREFIX}TOKEN_URL") # before the secret leaves the process
- # The secret is part of the identity: a rotated secret fetches a new token on the next request.
- key = (token_url, client_id, scope, hashlib.sha256(client_secret.encode()).hexdigest())
- now = time.monotonic()
- with _IDP_LOCK:
- cached = _IDP_CACHE.get(key)
- if cached is not None and cached[0] > now:
- return cached[1]
- form = {"grant_type": "client_credentials", "client_id": client_id, "client_secret": client_secret}
- if scope:
- form["scope"] = scope
- req = urllib.request.Request(
- token_url, data=urllib.parse.urlencode(form).encode(), method="POST",
- headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"})
- try:
- with open_credentialed(req, timeout=_HTTP_TIMEOUT_S) as resp:
- payload = json.loads(resp.read().decode() or "{}")
- except CredentialDestinationError:
- raise
- except Exception as exc: # HTTP and network errors alike; the message has no secret
- raise PlaneCredentialError(f"IdP token request to {display_url(token_url)} failed: {exc}", retryable=True) from exc
- access_token = payload.get("access_token") if isinstance(payload, dict) else None
- if not isinstance(access_token, str) or not access_token:
- raise PlaneCredentialError("IdP client-credentials response had no access_token", retryable=True)
- expires_in = payload.get("expires_in")
- ttl = float(expires_in) if isinstance(expires_in, int | float) and expires_in > 0 else 60.0
- with _IDP_LOCK:
- _IDP_CACHE[key] = (now + max(ttl - 30.0, 0.0), access_token)
- return access_token
|