diff --git a/codex-rs/app-server/src/request_processors/plugins.rs b/codex-rs/app-server/src/request_processors/plugins.rs index 4802228999..64e23a01a3 100644 --- a/codex-rs/app-server/src/request_processors/plugins.rs +++ b/codex-rs/app-server/src/request_processors/plugins.rs @@ -1608,14 +1608,6 @@ impl PluginRequestProcessor { ); return Err(invalid_request(error_message)); } - // Direct install writes the same cache tree that installed-plugin sync - // prunes before the backend installed snapshot can include this plugin. - let _remote_plugin_cache_mutation = - codex_core_plugins::remote::mark_remote_plugin_cache_mutation_in_flight( - config.codex_home.as_path(), - &actual_remote_marketplace_name, - &remote_plugin_name, - ); let validated_bundle = codex_core_plugins::remote_bundle::validate_remote_plugin_bundle( &remote_plugin_id, &actual_remote_marketplace_name, @@ -1638,6 +1630,24 @@ impl PluginRequestProcessor { remote_plugin_bundle_install_error_to_jsonrpc(err) })?; + // Direct install writes the same cache tree that installed-plugin sync prunes. Hold the + // shared cache-root gate through the backend mutation so a full sync cannot commit a + // snapshot fetched before this plugin became installed. + let plugins_manager = self.thread_manager.plugins_manager(); + let remote_plugin_sync_guard = plugins_manager + .acquire_remote_installed_plugin_sync_guard() + .await + .map_err(|err| { + internal_error(format!("failed to coordinate remote plugin install: {err}")) + })?; + // Keep this marker through downstream setup after releasing the shared gate. A new sync + // may start then, but it must not prune the bundle that this install just materialized. + let _remote_plugin_cache_mutation = + codex_core_plugins::remote::mark_remote_plugin_cache_mutation_in_flight( + config.codex_home.as_path(), + &actual_remote_marketplace_name, + &remote_plugin_name, + ); let result = codex_core_plugins::remote_bundle::download_and_install_remote_plugin_bundle( &remote_plugin_service_config, config.codex_home.to_path_buf(), @@ -1693,13 +1703,12 @@ impl PluginRequestProcessor { remote_plugin_catalog_error_to_jsonrpc(err, "install remote plugin") })?; - self.thread_manager - .plugins_manager() - .maybe_start_remote_installed_plugins_cache_refresh_after_mutation( - &config.plugins_config_input(), - auth.clone(), - Some(self.effective_plugins_changed_callback()), - ); + plugins_manager.maybe_start_remote_installed_plugins_cache_refresh_after_mutation( + &config.plugins_config_input(), + auth.clone(), + Some(self.effective_plugins_changed_callback()), + ); + drop(remote_plugin_sync_guard); let plugin_metadata = self .thread_manager @@ -2128,6 +2137,20 @@ impl PluginRequestProcessor { plugin_telemetry.capability_summary = Some(uninstall_target.fallback_capability_summary.clone()); } + let remote_plugin_sync_guard = plugins_manager + .acquire_remote_installed_plugin_sync_guard() + .await + .map_err(|err| { + internal_error(format!( + "failed to coordinate remote plugin uninstall: {err}" + )) + })?; + let remote_plugin_cache_mutation = + codex_core_plugins::remote::mark_remote_plugin_cache_mutation_in_flight( + config.codex_home.as_path(), + &uninstall_target.plugin_id.marketplace_name, + &uninstall_target.plugin_id.plugin_name, + ); let uninstall_result = codex_core_plugins::remote::uninstall_remote_plugin( &remote_plugin_service_config, auth.as_ref(), @@ -2136,21 +2159,25 @@ impl PluginRequestProcessor { ) .await; + let mut refresh_effective_plugins = false; if matches!( &uninstall_result, Ok(()) | Err(RemotePluginCatalogError::CacheRemove(_)) ) { self.analytics_events_client .track_plugin_uninstalled(plugin_telemetry); - if plugins_manager.clear_remote_installed_plugins_cache() { - self.on_effective_plugins_changed().await; - } + refresh_effective_plugins = plugins_manager.clear_remote_installed_plugins_cache(); plugins_manager.maybe_start_remote_installed_plugins_cache_refresh_after_mutation( &config.plugins_config_input(), auth.clone(), Some(self.effective_plugins_changed_callback()), ); } + drop(remote_plugin_cache_mutation); + drop(remote_plugin_sync_guard); + if refresh_effective_plugins { + self.on_effective_plugins_changed().await; + } uninstall_result.map_err(|err| { remote_plugin_catalog_error_to_jsonrpc(err, "uninstall remote plugin") diff --git a/codex-rs/core-plugins/src/discoverable_tests.rs b/codex-rs/core-plugins/src/discoverable_tests.rs index 3c2ca25bff..63538ce9ba 100644 --- a/codex-rs/core-plugins/src/discoverable_tests.rs +++ b/codex-rs/core-plugins/src/discoverable_tests.rs @@ -946,7 +946,11 @@ plugins = true let auth = CodexAuth::create_dummy_chatgpt_auth_for_testing(); let mut plugins = load_plugins_config(codex_home.path(), codex_home.path()).await; plugins.chatgpt_base_url = format!("{}/backend-api", server.uri()); - let plugins_manager = test_plugins_manager(codex_home.path().to_path_buf()); + let plugins_manager = test_plugins_manager_with_options( + codex_home.path().to_path_buf(), + Some(Product::Codex), + Some(AuthMode::Chatgpt), + ); fetch_and_cache_global_remote_plugin_catalog( codex_home.path(), &RemotePluginServiceConfig::new( diff --git a/codex-rs/core-plugins/src/lib.rs b/codex-rs/core-plugins/src/lib.rs index 328a9a6c75..b665c8a3b2 100644 --- a/codex-rs/core-plugins/src/lib.rs +++ b/codex-rs/core-plugins/src/lib.rs @@ -80,6 +80,7 @@ pub use manager::PluginUninstallError; pub use manager::PluginsConfigInput; pub use manager::PluginsManager; pub use manager::RecommendedPluginCandidatesInput; +pub use manager::RemoteInstalledPluginSyncGuard; pub use marketplace_policy::allowed_configured_marketplace_names; pub use marketplace_upgrade::ConfiguredMarketplaceUpgradeError as PluginMarketplaceUpgradeError; pub use marketplace_upgrade::ConfiguredMarketplaceUpgradeOutcome as PluginMarketplaceUpgradeOutcome; diff --git a/codex-rs/core-plugins/src/manager.rs b/codex-rs/core-plugins/src/manager.rs index f4e9f466e5..2a7faf2747 100644 --- a/codex-rs/core-plugins/src/manager.rs +++ b/codex-rs/core-plugins/src/manager.rs @@ -48,6 +48,8 @@ use crate::marketplace_upgrade::upgrade_configured_git_marketplaces_with_mode; use crate::remote::REMOTE_GLOBAL_MARKETPLACE_NAME; use crate::remote::RecommendedPluginsMode; use crate::remote::RemoteInstalledPlugin; +use crate::remote::RemoteInstalledPluginBundleSyncError; +use crate::remote::RemoteInstalledPluginBundleSyncOutcome; use crate::remote::RemotePluginCatalogError; use crate::remote::RemotePluginMaterialization; use crate::remote::RemotePluginScope; @@ -110,8 +112,10 @@ 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 tokio::sync::OnceCell; +use tokio::sync::OwnedSemaphorePermit; use tokio::sync::Semaphore; use tokio::sync::watch; use tracing::instrument; @@ -120,6 +124,7 @@ use tracing::warn; static CURATED_REPO_SYNC_STARTED: AtomicBool = AtomicBool::new(false); const FEATURED_PLUGIN_IDS_CACHE_TTL: std::time::Duration = std::time::Duration::from_secs(60 * 60 * 3); +const REMOTE_INSTALLED_PLUGIN_SYNC_WAIT_TIMEOUT: Duration = Duration::from_secs(120); type EffectivePluginsChangedCallback = Arc; @@ -197,7 +202,66 @@ struct CachedFeaturedPluginIds { featured_plugin_ids: Vec, } +#[derive(Clone, PartialEq, Eq)] +struct RemoteInstalledPluginsAuthIdentity { + auth_mode: Option, + account_id: Option, + chatgpt_user_id: Option, + is_workspace_account: Option, +} + +impl RemoteInstalledPluginsAuthIdentity { + fn from_auth(auth: Option<&CodexAuth>) -> Self { + Self { + auth_mode: auth.map(CodexAuth::api_auth_mode), + account_id: auth.and_then(CodexAuth::get_account_id), + chatgpt_user_id: auth.and_then(CodexAuth::get_chatgpt_user_id), + is_workspace_account: auth.map(CodexAuth::is_workspace_account), + } + } +} + +#[derive(Default)] +struct RemoteInstalledPluginsCache { + generation: u64, + auth_identity: Option, + reconciliation_generation: Option, + // A cancelled pass may mutate bundles before publication; retry must notify consumers. + needs_effective_plugins_refresh: bool, + plugins: Option>, +} + +enum RemoteInstalledPluginsCachePublication { + Refresh, + Reconcile, +} + +/// Holds the cache-root gate shared by full installed-bundle sync, reconciliation, and direct +/// remote plugin mutations. +/// +/// Callers should keep this guard only while mutating the remote plugin cache and backend +/// installed state, then release it before unrelated analytics, OAuth, or runtime refresh work. +pub struct RemoteInstalledPluginSyncGuard { + _permit: OwnedSemaphorePermit, +} + +struct RemoteInstalledPluginsReconciliationGuard<'a> { + manager: &'a PluginsManager, + generation: u64, + committed: bool, +} + +impl Drop for RemoteInstalledPluginsReconciliationGuard<'_> { + fn drop(&mut self) { + if !self.committed { + self.manager + .abandon_remote_installed_plugins_reconcile(self.generation); + } + } +} + struct RemoteInstalledPluginsCacheRefreshRequest { + generation: u64, service_config: RemotePluginServiceConfig, auth: Option, notify: RemoteInstalledPluginsCacheRefreshNotify, @@ -439,12 +503,12 @@ pub struct PluginsManager { non_curated_cache_refresh_lock: Semaphore, non_curated_cache_refresh_state: RwLock, non_curated_cache_refresh_completion: watch::Sender, - // Keep the cache auth-independent so auth changes only need to resolve capabilities again. + // Remote installed plugins vary by account, so loaded capabilities are cached per auth. loaded_plugins_cache: RwLock, loaded_plugins_load_semaphore: Semaphore, skill_root_loader: Arc>, tool_suggest_metadata_cache: ToolSuggestMetadataCache, - remote_installed_plugins_cache: RwLock>>, + remote_installed_plugins_cache: RwLock, remote_installed_plugin_bundle_sync_gate: Arc, remote_installed_plugins_cache_refresh_state: RwLock, remote_catalog_cache_refresh_state: RwLock, @@ -472,6 +536,7 @@ struct PluginLoadCacheKey { configured_plugins: HashMap, skill_config_rules: SkillConfigRules, remote_global_catalog_active: bool, + auth_identity: Option, } impl PluginLoadCacheKey { @@ -479,6 +544,7 @@ impl PluginLoadCacheKey { config: &PluginsConfigInput, codex_home: &Path, remote_global_catalog_active: bool, + auth_identity: RemoteInstalledPluginsAuthIdentity, ) -> Self { Self { configured_plugins: configured_plugins_from_stack( @@ -487,6 +553,8 @@ impl PluginLoadCacheKey { ), skill_config_rules: skill_config_rules_from_stack(&config.config_layer_stack), remote_global_catalog_active, + // Local curated loads are auth-independent; only remote snapshots vary by account. + auth_identity: remote_global_catalog_active.then_some(auth_identity), } } } @@ -547,7 +615,7 @@ impl PluginsManager { loaded_plugins_load_semaphore: Semaphore::new(/*permits*/ 1), skill_root_loader, tool_suggest_metadata_cache: ToolSuggestMetadataCache::new(), - remote_installed_plugins_cache: RwLock::new(None), + remote_installed_plugins_cache: RwLock::new(RemoteInstalledPluginsCache::default()), remote_installed_plugin_bundle_sync_gate, remote_installed_plugins_cache_refresh_state: RwLock::new( RemoteInstalledPluginsCacheRefreshState::default(), @@ -620,10 +688,12 @@ impl PluginsManager { if !config.plugins_enabled { return None; } + let auth = self.auth_manager.auth_cached(); let key = PluginLoadCacheKey::from_config( config, self.codex_home.as_path(), self.remote_global_catalog_active(config), + RemoteInstalledPluginsAuthIdentity::from_auth(auth.as_ref()), ); self.loaded_plugins_cache .read() @@ -653,47 +723,95 @@ impl PluginsManager { return PluginLoadOutcome::default(); } - let remote_global_catalog_active = self.remote_global_catalog_active(config); - let cache_key = PluginLoadCacheKey::from_config( - config, - self.codex_home.as_path(), - remote_global_catalog_active, - ); - if !force_reload && let Some(plugins) = self.cached_loaded_plugins(&cache_key) { - return self.resolve_loaded_plugins_for_auth(plugins); - } + // Both the semaphore wait and skill loading can outlive the auth state captured at the + // start of this load. Account switches require a restart, so discard those passes; + // same-account revisions also cover ordinary token refreshes, where returning no plugins + // is wrong, so retry those instead. + let auth_change_receiver = self.auth_manager.auth_change_receiver(); - let Ok(_load_permit) = self.loaded_plugins_load_semaphore.acquire().await else { - warn!("plugin load semaphore closed"); - return PluginLoadOutcome::default(); - }; - if !force_reload && let Some(plugins) = self.cached_loaded_plugins(&cache_key) { - return self.resolve_loaded_plugins_for_auth(plugins); + loop { + let auth_revision = *auth_change_receiver.borrow(); + let remote_global_catalog_active = self.remote_global_catalog_active(config); + let auth = self.auth_manager.auth_cached(); + let auth_mode = auth.as_ref().map(CodexAuth::api_auth_mode); + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth.as_ref()); + let cache_key = PluginLoadCacheKey::from_config( + config, + self.codex_home.as_path(), + remote_global_catalog_active, + auth_identity.clone(), + ); + if !force_reload && let Some(plugins) = self.cached_loaded_plugins(&cache_key) { + let outcome = self.resolve_loaded_plugins_for_auth(plugins, auth_mode); + if *auth_change_receiver.borrow() == auth_revision { + return outcome; + } + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return PluginLoadOutcome::default(); + } + continue; + } + + let Ok(_load_permit) = self.loaded_plugins_load_semaphore.acquire().await else { + warn!("plugin load semaphore closed"); + return PluginLoadOutcome::default(); + }; + if *auth_change_receiver.borrow() != auth_revision { + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return PluginLoadOutcome::default(); + } + continue; + } + if !force_reload && let Some(plugins) = self.cached_loaded_plugins(&cache_key) { + let outcome = self.resolve_loaded_plugins_for_auth(plugins, auth_mode); + if *auth_change_receiver.borrow() == auth_revision { + return outcome; + } + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return PluginLoadOutcome::default(); + } + continue; + } + let cache_generation = self.loaded_plugins_cache_generation(); + let plugin_skill_snapshots = new_plugin_skill_snapshots(); + let plugins = load_plugins_from_layer_stack( + &config.config_layer_stack, + self.remote_installed_plugins_snapshot(), + &self.store, + Some(&plugin_skill_snapshots), + self.restriction_product, + remote_global_catalog_active, + self.skill_root_loader.as_ref(), + ) + .await; + if *auth_change_receiver.borrow() != auth_revision { + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return PluginLoadOutcome::default(); + } + continue; + } + log_plugin_load_errors(&plugins); + self.cache_loaded_plugins_if_current( + cache_generation, + cache_key, + plugins.clone(), + plugin_skill_snapshots, + ); + let outcome = self.resolve_loaded_plugins_for_auth(plugins, auth_mode); + if *auth_change_receiver.borrow() == auth_revision { + return outcome; + } + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return PluginLoadOutcome::default(); + } } - let cache_generation = self.loaded_plugins_cache_generation(); - let plugin_skill_snapshots = new_plugin_skill_snapshots(); - let plugins = load_plugins_from_layer_stack( - &config.config_layer_stack, - self.remote_installed_plugins_snapshot(), - &self.store, - Some(&plugin_skill_snapshots), - self.restriction_product, - remote_global_catalog_active, - self.skill_root_loader.as_ref(), - ) - .await; - log_plugin_load_errors(&plugins); - self.cache_loaded_plugins_if_current( - cache_generation, - cache_key, - plugins.clone(), - plugin_skill_snapshots, - ); - self.resolve_loaded_plugins_for_auth(plugins) } - fn resolve_loaded_plugins_for_auth(&self, mut plugins: Vec) -> PluginLoadOutcome { - let auth_mode = self.auth_mode(); + fn resolve_loaded_plugins_for_auth( + &self, + mut plugins: Vec, + auth_mode: Option, + ) -> PluginLoadOutcome { let target_curated_marketplace = target_curated_marketplace(auth_mode); plugins.retain(|plugin| { plugin_is_eligible_for_target_marketplace( @@ -822,7 +940,10 @@ impl PluginsManager { Ok(cache) => cache, Err(err) => err.into_inner(), }; - let Some(plugins) = cache.as_ref() else { + if !self.remote_installed_plugins_cache_matches_current_auth(&cache) { + return HashMap::new(); + } + let Some(plugins) = cache.plugins.as_ref() else { return HashMap::new(); }; @@ -834,7 +955,10 @@ impl PluginsManager { Ok(cache) => cache, Err(err) => err.into_inner(), }; - let Some(plugins) = cache.as_ref() else { + if !self.remote_installed_plugins_cache_matches_current_auth(&cache) { + return RemoteInstalledPluginsSnapshot::default(); + } + let Some(plugins) = cache.plugins.as_ref() else { return RemoteInstalledPluginsSnapshot::default(); }; @@ -849,7 +973,9 @@ impl PluginsManager { Ok(cache) => cache, Err(err) => err.into_inner(), }; - if let Some(plugins) = cache.as_ref() { + if self.remote_installed_plugins_cache_matches_current_auth(&cache) + && let Some(plugins) = cache.plugins.as_ref() + { return plugins.iter().find_map(|plugin| { (plugin.name == plugin_id.plugin_name && plugin.marketplace_name == plugin_id.marketplace_name) @@ -862,6 +988,25 @@ impl PluginsManager { persisted_remote_plugin_id_for_installation(&installation) } + fn remote_installed_plugins_cache_matches_current_auth( + &self, + cache: &RemoteInstalledPluginsCache, + ) -> bool { + let auth = self.auth_manager.auth_cached(); + cache.auth_identity.as_ref() + == Some(&RemoteInstalledPluginsAuthIdentity::from_auth( + auth.as_ref(), + )) + } + + fn remote_installed_plugins_auth_is_current( + &self, + auth_identity: &RemoteInstalledPluginsAuthIdentity, + ) -> bool { + let auth = self.auth_manager.auth_cached(); + RemoteInstalledPluginsAuthIdentity::from_auth(auth.as_ref()) == *auth_identity + } + pub async fn telemetry_metadata_for_installed_plugin( &self, plugin_id: &PluginId, @@ -939,12 +1084,29 @@ impl PluginsManager { pub fn build_remote_installed_plugin_marketplaces_from_cache( &self, visible_marketplaces: &[&str], + ) -> Option> { + let auth = self.auth_manager.auth_cached(); + self.build_remote_installed_plugin_marketplaces_from_cache_for_auth( + auth.as_ref(), + visible_marketplaces, + ) + } + + fn build_remote_installed_plugin_marketplaces_from_cache_for_auth( + &self, + auth: Option<&CodexAuth>, + visible_marketplaces: &[&str], ) -> Option> { let cache = match self.remote_installed_plugins_cache.read() { Ok(cache) => cache, Err(err) => err.into_inner(), }; - let plugins = cache.as_ref()?; + if cache.auth_identity.as_ref() + != Some(&RemoteInstalledPluginsAuthIdentity::from_auth(auth)) + { + return None; + } + let plugins = cache.plugins.as_ref()?; Some( crate::remote::group_remote_installed_plugins_by_marketplaces( plugins, @@ -985,6 +1147,9 @@ impl PluginsManager { visible_marketplaces: &[&str], on_effective_plugins_changed: Option, ) -> Result, RemotePluginCatalogError> { + let generation = self + .prepare_remote_installed_plugins_cache_generation(auth) + .ok_or(RemotePluginCatalogError::AuthRequired)?; let plugins = crate::remote::fetch_remote_installed_plugins( &remote_plugin_service_config(config), auth, @@ -994,25 +1159,173 @@ impl PluginsManager { &plugins, visible_marketplaces, ); - let changed = self.write_remote_installed_plugins_cache(plugins); + let Some(changed) = self.write_remote_installed_plugins_cache_snapshot( + generation, + plugins, + auth, + RemoteInstalledPluginsCachePublication::Refresh, + ) else { + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth); + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return Err(RemotePluginCatalogError::AuthRequired); + } + return Ok(self + .build_remote_installed_plugin_marketplaces_from_cache_for_auth( + auth, + visible_marketplaces, + ) + .unwrap_or(marketplaces)); + }; if changed && let Some(on_effective_plugins_changed) = on_effective_plugins_changed { on_effective_plugins_changed(EffectivePluginsChange::default()); } - Ok(marketplaces) + Ok(self + .build_remote_installed_plugin_marketplaces_from_cache_for_auth( + auth, + visible_marketplaces, + ) + .unwrap_or(marketplaces)) } - fn write_remote_installed_plugins_cache(&self, plugins: Vec) -> bool { + fn prepare_remote_installed_plugins_cache_generation( + &self, + auth: Option<&CodexAuth>, + ) -> Option { + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth); + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return None; + } let mut cache = match self.remote_installed_plugins_cache.write() { Ok(cache) => cache, Err(err) => err.into_inner(), }; - if cache.as_ref().is_some_and(|cache| cache.eq(&plugins)) { - return false; + let cache_changed = if cache.auth_identity.as_ref() != Some(&auth_identity) { + cache.generation = cache.generation.wrapping_add(1); + cache.auth_identity = Some(auth_identity); + cache.reconciliation_generation = None; + cache.needs_effective_plugins_refresh = false; + cache.plugins.take().is_some() + } else { + false + }; + let generation = cache.generation; + drop(cache); + if cache_changed { + self.clear_loaded_plugins_cache(); } - *cache = Some(plugins); + Some(generation) + } + + fn begin_remote_installed_plugins_reconcile(&self, auth: Option<&CodexAuth>) -> Option { + let generation = self.prepare_remote_installed_plugins_cache_generation(auth)?; + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth); + let mut cache = match self.remote_installed_plugins_cache.write() { + Ok(cache) => cache, + Err(err) => err.into_inner(), + }; + if cache.generation != generation || cache.auth_identity.as_ref() != Some(&auth_identity) { + return None; + } + cache.generation = cache.generation.wrapping_add(1); + cache.reconciliation_generation = Some(cache.generation); + Some(cache.generation) + } + + fn abandon_remote_installed_plugins_reconcile(&self, generation: u64) { + let mut cache = match self.remote_installed_plugins_cache.write() { + Ok(cache) => cache, + Err(err) => err.into_inner(), + }; + if cache.reconciliation_generation != Some(generation) { + return; + } + cache.reconciliation_generation = None; + cache.generation = cache.generation.wrapping_add(1); + cache.needs_effective_plugins_refresh = true; drop(cache); self.clear_loaded_plugins_cache(); - true + } + + fn remote_installed_plugins_cache_generation_if_current( + &self, + auth: Option<&CodexAuth>, + ) -> Option { + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth); + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return None; + } + let cache = match self.remote_installed_plugins_cache.read() { + Ok(cache) => cache, + Err(err) => err.into_inner(), + }; + (cache.auth_identity.as_ref() == Some(&auth_identity)).then_some(cache.generation) + } + + fn write_remote_installed_plugins_cache_snapshot( + &self, + generation: u64, + plugins: Vec, + auth: Option<&CodexAuth>, + publication: RemoteInstalledPluginsCachePublication, + ) -> Option { + let auth_identity = RemoteInstalledPluginsAuthIdentity::from_auth(auth); + if !self.remote_installed_plugins_auth_is_current(&auth_identity) { + return None; + } + let mut cache = match self.remote_installed_plugins_cache.write() { + Ok(cache) => cache, + Err(err) => err.into_inner(), + }; + if cache.generation != generation + || cache + .auth_identity + .as_ref() + .is_some_and(|current| current != &auth_identity) + { + return None; + } + let is_reconcile = matches!( + publication, + RemoteInstalledPluginsCachePublication::Reconcile + ); + if !is_reconcile && cache.reconciliation_generation == Some(generation) { + return None; + } + if cache.auth_identity.is_none() { + cache.auth_identity = Some(auth_identity); + } + if is_reconcile { + cache.reconciliation_generation = None; + cache.generation = cache.generation.wrapping_add(1); + } + let needs_effective_plugins_refresh = + is_reconcile && std::mem::take(&mut cache.needs_effective_plugins_refresh); + if cache.plugins.as_ref() == Some(&plugins) { + drop(cache); + if needs_effective_plugins_refresh { + self.clear_loaded_plugins_cache(); + } + return Some(needs_effective_plugins_refresh); + } + cache.plugins = Some(plugins); + drop(cache); + self.clear_loaded_plugins_cache(); + Some(true) + } + + #[cfg(test)] + fn write_remote_installed_plugins_cache(&self, plugins: Vec) -> bool { + let auth = self.auth_manager.auth_cached(); + let generation = self + .prepare_remote_installed_plugins_cache_generation(auth.as_ref()) + .expect("test cache identity should remain current"); + self.write_remote_installed_plugins_cache_snapshot( + generation, + plugins, + auth.as_ref(), + RemoteInstalledPluginsCachePublication::Refresh, + ) + .expect("test cache generation should remain current") } pub fn clear_remote_installed_plugins_cache(&self) -> bool { @@ -1020,15 +1333,38 @@ impl PluginsManager { Ok(cache) => cache, Err(err) => err.into_inner(), }; - if cache.is_none() { + cache.generation = cache.generation.wrapping_add(1); + cache.auth_identity = None; + cache.reconciliation_generation = None; + cache.needs_effective_plugins_refresh = false; + if cache.plugins.take().is_none() { return false; } - *cache = None; drop(cache); self.clear_loaded_plugins_cache(); true } + fn clear_remote_installed_plugins_cache_if_current(&self, generation: u64) -> Option { + let mut cache = match self.remote_installed_plugins_cache.write() { + Ok(cache) => cache, + Err(err) => err.into_inner(), + }; + if cache.generation != generation { + return None; + } + cache.generation = cache.generation.wrapping_add(1); + cache.auth_identity = None; + cache.reconciliation_generation = None; + cache.needs_effective_plugins_refresh = false; + if cache.plugins.take().is_none() { + return Some(false); + } + drop(cache); + self.clear_loaded_plugins_cache(); + Some(true) + } + pub fn maybe_start_remote_plugin_caches_refresh( self: &Arc, config: &PluginsConfigInput, @@ -1079,8 +1415,14 @@ impl PluginsManager { return; } + let Some(generation) = + self.prepare_remote_installed_plugins_cache_generation(auth.as_ref()) + else { + return; + }; self.schedule_remote_installed_plugins_cache_refresh( RemoteInstalledPluginsCacheRefreshRequest { + generation, service_config: remote_plugin_service_config(config), auth, notify, @@ -1109,34 +1451,27 @@ impl PluginsManager { return; }; let manager = Arc::clone(self); - let config_for_refresh = config.clone(); - let service_config = remote_plugin_service_config(config); + let config = config.clone(); tokio::spawn(async move { let _permit = permit; - let result = crate::remote::sync_remote_installed_plugin_bundles_once( - manager.codex_home.clone(), - &service_config, - Some(&auth), - ) - .await; + let result = manager + .reconcile_remote_installed_plugins_after_acquiring_gate(&config, Some(&auth)) + .await; match result { - Ok(outcome) => { + Ok((outcome, effective_plugins_changed)) => { tracing::info!( materialized_remote_plugins = ?outcome.materialized_remote_plugins, removed_cache_plugin_ids = ?outcome.removed_cache_plugin_ids, failed_remote_plugin_ids = ?outcome.failed_remote_plugin_ids, + failed_materialization_remote_plugin_ids = ?outcome.failed_materialization_remote_plugin_ids, "completed remote installed plugin bundle sync" ); - if outcome.changed_local_cache() { - manager.maybe_start_remote_installed_plugins_cache_refresh_with_notify( - &config_for_refresh, - Some(auth), - RemoteInstalledPluginsCacheRefreshNotify::AfterSuccessfulRefresh, - on_effective_plugins_changed, - EffectivePluginsChange { - materialized_remote_plugins: outcome.materialized_remote_plugins, - }, - ); + if (effective_plugins_changed || outcome.changed_local_cache()) + && let Some(on_effective_plugins_changed) = on_effective_plugins_changed + { + on_effective_plugins_changed(EffectivePluginsChange { + materialized_remote_plugins: outcome.materialized_remote_plugins, + }); } } Err(err) => { @@ -1144,11 +1479,86 @@ impl PluginsManager { error = %err, "remote installed plugin bundle sync failed" ); + manager.maybe_start_remote_installed_plugins_cache_refresh_with_notify( + &config, + Some(auth), + RemoteInstalledPluginsCacheRefreshNotify::IfCacheChanged, + on_effective_plugins_changed, + EffectivePluginsChange::default(), + ); } } }); } + /// Acquires the cache-root gate shared by full installed-bundle sync, reconciliation, and + /// direct remote plugin mutations. + pub async fn acquire_remote_installed_plugin_sync_guard( + &self, + ) -> Result { + let permit = tokio::time::timeout( + REMOTE_INSTALLED_PLUGIN_SYNC_WAIT_TIMEOUT, + Arc::clone(&self.remote_installed_plugin_bundle_sync_gate).acquire_owned(), + ) + .await + .map_err(|_| RemoteInstalledPluginBundleSyncError::LockTimeout)? + .map_err(|_| RemoteInstalledPluginBundleSyncError::Superseded)?; + Ok(RemoteInstalledPluginSyncGuard { _permit: permit }) + } + + /// Synchronizes remote bundles and publishes the same installed-plugin snapshot. + /// + /// The shared gate orders this blocking path with background bundle synchronization. A + /// reconciled publication advances the cache generation so metadata fetches that started + /// before or during the bundle pass cannot overwrite its snapshot afterward. + pub async fn reconcile_remote_installed_plugins( + &self, + config: &PluginsConfigInput, + auth: Option<&CodexAuth>, + ) -> Result { + let _guard = self.acquire_remote_installed_plugin_sync_guard().await?; + let (outcome, _) = self + .reconcile_remote_installed_plugins_after_acquiring_gate(config, auth) + .await?; + Ok(outcome) + } + + async fn reconcile_remote_installed_plugins_after_acquiring_gate( + &self, + config: &PluginsConfigInput, + auth: Option<&CodexAuth>, + ) -> Result<(RemoteInstalledPluginBundleSyncOutcome, bool), RemoteInstalledPluginBundleSyncError> + { + let generation = self + .begin_remote_installed_plugins_reconcile(auth) + .ok_or(RemoteInstalledPluginBundleSyncError::Superseded)?; + let mut reconciliation = RemoteInstalledPluginsReconciliationGuard { + manager: self, + generation, + committed: false, + }; + let result = crate::remote::sync_remote_installed_plugin_bundles_once_with_snapshot( + self.codex_home.clone(), + &remote_plugin_service_config(config), + auth, + ) + .await?; + let outcome = result.outcome; + let Some(effective_plugins_changed) = self.write_remote_installed_plugins_cache_snapshot( + generation, + result.installed_plugins, + auth, + RemoteInstalledPluginsCachePublication::Reconcile, + ) else { + return Err(RemoteInstalledPluginBundleSyncError::Superseded); + }; + reconciliation.committed = true; + if !effective_plugins_changed && outcome.changed_local_cache() { + self.clear_loaded_plugins_cache(); + } + Ok((outcome, effective_plugins_changed)) + } + fn maybe_start_remote_catalog_cache_refresh( self: &Arc, config: &PluginsConfigInput, @@ -1372,9 +1782,12 @@ impl PluginsManager { Ok(cache) => cache, Err(err) => err.into_inner(), }; - cache - .as_deref() - .unwrap_or_default() + let plugins = self + .remote_installed_plugins_cache_matches_current_auth(&cache) + .then_some(cache.plugins.as_deref()) + .flatten() + .unwrap_or_default(); + plugins .iter() .filter(|plugin| plugin.marketplace_name == REMOTE_GLOBAL_MARKETPLACE_NAME) .map(|plugin| plugin.id.clone()) @@ -2379,12 +2792,24 @@ impl PluginsManager { self: &Arc, mut request: RemoteInstalledPluginsCacheRefreshRequest, ) { + if self.remote_installed_plugins_cache_generation_if_current(request.auth.as_ref()) + != Some(request.generation) + { + return; + } let should_spawn = { let mut state = match self.remote_installed_plugins_cache_refresh_state.write() { Ok(state) => state, Err(err) => err.into_inner(), }; - if let Some(existing_request) = state.requested.as_ref() { + if self.remote_installed_plugins_cache_generation_if_current(request.auth.as_ref()) + != Some(request.generation) + { + return; + } + if let Some(existing_request) = state.requested.as_ref() + && existing_request.generation == request.generation + { if matches!( existing_request.notify, RemoteInstalledPluginsCacheRefreshNotify::AfterSuccessfulRefresh @@ -2725,16 +3150,21 @@ impl PluginsManager { } }; - let installed_plugins = crate::remote::fetch_remote_installed_plugins( + let plugins = crate::remote::fetch_remote_installed_plugins( &request.service_config, request.auth.as_ref(), ) .await; - match installed_plugins { - Ok(installed_plugins) => { - // TODO(remote plugins): reconcile missing or stale local bundles before - // publishing remote installed state as effective local plugin config. - let changed = self.write_remote_installed_plugins_cache(installed_plugins); + match plugins { + Ok(plugins) => { + let Some(changed) = self.write_remote_installed_plugins_cache_snapshot( + request.generation, + plugins, + request.auth.as_ref(), + RemoteInstalledPluginsCachePublication::Refresh, + ) else { + continue; + }; let should_notify = changed || !request.change.materialized_remote_plugins.is_empty() || matches!( @@ -2752,7 +3182,11 @@ impl PluginsManager { RemotePluginCatalogError::AuthRequired | RemotePluginCatalogError::UnsupportedAuthMode, ) => { - let changed = self.clear_remote_installed_plugins_cache(); + let Some(changed) = + self.clear_remote_installed_plugins_cache_if_current(request.generation) + else { + continue; + }; if changed && let Some(on_effective_plugins_changed) = request.on_effective_plugins_changed diff --git a/codex-rs/core-plugins/src/manager_tests.rs b/codex-rs/core-plugins/src/manager_tests.rs index e12a1719c8..1aae6242fd 100644 --- a/codex-rs/core-plugins/src/manager_tests.rs +++ b/codex-rs/core-plugins/src/manager_tests.rs @@ -20,6 +20,7 @@ use crate::startup_sync::curated_plugins_repo_path; use crate::test_support::TEST_CURATED_PLUGIN_CACHE_VERSION; use crate::test_support::TEST_CURATED_PLUGIN_SHA; use crate::test_support::load_plugins_config as load_plugins_config_input; +use crate::test_support::set_test_auth; use crate::test_support::set_test_auth_mode; use crate::test_support::test_auth_manager; use crate::test_support::test_http_client_factory; @@ -3062,6 +3063,7 @@ fn loaded_plugins_cache_invalidation_rejects_stale_load_completion() { configured_plugins: HashMap::new(), skill_config_rules: SkillConfigRules::default(), remote_global_catalog_active: false, + auth_identity: None, }; let stale_generation = manager.loaded_plugins_cache_generation(); @@ -3076,6 +3078,60 @@ fn loaded_plugins_cache_invalidation_rejects_stale_load_completion() { assert_eq!(manager.cached_loaded_plugins(&cache_key), None); } +#[tokio::test] +async fn plugins_for_config_discards_in_flight_load_after_account_change() { + let codex_home = TempDir::new().unwrap(); + write_cached_plugin( + codex_home.path(), + REMOTE_GLOBAL_MARKETPLACE_NAME, + "remote-only", + ); + let config = PluginsConfigInput::new( + unrestricted_config_layer_stack(), + String::new(), + /*plugins_enabled*/ true, + /*remote_plugin_enabled*/ true, + String::new(), + test_http_client_factory(), + ); + let auth_manager = test_auth_manager(Some(AuthMode::ChatgptAuthTokens)); + let manager = Arc::new(test_plugins_manager_with_auth_manager( + codex_home.path().to_path_buf(), + Some(Product::Codex), + Arc::clone(&auth_manager), + )); + manager.write_remote_installed_plugins_cache(vec![remote_installed_plugin("remote-only")]); + let account_a = auth_manager + .auth_cached() + .expect("capture first ChatGPT auth"); + + let load_permit = manager + .loaded_plugins_load_semaphore + .try_acquire() + .expect("hold plugin load semaphore"); + let load = manager.plugins_for_config(&config); + tokio::pin!(load); + assert!(matches!( + futures::poll!(load.as_mut()), + std::task::Poll::Pending + )); + let account_b = CodexAuth::from_external_chatgpt_tokens( + "header.e30.other", + "other-account", + /*chatgpt_plan_type*/ None, + ) + .expect("build second ChatGPT auth"); + set_test_auth(&auth_manager, Some(account_b)).await; + drop(load_permit); + assert_eq!(load.await, PluginLoadOutcome::default()); + + set_test_auth(&auth_manager, Some(account_a)).await; + assert_eq!( + loaded_plugin_names(&manager, &config).await, + vec!["remote-only@openai-curated-remote".to_string()] + ); +} + #[tokio::test] async fn load_plugins_rejects_invalid_plugin_keys() { let codex_home = TempDir::new().unwrap(); @@ -6830,8 +6886,12 @@ fn remote_installed_plugins_cache_refresh_coalesces_materializations() { }); callback }; + let generation = manager + .prepare_remote_installed_plugins_cache_generation(/*auth*/ None) + .expect("prepare remote installed cache generation"); let request = |change, on_effective_plugins_changed| RemoteInstalledPluginsCacheRefreshRequest { + generation, service_config: RemotePluginServiceConfig::new( "https://example.com".to_string(), test_http_client_factory(), @@ -6931,6 +6991,200 @@ remote_plugin = true server.verify().await; } +#[tokio::test] +async fn reconcile_remote_installed_plugins_rejects_incomplete_snapshot_without_cleanup() { + let codex_home = TempDir::new().unwrap(); + write_file( + &codex_home.path().join(CONFIG_TOML_FILE), + r#"[features] +plugins = true +remote_plugin = true +"#, + ); + write_cached_plugin(codex_home.path(), REMOTE_GLOBAL_MARKETPLACE_NAME, "linear"); + write_cached_plugin( + codex_home.path(), + REMOTE_WORKSPACE_SHARED_WITH_ME_MARKETPLACE_NAME, + "malformed", + ); + write_cached_plugin( + codex_home.path(), + REMOTE_WORKSPACE_MARKETPLACE_NAME, + "renamed-malformed", + ); + let malformed_remote_plugin_id = "plugins~Plugin_malformed"; + let malformed_plugin_id = PluginId::new( + "malformed".to_string(), + REMOTE_WORKSPACE_SHARED_WITH_ME_MARKETPLACE_NAME.to_string(), + ) + .expect("valid malformed plugin id"); + PluginStore::new(codex_home.path().to_path_buf()) + .write_remote_plugin_id(&malformed_plugin_id, malformed_remote_plugin_id) + .expect("persist malformed plugin identity"); + + let server = MockServer::start().await; + Mock::given(method("GET")) + .and(path("/backend-api/ps/plugins/installed")) + .and(query_param("includeDownloadUrls", "true")) + .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({ + "plugins": [ + { + "id": "plugins~Plugin_linear", + "name": "linear", + "scope": "GLOBAL", + "installation_policy": "AVAILABLE", + "authentication_policy": "ON_USE", + "status": "ENABLED", + "release": { + "version": "local", + "display_name": "", + "description": "Track work", + "interface": {}, + }, + "enabled": true, + }, + { + "id": malformed_remote_plugin_id, + "name": "renamed-malformed", + "scope": "WORKSPACE", + "installation_policy": "AVAILABLE", + "authentication_policy": "ON_USE", + "status": "ENABLED", + "release": { + "version": "local", + "display_name": "Malformed", + "description": "Missing discoverability", + "interface": {}, + }, + "enabled": true, + }, + ], + "pagination": {"next_page_token": null}, + }))) + .expect(1) + .mount(&server) + .await; + + let mut config = load_config(codex_home.path(), codex_home.path()).await; + config.chatgpt_base_url = format!("{}/backend-api", server.uri()); + let auth_manager = test_auth_manager(Some(AuthMode::Chatgpt)); + let auth = auth_manager.auth_cached().expect("test ChatGPT auth"); + let manager = std::sync::Arc::new(test_plugins_manager_with_auth_manager( + codex_home.path().to_path_buf(), + Some(Product::Codex), + auth_manager, + )); + let mut previous_malformed = remote_installed_plugin_in_marketplace( + "malformed", + REMOTE_WORKSPACE_SHARED_WITH_ME_MARKETPLACE_NAME, + ); + previous_malformed.id = malformed_remote_plugin_id.to_string(); + previous_malformed.version = Some("local".to_string()); + previous_malformed.enabled = false; + manager.write_remote_installed_plugins_cache(vec![previous_malformed.clone()]); + + let result = manager + .reconcile_remote_installed_plugins(&config, Some(&auth)) + .await; + + assert!(matches!( + result, + Err(RemoteInstalledPluginBundleSyncError::Catalog( + RemotePluginCatalogError::UnexpectedResponse(_) + )) + )); + server.verify().await; + assert_eq!( + manager + .remote_installed_plugins_cache + .read() + .expect("installed plugin cache lock") + .plugins + .clone(), + Some(vec![previous_malformed]) + ); + let plugin_cache_root = codex_home.path().join("plugins/cache"); + let renamed_malformed_cache = plugin_cache_root + .join(REMOTE_WORKSPACE_MARKETPLACE_NAME) + .join("renamed-malformed"); + let previous_malformed_cache = plugin_cache_root + .join(REMOTE_WORKSPACE_SHARED_WITH_ME_MARKETPLACE_NAME) + .join("malformed"); + let linear_metadata = plugin_cache_root + .join(REMOTE_GLOBAL_MARKETPLACE_NAME) + .join("linear") + .join(".codex-remote-plugin-install.json"); + assert!(renamed_malformed_cache.exists()); + assert!(previous_malformed_cache.exists()); + assert!(!linear_metadata.exists()); +} + +#[test] +fn reconciliation_fences_refresh_publication_and_recovers_after_cancellation() { + let codex_home = TempDir::new().unwrap(); + let manager = test_plugins_manager(codex_home.path().to_path_buf()); + let reconcile_generation = manager + .begin_remote_installed_plugins_reconcile(/*auth*/ None) + .expect("begin reconciliation"); + let stale_refresh_generation = manager + .remote_installed_plugins_cache_generation_if_current(/*auth*/ None) + .expect("capture concurrent refresh generation"); + + assert_eq!( + manager.write_remote_installed_plugins_cache_snapshot( + stale_refresh_generation, + Vec::new(), + /*auth*/ None, + RemoteInstalledPluginsCachePublication::Refresh, + ), + None + ); + assert_eq!( + manager.write_remote_installed_plugins_cache_snapshot( + reconcile_generation, + vec![remote_installed_linear_plugin()], + /*auth*/ None, + RemoteInstalledPluginsCachePublication::Reconcile, + ), + Some(true) + ); + let cancelled_generation = manager + .begin_remote_installed_plugins_reconcile(/*auth*/ None) + .expect("begin cancelled reconciliation"); + let reconciliation = RemoteInstalledPluginsReconciliationGuard { + manager: &manager, + generation: cancelled_generation, + committed: false, + }; + + drop(reconciliation); + + let refresh_generation = manager + .remote_installed_plugins_cache_generation_if_current(/*auth*/ None) + .expect("capture refresh generation after cancellation"); + assert_eq!( + manager.write_remote_installed_plugins_cache_snapshot( + refresh_generation, + vec![remote_installed_plugin("beta")], + /*auth*/ None, + RemoteInstalledPluginsCachePublication::Refresh, + ), + Some(true) + ); + let retry_generation = manager + .begin_remote_installed_plugins_reconcile(/*auth*/ None) + .expect("begin retry after cancellation"); + assert_eq!( + manager.write_remote_installed_plugins_cache_snapshot( + retry_generation, + vec![remote_installed_plugin("beta")], + /*auth*/ None, + RemoteInstalledPluginsCachePublication::Reconcile, + ), + Some(true) + ); +} + #[test] fn plugin_install_error_preserves_store_io_sub_error_type() { let error = PluginInstallError::Store(PluginStoreError::Io { diff --git a/codex-rs/core-plugins/src/remote.rs b/codex-rs/core-plugins/src/remote.rs index 050c1e551e..f4e8294b68 100644 --- a/codex-rs/core-plugins/src/remote.rs +++ b/codex-rs/core-plugins/src/remote.rs @@ -62,6 +62,7 @@ pub use remote_installed_plugin_sync::RemotePluginMaterialization; pub use remote_installed_plugin_sync::mark_remote_plugin_cache_mutation_in_flight; pub(crate) use remote_installed_plugin_sync::remote_installed_plugin_bundle_sync_gate; pub use remote_installed_plugin_sync::sync_remote_installed_plugin_bundles_once; +pub(crate) use remote_installed_plugin_sync::sync_remote_installed_plugin_bundles_once_with_snapshot; pub use search::RemotePluginSearchPage; pub use search::RemotePluginSearchRequest; pub use search::search_remote_plugins; @@ -1815,11 +1816,18 @@ fn remote_installed_plugin_to_cache_entry( installed_plugin: &RemotePluginInstalledItem, ) -> Result { let plugin = &installed_plugin.plugin; + let marketplace_name = remote_plugin_canonical_marketplace_name(plugin)?.to_string(); + PluginId::new(plugin.name.clone(), marketplace_name.clone()).map_err(|err| { + RemotePluginCatalogError::UnexpectedResponse(format!( + "invalid remote plugin config id for `{}` in `{marketplace_name}`: {err}", + plugin.name + )) + })?; // Remote per-skill disabled state (`disabled_skill_names`) is intentionally // not projected into skills/list yet; local skills.config remains the // supported source for skill enablement. Ok(RemoteInstalledPlugin { - marketplace_name: remote_plugin_canonical_marketplace_name(plugin)?.to_string(), + marketplace_name, id: plugin.id.clone(), version: plugin.release.version.clone(), name: plugin.name.clone(), diff --git a/codex-rs/core-plugins/src/remote/remote_installed_plugin_sync.rs b/codex-rs/core-plugins/src/remote/remote_installed_plugin_sync.rs index 7560c81e61..040fb22f9a 100644 --- a/codex-rs/core-plugins/src/remote/remote_installed_plugin_sync.rs +++ b/codex-rs/core-plugins/src/remote/remote_installed_plugin_sync.rs @@ -4,6 +4,7 @@ use super::REMOTE_WORKSPACE_MARKETPLACE_NAME; use super::REMOTE_WORKSPACE_SHARED_WITH_ME_MARKETPLACE_NAME; use super::REMOTE_WORKSPACE_SHARED_WITH_ME_PRIVATE_MARKETPLACE_NAME; use super::REMOTE_WORKSPACE_SHARED_WITH_ME_UNLISTED_MARKETPLACE_NAME; +use super::RemoteInstalledPlugin; use super::RemoteInstalledPluginScope; use super::RemotePluginCatalogError; use super::RemotePluginScope; @@ -11,7 +12,6 @@ use super::RemotePluginServiceConfig; use super::RemotePluginShareDiscoverability; use super::ensure_chatgpt_auth; use super::fetch_installed_plugins; -use super::remote_plugin_canonical_marketplace_name; use crate::store::PLUGINS_CACHE_DIR; use crate::store::PluginStore; use crate::store::PluginStoreError; @@ -51,6 +51,13 @@ pub struct RemoteInstalledPluginBundleSyncOutcome { pub materialized_remote_plugins: Vec, pub removed_cache_plugin_ids: Vec, pub failed_remote_plugin_ids: Vec, + /// Failures that leave an otherwise valid installed plugin unavailable locally. + pub failed_materialization_remote_plugin_ids: Vec, +} + +pub(crate) struct RemoteInstalledPluginBundleSyncResult { + pub(crate) outcome: RemoteInstalledPluginBundleSyncOutcome, + pub(crate) installed_plugins: Vec, } impl RemoteInstalledPluginBundleSyncOutcome { @@ -66,6 +73,12 @@ pub enum RemoteInstalledPluginBundleSyncError { #[error("{0}")] Store(#[from] PluginStoreError), + + #[error("timed out waiting for another remote plugin cache mutation; retry")] + LockTimeout, + + #[error("remote plugin state changed during reconciliation; retry reconciliation")] + Superseded, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -100,15 +113,44 @@ pub async fn sync_remote_installed_plugin_bundles_once( config: &RemotePluginServiceConfig, auth: Option<&CodexAuth>, ) -> Result { + let result = + sync_remote_installed_plugin_bundles_once_with_snapshot(codex_home, config, auth).await?; + Ok(result.outcome) +} + +pub(crate) async fn sync_remote_installed_plugin_bundles_once_with_snapshot( + codex_home: PathBuf, + config: &RemotePluginServiceConfig, + auth: Option<&CodexAuth>, +) -> Result { let auth = ensure_chatgpt_auth(auth)?; let authenticated_account_id = auth.get_account_id(); - let installed_plugins = fetch_installed_plugins( + let fetched_installed_plugins = fetch_installed_plugins( config, auth, RemoteInstalledPluginScope::All, /*include_download_urls*/ true, ) .await?; + // `/installed` is an authoritative full snapshot. If any row cannot be + // canonicalized to a local cache key, omitting it makes an installed plugin + // indistinguishable from an uninstall, so reject the pass before downloads, + // publication, or stale cleanup. + let mut validated_installed_plugins = Vec::with_capacity(fetched_installed_plugins.len()); + for installed_plugin in fetched_installed_plugins { + let cached_plugin = super::remote_installed_plugin_to_cache_entry(&installed_plugin)?; + let plugin_id = PluginId::new( + installed_plugin.plugin.name.clone(), + cached_plugin.marketplace_name.clone(), + ) + .map_err(|err| { + RemotePluginCatalogError::UnexpectedResponse(format!( + "remote installed plugin `{}` has an invalid local cache id: {err}", + installed_plugin.plugin.id + )) + })?; + validated_installed_plugins.push((installed_plugin, cached_plugin, plugin_id)); + } let store = PluginStore::try_new(codex_home.clone())?; let mut installed_plugin_names_by_marketplace = BTreeMap::>::from_iter([ @@ -136,37 +178,27 @@ pub async fn sync_remote_installed_plugin_bundles_once( ]); let mut materialized_remote_plugins = BTreeMap::new(); let mut failed_remote_plugin_ids = BTreeSet::new(); + let mut failed_materialization_remote_plugin_ids = BTreeSet::new(); + let mut installed_plugins = Vec::new(); - for installed_plugin in installed_plugins { + for (installed_plugin, cached_plugin, plugin_id) in validated_installed_plugins { + let marketplace_name = cached_plugin.marketplace_name.clone(); let plugin = installed_plugin.plugin; let scope = plugin.scope; let discoverability = plugin.discoverability; - let marketplace_name = remote_plugin_canonical_marketplace_name(&plugin)?.to_string(); installed_plugin_names_by_marketplace .entry(marketplace_name.clone()) .or_default() .insert(plugin.name.clone()); - let plugin_id = match PluginId::new(plugin.name.clone(), marketplace_name.clone()) { - Ok(plugin_id) => plugin_id, - Err(err) => { - warn!( - remote_plugin_id = %plugin.id, - plugin = %plugin.name, - marketplace = %marketplace_name, - error = %err, - "skipping remote installed plugin with invalid local cache id" - ); - failed_remote_plugin_ids.insert(plugin.id); - continue; - } - }; let release_version = plugin .release .version .as_deref() .map(str::trim) .filter(|version| !version.is_empty()); - if store.active_plugin_version(&plugin_id).as_deref() == release_version { + if let Some(release_version) = release_version + && store.active_plugin_version(&plugin_id).as_deref() == Some(release_version) + { if let Err(err) = store.write_remote_plugin_id(&plugin_id, &plugin.id) { warn!( remote_plugin_id = %plugin.id, @@ -177,6 +209,7 @@ pub async fn sync_remote_installed_plugin_bundles_once( ); failed_remote_plugin_ids.insert(plugin.id); } + installed_plugins.push(cached_plugin); continue; } @@ -197,7 +230,9 @@ pub async fn sync_remote_installed_plugin_bundles_once( error = %err, "skipping remote installed plugin bundle download" ); - failed_remote_plugin_ids.insert(plugin.id); + failed_remote_plugin_ids.insert(plugin.id.clone()); + failed_materialization_remote_plugin_ids.insert(plugin.id); + installed_plugins.push(cached_plugin); continue; } }; @@ -229,34 +264,51 @@ pub async fn sync_remote_installed_plugin_bundles_once( error = %err, "failed to download remote installed plugin bundle" ); - failed_remote_plugin_ids.insert(plugin.id); + failed_remote_plugin_ids.insert(plugin.id.clone()); + failed_materialization_remote_plugin_ids.insert(plugin.id); } } + installed_plugins.push(cached_plugin); } + installed_plugins.sort_by(|left, right| { + left.marketplace_name + .cmp(&right.marketplace_name) + .then_with(|| left.id.cmp(&right.id)) + }); let stale_cache_cleanup = tokio::task::spawn_blocking(move || { - remove_stale_remote_plugin_caches( + let mut removed_cache_plugin_ids = Vec::new(); + let cleanup_error = remove_stale_remote_plugin_caches( codex_home.as_path(), &installed_plugin_names_by_marketplace, + &mut removed_cache_plugin_ids, ) + .err(); + removed_cache_plugin_ids.sort(); + (removed_cache_plugin_ids, cleanup_error) }) .await; - let removed_cache_plugin_ids = match stale_cache_cleanup { - Ok(Ok(removed_cache_plugin_ids)) => removed_cache_plugin_ids, - Ok(Err(err)) => { - warn!(error = %err, "failed to remove stale remote plugin cache entries"); - Vec::new() - } + let (removed_cache_plugin_ids, cleanup_error) = match stale_cache_cleanup { + Ok(result) => result, Err(err) => { warn!(error = %err, "failed to join stale remote plugin cache cleanup task"); - Vec::new() + (Vec::new(), Some(err.to_string())) } }; + if let Some(err) = cleanup_error { + warn!(error = %err, "failed to remove stale remote plugin cache entries"); + } - Ok(RemoteInstalledPluginBundleSyncOutcome { - materialized_remote_plugins: materialized_remote_plugins.into_values().collect(), - removed_cache_plugin_ids, - failed_remote_plugin_ids: failed_remote_plugin_ids.into_iter().collect(), + Ok(RemoteInstalledPluginBundleSyncResult { + outcome: RemoteInstalledPluginBundleSyncOutcome { + materialized_remote_plugins: materialized_remote_plugins.into_values().collect(), + removed_cache_plugin_ids, + failed_remote_plugin_ids: failed_remote_plugin_ids.into_iter().collect(), + failed_materialization_remote_plugin_ids: failed_materialization_remote_plugin_ids + .into_iter() + .collect(), + }, + installed_plugins, }) } @@ -301,8 +353,8 @@ impl Drop for RemotePluginCacheMutationGuard { fn remove_stale_remote_plugin_caches( codex_home: &Path, installed_plugin_names_by_marketplace: &BTreeMap>, -) -> Result, String> { - let mut removed_cache_plugin_ids = Vec::new(); + removed_cache_plugin_ids: &mut Vec, +) -> Result<(), String> { for marketplace_name in [ REMOTE_GLOBAL_MARKETPLACE_NAME, REMOTE_CREATED_BY_ME_MARKETPLACE_NAME, @@ -369,8 +421,7 @@ fn remove_stale_remote_plugin_caches( } } - removed_cache_plugin_ids.sort(); - Ok(removed_cache_plugin_ids) + Ok(()) } fn remote_plugin_cache_root(codex_home: &Path) -> PathBuf { @@ -410,7 +461,7 @@ mod tests { use wiremock::matchers::query_param_is_missing; #[tokio::test] - async fn sync_same_version_backfills_metadata_without_materialization() { + async fn sync_same_version_backfills_metadata_and_missing_version_requires_materialization() { let server = MockServer::start().await; let codex_home = tempfile::tempdir().expect("create codex home"); let cached_manifest = codex_home @@ -432,21 +483,37 @@ mod tests { .and(query_param("limit", "200")) .and(query_param("includeDownloadUrls", "true")) .respond_with(ResponseTemplate::new(200).set_body_json(json!({ - "plugins": [{ - "id": remote_plugin_id, - "name": "linear", - "scope": "GLOBAL", - "installation_policy": "AVAILABLE", - "authentication_policy": "ON_USE", - "status": "ENABLED", - "release": { - "version": "1.2.3", - "display_name": "Linear", - "description": "Track work", - "interface": {}, + "plugins": [ + { + "id": remote_plugin_id, + "name": "linear", + "scope": "GLOBAL", + "installation_policy": "AVAILABLE", + "authentication_policy": "ON_USE", + "status": "ENABLED", + "release": { + "version": "1.2.3", + "display_name": "Linear", + "description": "Track work", + "interface": {}, + }, + "enabled": true, }, - "enabled": true, - }], + { + "id": "plugins~Plugin_missing_version", + "name": "missing-version", + "scope": "GLOBAL", + "installation_policy": "AVAILABLE", + "authentication_policy": "ON_USE", + "status": "ENABLED", + "release": { + "display_name": "Missing version", + "description": "Needs materialization", + "interface": {}, + }, + "enabled": true, + }, + ], "pagination": {"next_page_token": null}, }))) .expect(1) @@ -466,7 +533,16 @@ mod tests { .await .expect("sync current remote plugin bundle"); - assert_eq!(outcome, RemoteInstalledPluginBundleSyncOutcome::default()); + assert_eq!( + outcome, + RemoteInstalledPluginBundleSyncOutcome { + failed_remote_plugin_ids: vec!["plugins~Plugin_missing_version".to_string()], + failed_materialization_remote_plugin_ids: vec![ + "plugins~Plugin_missing_version".to_string() + ], + ..RemoteInstalledPluginBundleSyncOutcome::default() + } + ); let plugin_id = PluginId::new( "linear".to_string(), REMOTE_GLOBAL_MARKETPLACE_NAME.to_string(), @@ -486,6 +562,14 @@ mod tests { "remote_plugin_id": remote_plugin_id, }) ); + assert!( + !codex_home + .path() + .join(PLUGINS_CACHE_DIR) + .join(REMOTE_GLOBAL_MARKETPLACE_NAME) + .join("missing-version") + .exists() + ); } #[tokio::test] @@ -611,6 +695,7 @@ mod tests { materialized_remote_plugins: Vec::new(), removed_cache_plugin_ids, failed_remote_plugin_ids: Vec::new(), + failed_materialization_remote_plugin_ids: Vec::new(), } ); assert_eq!( @@ -701,27 +786,33 @@ mod tests { REMOTE_GLOBAL_MARKETPLACE_NAME, "linear", ); - let removed = remove_stale_remote_plugin_caches( + let mut removed = Vec::new(); + remove_stale_remote_plugin_caches( codex_home.path(), &installed_plugin_names_by_marketplace, + &mut removed, ) .expect("cleanup while install is guarded"); assert_eq!(removed, Vec::::new()); assert!(cached_manifest.is_file()); drop(guard); - let removed = remove_stale_remote_plugin_caches( + let mut removed = Vec::new(); + remove_stale_remote_plugin_caches( codex_home.path(), &installed_plugin_names_by_marketplace, + &mut removed, ) .expect("cleanup while second install guard is still active"); assert_eq!(removed, Vec::::new()); assert!(cached_manifest.is_file()); drop(second_guard); - let removed = remove_stale_remote_plugin_caches( + let mut removed = Vec::new(); + remove_stale_remote_plugin_caches( codex_home.path(), &installed_plugin_names_by_marketplace, + &mut removed, ) .expect("cleanup after install guard is dropped"); assert_eq!(removed, vec!["linear@openai-curated-remote".to_string()]); @@ -799,9 +890,11 @@ mod tests { ), ]); - let removed = remove_stale_remote_plugin_caches( + let mut removed = Vec::new(); + remove_stale_remote_plugin_caches( codex_home.path(), &installed_plugin_names_by_marketplace, + &mut removed, ) .expect("cleanup private shared-with-me cache"); diff --git a/codex-rs/core-plugins/src/test_support.rs b/codex-rs/core-plugins/src/test_support.rs index ae081488a1..0cae12bcca 100644 --- a/codex-rs/core-plugins/src/test_support.rs +++ b/codex-rs/core-plugins/src/test_support.rs @@ -89,7 +89,11 @@ pub(crate) fn test_auth_manager(auth_mode: Option) -> Arc } pub(crate) async fn set_test_auth_mode(auth_manager: &AuthManager, auth_mode: Option) { - let Some(auth) = test_codex_auth(auth_mode) else { + set_test_auth(auth_manager, test_codex_auth(auth_mode)).await; +} + +pub(crate) async fn set_test_auth(auth_manager: &AuthManager, auth: Option) { + let Some(auth) = auth else { auth_manager.clear_external_auth(); return; };