Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Bind executor plugin measurements to the trusted plugin version (#46528)

papayo-oai6cf2ff11b391
diff --git a/codex-rs/core-plugins/src/lib.rs b/codex-rs/core-plugins/src/lib.rs
index 20b6fc0e47..c67f33e343 100644
--- a/codex-rs/core-plugins/src/lib.rs
+++ b/codex-rs/core-plugins/src/lib.rs
@@ -108,5 +108,6 @@ pub use remote::RecommendedPlugin;
pub use remote::RecommendedPluginsMode;
pub use remote_metadata::remote_catalog_metadata_eq;
pub use script_attribution::PluginCommandAttribution;
+pub use script_attribution::PluginMeasurementTarget;
pub use script_attribution::TrustedPluginRoots;
pub use script_attribution::command_script_arguments;
diff --git a/codex-rs/core-plugins/src/script_attribution.rs b/codex-rs/core-plugins/src/script_attribution.rs
index 97e752d661..9a10ea77bc 100644
--- a/codex-rs/core-plugins/src/script_attribution.rs
+++ b/codex-rs/core-plugins/src/script_attribution.rs
@@ -16,6 +16,7 @@ use crate::startup_sync::read_curated_plugins_sha;
use crate::store::DEFAULT_PLUGIN_VERSION;
use crate::store::PluginStore;
use crate::store::plugin_version_for_source;
+use crate::store::validate_plugin_version_segment;
use codex_exec_server::ExecutorFileSystem;
use codex_exec_server::GetMetadataOptions;
use codex_exec_server::ReadFileOptions;
@@ -25,6 +26,7 @@ use codex_shell_command::bash::extract_bash_command;
use codex_shell_command::bash::parse_shell_lc_plain_commands;
use codex_shell_command::parse_command::is_pathish;
use codex_utils_absolute_path::AbsolutePathBuf;
+use codex_utils_path_uri::PathConvention;
use codex_utils_path_uri::PathUri;
use std::collections::BTreeMap;
use std::collections::HashSet;
@@ -34,6 +36,7 @@ use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq)]
struct TrustedPluginRoot {
plugin_id: PluginId,
+ version: String,
root: AbsolutePathBuf,
metrics_operations_by_path: BTreeMap<String, PluginMetricsOperation>,
}
@@ -63,7 +66,81 @@ pub struct TrustedPluginRoots {
roots: Vec<TrustedPluginRoot>,
}
+/// An untrusted hint from a canonical executor script path, never authorization.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PluginMeasurementTarget {
+ pub(crate) plugin_id: PluginId,
+ pub(crate) version: String,
+ pub(crate) path_convention: PathConvention,
+}
+
+impl PluginMeasurementTarget {
+ /// Selects one remote plugin using the same command parser as attribution.
+ /// Skip paths outside the remote plugin cache before consulting the executor.
+ pub async fn from_command(
+ command: &[String],
+ cwd: &PathUri,
+ file_system: &dyn ExecutorFileSystem,
+ ) -> Option<Self> {
+ let command = single_plain_command(command)?;
+ let invocation = script_invocation(&command)?;
+ let script = cwd.join(invocation.script).ok()?;
+ Self::from_script_path(&script)?;
+ let script = file_system
+ .canonicalize(&script, /*sandbox*/ None)
+ .await
+ .ok()?;
+ Self::from_script_path(&script)
+ }
+
+ fn from_script_path(script: &PathUri) -> Option<Self> {
+ let path_convention = script.infer_path_convention()?;
+ let native_path = script.inferred_native_path_string();
+ // Normalize only the hint so equivalent Windows paths share preparation.
+ // Store identities must retain the authenticated catalog's spelling.
+ let native_path = match path_convention {
+ PathConvention::Windows => native_path.to_ascii_lowercase(),
+ PathConvention::Posix => native_path,
+ };
+ let components = path_convention
+ .path_segments(&native_path)
+ .collect::<Vec<_>>();
+ let mut candidates = components.windows(6).filter_map(|parts| {
+ if parts[..3] != ["plugins", "cache", REMOTE_GLOBAL_MARKETPLACE_NAME]
+ || parts[4] == DEFAULT_PLUGIN_VERSION
+ {
+ return None;
+ }
+ validate_plugin_version_segment(parts[4]).ok()?;
+ Some(Self {
+ plugin_id: PluginId::new(parts[3].to_owned(), parts[2].to_owned()).ok()?,
+ version: parts[4].to_owned(),
+ path_convention,
+ })
+ });
+ let target = candidates.next()?;
+ candidates.next().is_none().then_some(target)
+ }
+}
+
impl TrustedPluginRoots {
+ /// Adds already-trusted roots, preserving the existing root for each plugin and version.
+ /// Distinct versions remain eligible for exact executor-version matching.
+ pub fn extend(&mut self, other: &Self) {
+ let mut seen = self
+ .roots
+ .iter()
+ .map(|root| (root.plugin_id.as_key(), root.version.clone()))
+ .collect::<HashSet<_>>();
+ self.roots.extend(
+ other
+ .roots
+ .iter()
+ .filter(|root| seen.insert((root.plugin_id.as_key(), root.version.clone())))
+ .cloned(),
+ );
+ }
+
pub fn from_plugin_load_outcome(loaded_plugins: &PluginLoadOutcome, codex_home: &Path) -> Self {
let primary_runtime_marketplace_root = primary_runtime_marketplace_root();
let Ok(store) = PluginStore::try_new(codex_home.to_path_buf()) else {
@@ -85,9 +162,11 @@ impl TrustedPluginRoots {
if plugin.root != expected_root || !expected_root.as_path().is_dir() {
return None;
}
+ let version = expected_root.as_path().file_name()?.to_str()?.to_owned();
let root = expected_root.canonicalize().ok()?;
root.as_path().is_dir().then(|| TrustedPluginRoot {
plugin_id,
+ version,
metrics_operations_by_path: load_plugin_metrics_operations(&root)
.unwrap_or_default(),
root,
@@ -175,6 +254,24 @@ impl TrustedPluginRoots {
command: &[String],
cwd: &AbsolutePathBuf,
) -> Option<PluginCommandAttribution> {
+ self.local_candidate(command, cwd)
+ .map(|candidate| candidate.attribution())
+ }
+
+ /// Resolves one exact command to one trusted manifest-declared operation.
+ pub fn resolve_metrics_operation(
+ &self,
+ command: &[String],
+ cwd: &AbsolutePathBuf,
+ ) -> Option<ResolvedPluginMetricsOperation> {
+ self.local_candidate(command, cwd)?.metrics_operation()
+ }
+
+ fn local_candidate(
+ &self,
+ command: &[String],
+ cwd: &AbsolutePathBuf,
+ ) -> Option<MatchedPluginScript<'_>> {
let command = single_plain_command(command)?;
let invocation = script_invocation(command.as_slice())?;
let script = if Path::new(invocation.script).is_absolute() {
@@ -194,8 +291,8 @@ impl TrustedPluginRoots {
.strip_prefix(root.root.as_path())
.ok()
.filter(|relative_path| !relative_path.as_os_str().is_empty())?;
- Some(PluginCommandAttribution {
- plugin_id: root.plugin_id.clone(),
+ Some(MatchedPluginScript {
+ root,
normalized_relative_path: normalized_relative_script_path(relative_path)?,
})
});
@@ -203,58 +300,67 @@ impl TrustedPluginRoots {
matches.next().is_none().then_some(attribution)
}
- /// Resolves one exact command to one trusted manifest-declared operation.
- pub fn resolve_metrics_operation(
+ /// Resolves a trusted script on the selected executor filesystem.
+ ///
+ /// Remote commands can use a path convention that the app-server host cannot
+ /// canonicalize. Resolve aliases on that executor first, then match the
+ /// canonical target to a trusted local plugin script with the same contents.
+ /// Generic attribution accepts matching script bytes across plugin versions.
+ pub async fn resolve_executor_attribution(
&self,
command: &[String],
- cwd: &AbsolutePathBuf,
- ) -> Option<ResolvedPluginMetricsOperation> {
- let attribution = self.resolve_attribution(command, cwd)?;
- self.metrics_operation_for_attribution(attribution)
+ cwd: &PathUri,
+ file_system: &dyn ExecutorFileSystem,
+ ) -> Option<PluginCommandAttribution> {
+ self.executor_candidate(command, cwd, file_system, PluginVersionMatch::Any)
+ .await
+ .map(|candidate| candidate.matched.attribution())
}
- fn metrics_operation_for_attribution(
+ /// Resolves one trusted executor script to one manifest-declared operation,
+ /// requiring the executor's version to match the trusted declaration's version.
+ pub async fn resolve_metrics_operation_in_filesystem(
&self,
- attribution: PluginCommandAttribution,
+ command: &[String],
+ cwd: &PathUri,
+ file_system: &dyn ExecutorFileSystem,
) -> Option<ResolvedPluginMetricsOperation> {
- let mut matches = self.roots.iter().filter_map(|root| {
- (root.plugin_id == attribution.plugin_id)
- .then(|| {
- root.metrics_operations_by_path
- .get(&attribution.normalized_relative_path)
- })
- .flatten()
- });
- let operation = matches.next()?.clone();
- matches
- .next()
- .is_none()
- .then_some(ResolvedPluginMetricsOperation {
- plugin_id: attribution.plugin_id,
- operation,
- })
+ self.executor_candidate(command, cwd, file_system, PluginVersionMatch::Exact)
+ .await?
+ .matched
+ .metrics_operation()
}
- /// Resolves a trusted script on the selected executor filesystem.
- ///
- /// Remote commands can use a path convention that the app-server host cannot
- /// canonicalize. Match the target-native path to one trusted local plugin
- /// script, then require the executor-side file to have the same contents.
- pub async fn resolve_executor_attribution(
+ async fn executor_candidate(
&self,
command: &[String],
cwd: &PathUri,
file_system: &dyn ExecutorFileSystem,
- ) -> Option<PluginCommandAttribution> {
+ version_match: PluginVersionMatch,
+ ) -> Option<ExecutorAttributionCandidate<'_>> {
+ if self.roots.is_empty() {
+ return None;
+ }
let command = single_plain_command(command)?;
let invocation = script_invocation(command.as_slice())?;
let script = cwd.join(invocation.script).ok()?;
- let candidate = self.local_candidate_for_executor_script(&script)?;
+ // Preserve known script suffixes (including directory aliases), but avoid
+ // an executor round trip for unrelated workspace scripts.
+ let suffixes = normalized_script_suffixes(&script);
+ if !self.roots.iter().any(|root| {
+ suffixes.iter().any(|suffix| {
+ executor_plugin_root_matches(&script, root, suffix, PluginVersionMatch::Any)
+ || root.root.join(suffix).as_path().is_file()
+ })
+ }) {
+ return None;
+ }
let script = file_system
.canonicalize(&script, /*sandbox*/ None)
.await
.ok()?;
- if !executor_plugin_root_matches(&script, &candidate.attribution) {
+ let candidates = self.local_candidates_for_executor_script(&script, version_match);
+ if candidates.is_empty() {
return None;
}
let metadata = file_system
@@ -265,62 +371,98 @@ impl TrustedPluginRoots {
)
.await
.ok()?;
- if !metadata.is_file || metadata.size != candidate.contents.len() as u64 {
+ if !metadata.is_file
+ || !candidates
+ .iter()
+ .any(|candidate| metadata.size == candidate.contents.len() as u64)
+ {
return None;
}
let contents = file_system
.read_file(&script, ReadFileOptions::default(), /*sandbox*/ None)
.await
.ok()?;
- (contents == candidate.contents).then_some(candidate.attribution)
- }
-
- /// Resolves one trusted executor script to one manifest-declared operation.
- pub async fn resolve_metrics_operation_in_filesystem(
- &self,
- command: &[String],
- cwd: &PathUri,
- file_system: &dyn ExecutorFileSystem,
- ) -> Option<ResolvedPluginMetricsOperation> {
- let attribution = self
- .resolve_executor_attribution(command, cwd, file_system)
- .await?;
- self.metrics_operation_for_attribution(attribution)
+ let mut matches = candidates
+ .into_iter()
+ .filter(|candidate| contents == candidate.contents);
+ let candidate = matches.next()?;
+ match version_match {
+ PluginVersionMatch::Any => matches
+ .all(|other| other.matched.attribution() == candidate.matched.attribution())
+ .then_some(candidate),
+ PluginVersionMatch::Exact => matches.next().is_none().then_some(candidate),
+ }
}
- fn local_candidate_for_executor_script(
+ fn local_candidates_for_executor_script(
&self,
script: &PathUri,
- ) -> Option<ExecutorAttributionCandidate> {
+ version_match: PluginVersionMatch,
+ ) -> Vec<ExecutorAttributionCandidate<'_>> {
let suffixes = normalized_script_suffixes(script);
- let mut matches = self.roots.iter().filter_map(|root| {
- let (script, normalized_relative_path) = suffixes.iter().find_map(|suffix| {
- let script = root.root.join(suffix).canonicalize().ok()?;
- let relative_path = script.as_path().strip_prefix(root.root.as_path()).ok()?;
- if !script.as_path().is_file() {
- return None;
- }
- let normalized_relative_path = normalized_relative_script_path(relative_path)?;
- Some((script, normalized_relative_path))
- })?;
- Some(ExecutorAttributionCandidate {
- attribution: PluginCommandAttribution {
- plugin_id: root.plugin_id.clone(),
- normalized_relative_path,
- },
- contents: std::fs::read(script.as_path()).ok()?,
+ self.roots
+ .iter()
+ .filter_map(|root| {
+ let (script, normalized_relative_path) = suffixes.iter().find_map(|suffix| {
+ if !executor_plugin_root_matches(script, root, suffix, version_match) {
+ return None;
+ }
+ let script = root.root.join(suffix).canonicalize().ok()?;
+ let relative_path = script.as_path().strip_prefix(root.root.as_path()).ok()?;
+ if !script.as_path().is_file() {
+ return None;
+ }
+ let normalized_relative_path = normalized_relative_script_path(relative_path)?;
+ Some((script, normalized_relative_path))
+ })?;
+ Some(ExecutorAttributionCandidate {
+ matched: MatchedPluginScript {
+ root,
+ normalized_relative_path,
+ },
+ contents: std::fs::read(script.as_path()).ok()?,
+ })
})
- });
- let candidate = matches.next()?;
- matches.next().is_none().then_some(candidate)
+ .collect()
+ }
+}
+
+struct MatchedPluginScript<'a> {
+ root: &'a TrustedPluginRoot,
+ normalized_relative_path: String,
+}
+
+impl MatchedPluginScript<'_> {
+ fn attribution(&self) -> PluginCommandAttribution {
+ PluginCommandAttribution {
+ plugin_id: self.root.plugin_id.clone(),
+ normalized_relative_path: self.normalized_relative_path.clone(),
+ }
+ }
+
+ fn metrics_operation(&self) -> Option<ResolvedPluginMetricsOperation> {
+ Some(ResolvedPluginMetricsOperation {
+ plugin_id: self.root.plugin_id.clone(),
+ operation: self
+ .root
+ .metrics_operations_by_path
+ .get(&self.normalized_relative_path)?
+ .clone(),
+ })
}
}
-struct ExecutorAttributionCandidate {
- attribution: PluginCommandAttribution,
+struct ExecutorAttributionCandidate<'a> {
+ matched: MatchedPluginScript<'a>,
contents: Vec<u8>,
}
+#[derive(Clone, Copy)]
+enum PluginVersionMatch {
+ Any,
+ Exact,
+}
+
fn normalized_script_suffixes(script: &PathUri) -> Vec<String> {
let path = script.inferred_native_path_string().replace('\\', "/");
let components = path
@@ -335,24 +477,31 @@ fn normalized_script_suffixes(script: &PathUri) -> Vec<String> {
.collect()
}
-fn executor_plugin_root_matches(script: &PathUri, attribution: &PluginCommandAttribution) -> bool {
- let relative_depth = attribution.normalized_relative_path.split('/').count();
+fn executor_plugin_root_matches(
+ script: &PathUri,
+ trusted: &TrustedPluginRoot,
+ relative_path: &str,
+ version_match: PluginVersionMatch,
+) -> bool {
+ let relative_depth = relative_path.split('/').count();
let Some(root) = script.ancestors().nth(relative_depth) else {
return false;
};
- let path = root.inferred_native_path_string().replace('\\', "/");
- let components = path
- .split('/')
- .filter(|component| !component.is_empty())
- .collect::<Vec<_>>();
- let [.., plugins, cache, marketplace, plugin, version] = components.as_slice() else {
+ let Some(cache_parent) = root.ancestors().nth(5) else {
return false;
};
- *plugins == "plugins"
- && *cache == "cache"
- && *marketplace == attribution.plugin_id.marketplace_name.as_str()
- && *plugin == attribution.plugin_id.plugin_name.as_str()
- && !version.is_empty()
+ let Ok(plugin_root) = cache_parent.join(&format!(
+ "plugins/cache/{}/{}",
+ trusted.plugin_id.marketplace_name, trusted.plugin_id.plugin_name
+ )) else {
+ return false;
+ };
+ match version_match {
+ PluginVersionMatch::Any => root.parent().as_ref() == Some(&plugin_root),
+ PluginVersionMatch::Exact => plugin_root
+ .join(&trusted.version)
+ .is_ok_and(|expected| expected == root),
+ }
}
/// Returns the structurally parsed arguments following a single script command.
diff --git a/codex-rs/core-plugins/src/script_attribution_tests.rs b/codex-rs/core-plugins/src/script_attribution_tests.rs
index 8e79f8c630..b4fc63abcf 100644
--- a/codex-rs/core-plugins/src/script_attribution_tests.rs
+++ b/codex-rs/core-plugins/src/script_attribution_tests.rs
@@ -10,15 +10,24 @@ use crate::test_support::TEST_CURATED_PLUGIN_SHA;
use crate::test_support::write_curated_plugin_sha_with;
use crate::test_support::write_openai_api_curated_marketplace;
use crate::test_support::write_openai_curated_marketplace;
+use codex_exec_server::ExecServerError;
+use codex_exec_server::LOCAL_FS;
+use codex_exec_server::NoiseChannelPublicKey;
+use codex_exec_server::NoiseRendezvousConnectBundle;
+use codex_exec_server::NoiseRendezvousConnectProvider;
+use codex_exec_server_test_support::environment_manager_without_environments;
use codex_plugin::PluginLoadOutcome;
use codex_utils_path_uri::PathUri;
use codex_utils_plugins::SkillDiscoveryMode;
+use futures::FutureExt;
+use futures::future::BoxFuture;
use pretty_assertions::assert_eq;
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::collections::HashMap;
use std::collections::HashSet;
use std::fs;
+use std::sync::Arc;
use tempfile::TempDir;
const ENABLED: bool = true;
const DISABLED: bool = false;
@@ -151,6 +160,7 @@ fn resolves_primary_runtime_scripts_from_the_installed_plugin_cache() {
let roots = TrustedPluginRoots {
roots: vec![TrustedPluginRoot {
plugin_id: plugin_id.clone(),
+ version: "0.1.29".to_string(),
metrics_operations_by_path: BTreeMap::new(),
root: plugin_root.canonicalize().expect("canonical plugin root"),
}],
@@ -193,22 +203,20 @@ async fn resolves_relocated_script_through_executor_filesystem() {
let executor = TempDir::new().expect("executor temp dir");
let executor_root = executor
.path()
- .join("plugins/cache/openai-curated/sample/remote-version");
+ .join("plugins/cache/openai-curated/sample")
+ .join(curated_plugin_cache_version(TEST_CURATED_PLUGIN_SHA));
let executor_script = executor_root.join("scripts/run.py");
fs::create_dir_all(executor_script.parent().expect("script parent"))
.expect("create executor scripts");
fs::copy(script.as_path(), &executor_script).expect("copy script to executor");
let cwd = PathUri::from_host_native_path(&executor_root).expect("executor root URI");
- let environment =
- codex_exec_server::Environment::create_for_tests(/*exec_server_url*/ None)
- .expect("local executor environment");
assert_eq!(
roots
.resolve_executor_attribution(
&command(&["python", "scripts/run.py"]),
&cwd,
- environment.get_filesystem().as_ref(),
+ LOCAL_FS.as_ref(),
)
.await,
Some(PluginCommandAttribution {
@@ -223,7 +231,7 @@ async fn resolves_relocated_script_through_executor_filesystem() {
.resolve_executor_attribution(
&command(&["python", "scripts/run.py"]),
&cwd,
- environment.get_filesystem().as_ref(),
+ LOCAL_FS.as_ref(),
)
.await,
None
@@ -232,17 +240,35 @@ async fn resolves_relocated_script_through_executor_filesystem() {
#[test]
fn recognizes_windows_executor_plugin_cache_root() {
- let attribution = PluginCommandAttribution {
+ let reference = TempDir::new().expect("reference root");
+ let trusted = TrustedPluginRoot {
plugin_id: PluginId::parse("presentations@openai-primary-runtime").expect("plugin id"),
- normalized_relative_path:
- "skills/presentations/container_tools/mark_artifact_operation_started.mjs".to_string(),
+ version: "0.1.29".to_string(),
+ root: path(reference.path()),
+ metrics_operations_by_path: BTreeMap::new(),
};
+ let relative_path = "skills/presentations/container_tools/mark_artifact_operation_started.mjs";
let script = PathUri::parse(
"file:///C:/Users/user/.codex/plugins/cache/openai-primary-runtime/presentations/0.1.29/skills/presentations/container_tools/mark_artifact_operation_started.mjs",
)
.expect("Windows script URI");
- assert!(executor_plugin_root_matches(&script, &attribution));
+ assert!(executor_plugin_root_matches(
+ &script,
+ &trusted,
+ relative_path,
+ PluginVersionMatch::Exact,
+ ));
+ let wrong_version = PathUri::parse(
+ "file:///C:/Users/user/.codex/plugins/cache/openai-primary-runtime/presentations/0.1.28/skills/presentations/container_tools/mark_artifact_operation_started.mjs",
+ )
+ .expect("other-version Windows script URI");
+ assert!(!executor_plugin_root_matches(
+ &wrong_version,
+ &trusted,
+ relative_path,
+ PluginVersionMatch::Exact,
+ ));
}
fn assert_invalid_metrics_manifest(codex_home: &Path, root: &AbsolutePathBuf, manifest: &str) {
fs::write(root.join("analytics.yaml"), manifest).expect("write analytics manifest");
@@ -321,17 +347,20 @@ fn trusted_roots_require_verified_curated_or_remote_cache() {
vec![
TrustedPluginRoot {
plugin_id: PluginId::parse("sample@openai-curated").expect("plugin id"),
+ version: curated_plugin_cache_version(TEST_CURATED_PLUGIN_SHA),
metrics_operations_by_path: BTreeMap::new(),
root: root.canonicalize().expect("canonical root"),
},
TrustedPluginRoot {
plugin_id: PluginId::parse("api-sample@openai-api-curated").expect("plugin id"),
+ version: curated_plugin_cache_version(TEST_CURATED_PLUGIN_SHA),
metrics_operations_by_path: BTreeMap::new(),
root: api_root.canonicalize().expect("canonical root"),
},
TrustedPluginRoot {
plugin_id: PluginId::parse("remote-sample@openai-curated-remote")
.expect("plugin id"),
+ version: "1.2.3".to_string(),
metrics_operations_by_path: BTreeMap::new(),
root: remote_root.canonicalize().expect("canonical root"),
},
@@ -651,11 +680,13 @@ fn rejects_ambiguous_commands_overlaps_and_symlink_escapes() {
roots: vec![
TrustedPluginRoot {
plugin_id: PluginId::parse("sample@openai-curated").expect("plugin id"),
+ version: curated_plugin_cache_version(TEST_CURATED_PLUGIN_SHA),
metrics_operations_by_path: BTreeMap::new(),
root: root.canonicalize().expect("canonical root"),
},
TrustedPluginRoot {
plugin_id: PluginId::parse("nested@openai-curated").expect("plugin id"),
+ version: curated_plugin_cache_version(TEST_CURATED_PLUGIN_SHA),
metrics_operations_by_path: BTreeMap::new(),
root: root.join("scripts").canonicalize().expect("nested root"),
},
@@ -688,3 +719,461 @@ fn rejects_ambiguous_commands_overlaps_and_symlink_escapes() {
}
}
}
+
+const REFERENCE_HELPER: &str = "scripts/install-dependencies.sh";
+
+fn reference_metrics_operation(variant: &str) -> PluginMetricsOperation {
+ PluginMetricsOperation {
+ operation_name: "dependency_install".to_string(),
+ measurements: BTreeMap::from([(
+ "duration_ms".to_string(),
+ PluginMeasurementDefinition {
+ enum_dimensions: BTreeMap::from([(
+ "variant".to_string(),
+ BTreeSet::from([variant.to_string()]),
+ )]),
+ },
+ )]),
+ }
+}
+
+fn reference_identity_fixture(root: &Path, variant: &str, contents: &str) -> AbsolutePathBuf {
+ fs::create_dir_all(root.join("scripts")).expect("create reference scripts");
+ fs::write(root.join(REFERENCE_HELPER), contents).expect("write helper");
+ fs::write(
+ root.join("analytics.yaml"),
+ format!(
+ "version: 1\noperations:\n dependency_install:\n path: ./{REFERENCE_HELPER}\n measurements:\n duration_ms:\n dimensions:\n variant: [{variant}]\n"
+ ),
+ )
+ .expect("write operation manifest");
+ path(root).canonicalize().expect("canonical reference root")
+}
+
+fn reference_fixture(bundles: &[(&str, &str, &str, &str)]) -> (TempDir, TrustedPluginRoots) {
+ let home = TempDir::new().expect("references");
+ let roots = TrustedPluginRoots {
+ roots: bundles
+ .iter()
+ .map(|(name, version, variant, contents)| {
+ let root = reference_identity_fixture(
+ &home.path().join(name).join(version),
+ variant,
+ contents,
+ );
+ TrustedPluginRoot {
+ plugin_id: PluginId::parse(&format!("{name}@openai-curated-remote"))
+ .expect("plugin id"),
+ version: version.to_string(),
+ metrics_operations_by_path: load_plugin_metrics_operations(&root)
+ .expect("valid fixture analytics"),
+ root,
+ }
+ })
+ .collect(),
+ };
+ (home, roots)
+}
+
+fn executor_plugin(home: &Path, name: &str, version: &str, contents: &str) -> AbsolutePathBuf {
+ reference_identity_fixture(
+ &home.join(format!(
+ "plugins/cache/openai-curated-remote/{name}/{version}"
+ )),
+ "untrusted_executor_metadata",
+ contents,
+ )
+}
+
+// Check both APIs: ordinary attribution can survive version differences, while
+// measurements must use the exact authenticated declaration (never executor YAML).
+async fn assert_executor_resolution(
+ roots: &TrustedPluginRoots,
+ command: &[String],
+ cwd: &PathUri,
+ plugin_id: &PluginId,
+ variant: Option<&str>,
+) {
+ assert_eq!(
+ roots
+ .resolve_executor_attribution(command, cwd, LOCAL_FS.as_ref())
+ .await,
+ Some(PluginCommandAttribution {
+ plugin_id: plugin_id.clone(),
+ normalized_relative_path: REFERENCE_HELPER.to_string(),
+ }),
+ "attribution for {command:?} at {cwd:?}"
+ );
+ assert_eq!(
+ roots
+ .resolve_metrics_operation_in_filesystem(command, cwd, LOCAL_FS.as_ref())
+ .await,
+ variant.map(|variant| ResolvedPluginMetricsOperation {
+ plugin_id: plugin_id.clone(),
+ operation: reference_metrics_operation(variant),
+ }),
+ "measurements for {command:?} at {cwd:?}"
+ );
+}
+
+#[test]
+fn executor_cache_identity_obeys_windows_and_posix_case_conventions() {
+ let (_reference, roots) =
+ reference_fixture(&[("sites", "2.0.0-RC1", "selected", "printf shared\\n\n")]);
+ let plugin_id = PluginId::parse("sites@openai-curated-remote").expect("plugin id");
+ for prefix in ["file:///C:/Users/user/.codex", "file://server/share/.codex"] {
+ let script = PathUri::parse(&format!(
+ "{prefix}/PLUGINS/CACHE/OPENAI-CURATED-REMOTE/SITES/2.0.0-rc1/{REFERENCE_HELPER}"
+ ))
+ .expect("Windows script");
+ let target = PluginMeasurementTarget::from_script_path(&script)
+ .expect("Windows cache preselection follows the resolver's path identity");
+ assert_eq!(
+ target,
+ PluginMeasurementTarget {
+ plugin_id: plugin_id.clone(),
+ version: "2.0.0-rc1".to_string(),
+ path_convention: PathConvention::Windows,
+ }
+ );
+ let equivalent = PathUri::parse(&format!(
+ "{prefix}/plugins/cache/openai-curated-remote/sites/2.0.0-RC1/{REFERENCE_HELPER}"
+ ))
+ .expect("equivalent Windows script");
+ assert_eq!(
+ PluginMeasurementTarget::from_script_path(&equivalent),
+ Some(target)
+ );
+ let candidates =
+ roots.local_candidates_for_executor_script(&script, PluginVersionMatch::Exact);
+ let candidate = candidates
+ .first()
+ .expect("Windows identity casing must not prevent canonicalization");
+ assert_eq!(
+ candidate.matched.metrics_operation(),
+ Some(ResolvedPluginMetricsOperation {
+ plugin_id: plugin_id.clone(),
+ operation: reference_metrics_operation("selected"),
+ })
+ );
+ }
+ for script in [
+ format!(
+ "file:///home/user/.codex/PLUGINS/CACHE/OPENAI-CURATED-REMOTE/SITES/2.0.0-rc1/{REFERENCE_HELPER}"
+ ),
+ format!(
+ "file:///home/user/.codex/plugins/cache/openai-curated-remote/SITES/2.0.0-RC1/{REFERENCE_HELPER}"
+ ),
+ format!(
+ "file:///C:/Users/user/.codex/PLUGINS/CACHE/OPENAI-CURATED-REMOTE/SITES/2.0.0-rc2/{REFERENCE_HELPER}"
+ ),
+ format!(
+ "file:///C:/Users/user/.codex/PLUGINS/CACHE/OPENAI-CURATED-REMOTE/OTHER/2.0.0-rc1/{REFERENCE_HELPER}"
+ ),
+ ] {
+ let script = PathUri::parse(&script).expect("script");
+ let path_convention = script.infer_path_convention().expect("path convention");
+ let expected = PluginMeasurementTarget {
+ plugin_id: plugin_id.clone(),
+ version: match path_convention {
+ PathConvention::Windows => "2.0.0-rc1",
+ PathConvention::Posix => "2.0.0-RC1",
+ }
+ .to_string(),
+ path_convention,
+ };
+ assert_ne!(
+ PluginMeasurementTarget::from_script_path(&script),
+ Some(expected),
+ "preselection must not match a differently cased POSIX identity or another version"
+ );
+ assert!(
+ roots
+ .local_candidates_for_executor_script(&script, PluginVersionMatch::Exact)
+ .is_empty(),
+ "POSIX casing and different Windows versions must remain distinct"
+ );
+ }
+ for version in ["2.0.0-RC1", "2.0.0-rc1"] {
+ let script = PathUri::parse(&format!(
+ "file:///home/user/.codex/plugins/cache/openai-curated-remote/sites/{version}/{REFERENCE_HELPER}"
+ ))
+ .expect("POSIX script");
+ let target =
+ PluginMeasurementTarget::from_script_path(&script).expect("POSIX cache preselection");
+ assert_eq!(
+ target,
+ PluginMeasurementTarget {
+ plugin_id: plugin_id.clone(),
+ version: version.to_string(),
+ path_convention: PathConvention::Posix,
+ }
+ );
+ }
+}
+
+#[test]
+fn extending_trusted_roots_preserves_existing_plugins_and_deduplicates_snapshots() {
+ let contents = "printf shared\\n\n";
+ let (_frontend, mut roots) = reference_fixture(&[("sites", "1.2.3", "primary", contents)]);
+ let original = roots.clone();
+ let (_snapshot, additional) = reference_fixture(&[
+ ("sites", "1.2.3", "copied", contents),
+ ("other", "1.2.3", "additional", contents),
+ ]);
+
+ roots.extend(&additional);
+ let expected = TrustedPluginRoots {
+ roots: vec![original.roots[0].clone(), additional.roots[1].clone()],
+ };
+ assert_eq!(roots, expected);
+ roots.extend(&additional);
+ assert_eq!(roots, expected, "repeated snapshots must remain idempotent");
+}
+
+#[tokio::test]
+async fn authenticated_v2_reference_coexists_with_loaded_frontend_v1() {
+ let frontend = TempDir::new().expect("frontend");
+ let v1 = installed_remote_plugin_root(frontend.path(), "sites");
+ reference_identity_fixture(v1.as_path(), "install_v1", "printf v1\\n\n");
+ let plugin_id = PluginId::parse("sites@openai-curated-remote").expect("plugin id");
+ let mut roots = roots_for(
+ frontend.path(),
+ vec![loaded_plugin(&plugin_id.as_key(), v1.as_path(), ENABLED)],
+ );
+ let (_reference, references) =
+ reference_fixture(&[("sites", "2.0.0", "install_v2", "printf v2\\n\n")]);
+ roots.extend(&references);
+ // The operation must stay bound to the selected root when two versions share
+ // a plugin ID and helper path, for both local and executor resolution.
+ for (root, variant) in [
+ (&v1, "install_v1"),
+ (&references.roots[0].root, "install_v2"),
+ ] {
+ assert_eq!(
+ roots.resolve_metrics_operation(&command(&["sh", REFERENCE_HELPER]), root),
+ Some(ResolvedPluginMetricsOperation {
+ plugin_id: plugin_id.clone(),
+ operation: reference_metrics_operation(variant),
+ })
+ );
+ }
+ let executor = TempDir::new().expect("executor");
+ let root = executor_plugin(executor.path(), "sites", "2.0.0", "printf v2\\n\n");
+ let cwd = PathUri::from_host_native_path(root.as_path()).expect("executor URI");
+ assert_executor_resolution(
+ &roots,
+ &command(&["sh", REFERENCE_HELPER]),
+ &cwd,
+ &plugin_id,
+ Some("install_v2"),
+ )
+ .await;
+}
+
+#[tokio::test]
+async fn same_helper_path_in_two_plugins_resolves_by_executor_identity() {
+ // Identical bytes: neither suffix nor content identifies a plugin.
+ let contents = "printf shared\\n\n";
+ let (_reference, roots) = reference_fixture(&[
+ ("sites", "2.0.0", "sites_install", contents),
+ ("other", "2.0.0", "other_install", contents),
+ ]);
+ let executor = TempDir::new().expect("executor");
+ for (name, variant) in [("sites", "sites_install"), ("other", "other_install")] {
+ let root = executor_plugin(executor.path(), name, "2.0.0", contents);
+ let cwd = PathUri::from_host_native_path(root.as_path()).expect("executor URI");
+ let plugin_id =
+ PluginId::parse(&format!("{name}@openai-curated-remote")).expect("plugin id");
+ assert_executor_resolution(
+ &roots,
+ &command(&["sh", REFERENCE_HELPER]),
+ &cwd,
+ &plugin_id,
+ Some(variant),
+ )
+ .await;
+ }
+}
+
+#[tokio::test]
+async fn identical_script_bytes_do_not_authorize_another_executor_version() {
+ let contents = "printf shared\\n\n";
+ let (_reference, roots) =
+ reference_fixture(&[("sites", "2.0.0", "v2_only_operation", contents)]);
+ let plugin_id = PluginId::parse("sites@openai-curated-remote").expect("plugin id");
+ let executor = TempDir::new().expect("executor");
+ for version in ["1.2.3", "2.0.0"] {
+ let root = executor_plugin(executor.path(), "sites", version, contents);
+ let cwd = PathUri::from_host_native_path(root.as_path()).expect("executor URI");
+ let candidate = command(&["bash", "-lc", &format!("sh {REFERENCE_HELPER}")]);
+ assert_eq!(
+ PluginMeasurementTarget::from_command(&candidate, &cwd, LOCAL_FS.as_ref()).await,
+ Some(PluginMeasurementTarget {
+ plugin_id: plugin_id.clone(),
+ version: version.to_string(),
+ path_convention: PathConvention::native(),
+ })
+ );
+ assert_executor_resolution(
+ &roots,
+ &command(&["sh", REFERENCE_HELPER]),
+ &cwd,
+ &plugin_id,
+ (version == "2.0.0").then_some("v2_only_operation"),
+ )
+ .await;
+ }
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn executor_symlink_cannot_change_authenticated_plugin_or_version() {
+ let contents = "printf shared\\n\n";
+ let (_reference, roots) =
+ reference_fixture(&[("sites", "2.0.0", "v2_only_operation", contents)]);
+ let executor = TempDir::new().expect("executor");
+ let original = executor
+ .path()
+ .join("plugins/cache/openai-curated-remote/sites/2.0.0");
+ fs::create_dir_all(original.join("scripts")).expect("original scripts directory");
+ let cwd = PathUri::from_host_native_path(&original).expect("original executor URI");
+ for target_identity in [
+ "openai-curated-remote/other/2.0.0",
+ "openai-curated-remote/sites/1.2.3",
+ "openai-curated/sites/2.0.0",
+ "../outside-cache",
+ ] {
+ let target = reference_identity_fixture(
+ &executor.path().join("plugins/cache").join(target_identity),
+ "ignored_executor_metadata",
+ contents,
+ );
+ std::os::unix::fs::symlink(
+ target.join(REFERENCE_HELPER),
+ original.join(REFERENCE_HELPER),
+ )
+ .expect("redirect helper to another identity");
+ assert_eq!(
+ roots
+ .resolve_metrics_operation_in_filesystem(
+ &command(&["sh", REFERENCE_HELPER]),
+ &cwd,
+ LOCAL_FS.as_ref(),
+ )
+ .await,
+ None,
+ "canonical identity changed to {target_identity}"
+ );
+ fs::remove_file(original.join(REFERENCE_HELPER)).expect("remove helper symlink");
+ }
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn executor_aliases_use_canonical_plugin_paths() {
+ let contents = "printf shared\\n\n";
+ let (_reference, roots) = reference_fixture(&[
+ ("sites", "1.2.3", "older", contents),
+ ("sites", "2.0.0", "selected", contents),
+ ]);
+ let older_roots = TrustedPluginRoots {
+ roots: vec![roots.roots[0].clone()],
+ };
+ let plugin_id = PluginId::parse("sites@openai-curated-remote").expect("plugin id");
+ let executor = TempDir::new().expect("executor");
+ let target = executor_plugin(executor.path(), "sites", "2.0.0", contents);
+ let alias = executor.path().join("plugin-link");
+ std::os::unix::fs::symlink(target.as_path(), &alias).expect("directory alias");
+ let version_alias = executor
+ .path()
+ .join("plugins/cache/openai-curated-remote/sites/1.2.3/scripts/renamed-entry.sh");
+ fs::create_dir_all(version_alias.parent().expect("alias parent")).expect("V1 alias directory");
+ std::os::unix::fs::symlink(target.join(REFERENCE_HELPER), &version_alias).expect("V1 alias");
+ let cwd = PathUri::from_host_native_path(executor.path()).expect("executor URI");
+ // An already loaded reference still supports directory aliases. Preparation
+ // only probes cache paths, so ordinary workspace scripts need no executor I/O.
+ assert_executor_resolution(
+ &roots,
+ &command(&["sh", &alias.join(REFERENCE_HELPER).to_string_lossy()]),
+ &cwd,
+ &plugin_id,
+ Some("selected"),
+ )
+ .await;
+ let command = command(&["sh", &version_alias.to_string_lossy()]);
+ assert_eq!(
+ PluginMeasurementTarget::from_command(&command, &cwd, LOCAL_FS.as_ref()).await,
+ Some(PluginMeasurementTarget {
+ plugin_id: plugin_id.clone(),
+ version: "2.0.0".to_string(),
+ path_convention: PathConvention::Posix,
+ })
+ );
+ assert_executor_resolution(&roots, &command, &cwd, &plugin_id, Some("selected")).await;
+ assert_eq!(
+ older_roots
+ .resolve_metrics_operation_in_filesystem(&command, &cwd, LOCAL_FS.as_ref())
+ .await,
+ None,
+ "a V1-shaped alias and identical bytes cannot authorize V2 metrics"
+ );
+}
+
+#[tokio::test]
+async fn measurement_target_rejects_inline_commands_and_local_versions() -> anyhow::Result<()> {
+ let executor = TempDir::new()?;
+ let root = reference_identity_fixture(
+ &executor
+ .path()
+ .join("plugins/cache/openai-curated-remote/sites/local"),
+ "ignored",
+ "printf fixture\n",
+ );
+ let cwd = PathUri::from_host_native_path(root.as_path())?;
+ for args in [&["node", "-e", "42"][..], &["sh", REFERENCE_HELPER][..]] {
+ let command = command(args);
+ let fs = codex_exec_server::LOCAL_FS.as_ref();
+ assert_eq!(
+ PluginMeasurementTarget::from_command(&command, &cwd, fs).await,
+ None
+ );
+ }
+ Ok(())
+}
+
+struct UnusedConnectProvider;
+
+impl NoiseRendezvousConnectProvider for UnusedConnectProvider {
+ fn connect_bundle(
+ &self,
+ _: NoiseChannelPublicKey,
+ ) -> BoxFuture<'_, Result<NoiseRendezvousConnectBundle, ExecServerError>> {
+ panic!("unrelated script must not connect to the executor")
+ }
+}
+
+#[tokio::test]
+async fn unrelated_scripts_skip_executor_lookup() -> anyhow::Result<()> {
+ let (_reference, roots) =
+ reference_fixture(&[("sites", "2.0.0", "selected", "printf shared\\n\n")]);
+ let manager = environment_manager_without_environments();
+ let pending = manager.materialize_pending_noise_environment(
+ "tools".to_string(),
+ Arc::new(UnusedConnectProvider),
+ )?;
+ let fs = pending.get_filesystem();
+ let cwd = PathUri::parse("file:///workspace")?;
+ let command = command(&["node", "build.js"]);
+ // An executor lookup waits for provisioning; unrelated scripts must finish immediately.
+ assert_eq!(
+ futures::future::join3(
+ roots.resolve_executor_attribution(&command, &cwd, fs.as_ref()),
+ roots.resolve_metrics_operation_in_filesystem(&command, &cwd, fs.as_ref()),
+ PluginMeasurementTarget::from_command(&command, &cwd, fs.as_ref()),
+ )
+ .now_or_never(),
+ Some((None, None, None)),
+ );
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/plugins.rs b/codex-rs/core/tests/suite/plugins.rs
index b868d1620f..a6498c7a66 100644
--- a/codex-rs/core/tests/suite/plugins.rs
+++ b/codex-rs/core/tests/suite/plugins.rs
@@ -498,6 +498,167 @@ async fn persisted_remote_plugin_command_attribution_flows_through_turn_context(
Ok(())
}
+#[cfg(unix)]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn remote_plugin_measurements_require_the_frontend_version() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ // This fixture needs a real remote transport with separately controlled frontend
+ // and executor caches, rather than the runner's automatic executor selection.
+ let executor = super::multi_exec_server_sandbox::ExecServerProcess::start().await?;
+ let server = start_mock_server().await;
+ let home = Arc::new(TempDir::new()?);
+ let frontend_script = write_remote_plugin_script_and_config(home.as_ref());
+ let script = r#"if [ -n "${CODEX_PLUGIN_METRICS_OUTPUT:-}" ]; then
+ printf '%s' '{"version":1,"measurements":[{"name":"duration_ms","value":7,"dimensions":{"release":"v1"}}]}' > "$CODEX_PLUGIN_METRICS_OUTPUT"
+else
+ printf 'no metrics sidecar\n'
+fi
+"#;
+ std::fs::write(&frontend_script, script)?;
+ std::fs::write(
+ frontend_script
+ .parent()
+ .unwrap()
+ .parent()
+ .unwrap()
+ .join("analytics.yaml"),
+ "version: 1\noperations:\n dependency_install:\n path: ./scripts/run.sh\n measurements:\n duration_ms:\n dimensions:\n release: [v1]\n",
+ )?;
+ let executor_home = TempDir::new()?;
+ let mut responses = Vec::new();
+ for (version, call_id) in [("2.0.0", "wrong-version"), ("1.2.3", "matching-version")] {
+ let root = executor_home.path().join(format!(
+ "plugins/cache/openai-curated-remote/sample/{version}"
+ ));
+ std::fs::create_dir_all(root.join("scripts"))?;
+ let path = root.join("scripts/run.sh");
+ std::fs::write(&path, script)?;
+ // The executor's declaration is never an authority, even for matching bytes.
+ std::fs::write(
+ root.join("analytics.yaml"),
+ "version: 1\noperations: {untrusted: {path: ./scripts/run.sh, measurements: {other: {}}}}\n",
+ )?;
+ // A plugin-shaped alias must use the canonical plugin's identity and version.
+ let alias = executor_home.path().join(format!(
+ "plugins/cache/openai-curated-remote/apparent-plugin/{version}"
+ ));
+ std::fs::create_dir_all(alias.parent().unwrap())?;
+ std::os::unix::fs::symlink(&root, &alias)?;
+ let alias_script = alias.join("scripts/run.sh");
+ let command = shlex::try_join(["/bin/sh", alias_script.to_string_lossy().as_ref()])?;
+ responses.push(sse(vec![
+ ev_response_created(call_id),
+ ev_function_call(
+ call_id,
+ "exec_command",
+ &serde_json::json!({
+ "cmd": command,
+ "login": false,
+ "environment_id": codex_exec_server::REMOTE_ENVIRONMENT_ID,
+ "yield_time_ms": 1000,
+ })
+ .to_string(),
+ ),
+ ev_completed(call_id),
+ ]));
+ }
+ responses.push(sse(vec![
+ ev_response_created("done"),
+ ev_assistant_message("done-message", "done"),
+ ev_completed("done"),
+ ]));
+ let response_mock = mount_sse_sequence(&server, responses).await;
+ let base_url = server.uri();
+ let mut builder = test_codex()
+ .with_exec_server_url(executor.websocket_url.clone())
+ .with_home(home)
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_model("gpt-5.2")
+ .with_config(move |config| {
+ config.chatgpt_base_url = base_url;
+ config.analytics_enabled = Some(true);
+ config
+ .features
+ .enable(Feature::SkipHostSkillDiscovery)
+ .unwrap();
+ });
+ let test = builder.build(&server).await?;
+ let manager = test.thread_manager.environment_manager();
+ let remote = manager.default_environment().unwrap();
+ tokio::time::timeout(Duration::from_secs(30), remote.wait_until_ready()).await??;
+ assert!(remote.is_remote());
+ let (sandbox_policy, permission_profile) =
+ turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());
+ test.codex
+ .start_or_steer_turn(
+ TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "run both plugin versions".into(),
+ text_elements: Vec::new(),
+ }])
+ .with_thread_settings(ThreadSettingsOverrides {
+ approval_policy: Some(AskForApproval::Never),
+ sandbox_policy: Some(sandbox_policy),
+ permission_profile,
+ ..Default::default()
+ }),
+ )
+ .await?;
+ for call_id in ["wrong-version", "matching-version"] {
+ let expected = (Some(REMOTE_PLUGIN_CONFIG_NAME), Some("scripts/run.sh"));
+ let begin = wait_for_event_match(&test.codex, |event| match event {
+ EventMsg::ExecCommandBegin(event) if event.call_id == call_id => Some(event.clone()),
+ _ => None,
+ })
+ .await;
+ let end = wait_for_event_match(&test.codex, |event| match event {
+ EventMsg::ExecCommandEnd(event) if event.call_id == call_id => Some(event.clone()),
+ _ => None,
+ })
+ .await;
+ assert_eq!(end.exit_code, 0, "{}", end.aggregated_output);
+ assert_eq!(
+ (begin.plugin_id.as_deref(), begin.script_path.as_deref()),
+ expected
+ );
+ assert_eq!(
+ (end.plugin_id.as_deref(), end.script_path.as_deref()),
+ expected
+ );
+ }
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ assert!(
+ response_mock
+ .function_call_output_text("wrong-version")
+ .unwrap()
+ .contains("no metrics sidecar")
+ );
+ let event = wait_for_analytics_event(&server, "codex_plugin_measurement_event").await;
+ assert_eq!(
+ serde_json::json!({
+ "plugin_id": event["event_params"]["plugin_id"],
+ "operation": event["event_params"]["operation"],
+ "measurement_name": event["event_params"]["measurement_name"],
+ "number_value": event["event_params"]["number_value"],
+ "dimensions": event["event_params"]["dimensions"],
+ "thread_id": event["event_params"]["thread_id"],
+ "item_id": event["event_params"]["item_id"],
+ }),
+ serde_json::json!({
+ "plugin_id": REMOTE_PLUGIN_CONFIG_NAME,
+ "operation": "dependency_install",
+ "measurement_name": "duration_ms",
+ "number_value": 7.0,
+ "dimensions": {"release": "v1"},
+ "thread_id": test.session_configured.thread_id.to_string(),
+ "item_id": "matching-version",
+ })
+ );
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn thread_disabled_plugins_filter_skills_and_tools_without_changing_shared_plugins()
-> Result<()> {
diff --git a/codex-rs/login/BUILD.bazel b/codex-rs/login/BUILD.bazel
index 42c5385c53..561176b3ed 100644
--- a/codex-rs/login/BUILD.bazel
+++ b/codex-rs/login/BUILD.bazel
@@ -8,4 +8,5 @@ codex_rust_crate(
"src/assets/success_legacy.html",
],
crate_name = "codex_login",
+ unit_test_timeout = "long",
)