| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200 |
- """Signed-in provider requests that core makes FOR plugins; the token never reaches plugin code.
- A plugin that needs the user's subscription sign-in (today: Codex / ChatGPT) must not read, refresh
- or rewrite Hermes's auth store or ``~/.codex/auth.json``. Codex refresh tokens are single-use, so a
- second refresher races Hermes's locked refresh and can sign the user out. Instead the plugin declares
- ``requires_auth: [openai-codex]`` in its ``plugin.yaml`` and calls :func:`credentialed_provider_request`.
- Hermes resolves the credential through its own locked-refresh path, attaches ``Authorization``
- itself, sends only to that provider's origins, never follows a redirect, and hands back
- status, headers and body.
- The caller is identified by file location: the nearest stack frame inside an installed plugin
- directory. Like capabilities this is consent and visibility, not a sandbox. In-process plugin code
- can still read any file the user can.
- """
- from __future__ import annotations
- import json as _json
- import sys
- from dataclasses import dataclass
- from pathlib import Path
- from typing import Any, Callable, Mapping, Optional
- from hermes_cli.urllib_security import url_origin
- class ProviderNotSignedIn(RuntimeError):
- """The user has no usable sign-in for the provider in this Hermes profile."""
- @dataclass(frozen=True)
- class ProviderResponse:
- status: int
- headers: dict[str, str]
- body: bytes
- @property
- def text(self) -> str:
- return self.body.decode("utf-8", "replace")
- def json(self) -> Any:
- return _json.loads(self.body)
- def _codex_auth(url: str) -> tuple[dict[str, str], str]:
- """``(auth headers, credential base URL)`` from Hermes's own locked-refresh resolver."""
- from agent.codex_headers import codex_account_headers
- from agent.turn_failure_copy import oauth_relogin_command
- from hermes_cli.auth_codex import resolve_codex_runtime_credentials
- from hermes_cli.auth_constants import AuthError
- try:
- creds = resolve_codex_runtime_credentials()
- except AuthError as exc:
- if not exc.relogin_required:
- raise
- creds = {}
- token = str(creds.get("api_key") or "").strip()
- if not token:
- raise ProviderNotSignedIn(
- f"Not signed in to Codex in Hermes. Run `{oauth_relogin_command('openai-codex')}` "
- "or sign in to OpenAI Codex under Providers in the Hermes desktop app.")
- headers = codex_account_headers(token) if url_origin(url)[1] == "chatgpt.com" else {}
- headers["Authorization"] = f"Bearer {token}"
- return headers, str(creds.get("base_url") or "")
- # provider -> (origins its token may be sent to, auth resolver). chatgpt.com is the Codex backend
- # core itself calls; api.openai.com hosts the Realtime client-secret endpoint Codex clients use.
- _PROVIDERS: dict[str, tuple[frozenset, Callable[[str], tuple[dict[str, str], str]]]] = {
- "openai-codex": (frozenset({("https", "chatgpt.com", 443), ("https", "api.openai.com", 443)}), _codex_auth),
- }
- def _plugin_roots() -> set[Path]:
- """Every plugins directory an installed plugin can live under, as given and resolved."""
- from hermes_cli.plugins import get_bundled_plugins_dir
- from hermes_constants import get_default_hermes_root, get_hermes_home, get_process_hermes_home
- bases = (get_hermes_home() / "plugins", get_process_hermes_home() / "plugins",
- get_default_hermes_root() / "plugins", get_bundled_plugins_dir())
- return {r for base in bases for r in (base.absolute(), base.resolve())}
- def _calling_plugin_dir() -> Optional[Path]:
- """Directory of the plugin whose code is nearest on the calling stack, or None."""
- roots = _plugin_roots()
- frame = sys._getframe(2)
- while frame is not None:
- raw = Path(frame.f_code.co_filename)
- for path in (raw.absolute(), raw.resolve()):
- root = next((r for r in roots if path.is_relative_to(r) and path != r), None)
- if root is None:
- continue
- for parent in path.parents:
- if parent == root:
- break
- if (parent / "plugin.yaml").is_file() or (parent / "plugin.yml").is_file():
- return parent
- return root / path.relative_to(root).parts[0]
- frame = frame.f_back
- return None
- def _detached(exc: BaseException) -> BaseException:
- """*exc* without traceback or chain: those frames hold the token, refresh token or client secret."""
- exc.__cause__ = exc.__context__ = None
- return exc.with_traceback(None)
- def declared_auth_providers(manifest: Mapping[str, Any]) -> list[str]:
- """``requires_auth`` from a manifest dict: the providers whose sign-in the plugin uses."""
- raw = (manifest or {}).get("requires_auth")
- return [str(p).strip() for p in raw if str(p).strip()] if isinstance(raw, list) else []
- def requires_auth_notice(manifest: Mapping[str, Any]) -> str:
- """One line for install/show surfaces; empty when the plugin declares no sign-in use."""
- from hermes_cli.plugin_oauth import oauth_notice
- providers = declared_auth_providers(manifest)
- sign_in = (f"Uses your sign-in for: {', '.join(providers)} (Hermes sends the requests; "
- "the plugin never receives the token)") if providers else ""
- return "; ".join(part for part in (sign_in, oauth_notice(manifest)) if part)
- def _declared_providers(plugin_dir: Path) -> list[str]:
- from pm.plugin_declarations import native_manifest_file, read_native_manifest
- manifest = native_manifest_file(plugin_dir)
- return declared_auth_providers(read_native_manifest(manifest)) if manifest else []
- def credentialed_provider_request(
- provider: str, method: str, url: str, *, json: Any = None,
- headers: Optional[Mapping[str, str]] = None, timeout: float = 30.0,
- ) -> ProviderResponse:
- """Send ``method url`` with the user's *provider* sign-in attached by Hermes.
- *provider* is a Hermes sign-in (listed under ``requires_auth``) or an ``id`` the calling plugin
- declares under ``oauth:`` (:mod:`hermes_cli.plugin_oauth`); the plugin's own entry wins.
- Refuses (``PermissionError``) a caller outside an installed plugin, a plugin whose ``plugin.yaml``
- does not list *provider* under ``requires_auth``, and any origin outside the provider's
- allowlist; raises :class:`ProviderNotSignedIn` when this profile has no sign-in. Redirects are
- returned as-is, never followed. The result carries no credential.
- """
- from hermes_cli.plugin_oauth import _plugin_oauth_spec
- plugin_dir = _calling_plugin_dir()
- if plugin_dir is None:
- raise PermissionError("credentialed_provider_request must be called from an installed plugin's code")
- # The plugin's own oauth: entry first, so a core provider added later under the same id cannot take it over.
- spec = _plugin_oauth_spec(plugin_dir, provider)
- if spec is None:
- spec = _PROVIDERS.get(provider)
- if spec is None:
- raise ValueError(f"No signed-in requests for provider {provider!r} (supported: {', '.join(_PROVIDERS)}, "
- "or an id the plugin declares under oauth: in plugin.yaml)")
- if provider not in _declared_providers(plugin_dir):
- raise PermissionError(
- f"Plugin '{plugin_dir.name}' must declare `requires_auth: [{provider}]` in plugin.yaml")
- origins, resolve = spec
- if url_origin(url) not in origins:
- raise PermissionError(f"Refusing to send the {provider} sign-in to {url_origin(url)[1] or url!r}")
- import httpx
- # Every error the plugin receives past this point is rebuilt without traceback, chain or request: those
- # reach the frames and httpx objects that hold the token, refresh token or client secret.
- refusal: Optional[BaseException] = None
- with httpx.Client(timeout=timeout, follow_redirects=False) as client:
- request = client.build_request(method, url, json=json, headers=dict(headers or {})) # no credential yet
- try:
- auth_headers, credential_base = resolve(url)
- except httpx.HTTPError as exc: # a resolver's own refresh POST failed: its request holds the refresh token
- refusal = type(exc)(str(exc))
- except (RuntimeError, OSError, ValueError, LookupError, TypeError) as exc:
- refusal = _detached(exc)
- else:
- if url_origin(credential_base) not in origins:
- # A pooled gateway key belongs to its own host only (#121486).
- refusal = PermissionError(
- f"This profile's {provider} credential routes to a custom endpoint; refusing")
- else:
- for name in auth_headers:
- request.headers.pop(name, None)
- request.headers.update(auth_headers)
- try:
- response = client.send(request)
- except httpx.HTTPError as exc:
- refusal = type(exc)(str(exc))
- auth_headers = request = None
- if refusal is not None:
- raise refusal
- return ProviderResponse(response.status_code, dict(response.headers), response.content)
- __all__ = [
- "ProviderNotSignedIn", "ProviderResponse", "credentialed_provider_request", "declared_auth_providers",
- "requires_auth_notice",
- ]
|