Lightweight coding agent that runs in your terminal
Rust
Fail closed when workload identity initialization fails (#38424)
cooper-oai990218bbbd5c
diff --git a/codex-rs/app-server/src/config_manager_service_tests.rs b/codex-rs/app-server/src/config_manager_service_tests.rsindex 216db74b00..5b556bfdc6 100644--- a/codex-rs/app-server/src/config_manager_service_tests.rs+++ b/codex-rs/app-server/src/config_manager_service_tests.rs@@ -771,7 +771,7 @@ async fn managed_auth_policy_survives_unusable_requirements_file_changes() -> Relet auth_manager = codex_login::AuthManager::shared_from_config(&startup, /*enable_codex_api_key_env*/ false,)- .await;+ .await?;std::fs::write(&requirements_path,"allowed_login_methods = [\"chatgpt\"]\nallowed_chatgpt_workspaces = []\n",diff --git a/codex-rs/app-server/src/in_process.rs b/codex-rs/app-server/src/in_process.rsindex 2492eafeda..1438e59b48 100644--- a/codex-rs/app-server/src/in_process.rs+++ b/codex-rs/app-server/src/in_process.rs@@ -406,14 +406,15 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessClieargs.config.auth_config().validate()?;let channel_capacity = args.channel_capacity.max(1);let installation_id = resolve_installation_id(&args.config.codex_home).await?;+ let auth_manager =+ AuthManager::shared_from_config(args.config.as_ref(), args.enable_codex_api_key_env)+ .await+ .map_err(IoError::other)?;let (client_tx, mut client_rx) = mpsc::channel::<InProcessClientMessage>(channel_capacity);let (event_tx, event_rx) = mpsc::channel::<InProcessServerEvent>(channel_capacity);let runtime_handle = tokio::spawn(async move {let (outgoing_tx, outgoing_rx) = mpsc::channel::<OutgoingEnvelope>(channel_capacity);- let auth_manager =- AuthManager::shared_from_config(args.config.as_ref(), args.enable_codex_api_key_env)- .await;let analytics_events_client =analytics_events_client_from_config(Arc::clone(&auth_manager), args.config.as_ref());let analytics_events_flush_client = analytics_events_client.clone();diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rsindex 934e00ee0a..0588148302 100644--- a/codex-rs/app-server/src/lib.rs+++ b/codex-rs/app-server/src/lib.rs@@ -506,7 +506,9 @@ pub async fn run_main_with_transport_options(config_manager.replace_thread_config_loader(Arc::clone(&discovered_thread_config_loader));let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false)+ .await+ .map_err(std::io::Error::other)?;config_manager.replace_cloud_config_bundle_loader(auth_manager,config.chatgpt_base_url.clone(),@@ -760,7 +762,9 @@ pub async fn run_main_with_transport_options(drop(unix_socket_startup_lock);let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false)+ .await+ .map_err(std::io::Error::other)?;let remote_control_enabled = remote_control_policy == RemoteControlPolicy::Allowed&& remote_control_explicitly_requesteddiff --git a/codex-rs/app-server/src/message_processor_tracing_tests.rs b/codex-rs/app-server/src/message_processor_tracing_tests.rsindex 00a5383602..cd9d22d426 100644--- a/codex-rs/app-server/src/message_processor_tracing_tests.rs+++ b/codex-rs/app-server/src/message_processor_tracing_tests.rs@@ -234,7 +234,9 @@ async fn build_test_processor() {let (outgoing_tx, outgoing_rx) = mpsc::channel(16);let auth_manager =- AuthManager::shared_from_config(config.as_ref(), /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config.as_ref(), /*enable_codex_api_key_env*/ false)+ .await+ .expect("test auth manager");let config_manager = ConfigManager::new(config.codex_home.to_path_buf(),Vec::new(),diff --git a/codex-rs/chatgpt/src/chatgpt_client.rs b/codex-rs/chatgpt/src/chatgpt_client.rsindex 7beab01267..2e6feb8256 100644--- a/codex-rs/chatgpt/src/chatgpt_client.rs+++ b/codex-rs/chatgpt/src/chatgpt_client.rs@@ -66,7 +66,7 @@ pub(crate) async fn chatgpt_get_request_with_timeout<T: DeserializeOwned>() -> anyhow::Result<T> {let chatgpt_base_url = &config.chatgpt_base_url;let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await?;let auth = auth_manager.auth().awaitdiff --git a/codex-rs/chatgpt/src/connectors.rs b/codex-rs/chatgpt/src/connectors.rsindex 561889e780..ae6cbce5c8 100644--- a/codex-rs/chatgpt/src/connectors.rs+++ b/codex-rs/chatgpt/src/connectors.rs@@ -32,18 +32,18 @@ const DIRECTORY_CONNECTORS_TIMEOUT: Duration = Duration::from_secs(60);const CONNECTOR_METADATA_TIMEOUT: Duration = Duration::from_secs(60);const DEFAULT_APPS_PRODUCT_SKU: &str = "codex";-async fn apps_enabled(config: &Config) -> bool {+async fn apps_enabled(config: &Config) -> anyhow::Result<bool> {let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await?;let auth = auth_manager.auth().await;- config+ Ok(config.features- .apps_enabled_for_auth(auth.as_ref().is_some_and(CodexAuth::uses_codex_backend))+ .apps_enabled_for_auth(auth.as_ref().is_some_and(CodexAuth::uses_codex_backend)))}async fn connector_auth(config: &Config) -> anyhow::Result<CodexAuth> {let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await?;let auth = auth_manager.auth().await@@ -56,7 +56,7 @@ async fn connector_auth(config: &Config) -> anyhow::Result<CodexAuth> {}pub async fn list_connectors(config: &Config) -> anyhow::Result<Vec<AppInfo>> {- if !apps_enabled(config).await {+ if !apps_enabled(config).await? {return Ok(Vec::new());}let (connectors_result, accessible_result) = tokio::join!(@@ -82,7 +82,7 @@ pub async fn list_cached_all_connectors(config: &Config,plugin_apps: &[AppConnectorId],) -> Option<Vec<AppInfo>> {- if !apps_enabled(config).await {+ if !apps_enabled(config).await.ok()? {return Some(Vec::new());}@@ -100,7 +100,7 @@ pub async fn list_all_connectors_with_options(force_refetch: bool,plugin_apps: &[AppConnectorId],) -> anyhow::Result<Vec<AppInfo>> {- if !apps_enabled(config).await {+ if !apps_enabled(config).await? {return Ok(Vec::new());}let auth = connector_auth(config).await?;diff --git a/codex-rs/cli/src/debug_sandbox/cloud_config.rs b/codex-rs/cli/src/debug_sandbox/cloud_config.rsindex d7afa0aa10..952e6d9497 100644--- a/codex-rs/cli/src/debug_sandbox/cloud_config.rs+++ b/codex-rs/cli/src/debug_sandbox/cloud_config.rs@@ -44,7 +44,7 @@ pub(super) async fn bootstrap_cloud_config_bundle(bootstrap_auth_config(codex_home.as_path(), &bootstrap_config)?,/*enable_codex_api_key_env*/ false,)- .await)+ .await?)}#[cfg(test)]diff --git a/codex-rs/cli/src/doctor.rs b/codex-rs/cli/src/doctor.rsindex 8dd0792f3d..6a7d8a8d5d 100644--- a/codex-rs/cli/src/doctor.rs+++ b/codex-rs/cli/src/doctor.rs@@ -350,8 +350,9 @@ async fn build_report(let config_result = load_config(root_config_overrides, interactive, arg0_paths).await;match &config_result {Ok(config) => {- let auth_manager =+ let auth_manager_result =AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true).await;+ let auth_manager = auth_manager_result.as_ref().ok().cloned();let reachability_plan = provider_reachability_plan(config);let (config_check,@@ -370,13 +371,27 @@ async fn build_report(reachability_check,) = tokio::join!(async { run_sync_check("config", progress.clone(), || config_check(config)) },- async { run_sync_check("auth", progress.clone(), || auth_check(config)) },+ async {+ run_sync_check("auth", progress.clone(), || match &auth_manager_result {+ Ok(_) => auth_check(config),+ Err(error) => DoctorCheck::new(+ "auth.load",+ "auth",+ CheckStatus::Fail,+ "authentication could not be initialized",+ )+ .detail(error.to_string())+ .remediation(+ "Fix the reported authentication error, then rerun codex doctor.",+ ),+ })+ },async { run_sync_check("updates", progress.clone(), || updates_check(config)) },async { run_sync_check("network", progress.clone(), network_check) },run_async_check("websocket",progress.clone(),- websocket_reachability_check(config, Some(auth_manager)),+ websocket_reachability_check(config, auth_manager),),run_async_check("MCP", progress.clone(), mcp_check(config)),async {diff --git a/codex-rs/cli/src/login.rs b/codex-rs/cli/src/login.rsindex 142b1c8a03..5456d1a04c 100644--- a/codex-rs/cli/src/login.rs+++ b/codex-rs/cli/src/login.rs@@ -10,9 +10,11 @@use codex_config::types::AuthCredentialsStoreMode;use codex_core::config::Config;use codex_login::AuthKeyringBackendKind;+use codex_login::AuthManager;use codex_login::AuthRouteConfig;use codex_login::CLIENT_ID;use codex_login::ServerOptions;+use codex_login::is_workload_identity_selected;use codex_login::login_with_access_token;use codex_login::login_with_api_key;use codex_login::logout_with_revoke;@@ -439,8 +441,21 @@ pub async fn run_login_with_device_code_fallback_to_browser(pub async fn run_login_status(cli_config_overrides: CliConfigOverrides) -> ! {let config = load_config_or_exit(cli_config_overrides).await;- match config- .auth_config()+ if is_workload_identity_selected() {+ match AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await {+ Ok(_) => {+ eprintln!("Logged in using workload identity");+ std::process::exit(0);+ }+ Err(err) => {+ eprintln!("Error checking login status: {err}");+ std::process::exit(1);+ }+ }+ }++ let auth_config = config.auth_config();+ match auth_config.load_auth(/*enable_codex_api_key_env*/ false).await{diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex b1532f1fd2..75675efecc 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -1826,7 +1826,7 @@ async fn load_exec_server_remote_auth_provider(anyhow::anyhow!("CODEX_ACCESS_TOKEN is required when --use-agent-identity-auth is set")})?;let auth = AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false)- .await+ .await?.auth().await.ok_or_else(|| anyhow::anyhow!("Agent Identity authentication is unavailable"))?;@@ -1914,7 +1914,7 @@ async fn load_exec_server_remote_auth(missing_auth_error: &'static str,) -> anyhow::Result<codex_login::CodexAuth> {let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true).await?;let auth = match auth_manager.auth().await {Some(auth) => auth,@@ -2076,7 +2076,7 @@ async fn run_debug_prompt_input_command(config.codex_home.clone(),));let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await?;let mut extensions = codex_extension_api::ExtensionRegistryBuilder::new();codex_git_attribution::install(&mut extensions,@@ -2122,7 +2122,7 @@ async fn run_debug_models_command(.build().await?;let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ true).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ true).await?;let models_manager = build_models_manager(&config, auth_manager);models_manager.raw_model_catalog(diff --git a/codex-rs/cli/src/marketplace_cmd.rs b/codex-rs/cli/src/marketplace_cmd.rsindex 4a9609649b..d319e9af93 100644--- a/codex-rs/cli/src/marketplace_cmd.rs+++ b/codex-rs/cli/src/marketplace_cmd.rs@@ -212,7 +212,7 @@ async fn run_list(overrides: Vec<(String, toml::Value)>, args: ListMarketplaceAr.await.context("failed to load configuration")?;let manager = plugins_manager_for_config(&config);- manager.set_auth_mode(load_cli_auth_mode(&config).await);+ manager.set_auth_mode(load_cli_auth_mode(&config).await?);let plugins_input = config.plugins_config_input();let marketplace_listing = manager.discover_marketplaces_for_config(&plugins_input, &[])diff --git a/codex-rs/cli/src/mcp_cmd.rs b/codex-rs/cli/src/mcp_cmd.rsindex 6a6e6f76cc..e434a0a9d1 100644--- a/codex-rs/cli/src/mcp_cmd.rs+++ b/codex-rs/cli/src/mcp_cmd.rs@@ -523,14 +523,14 @@ async fn run_remove(config_overrides: &CliConfigOverrides, remove_args: RemoveArOk(())}-async fn load_mcp_manager(config: &Config) -> McpManager {+async fn load_mcp_manager(config: &Config) -> Result<McpManager> {let plugins_manager = Arc::new(plugins_manager_for_config(config));- plugins_manager.set_auth_mode(load_cli_auth_mode(config).await);- McpManager::new(plugins_manager)+ plugins_manager.set_auth_mode(load_cli_auth_mode(config).await?);+ Ok(McpManager::new(plugins_manager))}async fn run_login(config: &Config, login_args: LoginArgs) -> Result<()> {- let mcp_manager = load_mcp_manager(config).await;+ let mcp_manager = load_mcp_manager(config).await?;let mcp_servers = mcp_manager.configured_servers(config).await;let LoginArgs {@@ -599,7 +599,7 @@ async fn run_login(config: &Config, login_args: LoginArgs) -> Result<()> {}async fn run_logout(config: &Config, logout_args: LogoutArgs) -> Result<()> {- let mcp_manager = load_mcp_manager(config).await;+ let mcp_manager = load_mcp_manager(config).await?;let mcp_servers = mcp_manager.configured_servers(config).await;let LogoutArgs { name } = logout_args;@@ -629,9 +629,9 @@ async fn run_logout(config: &Config, logout_args: LogoutArgs) -> Result<()> {}async fn run_list(config: &Config, list_args: ListArgs) -> Result<()> {- let mcp_manager = load_mcp_manager(config).await;+ let mcp_manager = load_mcp_manager(config).await?;let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true).await?;let auth = auth_manager.auth().await;let mcp_servers = mcp_manager.configured_servers(config).await;let effective_mcp_servers = mcp_manager.effective_servers(config, auth.as_ref()).await;@@ -894,7 +894,7 @@ async fn run_list(config: &Config, list_args: ListArgs) -> Result<()> {}async fn run_get(config: &Config, get_args: GetArgs) -> Result<()> {- let mcp_manager = load_mcp_manager(config).await;+ let mcp_manager = load_mcp_manager(config).await?;let mcp_servers = mcp_manager.configured_servers(config).await;let Some(server) = mcp_servers.get(&get_args.name) else {diff --git a/codex-rs/cli/src/mcp_cmd/cloud_config.rs b/codex-rs/cli/src/mcp_cmd/cloud_config.rsindex ccaa028d25..2f7e7fba4f 100644--- a/codex-rs/cli/src/mcp_cmd/cloud_config.rs+++ b/codex-rs/cli/src/mcp_cmd/cloud_config.rs@@ -38,7 +38,8 @@ pub(super) async fn load_mcp_config(.context("failed to resolve cloud configuration authentication")?,/*enable_codex_api_key_env*/ false,)- .await;+ .await+ .context("failed to initialize cloud configuration authentication")?;ConfigBuilder::default().codex_home(codex_home.to_path_buf())diff --git a/codex-rs/cli/src/plugin_cmd.rs b/codex-rs/cli/src/plugin_cmd.rsindex d8d5b509d6..48dae16bdf 100644--- a/codex-rs/cli/src/plugin_cmd.rs+++ b/codex-rs/cli/src/plugin_cmd.rs@@ -591,7 +591,7 @@ async fn load_plugin_command_context(.context("failed to load configuration")?;let plugins_input = config.plugins_config_input();let manager = plugins_manager_for_config(&config);- manager.set_auth_mode(load_cli_auth_mode(&config).await);+ manager.set_auth_mode(load_cli_auth_mode(&config).await?);Ok(PluginCommandContext {codex_home: codex_home.to_path_buf(),plugins_input,@@ -599,12 +599,14 @@ async fn load_plugin_command_context(})}-pub(crate) async fn load_cli_auth_mode(config: &Config) -> Option<AuthMode> {- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true)- .await- .auth()- .await- .map(|auth| auth.api_auth_mode())+pub(crate) async fn load_cli_auth_mode(config: &Config) -> Result<Option<AuthMode>> {+ Ok(+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ true)+ .await?+ .auth()+ .await+ .map(|auth| auth.api_auth_mode()),+ )}struct PluginSelection {diff --git a/codex-rs/cli/tests/login.rs b/codex-rs/cli/tests/login.rsindex ac9ea6de9b..3eb81143f5 100644--- a/codex-rs/cli/tests/login.rs+++ b/codex-rs/cli/tests/login.rs@@ -9,7 +9,10 @@ use app_test_support::ChatGptAuthFixture;use app_test_support::write_chatgpt_auth;use codex_config::types::AuthCredentialsStoreMode;use codex_login::CLIENT_ID;+use codex_login::CODEX_ACCESS_TOKEN_ENV_VAR;use codex_login::REVOKE_TOKEN_URL_OVERRIDE_ENV_VAR;+use codex_protocol::shell_environment::OPENAI_FEDERATION_RULE_ID_ENV_VAR;+use codex_protocol::shell_environment::OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR;use predicates::str::contains;use pretty_assertions::assert_eq;use serde_json::Value;@@ -81,6 +84,24 @@ fn login_status_reports_auth_storage_errors() -> Result<()> {Ok(())}+#[test]+fn login_status_validates_configured_workload_identity() -> Result<()> {+ let codex_home = TempDir::new()?;+ write_file_auth_config(codex_home.path())?;+ let missing_assertion = codex_home.path().join("missing-identity-token");++ codex_command(codex_home.path())?+ .env_remove(CODEX_ACCESS_TOKEN_ENV_VAR)+ .env(OPENAI_FEDERATION_RULE_ID_ENV_VAR, "rule-test")+ .env(OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR, &missing_assertion)+ .args(["login", "status"])+ .assert()+ .failure()+ .stderr(contains("could not read workload identity assertion file"));++ Ok(())+}+#[test]fn login_with_access_token_rejects_invalid_jwt() -> Result<()> {let codex_home = TempDir::new()?;diff --git a/codex-rs/cloud-config/src/bundle_loader.rs b/codex-rs/cloud-config/src/bundle_loader.rsindex e3007502c6..d95f9bdb87 100644--- a/codex-rs/cloud-config/src/bundle_loader.rs+++ b/codex-rs/cloud-config/src/bundle_loader.rs@@ -87,19 +87,25 @@ wherepub async fn cloud_config_bundle_loader_for_storage(auth_config: AuthConfig,enable_codex_api_key_env: bool,-) -> CloudConfigBundleLoader {- let codex_home = auth_config.codex_home.clone();- let chatgpt_base_url = auth_config- .chatgpt_base_url- .clone()- .unwrap_or_else(|| "https://chatgpt.com/backend-api/".to_string());- let http_client_factory = auth_config.auth_route_config.http_client_factory().clone();+) -> std::io::Result<CloudConfigBundleLoader> {let auth_manager =- AuthManager::shared_from_auth_config(auth_config, enable_codex_api_key_env).await;+ AuthManager::shared_from_auth_config(auth_config.clone(), enable_codex_api_key_env).await?;+ Ok(cloud_config_bundle_loader_from_auth_config(+ auth_config,+ auth_manager,+ ))+}++fn cloud_config_bundle_loader_from_auth_config(+ auth_config: AuthConfig,+ auth_manager: Arc<AuthManager>,+) -> CloudConfigBundleLoader {cloud_config_bundle_loader(auth_manager,- chatgpt_base_url,- codex_home,- http_client_factory,+ auth_config+ .chatgpt_base_url+ .unwrap_or_else(|| "https://chatgpt.com/backend-api/".to_string()),+ auth_config.codex_home,+ auth_config.auth_route_config.http_client_factory().clone(),)}diff --git a/codex-rs/cloud-tasks/src/util.rs b/codex-rs/cloud-tasks/src/util.rsindex 78187b042a..03754ad550 100644--- a/codex-rs/cloud-tasks/src/util.rs+++ b/codex-rs/cloud-tasks/src/util.rs@@ -61,8 +61,18 @@ pub async fn load_auth_manager(let http_client_factory = config.http_client_factory();let mut auth_config = config.auth_config();auth_config.chatgpt_base_url = chatgpt_base_url.or(Some(config.chatgpt_base_url.clone()));- let auth_manager =- AuthManager::shared_from_auth_config(auth_config, /*enable_codex_api_key_env*/ false).await;+ let auth_manager = match AuthManager::shared_from_auth_config(+ auth_config,+ /*enable_codex_api_key_env*/ false,+ )+ .await+ {+ Ok(auth_manager) => auth_manager,+ Err(error) => {+ append_error_log(format!("failed to load auth: {error}"));+ return (None, http_client_factory);+ }+ };(Some(auth_manager), http_client_factory)}diff --git a/codex-rs/core/src/connectors.rs b/codex-rs/core/src/connectors.rsindex 1b17e0e6c4..118033a752 100644--- a/codex-rs/core/src/connectors.rs+++ b/codex-rs/core/src/connectors.rs@@ -120,7 +120,9 @@ pub async fn list_cached_accessible_connectors_from_mcp_tools(config: &Config,) -> Option<Vec<AppInfo>> {let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .ok()?;let auth = auth_manager.auth().await;if !config.features@@ -205,7 +207,7 @@ pub async fn list_accessible_connectors_from_mcp_tools_with_mcp_manager(mcp_manager: Arc<McpManager>,) -> anyhow::Result<AccessibleConnectorsStatus> {let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await?;let auth = auth_manager.auth().await;if !config.features@@ -427,8 +429,11 @@ async fn cached_directory_connectors_for_tool_suggest_with_auth(let auth = if let Some(auth) = auth {Some(auth)} else {- let auth_manager =- AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await;+ let Ok(auth_manager) =+ AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await+ else {+ return Vec::new();+ };loaded_auth = auth_manager.auth().await;loaded_auth.as_ref()};diff --git a/codex-rs/core/src/prompt_debug.rs b/codex-rs/core/src/prompt_debug.rsindex b97a5a2c7c..7cc2be215c 100644--- a/codex-rs/core/src/prompt_debug.rs+++ b/codex-rs/core/src/prompt_debug.rs@@ -33,7 +33,9 @@ pub async fn build_prompt_input(config.ephemeral = true;let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false)+ .await+ .map_err(|err| CodexErr::Fatal(err.to_string()))?;let local_runtime_paths = ExecServerRuntimePaths::from_optional_paths(config.codex_self_exe.clone(),diff --git a/codex-rs/core/src/shell_snapshot.rs b/codex-rs/core/src/shell_snapshot.rsindex d987417436..c6fbf47394 100644--- a/codex-rs/core/src/shell_snapshot.rs+++ b/codex-rs/core/src/shell_snapshot.rs@@ -289,6 +289,7 @@ async fn run_script_with_timeout(// Handler is kept as guard to control the drop. The `mut` pattern is required because .args()// returns a ref of handler.let mut handler = Command::new(&args[0]);+ codex_protocol::shell_environment::scrub_non_inheritable_env_vars(handler.as_std_mut());handler.args(&args[1..]);handler.stdin(Stdio::null());handler.current_dir(cwd);diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rsindex 5b4f3083ad..829486d8e7 100644--- a/codex-rs/exec/src/lib.rs+++ b/codex-rs/exec/src/lib.rs@@ -81,6 +81,7 @@ use codex_history::RolloutLine;use codex_login::default_client::set_default_client_residency_requirement;use codex_login::default_client::set_default_originator;use codex_login::enforce_login_restrictions;+use codex_login::is_workload_identity_selected;use codex_model_provider_info::LMSTUDIO_OSS_PROVIDER_ID;use codex_model_provider_info::OLLAMA_OSS_PROVIDER_ID;use codex_otel::set_parent_from_context;@@ -342,11 +343,15 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Result).await;let bootstrap_config_toml = &bootstrap_config.config_toml;+ let bootstrap_auth_config = bootstrap_auth_config(&codex_home, &bootstrap_config)?;+ // API keys cannot fetch workspace-managed configuration. Preserve the+ // existing ChatGPT bootstrap identity even when model requests allow+ // CODEX_API_KEY.let cloud_config_bundle = cloud_config_bundle_loader_for_storage(- bootstrap_auth_config(&codex_home, &bootstrap_config)?,+ bootstrap_auth_config,/*enable_codex_api_key_env*/ false,)- .await;+ .await?;let run_cli_overrides = cli_kv_overrides.clone();let run_loader_overrides = loader_overrides.clone();let run_cloud_config_bundle = cloud_config_bundle.clone();@@ -460,7 +465,9 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultset_default_client_residency_requirement(config.enforce_residency.value());- if let Err(err) = enforce_login_restrictions(&config.auth_config()).await {+ if !is_workload_identity_selected()+ && let Err(err) = enforce_login_restrictions(&config.auth_config()).await+ {eprintln!("{err}");std::process::exit(1);}diff --git a/codex-rs/login/src/auth/auth_tests.rs b/codex-rs/login/src/auth/auth_tests.rsindex 07d8a67ae5..2cada0be95 100644--- a/codex-rs/login/src/auth/auth_tests.rs+++ b/codex-rs/login/src/auth/auth_tests.rs@@ -1809,19 +1809,17 @@ fn auth_config_from_preserves_all_fields() {#[tokio::test]#[serial(codex_auth_env)]-async fn try_shared_from_config_rejects_partial_workload_identity_configuration() {+async fn shared_from_config_prefers_workload_identity_to_explicit_access_token() {let codex_home = tempdir().expect("tempdir");let config = test_auth_manager_config(codex_home.path());- let _access_token_guard = remove_access_token_env_var();+ let _access_token_guard = EnvVarGuard::set(CODEX_ACCESS_TOKEN_ENV_VAR, "at-explicit");let _rule_guard = EnvVarGuard::set(OPENAI_FEDERATION_RULE_ID_ENV_VAR, "rule-one");let _assertion_file_guard = EnvVarGuard::remove(OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR);- let error =- AuthManager::try_shared_from_config(&config, /*enable_codex_api_key_env*/ false)- .await- .expect_err("partial workload identity config should fail closed");+ let error = AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false)+ .await+ .expect_err("partial workload identity config should fail closed");- assert!(matches!(error, RefreshTokenError::Permanent(_)));assert!(error.to_string()@@ -2148,7 +2146,9 @@ async fn auth_manager_rejects_disallowed_stored_and_external_auth() {.await;config.managed_auth_policy.allowed_login_methods = Some(vec![ForcedLoginMethod::Chatgpt]);let manager =- AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .expect("auth manager");assert_eq!(manager.auth().await, None);assert!(@@ -2177,7 +2177,9 @@ async fn api_only_policy_rejects_access_tokens_before_hydration() {.await;config.managed_auth_policy.allowed_login_methods = Some(vec![ForcedLoginMethod::Api]);let manager =- AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .expect("auth manager");assert_eq!(manager.auth().await, None);assert!(@@ -2210,7 +2212,9 @@ async fn workspace_policy_rejects_agent_identity_before_hydration() {config.managed_auth_policy.allowed_chatgpt_workspaces =Some(vec![WORKSPACE_ID_ALLOWED.to_string()]);let manager =- AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .expect("auth manager");assert_eq!(manager.auth().await, None);drop(access_token_guard);@@ -2243,7 +2247,9 @@ async fn workspace_policy_rejects_agent_identity_before_hydration() {config.managed_auth_policy.allowed_chatgpt_workspaces =Some(vec![WORKSPACE_ID_ALLOWED.to_string()]);let manager =- AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .expect("auth manager");assert_eq!(manager.auth().await, None);}@@ -2279,7 +2285,9 @@ async fn workspace_policy_checks_the_selected_request_account() {).await;let manager =- AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_auth_config(config, /*enable_codex_api_key_env*/ false)+ .await+ .expect("auth manager");assert_eq!(manager.auth().await, None);}diff --git a/codex-rs/login/src/auth/manager.rs b/codex-rs/login/src/auth/manager.rsindex ffd855cf71..f2fb4f465f 100644--- a/codex-rs/login/src/auth/manager.rs+++ b/codex-rs/login/src/auth/manager.rs@@ -206,6 +206,37 @@ pub enum RefreshTokenError {Transient(#[from] std::io::Error),}+/// Error returned when constructing an [`AuthManager`] from resolved configuration.+#[derive(Debug, Error)]+#[error(transparent)]+pub struct AuthManagerInitializationError(AuthManagerInitializationErrorSource);++#[derive(Debug, Error)]+enum AuthManagerInitializationErrorSource {+ #[error(transparent)]+ WorkloadIdentityConfiguration(WorkloadIdentitySessionError),+ #[error(transparent)]+ InitialAuth(RefreshTokenError),+}++impl From<WorkloadIdentitySessionError> for AuthManagerInitializationError {+ fn from(error: WorkloadIdentitySessionError) -> Self {+ Self(AuthManagerInitializationErrorSource::WorkloadIdentityConfiguration(error))+ }+}++impl From<RefreshTokenError> for AuthManagerInitializationError {+ fn from(error: RefreshTokenError) -> Self {+ Self(AuthManagerInitializationErrorSource::InitialAuth(error))+ }+}++impl From<AuthManagerInitializationError> for std::io::Error {+ fn from(error: AuthManagerInitializationError) -> Self {+ Self::other(error)+ }+}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub enum ExternalAuthRefreshReason {Unauthorized,@@ -2615,40 +2646,20 @@ impl AuthManager {)}- /// Convenience constructor returning an `Arc` wrapper from resolved config.+ /// Builds a shared manager and activates process-configured workload identity when selected.pub async fn shared_from_config(config: &impl AuthManagerConfig,enable_codex_api_key_env: bool,- ) -> Arc<Self> {+ ) -> Result<Arc<Self>, AuthManagerInitializationError> {Self::shared_from_auth_config(auth_config_from(config), enable_codex_api_key_env).await}- /// Builds a shared manager using restrictions resolved before authentication.- pub async fn shared_from_auth_config(- auth_config: AuthConfig,- enable_codex_api_key_env: bool,- ) -> Arc<Self> {- Arc::new(Self::new_from_auth_config(auth_config, enable_codex_api_key_env).await)- }-- /// Constructs a manager and activates process-configured workload identity when selected.- pub async fn try_shared_from_config(- config: &impl AuthManagerConfig,- enable_codex_api_key_env: bool,- ) -> Result<Arc<Self>, RefreshTokenError> {- Self::try_shared_from_auth_config(auth_config_from(config), enable_codex_api_key_env).await- }-/// Activates workload identity against an auth config resolved before full runtime config.- pub async fn try_shared_from_auth_config(+ pub async fn shared_from_auth_config(auth_config: AuthConfig,enable_codex_api_key_env: bool,- ) -> Result<Arc<Self>, RefreshTokenError> {- let external_auth = WorkloadIdentityExternalAuth::from_process_config(- &auth_config,- enable_codex_api_key_env,- )- .map_err(configured_workload_identity_error)?;+ ) -> Result<Arc<Self>, AuthManagerInitializationError> {+ let external_auth = WorkloadIdentityExternalAuth::from_process_config(&auth_config)?;let mut manager = Self::new_from_auth_config(auth_config, enable_codex_api_key_env).await;manager.workload_identity_selected = external_auth.is_some();let manager = Arc::new(manager);@@ -2967,13 +2978,6 @@ fn auth_config_from(config: &impl AuthManagerConfig) -> AuthConfig {}}-fn configured_workload_identity_error(error: WorkloadIdentitySessionError) -> RefreshTokenError {- RefreshTokenError::Permanent(RefreshTokenFailedError::new(- RefreshTokenFailedReason::Other,- error.to_string(),- ))-}-#[cfg(test)]#[path = "auth_tests.rs"]mod tests;diff --git a/codex-rs/login/src/auth/workload_identity.rs b/codex-rs/login/src/auth/workload_identity.rsindex 13cc1920ad..f5f16ab906 100644--- a/codex-rs/login/src/auth/workload_identity.rs+++ b/codex-rs/login/src/auth/workload_identity.rs@@ -26,8 +26,6 @@ use super::ExternalAuthRefreshContext;use super::RefreshTokenError;use super::RefreshTokenFailedError;use super::RefreshTokenFailedReason;-use super::read_codex_access_token_from_env;-use super::read_codex_api_key_from_env;use crate::AuthRouteConfig;const PROD_TOKEN_URL: &str = "https://auth.openai.com/oauth/token";@@ -97,22 +95,21 @@ pub(super) enum WorkloadIdentitySessionError {InvalidConfiguration(String),}-pub fn is_workload_identity_selected(- auth_config: &AuthConfig,- enable_codex_api_key_env: bool,-) -> bool {- !has_explicit_process_auth(auth_config, enable_codex_api_key_env)- && ProcessEnvironment::read().has_marker()+/// Returns whether workload identity was selected through process configuration.+///+/// Either marker selects workload identity. Partial configuration then fails validation rather+/// than falling back to another credential source.+pub fn is_workload_identity_selected() -> bool {+ ProcessEnvironment::read().has_marker()}fn resolve_config(chatgpt_base_url: &str,environment: ProcessEnvironment,- has_explicit_process_auth: bool,chatgpt_login_allowed: bool,auth_route_config: AuthRouteConfig,) -> Result<Option<WorkloadIdentitySessionConfig>, WorkloadIdentitySessionError> {- if has_explicit_process_auth || !environment.has_marker() {+ if !environment.has_marker() {return Ok(None);}if !chatgpt_login_allowed {@@ -140,14 +137,6 @@ fn resolve_config(}))}-fn has_explicit_process_auth(auth_config: &AuthConfig, enable_codex_api_key_env: bool) -> bool {- (enable_codex_api_key_env- && auth_config.is_login_method_allowed(ForcedLoginMethod::Api)- && read_codex_api_key_from_env().is_some())- || (auth_config.is_login_method_allowed(ForcedLoginMethod::Chatgpt)- && read_codex_access_token_from_env().is_some())-}-fn required_path(value: Option<OsString>,variable: &'static str,@@ -296,17 +285,6 @@ struct WorkloadIdentitySessionEntry {}impl WorkloadIdentitySessionRegistry {- fn has_active_session(&self) -> Result<bool, WorkloadIdentitySessionError> {- let entry = self- .entry- .lock()- .map_err(|_| WorkloadIdentitySessionError::RegistryUnavailable)?;- Ok(entry- .as_ref()- .and_then(|active| active.session.upgrade())- .is_some())- }-fn session(&self,config: WorkloadIdentitySessionConfig,@@ -347,17 +325,14 @@ pub(super) struct WorkloadIdentityExternalAuth {impl WorkloadIdentityExternalAuth {pub(super) fn from_process_config(auth_config: &AuthConfig,- enable_codex_api_key_env: bool,) -> Result<Option<Self>, WorkloadIdentitySessionError> {let registry = process_registry();- let active_session = registry.has_active_session()?;resolve_config(auth_config.chatgpt_base_url.as_deref().unwrap_or("https://chatgpt.com/backend-api"),ProcessEnvironment::read(),- has_explicit_process_auth(auth_config, enable_codex_api_key_env) && !active_session,auth_config.is_login_method_allowed(ForcedLoginMethod::Chatgpt),auth_config.auth_route_config.clone(),)?diff --git a/codex-rs/login/src/auth/workload_identity_tests.rs b/codex-rs/login/src/auth/workload_identity_tests.rsindex 24d0040576..15d5115553 100644--- a/codex-rs/login/src/auth/workload_identity_tests.rs+++ b/codex-rs/login/src/auth/workload_identity_tests.rs@@ -26,14 +26,12 @@ fn complete_environment() -> ProcessEnvironment {fn resolve_for_test(environment: ProcessEnvironment,- has_explicit_process_auth: bool,chatgpt_login_allowed: bool,chatgpt_base_url: &str,) -> Result<Option<WorkloadIdentitySessionConfig>, WorkloadIdentitySessionError> {resolve_config(chatgpt_base_url,environment,- has_explicit_process_auth,chatgpt_login_allowed,auth_route_config(OutboundProxyPolicy::ReqwestDefault),)@@ -44,27 +42,12 @@ fn markers_select_wif_and_partial_configuration_fails_closed() {assert!(resolve_for_test(ProcessEnvironment::default(),- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ true,"https://chatgpt.com/backend-api",).expect("no markers").is_none());- assert!(- resolve_for_test(- ProcessEnvironment {- federation_rule_id: Some("partial".into()),- ..Default::default()- },- /*has_explicit_process_auth*/ true,- /*chatgpt_login_allowed*/ true,- "https://chatgpt.com/backend-api",- )- .expect("explicit auth wins")- .is_none()- );-for (environment, missing) in [(ProcessEnvironment {@@ -83,7 +66,6 @@ fn markers_select_wif_and_partial_configuration_fails_closed() {] {let error = resolve_for_test(environment,- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ true,"https://chatgpt.com/backend-api",)@@ -98,7 +80,6 @@ fn markers_select_wif_and_partial_configuration_fails_closed() {assert!(resolve_for_test(relative,- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ true,"https://chatgpt.com/backend-api",)@@ -112,7 +93,6 @@ fn markers_select_wif_and_partial_configuration_fails_closed() {fn auth_policy_and_app_environment_are_enforced() {let policy_error = resolve_for_test(complete_environment(),- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ false,"https://chatgpt.com/backend-api",)@@ -133,7 +113,6 @@ fn auth_policy_and_app_environment_are_enforced() {] {let config = resolve_for_test(complete_environment(),- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ true,chatgpt_base_url,)@@ -145,7 +124,6 @@ fn auth_policy_and_app_environment_are_enforced() {let error = resolve_for_test(complete_environment(),- /*has_explicit_process_auth*/ false,/*chatgpt_login_allowed*/ true,"https://example.invalid/backend-api",)diff --git a/codex-rs/login/src/lib.rs b/codex-rs/login/src/lib.rsindex 91573159d5..717bd0f4b0 100644--- a/codex-rs/login/src/lib.rs+++ b/codex-rs/login/src/lib.rs@@ -33,6 +33,7 @@ pub use auth::AuthHeaders;pub use auth::AuthKeyringBackendKind;pub use auth::AuthManager;pub use auth::AuthManagerConfig;+pub use auth::AuthManagerInitializationError;pub use auth::CLIENT_ID;pub use auth::CLIENT_ID_OVERRIDE_ENV_VAR;pub use auth::CODEX_ACCESS_TOKEN_ENV_VAR;diff --git a/codex-rs/mcp-server/src/lib.rs b/codex-rs/mcp-server/src/lib.rsindex 8baf188a32..b972521ddc 100644--- a/codex-rs/mcp-server/src/lib.rs+++ b/codex-rs/mcp-server/src/lib.rs@@ -64,6 +64,7 @@ pub async fn run_main(cli_config_overrides: CliConfigOverrides,strict_config: bool,) -> IoResult<()> {+ reject_workload_identity(codex_login::is_workload_identity_selected())?;// Parse CLI overrides once and derive the base Config eagerly so later// components do not need to work with raw TOML values.let cli_kv_overrides = cli_config_overrides.parse_overrides().map_err(|e| {@@ -161,7 +162,7 @@ pub async fn run_main(state_db,installation_id,)- .await;+ .await?;async move {while let Some(msg) = incoming_rx.recv().await {match msg {@@ -207,6 +208,20 @@ pub async fn run_main(Ok(())}+fn reject_workload_identity(workload_identity_selected: bool) -> IoResult<()> {+ if workload_identity_selected {+ return Err(std::io::Error::new(+ ErrorKind::Unsupported,+ "workload identity is not supported by `codex mcp-server`",+ ));+ }+ Ok(())+}++#[cfg(test)]+#[path = "workload_identity_tests.rs"]+mod workload_identity_tests;+#[cfg(test)]mod tests {use super::*;diff --git a/codex-rs/mcp-server/src/message_processor.rs b/codex-rs/mcp-server/src/message_processor.rsindex 559074d921..97cbd97356 100644--- a/codex-rs/mcp-server/src/message_processor.rs+++ b/codex-rs/mcp-server/src/message_processor.rs@@ -54,13 +54,14 @@ impl MessageProcessor {environment_manager: Arc<EnvironmentManager>,state_db: Option<StateDbHandle>,installation_id: String,- ) -> Self {+ ) -> std::io::Result<Self> {let outgoing = Arc::new(outgoing);let auth_manager = AuthManager::shared_from_config(config.as_ref(),/*enable_codex_api_key_env*/ false,)- .await;+ .await+ .map_err(std::io::Error::other)?;let user_instructions_provider = Arc::new(CodexHomeUserInstructionsProvider::new(config.codex_home.clone(),));@@ -110,13 +111,13 @@ impl MessageProcessor {/*attestation_provider*/ None,/*external_time_provider*/ None,));- Self {+ Ok(Self {outgoing,initialized: false,arg0_paths,thread_manager,active_turns,- }+ })}pub(crate) async fn process_request(&mut self, request: JsonRpcRequest<ClientRequest>) {diff --git a/codex-rs/mcp-server/src/workload_identity_tests.rs b/codex-rs/mcp-server/src/workload_identity_tests.rsnew file mode 100644index 0000000000..4e131c62b6--- /dev/null+++ b/codex-rs/mcp-server/src/workload_identity_tests.rs@@ -0,0 +1,15 @@+use super::reject_workload_identity;+use pretty_assertions::assert_eq;++#[test]+fn workload_identity_markers_are_rejected() {+ let error = reject_workload_identity(/*workload_identity_selected*/ true)+ .expect_err("mcp-server does not support workload identity");++ assert_eq!(+ error.to_string(),+ "workload identity is not supported by `codex mcp-server`"+ );+ reject_workload_identity(/*workload_identity_selected*/ false)+ .expect("mcp-server remains available without workload identity");+}diff --git a/codex-rs/thread-manager-sample/src/main.rs b/codex-rs/thread-manager-sample/src/main.rsindex 28121f368a..f01bc12251 100644--- a/codex-rs/thread-manager-sample/src/main.rs+++ b/codex-rs/thread-manager-sample/src/main.rs@@ -117,7 +117,7 @@ async fn run_main(arg0_paths: Arg0DispatchPaths) -> anyhow::Result<()> {let state_db = init_state_db(&config).await;let auth_manager =- AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await;+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await?;let local_runtime_paths = ExecServerRuntimePaths::from_optional_paths(config.codex_self_exe.clone(),config.codex_linux_sandbox_exe.clone(),diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex 8519cc549a..a77d13e30f 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -51,6 +51,7 @@ use codex_login::AuthConfig;use codex_login::default_client::originator;use codex_login::default_client::set_default_client_residency_requirement;use codex_login::enforce_login_restrictions;+use codex_login::is_workload_identity_selected;use codex_protocol::ThreadId;use codex_protocol::auth::AuthMode;use codex_protocol::config_types::AltScreenMode;@@ -834,8 +835,18 @@ fn app_server_target_for_launch(explicit_remote_endpoint: Option<RemoteAppServerEndpoint>,default_daemon_socket: Option<AbsolutePathBuf>,can_reuse_implicit_local_daemon: bool,-) -> AppServerTarget {- match explicit_remote_endpoint {+ workload_identity_selected: bool,+) -> std::io::Result<AppServerTarget> {+ if workload_identity_selected {+ if explicit_remote_endpoint.is_some() {+ return Err(std::io::Error::new(+ std::io::ErrorKind::InvalidInput,+ "workload identity must be configured on the remote app-server host",+ ));+ }+ return Ok(AppServerTarget::Embedded);+ }+ Ok(match explicit_remote_endpoint {Some(endpoint) => AppServerTarget::Remote { endpoint },None if can_reuse_implicit_local_daemon => {default_daemon_socket.map_or(AppServerTarget::Embedded, |socket_path| {@@ -845,7 +856,20 @@ fn app_server_target_for_launch(})}None => AppServerTarget::Embedded,- }+ })+}++async fn cloud_config_bundle_for_app_server_target(+ app_server_target: &AppServerTarget,+ bootstrap_config: &ConfigTomlLoadResult,+ codex_home: &Path,+) -> std::io::Result<CloudConfigBundleLoader> {+ cloud_config_bundle_loader_for_storage(+ app_server_target+ .auth_config_for_cloud_loader(bootstrap_auth_config(codex_home, bootstrap_config)?),+ /*enable_codex_api_key_env*/ false,+ )+ .await}fn loader_overrides_are_default(loader_overrides: &LoaderOverrides) -> bool {@@ -939,12 +963,14 @@ pub async fn run_main(launch_loader_overrides.user_config_path = Some(user_config_path);launch_loader_overrides.user_config_profile = Some(profile_v2.clone());}- let reuse_implicit_local_daemon = can_reuse_implicit_local_daemon(- &cli_kv_overrides,- &launch_loader_overrides,- strict_config,- cli.bypass_hook_trust,- );+ let workload_identity_selected = is_workload_identity_selected();+ let reuse_implicit_local_daemon = !workload_identity_selected+ && can_reuse_implicit_local_daemon(+ &cli_kv_overrides,+ &launch_loader_overrides,+ strict_config,+ cli.bypass_hook_trust,+ );let default_daemon = if explicit_remote_endpoint.is_none() && reuse_implicit_local_daemon {maybe_probe_default_daemon_socket(&codex_home).await} else {@@ -954,7 +980,8 @@ pub async fn run_main(explicit_remote_endpoint,default_daemon,reuse_implicit_local_daemon,- );+ workload_identity_selected,+ )?;let remote_cwd_override = cli.cwd.clone()@@ -995,12 +1022,12 @@ pub async fn run_main().await;let bootstrap_config_toml = &bootstrap_config.config_toml;- let cloud_config_bundle = cloud_config_bundle_loader_for_storage(- app_server_target- .auth_config_for_cloud_loader(bootstrap_auth_config(&codex_home, &bootstrap_config)?),- /*enable_codex_api_key_env*/ false,+ let cloud_config_bundle = cloud_config_bundle_for_app_server_target(+ &app_server_target,+ &bootstrap_config,+ &codex_home,)- .await;+ .await?;let cwd_override = if app_server_target.uses_remote_workspace() {None@@ -1090,11 +1117,15 @@ pub async fn run_main().await;- let cloud_config_bundle = cloud_config_bundle_loader_for_storage(- app_server_target.auth_config_for_cloud_loader(config.auth_config()),- /*enable_codex_api_key_env*/ false,- )- .await;+ let cloud_config_bundle = if workload_identity_selected {+ cloud_config_bundle+ } else {+ cloud_config_bundle_loader_for_storage(+ app_server_target.auth_config_for_cloud_loader(config.auth_config()),+ /*enable_codex_api_key_env*/ false,+ )+ .await?+ };let environment_manager = Arc::new(prepared_environment_manager.build(Some(local_runtime_paths), config.http_client_factory())@@ -1160,7 +1191,7 @@ pub async fn run_main(}}- if !app_server_target.uses_remote_workspace() {+ if !app_server_target.uses_remote_workspace() && !workload_identity_selected {#[allow(clippy::print_stderr)]if let Err(err) = enforce_login_restrictions(&config.auth_config()).await {eprintln!("{err}");@@ -1289,6 +1320,7 @@ async fn run_ratatui_app(environment_manager: Arc<EnvironmentManager>,) -> color_eyre::Result<AppExitInfo> {let uses_remote_workspace = app_server_target.uses_remote_workspace();+ let workload_identity_selected = is_workload_identity_selected();color_eyre::install()?;tooltips::announcement::prewarm(initial_config.http_client_factory());@@ -1379,7 +1411,9 @@ async fn run_ratatui_app(!uses_remote_workspace && should_show_trust_screen(&initial_config);#[cfg(target_os = "windows")]let mut trust_decision_was_made = false;- let login_status = if initial_config.model_provider.requires_openai_auth {+ let login_status = if workload_identity_selected {+ LoginStatus::AuthMode(AuthMode::Chatgpt)+ } else if initial_config.model_provider.requires_openai_auth {let Some(app_server) = app_server.as_mut() else {unreachable!("app server should exist when auth is required");};@@ -1430,12 +1464,12 @@ async fn run_ratatui_app(// If this onboarding run included the login step, always refresh the cloud config bundle// and rebuild config. This avoids missing newly available cloud-managed policy due to login// status detection edge cases.- if show_login_screen && !uses_remote_workspace {+ if show_login_screen && !uses_remote_workspace && !workload_identity_selected {cloud_config_bundle = cloud_config_bundle_loader_for_storage(initial_config.auth_config(),/*enable_codex_api_key_env*/ false,)- .await;+ .await?;}// If the user made an explicit trust decision, or we showed the login flow, reload config@@ -2520,7 +2554,8 @@ mod tests {/*explicit_remote_endpoint*/ None,Some(socket_path.clone()),/*can_reuse_implicit_local_daemon*/ true,- );+ /*workload_identity_selected*/ false,+ )?;assert_eq!(target,@@ -2542,7 +2577,8 @@ mod tests {Some(explicit_endpoint.clone()),Some(AbsolutePathBuf::relative_to_current_dir("default.sock")?),/*can_reuse_implicit_local_daemon*/ false,- );+ /*workload_identity_selected*/ false,+ )?;assert_eq!(target,@@ -2563,12 +2599,43 @@ mod tests {/*explicit_remote_endpoint*/ None,Some(socket_path),/*can_reuse_implicit_local_daemon*/ false,- );+ /*workload_identity_selected*/ false,+ )?;assert_eq!(target, AppServerTarget::Embedded);Ok(())}+ #[test]+ fn workload_identity_requires_an_embedded_app_server() -> color_eyre::Result<()> {+ let default_socket = AbsolutePathBuf::relative_to_current_dir("default.sock")?;+ assert_eq!(+ app_server_target_for_launch(+ /*explicit_remote_endpoint*/ None,+ Some(default_socket),+ /*can_reuse_implicit_local_daemon*/ true,+ /*workload_identity_selected*/ true,+ )?,+ AppServerTarget::Embedded+ );++ let explicit_endpoint = RemoteAppServerEndpoint::UnixSocket {+ socket_path: AbsolutePathBuf::relative_to_current_dir("explicit.sock")?,+ };+ let error = app_server_target_for_launch(+ Some(explicit_endpoint),+ /*default_daemon_socket*/ None,+ /*can_reuse_implicit_local_daemon*/ false,+ /*workload_identity_selected*/ true,+ )+ .expect_err("remote hosts must own workload identity");+ assert_eq!(+ error.to_string(),+ "workload identity must be configured on the remote app-server host"+ );+ Ok(())+ }+#[test]fn can_reuse_implicit_local_daemon_requires_default_launch_config() -> color_eyre::Result<()> {let mut loader_overrides = LoaderOverrides::default();diff --git a/codex-rs/tui/src/onboarding/auth.rs b/codex-rs/tui/src/onboarding/auth.rsindex 730172c5a2..b438c2addb 100644--- a/codex-rs/tui/src/onboarding/auth.rs+++ b/codex-rs/tui/src/onboarding/auth.rs@@ -1070,7 +1070,8 @@ mod tests {auth_config.clone(),/*enable_codex_api_key_env*/ false,)- .await,+ .await+ .expect("test cloud config loader"),feedback: codex_feedback::CodexFeedback::new(),log_db: None,state_db: None,diff --git a/codex-rs/tui/src/session_archive_commands.rs b/codex-rs/tui/src/session_archive_commands.rsindex 21b96f43b6..ef5b868c4e 100644--- a/codex-rs/tui/src/session_archive_commands.rs+++ b/codex-rs/tui/src/session_archive_commands.rs@@ -13,7 +13,6 @@ use crate::Cli;use crate::app_server_session::AppServerSession;use crate::legacy_core::config::ConfigBuilder;use crate::legacy_core::config::ConfigOverrides;-use crate::legacy_core::config::bootstrap_auth_config;use crate::legacy_core::config::load_config_toml_with_layer_stack;use crate::legacy_core::config::resolve_oss_provider;use crate::legacy_core::config::resolve_profile_v2_config_path;@@ -22,7 +21,6 @@ use crate::named_session_lookup::SessionCollection;use crate::named_session_lookup::SessionNameLookupMode;use codex_app_server_protocol::Thread as AppServerThread;use codex_arg0::Arg0DispatchPaths;-use codex_cloud_config::cloud_config_bundle_loader_for_storage;use codex_config::CloudConfigBundleLoader;use codex_config::ConfigLoadOptions;use codex_config::LoaderOverrides;@@ -278,12 +276,14 @@ async fn start_app_server_for_archive_command(launch_loader_overrides.user_config_profile = Some(profile_v2.clone());}- let reuse_implicit_local_daemon = super::can_reuse_implicit_local_daemon(- &cli_kv_overrides,- &launch_loader_overrides,- strict_config,- cli.bypass_hook_trust,- );+ let workload_identity_selected = codex_login::is_workload_identity_selected();+ let reuse_implicit_local_daemon = !workload_identity_selected+ && super::can_reuse_implicit_local_daemon(+ &cli_kv_overrides,+ &launch_loader_overrides,+ strict_config,+ cli.bypass_hook_trust,+ );let default_daemon = if explicit_remote_endpoint.is_none() && reuse_implicit_local_daemon {super::maybe_probe_default_daemon_socket(codex_home.as_path()).await} else {@@ -293,7 +293,8 @@ async fn start_app_server_for_archive_command(explicit_remote_endpoint,default_daemon,reuse_implicit_local_daemon,- );+ workload_identity_selected,+ )?;let remote_cwd_override = cli.cwd.clone()@@ -337,14 +338,12 @@ async fn start_app_server_for_archive_command(.await.wrap_err("failed to load config.toml")?;let config_toml = &bootstrap_config.config_toml;- let cloud_config_bundle = cloud_config_bundle_loader_for_storage(- app_server_target.auth_config_for_cloud_loader(bootstrap_auth_config(- codex_home.as_path(),- &bootstrap_config,- )?),- /*enable_codex_api_key_env*/ false,+ let cloud_config_bundle = super::cloud_config_bundle_for_app_server_target(+ &app_server_target,+ &bootstrap_config,+ codex_home.as_path(),)- .await;+ .await?;let model_provider = if cli.oss {resolve_oss_provider(cli.oss_provider.as_deref(), config_toml)