Commit Graph
5 Commits
Author SHA1 Message Date
a6523b1967 fix(codex): preserve auth.json API keys through Headroom (#3355)
## Description

Closes #3354.

When Codex uses an OpenAI API key stored in auth.json, Headroom's
generated provider block did not configure authentication. Codex
therefore sent requests to the local Headroom proxy without an
Authorization header and received 401 Missing bearer.

This is separate from #3206: that issue covers ChatGPT OAuth
authentication, while this change covers file-backed API-key
authentication.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature
- [ ] Breaking change
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring

## Changes Made

- Resolve API-key and OAuth credentials from `codex_home_dir()` for both
project and user configurations, honoring `CODEX_HOME`.
- Generate a private, config-specific helper beside `auth.json`; API
keys stay out of generated TOML and Headroom environment variables.
- Configure Codex's supported `auth.command` field for persistent
install, init, and wrap.
- Serialize command and argument paths with literal Unicode and validate
generated TOML before writing provider configurations.
- Abort provider updates with an actionable error if a helper collides
with another file/symlink or cannot be created.
- Use exclusive creation, 0600 permissions on Unix, and content checks
for helper ownership.
- Give project and user configurations independent helper lifetimes.
Retain legacy shared helpers and helpers referenced by
restored/remaining providers or unparseable configurations.
- Preserve unrelated files and the original provider config when
authentication setup fails.
- Remove an unused config-specific helper on uninstall/unwrap.

## Testing

- [x] Focused unit and integration tests pass
- [x] Linting and formatting pass
- [ ] Type checking
- [x] New regression tests added
- [x] Manual runtime testing performed

### Test Output

```text
$ .venv/bin/python -m pytest tests/test_provider_codex_install.py tests/test_install/test_codex_install.py tests/test_cli/test_init_cli.py tests/test_install/test_providers.py tests/test_cli/test_wrap_codex.py -q
284 passed

$ .venv/bin/ruff check .
All checks passed!
$ .venv/bin/ruff format --check .
1744 files already formatted
```

Ruff 0.16.8 matches this branch's CI pin. A focused coverage run reports
93% line/branch coverage for `headroom/providers/codex/install.py` and
covers 44/45 newly added executable lines across the three production
files in this follow-up. This is local focused coverage, not a claim
about the hosted Codecov aggregate. Before the follow-up implementation,
the added local-init/Unicode/helper-isolation regressions produced 6
failures while 118 existing tests passed.

## Real Behavior Proof

- Environment: macOS 26.6.2, Apple Silicon arm64, Python 3.12.11,
Headroom source from this PR, Codex CLI 0.160.0, Sub2API
OpenAI-compatible provider, model `gpt-6-luna`, existing API key in the
user's Codex `auth.json`.
- Setup: start an isolated Headroom proxy on an unused loopback port
with `ProxyConfig(optimize=False, cache_enabled=False,
rate_limit_enabled=False, openai_api_url=<existing upstream>)`. Generate
a temporary provider config with `_ensure_codex_provider(config_path,
port)` while credentials resolve from the user's Codex home. Add `model
= "gpt-6-luna"` and `model_reasoning_effort = "low"` at the document
root. Run the child with its own temporary `CODEX_HOME` and no
`OPENAI_API_KEY` or `OPENAI_BASE_URL` environment variable; its home
contains the generated config, not a copied credential file.
- Exact child command:

```sh
CODEX_HOME=<temporary-home> codex exec --ephemeral --skip-git-repo-check --sandbox read-only --json -C <temporary-workspace> 'Reply with exactly OK. Do not call tools.'
```

Captured after-fix output on 2026-10-07:

```text
Headroom test proxy: ready (optimization disabled)
Codex: 0.160.0; model: gpt-6-luna; auth: generated command, no API-key environment variable
codex exec exit: 0
agent messages: ['OK']
Responses bearer matches auth.json: True
```

The last line comes from an ASGI wrapper that compares the
HTTP/WebSocket Responses request bearer with the file-backed key without
logging either value. The command completed against the real upstream;
no mocked model response was used. The temporary provider config/helper
and test proxy were removed after validation.

- Observed limitation: this upstream rejects WebSocket negotiation with
HTTP 426, so Headroom's existing HTTP streaming fallback completed the
request. This run proves file-backed command authentication and
successful proxy routing, not a successful upstream WebSocket session.
- Not tested in this follow-up: a new Windows/Linux runtime run, full
test suite, native-extension rebuild, or optimization behavior. The
focused Python suite reused the existing local native extension; no Rust
code changed.

## Runtime Rollout Safety

- Rollout-managed feature(s): None.
- Minimum rollout channel: N/A.
- Stable/default behavior changed: Yes, only when Codex has a
file-backed API key and Headroom writes a provider block.
- Kill switch / disable path: Remove the Headroom-managed provider block
or run the existing Codex unwrap command.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert the generated provider block; auth.json is
unchanged.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of the code
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective
- [x] New and existing unit tests pass locally with my changes
- [x] I did not edit CHANGELOG.md

## Additional Notes

Helpers contain no credential value and read the user's existing
credential file at runtime, so key rotation does not require
reinstalling. Helper names now include a hash of the owning config's
canonical path. Legacy fixed-name helpers are retained conservatively
because other project configurations may still use them.

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/3355"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: JD Davis <mxjerrett@gmail.com>
2026-10-08 10:46:55 -05:00
2f81fa5931 fix(codex): detect ChatGPT auth from id_token claims so wrap/init emit requires_openai_auth (#3212)
Fixes #3206.

## The report

`headroom wrap codex` / `init codex` write a provider block without
`requires_openai_auth = true`. Codex then attaches **no `Authorization`
header**, and every request through the proxy 401s:

```
unexpected status 401 Unauthorized: Missing bearer or basic authentication in header
```

Silently — `headroom doctor` reported green throughout. The reporter
lost ~15h of scheduled Codex automation before bisecting it.

## Not the fix the issue suggested

The issue proposes adding the line unconditionally. **That would
re-break API-key users**, which is the regression `requires_openai_auth`
was made conditional for in the first place (#406) — the flag forces
Codex to demand an OpenAI OAuth login.

All three writers (install provider-scope, `init codex`, `wrap codex`)
*already* call `codex_uses_chatgpt_auth()` and emit the key when it
returns True. **The bug is in the detection, not the writers.**

## Root cause

`codex_uses_chatgpt_auth` recognised two shapes:

1. `auth_mode == "chatgpt"`
2. a top-level `tokens.account_id`

Newer Codex can write an `auth.json` with **neither** — the account
identity lives only in the `id_token` claims, under
`https://api.openai.com/auth.chatgpt_account_id`. That config reads as
API-key mode, the flag is omitted, and every request 401s.

Verified against a real `auth.json`: the JWT claim carries the *same*
account id as the top-level key, so it is a faithful signal for the
shape that lacks it.

## Fix

A third detection tier, consulted only when the first two are absent:

| Shape | Before | After |
|---|---|---|
| `auth_mode = "chatgpt"` | True | True |
| legacy `tokens.account_id` | True | True |
| **only the `id_token` claim** | **False** ← the bug | **True** |
| `auth_mode = "apikey"` + ChatGPT id_token | False | **False** (#406
stays closed) |
| API key, no tokens | False | False |
| id_token without the claim / malformed / blank id | False | False |

The payload is **decoded, not verified**. It is a local file the user
already owns, and the result only chooses which key we write into their
own `config.toml` — nothing is authenticated or authorised on the
strength of it. An API-key user has no ChatGPT id_token, so this cannot
resurrect #406, and an explicit `auth_mode` still wins outright (pinned
by test).

## Doctor stops reporting a false green

This failure is invisible from every other signal — proxy up, provider
block present. So the codex check now WARNs when the config is routed,
the user is on ChatGPT auth, **and** the block lacks the flag, naming
the re-run that repairs it.

It only runs when the flag is already missing, and the keyring fallback
it can reach is bounded by an existing 3s timeout, so `doctor` stays
fast. API-key users are never nagged.

## Existing configs

Self-healing — all three writers strip and regenerate the managed block
on every run, so re-running `wrap`/`init` emits the key now that
detection is correct. No separate migration needed.

## Testing

99 passing across the two suites. Confirmed **discriminating**: 3 of the
new tests fail against unfixed source and pass after —

- `test_chatgpt_auth_detected_from_id_token_claims_alone`
- `test_provider_block_emits_requires_openai_auth_for_the_new_shape`
-
`TestCodexRouting::test_chatgpt_auth_without_requires_openai_auth_warns`

plus explicit coverage for the #406 guard, malformed tokens, blank
account ids, and the API-key-not-nagged case.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Tejas Chopra <tejas@Tejass-MacBook-Pro.local>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
2026-08-22 15:29:54 -07:00
gglucassandClaude Opus 4.8 8c00f7103c fix(codex): poll /wham/usage for subscription limits (handshake no longer sends x-codex-* headers) (#924)
## Description

Codex's subscription usage window (primary/secondary rate-limit gauges)
stopped populating for ChatGPT-OAuth sessions. This PR restores it by
polling Codex's dedicated usage endpoint instead of relying on response
headers that are no longer sent.

### Why the previous approach no longer works

The existing code populates `CodexRateLimitState` from `x-codex-*`
rate-limit headers captured on the `/v1/responses` WebSocket handshake
(`update_from_headers` at WS accept). That worked when OpenAI returned
`x-codex-primary-used-percent`, `x-codex-primary-window-minutes`, etc.
on the handshake response.

OpenAI has since stopped sending those headers on the ChatGPT WebSocket
handshake. I confirmed this by faithfully replaying a real Plus-account
handshake (both `prewarm` and regular `request_kind`): no `x-codex-*`
headers come back on either. This matches OpenAI's own move to a
dedicated usage endpoint (`GET /backend-api/codex/usage` in CodexApi
mode) and reports such as openai/codex#14728. So `update_from_headers`
now runs on every accept but finds nothing to parse, and the window
silently stays empty.

The headers aren't coming back, so there is nothing to fix in the
parsing path. The data now lives behind a request we have to make
ourselves.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)

## Changes Made

- `subscription/codex_rate_limits.py`:
- `parse_codex_usage_payload()` / `update_from_usage_payload()` — map
the `GET /backend-api/wham/usage` JSON (`rate_limit.primary_window` /
`secondary_window` with `used_percent`, `limit_window_seconds`,
`reset_at`; `credits`; `rate_limit_reached_type`) into the existing
`CodexRateLimitState`. `limit_window_seconds` is converted to
window-minutes with the same round-up codex-rs uses (`(secs + 59) //
60`).
- `maybe_schedule_usage_poll()` — fire-and-forget, throttled to one
request per 60s, scoped to ChatGPT sessions (requires both a Bearer
token and `ChatGPT-Account-Id`; API-key traffic is skipped). Uses an
in-flight guard so concurrent accepts don't stack polls. Endpoint is
overridable via `HEADROOM_CODEX_USAGE_URL`.
- `proxy/handlers/openai.py`:
- At the Codex WS accept site, after the now-usually-empty
`update_from_headers` block, schedule the usage poll. Wrapped in
`contextlib.suppress` and fully non-blocking so it can never delay or
fail the WebSocket accept.

The old header-capture path is intentionally left in place as a no-cost
fallback in case OpenAI restores the headers.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [x] Manual testing performed (live `/wham/usage` replay against a Plus
account returned HTTP 200 with the expected schema; payload fixture in
tests mirrors that real shape)

## Test Output

```
$ uv run pytest tests/test_codex_rate_limits.py -q
........................................                                 [100%]
41 passed in 0.16s

$ uv run ruff check headroom/subscription/codex_rate_limits.py headroom/proxy/handlers/openai.py tests/test_codex_rate_limits.py
All checks passed!

$ uv run mypy headroom/subscription/codex_rate_limits.py
Success: no issues found in 1 source file
```

## Additional Notes

- New tests cover: full-payload mapping, window-minutes round-up,
credits balance kept only when `has_credits`, promo object vs string,
empty payload returns `None`, missing `used_percent` skipped,
header-gating (requires Bearer + account-id), poll throttling, and
no-event-loop safety.
- Scoping to `ChatGPT-Account-Id` keeps the poll off API-key traffic,
and the 60s throttle plus in-flight guard bound it to at most one
lightweight GET per minute per running proxy.

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-12 17:03:14 -05:00
JerrettDavisandClaude Opus 4.7 4071d57134 fix(ci): update tests to assert absence of requires_openai_auth (bug 3, #406)
- Restore build_provider_section() to headroom/providers/codex/install.py
  without requires_openai_auth (was removed entirely; pre-existing test
  test_provider_codex_install.py imports it and would fail to collect)
- Flip test_codex_provider_section_preserves_openai_oauth to assert
  requires_openai_auth is ABSENT, not present (old behavior was wrong)
- Fix test_provider_codex_runtime.py:337 same way — init config must
  NOT contain requires_openai_auth
- Fix Ruff B023 lint error in test_providers.py:492 — capture loop
  variable config_path in lambda default arg (_p=config_path)
- Fix e2e/init/run.py _verify_codex_local and _verify_codex_global to
  assert requires_openai_auth is absent, not present
- Fix e2e/wrap/run.py verify_codex_wrap same way

All unit tests pass locally (82 affected tests green).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-06 12:18:47 -05:00
JerrettDavisandCopilot 06428d20fd fix: preserve Codex OAuth proxy delivery
Preserve Codex OAuth-safe provider config across init, wrap, and

persistent install paths, and strengthen coverage so Codex requests

are proven to reach Headroom and the mock upstream.

The wrap e2e now sends a real chat-completions probe and checks

Headroom /stats. Runtime tests cover temporary launch env, install

env, init config, provider-scope config delivery, and the Python

3.11 ws bootstrap path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-05-05 21:03:42 -05:00