Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Support remote marketplaces in the plugin CLI (#42150)

willwang-openai6b59cefcbb35
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index 30063d3c3d..e217b70249 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -2469,6 +2469,7 @@ dependencies = [
"codex-utils-path",
"codex-windows-sandbox",
"crossterm",
+ "flate2",
"futures",
"http 1.4.0",
"insta",
@@ -2483,6 +2484,7 @@ dependencies = [
"sqlx",
"supports-color 3.0.2",
"sys-locale",
+ "tar",
"tempfile",
"tokio",
"tokio-tungstenite",
diff --git a/codex-rs/app-server/src/request_processors/plugins.rs b/codex-rs/app-server/src/request_processors/plugins.rs
index 13a9dfecca..bf3afd7bb9 100644
--- a/codex-rs/app-server/src/request_processors/plugins.rs
+++ b/codex-rs/app-server/src/request_processors/plugins.rs
@@ -680,8 +680,11 @@ impl PluginRequestProcessor {
match codex_core_plugins::remote::fetch_openai_curated_remote_collection_marketplace(
&remote_plugin_service_config,
auth.as_ref(),
+ /*catalog_cache_root*/ None,
+ RemotePluginCatalogCacheMode::ForceRefetch,
)
.await
+ .map(|outcome| outcome.marketplace)
{
Ok(Some(remote_marketplace)) => {
data.push(remote_marketplace_to_info(remote_marketplace));
diff --git a/codex-rs/cli/Cargo.toml b/codex-rs/cli/Cargo.toml
index 2640c964e0..c94dd50662 100644
--- a/codex-rs/cli/Cargo.toml
+++ b/codex-rs/cli/Cargo.toml
@@ -114,11 +114,13 @@ app_test_support = { workspace = true }
assert_cmd = { workspace = true }
assert_matches = { workspace = true }
codex-utils-cargo-bin = { workspace = true }
+flate2 = { workspace = true }
futures = { workspace = true }
insta = { workspace = true }
predicates = { workspace = true }
pretty_assertions = { workspace = true }
sqlx = { workspace = true }
+tar = { workspace = true }
tokio-tungstenite = { workspace = true }
wiremock = { workspace = true }
zstd = { workspace = true }
diff --git a/codex-rs/cli/src/plugin_cmd.rs b/codex-rs/cli/src/plugin_cmd.rs
index 44b3a11f01..e82200b26f 100644
--- a/codex-rs/cli/src/plugin_cmd.rs
+++ b/codex-rs/cli/src/plugin_cmd.rs
@@ -1,7 +1,10 @@
use anyhow::Context;
use anyhow::Result;
use anyhow::bail;
+use anyhow::ensure;
use clap::Parser;
+use codex_app_server_protocol::PluginAuthPolicy;
+use codex_app_server_protocol::PluginInstallPolicy;
use codex_core::config::Config;
use codex_core::config::find_codex_home;
use codex_core::plugins_manager_for_config;
@@ -11,6 +14,7 @@ use codex_core_plugins::PluginInstallOutcome;
use codex_core_plugins::PluginInstallRequest;
use codex_core_plugins::PluginsConfigInput;
use codex_core_plugins::PluginsManager;
+use codex_core_plugins::RemotePluginInstallRequest;
use codex_core_plugins::allowed_configured_marketplace_names;
use codex_core_plugins::installed_marketplaces::marketplace_install_root;
use codex_core_plugins::installed_marketplaces::resolve_configured_marketplace_root;
@@ -19,9 +23,17 @@ use codex_core_plugins::marketplace::MarketplacePluginAuthPolicy;
use codex_core_plugins::marketplace::MarketplacePluginInstallPolicy;
use codex_core_plugins::marketplace::MarketplacePluginSource;
use codex_core_plugins::marketplace::find_marketplace_manifest_path;
+use codex_core_plugins::remote;
+use codex_core_plugins::remote::REMOTE_GLOBAL_MARKETPLACE_NAME;
+use codex_core_plugins::remote::RemoteMarketplace;
+use codex_core_plugins::remote::RemoteMarketplaceSource;
+use codex_core_plugins::remote::RemotePluginCatalogCacheMode;
+use codex_core_plugins::remote::RemotePluginSummary;
use codex_login::AuthManager;
+use codex_login::CodexAuth;
use codex_plugin::PluginId;
use codex_plugin::validate_plugin_segment;
+use codex_utils_absolute_path::AbsolutePathBuf;
use codex_utils_cli::CliConfigOverrides;
use serde::Serialize;
use std::collections::HashMap;
@@ -46,19 +58,19 @@ pub struct PluginCli {
#[derive(Debug, clap::Subcommand)]
pub enum PluginSubcommand {
- /// Install a plugin from a configured marketplace snapshot.
+ /// Install a plugin from a configured or remote marketplace.
///
/// Pass either `PLUGIN@MARKETPLACE` or pass `PLUGIN` with
/// `--marketplace MARKETPLACE`.
Add(AddPluginArgs),
- /// List plugins available from configured marketplace snapshots.
+ /// List plugins available from configured and remote marketplaces.
List(ListPluginsArgs),
/// Add, list, upgrade, or remove configured plugin marketplaces.
Marketplace(MarketplaceCli),
- /// Remove an installed plugin from local config and cache.
+ /// Uninstall a plugin and remove its local cache.
///
/// Pass either `PLUGIN@MARKETPLACE` or pass `PLUGIN` with
/// `--marketplace MARKETPLACE`.
@@ -75,7 +87,7 @@ pub struct AddPluginArgs {
#[arg(value_name = "PLUGIN[@MARKETPLACE]")]
plugin: String,
- /// Configured marketplace name to use when PLUGIN does not include @MARKETPLACE.
+ /// Marketplace name to use when PLUGIN does not include @MARKETPLACE.
#[arg(long = "marketplace", short = 'm', value_name = "MARKETPLACE")]
marketplace_name: Option<String>,
@@ -90,7 +102,7 @@ pub struct AddPluginArgs {
after_help = "Examples:\n codex plugin list\n codex plugin list --marketplace debug\n codex plugin list --json\n codex plugin list --available --json"
)]
pub struct ListPluginsArgs {
- /// Only list plugins from this configured marketplace name.
+ /// Only list plugins from this marketplace name.
#[arg(long = "marketplace", short = 'm', value_name = "MARKETPLACE")]
marketplace_name: Option<String>,
@@ -126,52 +138,81 @@ pub async fn run_plugin_add(
overrides: Vec<(String, toml::Value)>,
args: AddPluginArgs,
) -> Result<()> {
- let PluginCommandContext {
- codex_home,
- plugins_input,
- manager,
- } = load_plugin_command_context(overrides).await?;
+ let context = load_plugin_command_context(overrides).await?;
let AddPluginArgs {
plugin,
marketplace_name,
json,
} = args;
- let PluginSelection {
- plugin_name,
- marketplace_name,
- ..
- } = parse_plugin_selection(plugin, marketplace_name)?;
- let marketplace = find_marketplace_for_plugin(
- &manager,
- codex_home.as_path(),
- &plugins_input,
- &marketplace_name,
- &plugin_name,
- )?;
- let outcome = manager
- .install_plugin(
- &plugins_input,
- PluginInstallRequest {
- plugin_name,
- marketplace_path: marketplace.path,
- },
+ let selection = parse_plugin_selection(plugin, marketplace_name)?;
+ let outcome = if selection.marketplace_name == REMOTE_GLOBAL_MARKETPLACE_NAME {
+ let mut listing = fetch_remote_marketplaces(
+ &context,
+ Some(&selection.marketplace_name),
+ RemotePluginCatalogCacheMode::PreferFreshCache,
)
.await?;
+ // A newly published plugin may be missing from an otherwise fresh catalog cache.
+ if listing.catalog_cache_used
+ && !listing
+ .marketplaces
+ .iter()
+ .flat_map(|marketplace| &marketplace.plugins)
+ .any(|plugin| plugin.name == selection.plugin_name)
+ {
+ listing = fetch_remote_marketplaces(
+ &context,
+ Some(&selection.marketplace_name),
+ RemotePluginCatalogCacheMode::ForceRefetch,
+ )
+ .await?;
+ }
+ let plugin = resolve_remote_plugin(listing.marketplaces, &selection)?;
+ context
+ .manager
+ .install_remote_plugin(
+ &context.plugins_input,
+ context.auth.as_ref(),
+ RemotePluginInstallRequest {
+ marketplace_name: selection.marketplace_name,
+ remote_plugin_id: plugin.remote_plugin_id,
+ install_attempt_id: None,
+ },
+ /*on_effective_plugins_changed*/ None,
+ )
+ .await?
+ .installed
+ } else {
+ let marketplace = find_marketplace_for_plugin(
+ &context.manager,
+ context.codex_home.as_path(),
+ &context.plugins_input,
+ &selection.marketplace_name,
+ &selection.plugin_name,
+ )?;
+ context
+ .manager
+ .install_plugin(
+ &context.plugins_input,
+ PluginInstallRequest {
+ plugin_name: selection.plugin_name,
+ marketplace_path: marketplace.path,
+ },
+ )
+ .await?
+ };
+ let output = JsonPluginAddOutput::from_outcome(outcome);
if json {
- let output = JsonPluginAddOutput::from_outcome(outcome);
println!("{}", serde_json::to_string_pretty(&output)?);
return Ok(());
}
println!(
"Added plugin `{}` from marketplace `{}`.",
- outcome.plugin_id.plugin_name, outcome.plugin_id.marketplace_name
- );
- println!(
- "Installed plugin root: {}",
- outcome.installed_path.as_path().display()
+ output.name, output.marketplace_name
);
+ println!("Installed plugin root: {}", output.installed_path);
Ok(())
}
@@ -204,39 +245,70 @@ pub async fn run_plugin_list(
overrides: Vec<(String, toml::Value)>,
args: ListPluginsArgs,
) -> Result<()> {
+ let context = load_plugin_command_context(overrides).await?;
+ let remote_listing = fetch_remote_marketplaces(
+ &context,
+ args.marketplace_name.as_deref(),
+ RemotePluginCatalogCacheMode::PreferFreshCache,
+ )
+ .await?;
let PluginCommandContext {
codex_home,
plugins_input,
manager,
..
- } = load_plugin_command_context(overrides).await?;
+ } = context;
let outcome = manager
- .list_marketplaces_for_config(&plugins_input, &[], /*include_openai_curated*/ true)
+ .list_marketplaces_for_config(
+ &plugins_input,
+ &[],
+ /*include_openai_curated*/ !remote_listing.uses_global_catalog,
+ )
.context("failed to list marketplace plugins")?;
ensure_configured_marketplace_snapshots_loaded(
codex_home.as_path(),
&plugins_input,
&outcome.errors,
- /*marketplace_name*/ None,
+ args.marketplace_name.as_deref(),
)?;
+ let marketplace_sources = configured_marketplace_sources(&plugins_input, codex_home.as_path());
let marketplaces = outcome
.marketplaces
.into_iter()
+ .map(|marketplace| {
+ let source = marketplace_sources.get(&marketplace.name).cloned();
+ PluginListMarketplace {
+ plugins: marketplace
+ .plugins
+ .into_iter()
+ .map(|plugin| {
+ PluginListEntry::from_configured_plugin(
+ &marketplace.name,
+ source.clone(),
+ plugin,
+ )
+ })
+ .collect(),
+ name: marketplace.name,
+ path: Some(marketplace.path),
+ }
+ })
+ .chain(
+ remote_listing
+ .marketplaces
+ .into_iter()
+ .map(PluginListMarketplace::from),
+ )
.filter(|marketplace| {
args.marketplace_name
.as_ref()
.is_none_or(|name| marketplace.name == *name)
})
.collect::<Vec<_>>();
- let marketplace_sources = configured_marketplace_sources(&plugins_input, codex_home.as_path());
if args.json {
- let output = JsonPluginListOutput::from_marketplaces(
- marketplaces,
- args.available,
- &marketplace_sources,
- );
+ let output = JsonPluginListOutput::from_marketplaces(marketplaces, args.available);
println!("{}", serde_json::to_string_pretty(&output)?);
return Ok(());
}
@@ -253,7 +325,6 @@ pub async fn run_plugin_list(
let mut plugin_width = "PLUGIN".len();
let mut status_width = "STATUS".len();
let mut installed_version_width = "VERSION".len();
- let mut path_width = "PATH".len();
for plugin in &marketplace.plugins {
let state = if plugin.installed && plugin.enabled {
@@ -263,19 +334,16 @@ pub async fn run_plugin_list(
} else {
"not installed"
};
- let installed_version = plugin.installed_version.clone().unwrap_or_default();
+ let installed_version = plugin.display_version.clone().unwrap_or_default();
let path = match &plugin.source {
- codex_core_plugins::marketplace::MarketplacePluginSource::Local { path } => {
- path.as_path().display().to_string()
- }
- codex_core_plugins::marketplace::MarketplacePluginSource::Git {
- url,
- path,
- ref_name,
- sha,
+ JsonPluginSource::Remote { id } => id.clone(),
+ JsonPluginSource::Local { path } => path.clone(),
+ JsonPluginSource::Git { url, ref_name, sha }
+ | JsonPluginSource::GitSubdir {
+ url, ref_name, sha, ..
} => {
let mut parts = vec![url.clone()];
- if let Some(path) = path {
+ if let JsonPluginSource::GitSubdir { path, .. } = &plugin.source {
parts.push(format!("path `{path}`"));
}
if let Some(ref_name) = ref_name {
@@ -286,7 +354,7 @@ pub async fn run_plugin_list(
}
parts.join(", ")
}
- codex_core_plugins::marketplace::MarketplacePluginSource::Npm {
+ JsonPluginSource::Npm {
package,
version,
registry,
@@ -301,26 +369,29 @@ pub async fn run_plugin_list(
parts.join(", ")
}
};
- plugin_width = plugin_width.max(plugin.id.len());
+ plugin_width = plugin_width.max(plugin.plugin_id.len());
status_width = status_width.max(state.len());
installed_version_width = installed_version_width.max(installed_version.len());
- path_width = path_width.max(path.len());
- rows.push((plugin.id.clone(), state, installed_version, path));
+ rows.push((plugin.plugin_id.clone(), state, installed_version, path));
}
if index > 0 {
println!();
}
println!("Marketplace `{}`", marketplace.name);
- println!("{}", marketplace.path.as_path().display());
+ if let Some(path) = &marketplace.path {
+ println!("{}", path.display());
+ } else {
+ println!("Remote catalog");
+ }
println!();
println!(
- "{:<plugin_width$} {:<status_width$} {:<installed_version_width$} {:<path_width$}",
- "PLUGIN", "STATUS", "VERSION", "PATH"
+ "{:<plugin_width$} {:<status_width$} {:<installed_version_width$} SOURCE",
+ "PLUGIN", "STATUS", "VERSION"
);
for (plugin, status, installed_version, path) in rows {
println!(
- "{plugin:<plugin_width$} {status:<status_width$} {installed_version:<installed_version_width$} {path:<path_width$}"
+ "{plugin:<plugin_width$} {status:<status_width$} {installed_version:<installed_version_width$} {path}"
);
}
}
@@ -329,30 +400,67 @@ pub async fn run_plugin_list(
Ok(())
}
+struct PluginListMarketplace {
+ name: String,
+ path: Option<AbsolutePathBuf>,
+ plugins: Vec<PluginListEntry>,
+}
+
+impl From<RemoteMarketplace> for PluginListMarketplace {
+ fn from(marketplace: RemoteMarketplace) -> Self {
+ Self {
+ plugins: marketplace
+ .plugins
+ .into_iter()
+ .map(|plugin| {
+ let version = plugin.local_version.or(plugin.version);
+ PluginListEntry {
+ plugin_id: plugin.id,
+ name: plugin.name,
+ marketplace_name: marketplace.name.clone(),
+ display_version: version.clone(),
+ version,
+ installed: plugin.installed,
+ enabled: plugin.enabled,
+ source: JsonPluginSource::Remote {
+ id: plugin.remote_plugin_id,
+ },
+ marketplace_source: None,
+ install_policy: match plugin.install_policy {
+ PluginInstallPolicy::NotAvailable => "NOT_AVAILABLE",
+ PluginInstallPolicy::Available => "AVAILABLE",
+ PluginInstallPolicy::InstalledByDefault => "INSTALLED_BY_DEFAULT",
+ },
+ auth_policy: match plugin.auth_policy {
+ PluginAuthPolicy::OnInstall => "ON_INSTALL",
+ PluginAuthPolicy::OnUse => "ON_USE",
+ },
+ }
+ })
+ .collect(),
+ name: marketplace.name,
+ path: None,
+ }
+ }
+}
+
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct JsonPluginListOutput {
- installed: Vec<JsonPluginListEntry>,
- available: Vec<JsonPluginListEntry>,
+ installed: Vec<PluginListEntry>,
+ available: Vec<PluginListEntry>,
}
impl JsonPluginListOutput {
fn from_marketplaces(
- marketplaces: Vec<codex_core_plugins::ConfiguredMarketplace>,
+ marketplaces: Vec<PluginListMarketplace>,
include_available: bool,
- marketplace_sources: &HashMap<String, JsonMarketplaceSource>,
) -> Self {
let mut installed = Vec::new();
let mut available = Vec::new();
for marketplace in marketplaces {
- let marketplace_source = marketplace_sources.get(&marketplace.name).cloned();
- for plugin in marketplace.plugins {
- let entry = JsonPluginListEntry::from_configured_plugin(
- &marketplace.name,
- marketplace_source.clone(),
- plugin,
- );
+ for entry in marketplace.plugins {
if entry.installed {
installed.push(entry);
} else if include_available {
@@ -370,11 +478,13 @@ impl JsonPluginListOutput {
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
-struct JsonPluginListEntry {
+struct PluginListEntry {
plugin_id: String,
name: String,
marketplace_name: String,
version: Option<String>,
+ #[serde(skip)]
+ display_version: Option<String>,
installed: bool,
enabled: bool,
source: JsonPluginSource,
@@ -384,18 +494,20 @@ struct JsonPluginListEntry {
auth_policy: &'static str,
}
-impl JsonPluginListEntry {
+impl PluginListEntry {
fn from_configured_plugin(
marketplace_name: &str,
marketplace_source: Option<JsonMarketplaceSource>,
plugin: codex_core_plugins::ConfiguredMarketplacePlugin,
) -> Self {
- let version = plugin.installed_version.or(plugin.local_version);
+ let display_version = plugin.installed_version;
+ let version = display_version.clone().or(plugin.local_version);
Self {
plugin_id: plugin.id,
name: plugin.name,
marketplace_name: marketplace_name.to_string(),
version,
+ display_version,
installed: plugin.installed,
enabled: plugin.enabled,
source: JsonPluginSource::from_marketplace_source(plugin.source),
@@ -409,6 +521,9 @@ impl JsonPluginListEntry {
#[derive(Debug, Serialize)]
#[serde(tag = "source", rename_all = "kebab-case")]
enum JsonPluginSource {
+ Remote {
+ id: String,
+ },
Local {
path: String,
},
@@ -531,7 +646,7 @@ pub async fn run_plugin_remove(
overrides: Vec<(String, toml::Value)>,
args: RemovePluginArgs,
) -> Result<()> {
- let PluginCommandContext { manager, .. } = load_plugin_command_context(overrides).await?;
+ let context = load_plugin_command_context(overrides).await?;
let RemovePluginArgs {
plugin,
marketplace_name,
@@ -539,9 +654,41 @@ pub async fn run_plugin_remove(
} = args;
let selection = parse_plugin_selection(plugin, marketplace_name)?;
- manager
- .uninstall_plugin(selection.plugin_key.clone())
- .await?;
+ if selection.marketplace_name == REMOTE_GLOBAL_MARKETPLACE_NAME {
+ ensure!(
+ context.plugins_input.plugins_enabled,
+ "remote plugins are not enabled"
+ );
+ let auth = context.auth.as_ref();
+ // Installed plugins may no longer appear in the directory or curated collection.
+ let marketplaces = context
+ .manager
+ .build_and_cache_remote_installed_plugin_marketplaces(
+ &context.plugins_input,
+ auth,
+ &[REMOTE_GLOBAL_MARKETPLACE_NAME],
+ /*on_effective_plugins_changed*/ None,
+ )
+ .await?;
+ let plugin = resolve_remote_plugin(marketplaces, &selection)?;
+ let outcome = context
+ .manager
+ .uninstall_remote_plugin(
+ &context.plugins_input,
+ auth,
+ &plugin.remote_plugin_id,
+ /*on_effective_plugins_changed*/ None,
+ )
+ .await?;
+ if let Some(err) = outcome.cache_removal_error {
+ return Err(err.into());
+ }
+ } else {
+ context
+ .manager
+ .uninstall_plugin(selection.plugin_key.clone())
+ .await?;
+ }
if json {
let output = JsonPluginRemoveOutput::from_selection(selection);
println!("{}", serde_json::to_string_pretty(&output)?);
@@ -577,7 +724,8 @@ impl JsonPluginRemoveOutput {
struct PluginCommandContext {
codex_home: PathBuf,
plugins_input: PluginsConfigInput,
- manager: PluginsManager,
+ manager: Arc<PluginsManager>,
+ auth: Option<CodexAuth>,
}
async fn load_plugin_command_context(
@@ -588,11 +736,16 @@ async fn load_plugin_command_context(
.await
.context("failed to load configuration")?;
let plugins_input = config.plugins_config_input();
- let manager = plugins_manager_for_config(&config, load_cli_auth_manager(&config).await?);
+ let auth_manager = load_cli_auth_manager(&config).await?;
+ let manager = Arc::new(plugins_manager_for_config(
+ &config,
+ Arc::clone(&auth_manager),
+ ));
Ok(PluginCommandContext {
codex_home: codex_home.to_path_buf(),
plugins_input,
manager,
+ auth: auth_manager.auth().await,
})
}
@@ -644,6 +797,96 @@ fn parse_plugin_selection(
}
}
+#[derive(Default)]
+struct RemoteMarketplaceListing {
+ marketplaces: Vec<RemoteMarketplace>,
+ // A successful global catalog replaces the local curated catalog even when it is empty.
+ uses_global_catalog: bool,
+ catalog_cache_used: bool,
+}
+
+async fn fetch_remote_marketplaces(
+ context: &PluginCommandContext,
+ marketplace_name: Option<&str>,
+ cache_mode: RemotePluginCatalogCacheMode,
+) -> Result<RemoteMarketplaceListing> {
+ if marketplace_name.is_some_and(|name| name != REMOTE_GLOBAL_MARKETPLACE_NAME) {
+ return Ok(RemoteMarketplaceListing::default());
+ }
+ if !context.plugins_input.plugins_enabled {
+ ensure!(marketplace_name.is_none(), "remote plugins are not enabled");
+ return Ok(RemoteMarketplaceListing::default());
+ }
+ let auth = context.auth.as_ref();
+ if !auth.is_some_and(CodexAuth::uses_codex_backend) {
+ ensure!(
+ marketplace_name.is_none(),
+ "chatgpt authentication required for remote plugin catalog"
+ );
+ return Ok(RemoteMarketplaceListing::default());
+ }
+ let service = context.plugins_input.remote_plugin_service_config();
+ let result = if context.plugins_input.remote_plugin_enabled {
+ remote::fetch_remote_marketplaces(
+ &service,
+ auth,
+ &[RemoteMarketplaceSource::Global],
+ /*catalog_cache_root*/ Some(context.codex_home.as_path()),
+ cache_mode,
+ )
+ .await
+ .map(|outcome| RemoteMarketplaceListing {
+ marketplaces: outcome.marketplaces,
+ uses_global_catalog: true,
+ catalog_cache_used: outcome.catalog_cache_used,
+ })
+ } else {
+ remote::fetch_openai_curated_remote_collection_marketplace(
+ &service,
+ auth,
+ /*catalog_cache_root*/ Some(context.codex_home.as_path()),
+ cache_mode,
+ )
+ .await
+ .map(|outcome| RemoteMarketplaceListing {
+ marketplaces: outcome.marketplace.into_iter().collect(),
+ uses_global_catalog: false,
+ catalog_cache_used: outcome.catalog_cache_used,
+ })
+ };
+ match result {
+ Ok(listing) => Ok(listing),
+ Err(err) if marketplace_name.is_none() => {
+ eprintln!("Warning: failed to list remote marketplace plugins: {err}");
+ Ok(RemoteMarketplaceListing::default())
+ }
+ Err(err) => Err(err).context("failed to list remote marketplace plugins"),
+ }
+}
+
+fn resolve_remote_plugin(
+ marketplaces: Vec<RemoteMarketplace>,
+ selection: &PluginSelection,
+) -> Result<RemotePluginSummary> {
+ let matches = marketplaces
+ .into_iter()
+ .flat_map(|marketplace| marketplace.plugins)
+ .filter(|plugin| plugin.name == selection.plugin_name)
+ .collect::<Vec<_>>();
+ match matches.as_slice() {
+ [plugin] => Ok(plugin.clone()),
+ [] => bail!(
+ "plugin `{}` was not found in remote marketplace `{}`",
+ selection.plugin_name,
+ selection.marketplace_name
+ ),
+ _ => bail!(
+ "plugin `{}` matched multiple remote plugins",
+ selection.plugin_key
+ ),
+ }
+}
+
fn find_marketplace_for_plugin(
manager: &PluginsManager,
codex_home: &std::path::Path,
diff --git a/codex-rs/cli/tests/plugin_cli.rs b/codex-rs/cli/tests/plugin_cli.rs
index c504ff94b3..b1c316860c 100644
--- a/codex-rs/cli/tests/plugin_cli.rs
+++ b/codex-rs/cli/tests/plugin_cli.rs
@@ -1,14 +1,33 @@
use anyhow::Result;
+use anyhow::ensure;
+use app_test_support::ChatGptAuthFixture;
+use app_test_support::write_chatgpt_auth;
use codex_config::CONFIG_TOML_FILE;
use codex_config::MarketplaceConfigUpdate;
use codex_config::record_user_marketplace;
+use codex_config::types::AuthCredentialsStoreMode;
use codex_utils_absolute_path::canonicalize_existing_preserving_symlinks;
+use flate2::Compression;
+use flate2::write::GzEncoder;
use predicates::prelude::PredicateBooleanExt;
use predicates::str::contains;
use pretty_assertions::assert_eq;
+use serde_json::Value;
use serde_json::json;
use std::path::Path;
+use std::process::Output;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
use tempfile::TempDir;
+use tokio::process::Command;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+use wiremock::matchers::query_param;
const MARKETPLACE_HEADER: &str = "MARKETPLACE";
const MARKETPLACE_LIST_HEADER: &str = "MARKETPLACE ROOT";
@@ -610,7 +629,7 @@ async fn plugin_list_prints_plugins_in_a_table() -> Result<()> {
.stdout(contains("PLUGIN"))
.stdout(contains("STATUS"))
.stdout(contains("VERSION"))
- .stdout(contains("PATH"))
+ .stdout(contains("SOURCE"))
.stdout(contains(marketplace_manifest.display().to_string()))
.stdout(contains("sample@debug"))
.stdout(contains("not installed"))
@@ -1106,3 +1125,753 @@ async fn plugin_add_rejects_cached_plugins_without_authorizing_marketplace_snaps
Ok(())
}
+
+const REMOTE_ID: &str = "b1234567-89ab-4cde-8f01-234567890abc";
+const MARKETPLACE: &str = "openai-curated-remote";
+const PLUGIN_KEY: &str = "sample@openai-curated-remote";
+
+fn sample_remote_plugin_bundle() -> Result<Vec<u8>> {
+ let mut archive = tar::Builder::new(GzEncoder::new(Vec::new(), Compression::default()));
+ for (path, contents) in [
+ (
+ ".codex-plugin/plugin.json",
+ r#"{"name":"sample","version":"1.2.3"}"#,
+ ),
+ (
+ "skills/sample/SKILL.md",
+ "---\nname: sample\ndescription: Sample remote skill\n---\nSample instructions.\n",
+ ),
+ ] {
+ let mut header = tar::Header::new_gnu();
+ header.set_size(contents.len() as u64);
+ header.set_mode(/*mode*/ 0o644);
+ header.set_cksum();
+ archive.append_data(&mut header, path, contents.as_bytes())?;
+ }
+ Ok(archive.into_inner()?.finish()?)
+}
+
+struct RemoteMarketplaceFixture {
+ home: TempDir,
+ server: MockServer,
+ plugin: Value,
+}
+
+impl RemoteMarketplaceFixture {
+ async fn new() -> Result<Self> {
+ let home = TempDir::new()?;
+ let server = MockServer::start().await;
+ std::fs::write(
+ home.path().join("config.toml"),
+ format!(
+ "cli_auth_credentials_store = 'file'\nchatgpt_base_url = '{}/backend-api'\n[features]\nplugins = true\nremote_plugin = true\n",
+ server.uri()
+ ),
+ )?;
+ write_chatgpt_auth(
+ home.path(),
+ ChatGptAuthFixture::new("chatgpt-token")
+ .account_id("account-123")
+ .chatgpt_account_id("account-123"),
+ AuthCredentialsStoreMode::File,
+ )?;
+ let plugin = json!({
+ "id": REMOTE_ID, "name": "sample", "scope": "GLOBAL",
+ "installation_policy": "AVAILABLE", "authentication_policy": "ON_USE",
+ "release": {"version": "1.2.3", "display_name": "Sample", "description": "Remote sample",
+ "interface": {}, "bundle_download_url": format!("{}/bundle.tar.gz", server.uri())}
+ });
+ Mock::given(method("GET"))
+ .and(path("/backend-api/ps/plugins/list"))
+ .and(query_param("scope", "GLOBAL"))
+ .and(header("authorization", "Bearer chatgpt-token"))
+ .and(header("chatgpt-account-id", "account-123"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(
+ json!({"plugins": [plugin.clone()], "pagination": {"next_page_token": null}}),
+ ))
+ .mount(&server)
+ .await;
+ Ok(Self {
+ home,
+ server,
+ plugin,
+ })
+ }
+
+ fn write_local_curated_marketplace(&self) -> Result<Value> {
+ let source = canonicalize_existing_preserving_symlinks(self.home.path())?
+ .join(".tmp")
+ .join("plugins");
+ let mut manifest = json!({
+ "name": "openai-curated",
+ "plugins": [{
+ "name": "sample",
+ "source": {"source": "local", "path": "./plugins/sample"}
+ }]
+ });
+ write_marketplace_source_with_manifest(&source, &manifest.to_string())?;
+ std::fs::write(
+ self.home.path().join(".tmp").join("plugins.sha"),
+ "local-curated",
+ )?;
+ manifest["name"] = json!("openai-api-curated");
+ std::fs::write(
+ source
+ .join(".agents")
+ .join("plugins")
+ .join("api_marketplace.json"),
+ manifest.to_string(),
+ )?;
+ Ok(json!({
+ "pluginId": "sample@openai-curated", "name": "sample",
+ "marketplaceName": "openai-curated", "version": "1.2.3",
+ "installed": false, "enabled": false,
+ "source": {"source": "local", "path": source.join("plugins").join("sample")},
+ "installPolicy": "AVAILABLE", "authPolicy": "ON_INSTALL"
+ }))
+ }
+
+ async fn run(&self, args: &[&str]) -> Result<Output> {
+ Ok(Command::new(codex_utils_cargo_bin::cargo_bin("codex")?)
+ .current_dir(self.home.path())
+ .env("CODEX_HOME", self.home.path())
+ .env("HOME", self.home.path())
+ .env_remove("OPENAI_API_KEY")
+ .env_remove("CODEX_API_KEY")
+ .env_remove("CODEX_ACCESS_TOKEN")
+ .env("CODEX_TEST_ALLOW_HTTP_REMOTE_PLUGIN_BUNDLE_DOWNLOADS", "1")
+ .args(args)
+ .output()
+ .await?)
+ }
+
+ async fn success(&self, args: &[&str]) -> Result<String> {
+ let output = self.run(args).await?;
+ ensure!(
+ output.status.success(),
+ "{}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ Ok(String::from_utf8(output.stdout)?)
+ }
+}
+
+#[tokio::test]
+async fn remote_plugin_listing_replaces_local_curated_catalog() -> Result<()> {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ let mut local_plugin = fixture.write_local_curated_marketplace()?;
+ fixture
+ .success(&["plugin", "add", "sample@openai-curated"])
+ .await?;
+ local_plugin["installed"] = json!(true);
+ local_plugin["enabled"] = json!(true);
+ local_plugin["version"] = json!("local-curated");
+ let mut installed_plugin = fixture.plugin.clone();
+ installed_plugin["enabled"] = json!(true);
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "plugins": [installed_plugin], "pagination": {"next_page_token": null}
+ })))
+ .mount(&fixture.server)
+ .await;
+
+ let listed = fixture
+ .success(&["plugin", "list", "--available", "--json"])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [{
+ "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
+ "version": "1.2.3", "installed": true, "enabled": true,
+ "source": {"source": "remote", "id": REMOTE_ID},
+ "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
+ }], "available": []})
+ );
+ let table = fixture.success(&["plugin", "list"]).await?;
+ insta::assert_snapshot!(table, @r"
+ Marketplace `openai-curated-remote`
+ Remote catalog
+
+ PLUGIN STATUS VERSION SOURCE
+ sample@openai-curated-remote installed, enabled 1.2.3 b1234567-89ab-4cde-8f01-234567890abc
+ ");
+
+ fixture.server.reset().await;
+ let listed = fixture
+ .success(&["plugin", "list", "-m", "openai-curated", "--json"])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [local_plugin], "available": []})
+ );
+ assert!(fixture.server.received_requests().await.unwrap().is_empty());
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_listing_preserves_local_curated_only_when_fetch_fails() -> Result<()> {
+ for status in [200, 403] {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ fixture.server.reset().await;
+ let local_plugin = fixture.write_local_curated_marketplace()?;
+ let response = ResponseTemplate::new(status).set_body_json(json!({
+ "plugins": [], "pagination": {"next_page_token": null}
+ }));
+ let _catalog = Mock::given(path("/backend-api/ps/plugins/list"))
+ .respond_with(response)
+ .mount_as_scoped(&fixture.server)
+ .await;
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "plugins": [], "pagination": {"next_page_token": null}
+ })))
+ .mount(&fixture.server)
+ .await;
+
+ let listed = fixture
+ .success(&["plugin", "list", "--available", "--json"])
+ .await?;
+ let available = if status == 200 {
+ Vec::new()
+ } else {
+ vec![local_plugin]
+ };
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": available}),
+ "catalog response status: {status}"
+ );
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_add_list_and_remove() -> Result<()> {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ let installed = Arc::new(AtomicBool::new(false));
+ let installed_for_list = Arc::clone(&installed);
+ let mut installed_plugin = fixture.plugin.clone();
+ installed_plugin["enabled"] = json!(true);
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(move |_: &wiremock::Request| {
+ let plugins = if installed_for_list.load(Ordering::SeqCst) {
+ vec![installed_plugin.clone()]
+ } else {
+ Vec::new()
+ };
+ ResponseTemplate::new(200)
+ .set_body_json(json!({"plugins": plugins, "pagination": {"next_page_token": null}}))
+ })
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
+ .respond_with(ResponseTemplate::new(200).set_body_json(&fixture.plugin))
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path("/bundle.tar.gz"))
+ .respond_with(ResponseTemplate::new(200).set_body_bytes(sample_remote_plugin_bundle()?))
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+ let installed_root = canonicalize_existing_preserving_symlinks(fixture.home.path())?
+ .join("plugins")
+ .join("cache")
+ .join(MARKETPLACE)
+ .join("sample")
+ .join("1.2.3");
+ let manifest = installed_root.join(".codex-plugin/plugin.json");
+ let installed_for_add = Arc::clone(&installed);
+ Mock::given(method("POST"))
+ .and(path(format!("/backend-api/ps/plugins/{REMOTE_ID}/install")))
+ .and(query_param("includeAppsNeedingAuth", "true"))
+ .and(header("authorization", "Bearer chatgpt-token"))
+ .respond_with(move |_: &wiremock::Request| {
+ assert!(
+ manifest.is_file(),
+ "cache must exist before backend install"
+ );
+ installed_for_add.store(true, Ordering::SeqCst);
+ ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": true}))
+ })
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+ Mock::given(method("POST"))
+ .and(path(format!(
+ "/backend-api/ps/plugins/{REMOTE_ID}/uninstall"
+ )))
+ .and(header("authorization", "Bearer chatgpt-token"))
+ .respond_with(move |_: &wiremock::Request| {
+ installed.store(false, Ordering::SeqCst);
+ ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": false}))
+ })
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+
+ let available = json!({
+ "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
+ "version": "1.2.3", "installed": false, "enabled": false,
+ "source": {"source": "remote", "id": REMOTE_ID}, "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
+ });
+ let listed = fixture
+ .success(&["plugin", "list", "--available", "--json"])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": [available.clone()]})
+ );
+ let table = fixture
+ .success(&["plugin", "list", "-m", MARKETPLACE])
+ .await?;
+ insta::assert_snapshot!(table, @r"
+ Marketplace `openai-curated-remote`
+ Remote catalog
+
+ PLUGIN STATUS VERSION SOURCE
+ sample@openai-curated-remote not installed 1.2.3 b1234567-89ab-4cde-8f01-234567890abc
+ ");
+ let added = fixture
+ .success(&["plugin", "add", PLUGIN_KEY, "--json"])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&added)?,
+ json!({
+ "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
+ "version": "1.2.3", "installedPath": installed_root, "authPolicy": "ON_USE"
+ })
+ );
+ assert_eq!(
+ fixture
+ .server
+ .received_requests()
+ .await
+ .unwrap()
+ .iter()
+ .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
+ .count(),
+ 1,
+ "installing a cached name must not refetch the catalog"
+ );
+ assert!(installed_root.join("skills/sample/SKILL.md").is_file());
+ let mut expected = available;
+ expected["installed"] = json!(true);
+ expected["enabled"] = json!(true);
+ let listed = fixture
+ .success(&["plugin", "list", "-m", MARKETPLACE, "--json"])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [expected], "available": []})
+ );
+ let _delisted = Mock::given(path("/backend-api/ps/plugins/list"))
+ .respond_with(
+ ResponseTemplate::new(200)
+ .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
+ )
+ .mount_as_scoped(&fixture.server)
+ .await;
+ let removed = fixture
+ .success(&[
+ "-c",
+ "features.remote_plugin=false",
+ "plugin",
+ "remove",
+ "sample",
+ "-m",
+ MARKETPLACE,
+ "--json",
+ ])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&removed)?,
+ json!({"pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE})
+ );
+ assert!(!installed_root.exists());
+ let listed = fixture.success(&["plugin", "list", "--json"]).await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": []})
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_add_refreshes_cached_catalog_on_name_miss() -> Result<()> {
+ for (remote_plugin_config, collection) in [
+ ("features.remote_plugin=true", None),
+ ("features.remote_plugin=false", Some("vertical")),
+ ] {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ fixture.server.reset().await;
+ let published = Arc::new(AtomicBool::new(false));
+ let published_for_list = Arc::clone(&published);
+ let plugin = fixture.plugin.clone();
+ Mock::given(method("GET"))
+ .and(path("/backend-api/ps/plugins/list"))
+ .and(query_param("scope", "GLOBAL"))
+ .respond_with(move |_: &wiremock::Request| {
+ let plugins = if published_for_list.load(Ordering::SeqCst) {
+ vec![plugin.clone()]
+ } else {
+ Vec::new()
+ };
+ ResponseTemplate::new(200).set_body_json(json!({
+ "plugins": plugins, "pagination": {"next_page_token": null}
+ }))
+ })
+ .expect(2)
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "plugins": [], "pagination": {"next_page_token": null}
+ })))
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
+ .respond_with(ResponseTemplate::new(200).set_body_json(&fixture.plugin))
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path("/bundle.tar.gz"))
+ .respond_with(ResponseTemplate::new(200).set_body_bytes(sample_remote_plugin_bundle()?))
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+ Mock::given(method("POST"))
+ .and(path(format!("/backend-api/ps/plugins/{REMOTE_ID}/install")))
+ .respond_with(
+ ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": true})),
+ )
+ .expect(1)
+ .mount(&fixture.server)
+ .await;
+
+ for is_published in [false, true] {
+ published.store(is_published, Ordering::SeqCst);
+ let listed = fixture
+ .success(&[
+ "-c",
+ remote_plugin_config,
+ "plugin",
+ "list",
+ "-m",
+ MARKETPLACE,
+ "--available",
+ "--json",
+ ])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": []}),
+ "normal listing must keep using the fresh catalog cache"
+ );
+ }
+ let added = fixture
+ .success(&[
+ "-c",
+ remote_plugin_config,
+ "plugin",
+ "add",
+ PLUGIN_KEY,
+ "--json",
+ ])
+ .await?;
+ let installed_root = canonicalize_existing_preserving_symlinks(fixture.home.path())?
+ .join("plugins")
+ .join("cache")
+ .join(MARKETPLACE)
+ .join("sample")
+ .join("1.2.3");
+ assert_eq!(
+ serde_json::from_str::<Value>(&added)?,
+ json!({
+ "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
+ "version": "1.2.3", "installedPath": installed_root, "authPolicy": "ON_USE"
+ })
+ );
+ assert!(
+ installed_root
+ .join("skills")
+ .join("sample")
+ .join("SKILL.md")
+ .is_file()
+ );
+ let requests = fixture.server.received_requests().await.unwrap();
+ let catalog_collections = requests
+ .iter()
+ .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
+ .map(|request| {
+ request
+ .url
+ .query_pairs()
+ .find_map(|(key, value)| (key == "collection").then(|| value.into_owned()))
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(catalog_collections, vec![collection.map(str::to_owned); 2]);
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_add_limits_catalog_refresh_without_mutation() -> Result<()> {
+ enum CatalogCache {
+ Missing,
+ Fresh,
+ Expired,
+ }
+
+ for (remote_plugin_config, collection) in [
+ ("features.remote_plugin=true", None),
+ ("features.remote_plugin=false", Some("vertical")),
+ ] {
+ for (cache, plugin_count, status, catalog_fetches, error) in [
+ (
+ CatalogCache::Missing,
+ 0,
+ 200,
+ 1,
+ "was not found in remote marketplace",
+ ),
+ (
+ CatalogCache::Fresh,
+ 0,
+ 200,
+ 2,
+ "was not found in remote marketplace",
+ ),
+ (
+ CatalogCache::Expired,
+ 0,
+ 200,
+ 2,
+ "was not found in remote marketplace",
+ ),
+ (
+ CatalogCache::Missing,
+ 2,
+ 200,
+ 1,
+ "matched multiple remote plugins",
+ ),
+ (
+ CatalogCache::Missing,
+ 0,
+ 403,
+ 1,
+ "failed to list remote marketplace plugins",
+ ),
+ ] {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ fixture.server.reset().await;
+ let mut duplicate = fixture.plugin.clone();
+ duplicate["id"] = json!("c1234567-89ab-4cde-8f01-234567890abc");
+ let plugins = [fixture.plugin.clone(), duplicate]
+ .into_iter()
+ .take(plugin_count)
+ .collect::<Vec<_>>();
+ Mock::given(path("/backend-api/ps/plugins/list"))
+ .and(query_param("scope", "GLOBAL"))
+ .respond_with(ResponseTemplate::new(status).set_body_json(json!({
+ "plugins": plugins, "pagination": {"next_page_token": null}
+ })))
+ .expect(catalog_fetches)
+ .mount(&fixture.server)
+ .await;
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "plugins": [], "pagination": {"next_page_token": null}
+ })))
+ .mount(&fixture.server)
+ .await;
+ if !matches!(cache, CatalogCache::Missing) {
+ let listed = fixture
+ .success(&[
+ "-c",
+ remote_plugin_config,
+ "plugin",
+ "list",
+ "-m",
+ MARKETPLACE,
+ "--available",
+ "--json",
+ ])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": []})
+ );
+ }
+ if matches!(cache, CatalogCache::Expired) {
+ let cache_paths = std::fs::read_dir(
+ fixture
+ .home
+ .path()
+ .join("cache")
+ .join("remote_plugin_catalog"),
+ )?
+ .map(|entry| entry.map(|entry| entry.path()))
+ .collect::<std::io::Result<Vec<_>>>()?;
+ assert_eq!(cache_paths.len(), 1);
+ let cache_path = &cache_paths[0];
+ let mut cached_catalog: Value =
+ serde_json::from_slice(&std::fs::read(cache_path)?)?;
+ cached_catalog["fetched_at"] = json!("2000-01-01T00:00:00Z");
+ std::fs::write(cache_path, serde_json::to_vec(&cached_catalog)?)?;
+ }
+ let output = fixture
+ .run(&["-c", remote_plugin_config, "plugin", "add", PLUGIN_KEY])
+ .await?;
+ assert!(!output.status.success());
+ let stderr = String::from_utf8(output.stderr)?;
+ assert!(stderr.contains(error), "{stderr}");
+ let requests = fixture.server.received_requests().await.unwrap();
+ let catalog_collections = requests
+ .iter()
+ .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
+ .map(|request| {
+ request
+ .url
+ .query_pairs()
+ .find_map(|(key, value)| (key == "collection").then(|| value.into_owned()))
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(
+ catalog_collections,
+ vec![collection.map(str::to_owned); catalog_fetches as usize]
+ );
+ assert!(requests.iter().all(|request| {
+ request.method == "GET"
+ && matches!(
+ request.url.path(),
+ "/backend-api/ps/plugins/list" | "/backend-api/ps/plugins/installed"
+ )
+ }));
+ assert!(
+ !fixture
+ .home
+ .path()
+ .join("plugins")
+ .join("cache")
+ .join(MARKETPLACE)
+ .exists()
+ );
+ }
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_install_checks_policy_and_bundle_before_mutation() -> Result<()> {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(
+ ResponseTemplate::new(200)
+ .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
+ )
+ .mount(&fixture.server)
+ .await;
+ for (field, value, error) in [
+ ("status", "DISABLED_BY_ADMIN", "disabled by admin"),
+ (
+ "installation_policy",
+ "NOT_AVAILABLE",
+ "not available for install",
+ ),
+ ("status", "ENABLED", "failed to read plugin bundle tar"),
+ ] {
+ let mut plugin = fixture.plugin.clone();
+ plugin[field] = json!(value);
+ let _detail = Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
+ .respond_with(ResponseTemplate::new(200).set_body_json(plugin))
+ .mount_as_scoped(&fixture.server)
+ .await;
+ let _bundle = Mock::given(path("/bundle.tar.gz"))
+ .respond_with(ResponseTemplate::new(200).set_body_bytes(b"bad gzip"))
+ .mount_as_scoped(&fixture.server)
+ .await;
+ let output = fixture
+ .run(&["plugin", "add", "sample", "-m", MARKETPLACE])
+ .await?;
+ assert!(!output.status.success());
+ let stderr = String::from_utf8(output.stderr)?;
+ assert!(stderr.contains(error), "{stderr}");
+ }
+ let requests = fixture.server.received_requests().await.unwrap();
+ assert!(requests.iter().all(|request| request.method != "POST"));
+ assert_eq!(
+ requests
+ .iter()
+ .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
+ .count(),
+ 1,
+ "installation policy and bundle failures must not refetch the catalog"
+ );
+ Ok(())
+}
+
+#[tokio::test]
+async fn remote_plugin_listing_uses_collection_when_remote_catalog_is_disabled() -> Result<()> {
+ let fixture = RemoteMarketplaceFixture::new().await?;
+ let mut local_plugin = fixture.write_local_curated_marketplace()?;
+ Mock::given(path("/backend-api/ps/plugins/installed"))
+ .respond_with(
+ ResponseTemplate::new(200)
+ .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
+ )
+ .mount(&fixture.server)
+ .await;
+ let listed = fixture
+ .success(&[
+ "-c",
+ "features.remote_plugin=false",
+ "plugin",
+ "list",
+ "--available",
+ "--json",
+ ])
+ .await?;
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": [local_plugin.clone(), {
+ "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
+ "version": "1.2.3", "installed": false, "enabled": false,
+ "source": {"source": "remote", "id": REMOTE_ID},
+ "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
+ }]})
+ );
+ let requests = fixture.server.received_requests().await.unwrap();
+ let listing = requests
+ .iter()
+ .find(|request| request.url.path().ends_with("/list"))
+ .unwrap();
+ assert!(
+ listing
+ .url
+ .query_pairs()
+ .any(|(key, value)| key == "collection" && value == "vertical")
+ );
+ fixture.server.reset().await;
+ fixture
+ .success(&["-c", "features.plugins=false", "plugin", "list"])
+ .await?;
+ fixture
+ .success(&["plugin", "list", "-m", "local-only"])
+ .await?;
+ assert!(fixture.server.received_requests().await.unwrap().is_empty());
+ std::fs::remove_file(fixture.home.path().join("auth.json"))?;
+ let output = fixture.run(&["plugin", "list", "-m", MARKETPLACE]).await?;
+ assert!(!output.status.success());
+ assert!(String::from_utf8(output.stderr)?.contains("chatgpt authentication required"));
+ let listed = fixture
+ .success(&["plugin", "list", "--available", "--json"])
+ .await?;
+ local_plugin["pluginId"] = json!("sample@openai-api-curated");
+ local_plugin["marketplaceName"] = json!("openai-api-curated");
+ assert_eq!(
+ serde_json::from_str::<Value>(&listed)?,
+ json!({"installed": [], "available": [local_plugin]})
+ );
+ Ok(())
+}
diff --git a/codex-rs/core-plugins/src/remote.rs b/codex-rs/core-plugins/src/remote.rs
index 68e5595630..18cd4ff967 100644
--- a/codex-rs/core-plugins/src/remote.rs
+++ b/codex-rs/core-plugins/src/remote.rs
@@ -204,6 +204,8 @@ pub enum RemoteMarketplaceSource {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RemotePluginCatalogCacheMode {
PreferCache,
+ /// Reuse fresh entries and synchronously refresh missing or stale entries.
+ PreferFreshCache,
ForceRefetch,
}
@@ -211,6 +213,15 @@ pub enum RemotePluginCatalogCacheMode {
pub struct RemoteMarketplacesFetchOutcome {
pub marketplaces: Vec<RemoteMarketplace>,
pub catalog_cache_refresh_scopes: BTreeSet<RemotePluginScope>,
+ /// Whether any requested directory was served from disk cache, even if it was empty.
+ pub catalog_cache_used: bool,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct RemoteMarketplaceFetchOutcome {
+ pub marketplace: Option<RemoteMarketplace>,
+ /// Whether the requested directory was served from disk cache, even if it was empty.
+ pub catalog_cache_used: bool,
}
#[derive(Debug, Clone, PartialEq)]
@@ -791,6 +802,7 @@ pub async fn fetch_remote_marketplaces(
let auth = ensure_chatgpt_auth(auth)?;
let mut marketplaces = Vec::new();
let mut catalog_cache_refresh_scopes = BTreeSet::new();
+ let mut catalog_cache_used = false;
let needs_workspace_installed = sources.iter().any(|source| {
matches!(
source,
@@ -813,6 +825,7 @@ pub async fn fetch_remote_marketplaces(
config,
auth,
scope,
+ /*collection*/ None,
catalog_cache_mode,
),
fetch_installed_plugins_for_scope(config, auth, scope),
@@ -820,6 +833,7 @@ pub async fn fetch_remote_marketplaces(
if directory_plugins.cache_refresh_needed {
catalog_cache_refresh_scopes.insert(scope);
}
+ catalog_cache_used |= directory_plugins.catalog_cache_used;
if let Some(marketplace) = build_remote_marketplace(
scope.marketplace_name(),
scope.marketplace_display_name(),
@@ -838,6 +852,7 @@ pub async fn fetch_remote_marketplaces(
config,
auth,
scope,
+ /*collection*/ None,
catalog_cache_mode,
),
fetch_installed_plugins_for_scope(config, auth, scope),
@@ -845,6 +860,7 @@ pub async fn fetch_remote_marketplaces(
if directory_plugins.cache_refresh_needed {
catalog_cache_refresh_scopes.insert(scope);
}
+ catalog_cache_used |= directory_plugins.catalog_cache_used;
if let Some(marketplace) = build_remote_marketplace(
scope.marketplace_name(),
scope.marketplace_display_name(),
@@ -862,12 +878,14 @@ pub async fn fetch_remote_marketplaces(
config,
auth,
scope,
+ /*collection*/ None,
catalog_cache_mode,
)
.await?;
if directory_plugins.cache_refresh_needed {
catalog_cache_refresh_scopes.insert(scope);
}
+ catalog_cache_used |= directory_plugins.catalog_cache_used;
if let Some(marketplace) = build_remote_marketplace(
scope.marketplace_name(),
scope.marketplace_display_name(),
@@ -942,6 +960,7 @@ pub async fn fetch_remote_marketplaces(
Ok(RemoteMarketplacesFetchOutcome {
marketplaces,
catalog_cache_refresh_scopes,
+ catalog_cache_used,
})
}
@@ -953,7 +972,9 @@ pub(crate) async fn fetch_and_cache_remote_plugin_catalog(
) -> Result<(), RemotePluginCatalogError> {
let auth = ensure_chatgpt_auth(auth)?;
let plugins = fetch_directory_plugins_for_scope(config, auth, scope).await?;
- catalog_cache::write_cached_directory_plugins(codex_home, config, auth, scope, &plugins);
+ catalog_cache::write_cached_directory_plugins(
+ codex_home, config, auth, scope, /*collection*/ None, &plugins,
+ );
Ok(())
}
@@ -975,7 +996,18 @@ pub fn invalidate_cached_remote_plugin_catalog_scopes(
return;
};
for scope in scopes {
- catalog_cache::remove_cached_directory_plugins(codex_home, config, auth, *scope);
+ catalog_cache::remove_cached_directory_plugins(
+ codex_home, config, auth, *scope, /*collection*/ None,
+ );
+ if *scope == RemotePluginScope::Global {
+ catalog_cache::remove_cached_directory_plugins(
+ codex_home,
+ config,
+ auth,
+ *scope,
+ Some(OPENAI_CURATED_REMOTE_COLLECTION_KEY),
+ );
+ }
}
}
@@ -1094,14 +1126,15 @@ pub(crate) fn has_fresh_cached_remote_plugin_catalog(
let Ok(auth) = ensure_chatgpt_auth(auth) else {
return false;
};
- catalog_cache::load_cached_directory_plugins(codex_home, config, auth, scope).is_some_and(
- |cached| {
- matches!(
- cached.freshness,
- catalog_cache::RemotePluginCatalogCacheFreshness::Fresh
- )
- },
+ catalog_cache::load_cached_directory_plugins(
+ codex_home, config, auth, scope, /*collection*/ None,
)
+ .is_some_and(|cached| {
+ matches!(
+ cached.freshness,
+ catalog_cache::RemotePluginCatalogCacheFreshness::Fresh
+ )
+ })
}
pub(crate) fn cached_remote_plugin_catalog_scopes(
@@ -1115,7 +1148,10 @@ pub(crate) fn cached_remote_plugin_catalog_scopes(
RemotePluginScope::CATALOG_CACHE_SCOPES
.into_iter()
.filter(|scope| {
- catalog_cache::load_cached_directory_plugins(codex_home, config, auth, *scope).is_some()
+ catalog_cache::load_cached_directory_plugins(
+ codex_home, config, auth, *scope, /*collection*/ None,
+ )
+ .is_some()
})
.collect()
}
@@ -1130,6 +1166,7 @@ pub fn cached_global_remote_discoverable_plugins(
config,
auth,
RemotePluginScope::Global,
+ /*collection*/ None,
)
.map(|cached| cached.plugins)
.unwrap_or_default()
@@ -1149,26 +1186,34 @@ pub fn cached_global_remote_discoverable_plugins(
pub async fn fetch_openai_curated_remote_collection_marketplace(
config: &RemotePluginServiceConfig,
auth: Option<&CodexAuth>,
-) -> Result<Option<RemoteMarketplace>, RemotePluginCatalogError> {
+ catalog_cache_root: Option<&Path>,
+ catalog_cache_mode: RemotePluginCatalogCacheMode,
+) -> Result<RemoteMarketplaceFetchOutcome, RemotePluginCatalogError> {
let auth = ensure_chatgpt_auth(auth)?;
let scope = RemotePluginScope::Global;
let (directory_plugins, installed_plugins) = tokio::try_join!(
- fetch_directory_plugins_for_scope_with_collection(
+ fetch_directory_plugins_for_scope_with_cache(
+ catalog_cache_root,
config,
auth,
scope,
- OPENAI_CURATED_REMOTE_COLLECTION_KEY,
+ Some(OPENAI_CURATED_REMOTE_COLLECTION_KEY),
+ catalog_cache_mode,
),
fetch_installed_plugins_for_scope(config, auth, scope),
)?;
- build_remote_marketplace(
+ let marketplace = build_remote_marketplace(
REMOTE_GLOBAL_MARKETPLACE_NAME,
REMOTE_GLOBAL_MARKETPLACE_DISPLAY_NAME,
- directory_plugins,
+ directory_plugins.plugins,
installed_plugins,
/*include_installed_only*/ false,
- )
+ )?;
+ Ok(RemoteMarketplaceFetchOutcome {
+ marketplace,
+ catalog_cache_used: directory_plugins.catalog_cache_used,
+ })
}
fn build_remote_marketplace(
@@ -1974,6 +2019,7 @@ fn normalize_remote_default_prompt(prompt: &str) -> Option<String> {
struct DirectoryPluginsFetchOutcome {
plugins: Vec<RemotePluginDirectoryItem>,
cache_refresh_needed: bool,
+ catalog_cache_used: bool,
}
async fn fetch_directory_plugins_for_scope_with_cache(
@@ -1981,12 +2027,16 @@ async fn fetch_directory_plugins_for_scope_with_cache(
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
scope: RemotePluginScope,
+ collection: Option<&str>,
cache_mode: RemotePluginCatalogCacheMode,
) -> Result<DirectoryPluginsFetchOutcome, RemotePluginCatalogError> {
- if cache_mode == RemotePluginCatalogCacheMode::PreferCache
+ if cache_mode != RemotePluginCatalogCacheMode::ForceRefetch
&& let Some(codex_home) = codex_home
- && let Some(cached) =
- catalog_cache::load_cached_directory_plugins(codex_home, config, auth, scope)
+ && let Some(cached) = catalog_cache::load_cached_directory_plugins(
+ codex_home, config, auth, scope, collection,
+ )
+ && (cache_mode == RemotePluginCatalogCacheMode::PreferCache
+ || cached.freshness == catalog_cache::RemotePluginCatalogCacheFreshness::Fresh)
{
return Ok(DirectoryPluginsFetchOutcome {
plugins: cached.plugins,
@@ -1994,16 +2044,22 @@ async fn fetch_directory_plugins_for_scope_with_cache(
cached.freshness,
catalog_cache::RemotePluginCatalogCacheFreshness::Stale
),
+ catalog_cache_used: true,
});
}
- let plugins = fetch_directory_plugins_for_scope(config, auth, scope).await?;
+ let plugins =
+ fetch_directory_plugins_for_scope_with_optional_collection(config, auth, scope, collection)
+ .await?;
if let Some(codex_home) = codex_home {
- catalog_cache::write_cached_directory_plugins(codex_home, config, auth, scope, &plugins);
+ catalog_cache::write_cached_directory_plugins(
+ codex_home, config, auth, scope, collection, &plugins,
+ );
}
Ok(DirectoryPluginsFetchOutcome {
plugins,
cache_refresh_needed: false,
+ catalog_cache_used: false,
})
}
@@ -2018,21 +2074,6 @@ async fn fetch_directory_plugins_for_scope(
.await
}
-async fn fetch_directory_plugins_for_scope_with_collection(
- config: &RemotePluginServiceConfig,
- auth: &CodexAuth,
- scope: RemotePluginScope,
- collection: &str,
-) -> Result<Vec<RemotePluginDirectoryItem>, RemotePluginCatalogError> {
- fetch_directory_plugins_for_scope_with_optional_collection(
- config,
- auth,
- scope,
- Some(collection),
- )
- .await
-}
-
async fn fetch_directory_plugins_for_scope_with_optional_collection(
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
diff --git a/codex-rs/core-plugins/src/remote/catalog_cache.rs b/codex-rs/core-plugins/src/remote/catalog_cache.rs
index 50999919c7..cf78330e25 100644
--- a/codex-rs/core-plugins/src/remote/catalog_cache.rs
+++ b/codex-rs/core-plugins/src/remote/catalog_cache.rs
@@ -26,6 +26,8 @@ struct RemotePluginCatalogCacheKey {
// Global catalogs predate scoped cache keys and must keep their existing filenames.
#[serde(skip_serializing_if = "Option::is_none")]
scope: Option<RemotePluginScope>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ collection: Option<String>,
}
impl RemotePluginCatalogCacheKey {
@@ -33,6 +35,7 @@ impl RemotePluginCatalogCacheKey {
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
scope: RemotePluginScope,
+ collection: Option<&str>,
) -> Option<Self> {
let cache_key = Self {
chatgpt_base_url: config.chatgpt_base_url.clone(),
@@ -40,6 +43,7 @@ impl RemotePluginCatalogCacheKey {
chatgpt_user_id: auth.get_chatgpt_user_id(),
is_workspace_account: auth.is_workspace_account(),
scope: (scope != RemotePluginScope::Global).then_some(scope),
+ collection: collection.map(str::to_owned),
};
// Preserve global catalog caching for existing header-auth clients, but never share
// user or workspace catalogs when the auth mode cannot identify their owner.
@@ -79,8 +83,9 @@ pub(crate) fn load_cached_directory_plugins(
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
scope: RemotePluginScope,
+ collection: Option<&str>,
) -> Option<CachedDirectoryPlugins> {
- let cache_key = RemotePluginCatalogCacheKey::new(config, auth, scope)?;
+ let cache_key = RemotePluginCatalogCacheKey::new(config, auth, scope, collection)?;
let cache_path = cache_path(codex_home, &cache_key);
let bytes = match std::fs::read(&cache_path) {
Ok(bytes) => bytes,
@@ -125,9 +130,10 @@ pub(crate) fn write_cached_directory_plugins(
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
scope: RemotePluginScope,
+ collection: Option<&str>,
plugins: &[RemotePluginDirectoryItem],
) {
- let Some(cache_key) = RemotePluginCatalogCacheKey::new(config, auth, scope) else {
+ let Some(cache_key) = RemotePluginCatalogCacheKey::new(config, auth, scope, collection) else {
return;
};
let cache_path = cache_path(codex_home, &cache_key);
@@ -146,8 +152,9 @@ pub(crate) fn remove_cached_directory_plugins(
config: &RemotePluginServiceConfig,
auth: &CodexAuth,
scope: RemotePluginScope,
+ collection: Option<&str>,
) {
- let Some(cache_key) = RemotePluginCatalogCacheKey::new(config, auth, scope) else {
+ let Some(cache_key) = RemotePluginCatalogCacheKey::new(config, auth, scope, collection) else {
return;
};
let cache_path = cache_path(codex_home, &cache_key);
diff --git a/codex-rs/core-plugins/src/remote/catalog_cache_tests.rs b/codex-rs/core-plugins/src/remote/catalog_cache_tests.rs
index 7039398660..049355968b 100644
--- a/codex-rs/core-plugins/src/remote/catalog_cache_tests.rs
+++ b/codex-rs/core-plugins/src/remote/catalog_cache_tests.rs
@@ -18,7 +18,7 @@ fn catalog_cache_freshness_honors_ttl() {
}
#[test]
-fn catalog_cache_paths_are_isolated_by_scope() {
+fn catalog_cache_paths_are_isolated_by_scope_and_collection() {
let codex_home = Path::new("/tmp/codex-home");
let cache_key_for_scope = |scope| RemotePluginCatalogCacheKey {
chatgpt_base_url: "https://chatgpt.com/backend-api".to_string(),
@@ -26,6 +26,7 @@ fn catalog_cache_paths_are_isolated_by_scope() {
chatgpt_user_id: Some("user-id".to_string()),
is_workspace_account: true,
scope: (scope != RemotePluginScope::Global).then_some(scope),
+ collection: None,
};
let paths = [
@@ -38,6 +39,10 @@ fn catalog_cache_paths_are_isolated_by_scope() {
assert_ne!(paths[0], paths[1]);
assert_ne!(paths[0], paths[2]);
assert_ne!(paths[1], paths[2]);
+
+ let mut collection_key = cache_key_for_scope(RemotePluginScope::Global);
+ collection_key.collection = Some("vertical".to_string());
+ assert!(!paths.contains(&cache_path(codex_home, &collection_key)));
}
#[test]
@@ -59,9 +64,14 @@ fn global_catalog_cache_reuses_legacy_cache_file() {
let contents = serde_json::to_string_pretty(&legacy_cache).expect("serialize legacy cache");
codex_utils_path::write_atomically(&legacy_cache_path, &contents).expect("write legacy cache");
- let cached =
- load_cached_directory_plugins(codex_home.path(), &config, &auth, RemotePluginScope::Global)
- .expect("load legacy global cache");
+ let cached = load_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ RemotePluginScope::Global,
+ /*collection*/ None,
+ )
+ .expect("load legacy global cache");
assert!(cached.plugins.is_empty());
assert_eq!(cached.freshness, RemotePluginCatalogCacheFreshness::Stale);
@@ -70,6 +80,7 @@ fn global_catalog_cache_reuses_legacy_cache_file() {
&config,
&auth,
RemotePluginScope::Global,
+ /*collection*/ None,
&[],
);
let refreshed_cache: RemotePluginCatalogDiskCache = serde_json::from_slice(
@@ -93,11 +104,18 @@ fn header_auth_does_not_cache_private_catalogs_without_a_stable_identity() {
&config,
&auth,
RemotePluginScope::Global,
+ /*collection*/ None,
&[],
);
assert!(
- load_cached_directory_plugins(codex_home.path(), &config, &auth, RemotePluginScope::Global)
- .is_some()
+ load_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ RemotePluginScope::Global,
+ /*collection*/ None,
+ )
+ .is_some()
);
for scope in [RemotePluginScope::User, RemotePluginScope::Workspace] {
@@ -107,10 +125,18 @@ fn header_auth_does_not_cache_private_catalogs_without_a_stable_identity() {
chatgpt_user_id: None,
is_workspace_account: false,
scope: Some(scope),
+ collection: None,
};
let insecure_cache_path = cache_path(codex_home.path(), &insecure_cache_key);
- write_cached_directory_plugins(codex_home.path(), &config, &auth, scope, &[]);
+ write_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ scope,
+ /*collection*/ None,
+ &[],
+ );
assert!(!insecure_cache_path.exists());
let insecure_cache = RemotePluginCatalogDiskCache {
@@ -122,6 +148,15 @@ fn header_auth_does_not_cache_private_catalogs_without_a_stable_identity() {
codex_utils_path::write_atomically(&insecure_cache_path, &contents)
.expect("write insecure cache");
- assert!(load_cached_directory_plugins(codex_home.path(), &config, &auth, scope).is_none());
+ assert!(
+ load_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ scope,
+ /*collection*/ None,
+ )
+ .is_none()
+ );
}
}
diff --git a/codex-rs/core-plugins/src/remote_tests.rs b/codex-rs/core-plugins/src/remote_tests.rs
index 6828084b24..1d8bc682ea 100644
--- a/codex-rs/core-plugins/src/remote_tests.rs
+++ b/codex-rs/core-plugins/src/remote_tests.rs
@@ -162,8 +162,116 @@ async fn remote_installed_plugins_paginate_across_all_scopes_without_download_ur
);
}
+#[tokio::test]
+async fn remote_catalog_cache_modes_control_refresh_and_persist_fetched_results() {
+ let server = MockServer::start().await;
+ let plugin = directory_plugin("plugin-gmail", "gmail");
+ Mock::given(method("GET"))
+ .and(path("/backend-api/ps/plugins/list"))
+ .and(query_param("scope", "GLOBAL"))
+ .and(query_param_is_missing("collection"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+ "plugins": [plugin],
+ "pagination": {"next_page_token": null},
+ })))
+ .expect(3)
+ .mount(&server)
+ .await;
+ let codex_home = tempfile::tempdir().expect("create codex home");
+ let (config, selected_urls) =
+ recording_remote_plugin_service_config(format!("{}/backend-api", server.uri()));
+ let auth = CodexAuth::create_dummy_chatgpt_auth_for_testing();
+
+ for (mode, expire_cache, expected_refresh_needed, expected_cache_used) in [
+ (
+ RemotePluginCatalogCacheMode::PreferFreshCache,
+ false,
+ false,
+ false,
+ ),
+ (
+ RemotePluginCatalogCacheMode::PreferFreshCache,
+ false,
+ false,
+ true,
+ ),
+ (RemotePluginCatalogCacheMode::PreferCache, true, true, true),
+ (
+ RemotePluginCatalogCacheMode::PreferFreshCache,
+ false,
+ false,
+ false,
+ ),
+ (
+ RemotePluginCatalogCacheMode::ForceRefetch,
+ false,
+ false,
+ false,
+ ),
+ ] {
+ if expire_cache {
+ let cache_path =
+ std::fs::read_dir(codex_home.path().join("cache/remote_plugin_catalog"))
+ .expect("read catalog cache directory")
+ .next()
+ .expect("catalog cache exists")
+ .expect("read cache entry")
+ .path();
+ let mut cached: serde_json::Value =
+ serde_json::from_slice(&std::fs::read(&cache_path).expect("read cache"))
+ .expect("decode cache");
+ cached["fetched_at"] = serde_json::json!("2000-01-01T00:00:00Z");
+ std::fs::write(
+ cache_path,
+ serde_json::to_vec(&cached).expect("encode cache"),
+ )
+ .expect("expire catalog cache");
+ }
+
+ let outcome = fetch_directory_plugins_for_scope_with_cache(
+ Some(codex_home.path()),
+ &config,
+ &auth,
+ RemotePluginScope::Global,
+ /*collection*/ None,
+ mode,
+ )
+ .await
+ .expect("fetch directory plugins");
+ assert_eq!(
+ (
+ outcome.plugins,
+ outcome.cache_refresh_needed,
+ outcome.catalog_cache_used,
+ ),
+ (
+ vec![plugin.clone()],
+ expected_refresh_needed,
+ expected_cache_used,
+ ),
+ );
+ }
+
+ assert_eq!(
+ recorded_http_client_urls(&selected_urls),
+ vec![
+ format!(
+ "{}/backend-api/ps/plugins/list?scope=GLOBAL&limit=200",
+ server.uri()
+ );
+ 3
+ ],
+ );
+ assert!(has_fresh_cached_remote_plugin_catalog(
+ codex_home.path(),
+ &config,
+ Some(&auth),
+ RemotePluginScope::Global,
+ ));
+}
+
#[test]
-fn cached_remote_plugin_catalog_scopes_returns_existing_scopes() {
+fn catalog_cache_invalidation_clears_global_collections_and_preserves_other_scopes() {
let codex_home = tempfile::tempdir().expect("create codex home");
let config = RemotePluginServiceConfig::new(
"https://chatgpt.com/backend-api".to_string(),
@@ -176,6 +284,7 @@ fn cached_remote_plugin_catalog_scopes_returns_existing_scopes() {
&config,
&auth,
scope,
+ /*collection*/ None,
&[],
);
}
@@ -184,6 +293,36 @@ fn cached_remote_plugin_catalog_scopes_returns_existing_scopes() {
cached_remote_plugin_catalog_scopes(codex_home.path(), &config, Some(&auth)),
BTreeSet::from([RemotePluginScope::Global, RemotePluginScope::Workspace])
);
+ catalog_cache::write_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ RemotePluginScope::Global,
+ Some(OPENAI_CURATED_REMOTE_COLLECTION_KEY),
+ &[],
+ );
+
+ invalidate_cached_remote_plugin_catalog_scopes(
+ codex_home.path(),
+ &config,
+ Some(&auth),
+ &[RemotePluginScope::Global],
+ );
+
+ assert_eq!(
+ cached_remote_plugin_catalog_scopes(codex_home.path(), &config, Some(&auth)),
+ BTreeSet::from([RemotePluginScope::Workspace]),
+ );
+ assert!(
+ catalog_cache::load_cached_directory_plugins(
+ codex_home.path(),
+ &config,
+ &auth,
+ RemotePluginScope::Global,
+ Some(OPENAI_CURATED_REMOTE_COLLECTION_KEY),
+ )
+ .is_none()
+ );
}
#[test]