| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385 |
- """Dashboard OAuth/login-status helpers: provider catalog, per-provider device pollers,
- Anthropic/Claude-Code status probes, and the poller for provider-profile device logins.
- """
- import contextlib
- import logging
- import functools
- import os
- import threading
- import time
- from datetime import datetime, timezone, UTC
- from typing import Any, Dict, Optional
- # Same logger the code used before extraction (record parity).
- _log = logging.getLogger("hermes_cli.web_server")
- _LOGGED_OUT: dict[str, Any] = {"logged_in": False, "source": None}
- def _truncate_token(value: Optional[str], visible: int = 6) -> str:
- """``…XXXXXX`` (last N chars) for UI display. JWTs show only the tail of the signature
- segment. A callable (Azure Foundry Entra-ID bearer provider) is NEVER invoked — it yields
- the ``<entra-id-bearer>`` placeholder."""
- if not value:
- return ""
- if callable(value) and not isinstance(value, str):
- return "<entra-id-bearer>"
- s = str(value)
- if s.count(".") >= 2:
- s = s.rsplit(".", 1)[-1]
- return s if len(s) <= visible else f"…{s[-visible:]}"
- def _token_status(source: str, source_label: str, creds: dict[str, Any]) -> dict[str, Any]:
- return {
- "logged_in": True, "source": source, "source_label": source_label,
- "token_preview": _truncate_token(creds.get("accessToken")),
- "expires_at": creds.get("expiresAt"), "has_refresh_token": bool(creds.get("refreshToken")),
- }
- def _anthropic_oauth_status() -> dict[str, Any]:
- """Status for the "Anthropic Account" card: Hermes-managed PKCE file first, then the
- registry-ordered env vars (process env — where Bitwarden-sourced secrets land — then .env).
- Claude Code's ``~/.claude/.credentials.json`` is deliberately NOT read here; it has its own
- ``claude-code`` entry, and counting it here would shadow a real ANTHROPIC_API_KEY.
- """
- try:
- from agent.anthropic_credentials import read_hermes_oauth_credentials, _get_hermes_oauth_file
- hermes_creds = read_hermes_oauth_credentials()
- except Exception:
- hermes_creds = None
- if hermes_creds and hermes_creds.get("accessToken"):
- return _token_status("hermes_pkce", f"Hermes PKCE ({_get_hermes_oauth_file()})", hermes_creds)
- env_var_order: tuple = ("ANTHROPIC_API_KEY", "ANTHROPIC_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN")
- try:
- from hermes_cli.auth import PROVIDER_REGISTRY
- env_var_order = PROVIDER_REGISTRY["anthropic"].api_key_env_vars
- except (ImportError, KeyError):
- pass
- from hermes_cli.config import get_env_value
- from hermes_cli.env_loader import format_secret_source_suffix
- for var in env_var_order:
- value = get_env_value(var) or os.getenv(var)
- if value:
- return {
- "logged_in": True, "source": "env_var", "source_label": f"{var}{format_secret_source_suffix(var)}",
- "token_preview": _truncate_token(value), "expires_at": None, "has_refresh_token": False,
- }
- return dict(_LOGGED_OUT)
- def _claude_code_only_status() -> dict[str, Any]:
- """Claude Code CLI credentials as their own entry, independent of the Anthropic card.
- Connected follows the same local validity gate as Anthropic resolution. A
- persisted access token that has already expired is not a usable login.
- """
- try:
- from agent.anthropic_credentials import (
- is_claude_code_token_valid,
- read_claude_code_credentials,
- )
- creds = read_claude_code_credentials()
- if creds and is_claude_code_token_valid(creds):
- return _token_status("claude_code_cli", "~/.claude/.credentials.json", creds)
- except Exception:
- pass
- return dict(_LOGGED_OUT)
- def _external_process_cli_command(provider_id: str, default: str) -> str:
- """Render an external-process provider's sign-in command with the CLI actually configured
- (its profile's ``process_command_env_vars`` override); others get ``default`` untouched."""
- try:
- from hermes_cli.auth import PROVIDER_REGISTRY, get_external_process_provider_status
- pconfig = PROVIDER_REGISTRY.get(provider_id)
- if not pconfig or pconfig.auth_type != "external_process":
- return default
- status = get_external_process_provider_status(provider_id) or {}
- command = str(status.get("command") or "").strip()
- if command:
- parts = default.split(" ", 1)
- tail = f" {parts[1]}" if len(parts) > 1 else ""
- return f"{command}{tail}"
- except Exception:
- pass
- return default
- # Hand-tuned OAuth/account cards: the bits not derivable from the unified provider catalog
- # (``flow``, ``status_fn``, ``cli_command``, display order). OVERRIDE BASE for
- # ``_build_oauth_catalog()``, which unions them with every accounts-tab provider so new
- # providers appear automatically (a provider profile customises its own card through
- # ``account_card`` / ``account_status`` / ``start_device_login``). Also carries two non-catalog rows:
- # the Anthropic credential-status card and the synthetic ``claude-code`` row.
- # ``flow``: ``device_code`` = show code + URL + poll; ``external`` = delegated to a terminal/CLI.
- _OAUTH_PROVIDER_CATALOG: tuple[dict[str, Any], ...] = (
- # status_fn None → dispatched via auth.get_<provider>_auth_status.
- {"id": "nous", "name": "Nous Portal", "flow": "device_code", "cli_command": "hermes auth add nous",
- "docs_url": "https://portal.nousresearch.com", "status_fn": None},
- {"id": "openai-codex", "name": "ChatGPT or Codex Subscription", "flow": "device_code",
- "cli_command": "hermes auth add openai-codex", "docs_url": "https://platform.openai.com/docs",
- "status_fn": None},
- {"id": "qwen-oauth", "name": "Qwen (via Qwen CLI)", "flow": "external",
- "cli_command": "hermes auth add qwen-oauth", "docs_url": "https://github.com/QwenLM/qwen-code",
- "status_fn": None},
- # Structurally device-code (verification URI + user code + token polling) with a PKCE
- # code-binding extension that doesn't change the operator UX.
- {"id": "minimax-oauth", "name": "MiniMax (OAuth)", "flow": "device_code",
- "cli_command": "hermes auth add minimax-oauth", "docs_url": "https://www.minimax.io", "status_fn": None},
- # Device code works in remote shells/containers without a reachable 127.0.0.1 callback.
- {"id": "xai-oauth", "name": "xAI Grok OAuth (SuperGrok / Premium+)", "flow": "device_code",
- "cli_command": "hermes auth add xai-oauth",
- "docs_url": "https://hermes-agent.nousresearch.com/docs/guides/xai-grok-oauth", "status_fn": None},
- # Anthropic / Claude entries sit at the bottom. Deliberately flow == "external": an
- # in-dashboard Connect button would let a scriptable HTTP endpoint mint Claude Pro/Max
- # subscription tokens outside Anthropic's own client, against its OAuth usage policies.
- # Login works via the terminal (`hermes auth add anthropic`) or a plain API key.
- {"id": "anthropic", "name": "Anthropic Account", "flow": "external", "cli_command": "hermes auth add anthropic",
- "docs_url": "https://docs.claude.com/en/api/getting-started", "status_fn": _anthropic_oauth_status},
- {"id": "claude-code", "name": "Anthropic OAuth: Required Extra Usage Credits to Use Subscription",
- "flow": "external", "cli_command": "claude setup-token",
- "docs_url": "https://docs.claude.com/en/docs/claude-code", "status_fn": _claude_code_only_status},
- )
- _oauth_sessions: dict[str, dict[str, Any]] = {}
- _oauth_sessions_lock = threading.Lock()
- def _oauth_profile_name(profile: Optional[str]) -> Optional[str]:
- requested = (profile or "").strip()
- if not requested or requested.lower() == "current":
- return None
- return requested
- def _oauth_poller(label: str):
- """Wrap a device-code poller body ``fn(session_id, sess)``: vanished session is a no-op,
- success marks ``approved``, any exception records ``error`` + ``error_message`` on the
- session instead of raising (the thread has no caller; the dashboard reads the status)."""
- def deco(fn):
- @functools.wraps(fn)
- def poller(session_id: str) -> None:
- with _oauth_sessions_lock:
- sess = _oauth_sessions.get(session_id)
- if not sess:
- return
- try:
- fn(session_id, sess)
- with _oauth_sessions_lock:
- # A body that already settled the session (a sign-in the user declined in the
- # browser is ``denied`` with a ``reason``) keeps its verdict.
- settled = sess["status"] != "pending"
- if not settled:
- sess["status"] = "approved"
- if settled:
- _log.info("oauth/device: %s login ended %s (session=%s)", label, sess["status"], session_id)
- else:
- _log.info("oauth/device: %s login completed (session=%s)", label, session_id)
- except Exception as e:
- from hermes_cli.observability.shared_metrics_setup import note_oauth_failure
- _log.warning("%s device-code poll failed (session=%s): %s", label, session_id, e)
- note_oauth_failure(sess, e)
- with _oauth_sessions_lock:
- sess["status"] = "error"
- sess["error_message"] = str(e)
- return poller
- return deco
- def _record_sign_in_state(sess: dict[str, Any], state: Any) -> None:
- """Write one ``anon_auth.SignInState`` onto the dashboard session, under the sessions lock.
- The whole desktop mapping lives here: the state carries its own copy, so nothing below turns a
- reason into a string. ``completed`` deliberately leaves ``status`` on ``"pending"`` so the
- :func:`_oauth_poller` wrapper stamps ``"approved"`` when the poller returns.
- """
- kind = getattr(state, "kind", "")
- if kind in ("code", "waiting"):
- return # the start route already published the code
- with _oauth_sessions_lock:
- if kind == "completed":
- sess["account_email"] = state.email or None
- # None when the config was left on the user's own model, as the poll route documents.
- sess["model"] = state.model if state.model_changed else None
- # What the free tier's handoff did (moved apps, apps to reconnect); empty without one.
- sess["handoff"] = list(state.handoff)
- # The same result as fields, so the desktop can name the apps and follow a retry.
- sess["handoff_status"] = state.handoff_status
- return
- if kind == "cancelled":
- sess["status"] = "cancelled"
- return
- if kind == "timed_out":
- sess["status"], sess["reason"] = "error", "timeout"
- # The enriched device-auth guidance, which the dashboard has room for.
- sess["error_message"] = state.detail or state.copy
- return
- sess["status"] = "error"
- sess["reason"] = getattr(state, "reason", "") or kind or "error"
- sess["error_message"] = state.copy # the chat form: no raw exception reaches the UI
- # Whether a later attempt can succeed, and the wait the service named (seconds).
- sess["retryable"] = bool(getattr(state, "retryable", False))
- sess["retry_after"] = int(getattr(state, "retry_after", 0) or 0)
- @_oauth_poller("nous")
- def _nous_sign_in_poller(session_id: str, sess: dict[str, Any]) -> None:
- """Drain the sign-in the start route began: the one shared flow, rendered onto the session.
- The generator was created and advanced to its ``Code`` state by ``_start_nous_device_code``, so
- it is already holding the device code and its HTTP client. Nothing here is wrapped in
- ``_profile_scope``: that context manager holds a process-global lock and swaps module
- attributes across its ``yield``, and this loop can last the sign-in code's whole expiry. The
- generator scopes its own short config/auth-store sections instead.
- """
- gen = sess.get("_sign_in")
- if gen is None:
- return
- try:
- for state in gen:
- _record_sign_in_state(sess, state)
- finally:
- with contextlib.suppress(Exception):
- gen.close() # unwinds the suspended HTTP client if we leave early
- @_oauth_poller("minimax")
- def _minimax_poller(session_id: str, sess: dict[str, Any]) -> None:
- """MiniMax poller: PKCE-style ``code_verifier`` + ``user_code`` instead of Nous's
- ``device_code``. Builds the same auth_state as the CLI's ``_minimax_oauth_login`` and persists
- via ``_minimax_save_auth_state`` so the system ends up as after ``hermes auth add minimax-oauth``.
- Region is fixed to "global" here; cn-region operators use the CLI's ``--region cn``."""
- from hermes_cli.web_server_profiles import _profile_scope
- from hermes_cli.auth import (
- _minimax_poll_token, _minimax_resolve_token_expiry_unix, _minimax_save_auth_state,
- MINIMAX_OAUTH_GLOBAL_INFERENCE, MINIMAX_OAUTH_SCOPE,
- )
- import httpx
- portal_base_url, client_id = sess["portal_base_url"], sess["client_id"]
- with httpx.Client(
- timeout=httpx.Timeout(15.0), headers={"Accept": "application/json"}, follow_redirects=True
- ) as client:
- token_data = _minimax_poll_token(
- client=client, portal_base_url=portal_base_url, client_id=client_id,
- user_code=sess["user_code"], code_verifier=sess["code_verifier"],
- expired_in=sess["expired_in_raw"], interval_ms=sess.get("interval_ms"),
- )
- now = datetime.now(UTC)
- expires_at_ts = _minimax_resolve_token_expiry_unix(int(token_data["expired_in"]), now=now)
- auth_state = {
- "provider": "minimax-oauth",
- "region": sess.get("region", "global"),
- "portal_base_url": portal_base_url,
- "inference_base_url": MINIMAX_OAUTH_GLOBAL_INFERENCE,
- "client_id": client_id,
- "scope": MINIMAX_OAUTH_SCOPE,
- "token_type": token_data.get("token_type", "Bearer"),
- "access_token": token_data["access_token"],
- "refresh_token": token_data["refresh_token"],
- "resource_url": token_data.get("resource_url"),
- "obtained_at": now.isoformat(),
- "expires_at": datetime.fromtimestamp(expires_at_ts, tz=UTC).isoformat(),
- "expires_in": max(0, int(expires_at_ts - now.timestamp())),
- }
- with _profile_scope(sess.get("profile")):
- # The cancellation check and the save share the session lock, so a cancel cannot land
- # between them (the same contract as the Nous and Codex savers).
- with _oauth_sessions_lock:
- if sess.get("cancelled"):
- sess["status"] = "cancelled"
- return
- _minimax_save_auth_state(auth_state)
- @_oauth_poller("xai")
- def _xai_device_poller(session_id: str, sess: dict[str, Any]) -> None:
- """Background poller for xAI's OAuth device-code flow."""
- from hermes_cli.web_server_profiles import _profile_scope
- import httpx
- from hermes_cli.auth import (
- _save_xai_oauth_tokens, _xai_oauth_discovery, _xai_oauth_poll_device_token,
- mark_provider_active_if_unset, unsuppress_credential_source,
- )
- discovery = _xai_oauth_discovery(20.0)
- with httpx.Client(timeout=httpx.Timeout(20.0), headers={"Accept": "application/json"}) as client:
- token_data = _xai_oauth_poll_device_token(
- client, token_endpoint=discovery["token_endpoint"], device_code=sess["device_code"],
- expires_in=max(60, int(sess["expires_at"] - time.time())), poll_interval=int(sess["interval"]),
- )
- tokens = {
- "access_token": str(token_data.get("access_token", "") or "").strip(),
- "refresh_token": str(token_data.get("refresh_token", "") or "").strip(),
- "id_token": str(token_data.get("id_token", "") or "").strip(),
- "expires_in": token_data.get("expires_in"),
- "token_type": str(token_data.get("token_type") or "Bearer").strip() or "Bearer",
- }
- with _profile_scope(sess.get("profile")), _oauth_sessions_lock:
- # One critical section with the cancel check, as in the Nous and Codex savers.
- if sess.get("cancelled"):
- sess["status"] = "cancelled"
- return
- # set_active=False: persist without hijacking an existing active chat provider.
- _save_xai_oauth_tokens(
- tokens, discovery=discovery, auth_mode="oauth_device_code", set_active=False,
- last_refresh=datetime.now(UTC).isoformat().replace("+00:00", "Z"),
- )
- # Mirror `hermes auth add xai-oauth`: first credential may become active; never overwrite.
- mark_provider_active_if_unset("xai-oauth")
- # The singleton write is the source of truth (the pool load seeds it as the canonical
- # ``device_code`` entry). Do NOT add a parallel ``manual:dashboard_*`` pool entry — it
- # duplicates the single-use refresh token and triggers ``refresh_token_reused`` churn.
- # An interactive login is an explicit re-enable, so clear any prior suppression.
- unsuppress_credential_source("xai-oauth", "device_code")
- def _sleep_unless_cancelled(sess: dict[str, Any], seconds: float) -> bool:
- """Sleep *seconds* in short ticks; True as soon as the session is cancelled."""
- deadline = time.monotonic() + seconds
- while True:
- with _oauth_sessions_lock:
- if sess.get("cancelled"):
- return True
- left = deadline - time.monotonic()
- if left <= 0:
- return False
- time.sleep(min(0.25, left))
- _DEVICE_LOGIN_ENDINGS = {"denied": "Authorization was denied.", "expired": "Device code expired before approval"}
- @_oauth_poller("provider-profile")
- def _profile_device_poller(session_id: str, sess: dict[str, Any]) -> None:
- """Drive a device-code login a provider profile owns (``ProviderProfile.start_device_login``):
- one ``poll_device_login`` per interval (each bound to the session's profile) until approved, then
- ``save_device_login`` under the session's profile scope, in one critical section with the cancel check like the built-in savers."""
- from hermes_cli.web_server_profiles import _config_profile_scope, _profile_scope
- profile, state, interval = sess["_provider_profile"], sess["_device_state"], int(sess["interval"])
- result: dict[str, Any] = {}
- while time.time() < sess["expires_at"]:
- if _sleep_unless_cancelled(sess, interval):
- break
- with _config_profile_scope(sess.get("profile")): # await-safe: no skills lock across the wait
- result = dict(profile.poll_device_login(state) or {})
- state = result.get("state", state)
- if result.get("status") != "pending":
- break
- interval = int(result.get("interval") or interval)
- with _profile_scope(sess.get("profile")), _oauth_sessions_lock:
- if sess.get("cancelled"):
- sess["status"] = "cancelled"
- return
- status = result.get("status")
- if status in (None, "pending"): # the code's lifetime ran out
- status = "expired"
- if status != "approved":
- sess["status"] = status if status in _DEVICE_LOGIN_ENDINGS else "error"
- sess["error_message"] = result.get("message") or _DEVICE_LOGIN_ENDINGS.get(status) or "Sign-in failed"
- return
- profile.save_device_login(result.get("credential"))
|