Preserve plugin runtimes across catalog metadata updates (#62105)

## Why

An advertised plugin release or installation metadata change should preserve live MCP sessions and cached skills while the active local bundle remains unchanged, including when an upgrade fails.

## What changed

- Compare runtime identity, enablement, connector ownership, and the active bundle separately from catalog release, policy, and display metadata.
- Track the active bundle's directory version and persisted remote plugin ID so changes made by another process refresh the runtime.
- Retain pending runtime notifications until a host callback is available and deliver them through `plugin/reconcile`.
- Preserve cancellation recovery across retries while avoiding unnecessary runtime invalidation for catalog fetch failures.

## Testing

Add unit and app-server regression coverage for catalog-only updates, failed upgrades, externally activated bundles, deferred notifications, and reconciliation recovery.

GitOrigin-RevId: ab20012c1bfd760adea55614f49fbbc7ef86fe8b
This commit is contained in:
Charlie Marsh
2026-11-17 19:46:24 +00:00
committed by copyberry
parent 7457b7268f
commit 9a56c2b1aa
8 changed files with 529 additions and 100 deletions
@@ -32,7 +32,11 @@ impl PluginRequestProcessor {
let outcome = self
.thread_manager
.plugins_manager()
.reconcile_remote_installed_plugins(&plugins_input, auth.as_ref())
.reconcile_remote_installed_plugins_with_notify(
&plugins_input,
auth.as_ref(),
Some(self.effective_plugins_changed_callback()),
)
.await
.map_err(|err| {
internal_error(format!(
@@ -14,7 +14,7 @@ use pretty_assertions::assert_eq;
use tokio::sync::RwLock;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn signed_image_renewal_preserves_live_mcp_and_plugin_skills() -> Result<()> {
async fn catalog_metadata_updates_preserve_live_mcp_and_plugin_skills() -> Result<()> {
let responses_server = responses::start_mock_server().await;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let base_url = format!("http://{}", listener.local_addr()?);
@@ -156,9 +156,64 @@ async fn signed_image_renewal_preserves_live_mcp_and_plugin_skills() -> Result<(
warm_skills
);
installed.write().await["installed_at"] = json!("2026-11-16T12:00:00Z");
refresh_and_expect_logo(&mut app_server, renewed_logo).await?;
read_mcp_skill_resource(&mut app_server, &thread.id).await?;
assert_eq!(sessions.load(Ordering::SeqCst), warm_sessions);
{
let mut plugin = installed.write().await;
plugin["release"]["version"] = json!("1.1.0");
plugin["release"]["bundle_download_url"] = json!(format!("{base_url}/missing-bundle"));
}
let request = app_server
.send_raw_request("plugin/installed", Some(json!({})))
.await?;
let _: PluginInstalledResponse =
timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(request)).await??;
let request = app_server
.send_raw_request("plugin/reconcile", Some(json!({})))
.await?;
let reconciled: PluginReconcileResponse =
timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(request)).await??;
assert!(reconciled.changed_plugins.is_empty());
assert_eq!(
reconciled.failed_remote_plugin_ids,
vec!["plugins~Plugin_00000000000000000000000000000000"]
);
let request = app_server
.send_raw_request("plugin/installed", Some(json!({})))
.await?;
let response: PluginInstalledResponse =
timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(request)).await??;
let plugin = response
.marketplaces
.iter()
.flat_map(|marketplace| &marketplace.plugins)
.find(|plugin| plugin.name == "demo-plugin")
.context("installed plugin should remain visible after an advertised upgrade")?;
assert_eq!(plugin.version.as_deref(), Some("1.1.0"));
assert_eq!(plugin.local_version.as_deref(), Some("1.0.0"));
let request = app_server
.send_raw_request("plugin/reconcile", Some(json!({})))
.await?;
let _: PluginReconcileResponse =
timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(request)).await??;
read_mcp_skill_resource(&mut app_server, &thread.id).await?;
assert_eq!(sessions.load(Ordering::SeqCst), warm_sessions);
assert_eq!(
list_plugin_skills(&mut app_server, codex_home.path()).await?,
warm_skills
);
// Runtime metadata must update the cached skill catalog without changing the bundle.
installed.write().await["release"]["interface"]["logo_url"] = json!(changed_logo);
installed.write().await["enabled"] = json!(false);
{
let mut plugin = installed.write().await;
plugin["release"]["version"] = json!("1.0.0");
plugin["release"]["bundle_download_url"] = json!(format!("{base_url}/bundle"));
plugin["release"]["interface"]["logo_url"] = json!(changed_logo);
plugin["enabled"] = json!(false);
}
refresh_and_expect_logo(&mut app_server, changed_logo).await?;
assert!(
list_plugin_skills(&mut app_server, codex_home.path())
@@ -167,15 +222,110 @@ async fn signed_image_renewal_preserves_live_mcp_and_plugin_skills() -> Result<(
);
read_mcp_skill_resource(&mut app_server, &thread.id).await?;
assert_eq!(sessions.load(Ordering::SeqCst), warm_sessions);
assert_eq!(calls.snapshot().main_prompt_reads, 4);
assert_eq!(calls.snapshot().main_prompt_reads, 6);
assert_eq!(
std::fs::read_to_string(warm_skills[0].path.as_str())?,
SKILL_CONTENTS
);
// Restore the plugin, then simulate a different process activating a new bundle.
let plugin_root = codex_home
.path()
.join("plugins/cache/openai-curated-remote/demo-plugin");
let original_root = plugin_root.join("1.0.0");
write_fixture_mcp(&original_root, "fixture-original")?;
installed.write().await["enabled"] = json!(true);
reconcile_plugins(&mut app_server).await?;
expect_fixture_mcp(&mut app_server, &thread.id, "fixture-original").await?;
{
let mut plugin = installed.write().await;
plugin["release"]["version"] = json!("1.1.0");
plugin["release"]["bundle_download_url"] = json!(format!("{base_url}/missing-bundle"));
}
let failed = reconcile_plugins(&mut app_server).await?;
assert!(failed.changed_plugins.is_empty());
assert_eq!(failed.failed_remote_plugin_ids.len(), 1);
expect_fixture_mcp(&mut app_server, &thread.id, "fixture-original").await?;
let upgraded_root = plugin_root.join("1.1.0");
std::fs::rename(&original_root, &upgraded_root)?;
write_fixture_mcp(&upgraded_root, "fixture-upgrade")?;
assert!(
reconcile_plugins(&mut app_server)
.await?
.changed_plugins
.is_empty()
);
expect_fixture_mcp(&mut app_server, &thread.id, "fixture-upgrade").await?;
// A different remote identity can replace the bundle without changing its directory version.
let replacement_id = "plugins~Plugin_00000000000000000000000000000001";
installed.write().await["id"] = json!(replacement_id);
let failed = reconcile_plugins(&mut app_server).await?;
assert_eq!(failed.failed_remote_plugin_ids, vec![replacement_id]);
expect_fixture_mcp(&mut app_server, &thread.id, "fixture-upgrade").await?;
write_fixture_mcp(&upgraded_root, "fixture-replacement")?;
std::fs::write(
plugin_root.join(".codex-remote-plugin-install.json"),
serde_json::to_vec(&json!({"schema_version": 1, "remote_plugin_id": replacement_id}))?,
)?;
assert!(
reconcile_plugins(&mut app_server)
.await?
.changed_plugins
.is_empty()
);
expect_fixture_mcp(&mut app_server, &thread.id, "fixture-replacement").await?;
server_handle.abort();
Ok(())
}
fn write_fixture_mcp(root: &std::path::Path, name: &str) -> Result<()> {
std::fs::write(
root.join(".mcp.json"),
serde_json::to_vec(&json!({
"mcpServers": {(name): {"type": "http", "url": "http://127.0.0.1:9/mcp"}}
}))?,
)?;
Ok(())
}
async fn reconcile_plugins(app_server: &mut TestAppServer) -> Result<PluginReconcileResponse> {
let request = app_server
.send_raw_request("plugin/reconcile", Some(json!({})))
.await?;
timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(request)).await?
}
async fn expect_fixture_mcp(
app_server: &mut TestAppServer,
thread_id: &str,
expected: &str,
) -> Result<()> {
timeout(DEFAULT_READ_TIMEOUT, async {
loop {
let request = app_server
.send_raw_request("mcpServerStatus/list", Some(json!({"threadId": thread_id})))
.await?;
let response: serde_json::Value = app_server.read_response(request).await?;
let names = response["data"]
.as_array()
.context("missing MCP status data")?
.iter()
.filter_map(|row| row["name"].as_str())
.filter(|name| name.starts_with("fixture-"))
.collect::<Vec<_>>();
if names == [expected] {
return Ok::<(), anyhow::Error>(());
}
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
}
})
.await??;
Ok(())
}
async fn refresh_and_expect_logo(app_server: &mut TestAppServer, logo: &str) -> Result<()> {
// plugin/installed starts the real background sync with the production callback.
// Reconcile acquires the same gate, so its completion fences the background pass.
+141 -47
View File
@@ -354,13 +354,32 @@ impl RemoteInstalledPluginsAuthIdentity {
struct RemoteInstalledPluginsCache {
generation: u64,
auth_identity: Option<RemoteInstalledPluginsAuthIdentity>,
reconciliation_generation: Option<u64>,
// A cancelled pass may mutate bundles before publication; retry must notify consumers.
needs_effective_plugins_refresh: bool,
reconciliation: ReconciliationState,
plugins: Option<Vec<RemoteInstalledPlugin>>,
pending_runtime_change: Option<uuid::Uuid>,
display_assets: InstalledPluginDisplayAssets,
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
enum ReconciliationState {
#[default]
Idle,
Running,
// A cancelled pass may mutate bundles before publication; retry must notify consumers.
RetryRequired,
Retrying,
}
impl ReconciliationState {
fn is_running(self) -> bool {
matches!(self, Self::Running | Self::Retrying)
}
fn requires_retry(self) -> bool {
matches!(self, Self::RetryRequired | Self::Retrying)
}
}
struct InstalledPluginCacheUpdate {
metadata_change_id: Option<uuid::Uuid>,
}
@@ -388,8 +407,10 @@ struct RemoteInstalledPluginsReconciliationGuard<'a> {
impl Drop for RemoteInstalledPluginsReconciliationGuard<'_> {
fn drop(&mut self) {
if !self.committed {
self.manager
.abandon_remote_installed_plugins_reconcile(self.generation);
self.manager.abandon_remote_installed_plugins_reconcile(
self.generation,
/*require_refresh*/ true,
);
}
}
}
@@ -1506,7 +1527,7 @@ impl PluginsManager {
&plugins,
visible_marketplaces,
);
let Some(update) = self.write_remote_installed_plugins_cache_snapshot(
let Some(_) = self.write_remote_installed_plugins_cache_snapshot(
generation,
plugins,
auth,
@@ -1524,11 +1545,11 @@ impl PluginsManager {
)
.unwrap_or(marketplaces));
};
if update.metadata_change_id.is_some()
&& let Some(on_effective_plugins_changed) = on_effective_plugins_changed
if let Some(on_effective_plugins_changed) = on_effective_plugins_changed
&& let Some(change_id) = self.take_pending_runtime_change()
{
on_effective_plugins_changed(EffectivePluginsChange {
metadata_change_id: update.metadata_change_id,
metadata_change_id: Some(change_id),
..Default::default()
});
}
@@ -1556,8 +1577,8 @@ impl PluginsManager {
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.reconciliation = ReconciliationState::Idle;
cache.pending_runtime_change = None;
cache.plugins.take().is_some()
} else {
false
@@ -1581,23 +1602,32 @@ impl PluginsManager {
return None;
}
cache.generation = cache.generation.wrapping_add(1);
cache.reconciliation_generation = Some(cache.generation);
cache.reconciliation = if cache.reconciliation.requires_retry() {
ReconciliationState::Retrying
} else {
ReconciliationState::Running
};
Some(cache.generation)
}
fn abandon_remote_installed_plugins_reconcile(&self, generation: u64) {
fn abandon_remote_installed_plugins_reconcile(&self, generation: u64, require_refresh: bool) {
let mut cache = match self.remote_installed_plugins_cache.write() {
Ok(cache) => cache,
Err(err) => err.into_inner(),
};
if cache.reconciliation_generation != Some(generation) {
if cache.generation != generation || !cache.reconciliation.is_running() {
return;
}
cache.reconciliation_generation = None;
cache.reconciliation = if require_refresh || cache.reconciliation.requires_retry() {
ReconciliationState::RetryRequired
} else {
ReconciliationState::Idle
};
cache.generation = cache.generation.wrapping_add(1);
cache.needs_effective_plugins_refresh = true;
drop(cache);
self.clear_loaded_plugins_cache();
if require_refresh {
self.clear_loaded_plugins_cache();
}
}
fn remote_installed_plugins_cache_generation_if_current(
@@ -1615,10 +1645,26 @@ impl PluginsManager {
(cache.auth_identity.as_ref() == Some(&auth_identity)).then_some(cache.generation)
}
fn active_remote_plugin_bundle(
&self,
id: &PluginId,
) -> Option<crate::remote::ActiveRemotePluginBundle> {
let installation = self.store.active_plugin_installation(id)?;
Some(crate::remote::ActiveRemotePluginBundle {
directory_version: installation
.root
.as_path()
.file_name()?
.to_str()?
.to_owned(),
remote_plugin_id: installation.persisted_remote_plugin_id().ok().flatten(),
})
}
fn write_remote_installed_plugins_cache_snapshot(
&self,
generation: u64,
plugins: Vec<RemoteInstalledPlugin>,
mut plugins: Vec<RemoteInstalledPlugin>,
auth: Option<&CodexAuth>,
publication: RemoteInstalledPluginsCachePublication,
) -> Option<InstalledPluginCacheUpdate> {
@@ -1642,24 +1688,29 @@ impl PluginsManager {
publication,
RemoteInstalledPluginsCachePublication::Reconcile
);
if !is_reconcile && cache.reconciliation_generation == Some(generation) {
if !is_reconcile && cache.reconciliation.is_running() {
return None;
}
if cache.auth_identity.is_none() {
cache.auth_identity = Some(auth_identity);
}
let needs_effective_plugins_refresh = is_reconcile && cache.reconciliation.requires_retry();
if is_reconcile {
cache.reconciliation_generation = None;
cache.reconciliation = ReconciliationState::Idle;
cache.generation = cache.generation.wrapping_add(1);
}
let needs_effective_plugins_refresh =
is_reconcile && std::mem::take(&mut cache.needs_effective_plugins_refresh);
cache.display_assets = match publication {
RemoteInstalledPluginsCachePublication::Refresh(display_assets) => display_assets,
RemoteInstalledPluginsCachePublication::Reconcile => {
InstalledPluginDisplayAssets::Include
}
};
for plugin in &mut plugins {
plugin.active_bundle =
PluginId::new(plugin.name.clone(), plugin.marketplace_name.clone())
.ok()
.and_then(|id| self.active_remote_plugin_bundle(&id));
}
let previous = cache.plugins.as_deref();
let payload_changed = previous != Some(plugins.as_slice());
let metadata_changed = payload_changed
@@ -1677,6 +1728,9 @@ impl PluginsManager {
} else {
Default::default()
};
if let Some(change_id) = metadata_change_id {
cache.pending_runtime_change = Some(change_id);
}
if payload_changed {
cache.plugins = Some(plugins);
}
@@ -1688,6 +1742,14 @@ impl PluginsManager {
Some(InstalledPluginCacheUpdate { metadata_change_id })
}
fn take_pending_runtime_change(&self) -> Option<uuid::Uuid> {
self.remote_installed_plugins_cache
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.pending_runtime_change
.take()
}
#[cfg(test)]
fn write_remote_installed_plugins_cache(&self, plugins: Vec<RemoteInstalledPlugin>) -> bool {
let auth = self.auth_manager.auth_cached();
@@ -1712,8 +1774,8 @@ impl PluginsManager {
};
cache.generation = cache.generation.wrapping_add(1);
cache.auth_identity = None;
cache.reconciliation_generation = None;
cache.needs_effective_plugins_refresh = false;
cache.reconciliation = ReconciliationState::Idle;
cache.pending_runtime_change = None;
if cache.plugins.take().is_none() {
return false;
}
@@ -1732,8 +1794,8 @@ impl PluginsManager {
}
cache.generation = cache.generation.wrapping_add(1);
cache.auth_identity = None;
cache.reconciliation_generation = None;
cache.needs_effective_plugins_refresh = false;
cache.reconciliation = ReconciliationState::Idle;
cache.pending_runtime_change = None;
if cache.plugins.take().is_none() {
return Some(false);
}
@@ -1850,13 +1912,14 @@ impl PluginsManager {
metadata_change_id = ?update.metadata_change_id,
"completed remote installed plugin bundle sync"
);
if (update.metadata_change_id.is_some() || !outcome.changed_plugins.is_empty())
&& let Some(on_effective_plugins_changed) = on_effective_plugins_changed
{
on_effective_plugins_changed(EffectivePluginsChange {
metadata_change_id: update.metadata_change_id,
materialized_remote_plugins: outcome.materialized_remote_plugins,
});
if let Some(on_effective_plugins_changed) = on_effective_plugins_changed {
let change_id = manager.take_pending_runtime_change();
if change_id.is_some() || !outcome.changed_plugins.is_empty() {
on_effective_plugins_changed(EffectivePluginsChange {
metadata_change_id: change_id,
materialized_remote_plugins: outcome.materialized_remote_plugins,
});
}
}
}
Err(err) => {
@@ -1900,11 +1963,30 @@ impl PluginsManager {
&self,
config: &PluginsConfigInput,
auth: Option<&CodexAuth>,
) -> Result<RemoteInstalledPluginBundleSyncOutcome, RemoteInstalledPluginBundleSyncError> {
self.reconcile_remote_installed_plugins_with_notify(config, auth, /*callback*/ None)
.await
}
/// Synchronize bundles and deliver any pending host runtime invalidation.
pub async fn reconcile_remote_installed_plugins_with_notify(
&self,
config: &PluginsConfigInput,
auth: Option<&CodexAuth>,
callback: Option<EffectivePluginsChangedCallback>,
) -> Result<RemoteInstalledPluginBundleSyncOutcome, RemoteInstalledPluginBundleSyncError> {
let _guard = self.acquire_remote_installed_plugin_sync_guard().await?;
let (outcome, _) = self
.reconcile_remote_installed_plugins_after_acquiring_gate(config, auth)
.await?;
if let Some(callback) = callback
&& let Some(change_id) = self.take_pending_runtime_change()
{
callback(EffectivePluginsChange {
metadata_change_id: Some(change_id),
..Default::default()
});
}
Ok(outcome)
}
@@ -1954,7 +2036,18 @@ impl PluginsManager {
auth,
&previous_plugin_ids,
)
.await?;
.await;
let result = match result {
Err(err @ RemoteInstalledPluginBundleSyncError::Catalog(_)) => {
// Catalog errors precede any bundle mutations, so no recovery refresh is needed.
self.abandon_remote_installed_plugins_reconcile(
generation, /*require_refresh*/ false,
);
reconciliation.committed = true;
return Err(err);
}
result => result?,
};
let mut outcome = result.outcome;
// The generation fence keeps this comparison on the snapshot replaced by this pass.
// In a known snapshot, absence means inactive: cached reinstalls need the same hints
@@ -3556,7 +3649,7 @@ impl PluginsManager {
.await;
match plugins {
Ok(plugins) => {
let Some(update) = self.write_remote_installed_plugins_cache_snapshot(
let Some(_) = self.write_remote_installed_plugins_cache_snapshot(
request.generation,
plugins,
request.auth.as_ref(),
@@ -3566,19 +3659,20 @@ impl PluginsManager {
) else {
continue;
};
let should_notify = update.metadata_change_id.is_some()
|| !request.change.materialized_remote_plugins.is_empty()
|| matches!(
request.notify,
RemoteInstalledPluginsCacheRefreshNotify::AfterSuccessfulRefresh
);
if should_notify
&& let Some(on_effective_plugins_changed) =
request.on_effective_plugins_changed
if let Some(on_effective_plugins_changed) = request.on_effective_plugins_changed
{
let mut change = request.change;
change.metadata_change_id = update.metadata_change_id;
on_effective_plugins_changed(change);
let change_id = self.take_pending_runtime_change();
if change_id.is_some()
|| !request.change.materialized_remote_plugins.is_empty()
|| matches!(
request.notify,
RemoteInstalledPluginsCacheRefreshNotify::AfterSuccessfulRefresh
)
{
let mut change = request.change;
change.metadata_change_id = change_id;
on_effective_plugins_changed(change);
}
}
}
Err(
+106 -1
View File
@@ -1049,6 +1049,7 @@ fn remote_installed_plugin_in_marketplace(
marketplace_name: marketplace_name.to_string(),
id: format!("plugins~Plugin_{name}"),
version: None,
active_bundle: None,
name: name.to_string(),
installed_at: None,
enabled: true,
@@ -2037,6 +2038,80 @@ async fn unresolved_display_assets_does_not_satisfy_display_cache_reads() {
);
}
#[tokio::test]
async fn publish_catalog_changes_without_invalidating_the_installed_runtime() {
let codex_home = TempDir::new().unwrap();
let manager = test_plugins_manager(codex_home.path().to_path_buf());
let auth = manager.auth_manager.auth_cached();
let generation = manager
.prepare_remote_installed_plugins_cache_generation(auth.as_ref())
.unwrap();
let mut plugin = remote_installed_linear_plugin();
let initial = manager
.write_remote_installed_plugins_cache_snapshot(
generation,
vec![plugin.clone()],
auth.as_ref(),
RemoteInstalledPluginsCachePublication::Refresh(InstalledPluginDisplayAssets::Include),
)
.unwrap();
assert!(initial.metadata_change_id.is_some());
plugin.version = Some("2.0.0".into());
plugin.installed_at = chrono::DateTime::from_timestamp(/*secs*/ 1, /*nsecs*/ 0);
let update = manager
.write_remote_installed_plugins_cache_snapshot(
generation,
vec![plugin.clone()],
auth.as_ref(),
RemoteInstalledPluginsCachePublication::Refresh(InstalledPluginDisplayAssets::Include),
)
.unwrap();
assert!(update.metadata_change_id.is_none());
assert_eq!(
manager.build_remote_installed_plugin_marketplaces_from_cache(&[
REMOTE_GLOBAL_MARKETPLACE_NAME
]),
Some(
crate::remote::group_remote_installed_plugins_by_marketplaces(
&[plugin],
&[REMOTE_GLOBAL_MARKETPLACE_NAME],
)
)
);
}
#[test]
fn active_directory_upgrade_is_retained_until_the_host_can_be_notified() {
let home = TempDir::new().unwrap();
let manager = test_plugins_manager(home.path().to_path_buf());
let base = home
.path()
.join("plugins/cache/openai-curated-remote/linear");
let id = PluginId::parse("linear@openai-curated-remote").unwrap();
write_plugin_with_version(&base, "0.6.0", "linear", Some("0.6.0"));
manager
.store
.write_remote_plugin_id(&id, "plugins~Plugin_old")
.unwrap();
let mut plugin = remote_installed_linear_plugin();
plugin.id = "plugins~Plugin_replacement".into();
plugin.version = Some("0.9.0".into());
assert!(manager.write_remote_installed_plugins_cache(vec![plugin.clone()]));
assert!(manager.take_pending_runtime_change().is_some());
assert_eq!(
manager.local_remote_plugin_version(&id.as_key(), &plugin.id),
None
);
std::fs::remove_dir_all(base.join("0.6.0")).unwrap();
write_plugin_with_version(&base, "0.7.0", "linear", Some("0.7.0"));
assert!(manager.write_remote_installed_plugins_cache(vec![plugin.clone()]));
assert!(!manager.write_remote_installed_plugins_cache(vec![plugin]));
assert!(manager.take_pending_runtime_change().is_some());
assert!(manager.take_pending_runtime_change().is_none());
}
#[tokio::test]
async fn build_remote_installed_plugin_marketplaces_from_cache_filters_by_marketplace_name() {
let codex_home = TempDir::new().unwrap();
@@ -7917,6 +7992,10 @@ remote_plugin = true
);
previous_malformed.id = malformed_remote_plugin_id.to_string();
previous_malformed.version = Some("local".to_string());
previous_malformed.active_bundle = Some(crate::remote::ActiveRemotePluginBundle {
directory_version: "local".into(),
remote_plugin_id: Some(malformed_remote_plugin_id.to_string()),
});
previous_malformed.enabled = false;
manager.write_remote_installed_plugins_cache(vec![previous_malformed.clone()]);
@@ -7988,7 +8067,12 @@ async fn failed_installed_plugin_pagination_preserves_inventory_and_releases_mut
Some(Product::Codex),
auth_manager,
));
let previous_inventory = vec![remote_installed_plugin("retained")];
let mut retained = remote_installed_plugin("retained");
retained.active_bundle = Some(crate::remote::ActiveRemotePluginBundle {
directory_version: "local".into(),
remote_plugin_id: None,
});
let previous_inventory = vec![retained];
manager.write_remote_installed_plugins_cache(previous_inventory.clone());
manager.maybe_start_remote_installed_plugin_bundle_sync(
@@ -8098,9 +8182,30 @@ fn reconciliation_fences_refresh_publication_and_recovers_after_cancellation() {
.map(|update| update.metadata_change_id.is_some()),
Some(true)
);
// Delivering an observed change must not consume the separate recovery obligation.
assert!(manager.take_pending_runtime_change().is_some());
let failed_retry_generation = manager
.begin_remote_installed_plugins_reconcile(/*auth*/ None)
.expect("begin retry before catalog failure");
manager.abandon_remote_installed_plugins_reconcile(
failed_retry_generation,
/*require_refresh*/ false,
);
assert_eq!(
manager
.remote_installed_plugins_cache
.read()
.unwrap()
.reconciliation,
ReconciliationState::RetryRequired
);
let retry_generation = manager
.begin_remote_installed_plugins_reconcile(/*auth*/ None)
.expect("begin retry after cancellation");
manager.abandon_remote_installed_plugins_reconcile(
failed_retry_generation,
/*require_refresh*/ true,
);
assert_eq!(
manager
.write_remote_installed_plugins_cache_snapshot(
+8
View File
@@ -353,11 +353,18 @@ pub struct RemoteMarketplaceFetchOutcome {
pub catalog_cache_used: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ActiveRemotePluginBundle {
pub(crate) directory_version: String,
pub(crate) remote_plugin_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct RemoteInstalledPlugin {
pub marketplace_name: String,
pub id: String,
pub version: Option<String>,
pub(crate) active_bundle: Option<ActiveRemotePluginBundle>,
pub name: String,
pub canonical_app_id: Option<String>,
pub installed_at: Option<DateTime<Utc>>,
@@ -2049,6 +2056,7 @@ fn remote_installed_plugin_to_cache_entry(
marketplace_name,
id: plugin.id.clone(),
version: plugin.release.version.clone(),
active_bundle: None,
name: plugin.name.clone(),
canonical_app_id: plugin.canonical_app_id.clone(),
installed_at: installed_plugin.installed_at,
+78 -36
View File
@@ -1,52 +1,92 @@
//! Compares the metadata that determines installed-plugin behavior.
//! Compares installed runtime inputs separately from remote catalog metadata.
//!
//! Display metadata (including image URLs and store capability badges) is excluded. Callers must
//! still publish the unmodified payload so display consumers receive fresh metadata.
//! Runtime invalidation tracks plugin identity, enablement, canonical connector ownership, and the active bundle identity.
//! Catalog release, policy, and display changes still need to be published to catalog consumers.
use crate::remote::ActiveRemotePluginBundle;
use crate::remote::RemoteInstalledPlugin;
use crate::remote::RemoteMarketplace;
use std::collections::BTreeMap;
use std::collections::HashMap;
/// Use the same comparisons for invalidation and its diagnostics. Expose field names only.
fn changed_fields<'a>(
previous: &'a RemoteInstalledPlugin,
current: &'a RemoteInstalledPlugin,
) -> impl Iterator<Item = &'static str> + 'a {
macro_rules! compare {
($($field:ident),+ $(,)?) => {
[$( (stringify!($field), previous.$field != current.$field) ),+]
};
/// The account metadata consumed when building installed plugin runtimes.
#[derive(PartialEq, Eq)]
struct InstalledPluginRuntimeState<'a> {
marketplace_name: &'a str,
id: &'a str,
name: &'a str,
canonical_app_id: Option<&'a str>,
enabled: bool,
active_bundle: Option<&'a ActiveRemotePluginBundle>,
}
impl<'a> From<&'a RemoteInstalledPlugin> for InstalledPluginRuntimeState<'a> {
fn from(plugin: &'a RemoteInstalledPlugin) -> Self {
Self {
marketplace_name: &plugin.marketplace_name,
id: &plugin.id,
name: &plugin.name,
canonical_app_id: plugin.canonical_app_id.as_deref(),
enabled: plugin.enabled,
active_bundle: plugin
.enabled
.then_some(plugin.active_bundle.as_ref())
.flatten(),
}
}
}
impl InstalledPluginRuntimeState<'_> {
/// Report only changed field names, never their values.
fn changed_fields(self, current: Self) -> impl Iterator<Item = &'static str> {
let Self {
marketplace_name,
id,
name,
canonical_app_id,
enabled,
active_bundle,
} = self;
[
(
"marketplace_name",
marketplace_name != current.marketplace_name,
),
("id", id != current.id),
("name", name != current.name),
(
"canonical_app_id",
canonical_app_id != current.canonical_app_id,
),
("enabled", enabled != current.enabled),
(
"active_directory_version",
active_bundle.map(|bundle| &bundle.directory_version)
!= current
.active_bundle
.map(|bundle| &bundle.directory_version),
),
(
"active_remote_plugin_id",
active_bundle.and_then(|bundle| bundle.remote_plugin_id.as_deref())
!= current
.active_bundle
.and_then(|bundle| bundle.remote_plugin_id.as_deref()),
),
]
.into_iter()
.filter_map(|(field, changed)| changed.then_some(field))
}
compare!(
marketplace_name,
id,
name,
canonical_app_id,
version,
installed_at,
enabled,
install_policy,
install_policy_source,
must_show_installation_interstitial,
auth_policy,
availability,
disabled_reason,
eligible_plan_types,
)
.into_iter()
.filter_map(|(field, changed)| changed.then_some(field))
}
pub(crate) fn installed_plugin_metadata_eq(
previous: &[RemoteInstalledPlugin],
current: &[RemoteInstalledPlugin],
) -> bool {
previous.len() == current.len()
&& previous
.iter()
.zip(current)
.all(|(previous, current)| changed_fields(previous, current).next().is_none())
previous
.iter()
.map(InstalledPluginRuntimeState::from)
.eq(current.iter().map(InstalledPluginRuntimeState::from))
}
/// Called only for a changed snapshot. Match by remote ID so an insertion does
@@ -66,7 +106,9 @@ pub(crate) fn installed_plugin_metadata_changes(
let mut changes = BTreeMap::new();
for (index, plugin) in current.iter().enumerate() {
let fields = if let Some((old_index, prior)) = old.remove(plugin.id.as_str()) {
let mut fields: Vec<_> = changed_fields(prior, plugin).collect();
let mut fields: Vec<_> = InstalledPluginRuntimeState::from(prior)
.changed_fields(InstalledPluginRuntimeState::from(plugin))
.collect();
if old_index != index && same_members {
fields.push("position");
}
@@ -28,6 +28,10 @@ enabled = true
Some(AuthMode::Chatgpt),
);
let mut remote = remote_installed_plugin("sample");
remote.active_bundle = Some(crate::remote::ActiveRemotePluginBundle {
directory_version: "local".into(),
remote_plugin_id: None,
});
remote.interface = Some(
serde_json::from_value(serde_json::json!({
"capabilities": [], "screenshots": [], "screenshotUrls": [],
@@ -110,6 +114,10 @@ enabled = true
assert!(Arc::ptr_eq(&suggestions, &refreshed_suggestions));
remote.version = Some("2.0.0".to_string());
assert!(!manager.write_remote_installed_plugins_cache(vec![remote.clone()]));
assert_eq!(manager.loaded_plugins_cache_generation(), loaded_generation);
remote.enabled = false;
assert!(manager.write_remote_installed_plugins_cache(vec![remote]));
assert_eq!(
manager.loaded_plugins_cache_generation(),
@@ -17,6 +17,7 @@ fn plugin(renewal: &str) -> RemoteInstalledPlugin {
marketplace_name: REMOTE_GLOBAL_MARKETPLACE_NAME.to_string(),
id: "plugin-test".to_string(),
version: Some("1.0.0".to_string()),
active_bundle: None,
name: "test".to_string(),
canonical_app_id: None,
installed_at: None,
@@ -45,16 +46,38 @@ fn catalog(plugins: &[RemoteInstalledPlugin]) -> Vec<RemoteMarketplace> {
}
#[test]
fn behavioral_metadata_changes_still_invalidate() {
fn runtime_metadata_changes_invalidate() {
let changes: &[fn(&mut RemoteInstalledPlugin)] = &[
|plugin| plugin.marketplace_name.push_str("-other"),
|plugin| plugin.id.push_str("-other"),
|plugin| plugin.name.push_str("-other"),
|plugin| plugin.canonical_app_id = Some("new-app".to_string()),
|plugin| plugin.enabled = false,
|plugin| {
plugin.active_bundle = Some(crate::remote::ActiveRemotePluginBundle {
directory_version: "2.0.0".into(),
remote_plugin_id: None,
})
},
];
for change in changes {
let previous = [plugin("old")];
let mut current = previous.clone();
change(&mut current[0]);
assert!(!installed_plugin_metadata_eq(&previous, &current));
}
assert!(!installed_plugin_metadata_eq(&[plugin("old")], &[]));
assert!(!remote_catalog_metadata_eq(&catalog(&[plugin("old")]), &[]));
}
#[test]
fn catalog_metadata_changes_do_not_invalidate_the_installed_runtime() {
let changes: &[fn(&mut RemoteInstalledPlugin)] = &[
|plugin| plugin.version = Some("2.0.0".to_string()),
|plugin| {
plugin.installed_at =
chrono::DateTime::from_timestamp(/*secs*/ 1, /*nsecs*/ 0)
},
|plugin| plugin.enabled = false,
|plugin| plugin.install_policy = PluginInstallPolicy::NotAvailable,
|plugin| {
plugin.install_policy_source =
@@ -67,20 +90,15 @@ fn behavioral_metadata_changes_still_invalidate() {
];
for change in changes {
let previous = [plugin("old")];
let mut current = [plugin("new")];
let mut current = previous.clone();
change(&mut current[0]);
assert!(!installed_plugin_metadata_eq(&previous, &current));
assert!(installed_plugin_metadata_eq(&previous, &current));
assert!(installed_plugin_metadata_changes(&previous, &current).is_empty());
assert!(!remote_catalog_metadata_eq(
&catalog(&previous),
&catalog(&current)
));
}
let previous = [plugin("old")];
let mut current = [plugin("new")];
current[0].canonical_app_id = Some("new-app".to_string());
assert!(!installed_plugin_metadata_eq(&previous, &current));
assert!(!installed_plugin_metadata_eq(&previous, &[]));
assert!(!remote_catalog_metadata_eq(&catalog(&previous), &[]));
}
#[test]
@@ -212,7 +230,7 @@ fn diagnostics_attribute_fields_by_plugin_id_across_membership_changes() {
std::collections::BTreeMap::from([
("added".into(), vec!["added"]),
("removed".into(), vec!["removed"]),
(id, vec!["version", "enabled"]),
(id, vec!["enabled"]),
])
);
}