Lightweight coding agent that runs in your terminal
Rust
Distinguish daemon release identity from executable contents (#50559)
Eric Traut1a169eda1105
diff --git a/codex-rs/app-server-daemon/src/managed_install.rs b/codex-rs/app-server-daemon/src/managed_install.rsindex ce3107fbd5..067ebcabad 100644--- a/codex-rs/app-server-daemon/src/managed_install.rs+++ b/codex-rs/app-server-daemon/src/managed_install.rs@@ -184,6 +184,15 @@ pub(crate) async fn managed_codex_version(codex_bin: &Path) -> Result<String> {#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]pub(crate) struct ExecutableIdentity {digest: [u8; 32],+ // Distinguish release generations whose executable bytes are identical.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ path_digest: Option<[u8; 32]>,+}++impl ExecutableIdentity {+ pub(crate) fn same_contents(&self, other: &Self) -> bool {+ self.digest == other.digest+ }}pub(crate) async fn executable_identity(executable: &Path) -> Result<ExecutableIdentity> {@@ -191,9 +200,12 @@ pub(crate) async fn executable_identity(executable: &Path) -> Result<ExecutableI// Debug executables can be hundreds of MB. Stream the digest off the async// runtime instead of allocating the whole file and blocking a runtime thread.tokio::task::spawn_blocking(move || {- std::fs::File::open(&executable)+ let executable = std::fs::canonicalize(&executable).unwrap_or(executable);+ let mut identity = std::fs::File::open(&executable).and_then(executable_identity_from_reader)- .with_context(|| format!("failed to read executable {}", executable.display()))+ .with_context(|| format!("failed to read executable {}", executable.display()))?;+ identity.path_digest = Some(path_digest(&executable));+ Ok(identity)}).await.context("executable identity task failed")?@@ -206,9 +218,27 @@ pub(crate) fn executable_identity_from_reader(hasher.update_reader(reader)?;Ok(ExecutableIdentity {digest: *hasher.finalize().as_bytes(),+ path_digest: None,})}+fn path_digest(path: &Path) -> [u8; 32] {+ let mut hasher = blake3::Hasher::new();+ #[cfg(unix)]+ {+ use std::os::unix::ffi::OsStrExt;+ hasher.update(path.as_os_str().as_bytes());+ }+ #[cfg(windows)]+ {+ use std::os::windows::ffi::OsStrExt;+ for unit in path.as_os_str().encode_wide() {+ hasher.update(&unit.to_le_bytes());+ }+ }+ *hasher.finalize().as_bytes()+}+fn managed_codex_file_name() -> &'static str {if cfg!(windows) { "codex.exe" } else { "codex" }}diff --git a/codex-rs/app-server-daemon/src/managed_install_tests.rs b/codex-rs/app-server-daemon/src/managed_install_tests.rsindex ce73d8616a..9403dc8baa 100644--- a/codex-rs/app-server-daemon/src/managed_install_tests.rs+++ b/codex-rs/app-server-daemon/src/managed_install_tests.rs@@ -18,7 +18,7 @@ fn rejects_malformed_codex_cli_version_output() {}#[tokio::test]-async fn executable_identity_uses_binary_contents() {+async fn executable_identity_uses_path_and_binary_contents() {let directory = tempfile::tempdir().expect("temporary directory");let executable = directory.path().join("codex");// Span multiple reads, including a partial final buffer, and preserve the@@ -30,9 +30,18 @@ async fn executable_identity_uses_binary_contents() {executable_identity(&executable).await.expect("identity"),ExecutableIdentity {digest: *blake3::hash(contents).as_bytes(),+ path_digest: Some(super::path_digest(+ &std::fs::canonicalize(&executable).expect("canonical executable"),+ )),});}+ let copy = directory.path().join("codex-copy");+ std::fs::copy(&executable, ©).expect("copy executable");+ let identity = executable_identity(&executable).await.expect("identity");+ let copy_identity = executable_identity(©).await.expect("copy identity");+ assert_ne!(identity, copy_identity);+ assert!(identity.same_contents(©_identity));std::fs::write(&executable, &bytes).expect("write executable");let old = executable_identity(&executable).await.expect("identity");bytes[100_000] ^= 1;diff --git a/codex-rs/app-server-daemon/src/manual_update.rs b/codex-rs/app-server-daemon/src/manual_update.rsindex 6bd0b01db0..c0d8269bad 100644--- a/codex-rs/app-server-daemon/src/manual_update.rs+++ b/codex-rs/app-server-daemon/src/manual_update.rs@@ -252,7 +252,8 @@ pub(super) async fn run(let current_managed_codex_path = daemon.current_managed_codex_bin()?;let installed_version = Some(managed_codex_version(¤t_managed_codex_path).await?);let updated = previous_release != selected_release(daemon)?.1- || previous_identity != executable_identity(¤t_managed_codex_path).await?;+ || !previous_identity+ .same_contents(&executable_identity(¤t_managed_codex_path).await?);let running_version = client::probe(&daemon.socket_path).await.ok()diff --git a/codex-rs/app-server-daemon/src/prepare_install.rs b/codex-rs/app-server-daemon/src/prepare_install.rsindex ecf2501d22..88425718b6 100644--- a/codex-rs/app-server-daemon/src/prepare_install.rs+++ b/codex-rs/app-server-daemon/src/prepare_install.rs@@ -236,7 +236,9 @@ async fn prepare_from_package(anyhow::ensure!(package_tree(source, /*destination*/ None)? == digest&& std::fs::read(stage.path().join("codex-package.json"))? == manifest_bytes- && managed_install::executable_identity(&staged_exe).await? == running_identity,+ && managed_install::executable_identity(&staged_exe)+ .await?+ .same_contents(&running_identity),"the CLI package changed while preparing the daemon or differs from the running executable");let binary_version =diff --git a/codex-rs/app-server-daemon/src/update_loop.rs b/codex-rs/app-server-daemon/src/update_loop.rsindex 4dc4adf85f..5e28ad8856 100644--- a/codex-rs/app-server-daemon/src/update_loop.rs+++ b/codex-rs/app-server-daemon/src/update_loop.rs@@ -138,10 +138,9 @@ async fn run_with_http(updater.mark_ready().await?;let needs_managed_handoff =match resolved_managed_codex_bin(&daemon.current_managed_codex_bin()?).await {- Ok(managed_bin) => {- executable_identity(&managed_bin).await.ok().as_ref()- != Some(running_updater_identity)- }+ Ok(managed_bin) => executable_identity(&managed_bin)+ .await+ .map_or(true, |identity| identity != *running_updater_identity),Err(_) => true,};let auto_update_enabled = UpdaterSettings::load(&daemon.settings_file)@@ -341,7 +340,7 @@ async fn update_once(// latest-channel marker. Retry after the interval instead of exiting.return Ok((UpdateLoopControl::Continue, None));}- let (package_root, previous_selection, previous_release) = selected_release(daemon)?;+ let (package_root, _, previous_release) = selected_release(daemon)?;let codex_home = package_root.parent().and_then(Path::parent)@@ -430,20 +429,14 @@ async fn update_once(}),);let restart_mode = match trigger {- // The package can contain different resources even when its CLI binary- // is identical. A release change must also replace the running process.- UpdateTrigger::Manual | UpdateTrigger::RestoreProduction(_)- if selected_release(daemon)?.1 != previous_selection =>- {- RestartMode::Always- }UpdateTrigger::Manual | UpdateTrigger::RestoreProduction(_) => {RestartMode::IfBinaryOrVersionChanged}+ // Updater adoption does not imply daemon replacement.UpdateTrigger::Scheduledif executable_identity(&managed_codex_bin).await? != *running_updater_identity =>{- RestartMode::Always+ RestartMode::IfBinaryOrVersionChanged}UpdateTrigger::Scheduled => RestartMode::IfVersionChanged,};@@ -474,8 +467,7 @@ async fn update_once());}RestartIfRunningOutcome::AlreadyCurrent- if trigger != UpdateTrigger::Scheduled- && restart_mode == RestartMode::IfBinaryOrVersionChanged =>+ if restart_mode == RestartMode::IfBinaryOrVersionChanged =>{anyhow::ensure!(daemon.is_stable_standalone_release()?@@ -488,6 +480,15 @@ async fn update_once(Some(RestartIfRunningOutcome::AlreadyCurrent),));}+ RestartIfRunningOutcome::NotReady+ if trigger == UpdateTrigger::Scheduled+ && restart_mode == RestartMode::IfBinaryOrVersionChanged =>+ {+ return Ok((+ UpdateLoopControl::Continue,+ Some(RestartIfRunningOutcome::NotReady),+ ));+ }RestartIfRunningOutcome::NotReady | RestartIfRunningOutcome::AlreadyCurrent => {anyhow::ensure!(trigger == UpdateTrigger::Scheduled,diff --git a/codex-rs/app-server-daemon/src/update_loop_tests.rs b/codex-rs/app-server-daemon/src/update_loop_tests.rsindex 2f7cd1cfad..8ccfc16803 100644--- a/codex-rs/app-server-daemon/src/update_loop_tests.rs+++ b/codex-rs/app-server-daemon/src/update_loop_tests.rs@@ -15,6 +15,8 @@ use super::manual_update::run as manual_update_once;#[cfg(unix)]use crate::Daemon;#[cfg(unix)]+use crate::RestartIfRunningOutcome;+#[cfg(unix)]use crate::UpdateOutput;#[cfg(unix)]use crate::UpdateStatus;@@ -714,6 +716,92 @@ async fn test_control_server(})}+#[cfg(unix)]+#[tokio::test]+async fn scheduled_no_op_preserves_daemon_and_hands_off_stale_updater() {+ let home = TempDir::new().expect("home");+ let (daemon, _) = manual_update_daemon(&home);+ let settings = crate::settings::DaemonSettings::default();+ let backend = crate::backend::pid_backend(daemon.backend_paths(&settings));+ backend.start().await.expect("start daemon");+ let server = test_control_server(&daemon, home.path()).await;+ let pid_record = std::fs::read(&daemon.pid_file).expect("daemon PID record");+ let no_op = FakeInstallerHttp::new(InstallerResponse::Success(+ b"# CODEX_INSTALL_IF_LATEST\nexit 0\n".to_vec(),+ ));++ let outcome = super::update_once(+ &no_op,+ &daemon,+ &executable_identity_from_reader(&b"stale updater"[..]).expect("updater identity"),+ &mut test_terminate(),+ super::UpdateTrigger::Scheduled,+ )+ .await+ .expect("scheduled update");++ assert!(matches!(+ outcome,+ (+ super::UpdateLoopControl::Continue,+ Some(RestartIfRunningOutcome::AlreadyCurrent)+ )+ ));+ assert_eq!(+ std::fs::read(&daemon.pid_file).expect("daemon PID record"),+ pid_record+ );+ backend.stop().await.expect("stop daemon");+ server.abort();+}++#[cfg(unix)]+#[tokio::test]+async fn scheduled_resource_only_update_restarts_daemon() {+ let home = TempDir::new().expect("home");+ let (daemon, release) = manual_update_daemon(&home);+ let settings = crate::settings::DaemonSettings::default();+ let backend = crate::backend::pid_backend(daemon.backend_paths(&settings));+ backend.start().await.expect("start daemon");+ let server = test_control_server(&daemon, home.path()).await;+ let previous_pid_record = std::fs::read(&daemon.pid_file).expect("daemon PID record");+ let root = home.path().join("packages/standalone");+ let next_release = release.replacen("1.0.0", "1.0.1", 1);+ let installer = FakeInstallerHttp::new(InstallerResponse::Success(+ format!(+ "#!/bin/sh\n# CODEX_INSTALL_IF_LATEST\nmkdir -p '{root}/releases/{next_release}'\ncp '{root}/releases/{release}/codex' '{root}/releases/{next_release}/codex'\nln -sfn 'releases/{next_release}' '{root}/current'\nprintf '{next_release}' > '{root}/auto-update-version'\n",+ root = root.display(),+ )+ .into_bytes(),+ ));++ let outcome = super::update_once(+ &installer,+ &daemon,+ &executable_identity(&daemon.managed_codex_bin)+ .await+ .expect("updater identity"),+ &mut test_terminate(),+ super::UpdateTrigger::Scheduled,+ )+ .await+ .expect("scheduled update");++ assert!(matches!(+ outcome,+ (+ super::UpdateLoopControl::Continue,+ Some(RestartIfRunningOutcome::Restarted)+ )+ ));+ assert_ne!(+ std::fs::read(&daemon.pid_file).expect("daemon PID record"),+ previous_pid_record+ );+ backend.stop().await.expect("stop daemon");+ server.abort();+}+#[cfg(unix)]#[tokio::test]async fn manual_update_restarts_managed_daemon_with_automatic_updates_disabled() {