Lightweight coding agent that runs in your terminal
Rust
Centralize remote plugin mutations in `PluginsManager` (#42114)
willwang-openaief76e6ac3099
diff --git a/codex-rs/app-server/src/request_processors/plugins.rs b/codex-rs/app-server/src/request_processors/plugins.rsindex 1e3e41d954..13a9dfecca 100644--- a/codex-rs/app-server/src/request_processors/plugins.rs+++ b/codex-rs/app-server/src/request_processors/plugins.rs@@ -4,13 +4,15 @@ use crate::error_code::internal_error;use crate::error_code::invalid_request;use codex_analytics::PluginInstallSource;use codex_app_server_protocol::PluginAvailability;-use codex_app_server_protocol::PluginInstallPolicy;use codex_app_server_protocol::PluginSharePrincipalRole;use codex_app_server_protocol::PluginShareTargetRole;use codex_config::types::McpServerConfig;use codex_core_plugins::OPENAI_CURATED_MARKETPLACE_NAME;use codex_core_plugins::PluginListBackgroundTaskOptions;use codex_core_plugins::PluginMarketplaceContext;+use codex_core_plugins::RemotePluginInstallRequest;+use codex_core_plugins::RemotePluginOperationError;+use codex_core_plugins::RemotePluginOperationErrorKind;use codex_core_plugins::is_openai_curated_marketplace_name;use codex_core_plugins::loader::load_configured_plugin_mcp_servers;use codex_core_plugins::manifest::is_agent_plugin_manifest;@@ -1553,173 +1555,62 @@ impl PluginRequestProcessor {install_attempt_id: Option<String>,) -> Result<PluginInstallResponse, JSONRPCErrorError> {let config = self.load_latest_config(/*fallback_cwd*/ None).await?;- if !config.features.enabled(Feature::Plugins) {- return Err(invalid_request(format!(- "remote plugin install is not enabled for marketplace {remote_marketplace_name}"- )));- }- validate_remote_plugin_id(&remote_plugin_id)?;-let auth = self.auth_manager.auth().await;- let remote_plugin_service_config = remote_plugin_service_config(&config);- let remote_detail =- codex_core_plugins::remote::fetch_remote_plugin_detail_with_download_urls(- &remote_plugin_service_config,+ let plugins_manager = self.thread_manager.plugins_manager();+ let installation = plugins_manager+ .install_remote_plugin(+ &config.plugins_config_input(),auth.as_ref(),- &remote_marketplace_name,- &remote_plugin_id,+ RemotePluginInstallRequest {+ marketplace_name: remote_marketplace_name.clone(),+ remote_plugin_id: remote_plugin_id.clone(),+ install_attempt_id,+ },+ Some(self.effective_plugins_changed_callback()),).await.map_err(|err| {- let error_type = remote_plugin_catalog_error_type(&err);- let sub_error_type = err.sub_error_type();- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &remote_marketplace_name,- /*plugin_id*/ None,- error_type,- sub_error_type,- err.to_string(),- );- remote_plugin_catalog_error_to_jsonrpc(- err,- "read remote plugin details before install",- )- })?;- let actual_remote_marketplace_name = remote_detail.marketplace_name.clone();- let remote_plugin_name = remote_detail.summary.name.clone();- let resolved_plugin_id = PluginId::parse(&remote_detail.summary.id).map_err(|err| {- internal_error(format!(- "invalid resolved plugin id `{}`: {err}",- remote_detail.summary.id- ))- })?;- if remote_detail.summary.availability == PluginAvailability::DisabledByAdmin {- let error_message = format!("remote plugin {remote_plugin_id} is disabled by admin");- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &actual_remote_marketplace_name,- Some(&resolved_plugin_id),- "remote_plugin_not_available",- Some("disabled_by_admin".to_string()),- error_message.clone(),- );- return Err(invalid_request(error_message));- }- if remote_detail.summary.install_policy == PluginInstallPolicy::NotAvailable {- let error_message =- format!("remote plugin {remote_plugin_id} is not available for install");- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &actual_remote_marketplace_name,- Some(&resolved_plugin_id),- "remote_plugin_not_available",- Some("install_policy_not_available".to_string()),- error_message.clone(),- );- return Err(invalid_request(error_message));- }- let validated_bundle = codex_core_plugins::remote_bundle::validate_remote_plugin_bundle(- &remote_plugin_id,- &actual_remote_marketplace_name,- &remote_plugin_name,- remote_detail.release_version.as_deref(),- remote_detail.bundle_download_url.as_deref(),- remote_detail.app_manifest.clone(),- )- .map_err(|err| {- let error_type = remote_plugin_bundle_install_error_type(&err);- let sub_error_type = err.sub_error_type();- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &actual_remote_marketplace_name,- Some(&resolved_plugin_id),- error_type,- sub_error_type,- err.to_string(),- );- 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}"))+ let classification = match err.kind.as_ref() {+ RemotePluginOperationErrorKind::Catalog { source, .. } => Some((+ remote_plugin_catalog_error_type(source),+ source.sub_error_type(),+ )),+ RemotePluginOperationErrorKind::Bundle(source) => Some((+ remote_plugin_bundle_install_error_type(source),+ source.sub_error_type(),+ )),+ RemotePluginOperationErrorKind::DisabledByAdmin(_) => Some((+ "remote_plugin_not_available",+ Some("disabled_by_admin".to_string()),+ )),+ RemotePluginOperationErrorKind::NotAvailable(_) => Some((+ "remote_plugin_not_available",+ Some("install_policy_not_available".to_string()),+ )),+ RemotePluginOperationErrorKind::Sync { .. }+ | RemotePluginOperationErrorKind::InvalidRequest(_)+ | RemotePluginOperationErrorKind::Internal(_) => None,+ };+ if let Some((error_type, sub_error_type)) = classification {+ let marketplace = err+ .plugin_id+ .as_ref()+ .map(|id| id.marketplace_name.as_str())+ .unwrap_or(&remote_marketplace_name);+ self.track_plugin_install_failed_for_remote_plugin(+ &remote_plugin_id,+ marketplace,+ err.plugin_id.as_ref(),+ error_type,+ sub_error_type,+ err.to_string(),+ );+ }+ remote_plugin_operation_error_to_jsonrpc(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(),- validated_bundle,- )- .await- .map_err(|err| {- let error_type = remote_plugin_bundle_install_error_type(&err);- let sub_error_type = err.sub_error_type();- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &actual_remote_marketplace_name,- Some(&resolved_plugin_id),- error_type,- sub_error_type,- err.to_string(),- );- remote_plugin_bundle_install_error_to_jsonrpc(err)- })?;-- // Cache first so a backend install cannot succeed when local materialization fails.- // If this backend call fails, the cache entry is harmless because remote installed state- // is still backend-gated.- let install_result = if let Some(install_attempt_id) = install_attempt_id.as_deref() {- codex_core_plugins::remote::install_remote_plugin_with_install_attempt_id(- &remote_plugin_service_config,- auth.as_ref(),- &actual_remote_marketplace_name,- &remote_plugin_id,- install_attempt_id,- )- .await- } else {- codex_core_plugins::remote::install_remote_plugin(- &remote_plugin_service_config,- auth.as_ref(),- &actual_remote_marketplace_name,- &remote_plugin_id,- )- .await- }- .map_err(|err| {- let error_type = remote_plugin_catalog_error_type(&err);- let sub_error_type = err.sub_error_type();- self.track_plugin_install_failed_for_remote_plugin(- &remote_plugin_id,- &actual_remote_marketplace_name,- Some(&result.plugin_id),- error_type,- sub_error_type,- err.to_string(),- );- remote_plugin_catalog_error_to_jsonrpc(err, "install remote plugin")- })?;-- 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);+ // Retain the installation outcome through OAuth/app setup: it protects the bundle from pruning.+ let remote_detail = installation.detail;+ let result = installation.installed;let plugin_metadata = self.thread_manager@@ -1753,7 +1644,7 @@ impl PluginRequestProcessor {let is_chatgpt_auth = auth.as_ref().is_some_and(CodexAuth::is_chatgpt_auth);let apps_needing_auth = if let Some(app_ids_needing_auth) =- install_result.app_ids_needing_auth+ installation.app_ids_needing_auth{if app_ids_needing_auth.is_empty()|| !config.features.apps_enabled_for_auth(is_chatgpt_auth)@@ -2136,78 +2027,30 @@ impl PluginRequestProcessor {plugin_id: String,) -> Result<PluginUninstallResponse, JSONRPCErrorError> {let config = self.load_latest_config(/*fallback_cwd*/ None).await?;- if !config.features.enabled(Feature::Plugins) {- return Err(invalid_request("remote plugin uninstall is not enabled"));- }- validate_remote_plugin_id(&plugin_id)?;-let auth = self.auth_manager.auth().await;- let remote_plugin_service_config = remote_plugin_service_config(&config);- let uninstall_target = codex_core_plugins::remote::resolve_remote_plugin_uninstall_target(- &remote_plugin_service_config,- auth.as_ref(),- &plugin_id,- )- .await- .map_err(|err| {- remote_plugin_catalog_error_to_jsonrpc(err, "resolve remote plugin before uninstall")- })?;- let plugins_manager = self.thread_manager.plugins_manager();- let mut plugin_telemetry = plugins_manager- .telemetry_metadata_for_installed_plugin_with_remote_id(- &uninstall_target.plugin_id,- &uninstall_target.remote_plugin_id,- )- .await;- if plugin_telemetry.capability_summary.is_none() {- 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(),- config.codex_home.to_path_buf(),- uninstall_target,- )- .await;-- let mut refresh_effective_plugins = false;- if matches!(- &uninstall_result,- Ok(()) | Err(RemotePluginCatalogError::CacheRemove(_))- ) {- self.analytics_events_client- .track_plugin_uninstalled(plugin_telemetry);- refresh_effective_plugins = plugins_manager.clear_remote_installed_plugins_cache();- plugins_manager.maybe_start_remote_installed_plugins_cache_refresh_after_mutation(+ let outcome = self+ .thread_manager+ .plugins_manager()+ .uninstall_remote_plugin(&config.plugins_config_input(),- auth.clone(),+ auth.as_ref(),+ &plugin_id,Some(self.effective_plugins_changed_callback()),- );- }- drop(remote_plugin_cache_mutation);- drop(remote_plugin_sync_guard);- if refresh_effective_plugins {+ )+ .await+ .map_err(remote_plugin_operation_error_to_jsonrpc)?;+ self.analytics_events_client+ .track_plugin_uninstalled(outcome.telemetry);+ if outcome.effective_plugins_changed {self.on_effective_plugins_changed().await;}+ if let Some(err) = outcome.cache_removal_error {+ return Err(remote_plugin_catalog_error_to_jsonrpc(+ err,+ "uninstall remote plugin",+ ));+ }- uninstall_result.map_err(|err| {- remote_plugin_catalog_error_to_jsonrpc(err, "uninstall remote plugin")- })?;Ok(PluginUninstallResponse {})}}@@ -2528,3 +2371,21 @@ fn remote_plugin_bundle_install_error_to_jsonrpc() -> JSONRPCErrorError {internal_error(format!("install remote plugin bundle: {err}"))}++fn remote_plugin_operation_error_to_jsonrpc(err: RemotePluginOperationError) -> JSONRPCErrorError {+ match *err.kind {+ RemotePluginOperationErrorKind::Catalog { context, source } => {+ remote_plugin_catalog_error_to_jsonrpc(source, context)+ }+ RemotePluginOperationErrorKind::Bundle(source) => {+ remote_plugin_bundle_install_error_to_jsonrpc(source)+ }+ RemotePluginOperationErrorKind::Sync { context, source } => {+ internal_error(format!("{context}: {source}"))+ }+ err @ (RemotePluginOperationErrorKind::DisabledByAdmin(_)+ | RemotePluginOperationErrorKind::NotAvailable(_)+ | RemotePluginOperationErrorKind::InvalidRequest(_)) => invalid_request(err.to_string()),+ RemotePluginOperationErrorKind::Internal(message) => internal_error(message),+ }+}diff --git a/codex-rs/core-plugins/src/lib.rs b/codex-rs/core-plugins/src/lib.rsindex cde35626bc..539e628284 100644--- a/codex-rs/core-plugins/src/lib.rs+++ b/codex-rs/core-plugins/src/lib.rs@@ -83,7 +83,11 @@ pub use manager::PluginUninstallError;pub use manager::PluginsConfigInput;pub use manager::PluginsManager;pub use manager::RecommendedPluginCandidatesInput;-pub use manager::RemoteInstalledPluginSyncGuard;+pub use manager::RemotePluginInstallOutcome;+pub use manager::RemotePluginInstallRequest;+pub use manager::RemotePluginOperationError;+pub use manager::RemotePluginOperationErrorKind;+pub use manager::RemotePluginUninstallOutcome;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.rsindex 4b2d0ff69f..a83f0eb459 100644--- a/codex-rs/core-plugins/src/manager.rs+++ b/codex-rs/core-plugins/src/manager.rs@@ -1,5 +1,12 @@#[path = "bundled_plugin_exclusions.rs"]mod bundled_plugin_exclusions;+#[path = "remote_mutations.rs"]+mod remote_mutations;+pub use remote_mutations::RemotePluginInstallOutcome;+pub use remote_mutations::RemotePluginInstallRequest;+pub use remote_mutations::RemotePluginOperationError;+pub use remote_mutations::RemotePluginOperationErrorKind;+pub use remote_mutations::RemotePluginUninstallOutcome;#[path = "marketplace_context.rs"]mod marketplace_context;pub use marketplace_context::PluginMarketplaceContext;@@ -255,7 +262,7 @@ enum RemoteInstalledPluginsCachePublication {////// 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 {+struct RemoteInstalledPluginSyncGuard {_permit: OwnedSemaphorePermit,}@@ -1458,7 +1465,7 @@ impl PluginsManager {});}- pub fn maybe_start_remote_installed_plugins_cache_refresh_after_mutation(+ fn maybe_start_remote_installed_plugins_cache_refresh_after_mutation(self: &Arc<Self>,config: &PluginsConfigInput,auth: Option<CodexAuth>,@@ -1563,7 +1570,7 @@ impl PluginsManager {/// 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(+ async fn acquire_remote_installed_plugin_sync_guard(&self,) -> Result<RemoteInstalledPluginSyncGuard, RemoteInstalledPluginBundleSyncError> {let permit = tokio::time::timeout(diff --git a/codex-rs/core-plugins/src/remote_mutations.rs b/codex-rs/core-plugins/src/remote_mutations.rsnew file mode 100644index 0000000000..5e07d6f8a7--- /dev/null+++ b/codex-rs/core-plugins/src/remote_mutations.rs@@ -0,0 +1,298 @@+//! Shared remote plugin mutations for the CLI and app-server.+//! The sync gate covers cache/backend changes and refresh scheduling. An install outcome keeps+//! its bundle protected from pruning until the caller finishes downstream setup and drops it.++use super::EffectivePluginsChangedCallback;+use super::PluginInstallOutcome;+use super::PluginsConfigInput;+use super::PluginsManager;+use crate::marketplace::MarketplacePluginAuthPolicy;+use crate::remote;+use crate::remote::RemoteInstalledPluginBundleSyncError;+use crate::remote::RemotePluginCacheMutationGuard;+use crate::remote::RemotePluginCatalogError;+use crate::remote::RemotePluginDetail;+use crate::remote_bundle;+use crate::remote_bundle::RemotePluginBundleInstallError;+use codex_app_server_protocol::PluginAuthPolicy;+use codex_app_server_protocol::PluginAvailability;+use codex_app_server_protocol::PluginInstallPolicy;+use codex_login::CodexAuth;+use codex_plugin::PluginId;+use codex_plugin::PluginTelemetryMetadata;+use std::sync::Arc;++#[cfg(test)]+#[path = "remote_mutations_tests.rs"]+mod tests;++pub struct RemotePluginInstallRequest {+ pub marketplace_name: String,+ pub remote_plugin_id: String,+ pub install_attempt_id: Option<String>,+}++/// Keep this outcome alive throughout post-install setup to protect the installed bundle.+#[must_use]+pub struct RemotePluginInstallOutcome {+ pub installed: PluginInstallOutcome,+ pub detail: RemotePluginDetail,+ pub app_ids_needing_auth: Option<Vec<String>>,+ _cache_mutation: RemotePluginCacheMutationGuard,+}++pub struct RemotePluginUninstallOutcome {+ pub telemetry: PluginTelemetryMetadata,+ pub effective_plugins_changed: bool,+ /// The backend uninstall succeeded even when removing the local cache failed.+ pub cache_removal_error: Option<RemotePluginCatalogError>,+}++#[derive(Debug, thiserror::Error)]+#[error("{kind}")]+pub struct RemotePluginOperationError {+ pub plugin_id: Option<PluginId>,+ #[source]+ pub kind: Box<RemotePluginOperationErrorKind>,+}++#[derive(Debug, thiserror::Error)]+pub enum RemotePluginOperationErrorKind {+ #[error("{context}: {source}")]+ Catalog {+ context: &'static str,+ source: RemotePluginCatalogError,+ },+ #[error("install remote plugin bundle: {0}")]+ Bundle(#[source] RemotePluginBundleInstallError),+ #[error("{context}: {source}")]+ Sync {+ context: &'static str,+ source: RemoteInstalledPluginBundleSyncError,+ },+ #[error("remote plugin {0} is disabled by admin")]+ DisabledByAdmin(String),+ #[error("remote plugin {0} is not available for install")]+ NotAvailable(String),+ #[error("{0}")]+ InvalidRequest(String),+ #[error("{0}")]+ Internal(String),+}++impl PluginsManager {+ /// Resolve, validate, materialize, and install a remote plugin as one coordinated mutation.+ pub async fn install_remote_plugin(+ self: &Arc<Self>,+ config: &PluginsConfigInput,+ auth: Option<&CodexAuth>,+ request: RemotePluginInstallRequest,+ on_effective_plugins_changed: Option<EffectivePluginsChangedCallback>,+ ) -> Result<RemotePluginInstallOutcome, RemotePluginOperationError> {+ use RemotePluginOperationErrorKind as Error;+ let unresolved = |kind| RemotePluginOperationError {+ plugin_id: None,+ kind: Box::new(kind),+ };+ let RemotePluginInstallRequest {+ marketplace_name,+ remote_plugin_id,+ install_attempt_id,+ } = request;+ if !config.plugins_enabled {+ return Err(unresolved(Error::InvalidRequest(format!(+ "remote plugin install is not enabled for marketplace {marketplace_name}"+ ))));+ }+ remote::validate_remote_plugin_id(&remote_plugin_id)+ .map_err(|err| unresolved(Error::InvalidRequest(err.message)))?;+ let service = config.remote_plugin_service_config();+ let detail = remote::fetch_remote_plugin_detail_with_download_urls(+ &service,+ auth,+ &marketplace_name,+ &remote_plugin_id,+ )+ .await+ .map_err(|source| {+ unresolved(Error::Catalog {+ context: "read remote plugin details before install",+ source,+ })+ })?;+ let plugin_id = PluginId::parse(&detail.summary.id).map_err(|err| {+ unresolved(Error::Internal(format!(+ "invalid resolved plugin id `{}`: {err}",+ detail.summary.id+ )))+ })?;+ let resolved = |kind| RemotePluginOperationError {+ plugin_id: Some(plugin_id.clone()),+ kind: Box::new(kind),+ };+ if detail.summary.availability == PluginAvailability::DisabledByAdmin {+ return Err(resolved(Error::DisabledByAdmin(remote_plugin_id)));+ }+ if detail.summary.install_policy == PluginInstallPolicy::NotAvailable {+ return Err(resolved(Error::NotAvailable(remote_plugin_id)));+ }+ let bundle = remote_bundle::validate_remote_plugin_bundle(+ &remote_plugin_id,+ &detail.marketplace_name,+ &detail.summary.name,+ detail.release_version.as_deref(),+ detail.bundle_download_url.as_deref(),+ detail.app_manifest.clone(),+ )+ .map_err(|err| resolved(Error::Bundle(err)))?;+ let _sync_guard = self+ .acquire_remote_installed_plugin_sync_guard()+ .await+ .map_err(|source| {+ resolved(Error::Sync {+ context: "failed to coordinate remote plugin install",+ source,+ })+ })?;+ let cache_mutation = remote::mark_remote_plugin_cache_mutation_in_flight(+ &self.codex_home,+ &detail.marketplace_name,+ &detail.summary.name,+ );+ // Materialize first: a failed download must never leave a backend installation behind.+ let installed = remote_bundle::download_and_install_remote_plugin_bundle(+ &service,+ self.codex_home.clone(),+ bundle,+ )+ .await+ .map_err(|err| resolved(Error::Bundle(err)))?;+ let install_result = if let Some(install_attempt_id) = install_attempt_id.as_deref() {+ remote::install_remote_plugin_with_install_attempt_id(+ &service,+ auth,+ &detail.marketplace_name,+ &remote_plugin_id,+ install_attempt_id,+ )+ .await+ } else {+ remote::install_remote_plugin(+ &service,+ auth,+ &detail.marketplace_name,+ &remote_plugin_id,+ )+ .await+ }+ .map_err(|source| {+ resolved(Error::Catalog {+ context: "install remote plugin",+ source,+ })+ })?;+ self.maybe_start_remote_installed_plugins_cache_refresh_after_mutation(+ config,+ auth.cloned(),+ on_effective_plugins_changed,+ );+ Ok(RemotePluginInstallOutcome {+ installed: PluginInstallOutcome {+ plugin_id: installed.plugin_id,+ plugin_version: installed.plugin_version,+ installed_path: installed.installed_path,+ auth_policy: match detail.summary.auth_policy {+ PluginAuthPolicy::OnInstall => MarketplacePluginAuthPolicy::OnInstall,+ PluginAuthPolicy::OnUse => MarketplacePluginAuthPolicy::OnUse,+ },+ },+ detail,+ app_ids_needing_auth: install_result.app_ids_needing_auth,+ _cache_mutation: cache_mutation,+ })+ }++ /// Remove the backend installation and local cache, then schedule an installed-state refresh.+ pub async fn uninstall_remote_plugin(+ self: &Arc<Self>,+ config: &PluginsConfigInput,+ auth: Option<&CodexAuth>,+ remote_plugin_id: &str,+ on_effective_plugins_changed: Option<EffectivePluginsChangedCallback>,+ ) -> Result<RemotePluginUninstallOutcome, RemotePluginOperationError> {+ use RemotePluginOperationErrorKind as Error;+ let unresolved = |kind| RemotePluginOperationError {+ plugin_id: None,+ kind: Box::new(kind),+ };+ if !config.plugins_enabled {+ return Err(unresolved(Error::InvalidRequest(+ "remote plugin uninstall is not enabled".to_string(),+ )));+ }+ remote::validate_remote_plugin_id(remote_plugin_id)+ .map_err(|err| unresolved(Error::InvalidRequest(err.message)))?;+ let service = config.remote_plugin_service_config();+ let target =+ remote::resolve_remote_plugin_uninstall_target(&service, auth, remote_plugin_id)+ .await+ .map_err(|source| {+ unresolved(Error::Catalog {+ context: "resolve remote plugin before uninstall",+ source,+ })+ })?;+ let mut telemetry = self+ .telemetry_metadata_for_installed_plugin_with_remote_id(+ &target.plugin_id,+ remote_plugin_id,+ )+ .await;+ if telemetry.capability_summary.is_none() {+ telemetry.capability_summary = Some(target.fallback_capability_summary.clone());+ }+ let plugin_id = target.plugin_id.clone();+ let resolved = |kind| RemotePluginOperationError {+ plugin_id: Some(plugin_id.clone()),+ kind: Box::new(kind),+ };+ let _sync_guard = self+ .acquire_remote_installed_plugin_sync_guard()+ .await+ .map_err(|source| {+ resolved(Error::Sync {+ context: "failed to coordinate remote plugin uninstall",+ source,+ })+ })?;+ let _cache_mutation = remote::mark_remote_plugin_cache_mutation_in_flight(+ &self.codex_home,+ &plugin_id.marketplace_name,+ &plugin_id.plugin_name,+ );+ let cache_removal_error =+ match remote::uninstall_remote_plugin(&service, auth, self.codex_home.clone(), target)+ .await+ {+ Ok(()) => None,+ Err(err @ RemotePluginCatalogError::CacheRemove(_)) => Some(err),+ Err(source) => {+ return Err(resolved(Error::Catalog {+ context: "uninstall remote plugin",+ source,+ }));+ }+ };+ let effective_plugins_changed = self.clear_remote_installed_plugins_cache();+ self.maybe_start_remote_installed_plugins_cache_refresh_after_mutation(+ config,+ auth.cloned(),+ on_effective_plugins_changed,+ );+ Ok(RemotePluginUninstallOutcome {+ telemetry,+ effective_plugins_changed,+ cache_removal_error,+ })+ }+}diff --git a/codex-rs/core-plugins/src/remote_mutations_tests.rs b/codex-rs/core-plugins/src/remote_mutations_tests.rsnew file mode 100644index 0000000000..727001d73b--- /dev/null+++ b/codex-rs/core-plugins/src/remote_mutations_tests.rs@@ -0,0 +1,111 @@+//! Regression coverage for the shared mutation gate, refresh, and backend failure handling.++use super::*;+use crate::remote::REMOTE_GLOBAL_MARKETPLACE_NAME;+use crate::test_support::load_plugins_config;+use crate::test_support::test_auth_manager;+use crate::test_support::test_plugins_manager_with_auth_manager;+use crate::test_support::write_file;+use codex_protocol::auth::AuthMode;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering;+use tempfile::TempDir;+use tokio::sync::Notify;+use wiremock::Mock;+use wiremock::MockServer;+use wiremock::ResponseTemplate;+use wiremock::matchers::method;+use wiremock::matchers::path;++#[tokio::test]+async fn uninstall_serializes_backend_mutations_and_preserves_cache_on_failure() {+ for uninstall_fails in [false, true] {+ let home = TempDir::new().unwrap();+ let server = MockServer::start().await;+ let mut config = load_plugins_config(home.path(), 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().await;+ let manager = Arc::new(test_plugins_manager_with_auth_manager(+ home.path().to_path_buf(),+ /*restriction_product*/ None,+ auth_manager,+ ));+ let remote_id = "b1234567-89ab-4cde-8f01-234567890abc";+ let plugin_id = PluginId::new(+ "sample".to_string(),+ REMOTE_GLOBAL_MARKETPLACE_NAME.to_string(),+ )+ .unwrap();+ let cache = manager.store.plugin_base_root(&plugin_id);+ write_file(+ cache.join("1.0.0/.codex-plugin/plugin.json").as_path(),+ r#"{"name":"sample","version":"1.0.0"}"#,+ );+ Mock::given(method("GET"))+ .and(path(format!("/backend-api/ps/plugins/{remote_id}")))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "id": remote_id, "name": "sample", "scope": "GLOBAL",+ "installation_policy": "AVAILABLE", "authentication_policy": "ON_USE",+ "release": {"display_name": "Sample", "description": "Sample plugin", "interface": {}}+ }))).mount(&server).await;+ Mock::given(method("GET"))+ .and(path("/backend-api/ps/plugins/installed"))+ .respond_with(+ ResponseTemplate::new(200)+ .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),+ )+ .expect(if uninstall_fails { 0 } else { 1 })+ .mount(&server)+ .await;+ let gate_held = Arc::new(AtomicBool::new(false));+ let gate_held_at_post = Arc::clone(&gate_held);+ let manager_at_post = Arc::clone(&manager);+ Mock::given(method("POST"))+ .and(path(format!(+ "/backend-api/ps/plugins/{remote_id}/uninstall"+ )))+ .respond_with(move |_: &wiremock::Request| {+ gate_held_at_post.store(+ manager_at_post+ .remote_installed_plugin_bundle_sync_gate+ .available_permits()+ == 0,+ Ordering::SeqCst,+ );+ ResponseTemplate::new(if uninstall_fails { 400 } else { 200 })+ .set_body_json(json!({"id": remote_id, "enabled": false}))+ })+ .expect(1)+ .mount(&server)+ .await;+ let refreshed = Arc::new(Notify::new());+ let refreshed_callback = Arc::clone(&refreshed);+ let outcome = manager+ .uninstall_remote_plugin(+ &config,+ auth.as_ref(),+ remote_id,+ Some(Arc::new(move |_| refreshed_callback.notify_one())),+ )+ .await;+ assert_eq!(+ (+ gate_held.load(Ordering::SeqCst),+ manager+ .remote_installed_plugin_bundle_sync_gate+ .available_permits(),+ cache.as_path().exists(),+ outcome.is_err()+ ),+ (true, 1, uninstall_fails, uninstall_fails),+ );+ if !uninstall_fails {+ tokio::time::timeout(std::time::Duration::from_secs(5), refreshed.notified())+ .await+ .expect("successful uninstall should refresh installed state");+ }+ }+}