| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169 |
- """OpenAI Codex browser login: authorization-code + PKCE on a loopback listener (opt-in).
- ``hermes auth add openai-codex --browser`` (or ``auth.codex_login_flow: browser``) sends the
- system browser to OpenAI's authorize endpoint and receives the code on
- ``http://localhost:1455/auth/callback`` — the redirect URI fixed by the public Codex client
- registration, so the port is not negotiable. Organizations that disable the device-code grant can
- still sign in this way (#95743). The device-code flow in ``auth_codex.py`` stays the default and is
- the fallback whenever the loopback port is already taken (a Codex CLI login in progress).
- Credentials come back in the same dict shape as ``_codex_device_code_login`` with
- ``source="loopback_pkce"`` so the pool/singleton save paths treat both flows alike. Tokens,
- authorization codes and the PKCE verifier are never logged or printed.
- Derived from #97058 by @astraltrekkin, re-homed after the ``auth_codex.py`` split.
- """
- from __future__ import annotations
- import hmac
- import logging
- import secrets
- import webbrowser
- from typing import Any, Dict, Optional
- from urllib.parse import urlencode
- from hermes_cli.auth_constants import AuthError, CODEX_OAUTH_CLIENT_ID, CODEX_OAUTH_TOKEN_URL, _codex_err
- from hermes_cli.auth_device_flow import (
- _bind_loopback_callback_server, _can_open_graphical_browser, _make_loopback_callback_handler,
- _pkce_code_challenge, _pkce_code_verifier, _print_loopback_ssh_hint, _serve_loopback_callback)
- logger = logging.getLogger("hermes_cli.auth")
- CODEX_OAUTH_AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize"
- CODEX_OAUTH_BROWSER_SCOPE = "openid profile email offline_access"
- # Registered with the Codex client: ``http://localhost:1455/auth/callback``. The listener binds
- # 127.0.0.1 explicitly; only the redirect URI string says ``localhost``.
- CODEX_BROWSER_CALLBACK_PORT = 1455
- CODEX_BROWSER_CALLBACK_PATH = "/auth/callback"
- CODEX_BROWSER_CALLBACK_TIMEOUT_SECONDS = 300.0
- CODEX_LOGIN_FLOWS = ("device_code", "browser")
- CODEX_BROWSER_PORT_BUSY_CODE = "codex_browser_port_busy"
- _PORT_BUSY_NOTICE = (
- f"Port {CODEX_BROWSER_CALLBACK_PORT} is already in use (a Codex CLI sign-in may be running). "
- "OpenAI only redirects to that port, so falling back to the device-code login.")
- def _codex_login_flow(args: Any) -> str:
- """``browser`` only when the user asked for it: ``--browser`` or ``auth.codex_login_flow``."""
- if getattr(args, "browser", False):
- return "browser"
- from hermes_cli.config import load_config_readonly
- auth_cfg = (load_config_readonly() or {}).get("auth")
- flow = str((auth_cfg or {}).get("codex_login_flow", "device_code") if isinstance(auth_cfg, dict) else "device_code")
- flow = flow.strip().lower() or "device_code"
- if flow not in CODEX_LOGIN_FLOWS:
- print(f"Ignoring unknown auth.codex_login_flow {flow!r} (expected one of {', '.join(CODEX_LOGIN_FLOWS)}).")
- return "device_code"
- return flow
- def codex_oauth_login(args: Any) -> dict[str, Any]:
- """Run the Codex OAuth flow selected by *args*/config; port-busy browser attempts fall back."""
- from hermes_cli import auth as auth_mod # late: ``hermes_cli.auth.<name>`` patches must intercept
- if _codex_login_flow(args) == "browser":
- try:
- return _codex_browser_login(
- open_browser=not getattr(args, "no_browser", False),
- timeout_seconds=getattr(args, "timeout", None))
- except AuthError as exc:
- if exc.code != CODEX_BROWSER_PORT_BUSY_CODE:
- raise
- print(_PORT_BUSY_NOTICE)
- print()
- print("Signing in to OpenAI Codex...")
- print("(Hermes creates its own session — won't affect Codex CLI or VS Code)")
- print()
- return auth_mod._codex_device_code_login()
- def _codex_browser_authorize_url(*, redirect_uri: str, state: str, code_challenge: str) -> str:
- return f"{CODEX_OAUTH_AUTHORIZE_URL}?" + urlencode({
- "response_type": "code", "client_id": CODEX_OAUTH_CLIENT_ID, "redirect_uri": redirect_uri,
- "scope": CODEX_OAUTH_BROWSER_SCOPE, "code_challenge": code_challenge,
- "code_challenge_method": "S256", "id_token_add_organizations": "true", "state": state})
- def _codex_browser_exchange_code(code: str, *, redirect_uri: str, code_verifier: str) -> dict[str, Any]:
- """Swap the authorization code for tokens at the token endpoint the device flow also uses."""
- from hermes_cli.auth_codex import _codex_login_post, _codex_login_rate_limited_error
- token_resp = _codex_login_post(
- CODEX_OAUTH_TOKEN_URL,
- data={
- "grant_type": "authorization_code", "code": code, "redirect_uri": redirect_uri,
- "client_id": CODEX_OAUTH_CLIENT_ID, "code_verifier": code_verifier},
- headers={"Content-Type": "application/x-www-form-urlencoded"},
- failure=("Token exchange failed", "token_exchange_failed"))
- if token_resp.status_code == 429:
- raise _codex_login_rate_limited_error(token_resp, during=" during token exchange")
- if token_resp.status_code != 200:
- raise _codex_err(
- f"Token exchange returned status {token_resp.status_code}.", "token_exchange_error")
- tokens = token_resp.json()
- if not tokens.get("access_token", ""):
- raise _codex_err(
- "Token exchange did not return an access_token.", "token_exchange_no_access_token")
- return tokens
- def _codex_browser_login(
- *, open_browser: bool = True, timeout_seconds: Optional[float] = None) -> dict[str, Any]:
- """Authorization-code + PKCE login on the loopback listener; returns the device-flow creds shape.
- Raises ``AuthError(code=CODEX_BROWSER_PORT_BUSY_CODE)`` when :1455 cannot be bound so the caller
- can fall back to the device-code flow instead of failing the login.
- """
- from hermes_cli.auth import _utc_now_z
- from hermes_cli.auth_codex import _codex_base_url
- code_verifier = _pkce_code_verifier()
- state = secrets.token_urlsafe(32)
- handler_cls, result = _make_loopback_callback_handler(CODEX_BROWSER_CALLBACK_PATH, display_name="OpenAI Codex")
- server = _bind_loopback_callback_server(
- "127.0.0.1", CODEX_BROWSER_CALLBACK_PORT, handler_cls, err=_codex_err,
- bind_failed_code=CODEX_BROWSER_PORT_BUSY_CODE)
- redirect_uri = f"http://localhost:{server.server_address[1]}{CODEX_BROWSER_CALLBACK_PATH}"
- auth_url = _codex_browser_authorize_url(
- redirect_uri=redirect_uri, state=state, code_challenge=_pkce_code_challenge(code_verifier))
- print()
- print("Signing in to OpenAI Codex (browser authorization)...")
- print("(Hermes creates its own session — won't affect Codex CLI or VS Code)")
- print()
- print(f"Open this URL to authorize Hermes:\n {auth_url}\n")
- _print_loopback_ssh_hint(redirect_uri)
- if open_browser and _can_open_graphical_browser():
- try:
- opened = webbrowser.open(auth_url)
- except Exception:
- opened = False
- print("Browser opened for OpenAI authorization." if opened
- else "Could not open the browser automatically; use the URL above.")
- wait = float(timeout_seconds or CODEX_BROWSER_CALLBACK_TIMEOUT_SECONDS)
- print(f"Waiting for the OpenAI callback on {redirect_uri} (timeout {int(wait)}s, Ctrl+C to cancel)...")
- try:
- callback = _serve_loopback_callback(
- server, result, timeout_seconds=wait, err=_codex_err, timeout_code="codex_browser_callback_timeout")
- except KeyboardInterrupt:
- print("\nLogin cancelled.")
- raise SystemExit(130)
- if callback.get("error"):
- detail = callback.get("error_description") or callback["error"]
- raise _codex_err(f"OpenAI authorization failed: {detail}", "codex_browser_auth_denied")
- if not hmac.compare_digest(str(callback.get("state") or ""), state):
- raise _codex_err(
- "Authorization callback state mismatch — the redirect did not come from this login. Aborting.",
- "codex_browser_state_mismatch")
- code = str(callback.get("code") or "").strip()
- if not code:
- raise _codex_err("Authorization callback did not carry a code.", "codex_browser_no_code")
- print("Exchanging the authorization code for Codex tokens...")
- tokens = _codex_browser_exchange_code(code, redirect_uri=redirect_uri, code_verifier=code_verifier)
- return {
- "tokens": {
- "access_token": tokens.get("access_token", ""),
- "refresh_token": tokens.get("refresh_token", "")},
- "base_url": _codex_base_url(), "last_refresh": _utc_now_z(), "auth_mode": "chatgpt",
- "source": "loopback_pkce"}
|