Enable OAuth discovery by default for config servers (#62824)

## Why

Config servers that publish OAuth metadata still required administrators
to configure OAuth endpoints explicitly for Codex to use them.

## What changed

- Discover OAuth metadata when `config_server.oauth` is omitted. Use
  explicit settings when provided, and fetch managed configuration
  anonymously when discovery finds no metadata.
- Have the Git credential helper resolve the config server before
  fetching managed configuration. It refuses explicit or discovered
  OAuth so it can apply workspace policy without opening the OS keyring.
- Apply local network policy to discovery during `codex logout`.

## Testing

Cover app-server recovery after a discovery failure, Git credential
helper rejection of explicit OAuth without a network request, and
logout discovery blocked by local network policy.

GitOrigin-RevId: 1ad84effef48fd9b56371ee177bd53c54f3e87b8
This commit is contained in:
vishnu-oai
2026-11-20 19:16:07 +00:00
committed by copyberry
parent 4e9ce8fa9e
commit 60fc55bb69
8 changed files with 183 additions and 92 deletions
@@ -1,10 +1,12 @@
//! Exercises required HTTPS policy through real app-server startup and session RPCs.
use super::https_mock::tls_listener;
use anyhow::Context;
use anyhow::Result;
use app_test_support::TestAppServer;
use codex_app_server_protocol::LoginAccountResponse;
use codex_app_server_protocol::LogoutAccountResponse;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::ThreadResumeParams;
use codex_app_server_protocol::ThreadResumeResponse;
use codex_app_server_protocol::ThreadStartParams;
@@ -15,8 +17,10 @@ use codex_config::test_support::CloudConfigBundleFixture;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
use pretty_assertions::assert_eq;
use serde_json::json;
use std::path::Path;
use std::path::PathBuf;
use std::time::Duration;
use tempfile::TempDir;
use tempfile::tempdir;
use tokio::net::TcpStream;
@@ -32,10 +36,7 @@ async fn config_server_settings_are_fetched_and_applied_at_startup() -> Result<(
skip_if_no_network!(Ok(()));
let setup = ConfigServerSetup::new().await?;
let mut app = setup.start_app().await?;
assert_eq!(
setup.config_server.received_requests().await.unwrap().len(),
1
);
assert_eq!(setup.bundle_request_count().await?, 1);
let started = app
.start_thread(ThreadStartParams {
model_provider: Some("openai".into()),
@@ -50,6 +51,43 @@ async fn config_server_settings_are_fetched_and_applied_at_startup() -> Result<(
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_server_settings_recover_after_discovery_failure() -> Result<()> {
skip_if_no_network!(Ok(()));
let setup = ConfigServerSetup::new().await?;
let failure = Mock::given(method("GET"))
.and(path("/.well-known/oauth-authorization-server/team"))
.respond_with(ResponseTemplate::new(503))
.expect(/*r*/ 1..)
.mount_as_scoped(&setup.config_server)
.await;
let mut app = setup.start_app_with_args(&[]).await?;
let request = app
.send_thread_start_request_with_auto_env(ThreadStartParams::default())
.await?;
let error = tokio::time::timeout(
Duration::from_secs(/*secs*/ 30),
app.read_stream_until_error_message(RequestId::Integer(request)),
)
.await??;
assert_eq!(
error.error.data,
Some(json!({
"reason": "cloudConfigBundle",
"errorCode": "Internal",
"detail": "OAuth discovery failed",
}))
);
assert_eq!(setup.bundle_request_count().await?, 0);
// Missing metadata permits anonymous configuration retrieval.
drop(failure);
let started = app.start_thread(ThreadStartParams::default()).await?;
assert_eq!(started.model_provider, "company");
app.shutdown_gracefully().await?;
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_server_settings_survive_openai_login_and_logout() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -89,10 +127,7 @@ async fn config_server_settings_are_cached_across_restart_and_resume() -> Result
setup
.assert_turn_uses_managed_instructions(&mut app, &resumed.thread.id)
.await?;
assert_eq!(
setup.config_server.received_requests().await.unwrap().len(),
1
);
assert_eq!(setup.bundle_request_count().await?, 1);
app.shutdown_gracefully().await?;
Ok(())
}
@@ -152,7 +187,23 @@ wire_api = 'responses'
})
}
async fn bundle_request_count(&self) -> Result<usize> {
let requests = self
.config_server
.received_requests()
.await
.context("config server request recording is disabled")?;
Ok(requests
.iter()
.filter(|request| request.url.path() == "/team/codex/config/bundle")
.count())
}
async fn start_app(&self) -> Result<TestAppServer> {
self.start_app_with_args(&["--strict-config"]).await
}
async fn start_app_with_args(&self, args: &[&str]) -> Result<TestAppServer> {
let ca_path = self.ca_path.to_string_lossy();
let env = [
("CODEX_CA_CERTIFICATE", Some(ca_path.as_ref())),
@@ -161,7 +212,7 @@ wire_api = 'responses'
];
TestAppServer::builder()
.with_codex_home(self.home.path())
.with_args(&["--strict-config"])
.with_args(args)
.with_env_overrides(&env)
.build_initialized()
.await
+14 -15
View File
@@ -6,6 +6,7 @@ use chrono::Utc;
use clap::Args;
use clap::ValueEnum;
use codex_app_server::in_process::EmbeddedNetworkPolicy;
use codex_cloud_config::anonymous_config_server_bundle_loader;
use codex_cloud_config::managed_config_bundle_loader_for_auth;
use codex_config::types::AuthCredentialsStoreMode;
use codex_core::config::Config;
@@ -133,23 +134,21 @@ async fn git_token_for_origin(
return Ok(None);
}
let requirements = config.config_layer_stack.requirements_toml();
// Config-server OAuth uses the OS keyring, which Git must never open.
ensure!(
requirements
.config_server
.as_ref()
.is_none_or(|server| server.oauth.is_none()),
"Git cannot verify Codex workspace policy using a protected login"
);
let login_changes = manager.auth_change_receiver();
let network = EmbeddedNetworkPolicy::load(&Default::default()).await;
let bundle = managed_config_bundle_loader_for_auth(
network.bind_bootstrap_auth(config.auth_config()),
&auth,
requirements,
)
.await
.map_err(config_unavailable)?;
let bootstrap = network.bind_bootstrap_auth(config.auth_config());
let bundle = if let Some(server) = &requirements.config_server {
anonymous_config_server_bundle_loader(
server,
bootstrap.codex_home,
&bootstrap.auth_route_config,
)
.await?
} else {
managed_config_bundle_loader_for_auth(bootstrap, &auth, requirements)
.await
.map_err(config_unavailable)?
};
let effective = builder
.cloud_config_bundle(bundle)
.build()
+57 -3
View File
@@ -581,9 +581,13 @@ pub async fn run_login_status(cli_config_overrides: CliConfigOverrides) -> ! {
}
}
async fn logout_config_server(config: &Config) -> std::io::Result<bool> {
async fn logout_config_server(
config: &Config,
loader_overrides: &codex_config::LoaderOverrides,
) -> std::io::Result<bool> {
let network = codex_app_server::in_process::EmbeddedNetworkPolicy::load(loader_overrides).await;
match codex_cloud_config::managed_config_auth_manager(
config.auth_config(),
network.bind_bootstrap_auth(config.auth_config()),
config.config_layer_stack.requirements_toml(),
)
.await?
@@ -601,7 +605,7 @@ pub async fn run_logout(cli_config_overrides: CliConfigOverrides) -> ! {
.requirements_toml()
.requires_remote_config()
{
logout_config_server(&config).await
logout_config_server(&config, &Default::default()).await
} else {
Ok(false)
};
@@ -743,16 +747,21 @@ mod storage_tests;
#[cfg(test)]
mod tests {
use codex_config::LoaderOverrides;
use codex_config::types::AuthCredentialsStoreMode;
use codex_core::config::ConfigBuilder;
use codex_login::AuthKeyringBackendKind;
use codex_login::OAuthDeviceCodePrompt;
use codex_login::load_auth_dot_json;
use codex_login::login_with_api_key;
use pretty_assertions::assert_eq;
use std::io::ErrorKind;
use std::net::TcpListener;
use tempfile::tempdir;
use super::clear_existing_auth_before_login;
use super::config_server_device_code_message;
use super::logout_config_server;
use super::safe_format_key;
#[test]
@@ -766,6 +775,51 @@ mod tests {
insta::assert_snapshot!(config_server_device_code_message(&prompt), @"To sign in to the config server, open https://login.example/device and enter code ABCD-EFGH.");
}
#[tokio::test]
async fn logout_config_server_respects_local_network_policy() -> anyhow::Result<()> {
let home = tempdir()?;
let listener = TcpListener::bind("127.0.0.1:0")?;
listener.set_nonblocking(true)?;
let address = listener.local_addr()?;
let requirements_path = home.path().join("requirements.toml");
std::fs::write(
&requirements_path,
format!(
r#"
[config_server]
base_url = "https://{address}"
[application.network.domains]
"127.0.0.1" = "deny"
"#,
),
)?;
let overrides = LoaderOverrides {
system_requirements_path: Some(requirements_path),
ignore_project_config: true,
..LoaderOverrides::without_managed_config_for_tests()
};
let config = ConfigBuilder::default()
.codex_home(home.path().to_path_buf())
.loader_overrides(overrides.clone())
.build()
.await?;
let error = logout_config_server(&config, &overrides)
.await
.expect_err("logout discovery should fail for a denied destination");
assert_eq!(error.to_string(), "OAuth discovery failed");
assert_eq!(
listener
.accept()
.expect_err("logout discovery connected to a denied destination")
.kind(),
ErrorKind::WouldBlock
);
Ok(())
}
#[tokio::test]
async fn clears_existing_auth_before_login() {
let codex_home = tempdir().expect("create temporary Codex home");
+2 -10
View File
@@ -2,7 +2,6 @@ use crate::backend::BackendBundleClient;
use crate::chatgpt::ChatGptSource;
use crate::chatgpt::plan_requires_managed_config;
use crate::config_source::BundleSource;
use crate::discovery::ConfigServerDiscovery;
use crate::service::CLOUD_CONFIG_BUNDLE_TIMEOUT;
use crate::service::CloudConfigBundleService;
use codex_config::CloudConfigBundleLoader;
@@ -29,13 +28,8 @@ pub async fn managed_config_auth_manager(
let Some(service_config) = requirements.config_server.as_ref() else {
return Ok(None);
};
crate::config_server_auth_manager(
service_config,
auth.codex_home,
&auth.auth_route_config,
ConfigServerDiscovery::Disabled,
)
.await
crate::config_server_auth_manager(service_config, auth.codex_home, &auth.auth_route_config)
.await
}
/// How to sign in when the config server has no saved OAuth grant.
@@ -94,7 +88,6 @@ pub async fn managed_config_bundle_loader(
service_config.clone(),
codex_home,
&codex_login::AuthRouteConfig::from_http_client_factory(factory),
ConfigServerDiscovery::Disabled,
)
.await;
}
@@ -122,7 +115,6 @@ pub async fn managed_config_bundle_loader_for_storage(
service_config.clone(),
auth_config.codex_home,
&auth_config.auth_route_config,
ConfigServerDiscovery::Disabled,
)
.await);
}
+35 -22
View File
@@ -7,7 +7,6 @@ use crate::backend::RetryableFailureKind;
use crate::backend::fetch_bundle;
use crate::bundle_loader::managed_config_bundle_loader_for_service;
use crate::config_source::BundleSource;
use crate::discovery::ConfigServerDiscovery;
use crate::discovery::resolve_config_server;
use crate::service::CLOUD_CONFIG_BUNDLE_TIMEOUT;
use crate::service::CloudConfigBundleService;
@@ -38,34 +37,47 @@ pub async fn config_server_bundle_loader(
config: ConfigServer,
codex_home: PathBuf,
routes: &AuthRouteConfig,
discovery: ConfigServerDiscovery,
) -> CloudConfigBundleLoader {
let service = create_config_server_service(&config, &codex_home, routes, discovery).await;
let service = create_config_server_service(&config, &codex_home, routes).await;
let loader = match service {
Ok(service) => {
let (loader, _) = managed_config_bundle_loader_for_service(service);
loader
}
Err(error) => config_server_loader_after_failure(
config.clone(),
codex_home,
routes.clone(),
discovery,
error,
),
Err(error) => {
config_server_loader_after_failure(config.clone(), codex_home, routes.clone(), error)
}
};
loader.with_config_server(config)
}
/// Git must apply the same policy as Codex without opening the OS keyring.
/// Use the checked resolution directly so a second discovery cannot select OAuth.
pub async fn anonymous_config_server_bundle_loader(
config: &ConfigServer,
codex_home: PathBuf,
routes: &AuthRouteConfig,
) -> std::io::Result<CloudConfigBundleLoader> {
let resolved = resolve_config_server(config, routes).await?;
if resolved.oauth.is_some() {
return Err(std::io::Error::other(
"Git cannot verify Codex workspace policy using a protected login",
));
}
let service =
config_server_service(resolved, &codex_home, routes).map_err(std::io::Error::other)?;
let (loader, _) = managed_config_bundle_loader_for_service(service);
Ok(loader.with_config_server(config.clone()))
}
async fn create_config_server_service(
config: &ConfigServer,
codex_home: &Path,
routes: &AuthRouteConfig,
discovery: ConfigServerDiscovery,
) -> Result<CloudConfigBundleService<ConfigServerSource>, CloudConfigBundleLoadError> {
let resolved = resolve_config_server(config, routes, discovery)
let resolved = resolve_config_server(config, routes)
.await
.map_err(|error| {
CloudConfigBundleLoadError::new(
@@ -75,6 +87,14 @@ async fn create_config_server_service(
)
})?;
config_server_service(resolved, codex_home, routes)
}
fn config_server_service(
resolved: ConfigServer,
codex_home: &Path,
routes: &AuthRouteConfig,
) -> Result<CloudConfigBundleService<ConfigServerSource>, CloudConfigBundleLoadError> {
let factory = config_server_http_client_factory(&resolved, routes);
let codex_home = codex_home.to_path_buf();
let source = ConfigServerSource::from_config_server(resolved, codex_home.clone(), factory)?;
@@ -90,7 +110,6 @@ fn config_server_loader_after_failure(
config: ConfigServer,
codex_home: PathBuf,
routes: AuthRouteConfig,
discovery: ConfigServerDiscovery,
error: CloudConfigBundleLoadError,
) -> CloudConfigBundleLoader {
let initialized = Arc::new(OnceCell::new());
@@ -115,13 +134,8 @@ fn config_server_loader_after_failure(
None => {
initialized
.get_or_try_init(|| async move {
let mut service = create_config_server_service(
&config,
&codex_home,
&routes,
discovery,
)
.await?;
let mut service =
create_config_server_service(&config, &codex_home, &routes).await?;
service.policy = policy;
let (loader, _) = managed_config_bundle_loader_for_service(service);
Ok(loader)
@@ -153,9 +167,8 @@ pub async fn config_server_auth_manager(
service_config: &ConfigServer,
codex_home: PathBuf,
routes: &AuthRouteConfig,
discovery: ConfigServerDiscovery,
) -> std::io::Result<Option<OAuthSessionManager>> {
let resolved = resolve_config_server(service_config, routes, discovery).await?;
let resolved = resolve_config_server(service_config, routes).await?;
let factory = config_server_http_client_factory(&resolved, routes);
oauth_session_manager(resolved.oauth.as_deref(), codex_home, &factory)
}
+1 -11
View File
@@ -13,24 +13,14 @@ use std::time::Duration;
const DISCOVERY_TIMEOUT: Duration = Duration::from_secs(5);
/// Controls OAuth discovery when the config server has no explicit OAuth settings.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ConfigServerDiscovery {
#[default]
Disabled,
Enabled,
}
pub(crate) async fn resolve_config_server(
config: &ConfigServer,
routes: &AuthRouteConfig,
discovery: ConfigServerDiscovery,
) -> io::Result<ConfigServer> {
config.validated_base_url().map_err(io::Error::other)?;
let mut resolved = config.clone();
if discovery == ConfigServerDiscovery::Enabled
&& config.oauth.is_none()
if config.oauth.is_none()
&& let Some(oauth) = discover_oauth(&config.base_url, routes).await?
{
resolved.oauth = Some(Box::new(oauth));
+13 -21
View File
@@ -2,7 +2,6 @@
//! Tests config-server OAuth defaults, discovery activation, and routing.
use super::ConfigServerDiscovery;
use super::DISCOVERY_TIMEOUT;
use super::discover_oauth;
use super::resolve_config_server;
@@ -100,7 +99,7 @@ async fn bounds_company_discovery_duration() {
}
#[tokio::test]
async fn preserves_explicit_oauth_and_flag_off_without_discovery() {
async fn preserves_explicit_oauth_without_discovery() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address = listener.local_addr().unwrap();
@@ -116,25 +115,18 @@ async fn preserves_explicit_oauth_and_flag_off_without_discovery() {
credentials_store: Default::default(),
};
for (discovery, oauth) in [
(ConfigServerDiscovery::Disabled, None),
(
ConfigServerDiscovery::Enabled,
Some(Box::new(explicit_oauth)),
),
] {
let config = ConfigServer {
base_url: format!("https://{address}"),
oauth,
};
assert_eq!(
resolve_config_server(&config, &routes, discovery)
.await
.unwrap(),
config,
"discovery: {discovery:?}"
);
}
let config = ConfigServer {
base_url: format!("https://{address}"),
oauth: Some(Box::new(explicit_oauth)),
};
assert_eq!(
resolve_config_server(&config, &routes).await.unwrap(),
config
);
let home = tempfile::tempdir().unwrap();
crate::anonymous_config_server_bundle_loader(&config, home.path().into(), &routes)
.await
.expect_err("Git must refuse explicit OAuth without fetching anonymous policy");
assert_eq!(
listener
.accept()
+1 -1
View File
@@ -23,6 +23,6 @@ pub use bundle_loader::managed_config_auth_manager;
pub use bundle_loader::managed_config_bundle_loader;
pub use bundle_loader::managed_config_bundle_loader_for_auth;
pub use bundle_loader::managed_config_bundle_loader_for_storage;
pub use config_server::anonymous_config_server_bundle_loader;
pub use config_server::config_server_auth_manager;
pub use config_server::config_server_bundle_loader;
pub use discovery::ConfigServerDiscovery;