Add explicit daemon package replacement from the CLI (#45580)

## What changed

Add `codex app-server daemon update --from-cli` to copy and pin the invoking CLI's complete package, including downgrades and local builds. Require interactive confirmation or `--yes`, and warn that restarting a running daemon may interrupt work.

Validate and stage the package before stopping the daemon, recheck the selection and running state after confirmation, and restart only a previously running daemon. Migrate legacy daemon installations to the dedicated package directory while preserving the standalone CLI selection. Explicit replacements disable automatic package updates.

## Testing

Add coverage for cancellation, packages changed during confirmation, version pinning, and legacy migration. Extend CLI integration tests to verify noninteractive confirmation requirements, rejection of incomplete packages without stopping the daemon, and successful replacement and restart.

GitOrigin-RevId: 2d971d6f0259aa576a15a8b115ca9d0e89060fdf
This commit is contained in:
Eric Traut authored and copyberry committed 2026-09-15 02:35:59 +00:00
1 parent 19286b8819
commit fc269b66ad
10 files changed
+625 -79

No files matched your search

+118 -17
View File
@@ -324,11 +324,17 @@ fn manual_update_rejects_an_unowned_installation() -> Result<()> {
Ok(())
}
fn packaged_daemon_launch(action: &str) -> Result<()> {
#[derive(Clone, Copy, PartialEq, Eq)]
enum InitialDaemon {
Missing,
Legacy,
}
fn packaged_daemon_launch(action: &str, initial: InitialDaemon) -> Result<()> {
use std::os::unix::fs::PermissionsExt;
let mut daemon = TestDaemon::new()?;
let standalone = daemon.home.path().join("packages/standalone");
let package = if action == "start" {
let package = if action == "start" && initial == InitialDaemon::Missing {
standalone.join("releases/caller")
} else {
daemon.home.path().join("cli-package")
@@ -363,13 +369,15 @@ fn packaged_daemon_launch(action: &str) -> Result<()> {
"version": env!("CARGO_PKG_VERSION"), "target": target, "entrypoint": "bin/codex"
}))?,
)?;
if action == "start" {
if action == "start" && initial == InitialDaemon::Missing {
std::fs::remove_file(standalone.join("current"))?;
std::os::unix::fs::symlink(&package, standalone.join("current"))?;
}
let cli_selection = standalone.join("current").canonicalize()?;
let state = daemon.home.path().join("app-server-daemon");
std::fs::remove_file(state.join("app-server.stderr.log"))?;
if initial == InitialDaemon::Missing {
std::fs::remove_file(state.join("app-server.stderr.log"))?;
}
std::fs::write(
state.join("settings.json"),
br#"{"shutdownGraceSeconds":0}"#,
@@ -384,29 +392,117 @@ fn packaged_daemon_launch(action: &str) -> Result<()> {
"{}",
String::from_utf8_lossy(&result.stderr)
);
assert!(String::from_utf8_lossy(&result.stderr).contains("Installing daemon from CLI version"));
assert_eq!(
String::from_utf8_lossy(&result.stderr).contains("Installing daemon from CLI version"),
initial == InitialDaemon::Missing
);
let output: Value = serde_json::from_slice(&result.stdout)?;
let dedicated = daemon
.home
.path()
.canonicalize()?
.join("packages/app-server-daemon");
let (initial_root, initial_pid_file) = match initial {
InitialDaemon::Missing => (&dedicated, "daemon.pid"),
InitialDaemon::Legacy => (&standalone, "app-server.pid"),
};
assert_eq!(
output["managedCodexPath"],
dedicated
initial_root
.canonicalize()?
.join("current/bin/codex")
.to_str()
.context("managed path is not UTF-8")?
);
assert_eq!(
std::fs::read(dedicated.join("current/codex-path/rg"))?,
b"runtime fixture"
);
assert_eq!(daemon.codex.canonicalize()?, cli_before);
assert_eq!(standalone.join("current").canonicalize()?, cli_selection);
assert!(state.join("daemon.pid").exists());
assert!(!state.join("app-server.pid").exists());
assert!(!state.join("app-server-updater.pid").exists());
assert!(state.join(initial_pid_file).exists());
let legacy_updater = match initial {
InitialDaemon::Missing => {
assert!(!state.join("app-server-updater.pid").exists());
None
}
InitialDaemon::Legacy => Some(daemon.pid("app-server-updater.pid")?),
};
if action == "start" {
let initial_current = initial_root.join("current");
let current = dedicated.join("current");
let original = initial_current.canonicalize()?;
let original_pid = daemon.pid(initial_pid_file)?;
let settings_before = std::fs::read(state.join("settings.json"))?;
let refused = daemon
.command()
.args(["app-server", "daemon", "update", "--from-cli"])
.output()?;
assert!(!refused.status.success());
assert!(String::from_utf8_lossy(&refused.stderr).contains("rerun with --yes"));
assert_eq!(daemon.pid(initial_pid_file)?, original_pid);
assert_eq!(initial_current.canonicalize()?, original);
if initial == InitialDaemon::Legacy {
assert!(!current.exists());
}
std::fs::remove_file(package.join("bin/codex-code-mode-host"))?;
let invalid = daemon
.command()
.args(["app-server", "daemon", "update", "--from-cli", "--yes"])
.output()?;
assert!(!invalid.status.success());
assert_eq!(daemon.pid(initial_pid_file)?, original_pid);
assert_eq!(initial_current.canonicalize()?, original);
if initial == InitialDaemon::Legacy {
assert!(!current.exists());
}
std::fs::write(
package.join("bin/codex-code-mode-host"),
b"replacement helper",
)?;
std::fs::set_permissions(
package.join("bin/codex-code-mode-host"),
std::fs::Permissions::from_mode(0o755),
)?;
let replaced = daemon
.command()
.args(["app-server", "daemon", "update", "--from-cli", "--yes"])
.output()?;
ensure!(
replaced.status.success(),
"{}",
String::from_utf8_lossy(&replaced.stderr)
);
let output: Value = serde_json::from_slice(&replaced.stdout)?;
assert_eq!(output["status"], "updated");
assert_ne!(daemon.pid("daemon.pid")?, original_pid);
wait_for_exit(original_pid)?;
if let Some(pid) = legacy_updater {
wait_for_exit(pid)?;
}
assert!(!state.join("app-server.pid").exists());
assert!(!state.join("app-server-updater.pid").exists());
assert_eq!(
output["managedCodexPath"],
current
.join("bin/codex")
.to_str()
.context("managed path is not UTF-8")?
);
assert_ne!(current.canonicalize()?, original);
assert!(!dedicated.join("auto-update-version").exists());
assert_eq!(std::fs::read(state.join("settings.json"))?, settings_before);
assert_eq!(
std::fs::read(current.join("bin/codex-code-mode-host"))?,
b"replacement helper"
);
if initial == InitialDaemon::Missing {
assert_eq!(
std::fs::read(original.join("bin/codex-code-mode-host"))?,
b"runtime fixture"
);
}
assert_eq!(daemon.lifecycle("start")?["status"], "alreadyRunning");
assert_eq!(daemon.lifecycle("stop")?["status"], "stopped");
assert_eq!(standalone.join("current").canonicalize()?, cli_selection);
}
if action == "bootstrap" {
assert_eq!(output["autoUpdateEnabled"], false);
}
@@ -414,16 +510,21 @@ fn packaged_daemon_launch(action: &str) -> Result<()> {
}
#[test]
fn packaged_daemon_start_seeds_local_package() -> Result<()> {
packaged_daemon_launch("start")
fn packaged_daemon_start_and_explicit_replacement() -> Result<()> {
packaged_daemon_launch("start", InitialDaemon::Missing)
}
#[test]
fn packaged_daemon_restart_seeds_local_package() -> Result<()> {
packaged_daemon_launch("restart")
packaged_daemon_launch("restart", InitialDaemon::Missing)
}
#[test]
fn packaged_daemon_bootstrap_seeds_local_package() -> Result<()> {
packaged_daemon_launch("bootstrap")
packaged_daemon_launch("bootstrap", InitialDaemon::Missing)
}
#[test]
fn packaged_daemon_explicit_replacement_migrates_running_legacy() -> Result<()> {
packaged_daemon_launch("start", InitialDaemon::Legacy)
}