Support featured plugins (#15042)

codex-rs/core/src/plugins/manager.rs

@@ -15,6 +15,7 @@ use super::read_curated_plugins_sha;
 use super::remote::RemotePluginFetchError;
 use super::remote::RemotePluginMutationError;
 use super::remote::enable_remote_plugin;
+use super::remote::fetch_remote_featured_plugin_ids;
 use super::remote::fetch_remote_plugin_status;
 use super::remote::uninstall_remote_plugin;
 use super::store::DEFAULT_PLUGIN_VERSION;
@@ -24,6 +25,7 @@ use super::store::PluginInstallResult as StorePluginInstallResult;
 use super::store::PluginStore;
 use super::store::PluginStoreError;
 use super::sync_openai_plugins_repo;
+use crate::AuthManager;
 use crate::analytics_client::AnalyticsEventsClient;
 use crate::auth::CodexAuth;
 use crate::config::Config;
@@ -55,6 +57,8 @@ use std::sync::Arc;
 use std::sync::RwLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
+use std::time::Duration;
+use std::time::Instant;
 use toml_edit::value;
 use tracing::info;
 use tracing::warn;
@@ -65,6 +69,44 @@ const DEFAULT_APP_CONFIG_FILE: &str = ".app.json";
 pub const OPENAI_CURATED_MARKETPLACE_NAME: &str = "openai-curated";
 static CURATED_REPO_SYNC_STARTED: AtomicBool = AtomicBool::new(false);
 const MAX_CAPABILITY_SUMMARY_DESCRIPTION_LEN: usize = 1024;
+const FEATURED_PLUGIN_IDS_CACHE_TTL: Duration = Duration::from_secs(60 * 60 * 3);
+
+#[derive(Clone, PartialEq, Eq)]
+struct FeaturedPluginIdsCacheKey {
+    chatgpt_base_url: String,
+    account_id: Option<String>,
+    chatgpt_user_id: Option<String>,
+    is_workspace_account: bool,
+}
+
+#[derive(Clone)]
+struct CachedFeaturedPluginIds {
+    key: FeaturedPluginIdsCacheKey,
+    expires_at: Instant,
+    featured_plugin_ids: Vec<String>,
+}
+
+fn featured_plugin_ids_cache_key(
+    config: &Config,
+    auth: Option<&CodexAuth>,
+) -> FeaturedPluginIdsCacheKey {
+    let token_data = auth.and_then(|auth| auth.get_token_data().ok());
+    let account_id = token_data
+        .as_ref()
+        .and_then(|token_data| token_data.account_id.clone());
+    let chatgpt_user_id = token_data
+        .as_ref()
+        .and_then(|token_data| token_data.id_token.chatgpt_user_id.clone());
+    let is_workspace_account = token_data
+        .as_ref()
+        .is_some_and(|token_data| token_data.id_token.is_workspace_account());
+    FeaturedPluginIdsCacheKey {
+        chatgpt_base_url: config.chatgpt_base_url.clone(),
+        account_id,
+        chatgpt_user_id,
+        is_workspace_account,
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AppConnectorId(pub String);
@@ -417,6 +459,7 @@ impl From<RemotePluginFetchError> for PluginRemoteSyncError {
 pub struct PluginsManager {
     codex_home: PathBuf,
     store: PluginStore,
+    featured_plugin_ids_cache: RwLock<Option<CachedFeaturedPluginIds>>,
     cached_enabled_outcome: RwLock<Option<PluginLoadOutcome>>,
     analytics_events_client: RwLock<Option<AnalyticsEventsClient>>,
 }
@@ -426,6 +469,7 @@ impl PluginsManager {
         Self {
             codex_home: codex_home.clone(),
             store: PluginStore::new(codex_home),
+            featured_plugin_ids_cache: RwLock::new(None),
             cached_enabled_outcome: RwLock::new(None),
             analytics_events_client: RwLock::new(None),
         }
@@ -471,6 +515,11 @@ impl PluginsManager {
             Ok(cache) => cache,
             Err(err) => err.into_inner(),
         };
+        let mut featured_plugin_ids_cache = match self.featured_plugin_ids_cache.write() {
+            Ok(cache) => cache,
+            Err(err) => err.into_inner(),
+        };
+        *featured_plugin_ids_cache = None;
         *cached_enabled_outcome = None;
     }
 
@@ -481,6 +530,72 @@ impl PluginsManager {
         }
     }
 
+    fn cached_featured_plugin_ids(
+        &self,
+        cache_key: &FeaturedPluginIdsCacheKey,
+    ) -> Option<Vec<String>> {
+        {
+            let cache = match self.featured_plugin_ids_cache.read() {
+                Ok(cache) => cache,
+                Err(err) => err.into_inner(),
+            };
+            let now = Instant::now();
+            if let Some(cached) = cache.as_ref()
+                && now < cached.expires_at
+                && cached.key == *cache_key
+            {
+                return Some(cached.featured_plugin_ids.clone());
+            }
+        }
+
+        let mut cache = match self.featured_plugin_ids_cache.write() {
+            Ok(cache) => cache,
+            Err(err) => err.into_inner(),
+        };
+        let now = Instant::now();
+        if cache
+            .as_ref()
+            .is_some_and(|cached| now >= cached.expires_at || cached.key != *cache_key)
+        {
+            *cache = None;
+        }
+        None
+    }
+
+    fn write_featured_plugin_ids_cache(
+        &self,
+        cache_key: FeaturedPluginIdsCacheKey,
+        featured_plugin_ids: &[String],
+    ) {
+        let mut cache = match self.featured_plugin_ids_cache.write() {
+            Ok(cache) => cache,
+            Err(err) => err.into_inner(),
+        };
+        *cache = Some(CachedFeaturedPluginIds {
+            key: cache_key,
+            expires_at: Instant::now() + FEATURED_PLUGIN_IDS_CACHE_TTL,
+            featured_plugin_ids: featured_plugin_ids.to_vec(),
+        });
+    }
+
+    pub async fn featured_plugin_ids_for_config(
+        &self,
+        config: &Config,
+        auth: Option<&CodexAuth>,
+    ) -> Result<Vec<String>, RemotePluginFetchError> {
+        if !config.features.enabled(Feature::Plugins) {
+            return Ok(Vec::new());
+        }
+
+        let cache_key = featured_plugin_ids_cache_key(config, auth);
+        if let Some(featured_plugin_ids) = self.cached_featured_plugin_ids(&cache_key) {
+            return Ok(featured_plugin_ids);
+        }
+        let featured_plugin_ids = fetch_remote_featured_plugin_ids(config, auth).await?;
+        self.write_featured_plugin_ids_cache(cache_key, &featured_plugin_ids);
+        Ok(featured_plugin_ids)
+    }
+
     pub async fn install_plugin(
         &self,
         request: PluginInstallRequest,
@@ -935,7 +1050,11 @@ impl PluginsManager {
         })
     }
 
-    pub fn maybe_start_curated_repo_sync_for_config(self: &Arc<Self>, config: &Config) {
+    pub fn maybe_start_curated_repo_sync_for_config(
+        self: &Arc<Self>,
+        config: &Config,
+        auth_manager: Arc<AuthManager>,
+    ) {
         if config.features.enabled(Feature::Plugins) {
             let mut configured_curated_plugin_ids =
                 configured_plugins_from_stack(&config.config_layer_stack)
@@ -959,6 +1078,21 @@ impl PluginsManager {
                     .collect::<Vec<_>>();
             configured_curated_plugin_ids.sort_unstable_by_key(super::store::PluginId::as_key);
             self.start_curated_repo_sync(configured_curated_plugin_ids);
+
+            let config = config.clone();
+            let manager = Arc::clone(self);
+            tokio::spawn(async move {
+                let auth = auth_manager.auth().await;
+                if let Err(err) = manager
+                    .featured_plugin_ids_for_config(&config, auth.as_ref())
+                    .await
+                {
+                    warn!(
+                        error = %err,
+                        "failed to warm featured plugin ids cache"
+                    );
+                }
+            });
         }
     }
 

codex-rs/core/src/plugins/mod.rs

@@ -46,6 +46,8 @@ pub use marketplace::MarketplacePluginAuthPolicy;
 pub use marketplace::MarketplacePluginInstallPolicy;
 pub use marketplace::MarketplacePluginPolicy;
 pub use marketplace::MarketplacePluginSource;
+pub use remote::RemotePluginFetchError;
+pub use remote::fetch_remote_featured_plugin_ids;
 pub(crate) use render::render_explicit_plugin_instructions;
 pub(crate) use render::render_plugins_section;
 pub use store::PluginId;

codex-rs/core/src/plugins/remote.rs

@@ -7,6 +7,7 @@ use url::Url;
 
 const DEFAULT_REMOTE_MARKETPLACE_NAME: &str = "openai-curated";
 const REMOTE_PLUGIN_FETCH_TIMEOUT: Duration = Duration::from_secs(30);
+const REMOTE_FEATURED_PLUGIN_FETCH_TIMEOUT: Duration = Duration::from_secs(10);
 const REMOTE_PLUGIN_MUTATION_TIMEOUT: Duration = Duration::from_secs(30);
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
@@ -80,7 +81,7 @@ pub enum RemotePluginMutationError {
 }
 
 #[derive(Debug, thiserror::Error)]
-pub(crate) enum RemotePluginFetchError {
+pub enum RemotePluginFetchError {
     #[error("chatgpt authentication required to sync remote plugins")]
     AuthRequired,
 
@@ -158,6 +159,46 @@ pub(crate) async fn fetch_remote_plugin_status(
     })
 }
 
+pub async fn fetch_remote_featured_plugin_ids(
+    config: &Config,
+    auth: Option<&CodexAuth>,
+) -> Result<Vec<String>, RemotePluginFetchError> {
+    let base_url = config.chatgpt_base_url.trim_end_matches('/');
+    let url = format!("{base_url}/plugins/featured");
+    let client = build_reqwest_client();
+    let mut request = client
+        .get(&url)
+        .timeout(REMOTE_FEATURED_PLUGIN_FETCH_TIMEOUT);
+
+    if let Some(auth) = auth.filter(|auth| auth.is_chatgpt_auth()) {
+        let token = auth
+            .get_token()
+            .map_err(RemotePluginFetchError::AuthToken)?;
+        request = request.bearer_auth(token);
+        if let Some(account_id) = auth.get_account_id() {
+            request = request.header("chatgpt-account-id", account_id);
+        }
+    }
+
+    let response = request
+        .send()
+        .await
+        .map_err(|source| RemotePluginFetchError::Request {
+            url: url.clone(),
+            source,
+        })?;
+    let status = response.status();
+    let body = response.text().await.unwrap_or_default();
+    if !status.is_success() {
+        return Err(RemotePluginFetchError::UnexpectedStatus { url, status, body });
+    }
+
+    serde_json::from_str(&body).map_err(|source| RemotePluginFetchError::Decode {
+        url: url.clone(),
+        source,
+    })
+}
+
 pub(crate) async fn enable_remote_plugin(
     config: &Config,
     auth: Option<&CodexAuth>,