Skip to content

The agent that grows with you

11.7 KB
Raw Blame
"""Explicit RFC 8628 MCP login, sharing SDK discovery, client auth and token storage.

The SDK still owns runtime requests and refresh. Device authorization is only
started by `hermes mcp login/reauth`, never a background reconnect.
"""
from __future__ import annotations

import asyncio
import math
import sys
import time

from mcp.shared.auth import OAuthMetadata
from pydantic import AnyHttpUrl

DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code"


class DeviceOAuthMetadata(OAuthMetadata):
    # RFC 8414 makes authorization_endpoint optional for grants not using it.
    authorization_endpoint: AnyHttpUrl | None = None
    device_authorization_endpoint: AnyHttpUrl


async def _discover(client, provider):
    from mcp.client.auth.exceptions import OAuthFlowError
    from mcp.client.auth.utils import (
        build_protected_resource_metadata_discovery_urls,
        extract_resource_metadata_from_www_auth,
        handle_protected_resource_response,
    )
    context = provider.context
    response = await client.get(context.server_url)
    challenge = extract_resource_metadata_from_www_auth(response)
    prm = None
    for url in build_protected_resource_metadata_discovery_urls(challenge, context.server_url):
        response = await client.get(url)
        prm = await handle_protected_resource_response(response)
        if prm:
            await provider._validate_resource_match(prm)
            context.protected_resource_metadata = prm
            break
    # RFC 9728 lets a resource advertise several authorization servers; a browser-only
    # server often comes first and the device-code one later, so try each in order.
    servers = [str(url) for url in prm.authorization_servers] if prm else [None]
    failures = []
    for auth_server_url in servers:
        try:
            metadata = await _device_metadata(client, context.server_url, auth_server_url)
        except (RuntimeError, OAuthFlowError, ValueError) as exc:
            failures.append((auth_server_url, exc))
            continue
        context.auth_server_url = auth_server_url
        context.oauth_metadata = metadata
        return
    if len(failures) == 1:
        raise failures[0][1]
    raise RuntimeError("No advertised authorization server supports device login: "
                       + "; ".join(f"{url}: {exc}" for url, exc in failures))


async def _device_metadata(client, server_url, auth_server_url):
    """Issuer-bound device metadata of one authorization server; raises when it is unusable."""
    from mcp.client.auth.utils import build_oauth_authorization_server_metadata_discovery_urls

    from tools.mcp_oauth_provider import metadata_issued_by_origin

    for url in build_oauth_authorization_server_metadata_discovery_urls(auth_server_url, server_url):
        response = await client.get(url)
        if response.status_code == 404:
            continue
        data = _payload(response, "OAuth metadata")
        if not data.get("device_authorization_endpoint"):
            raise RuntimeError("Server does not advertise device authorization; use --flow browser if supported")
        metadata = DeviceOAuthMetadata.model_validate(data)
        # The advertised identifier reaches here as str(AnyHttpUrl) with a trailing "/" (pydantic
        # normalizes a host-only URL to its root path) while the document issuer keeps the advertised
        # form, so the SDK's exact-string check (RFC 8414 §3.3) would reject Google's issuer
        # ("https://accounts.google.com" != "https://accounts.google.com/"). Compare both sides
        # root-slash-normalized, the same convention _metadata_issuer and the refresh-token issuer
        # binding already use; any other mismatch is still rejected.
        expected = auth_server_url.rstrip("/") if auth_server_url else auth_server_url
        if expected and not metadata_issued_by_origin(metadata, expected, response):
            if str(metadata.issuer).rstrip("/") != expected:
                from mcp.client.auth.exceptions import OAuthFlowError
                raise OAuthFlowError(f"Authorization server metadata issuer mismatch: {metadata.issuer} != {expected}")
        grants = metadata.grant_types_supported
        if grants is not None and DEVICE_GRANT not in grants:
            raise RuntimeError("Server does not advertise the device_code grant")
        return metadata
    raise RuntimeError("No OAuth authorization server metadata found")


def _payload(response, label):
    try:
        data = response.json()
    except ValueError:
        raise RuntimeError(f"{label}: invalid JSON response") from None
    if not isinstance(data, dict):
        raise RuntimeError(f"{label}: expected a JSON object")
    if not 200 <= response.status_code < 300:
        # Descriptions and arbitrary error values may contain credentials.
        raise RuntimeError(f"{label} failed (HTTP {response.status_code})")
    return data


async def _register(client, provider, cfg):
    from mcp.shared.auth import OAuthClientInformationFull
    from mcp.client.auth.oauth2 import OAuthRegistrationError, check_registration_usable

    context = provider.context
    metadata = context.client_metadata.model_dump(mode="json", exclude_none=True)
    metadata.update(grant_types=[DEVICE_GRANT, "refresh_token"], response_types=[])
    if cfg.get("client_id"):
        data = {**metadata, "client_id": cfg["client_id"]}
        if cfg.get("client_secret"):
            data["client_secret"] = cfg["client_secret"]
    else:
        endpoint = context.oauth_metadata.registration_endpoint
        if not endpoint:
            raise RuntimeError("Server has no registration endpoint; configure oauth.client_id (and client_secret if required)")
        response = await client.post(str(endpoint), json=metadata)
        data = _payload(response, "Client registration")
    # SEP-2352: bind the credentials to the identifier the SDK's runtime flow compares them against — the
    # advertised authorization server when the resource advertised one, else the metadata issuer (its Step 4
    # rule). For a path-scoped server whose document names its origin (#116233) the two differ, and a
    # binding to the document issuer would make the next 401 discard this client and its tokens.
    data["issuer"] = str(context.auth_server_url or context.oauth_metadata.issuer)
    context.client_info = OAuthClientInformationFull.model_validate(data)
    provider._coerce_client_secret_post()
    try:
        check_registration_usable(context.client_info)
    except OAuthRegistrationError:
        raise RuntimeError("Device OAuth client has unsupported or incomplete token endpoint authentication") from None


def _positive_seconds(value, label):
    value = float(value)
    if not math.isfinite(value) or value <= 0:
        raise RuntimeError(f"Device authorization has invalid {label}")
    return value


async def _authorize(client, provider, cfg):
    from tools.mcp_oauth_provider import google_offline_access_params
    from tools.mcp_tool import sdk_httpx

    context = provider.context
    resource = context.get_resource_url()
    data = {"client_id": context.client_info.client_id, "resource": resource}
    if context.client_metadata.scope:
        data["scope"] = context.client_metadata.scope
    data.update(google_offline_access_params(context))
    data, headers = context.prepare_token_auth(data, {})
    response = await client.post(str(context.oauth_metadata.device_authorization_endpoint), data=data, headers=headers)
    authorization = _payload(response, "Device authorization")
    for key in ("device_code", "user_code", "verification_uri"):
        if not isinstance(authorization.get(key), str) or not authorization[key]:
            raise RuntimeError(f"Device authorization is missing {key}")
    verification = AnyHttpUrl(authorization["verification_uri"])
    interval = _positive_seconds(authorization.get("interval", 5), "interval")
    deadline = time.monotonic() + min(_positive_seconds(authorization["expires_in"], "expires_in"),
                                     _positive_seconds(cfg.get("timeout", 300), "timeout"))
    print(f"\n  MCP OAuth: open {verification} on any device.\n  Code: {authorization['user_code']}\n"
          "  Waiting for approval...\n", file=sys.stderr, flush=True)
    token_data = {"client_id": context.client_info.client_id, "device_code": authorization["device_code"],
                  "grant_type": DEVICE_GRANT, "resource": resource}
    token_data, headers = context.prepare_token_auth(token_data, {})
    httpx = sdk_httpx()
    while True:
        remaining = deadline - time.monotonic()
        if remaining <= interval:
            raise RuntimeError("Device authorization expired before approval; run login again")
        await asyncio.sleep(interval)
        request = provider._prepare_token_request(httpx.Request("POST", str(context.oauth_metadata.token_endpoint),
                                                               data=token_data, headers=headers))
        try:
            response = await asyncio.wait_for(client.send(request), timeout=deadline - time.monotonic())
        except (TimeoutError, httpx.TimeoutException):
            # RFC 8628 requires reducing polling frequency after connection timeouts.
            interval *= 2
            continue
        if 200 <= response.status_code < 300:
            from mcp.shared.auth import OAuthToken
            tokens = OAuthToken.model_validate(_payload(response, "Device token"))
            if not tokens.access_token:
                raise RuntimeError("Device token response has no access token")
            if tokens.scope is None:
                tokens.scope = context.client_metadata.scope
            return tokens
        try:
            error = response.json().get("error")
        except (ValueError, AttributeError):
            error = None
        if error == "authorization_pending":
            continue
        if error == "slow_down":
            interval += 5
            continue
        safe_error = error if error in {"access_denied", "expired_token"} else f"HTTP {response.status_code}"
        raise RuntimeError(f"Device authorization failed: {safe_error}")


async def login_device(name, server_url, oauth_config):
    """Authorize then commit state in the active profile; failed grants preserve old state."""
    from tools.mcp_oauth import _build_client_metadata
    from tools.mcp_oauth_manager import HermesMCPOAuthProvider, get_manager
    from tools.mcp_oauth_provider import prepare_oauth_config
    from tools.mcp_tool import sdk_httpx

    cfg, storage = prepare_oauth_config(name, server_url, oauth_config)
    # Device flow never binds a callback socket or uses the hosted browser CIMD.
    cfg["_resolved_port"] = cfg.get("redirect_port", 8420)
    provider = HermesMCPOAuthProvider(server_url=server_url, server_name=name, storage=storage,
                                     client_metadata=_build_client_metadata(cfg),
                                     token_user_agent=cfg.get("user_agent"))
    httpx = sdk_httpx()
    try:
        async with httpx.AsyncClient(timeout=10, follow_redirects=False) as client:
            await _discover(client, provider)
            await _register(client, provider, cfg)
            tokens = await _authorize(client, provider, cfg)
    except (ValueError, TypeError, KeyError):
        raise RuntimeError("Device OAuth response has invalid fields") from None
    except httpx.HTTPError:
        raise RuntimeError("Device OAuth network request failed") from None
    # Validate the entire grant before touching disk; reuse the existing scoped store.
    previous = storage.snapshot()
    try:
        await storage.set_client_info(provider.context.client_info)
        storage.save_oauth_metadata(provider.context.oauth_metadata)
        await storage.set_tokens(tokens)
    except OSError:
        storage.restore(previous)
        raise
    get_manager().evict(name)