| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236 |
- """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)
|