use std::collections::HashMap; use std::collections::HashSet; use std::sync::LazyLock; use std::sync::Mutex as StdMutex; use codex_core::config::Config; use codex_core::features::Feature; use codex_core::token_data::TokenData; use serde::Deserialize; use std::time::Duration; use std::time::Instant; use crate::chatgpt_client::chatgpt_get_request_with_timeout; use crate::chatgpt_token::get_chatgpt_token_data; use crate::chatgpt_token::init_chatgpt_token_from_auth; use codex_core::connectors::AppBranding; pub use codex_core::connectors::AppInfo; use codex_core::connectors::AppMetadata; use codex_core::connectors::CONNECTORS_CACHE_TTL; pub use codex_core::connectors::connector_display_label; use codex_core::connectors::connector_install_url; use codex_core::connectors::filter_disallowed_connectors; pub use codex_core::connectors::list_accessible_connectors_from_mcp_tools; pub use codex_core::connectors::list_accessible_connectors_from_mcp_tools_with_options; pub use codex_core::connectors::list_accessible_connectors_from_mcp_tools_with_options_and_status; pub use codex_core::connectors::list_cached_accessible_connectors_from_mcp_tools; use codex_core::connectors::merge_connectors; use codex_core::connectors::merge_plugin_apps; pub use codex_core::connectors::with_app_enabled_state; use codex_core::plugins::PluginsManager; #[derive(Debug, Deserialize)] struct DirectoryListResponse { apps: Vec, #[serde(alias = "nextToken")] next_token: Option, } #[derive(Debug, Deserialize, Clone)] struct DirectoryApp { id: String, name: String, description: Option, #[serde(alias = "appMetadata")] app_metadata: Option, branding: Option, labels: Option>, #[serde(alias = "logoUrl")] logo_url: Option, #[serde(alias = "logoUrlDark")] logo_url_dark: Option, #[serde(alias = "distributionChannel")] distribution_channel: Option, visibility: Option, } const DIRECTORY_CONNECTORS_TIMEOUT: Duration = Duration::from_secs(60); #[derive(Clone, PartialEq, Eq)] struct AllConnectorsCacheKey { chatgpt_base_url: String, account_id: Option, chatgpt_user_id: Option, is_workspace_account: bool, } #[derive(Clone)] struct CachedAllConnectors { key: AllConnectorsCacheKey, expires_at: Instant, connectors: Vec, } static ALL_CONNECTORS_CACHE: LazyLock>> = LazyLock::new(|| StdMutex::new(None)); pub async fn list_connectors(config: &Config) -> anyhow::Result> { if !config.features.enabled(Feature::Apps) { return Ok(Vec::new()); } let (connectors_result, accessible_result) = tokio::join!( list_all_connectors(config), list_accessible_connectors_from_mcp_tools(config), ); let connectors = connectors_result?; let accessible = accessible_result?; Ok(with_app_enabled_state( merge_connectors_with_accessible(connectors, accessible, true), config, )) } pub async fn list_all_connectors(config: &Config) -> anyhow::Result> { list_all_connectors_with_options(config, false).await } pub async fn list_cached_all_connectors(config: &Config) -> Option> { if !config.features.enabled(Feature::Apps) { return Some(Vec::new()); } if init_chatgpt_token_from_auth(&config.codex_home, config.cli_auth_credentials_store_mode) .await .is_err() { return None; } let token_data = get_chatgpt_token_data()?; let cache_key = all_connectors_cache_key(config, &token_data); read_cached_all_connectors(&cache_key).map(|connectors| { let connectors = merge_plugin_apps(connectors, plugin_apps_for_config(config)); filter_disallowed_connectors(connectors) }) } pub async fn list_all_connectors_with_options( config: &Config, force_refetch: bool, ) -> anyhow::Result> { if !config.features.enabled(Feature::Apps) { return Ok(Vec::new()); } init_chatgpt_token_from_auth(&config.codex_home, config.cli_auth_credentials_store_mode) .await?; let token_data = get_chatgpt_token_data().ok_or_else(|| anyhow::anyhow!("ChatGPT token not available"))?; let cache_key = all_connectors_cache_key(config, &token_data); if !force_refetch && let Some(cached_connectors) = read_cached_all_connectors(&cache_key) { let connectors = merge_plugin_apps(cached_connectors, plugin_apps_for_config(config)); return Ok(filter_disallowed_connectors(connectors)); } let mut apps = list_directory_connectors(config).await?; if token_data.id_token.is_workspace_account() { apps.extend(list_workspace_connectors(config).await?); } let mut connectors = merge_directory_apps(apps) .into_iter() .map(directory_app_to_app_info) .collect::>(); for connector in &mut connectors { let install_url = match connector.install_url.take() { Some(install_url) => install_url, None => connector_install_url(&connector.name, &connector.id), }; connector.name = normalize_connector_name(&connector.name, &connector.id); connector.description = normalize_connector_value(connector.description.as_deref()); connector.install_url = Some(install_url); connector.is_accessible = false; } connectors.sort_by(|left, right| { left.name .cmp(&right.name) .then_with(|| left.id.cmp(&right.id)) }); let connectors = filter_disallowed_connectors(connectors); write_cached_all_connectors(cache_key, &connectors); let connectors = merge_plugin_apps(connectors, plugin_apps_for_config(config)); Ok(filter_disallowed_connectors(connectors)) } fn all_connectors_cache_key(config: &Config, token_data: &TokenData) -> AllConnectorsCacheKey { AllConnectorsCacheKey { chatgpt_base_url: config.chatgpt_base_url.clone(), account_id: token_data.account_id.clone(), chatgpt_user_id: token_data.id_token.chatgpt_user_id.clone(), is_workspace_account: token_data.id_token.is_workspace_account(), } } fn read_cached_all_connectors(cache_key: &AllConnectorsCacheKey) -> Option> { let mut cache_guard = ALL_CONNECTORS_CACHE .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); let now = Instant::now(); if let Some(cached) = cache_guard.as_ref() { if now < cached.expires_at && cached.key == *cache_key { return Some(cached.connectors.clone()); } if now >= cached.expires_at { *cache_guard = None; } } None } fn write_cached_all_connectors(cache_key: AllConnectorsCacheKey, connectors: &[AppInfo]) { let mut cache_guard = ALL_CONNECTORS_CACHE .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); *cache_guard = Some(CachedAllConnectors { key: cache_key, expires_at: Instant::now() + CONNECTORS_CACHE_TTL, connectors: connectors.to_vec(), }); } fn plugin_apps_for_config(config: &Config) -> Vec { PluginsManager::new(config.codex_home.clone()) .plugins_for_config(config) .effective_apps() } pub fn merge_connectors_with_accessible( connectors: Vec, accessible_connectors: Vec, all_connectors_loaded: bool, ) -> Vec { let accessible_connectors = if all_connectors_loaded { let connector_ids: HashSet<&str> = connectors .iter() .map(|connector| connector.id.as_str()) .collect(); accessible_connectors .into_iter() .filter(|connector| connector_ids.contains(connector.id.as_str())) .collect() } else { accessible_connectors }; let merged = merge_connectors(connectors, accessible_connectors); filter_disallowed_connectors(merged) } async fn list_directory_connectors(config: &Config) -> anyhow::Result> { let mut apps = Vec::new(); let mut next_token: Option = None; loop { let path = match next_token.as_deref() { Some(token) => { let encoded_token = urlencoding::encode(token); format!( "/connectors/directory/list?tier=categorized&token={encoded_token}&external_logos=true" ) } None => "/connectors/directory/list?tier=categorized&external_logos=true".to_string(), }; let response: DirectoryListResponse = chatgpt_get_request_with_timeout(config, path, Some(DIRECTORY_CONNECTORS_TIMEOUT)) .await?; apps.extend( response .apps .into_iter() .filter(|app| !is_hidden_directory_app(app)), ); next_token = response .next_token .map(|token| token.trim().to_string()) .filter(|token| !token.is_empty()); if next_token.is_none() { break; } } Ok(apps) } async fn list_workspace_connectors(config: &Config) -> anyhow::Result> { let response: anyhow::Result = chatgpt_get_request_with_timeout( config, "/connectors/directory/list_workspace?external_logos=true".to_string(), Some(DIRECTORY_CONNECTORS_TIMEOUT), ) .await; match response { Ok(response) => Ok(response .apps .into_iter() .filter(|app| !is_hidden_directory_app(app)) .collect()), Err(_) => Ok(Vec::new()), } } fn merge_directory_apps(apps: Vec) -> Vec { let mut merged: HashMap = HashMap::new(); for app in apps { if let Some(existing) = merged.get_mut(&app.id) { merge_directory_app(existing, app); } else { merged.insert(app.id.clone(), app); } } merged.into_values().collect() } fn merge_directory_app(existing: &mut DirectoryApp, incoming: DirectoryApp) { let DirectoryApp { id: _, name, description, app_metadata, branding, labels, logo_url, logo_url_dark, distribution_channel, visibility: _, } = incoming; let incoming_name_is_empty = name.trim().is_empty(); if existing.name.trim().is_empty() && !incoming_name_is_empty { existing.name = name; } let incoming_description_present = description .as_deref() .map(|value| !value.trim().is_empty()) .unwrap_or(false); if incoming_description_present { existing.description = description; } if existing.logo_url.is_none() && logo_url.is_some() { existing.logo_url = logo_url; } if existing.logo_url_dark.is_none() && logo_url_dark.is_some() { existing.logo_url_dark = logo_url_dark; } if existing.distribution_channel.is_none() && distribution_channel.is_some() { existing.distribution_channel = distribution_channel; } if let Some(incoming_branding) = branding { if let Some(existing_branding) = existing.branding.as_mut() { if existing_branding.category.is_none() && incoming_branding.category.is_some() { existing_branding.category = incoming_branding.category; } if existing_branding.developer.is_none() && incoming_branding.developer.is_some() { existing_branding.developer = incoming_branding.developer; } if existing_branding.website.is_none() && incoming_branding.website.is_some() { existing_branding.website = incoming_branding.website; } if existing_branding.privacy_policy.is_none() && incoming_branding.privacy_policy.is_some() { existing_branding.privacy_policy = incoming_branding.privacy_policy; } if existing_branding.terms_of_service.is_none() && incoming_branding.terms_of_service.is_some() { existing_branding.terms_of_service = incoming_branding.terms_of_service; } if !existing_branding.is_discoverable_app && incoming_branding.is_discoverable_app { existing_branding.is_discoverable_app = true; } } else { existing.branding = Some(incoming_branding); } } if let Some(incoming_app_metadata) = app_metadata { if let Some(existing_app_metadata) = existing.app_metadata.as_mut() { if existing_app_metadata.review.is_none() && incoming_app_metadata.review.is_some() { existing_app_metadata.review = incoming_app_metadata.review; } if existing_app_metadata.categories.is_none() && incoming_app_metadata.categories.is_some() { existing_app_metadata.categories = incoming_app_metadata.categories; } if existing_app_metadata.sub_categories.is_none() && incoming_app_metadata.sub_categories.is_some() { existing_app_metadata.sub_categories = incoming_app_metadata.sub_categories; } if existing_app_metadata.seo_description.is_none() && incoming_app_metadata.seo_description.is_some() { existing_app_metadata.seo_description = incoming_app_metadata.seo_description; } if existing_app_metadata.screenshots.is_none() && incoming_app_metadata.screenshots.is_some() { existing_app_metadata.screenshots = incoming_app_metadata.screenshots; } if existing_app_metadata.developer.is_none() && incoming_app_metadata.developer.is_some() { existing_app_metadata.developer = incoming_app_metadata.developer; } if existing_app_metadata.version.is_none() && incoming_app_metadata.version.is_some() { existing_app_metadata.version = incoming_app_metadata.version; } if existing_app_metadata.version_id.is_none() && incoming_app_metadata.version_id.is_some() { existing_app_metadata.version_id = incoming_app_metadata.version_id; } if existing_app_metadata.version_notes.is_none() && incoming_app_metadata.version_notes.is_some() { existing_app_metadata.version_notes = incoming_app_metadata.version_notes; } if existing_app_metadata.first_party_type.is_none() && incoming_app_metadata.first_party_type.is_some() { existing_app_metadata.first_party_type = incoming_app_metadata.first_party_type; } if existing_app_metadata.first_party_requires_install.is_none() && incoming_app_metadata.first_party_requires_install.is_some() { existing_app_metadata.first_party_requires_install = incoming_app_metadata.first_party_requires_install; } if existing_app_metadata .show_in_composer_when_unlinked .is_none() && incoming_app_metadata .show_in_composer_when_unlinked .is_some() { existing_app_metadata.show_in_composer_when_unlinked = incoming_app_metadata.show_in_composer_when_unlinked; } } else { existing.app_metadata = Some(incoming_app_metadata); } } if existing.labels.is_none() && labels.is_some() { existing.labels = labels; } } fn is_hidden_directory_app(app: &DirectoryApp) -> bool { matches!(app.visibility.as_deref(), Some("HIDDEN")) } fn directory_app_to_app_info(app: DirectoryApp) -> AppInfo { AppInfo { id: app.id, name: app.name, description: app.description, logo_url: app.logo_url, logo_url_dark: app.logo_url_dark, distribution_channel: app.distribution_channel, branding: app.branding, app_metadata: app.app_metadata, labels: app.labels, install_url: None, is_accessible: false, is_enabled: true, plugin_display_names: Vec::new(), } } fn normalize_connector_name(name: &str, connector_id: &str) -> String { let trimmed = name.trim(); if trimmed.is_empty() { connector_id.to_string() } else { trimmed.to_string() } } fn normalize_connector_value(value: Option<&str>) -> Option { value .map(str::trim) .filter(|value| !value.is_empty()) .map(str::to_string) } #[cfg(test)] mod tests { use super::*; use pretty_assertions::assert_eq; fn app(id: &str) -> AppInfo { AppInfo { id: id.to_string(), name: id.to_string(), description: None, logo_url: None, logo_url_dark: None, distribution_channel: None, branding: None, app_metadata: None, labels: None, install_url: None, is_accessible: false, is_enabled: true, plugin_display_names: Vec::new(), } } #[test] fn allows_asdk_connectors() { let filtered = filter_disallowed_connectors(vec![app("asdk_app_hidden"), app("alpha")]); assert_eq!(filtered, vec![app("asdk_app_hidden"), app("alpha")]); } #[test] fn allows_whitelisted_asdk_connectors() { let filtered = filter_disallowed_connectors(vec![ app("asdk_app_69781557cc1481919cf5e9824fa2e792"), app("beta"), ]); assert_eq!( filtered, vec![ app("asdk_app_69781557cc1481919cf5e9824fa2e792"), app("beta") ] ); } #[test] fn filters_openai_prefixed_connectors() { let filtered = filter_disallowed_connectors(vec![ app("connector_openai_foo"), app("connector_openai_bar"), app("gamma"), ]); assert_eq!(filtered, vec![app("gamma")]); } #[test] fn filters_disallowed_connector_ids() { let filtered = filter_disallowed_connectors(vec![ app("asdk_app_6938a94a61d881918ef32cb999ff937c"), app("delta"), ]); assert_eq!(filtered, vec![app("delta")]); } fn merged_app(id: &str, is_accessible: bool) -> AppInfo { AppInfo { id: id.to_string(), name: id.to_string(), description: None, logo_url: None, logo_url_dark: None, distribution_channel: None, branding: None, app_metadata: None, labels: None, install_url: Some(connector_install_url(id, id)), is_accessible, is_enabled: true, plugin_display_names: Vec::new(), } } #[test] fn excludes_accessible_connectors_not_in_all_when_all_loaded() { let merged = merge_connectors_with_accessible( vec![app("alpha")], vec![app("alpha"), app("beta")], true, ); assert_eq!(merged, vec![merged_app("alpha", true)]); } #[test] fn keeps_accessible_connectors_not_in_all_while_all_loading() { let merged = merge_connectors_with_accessible( vec![app("alpha")], vec![app("alpha"), app("beta")], false, ); assert_eq!( merged, vec![merged_app("alpha", true), merged_app("beta", true)] ); } }