Add auth split and App-controlled Fast lifecycle

Author: gaoguobin

.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "codex-fast-proxy",
   "version": "0.1.0",
-  "description": "Codex App Fast/Priority proxy for third-party OpenAI-compatible Responses API providers.",
+  "description": "Codex App proxy for third-party OpenAI-compatible Responses API providers with Fast/Priority controls.",
   "author": {
     "name": "gaoguobin",
     "url": "https://github.com/gaoguobin"
@@ -24,8 +24,8 @@
   "skills": "./skills/",
   "interface": {
     "displayName": "Codex Fast Proxy",
-    "shortDescription": "Fast/Priority proxy for Codex App with third-party APIs.",
-    "longDescription": "Manage a local, safety-bounded proxy and Agent Skill so Codex App users on third-party OpenAI-compatible API providers can enable, verify, benchmark, update, and uninstall the Fast/Priority path.",
+    "shortDescription": "Third-party API proxy for Codex App with Fast/Priority controls.",
+    "longDescription": "Manage a local, safety-bounded proxy and Agent Skill so Codex App users on third-party OpenAI-compatible API providers can preserve the App Fast toggle, optionally force global Fast/Priority, split upstream auth for ChatGPT login, verify traffic, benchmark, update, and uninstall.",
     "developerName": "gaoguobin",
     "category": "Developer Tools",
     "capabilities": [

.codex/INSTALL.md

@@ -75,10 +75,44 @@ Do not claim the skill is available before the restart.
 After restarting Codex App or opening a new CLI process, the user can ask:
 
 - `启用 Codex Fast proxy`
-- `让 Codex App 使用 Fast`
+- `启用 Codex Fast proxy 的 ChatGPT 登录兼容模式`
+- `全局开启 Codex Fast proxy 的 Fast 注入`
 - `查看 Codex Fast proxy 状态`
 - `停止 Codex Fast proxy`
 
+Default enable uses `--service-tier-policy auto`. In ChatGPT-login or unclear states this respects
+Codex App/CLI Fast UI choices; in API-key mode it may inject the priority tier when Codex omits
+`service_tier`, because the App Fast UI may not be available. Use
+`--service-tier-policy inject_missing` only when the user explicitly asks for global Fast injection,
+and `--service-tier-policy preserve` only when they explicitly want no proxy-side Fast injection. If
+the user wants ChatGPT login compatibility for plugins/GitHub/Apps/connectors while model requests
+still use a third-party provider, configure an upstream key environment variable with
+`--upstream-api-key-env <ENV_NAME>`; do not ask the user to paste API keys into chat and do not edit
+`auth.json` unless they explicitly request recovery. This auth override applies only to provider API
+requests that already go through the local proxy; it must not intercept or modify ChatGPT
+plugin/GitHub/App connector traffic. In override mode, the proxy replaces provider `Authorization`
+and drops unexpected `Cookie` headers before forwarding upstream.
+
+If Codex currently works through a third-party provider and the user wants to prepare for ChatGPT
+login, run `python -m codex_fast_proxy prepare-chatgpt-login` first as a dry run. Report the
+non-secret JSON fields, then ask before running `python -m codex_fast_proxy prepare-chatgpt-login
+--target-env <ENV_NAME> --apply`. The apply step writes the provider key through the Windows user
+environment API, does not print the key, does not change proxy settings, and does not edit
+`auth.json`. After apply, run `python -m codex_fast_proxy set-upstream --upstream-api-key-env
+<ENV_NAME>` so the manager verifies `POST /v1/responses` with `stream=true` before saving the auth
+split. Tell the user to restart Codex App or open a new CLI process after any user environment
+variable change.
+
+Before first enable or model-path setting changes, `install --start` verifies the candidate upstream
+and auth source by sending one Codex-style `POST /v1/responses` request with `stream=true`. This is
+real provider traffic and can consume a small amount of quota. If verification fails, do not retry
+with `--no-verify` unless the user explicitly accepts that the next Codex session may be unable to
+reach the model.
+
+Enable also writes the Codex hook feature flags and a trusted hook state entry. Treat
+`startup_hook: true` as installed, enabled, and trusted; if `startup_hook_trust` reports `modified`
+or `untrusted`, rerun enable/update instead of assuming `~/.codex/hooks.json` is enough.
+
 ## Existing install
 
 If the repository already exists, fetch and follow:

.codex/SET_UPSTREAM.md

@@ -7,7 +7,9 @@ Do not edit the active provider `base_url` in `~/.codex/config.toml` directly wh
 enabled. That field should keep pointing to the local proxy. API keys, model, reasoning, and other
 Codex settings can still be edited in `config.toml` as usual.
 
-If the user did not provide the new upstream URL, ask for it. Do not guess provider URLs.
+If the user only wants to change Fast policy or ChatGPT-login upstream auth, a new upstream URL is
+not required. If they want to change provider URL and did not provide the new upstream URL, ask for
+it. Do not guess provider URLs.
 
 If the Codex environment uses sandbox or approval controls, request approval/escalation because this
 flow may write under `%USERPROFILE%\.codex`, edit `%USERPROFILE%\.codex\hooks.json`, restart the
@@ -28,12 +30,98 @@ $resultJson
 python -m codex_fast_proxy status
 ```
 
+`set-upstream` verifies the candidate route before writing settings by sending one side-path
+Codex-style `POST /v1/responses` request with `stream=true` to the candidate upstream and auth
+source. This is real provider traffic and can consume a small amount of quota. If verification
+fails, do not retry with `--no-verify` unless the user explicitly accepts that the next Codex session
+may be unable to reach the model.
+
+If the user asks to verify first without changing local state, run:
+
+```powershell
+python -m codex_fast_proxy verify-upstream --upstream-base '<UPSTREAM_BASE_URL>'
+```
+
+Report the JSON result and stop. `verify-upstream` must not write settings, edit Codex config,
+install hooks, or restart the proxy.
+
+For ChatGPT login compatibility without changing the upstream URL, ask for the environment variable
+name that already contains the third-party provider API key. Do not ask the user to paste the key
+value into chat. This affects only provider API requests that already go through the local proxy; it
+must not intercept ChatGPT plugin/GitHub/App connector traffic. In override mode, the proxy replaces
+provider `Authorization` and drops unexpected `Cookie` headers before forwarding upstream.
+
+If the user does not already have a provider key environment variable, run a dry run first:
+
+```powershell
+python -m codex_fast_proxy prepare-chatgpt-login
+```
+
+Report only the non-secret JSON fields. If the dry run found the current working provider key in
+`auth.json` or the environment, ask before applying:
+
+```powershell
+python -m codex_fast_proxy prepare-chatgpt-login --target-env '<ENV_NAME>' --apply
+```
+
+The apply step writes a Windows user environment variable through the manager, does not print the
+key, and does not change proxy settings. After it succeeds, continue with `set-upstream` so the
+manager verifies a streaming `/v1/responses` request before saving the auth override.
+
+```powershell
+$statusJson = python -m codex_fast_proxy status
+$status = $statusJson | ConvertFrom-Json
+if ($status.config_matches -ne $true) {
+    $statusJson
+    throw 'Codex config no longer points to the recorded local proxy. Review ~/.codex/config.toml before changing upstream auth.'
+}
+
+$resultJson = python -m codex_fast_proxy set-upstream --upstream-api-key-env '<ENV_NAME>'
+$resultJson
+python -m codex_fast_proxy status
+```
+
+To clear a previously configured upstream auth environment override and return to preserving Codex's
+original provider `Authorization` header, run:
+
+```powershell
+python -m codex_fast_proxy set-upstream --clear-upstream-api-key-env
+python -m codex_fast_proxy status
+```
+
+For explicit global Fast injection without changing the upstream URL, confirm that the user accepts
+that Codex App's Fast UI toggle will no longer control requests whose `service_tier` is missing, then
+run:
+
+```powershell
+python -m codex_fast_proxy set-upstream --service-tier-policy inject_missing
+python -m codex_fast_proxy status
+```
+
+To return to UI-controlled Fast behavior, run:
+
+```powershell
+python -m codex_fast_proxy set-upstream --service-tier-policy preserve
+python -m codex_fast_proxy status
+```
+
+For the default automatic behavior, where API-key mode can use global priority but ChatGPT-login or
+unclear states preserve the App/CLI choice, run:
+
+```powershell
+python -m codex_fast_proxy set-upstream --service-tier-policy auto
+python -m codex_fast_proxy status
+```
+
 Report the set-upstream JSON and the final status JSON. The key fields are `provider`, `base_url`,
-`previous_upstream_base`, `upstream_base`, `config_matches`, `restart_required`, and `start_result`.
+`previous_upstream_base`, `upstream_base`, `service_tier_policy`, `upstream_auth`, `config_matches`,
+`verification`, `restart_required`, and `start_result`.
 
 Do not use `--restart` unless the user explicitly accepts that restarting the proxy can interrupt
 current proxy-backed Codex sessions. If `restart_required=true`, tell the user to restart Codex App,
 open a new CLI process, or run `python -m codex_fast_proxy start` later to apply the new upstream.
 
-If the user also changed API key environment variables, model, reasoning, or other Codex config, tell
-them to restart Codex App or open a new CLI process so Codex reloads those settings.
+If the user changed API key environment variables, model, reasoning, or other Codex config, tell
+them to restart Codex App or open a new CLI process so Codex reloads those settings. The proxy can
+read Windows user environment variables directly when possible, but already-running Codex processes
+still may need a restart to reload their own config and environment.

.codex/UNINSTALL.md

@@ -68,6 +68,13 @@ if (-not $deferred) {
 
 Report the uninstall JSON result when available.
 
+If the uninstall JSON includes `direct_upstream_auth_warning`, report it before telling the user to
+restart Codex. This means Codex config has been restored to the direct third-party upstream, but the
+current Codex auth state still looks like ChatGPT account login. Direct upstream mode no longer has
+the proxy auth override, so model requests may send ChatGPT auth to the third-party provider and
+fail with 401. Tell the user to switch Codex App back to API-key/third-party provider auth before
+restarting, or keep the proxy enabled if they want ChatGPT-login UI with a third-party provider.
+
 When cleanup completed without `restart_required_before_cleanup=true`, explicitly tell the user:
 
 ```text
@@ -79,3 +86,9 @@ If the block printed `restart_required_before_cleanup=true`, explicitly tell the
 ```text
 配置已恢复直连，代理暂时保留运行以避免打断当前进程；请重启 Codex App 并回到这个对话，或新开 CLI 实例后再次执行卸载完成清理。
 ```
+
+If `direct_upstream_auth_warning` is present, add this before the restart instruction:
+
+```text
+注意：当前检测到 ChatGPT 登录态。卸载恢复直连后不再经过 proxy 的 upstream auth override；如果继续保持 ChatGPT 登录，第三方 provider 可能收到 ChatGPT token 并返回 401。请先退出 ChatGPT 登录并切回第三方/API-key 认证，或暂时不要卸载、继续保留 proxy。
+```

.codex/UPDATE.md

@@ -10,6 +10,16 @@ Fetch and follow instructions from https://raw.githubusercontent.com/gaoguobin/c
 
 ## Update steps
 
+If the user only asks to check whether an update is available, run this read-only command and stop:
+
+```powershell
+python -m codex_fast_proxy check-update
+```
+
+Report the JSON, including `relation`, `update_available`, `local_changes`, and `next_action`. If
+`relation=local_ahead`, do not report it as an available update. Do not pull, install, restart the
+proxy, edit Codex config, or write proxy state unless the user then explicitly asks to update.
+
 If the Codex environment uses sandbox or approval controls, request approval/escalation for the update block because it fetches from GitHub, installs a Python package, may write under `%USERPROFILE%\.codex`, may write `%USERPROFILE%\.codex\hooks.json`, and may create a junction under `%USERPROFILE%\.agents`.
 
 If any command fails because of network, permissions, sandbox write limits, or junction creation, do not try unrelated workarounds. Ask for approval and rerun the same intended update step.
@@ -50,4 +60,41 @@ status JSON as the current state. If the skill was newly linked or changed, expl
 请重启 Codex App 并回到这个对话，或新开 CLI 实例，让它重新扫描 ~/.agents/skills；然后再说“启用 Codex Fast proxy”。
 ```
 
-If `install --start` ran during update, it refreshes `~/.codex/hooks.json` and enables Codex `SessionStart` autostart for future App/CLI starts. It also compares the running proxy runtime with the installed code; if the proxy is healthy but stale, it restarts the proxy before returning. Use the final `status` output to report `runtime_matches` and `needs_restart`. If `status.needs_restart` is still `true`, tell the user to restart Codex App or open a new CLI process; the `SessionStart` hook will retry the stale runtime restart when config still points to the local proxy. Codex may fire `SessionStart` for each new or resumed session; `autostart --quiet` does not log normal no-op checks.
+If `install --start` ran during update, it refreshes `~/.codex/hooks.json` and enables Codex `SessionStart` autostart for future App/CLI starts. It also compares the running proxy runtime with the installed code; if the proxy is healthy but stale, explicit `install --start`/`start` may restart the proxy before returning. Use the final `status` output to report `runtime_matches` and `needs_restart`. If `status.needs_restart` is still `true`, tell the user to restart Codex App, open a new CLI process after the old proxy is gone, or run `python -m codex_fast_proxy start` when it is safe to refresh runtime code. Codex may fire `SessionStart` for each new or resumed session; `autostart --quiet` does not restart an already healthy proxy just because runtime code is stale, and it does not log normal no-op checks.
+
+Current Codex builds may require trusted user hooks. After update, `startup_hook: true` means the
+hook exists, is enabled, and its current command hash is trusted. If `startup_hook_trust` reports
+`modified` or `untrusted`, rerun `python -m codex_fast_proxy install --start` before asking the user
+to rely on autostart.
+
+Current behavior after update:
+
+- New installs default to `auto`: ChatGPT-login or unclear states preserve Codex App/CLI Fast UI
+  choices, while API-key mode can use global priority when Codex omits `service_tier`.
+- Existing `service_tier_policy` and `upstream_api_key_env` settings are preserved during
+  `install --start`.
+- Older installs that never recorded `service_tier_policy` and do not have `upstream_api_key_env`
+  are treated as `inject_missing` to keep their previous global Fast behavior. Missing policy plus
+  `upstream_api_key_env` is treated as App-controlled `preserve`, because that shape belongs to the
+  ChatGPT-login auth split path. If the user explicitly wants auto behavior, run:
+
+```powershell
+python -m codex_fast_proxy set-upstream --service-tier-policy auto
+```
+
+  Do not pass `--restart` unless the user accepts interrupting current proxy-backed Codex sessions.
+
+- For ChatGPT login compatibility after update, first prepare the provider key env without printing
+  the key, then configure only the upstream API key environment variable name:
+
+```powershell
+python -m codex_fast_proxy prepare-chatgpt-login
+python -m codex_fast_proxy prepare-chatgpt-login --target-env PACKY_API_KEY --apply
+python -m codex_fast_proxy set-upstream --upstream-api-key-env PACKY_API_KEY
+```
+
+  The first command is a dry run. Run the `--apply` command only after the user approves writing a
+  Windows user environment variable. Do not pass `--restart` unless the user accepts interrupting
+  current proxy-backed Codex sessions.
+
+Never print API key values, `auth.json` contents, ChatGPT tokens, cookies, request bodies, or prompts.

.gitignore

@@ -6,3 +6,4 @@ __pycache__/
 build/
 dist/
 .pytest_cache/
+.claude/