Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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, &copy).expect("copy executable");
+ let identity = executable_identity(&executable).await.expect("identity");
+ let copy_identity = executable_identity(&copy).await.expect("copy identity");
+ assert_ne!(identity, copy_identity);
+ assert!(identity.same_contents(&copy_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.rs
index 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(&current_managed_codex_path).await?);
let updated = previous_release != selected_release(daemon)?.1
- || previous_identity != executable_identity(&current_managed_codex_path).await?;
+ || !previous_identity
+ .same_contents(&executable_identity(&current_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.rs
index 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.rs
index 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::Scheduled
if 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.rs
index 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() {