Skip to content

The agent that grows with you

5.2 KB
Raw Blame
"""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