Lightweight coding agent that runs in your terminal
Rust
Isolate automatic plugin Git operations (#39520)
Charlie Marshffad92234000
diff --git a/codex-rs/app-server/tests/suite/v2/curated_mcp_sync.rs b/codex-rs/app-server/tests/suite/v2/curated_mcp_sync.rsindex 7465f7f339..957c2645b9 100644--- a/codex-rs/app-server/tests/suite/v2/curated_mcp_sync.rs+++ b/codex-rs/app-server/tests/suite/v2/curated_mcp_sync.rs@@ -38,6 +38,7 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);struct CuratedMcpSyncFixture {mcp: TestAppServer,sync_barrier: PathBuf,+ malicious_git_helper_marker: PathBuf,mcp_server_handle: JoinHandle<()>,_fixture_root: TempDir,_responses_server: MockServer,@@ -49,10 +50,11 @@ impl CuratedMcpSyncFixture {let (mcp_server_url, mcp_server_handle) = start_mcp_server().await?;let fixture_root = TempDir::new()?;let codex_home = fixture_root.path().join("codex-home");- let curated_repo = fixture_root.path().join("curated-repo");+ let curated_repo = fixture_root.path().join("plugins.git");let git_wrapper_dir = fixture_root.path().join("bin");let git_config = fixture_root.path().join("gitconfig");let sync_barrier = fixture_root.path().join("allow-curated-sync");+ let malicious_git_helper_marker = fixture_root.path().join("malicious-git-helper-ran");std::fs::create_dir_all(&codex_home)?;std::fs::create_dir_all(&curated_repo)?;std::fs::create_dir_all(&git_wrapper_dir)?;@@ -91,7 +93,7 @@ impl CuratedMcpSyncFixture {&["commit", "-m", "test curated plugins"],)?;- let curated_repo_url = format!("file://{}", curated_repo.display());+ let curated_repo_url = format!("file://{}/", fixture_root.path().display());let rewrite_key = format!("url.{curated_repo_url}.insteadOf");run_git(&real_git,@@ -103,10 +105,34 @@ impl CuratedMcpSyncFixture {.to_str().context("git config path should be UTF-8")?,&rewrite_key,- GITHUB_PLUGINS_GIT_URL,+ "https://github.com/openai/",],)?;+ let malicious_git_helper = fixture_root.path().join("malicious-git-helper.sh");+ std::fs::write(+ &malicious_git_helper,+ format!(+ "#!/bin/sh\nprintf ran > '{}'\nexit 73\n",+ malicious_git_helper_marker.display()+ ),+ )?;+ let mut helper_permissions = std::fs::metadata(&malicious_git_helper)?.permissions();+ helper_permissions.set_mode(0o755);+ std::fs::set_permissions(&malicious_git_helper, helper_permissions)?;+ run_git(&real_git, &codex_home, &["init", "-b", "main"])?;+ run_git(+ &real_git,+ &codex_home,+ &["config", "protocol.ext.allow", "always"],+ )?;+ let malicious_rewrite_key =+ format!("url.ext::{}.insteadOf", malicious_git_helper.display());+ run_git(+ &real_git,+ &codex_home,+ &["config", &malicious_rewrite_key, GITHUB_PLUGINS_GIT_URL],+ )?;let git_wrapper = git_wrapper_dir.join("git");std::fs::write(&git_wrapper,@@ -168,6 +194,7 @@ url = "{mcp_server_url}/mcp""#Ok(Self {mcp,sync_barrier,+ malicious_git_helper_marker,mcp_server_handle,_fixture_root: fixture_root,_responses_server: responses_server,@@ -208,6 +235,10 @@ async fn existing_thread_loads_api_curated_mcp_after_auth_switch_sync() -> Resul// Let sync materialize the bundle; its completion callback must refresh this same thread.std::fs::write(&fixture.sync_barrier, "continue")?;wait_for_mcp_ready(&mut fixture.mcp, TEST_SERVER_NAME).await?;+ ensure!(+ !fixture.malicious_git_helper_marker.exists(),+ "curated startup synchronization executed repository-local Git configuration"+ );let response: McpServerToolCallResponse = fixture.mcpdiff --git a/codex-rs/app-server/tests/suite/v2/marketplace_upgrade.rs b/codex-rs/app-server/tests/suite/v2/marketplace_upgrade.rsindex 4ef4f9174e..752b061228 100644--- a/codex-rs/app-server/tests/suite/v2/marketplace_upgrade.rs+++ b/codex-rs/app-server/tests/suite/v2/marketplace_upgrade.rs@@ -8,6 +8,11 @@ use app_test_support::TestAppServer;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::MarketplaceUpgradeParams;use codex_app_server_protocol::MarketplaceUpgradeResponse;+use codex_app_server_protocol::PluginInstallParams;+use codex_app_server_protocol::PluginInstallResponse;+use codex_app_server_protocol::PluginListMarketplaceKind;+use codex_app_server_protocol::PluginListParams;+use codex_app_server_protocol::PluginListResponse;use codex_app_server_protocol::RequestId;use codex_config::MarketplaceConfigUpdate;use codex_config::record_user_marketplace;@@ -195,6 +200,141 @@ async fn marketplace_upgrade_all_configured_git_marketplaces() -> Result<()> {Ok(())}+#[tokio::test]+async fn automatic_upgrade_isolates_git_while_explicit_install_preserves_configuration()+-> Result<()> {+ let codex_home = TempDir::new()?;+ let source = TempDir::new()?;+ let plugin_source = TempDir::new()?;+ let old_revision = init_marketplace_repo(source.path(), "trusted", "old")?;++ init_marketplace_repo(plugin_source.path(), "plugin", "plugin")?;+ let plugin_root = plugin_source.path().join(".codex-plugin");+ std::fs::create_dir_all(&plugin_root)?;+ std::fs::write(+ plugin_root.join("plugin.json"),+ r#"{"name":"toolkit","version":"1.0.0","interface":{"displayName":"Toolkit"}}"#,+ )?;+ run_git(plugin_source.path(), &["add", "."])?;+ run_git(plugin_source.path(), &["commit", "-qm", "add plugin"])?;+ let plugin_url = url::Url::from_directory_path(plugin_source.path())+ .map_err(|()| anyhow::anyhow!("invalid plugin source path"))?+ .to_string();+ std::fs::write(+ source.path().join(".agents/plugins/marketplace.json"),+ serde_json::json!({+ "name": "trusted",+ "plugins": [{+ "name": "toolkit",+ "source": {"source": "url", "url": plugin_url},+ }],+ })+ .to_string(),+ )?;+ run_git(source.path(), &["add", ".agents/plugins/marketplace.json"])?;+ commit_marketplace_marker(source.path(), "new")?;+ record_git_marketplace(+ codex_home.path(),+ "trusted",+ source.path(),+ &old_revision,+ /*ref_name*/ None,+ )?;+ let config_path = codex_home.path().join("config.toml");+ std::fs::write(+ &config_path,+ format!(+ "{}\n[plugins.\"toolkit@trusted\"]\nenabled = true\n",+ std::fs::read_to_string(&config_path)?+ ),+ )?;++ run_git(codex_home.path(), &["init", "--quiet"])?;+ let source_path = source.path().display().to_string();+ let missing_path = codex_home.path().join("missing").display().to_string();+ let rewrite_key = format!("url.{missing_path}.insteadOf");+ for untrusted_source in [&source_path, &plugin_url] {+ run_git(+ codex_home.path(),+ &["config", "--add", &rewrite_key, untrusted_source],+ )?;+ assert!(run_git(codex_home.path(), &["ls-remote", untrusted_source, "HEAD"]).is_err());+ }++ let manual_plugin_alias = "https://manual.example/plugin.git";+ let manual_plugin_rewrite = format!("url.{}.insteadOf", plugin_source.path().display());+ let mut server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .with_plugin_startup_tasks()+ .with_env_overrides(&[+ ("GIT_CONFIG_COUNT", Some("1")),+ ("GIT_CONFIG_KEY_0", Some(&manual_plugin_rewrite)),+ ("GIT_CONFIG_VALUE_0", Some(manual_plugin_alias)),+ ])+ .build_initialized_with_timeout(DEFAULT_TIMEOUT)+ .await?;+ let plugin_root = codex_home+ .path()+ .join("plugins/cache/trusted/toolkit/1.0.0/.codex-plugin/plugin.json");+ timeout(DEFAULT_TIMEOUT, async {+ while !plugin_root.exists() {+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ })+ .await?;++ let marketplace_path = marketplace_install_root(codex_home.path())+ .join("trusted/.agents/plugins/marketplace.json");+ std::fs::write(+ &marketplace_path,+ serde_json::json!({+ "name": "trusted",+ "plugins": [{+ "name": "toolkit",+ "source": {"source": "url", "url": manual_plugin_alias},+ }],+ })+ .to_string(),+ )?;+ let marketplace_path = AbsolutePathBuf::try_from(marketplace_path)?;+ let _: PluginInstallResponse = server+ .request(|request_id| ClientRequest::PluginInstall {+ request_id,+ params: PluginInstallParams {+ marketplace_path: Some(marketplace_path),+ remote_marketplace_name: None,+ install_attempt_id: None,+ plugin_name: "toolkit".to_string(),+ },+ })+ .await?;++ std::fs::write(+ plugin_source.path().join(".codex-plugin/plugin.json"),+ r#"{"name":"toolkit","version":"1.1.0","interface":{"displayName":"Toolkit"}}"#,+ )?;+ run_git(plugin_source.path(), &["add", "."])?;+ run_git(plugin_source.path(), &["commit", "-qm", "upgrade plugin"])?;+ let _: PluginListResponse = server+ .request(|request_id| ClientRequest::PluginList {+ request_id,+ params: PluginListParams {+ cwds: None,+ marketplace_kinds: Some(vec![PluginListMarketplaceKind::Local]),+ force_refetch: true,+ },+ })+ .await?;+ assert!(+ codex_home+ .path()+ .join("plugins/cache/trusted/toolkit/1.1.0/.codex-plugin/plugin.json")+ .is_file(),+ "explicit plugin/list refresh must preserve command-scoped Git configuration"+ );+ Ok(())+}+#[tokio::test]async fn marketplace_upgrade_named_marketplace_only() -> Result<()> {let codex_home = TempDir::new()?;@@ -211,17 +351,26 @@ async fn marketplace_upgrade_named_marketplace_only() -> Result<()> {&debug_old_revision,/*ref_name*/ None,)?;- record_git_marketplace(+ let tools_source_alias = "manual:tools";+ record_user_marketplace(codex_home.path(),"tools",- tools_source.path(),- &tools_old_revision,- /*ref_name*/ None,+ &configured_git_marketplace_update(+ tools_source_alias,+ Some(&tools_old_revision),+ /*ref_name*/ None,+ ),)?;disable_plugin_startup_tasks(codex_home.path())?;+ let tools_rewrite = format!("url.{}.insteadOf", tools_source.path().display());let mut mcp = TestAppServer::builder().with_codex_home(codex_home.path())+ .with_env_overrides(&[+ ("GIT_CONFIG_COUNT", Some("1")),+ ("GIT_CONFIG_KEY_0", Some(&tools_rewrite)),+ ("GIT_CONFIG_VALUE_0", Some(tools_source_alias)),+ ]).without_auto_env().build_initialized().await?;diff --git a/codex-rs/core-plugins/src/git_policy.rs b/codex-rs/core-plugins/src/git_policy.rsnew file mode 100644index 0000000000..27ba6998ae--- /dev/null+++ b/codex-rs/core-plugins/src/git_policy.rs@@ -0,0 +1,85 @@+use codex_utils_absolute_path::AbsolutePathBuf;+use std::path::Path;+use std::process::Command;+use tempfile::TempDir;++// These variables can redirect Git to an untrusted repository or inject command-scoped settings.+pub(crate) const REPOSITORY_LOCAL_GIT_ENVIRONMENT_VARIABLES: &[&str] = &[+ "GIT_ALTERNATE_OBJECT_DIRECTORIES",+ "GIT_CEILING_DIRECTORIES",+ "GIT_COMMON_DIR",+ "GIT_CONFIG",+ "GIT_CONFIG_COUNT",+ "GIT_CONFIG_PARAMETERS",+ "GIT_DIR",+ "GIT_DISCOVERY_ACROSS_FILESYSTEM",+ "GIT_GRAFT_FILE",+ "GIT_IMPLICIT_WORK_TREE",+ "GIT_INDEX_FILE",+ "GIT_NAMESPACE",+ "GIT_OBJECT_DIRECTORY",+ "GIT_PREFIX",+ "GIT_REPLACE_REF_BASE",+ "GIT_SHALLOW_FILE",+ "GIT_WORK_TREE",+];++/// Distinguishes isolated background Git operations from explicitly requested user operations.+#[derive(Clone, Copy, PartialEq, Eq)]+pub(crate) enum PluginGitMode {+ /// Ignores repository-scoped Git configuration inherited from the launch project.+ Automatic,+ /// Preserves the configuration explicitly available to user-requested Git commands.+ Manual,+}++impl PluginGitMode {+ /// Creates a Git command with the repository-environment policy for this operation.+ /// Automatic remote lookups and initial clones must also select a trusted repository.+ pub(crate) fn command(self, git_binary: &Path) -> Command {+ let mut command = Command::new(git_binary);+ command.args(["-c", codex_git_utils::SAFE_BARE_REPOSITORY_CONFIG]);+ if matches!(self, Self::Automatic) {+ command.env("GIT_OPTIONAL_LOCKS", "0");+ for name in REPOSITORY_LOCAL_GIT_ENVIRONMENT_VARIABLES {+ command.env_remove(name);+ }+ }+ command+ }+}++/// Isolates an automatic Git command from repository discovery in the launch project.+///+/// The command must already have repository-scoped environment variables removed. Keep the+/// returned guard alive until the Git process exits because it owns the selected repository.+pub(crate) fn configure_trusted_git_repository(+ command: &mut Command,+ codex_home: &Path,+) -> Result<TempDir, String> {+ let canonical_home = AbsolutePathBuf::from_absolute_path(codex_home)+ .and_then(|path| path.canonicalize())+ .map_err(|err| format!("failed to resolve trusted Codex home: {err}"))?;+ let staging_root = canonical_home.join(".tmp");+ std::fs::create_dir_all(staging_root.as_path())+ .map_err(|err| format!("failed to create trusted Git repository root: {err}"))?;+ let staging_root = staging_root+ .canonicalize()+ .map_err(|err| format!("failed to resolve trusted Git repository root: {err}"))?;+ if !staging_root.as_path().starts_with(canonical_home.as_path()) {+ return Err("trusted Git repository root escapes Codex home".to_string());+ }++ let repository = tempfile::Builder::new()+ .prefix("git-")+ .tempdir_in(staging_root.as_path())+ .map_err(|err| format!("failed to create trusted Git repository: {err}"))?;+ for directory in ["objects", "refs"] {+ std::fs::create_dir(repository.path().join(directory))+ .map_err(|err| format!("failed to initialize trusted Git repository: {err}"))?;+ }+ std::fs::write(repository.path().join("HEAD"), "ref: refs/heads/main\n")+ .map_err(|err| format!("failed to initialize trusted Git repository HEAD: {err}"))?;+ command.env("GIT_DIR", repository.path());+ Ok(repository)+}diff --git a/codex-rs/core-plugins/src/lib.rs b/codex-rs/core-plugins/src/lib.rsindex 5c84f19801..6aed23f44f 100644--- a/codex-rs/core-plugins/src/lib.rs+++ b/codex-rs/core-plugins/src/lib.rs@@ -3,6 +3,7 @@ mod artifact_operation;mod command_migration;mod discoverable;mod error_subtype;+mod git_policy;mod http_client_selector;pub mod installed_marketplaces;pub mod loader;@@ -32,6 +33,9 @@ mod test_support;pub mod toggles;mod tool_suggest_metadata;+pub(crate) use git_policy::PluginGitMode;+pub(crate) use git_policy::configure_trusted_git_repository;+pub const OPENAI_CURATED_MARKETPLACE_NAME: &str = "openai-curated";pub const OPENAI_API_CURATED_MARKETPLACE_NAME: &str = "openai-api-curated";pub const OPENAI_BUNDLED_MARKETPLACE_NAME: &str = "openai-bundled";diff --git a/codex-rs/core-plugins/src/loader.rs b/codex-rs/core-plugins/src/loader.rsindex 69f5b1616b..175564f539 100644--- a/codex-rs/core-plugins/src/loader.rs+++ b/codex-rs/core-plugins/src/loader.rs@@ -1,3 +1,4 @@+use crate::PluginGitMode;use crate::app_mcp_routing::apply_app_mcp_routing_policy;use crate::app_mcp_routing::apps_route_available;use crate::is_openai_curated_marketplace_name;@@ -56,7 +57,6 @@ use std::collections::HashMap;use std::collections::HashSet;use std::fs;use std::path::Path;-use std::process::Command;use tempfile::TempDir;use tracing::instrument;use tracing::warn;@@ -496,6 +496,7 @@ pub(crate) fn refresh_non_curated_plugin_cache(codex_home,additional_roots,configured_plugin_keys,+ PluginGitMode::Automatic,))}@@ -503,12 +504,14 @@ pub(crate) fn refresh_non_curated_plugin_cache_detailed(codex_home: &Path,additional_roots: &[AbsolutePathBuf],configured_plugin_keys: &[String],+ git_mode: PluginGitMode,) -> Result<NonCuratedCacheRefreshOutcome, String> {refresh_non_curated_plugin_cache_with_mode(codex_home,additional_roots,configured_plugin_keys,NonCuratedCacheRefreshMode::IfVersionChanged,+ git_mode,)}@@ -522,6 +525,7 @@ pub(crate) fn refresh_non_curated_plugin_cache_force_reinstall(codex_home,additional_roots,configured_plugin_keys,+ PluginGitMode::Automatic,))}@@ -529,12 +533,14 @@ pub(crate) fn refresh_non_curated_plugin_cache_force_reinstall_detailed(codex_home: &Path,additional_roots: &[AbsolutePathBuf],configured_plugin_keys: &[String],+ git_mode: PluginGitMode,) -> Result<NonCuratedCacheRefreshOutcome, String> {refresh_non_curated_plugin_cache_with_mode(codex_home,additional_roots,configured_plugin_keys,NonCuratedCacheRefreshMode::ForceReinstall,+ git_mode,)}@@ -543,6 +549,7 @@ fn refresh_non_curated_plugin_cache_with_mode(additional_roots: &[AbsolutePathBuf],configured_plugin_keys: &[String],mode: NonCuratedCacheRefreshMode,+ git_mode: PluginGitMode,) -> Result<NonCuratedCacheRefreshOutcome, String> {let mut configured_non_curated_plugin_ids = configured_plugin_keys.iter()@@ -644,9 +651,10 @@ fn refresh_non_curated_plugin_cache_with_mode(};let refresh_result = (|| -> Result<bool, String> {let materialized =- materialize_marketplace_plugin_source(codex_home, &source).map_err(|err| {- format!("failed to materialize plugin source for {plugin_key}: {err}")- })?;+ materialize_marketplace_plugin_source_with_mode(codex_home, &source, git_mode)+ .map_err(|err| {+ format!("failed to materialize plugin source for {plugin_key}: {err}")+ })?;let source_path = materialized.path;let plugin_version = match manifest_fallback_contents.as_deref() {Some(manifest_contents) => plugin_version_for_source_with_fallback_manifest(@@ -1706,6 +1714,15 @@ pub struct MaterializedMarketplacePluginSource {pub fn materialize_marketplace_plugin_source(codex_home: &Path,source: &MarketplacePluginSource,+) -> Result<MaterializedMarketplacePluginSource, String> {+ materialize_marketplace_plugin_source_with_mode(codex_home, source, PluginGitMode::Manual)+}++/// Applies the initiating operation's Git trust policy throughout plugin materialization.+pub(crate) fn materialize_marketplace_plugin_source_with_mode(+ codex_home: &Path,+ source: &MarketplacePluginSource,+ mode: PluginGitMode,) -> Result<MaterializedMarketplacePluginSource, String> {match source {MarketplacePluginSource::Local { path } => Ok(MaterializedMarketplacePluginSource {@@ -1735,11 +1752,13 @@ pub fn materialize_marketplace_plugin_source()})?;clone_git_plugin_source(+ codex_home,url,ref_name.as_deref(),sha.as_deref(),path.as_deref(),tempdir.path(),+ mode,)?;let path = if let Some(path) = path {AbsolutePathBuf::try_from(tempdir.path().join(path)).map_err(|err| {@@ -1775,12 +1794,18 @@ pub fn materialize_marketplace_plugin_source(}fn clone_git_plugin_source(+ codex_home: &Path,url: &str,ref_name: Option<&str>,sha: Option<&str>,sparse_checkout_path: Option<&str>,destination: &Path,+ mode: PluginGitMode,) -> Result<(), String> {+ let clone_cwd = match mode {+ PluginGitMode::Automatic => Some(codex_home),+ PluginGitMode::Manual => None,+ };if let Some(sparse_checkout_path) = sparse_checkout_path {run_git(&[@@ -1791,7 +1816,8 @@ fn clone_git_plugin_source(url,destination.to_string_lossy().as_ref(),],- /*cwd*/ None,+ clone_cwd,+ mode,)?;run_git(&[@@ -1802,42 +1828,56 @@ fn clone_git_plugin_source(sparse_checkout_path,],Some(destination),+ mode,)?;} else {run_git(&["clone", url, destination.to_string_lossy().as_ref()],- /*cwd*/ None,+ clone_cwd,+ mode,)?;}if let Some(sha) = sha {- run_git(&["checkout", sha], Some(destination))?;- let checked_out_sha = run_git_output(&["rev-parse", "HEAD"], Some(destination))?;+ run_git(&["checkout", sha], Some(destination), mode)?;+ let checked_out_sha = run_git_output(&["rev-parse", "HEAD"], Some(destination), mode)?;if !checked_out_sha.eq_ignore_ascii_case(sha) {return Err(format!("checked out Git SHA {checked_out_sha} does not match requested SHA {sha}"));}} else if let Some(ref_name) = ref_name {- run_git(&["checkout", ref_name], Some(destination))?;+ run_git(&["checkout", ref_name], Some(destination), mode)?;} else if sparse_checkout_path.is_some() {- run_git(&["checkout"], Some(destination))?;+ run_git(&["checkout"], Some(destination), mode)?;}Ok(())}-fn run_git(args: &[&str], cwd: Option<&Path>) -> Result<(), String> {- run_git_output(args, cwd).map(drop)+fn run_git(args: &[&str], cwd: Option<&Path>, mode: PluginGitMode) -> Result<(), String> {+ run_git_output(args, cwd, mode).map(drop)}-fn run_git_output(args: &[&str], cwd: Option<&Path>) -> Result<String, String> {- let mut command = Command::new("git");- command- .args(["-c", codex_git_utils::SAFE_BARE_REPOSITORY_CONFIG])- .args(args);+fn run_git_output(+ args: &[&str],+ cwd: Option<&Path>,+ mode: PluginGitMode,+) -> Result<String, String> {+ let mut command = mode.command(Path::new("git"));+ command.args(args);command.env("GIT_TERMINAL_PROMPT", "0");- if let Some(cwd) = cwd {- command.current_dir(cwd);- }+ let _trusted_repository = if let Some(cwd) = cwd+ && args.first() == Some(&"clone")+ {+ Some(crate::configure_trusted_git_repository(&mut command, cwd)?)+ } else {+ if let Some(cwd) = cwd {+ command.current_dir(cwd);+ if matches!(mode, PluginGitMode::Manual) {+ command.env_remove("GIT_DIR");+ }+ }+ None+ };let output = command.output()diff --git a/codex-rs/core-plugins/src/loader_tests.rs b/codex-rs/core-plugins/src/loader_tests.rsindex abbd3fcc24..efc2f27ae0 100644--- a/codex-rs/core-plugins/src/loader_tests.rs+++ b/codex-rs/core-plugins/src/loader_tests.rs@@ -630,6 +630,9 @@ fn load_plugin_hooks_supports_inline_manifest_hook_list() {#[test]fn materialize_git_subdir_uses_sparse_checkout() {+ let run_git = |args: &[&str], cwd| super::run_git(args, cwd, PluginGitMode::Manual);+ let run_git_output =+ |args: &[&str], cwd| super::run_git_output(args, cwd, PluginGitMode::Manual);let codex_home = tempfile::tempdir().expect("create codex home");let repo = tempfile::tempdir().expect("create git repo");let plugin_dir = repo.path().join("plugins/toolkit");@@ -678,6 +681,9 @@ fn materialize_git_subdir_uses_sparse_checkout() {#[test]fn materialize_git_source_rejects_sha_that_resolves_to_hostile_default_branch() {+ let run_git = |args: &[&str], cwd| super::run_git(args, cwd, PluginGitMode::Manual);+ let run_git_output =+ |args: &[&str], cwd| super::run_git_output(args, cwd, PluginGitMode::Manual);let codex_home = tempfile::tempdir().expect("create codex home");let repo = tempfile::tempdir().expect("create git repo");run_git(&["init"], Some(repo.path())).expect("init git repo");diff --git a/codex-rs/core-plugins/src/manager.rs b/codex-rs/core-plugins/src/manager.rsindex 6f191667a1..f4e9f466e5 100644--- a/codex-rs/core-plugins/src/manager.rs+++ b/codex-rs/core-plugins/src/manager.rs@@ -1,5 +1,6 @@use super::LoadedPlugin;use super::PluginLoadOutcome;+use crate::PluginGitMode;use crate::app_mcp_routing::apply_app_mcp_routing_policy;use crate::installed_marketplaces::installed_marketplace_roots_from_layer_stack;use crate::is_openai_curated_marketplace_name;@@ -43,7 +44,7 @@ use crate::marketplace_policy::MarketplacePolicy;use crate::marketplace_policy::configured_plugins_from_stack;use crate::marketplace_upgrade::ConfiguredMarketplaceUpgradeError;use crate::marketplace_upgrade::ConfiguredMarketplaceUpgradeOutcome;-use crate::marketplace_upgrade::upgrade_configured_git_marketplaces;+use crate::marketplace_upgrade::upgrade_configured_git_marketplaces_with_mode;use crate::remote::REMOTE_GLOBAL_MARKETPLACE_NAME;use crate::remote::RecommendedPluginsMode;use crate::remote::RemoteInstalledPlugin;@@ -263,6 +264,7 @@ struct NonCuratedCacheRefreshRequest {configured_plugin_keys: Vec<String>,configured_plugin_sources: Vec<NonCuratedPluginSource>,mode: NonCuratedCacheRefreshMode,+ git_mode: PluginGitMode,}#[derive(Clone, PartialEq, Eq)]@@ -2157,8 +2159,10 @@ impl PluginsManager {if let Err(err) = std::thread::Builder::new().name("plugins-marketplace-auto-upgrade".to_string()).spawn(move || {- let outcome = manager.upgrade_configured_marketplaces_for_config(- &config, /*marketplace_name*/ None,+ let outcome = manager.upgrade_configured_marketplaces_for_config_with_mode(+ &config,+ /*marketplace_name*/ None,+ PluginGitMode::Automatic,);match outcome {Ok(outcome) => {@@ -2255,10 +2259,25 @@ impl PluginsManager {config: &PluginsConfigInput,marketplace_name: Option<&str>,) -> Result<ConfiguredMarketplaceUpgradeOutcome, String> {- let mut outcome = upgrade_configured_git_marketplaces(+ self.upgrade_configured_marketplaces_for_config_with_mode(+ config,+ marketplace_name,+ PluginGitMode::Manual,+ )+ }++ /// Carries the initiating Git trust policy through marketplace and plugin refreshes.+ fn upgrade_configured_marketplaces_for_config_with_mode(+ &self,+ config: &PluginsConfigInput,+ marketplace_name: Option<&str>,+ mode: PluginGitMode,+ ) -> Result<ConfiguredMarketplaceUpgradeOutcome, String> {+ let mut outcome = upgrade_configured_git_marketplaces_with_mode(self.codex_home.as_path(),&config.config_layer_stack,marketplace_name,+ mode,);if let Some(marketplace_name) = marketplace_name&& outcome.selected_marketplaces.is_empty()@@ -2279,6 +2298,7 @@ impl PluginsManager {self.codex_home.as_path(),&outcome.upgraded_roots,&configured_plugin_keys,+ mode,) {Ok(refresh_outcome) => {self.clear_caches_after_marketplace_source_refresh(@@ -2319,9 +2339,11 @@ impl PluginsManager {config,roots,NonCuratedCacheRefreshMode::IfVersionChanged,+ PluginGitMode::Automatic,);}+ /// Runs an explicitly requested refresh using the caller's normal Git configuration.pub async fn refresh_non_curated_plugin_cache_for_config(self: &Arc<Self>,config: &PluginsConfigInput,@@ -2332,7 +2354,12 @@ impl PluginsManager {};let mut completion = self.non_curated_cache_refresh_completion.subscribe();let changed_sequence = completion.borrow_and_update().changed_sequence;- self.maybe_start_non_curated_plugin_cache_refresh(config, roots);+ self.schedule_non_curated_plugin_cache_refresh(+ config,+ roots,+ NonCuratedCacheRefreshMode::IfVersionChanged,+ PluginGitMode::Manual,+ );loop {let in_flight = match self.non_curated_cache_refresh_state.read() {@@ -2466,6 +2493,7 @@ impl PluginsManager {config: &PluginsConfigInput,roots: &[AbsolutePathBuf],mode: NonCuratedCacheRefreshMode,+ git_mode: PluginGitMode,) {let marketplace_roots =self.marketplace_roots(config, roots, /*include_openai_curated*/ false);@@ -2535,6 +2563,7 @@ impl PluginsManager {configured_plugin_keys,configured_plugin_sources,mode,+ git_mode,};let should_spawn = {@@ -2568,16 +2597,24 @@ impl PluginsManager {request.mode = NonCuratedCacheRefreshMode::ForceReinstall;}// Reconcile each canonical plugin generation once before publishing its resource.- if state.requested.as_ref() == Some(&request)- || (request.mode == NonCuratedCacheRefreshMode::IfVersionChanged- && !state.in_flight- && state.last_refreshed.as_ref().is_some_and(|last_refreshed| {- last_refreshed.roots == request.roots- && last_refreshed.configured_plugin_keys- == request.configured_plugin_keys- && last_refreshed.configured_plugin_sources- == request.configured_plugin_sources- }))+ if state.requested.as_ref().is_some_and(|requested| {+ requested == &request+ || (requested.git_mode == PluginGitMode::Manual+ && request.git_mode == PluginGitMode::Automatic+ && requested.roots == request.roots+ && requested.configured_plugin_keys == request.configured_plugin_keys+ && requested.configured_plugin_sources == request.configured_plugin_sources+ && requested.mode == request.mode)+ }) || (request.mode == NonCuratedCacheRefreshMode::IfVersionChanged+ && !state.in_flight+ && state.last_refreshed.as_ref().is_some_and(|last_refreshed| {+ last_refreshed.roots == request.roots+ && last_refreshed.configured_plugin_keys == request.configured_plugin_keys+ && last_refreshed.configured_plugin_sources+ == request.configured_plugin_sources+ && (last_refreshed.git_mode == request.git_mode+ || last_refreshed.git_mode == PluginGitMode::Manual)+ })){return;}@@ -2819,6 +2856,7 @@ impl PluginsManager {self.codex_home.as_path(),&request.roots,&request.configured_plugin_keys,+ request.git_mode,)}NonCuratedCacheRefreshMode::ForceReinstall => {@@ -2826,6 +2864,7 @@ impl PluginsManager {self.codex_home.as_path(),&request.roots,&request.configured_plugin_keys,+ request.git_mode,)}};diff --git a/codex-rs/core-plugins/src/manager_tests.rs b/codex-rs/core-plugins/src/manager_tests.rsindex a6570c9602..e12a1719c8 100644--- a/codex-rs/core-plugins/src/manager_tests.rs+++ b/codex-rs/core-plugins/src/manager_tests.rs@@ -6197,6 +6197,106 @@ enabled = true);}+#[tokio::test]+async fn non_curated_plugin_cache_refresh_preserves_manual_priority() {+ let codex_home = TempDir::new().unwrap();+ let marketplace_root = codex_home.path().join("marketplace");+ fs::create_dir_all(marketplace_root.join(".git")).unwrap();+ write_plugin_with_version(+ &marketplace_root,+ "sample-plugin",+ "sample-plugin",+ Some("1.0.0"),+ );+ write_file(+ &marketplace_root.join(".agents/plugins/marketplace.json"),+ r#"{+ "name": "debug",+ "plugins": [{+ "name": "sample-plugin",+ "source": { "source": "local", "path": "./sample-plugin" }+ }]+}"#,+ );+ write_file(+ &codex_home.path().join(CONFIG_TOML_FILE),+ r#"[features]+plugins = true++[plugins."sample-plugin@debug"]+enabled = true+"#,+ );+ let config = load_plugins_config_input(codex_home.path(), &marketplace_root).await;+ let roots = [AbsolutePathBuf::try_from(marketplace_root.clone()).unwrap()];+ let manager = Arc::new(test_plugins_manager(codex_home.path().to_path_buf()));+ manager+ .non_curated_cache_refresh_state+ .write()+ .expect("refresh state lock")+ .in_flight = true;++ for git_mode in [+ PluginGitMode::Automatic,+ PluginGitMode::Manual,+ PluginGitMode::Automatic,+ ] {+ manager.schedule_non_curated_plugin_cache_refresh(+ &config,+ &roots,+ NonCuratedCacheRefreshMode::IfVersionChanged,+ git_mode,+ );+ }++ {+ let mut state = manager+ .non_curated_cache_refresh_state+ .write()+ .expect("refresh state lock");+ assert!(matches!(+ state.requested.as_ref().map(|request| request.git_mode),+ Some(PluginGitMode::Manual)+ ));+ state.last_refreshed = state.requested.take();+ state.in_flight = false;+ }++ manager.maybe_start_non_curated_plugin_cache_refresh(&config, &roots);++ {+ let mut state = manager+ .non_curated_cache_refresh_state+ .write()+ .expect("refresh state lock");+ assert!(!state.in_flight);+ assert!(state.requested.is_none());+ state.requested = state.last_refreshed.clone();+ state.in_flight = true;+ }++ write_plugin_with_version(+ &marketplace_root,+ "sample-plugin",+ "sample-plugin",+ Some("2.0.0"),+ );+ manager.maybe_start_non_curated_plugin_cache_refresh(&config, &roots);++ let state = manager+ .non_curated_cache_refresh_state+ .read()+ .expect("refresh state lock");+ let request = state.requested.as_ref().expect("pending refresh");+ assert!(matches!(request.git_mode, PluginGitMode::Automatic));+ assert_eq!(+ request.configured_plugin_sources[0]+ .local_version+ .as_deref(),+ Some("2.0.0")+ );+}+#[test]fn refresh_non_curated_plugin_cache_reinstalls_missing_configured_plugin_with_manifest_version() {let tmp = tempfile::tempdir().unwrap();diff --git a/codex-rs/core-plugins/src/marketplace_upgrade.rs b/codex-rs/core-plugins/src/marketplace_upgrade.rsindex fc60349a5c..18225ae8c2 100644--- a/codex-rs/core-plugins/src/marketplace_upgrade.rs+++ b/codex-rs/core-plugins/src/marketplace_upgrade.rs@@ -6,6 +6,7 @@ use self::activation::installed_marketplace_metadata_matches;use self::activation::write_installed_marketplace_metadata;use self::git::clone_git_source;use self::git::git_remote_revision;+use crate::PluginGitMode;use crate::installed_marketplaces::marketplace_install_root;use crate::marketplace::validate_marketplace_root;use crate::marketplace_add::MarketplaceSource;@@ -72,6 +73,21 @@ pub fn upgrade_configured_git_marketplaces(codex_home: &Path,config_layer_stack: &ConfigLayerStack,marketplace_name: Option<&str>,+) -> ConfiguredMarketplaceUpgradeOutcome {+ upgrade_configured_git_marketplaces_with_mode(+ codex_home,+ config_layer_stack,+ marketplace_name,+ PluginGitMode::Manual,+ )+}++/// Applies the initiating operation's Git trust policy to every selected marketplace.+pub(crate) fn upgrade_configured_git_marketplaces_with_mode(+ codex_home: &Path,+ config_layer_stack: &ConfigLayerStack,+ marketplace_name: Option<&str>,+ mode: PluginGitMode,) -> ConfiguredMarketplaceUpgradeOutcome {let loaded = load_configured_git_marketplaces(config_layer_stack);let marketplaces = loaded@@ -118,6 +134,7 @@ pub fn upgrade_configured_git_marketplaces(&install_root,&marketplace,normalized_source.as_ref(),+ mode,) {Ok(Some(upgraded_root)) => upgraded_roots.push(upgraded_root),Ok(None) => {}@@ -208,6 +225,7 @@ fn upgrade_configured_git_marketplace(install_root: &Path,marketplace: &ConfiguredGitMarketplace,normalized_source: Option<&MarketplaceSource>,+ mode: PluginGitMode,) -> Result<Option<AbsolutePathBuf>, String> {validate_plugin_segment(&marketplace.name, "marketplace name")?;let (source, ref_name) = match normalized_source {@@ -217,7 +235,13 @@ fn upgrade_configured_git_marketplace(}None => (marketplace.source.as_str(), marketplace.ref_name.as_deref()),};- let remote_revision = git_remote_revision(source, ref_name, MARKETPLACE_UPGRADE_GIT_TIMEOUT)?;+ let remote_revision = git_remote_revision(+ codex_home,+ source,+ ref_name,+ MARKETPLACE_UPGRADE_GIT_TIMEOUT,+ mode,+ )?;let destination = install_root.join(&marketplace.name);if validate_marketplace_root(&destination).is_ok_and(|marketplace_name| marketplace_name == marketplace.name)@@ -245,11 +269,13 @@ fn upgrade_configured_git_marketplace(})?;let activated_revision = clone_git_source(+ codex_home,source,ref_name,&marketplace.sparse_paths,staged_dir.path(),MARKETPLACE_UPGRADE_GIT_TIMEOUT,+ mode,)?;let marketplace_name = validate_marketplace_root(staged_dir.path()).map_err(|err| format!("failed to validate upgraded marketplace root: {err}"))?;diff --git a/codex-rs/core-plugins/src/marketplace_upgrade/git.rs b/codex-rs/core-plugins/src/marketplace_upgrade/git.rsindex 2c9b92e267..c35c4444d9 100644--- a/codex-rs/core-plugins/src/marketplace_upgrade/git.rs+++ b/codex-rs/core-plugins/src/marketplace_upgrade/git.rs@@ -1,3 +1,4 @@+use crate::PluginGitMode;use std::path::Path;use std::path::PathBuf;use std::process::Command;@@ -6,9 +7,11 @@ use std::process::Stdio;use std::time::Duration;pub(super) fn git_remote_revision(+ codex_home: &Path,source: &str,ref_name: Option<&str>,timeout: Duration,+ mode: PluginGitMode,) -> Result<String, String> {if let Some(ref_name) = ref_name&& is_full_git_sha(ref_name)@@ -17,8 +20,12 @@ pub(super) fn git_remote_revision(}let ref_name = ref_name.unwrap_or("HEAD");+ let mut command = git_command(mode);+ let _trusted_repository = matches!(mode, PluginGitMode::Automatic)+ .then(|| crate::configure_trusted_git_repository(&mut command, codex_home))+ .transpose()?;let output = run_git_command_with_timeout(- git_command().arg("ls-remote").arg(source).arg(ref_name),+ command.arg("ls-remote").arg(source).arg(ref_name),"git ls-remote marketplace source",timeout,)?;@@ -41,23 +48,29 @@ pub(super) fn git_remote_revision(}pub(super) fn clone_git_source(+ codex_home: &Path,source: &str,ref_name: Option<&str>,sparse_paths: &[String],destination: &Path,timeout: Duration,+ mode: PluginGitMode,) -> Result<String, String> {let git_destination = git_path_arg(destination);+ let mut command = git_command(mode);+ let _trusted_repository = matches!(mode, PluginGitMode::Automatic)+ .then(|| crate::configure_trusted_git_repository(&mut command, codex_home))+ .transpose()?;if sparse_paths.is_empty() {let output = run_git_command_with_timeout(- git_command().arg("clone").arg(source).arg(&git_destination),+ command.arg("clone").arg(source).arg(&git_destination),"git clone marketplace source",timeout,)?;ensure_git_success(&output, "git clone marketplace source")?;if let Some(ref_name) = ref_name {let output = run_git_command_with_timeout(- git_command()+ git_command(mode).arg("-C").arg(&git_destination).arg("checkout")@@ -67,11 +80,11 @@ pub(super) fn clone_git_source()?;ensure_git_success(&output, "git checkout marketplace ref")?;}- return git_worktree_revision(&git_destination, timeout);+ return git_worktree_revision(&git_destination, timeout, mode);}let output = run_git_command_with_timeout(- git_command()+ command.arg("clone").arg("--filter=blob:none").arg("--no-checkout")@@ -82,7 +95,7 @@ pub(super) fn clone_git_source()?;ensure_git_success(&output, "git clone marketplace source")?;- let mut sparse_checkout = git_command();+ let mut sparse_checkout = git_command(mode);sparse_checkout.arg("-C").arg(&git_destination)@@ -97,7 +110,7 @@ pub(super) fn clone_git_source(ensure_git_success(&output, "git sparse-checkout marketplace source")?;let output = run_git_command_with_timeout(- git_command()+ git_command(mode).arg("-C").arg(&git_destination).arg("checkout")@@ -106,12 +119,16 @@ pub(super) fn clone_git_source(timeout,)?;ensure_git_success(&output, "git checkout marketplace ref")?;- git_worktree_revision(&git_destination, timeout)+ git_worktree_revision(&git_destination, timeout, mode)}-fn git_worktree_revision(destination: &Path, timeout: Duration) -> Result<String, String> {+fn git_worktree_revision(+ destination: &Path,+ timeout: Duration,+ mode: PluginGitMode,+) -> Result<String, String> {let output = run_git_command_with_timeout(- git_command()+ git_command(mode).arg("-C").arg(destination).arg("rev-parse")@@ -133,10 +150,9 @@ fn is_full_git_sha(value: &str) -> bool {value.len() == 40 && value.chars().all(|ch| ch.is_ascii_hexdigit())}-fn git_command() -> Command {- let mut command = Command::new("git");+fn git_command(mode: PluginGitMode) -> Command {+ let mut command = mode.command(Path::new("git"));command- .args(["-c", codex_git_utils::SAFE_BARE_REPOSITORY_CONFIG]).env("GIT_OPTIONAL_LOCKS", "0").env("GIT_TERMINAL_PROMPT", "0");command@@ -239,7 +255,7 @@ mod tests {#[test]fn git_command_uses_path_lookup_with_stable_noninteractive_env() {- let command = git_command();+ let command = git_command(crate::PluginGitMode::Automatic);assert_eq!(command.get_program(), OsStr::new("git"));assert_eq!(diff --git a/codex-rs/core-plugins/src/marketplace_upgrade_tests.rs b/codex-rs/core-plugins/src/marketplace_upgrade_tests.rsindex 41f3fd67dd..917303648c 100644--- a/codex-rs/core-plugins/src/marketplace_upgrade_tests.rs+++ b/codex-rs/core-plugins/src/marketplace_upgrade_tests.rs@@ -1,10 +1,12 @@use super::*;+use crate::PluginGitMode;use codex_config::ConfigLayerEntry;use codex_config::ConfigLayerSource;use codex_config::ConfigRequirements;use codex_config::ConfigRequirementsToml;use pretty_assertions::assert_eq;use std::path::Path;+use std::path::PathBuf;use std::process::Command;use tempfile::TempDir;@@ -87,6 +89,134 @@ source = {good_url:?});}+#[test]+fn automatic_marketplace_git_ignores_inherited_repository_configuration() {+ const CHILD_HOME: &str = "CODEX_MARKETPLACE_GIT_ISOLATION_CHILD_HOME";+ const CHILD_SOURCE: &str = "CODEX_MARKETPLACE_GIT_ISOLATION_CHILD_SOURCE";++ if let Some(codex_home) = std::env::var_os(CHILD_HOME) {+ let codex_home = PathBuf::from(codex_home);+ let source = std::env::var(CHILD_SOURCE).expect("read configured marketplace source");+ let config =+ format!("[marketplaces.trusted]\nsource_type = \"git\"\nsource = {source:?}\n");+ std::fs::write(codex_home.join(CONFIG_TOML_FILE), &config).expect("write config");+ let stack = config_layer_stack(&codex_home, &config);+ let outcome = upgrade_configured_git_marketplaces_with_mode(+ &codex_home,+ &stack,+ /*marketplace_name*/ None,+ PluginGitMode::Automatic,+ );+ assert_eq!(+ outcome,+ ConfiguredMarketplaceUpgradeOutcome {+ selected_marketplaces: vec!["trusted".to_string()],+ upgraded_roots: vec![+ AbsolutePathBuf::try_from(+ marketplace_install_root(&codex_home).join("trusted")+ )+ .expect("installed marketplace root"),+ ],+ errors: Vec::new(),+ }+ );+ for (url, mode) in [+ ("global:marketplace", PluginGitMode::Automatic),+ ("manual:marketplace", PluginGitMode::Manual),+ ] {+ let materialized = crate::loader::materialize_marketplace_plugin_source_with_mode(+ &codex_home,+ &crate::marketplace::MarketplacePluginSource::Git {+ url: url.to_string(),+ path: None,+ ref_name: matches!(mode, PluginGitMode::Manual)+ .then(|| "manual-filter".to_string()),+ sha: None,+ },+ mode,+ )+ .expect("materialize automatic or manually installed Git plugin");+ if matches!(mode, PluginGitMode::Manual) {+ assert!(+ std::fs::read_to_string(materialized.path.as_path().join("manual.txt"))+ .expect("read manually filtered checkout")+ .starts_with("git version ")+ );+ }+ }+ return;+ }++ let root = TempDir::new().expect("create temporary directory");+ let project = root.path().join("project");+ let codex_home = project.join("codex-home");+ let remote = root.path().join("remote");+ std::fs::create_dir_all(&codex_home).expect("create Codex home");+ std::fs::create_dir_all(&remote).expect("create remote marketplace");+ init_marketplace_repo(&remote, "trusted");+ run_git(&remote, &["switch", "--create", "manual-filter"]);+ std::fs::write(+ remote.join(".gitattributes"),+ "manual.txt filter=codex-required\n",+ )+ .expect("write required manual checkout filter");+ std::fs::write(remote.join("manual.txt"), "manual checkout")+ .expect("write manual checkout fixture");+ run_git(&remote, &["add", "."]);+ run_git(+ &remote,+ &["commit", "-m", "add required manual checkout filter"],+ );+ run_git(&remote, &["switch", "-"]);+ run_git(&project, &["init", "--quiet"]);++ let source = url::Url::from_directory_path(&remote)+ .expect("remote marketplace URL")+ .to_string();+ let untrusted = url::Url::from_directory_path(root.path().join("missing"))+ .expect("malicious replacement URL")+ .to_string();+ let rewrite_key = format!("url.{untrusted}.insteadOf");+ run_git(&project, &["config", &rewrite_key, &source]);+ std::fs::write(+ root.path().join("global.conf"),+ "[url \"../remote\"]\n\tinsteadOf = global:marketplace\n[protocol \"file\"]\n\tallow = always\n",+ )+ .expect("write global Git configuration");+ std::fs::write(+ root.path().join("system.conf"),+ "[protocol \"file\"]\n\tallow = never\n",+ )+ .expect("write system Git configuration");+ let output = Command::new(std::env::current_exe().expect("locate test binary"))+ .args([+ "--exact",+ "marketplace_upgrade::tests::automatic_marketplace_git_ignores_inherited_repository_configuration",+ "--nocapture",+ ])+ .current_dir(&project)+ .env(CHILD_HOME, &codex_home)+ .env(CHILD_SOURCE, &source)+ .env("GIT_CONFIG_GLOBAL", "../global.conf")+ .env("GIT_CONFIG_SYSTEM", "../system.conf")+ .env("GIT_DIR", project.join(".git"))+ .env("GIT_CONFIG_COUNT", "3")+ .env("GIT_CONFIG_KEY_0", &rewrite_key)+ .env("GIT_CONFIG_VALUE_0", &source)+ .env("GIT_CONFIG_KEY_1", "url.../remote.insteadOf")+ .env("GIT_CONFIG_VALUE_1", "manual:marketplace")+ .env("GIT_CONFIG_KEY_2", "filter.codex-required.smudge")+ .env("GIT_CONFIG_VALUE_2", "git version")+ .output()+ .expect("run marketplace Git isolation regression");+ assert!(+ output.status.success(),+ "marketplace Git isolation failed: {}{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+}+#[test]fn upgrade_uses_validated_source_for_git_operations() {let codex_home = TempDir::new().expect("create Codex home");@@ -124,6 +254,7 @@ ref = "missing-ref"&install_root,&marketplace,Some(&normalized_source),+ PluginGitMode::Manual,).expect("upgrade should use the validated source").expect("marketplace should be upgraded");@@ -168,6 +299,7 @@ fn up_to_date_fast_path_validates_marketplace_name() {&install_root,&marketplace,Some(&normalized_source),+ PluginGitMode::Manual,).expect_err("mismatched marketplace name must not use the up-to-date fast path");diff --git a/codex-rs/core-plugins/src/startup_sync.rs b/codex-rs/core-plugins/src/startup_sync.rsindex eb37df3b03..90b54930af 100644--- a/codex-rs/core-plugins/src/startup_sync.rs+++ b/codex-rs/core-plugins/src/startup_sync.rs@@ -38,28 +38,6 @@ const CURATED_PLUGINS_HTTP_TIMEOUT: Duration = Duration::from_secs(30);const CURATED_PLUGINS_BACKUP_ARCHIVE_TIMEOUT: Duration = Duration::from_secs(30);// Keep this comfortably above a normal sync attempt so we do not race another Codex process.const CURATED_PLUGINS_STALE_TEMP_DIR_MAX_AGE: Duration = Duration::from_secs(10 * 60);-// These variables can redirect Git away from the repository selected by `-C`,-// or inject command-scoped configuration into the sync commands.-const REPOSITORY_LOCAL_GIT_ENVIRONMENT_VARIABLES: &[&str] = &[- "GIT_ALTERNATE_OBJECT_DIRECTORIES",- "GIT_CEILING_DIRECTORIES",- "GIT_COMMON_DIR",- "GIT_CONFIG",- "GIT_CONFIG_COUNT",- "GIT_CONFIG_PARAMETERS",- "GIT_DIR",- "GIT_DISCOVERY_ACROSS_FILESYSTEM",- "GIT_GRAFT_FILE",- "GIT_IMPLICIT_WORK_TREE",- "GIT_INDEX_FILE",- "GIT_NAMESPACE",- "GIT_OBJECT_DIRECTORY",- "GIT_PREFIX",- "GIT_REPLACE_REF_BASE",- "GIT_SHALLOW_FILE",- "GIT_WORK_TREE",-];-#[derive(Debug, Deserialize)]struct GitHubRepositorySummary {default_branch: String,@@ -210,7 +188,7 @@ fn sync_openai_plugins_repo_via_git() -> Result<String, String> {let repo_path = curated_plugins_repo_path(codex_home);let sha_path = codex_home.join(CURATED_PLUGINS_SHA_FILE);- let remote_sha = git_ls_remote_head_sha(git_binary)?;+ let remote_sha = git_ls_remote_head_sha(codex_home, git_binary)?;let local_sha = read_local_git_or_sha_file(&repo_path, &sha_path, git_binary);if local_sha.as_deref() == Some(remote_sha.as_str()) && repo_path.join(".git").is_dir() {@@ -629,8 +607,9 @@ fn read_local_git_or_sha_file(read_sha_file(sha_path)}-fn git_ls_remote_head_sha(git_binary: &Path) -> Result<String, String> {+fn git_ls_remote_head_sha(codex_home: &Path, git_binary: &Path) -> Result<String, String> {let mut command = git_command(git_binary);+ let _trusted_repository = crate::configure_trusted_git_repository(&mut command, codex_home)?;command.arg("ls-remote").arg("https://github.com/openai/plugins.git")@@ -683,14 +662,7 @@ fn git_head_sha(repo_path: &Path, git_binary: &Path) -> Result<String, String> {}fn git_command(git_binary: &Path) -> Command {- let mut command = Command::new(git_binary);- command- .args(["-c", codex_git_utils::SAFE_BARE_REPOSITORY_CONFIG])- .env("GIT_OPTIONAL_LOCKS", "0");- for name in REPOSITORY_LOCAL_GIT_ENVIRONMENT_VARIABLES {- command.env_remove(name);- }- command+ crate::PluginGitMode::Automatic.command(git_binary)}#[cfg(any(target_os = "macos", test))]diff --git a/codex-rs/core-plugins/src/startup_sync_tests.rs b/codex-rs/core-plugins/src/startup_sync_tests.rsindex 7b5a944576..29798ee542 100644--- a/codex-rs/core-plugins/src/startup_sync_tests.rs+++ b/codex-rs/core-plugins/src/startup_sync_tests.rs@@ -1,4 +1,5 @@use super::*;+use crate::git_policy::REPOSITORY_LOCAL_GIT_ENVIRONMENT_VARIABLES;use crate::test_support::RecordingHttpClientSelector;use crate::test_support::recorded_http_client_urls;use pretty_assertions::assert_eq;