mirror of
https://github.com/openai/codex.git
synced 2026-11-20 23:08:21 +00:00
Seed missing daemon installs from complete local CLI packages (#45558)
## Why Daemon lifecycle commands previously required a standalone managed installation. A complete CLI package can supply the daemon executable and helpers without requiring a separate installer run. ## What changed - Let `codex app-server daemon start`, `restart`, and `bootstrap` copy the invoking package into `CODEX_HOME/packages/app-server-daemon` when no daemon installation exists. - Validate the package's platform, required helpers, executable identity, and copied contents before selecting the staged release. - Preserve existing dedicated and legacy daemon selections, reject broken selections instead of replacing them, and leave the CLI package and selection unchanged. - Preserve standalone release pins and latest-channel eligibility, and select dedicated releases using Unix symlinks or Windows junctions. ## Testing Add package preparation tests for complete copies, incomplete packages, broken selections, legacy preservation, and update-channel handling. Add Windows junction creation and retargeting coverage, plus CLI integration tests that launch the copied package through `start`, `restart`, and `bootstrap`. GitOrigin-RevId: abd2f4f82eae0885434ea30603c2c1c0ca760bef
This commit is contained in:
1 parent
446b771049
commit
653e5fbb9d
12 files changed
+815
-50
No files matched your search
@@ -5,6 +5,11 @@
|
|||||||
slow-timeout = { period = "30s", terminate-after = 2 }
|
slow-timeout = { period = "30s", terminate-after = 2 }
|
||||||
retries = 1
|
retries = 1
|
||||||
|
|
||||||
|
[[profile.default.overrides]]
|
||||||
|
# These cases copy a full debug CLI package and launch its new executable.
|
||||||
|
filter = 'package(codex-cli) & binary(app_server_daemon) & test(packaged_daemon_)'
|
||||||
|
slow-timeout = { period = "1m", terminate-after = 2 }
|
||||||
|
|
||||||
[profile.default.junit]
|
[profile.default.junit]
|
||||||
path = "junit.xml"
|
path = "junit.xml"
|
||||||
|
|
||||||
|
|||||||
Generated
+2
@@ -2309,11 +2309,13 @@ dependencies = [
|
|||||||
"codex-app-server-protocol",
|
"codex-app-server-protocol",
|
||||||
"codex-app-server-transport",
|
"codex-app-server-transport",
|
||||||
"codex-http-client",
|
"codex-http-client",
|
||||||
|
"codex-install-context",
|
||||||
"codex-uds",
|
"codex-uds",
|
||||||
"codex-utils-home-dir",
|
"codex-utils-home-dir",
|
||||||
"futures",
|
"futures",
|
||||||
"libc",
|
"libc",
|
||||||
"pretty_assertions",
|
"pretty_assertions",
|
||||||
|
"semver",
|
||||||
"serde",
|
"serde",
|
||||||
"serde_json",
|
"serde_json",
|
||||||
"tempfile",
|
"tempfile",
|
||||||
|
|||||||
@@ -17,12 +17,14 @@ anyhow = { workspace = true }
|
|||||||
codex-app-server-protocol = { workspace = true }
|
codex-app-server-protocol = { workspace = true }
|
||||||
codex-app-server-transport = { workspace = true }
|
codex-app-server-transport = { workspace = true }
|
||||||
codex-http-client = { workspace = true }
|
codex-http-client = { workspace = true }
|
||||||
|
codex-install-context = { workspace = true }
|
||||||
codex-utils-home-dir = { workspace = true }
|
codex-utils-home-dir = { workspace = true }
|
||||||
codex-uds = { workspace = true }
|
codex-uds = { workspace = true }
|
||||||
futures = { workspace = true }
|
futures = { workspace = true }
|
||||||
libc = { workspace = true }
|
libc = { workspace = true }
|
||||||
serde = { workspace = true, features = ["derive"] }
|
serde = { workspace = true, features = ["derive"] }
|
||||||
serde_json = { workspace = true }
|
serde_json = { workspace = true }
|
||||||
|
semver = { workspace = true }
|
||||||
blake3 = { workspace = true }
|
blake3 = { workspace = true }
|
||||||
tokio = { workspace = true, features = [
|
tokio = { workspace = true, features = [
|
||||||
"fs",
|
"fs",
|
||||||
|
|||||||
@@ -45,7 +45,7 @@ should parse that JSON rather than relying on human-readable text. Lifecycle
|
|||||||
responses report the resolved backend, socket path, local CLI version, and
|
responses report the resolved backend, socket path, local CLI version, and
|
||||||
running app-server version when applicable.
|
running app-server version when applicable.
|
||||||
|
|
||||||
Standalone-managed daemons check for updates after five minutes, then hourly by
|
Eligible managed daemons check for updates after five minutes, then hourly by
|
||||||
default. Edit `CODEX_HOME/app-server-daemon/settings.json` to change this:
|
default. Edit `CODEX_HOME/app-server-daemon/settings.json` to change this:
|
||||||
|
|
||||||
```json
|
```json
|
||||||
@@ -59,8 +59,9 @@ enabled state; the next updater wait reads a new interval. The preference does
|
|||||||
not affect an explicit `codex update` command or `daemon update`.
|
not affect an explicit `codex update` command or `daemon update`.
|
||||||
|
|
||||||
`daemon update` checks the latest stable release once, even with automatic
|
`daemon update` checks the latest stable release once, even with automatic
|
||||||
updates disabled. It requires a Codex installer-owned latest-channel standalone
|
updates disabled. It requires an installer-owned latest-channel package in either
|
||||||
install. JSON reports `updated`, `noUpdate`, or `unsupported`, with installed
|
the dedicated daemon root or the retained legacy root. JSON reports `updated`,
|
||||||
|
`noUpdate`, or `unsupported`, with installed
|
||||||
and running versions. The updater owns scheduled and manual installs. A manual
|
and running versions. The updater owns scheduled and manual installs. A manual
|
||||||
update restarts a running managed daemon, so active or queued work may be
|
update restarts a running managed daemon, so active or queued work may be
|
||||||
interrupted.
|
interrupted.
|
||||||
@@ -90,17 +91,29 @@ $codexHome = if ($env:CODEX_HOME) { $env:CODEX_HOME } else { Join-Path $HOME '.c
|
|||||||
& "$codexHome\packages\standalone\current\bin\codex.exe" app-server daemon bootstrap --remote-control
|
& "$codexHome\packages\standalone\current\bin\codex.exe" app-server daemon bootstrap --remote-control
|
||||||
```
|
```
|
||||||
|
|
||||||
`bootstrap` requires the standalone managed install. It records the daemon
|
`bootstrap` can use any complete CLI package. If no daemon package is installed,
|
||||||
settings under `CODEX_HOME/app-server-daemon/`, starts app-server as a
|
it copies the invoking package into `CODEX_HOME/packages/app-server-daemon` and
|
||||||
|
prints an installation message without asking for confirmation. Existing daemon
|
||||||
|
packages are reused, including legacy installations; a broken selection is not
|
||||||
|
silently replaced. A bare executable cannot supply a new installation.
|
||||||
|
|
||||||
|
It records the daemon settings under `CODEX_HOME/app-server-daemon/`, starts app-server as a
|
||||||
pidfile-backed detached process. It launches a detached updater loop when
|
pidfile-backed detached process. It launches a detached updater loop when
|
||||||
automatic updates are enabled, the installer selected the stable `latest`
|
automatic updates are enabled, the installer selected the stable `latest`
|
||||||
channel, and the managed binary supports the updater command.
|
channel, and the managed binary supports the updater command.
|
||||||
|
|
||||||
## Installation and update cases
|
## Installation and update cases
|
||||||
|
|
||||||
The daemon uses the standalone installer (`install.sh` on Unix, `install.ps1`
|
New daemons use `CODEX_HOME/packages/app-server-daemon/current/bin/codex`
|
||||||
on Windows) and its managed binary under `CODEX_HOME/packages/standalone/current`:
|
(`codex.exe` on Windows). The package contains the executable and its helpers.
|
||||||
`bin/codex` or `bin/codex.exe`, falling back to the legacy flat layout when present.
|
Daemon-only installer updates leave the user's CLI command and shell setup alone.
|
||||||
|
|
||||||
|
Previously launched legacy daemons retain `CODEX_HOME/packages/standalone/current`,
|
||||||
|
including its flat binary layout when present. Starts and scheduled updates keep
|
||||||
|
using that location. An explicit production update prepares and validates a
|
||||||
|
compatible dedicated package before stopping the legacy updater and daemon,
|
||||||
|
selecting the new package, and restarting only a previously running daemon.
|
||||||
|
The old CLI package files and selection remain unchanged.
|
||||||
|
|
||||||
| Situation | What starts | Does this daemon fetch new binaries? | Does a running app-server eventually move to a newer binary on its own? |
|
| Situation | What starts | Does this daemon fetch new binaries? | Does a running app-server eventually move to a newer binary on its own? |
|
||||||
| --- | --- | --- | --- |
|
| --- | --- | --- | --- |
|
||||||
@@ -108,11 +121,12 @@ on Windows) and its managed binary under `CODEX_HOME/packages/standalone/current
|
|||||||
| Installer selected an explicit release; `bootstrap` is used | Managed binary only | No; the selected release stays pinned. | No; an explicit restart uses the selected binary. |
|
| Installer selected an explicit release; `bootstrap` is used | Managed binary only | No; the selected release stays pinned. | No; an explicit restart uses the selected binary. |
|
||||||
| Another tool updates the managed binary | A fresh start or explicit restart uses it; a running server is reused. | Yes, when a latest-channel updater is running, on the configured cadence. | An updater that was running through the change compares binary contents on its next successful installer pass and refreshes the server first. |
|
| Another tool updates the managed binary | A fresh start or explicit restart uses it; a running server is reused. | Yes, when a latest-channel updater is running, on the configured cadence. | An updater that was running through the change compares binary contents on its next successful installer pass and refreshes the server first. |
|
||||||
|
|
||||||
### Standalone installs
|
### Managed packages
|
||||||
|
|
||||||
For installs created by either platform's standalone installer:
|
For dedicated and retained legacy daemon installations:
|
||||||
|
|
||||||
- lifecycle commands always use the standalone managed binary path
|
- lifecycle commands use the selected daemon package, regardless of the invoking
|
||||||
|
CLI version; they do not implicitly replace an existing package
|
||||||
- `bootstrap` is supported
|
- `bootstrap` is supported
|
||||||
- managed `start`, `restart`, and `bootstrap` ensure a single detached pid-backed
|
- managed `start`, `restart`, and `bootstrap` ensure a single detached pid-backed
|
||||||
updater loop only when automatic updates are enabled for a stable latest-channel
|
updater loop only when automatic updates are enabled for a stable latest-channel
|
||||||
|
|||||||
@@ -6,6 +6,7 @@ use backend::windows::try_lock_file;
|
|||||||
mod client;
|
mod client;
|
||||||
mod install_lock;
|
mod install_lock;
|
||||||
mod managed_install;
|
mod managed_install;
|
||||||
|
mod prepare_install;
|
||||||
mod remote_control_client;
|
mod remote_control_client;
|
||||||
mod settings;
|
mod settings;
|
||||||
mod thread_recovery;
|
mod thread_recovery;
|
||||||
@@ -217,23 +218,22 @@ pub async fn run(command: LifecycleCommand) -> Result<LifecycleOutput> {
|
|||||||
if matches!(command, LifecycleCommand::Start | LifecycleCommand::Restart) {
|
if matches!(command, LifecycleCommand::Start | LifecycleCommand::Restart) {
|
||||||
backend::windows::ensure_not_elevated()?;
|
backend::windows::ensure_not_elevated()?;
|
||||||
}
|
}
|
||||||
Daemon::from_environment()?.run(command).await
|
// Keep daemon package preparation off callers' async stack frames.
|
||||||
|
Box::pin(Daemon::from_environment()?.run(command)).await
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn bootstrap(options: BootstrapOptions) -> Result<BootstrapOutput> {
|
pub async fn bootstrap(options: BootstrapOptions) -> Result<BootstrapOutput> {
|
||||||
ensure_supported_platform()?;
|
ensure_supported_platform()?;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
backend::windows::ensure_not_elevated()?;
|
backend::windows::ensure_not_elevated()?;
|
||||||
Daemon::from_environment()?.bootstrap(options).await
|
Box::pin(Daemon::from_environment()?.bootstrap(options)).await
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn ensure_remote_control_ready() -> Result<RemoteControlReadyOutput> {
|
pub async fn ensure_remote_control_ready() -> Result<RemoteControlReadyOutput> {
|
||||||
ensure_supported_platform()?;
|
ensure_supported_platform()?;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
backend::windows::ensure_not_elevated()?;
|
backend::windows::ensure_not_elevated()?;
|
||||||
Daemon::from_environment()?
|
Box::pin(Daemon::from_environment()?.ensure_remote_control_ready()).await
|
||||||
.ensure_remote_control_ready()
|
|
||||||
.await
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn enable_remote_control_on_socket(
|
pub async fn enable_remote_control_on_socket(
|
||||||
@@ -261,7 +261,7 @@ pub async fn set_remote_control(mode: RemoteControlMode) -> Result<RemoteControl
|
|||||||
ensure_supported_platform()?;
|
ensure_supported_platform()?;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
backend::windows::ensure_not_elevated()?;
|
backend::windows::ensure_not_elevated()?;
|
||||||
Daemon::from_environment()?.set_remote_control(mode).await
|
Box::pin(Daemon::from_environment()?.set_remote_control(mode)).await
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn run_pid_update_loop(
|
pub async fn run_pid_update_loop(
|
||||||
@@ -381,6 +381,7 @@ impl Daemon {
|
|||||||
}
|
}
|
||||||
|
|
||||||
async fn start(&self) -> Result<LifecycleOutput> {
|
async fn start(&self) -> Result<LifecycleOutput> {
|
||||||
|
let mut managed = self.clone();
|
||||||
let settings = self.load_settings().await?;
|
let settings = self.load_settings().await?;
|
||||||
let (status, backend, pid, info) = if let Ok(info) = client::probe(&self.socket_path).await
|
let (status, backend, pid, info) = if let Ok(info) = client::probe(&self.socket_path).await
|
||||||
{
|
{
|
||||||
@@ -402,8 +403,10 @@ impl Daemon {
|
|||||||
if let Err(err) = thread_recovery::discard_pending(self) {
|
if let Err(err) = thread_recovery::discard_pending(self) {
|
||||||
eprintln!("warning: failed to clear stale daemon recovery before start: {err}");
|
eprintln!("warning: failed to clear stale daemon recovery before start: {err}");
|
||||||
}
|
}
|
||||||
self.ensure_managed_codex_bin()?;
|
prepare_install::prepare(self, &settings).await?;
|
||||||
let pid = self.start_managed_backend(&settings).await?;
|
managed.managed_codex_bin = self.current_managed_codex_bin()?;
|
||||||
|
managed.ensure_managed_codex_bin()?;
|
||||||
|
let pid = managed.start_managed_backend(&settings).await?;
|
||||||
(
|
(
|
||||||
LifecycleStatus::Started,
|
LifecycleStatus::Started,
|
||||||
Some(BackendKind::Pid),
|
Some(BackendKind::Pid),
|
||||||
@@ -412,11 +415,11 @@ impl Daemon {
|
|||||||
)
|
)
|
||||||
};
|
};
|
||||||
if backend.is_some()
|
if backend.is_some()
|
||||||
&& let Err(err) = self.ensure_managed_updater(&settings).await
|
&& let Err(err) = managed.ensure_managed_updater(&settings).await
|
||||||
{
|
{
|
||||||
eprintln!("warning: failed to ensure managed updater after app-server start: {err:#}");
|
eprintln!("warning: failed to ensure managed updater after app-server start: {err:#}");
|
||||||
}
|
}
|
||||||
Ok(self
|
Ok(managed
|
||||||
.output(status, backend, pid, Some(info.app_server_version))
|
.output(status, backend, pid, Some(info.app_server_version))
|
||||||
.await)
|
.await)
|
||||||
}
|
}
|
||||||
@@ -430,13 +433,16 @@ impl Daemon {
|
|||||||
"app server is running but is not managed by codex app-server daemon"
|
"app server is running but is not managed by codex app-server daemon"
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
prepare_install::prepare(self, &settings).await?;
|
||||||
|
let mut managed = self.clone();
|
||||||
|
managed.managed_codex_bin = self.current_managed_codex_bin()?;
|
||||||
if !settings.auto_update_enabled {
|
if !settings.auto_update_enabled {
|
||||||
backend::pid_update_loop_backend(self.backend_paths(&settings))
|
backend::pid_update_loop_backend(self.backend_paths(&settings))
|
||||||
.stop()
|
.stop()
|
||||||
.await?;
|
.await?;
|
||||||
}
|
}
|
||||||
|
|
||||||
self.ensure_managed_codex_bin()?;
|
managed.ensure_managed_codex_bin()?;
|
||||||
if let Some(backend) = self.running_backend_instance(&settings).await? {
|
if let Some(backend) = self.running_backend_instance(&settings).await? {
|
||||||
if let Err(err) = thread_recovery::discard_pending(self) {
|
if let Err(err) = thread_recovery::discard_pending(self) {
|
||||||
eprintln!("warning: failed to clear stale daemon recovery before restart: {err}");
|
eprintln!("warning: failed to clear stale daemon recovery before restart: {err}");
|
||||||
@@ -446,14 +452,14 @@ impl Daemon {
|
|||||||
.await?;
|
.await?;
|
||||||
}
|
}
|
||||||
|
|
||||||
let pid = self.start_managed_backend(&settings).await?;
|
let pid = managed.start_managed_backend(&settings).await?;
|
||||||
let info = self.wait_until_ready().await?;
|
let info = self.wait_until_ready().await?;
|
||||||
if let Err(err) = self.ensure_managed_updater(&settings).await {
|
if let Err(err) = managed.ensure_managed_updater(&settings).await {
|
||||||
eprintln!(
|
eprintln!(
|
||||||
"warning: failed to ensure managed updater after app-server restart: {err:#}"
|
"warning: failed to ensure managed updater after app-server restart: {err:#}"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
Ok(self
|
Ok(managed
|
||||||
.output(
|
.output(
|
||||||
LifecycleStatus::Restarted,
|
LifecycleStatus::Restarted,
|
||||||
Some(BackendKind::Pid),
|
Some(BackendKind::Pid),
|
||||||
@@ -746,8 +752,6 @@ impl Daemon {
|
|||||||
}
|
}
|
||||||
|
|
||||||
async fn bootstrap_locked(&self, options: BootstrapOptions) -> Result<BootstrapOutput> {
|
async fn bootstrap_locked(&self, options: BootstrapOptions) -> Result<BootstrapOutput> {
|
||||||
self.ensure_managed_codex_bin()?;
|
|
||||||
|
|
||||||
let mut settings = self.load_settings().await?;
|
let mut settings = self.load_settings().await?;
|
||||||
settings.remote_control_enabled = options.remote_control_enabled;
|
settings.remote_control_enabled = options.remote_control_enabled;
|
||||||
if client::probe(&self.socket_path).await.is_ok()
|
if client::probe(&self.socket_path).await.is_ok()
|
||||||
@@ -757,6 +761,10 @@ impl Daemon {
|
|||||||
"app server is running but is not managed by codex app-server daemon"
|
"app server is running but is not managed by codex app-server daemon"
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
prepare_install::prepare(self, &settings).await?;
|
||||||
|
let mut managed = self.clone();
|
||||||
|
managed.managed_codex_bin = self.current_managed_codex_bin()?;
|
||||||
|
managed.ensure_managed_codex_bin()?;
|
||||||
settings.save(&self.settings_file).await?;
|
settings.save(&self.settings_file).await?;
|
||||||
|
|
||||||
backend::pid_update_loop_backend(self.backend_paths(&settings))
|
backend::pid_update_loop_backend(self.backend_paths(&settings))
|
||||||
@@ -771,17 +779,17 @@ impl Daemon {
|
|||||||
.await?;
|
.await?;
|
||||||
}
|
}
|
||||||
|
|
||||||
let backend = backend::pid_backend(self.backend_paths(&settings));
|
let backend = backend::pid_backend(managed.backend_paths(&settings));
|
||||||
backend.start().await?;
|
backend.start().await?;
|
||||||
let info = self.wait_until_ready().await?;
|
let info = self.wait_until_ready().await?;
|
||||||
let auto_update_enabled = self.ensure_managed_updater(&settings).await?;
|
let auto_update_enabled = managed.ensure_managed_updater(&settings).await?;
|
||||||
let managed_codex_version = self.managed_codex_version_best_effort().await;
|
let managed_codex_version = managed.managed_codex_version_best_effort().await;
|
||||||
Ok(BootstrapOutput {
|
Ok(BootstrapOutput {
|
||||||
status: BootstrapStatus::Bootstrapped,
|
status: BootstrapStatus::Bootstrapped,
|
||||||
backend: BackendKind::Pid,
|
backend: BackendKind::Pid,
|
||||||
auto_update_enabled,
|
auto_update_enabled,
|
||||||
remote_control_enabled: settings.remote_control_enabled,
|
remote_control_enabled: settings.remote_control_enabled,
|
||||||
managed_codex_path: self.managed_codex_bin.clone(),
|
managed_codex_path: managed.managed_codex_bin,
|
||||||
managed_codex_version,
|
managed_codex_version,
|
||||||
socket_path: self.socket_path.clone(),
|
socket_path: self.socket_path.clone(),
|
||||||
cli_version: env!("CARGO_PKG_VERSION").to_string(),
|
cli_version: env!("CARGO_PKG_VERSION").to_string(),
|
||||||
@@ -913,17 +921,8 @@ impl Daemon {
|
|||||||
}
|
}
|
||||||
|
|
||||||
let managed_codex_path = self.managed_codex_bin.display();
|
let managed_codex_path = self.managed_codex_bin.display();
|
||||||
let install_command = if cfg!(windows) {
|
|
||||||
"irm https://chatgpt.com/codex/install.ps1 | iex"
|
|
||||||
} else {
|
|
||||||
"curl -fsSL https://chatgpt.com/codex/install.sh | sh"
|
|
||||||
};
|
|
||||||
Err(anyhow!(
|
Err(anyhow!(
|
||||||
"managed standalone Codex install not found at {managed_codex_path}\n\n\
|
"daemon executable not found at {managed_codex_path}; repair the existing installation, or run `codex app-server daemon start` to install a missing daemon"
|
||||||
This command requires the standalone install managed by the Codex installer, because \
|
|
||||||
the daemon starts and updates app-server from that fixed path.\n\n\
|
|
||||||
Install it with:\n {install_command}\n\n\
|
|
||||||
Then rerun the command you just tried."
|
|
||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -14,7 +14,7 @@ use tokio::fs;
|
|||||||
use tokio::process::Command;
|
use tokio::process::Command;
|
||||||
use tokio::time::timeout;
|
use tokio::time::timeout;
|
||||||
|
|
||||||
/// Dedicated daemon packages take precedence over standalone installations.
|
/// New daemons own their packages, regardless of how the calling CLI was installed.
|
||||||
/// Preserve legacy launch state, including logs left after a daemon is stopped;
|
/// Preserve legacy launch state, including logs left after a daemon is stopped;
|
||||||
/// settings, installer selections, and lock files alone do not prove a prior launch.
|
/// settings, installer selections, and lock files alone do not prove a prior launch.
|
||||||
pub(crate) fn package_root(codex_home: &Path) -> PathBuf {
|
pub(crate) fn package_root(codex_home: &Path) -> PathBuf {
|
||||||
@@ -52,13 +52,6 @@ pub(crate) fn package_root(codex_home: &Path) -> PathBuf {
|
|||||||
return codex_home.join("packages").join(package);
|
return codex_home.join("packages").join(package);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Retain CLI installs until the next stage adds dedicated package seeding.
|
|
||||||
let standalone = codex_home.join("packages/standalone");
|
|
||||||
if !matches!(standalone.join("current").symlink_metadata(),
|
|
||||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound)
|
|
||||||
{
|
|
||||||
return standalone;
|
|
||||||
}
|
|
||||||
dedicated
|
dedicated
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -21,7 +21,7 @@ fn discovers_package_and_legacy_installs() {
|
|||||||
// A CLI install and a previous stop/status operation do not establish ownership.
|
// A CLI install and a previous stop/status operation do not establish ownership.
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
super::package_root(home.path()),
|
super::package_root(home.path()),
|
||||||
home.path().join("packages/standalone")
|
home.path().join("packages/app-server-daemon")
|
||||||
);
|
);
|
||||||
std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
|
std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
|
||||||
assert_eq!(super::managed_codex_bin(home.path()), legacy);
|
assert_eq!(super::managed_codex_bin(home.path()), legacy);
|
||||||
|
|||||||
@@ -0,0 +1,317 @@
|
|||||||
|
//! Prepares complete local CLI packages for a stopped daemon. Legacy standalone
|
||||||
|
//! installations are left to their installer; new releases are immutable.
|
||||||
|
|
||||||
|
use std::path::Path;
|
||||||
|
|
||||||
|
use anyhow::Context;
|
||||||
|
use anyhow::Result;
|
||||||
|
use anyhow::anyhow;
|
||||||
|
use codex_install_context::CodexPackageManifest;
|
||||||
|
use codex_install_context::InstallContext;
|
||||||
|
|
||||||
|
use crate::Daemon;
|
||||||
|
use crate::install_lock::acquire_install_lock;
|
||||||
|
use crate::managed_install;
|
||||||
|
use crate::settings::DaemonSettings;
|
||||||
|
|
||||||
|
/// Prepare a missing package while the caller holds the daemon operation lock.
|
||||||
|
pub(super) async fn prepare(daemon: &Daemon, settings: &DaemonSettings) -> Result<()> {
|
||||||
|
let source = InstallContext::current().package_layout.as_ref();
|
||||||
|
prepare_from_package(
|
||||||
|
daemon,
|
||||||
|
settings,
|
||||||
|
source.map(|layout| layout.package_dir.as_path()),
|
||||||
|
&std::env::current_exe()?,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn prepare_from_package(
|
||||||
|
daemon: &Daemon,
|
||||||
|
settings: &DaemonSettings,
|
||||||
|
source: Option<&Path>,
|
||||||
|
running_exe: &Path,
|
||||||
|
) -> Result<()> {
|
||||||
|
let home = daemon
|
||||||
|
.settings_file
|
||||||
|
.parent()
|
||||||
|
.and_then(Path::parent)
|
||||||
|
.context("daemon settings path has no Codex home")?;
|
||||||
|
let root = managed_install::package_root(home);
|
||||||
|
anyhow::ensure!(
|
||||||
|
daemon.managed_codex_bin.starts_with(&root),
|
||||||
|
"daemon package location changed; retry the command"
|
||||||
|
);
|
||||||
|
if !root.ends_with("app-server-daemon")
|
||||||
|
|| daemon.running_backend_instance(settings).await?.is_some()
|
||||||
|
|| crate::client::probe(&daemon.socket_path).await.is_ok()
|
||||||
|
{
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
if !matches!(root.join("current").symlink_metadata(), Err(error) if error.kind() == std::io::ErrorKind::NotFound)
|
||||||
|
|| ["daemon.pid", "daemon.stderr.log", "daemon-updater.pid", "daemon-updater.stderr.log"]
|
||||||
|
.iter().any(|name| !matches!(home.join("app-server-daemon").join(name).symlink_metadata(), Err(error) if error.kind() == std::io::ErrorKind::NotFound))
|
||||||
|
{
|
||||||
|
daemon.ensure_managed_codex_bin()?;
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
std::fs::create_dir_all(&root)?;
|
||||||
|
let _install_lock = acquire_install_lock(&root).await?;
|
||||||
|
// An older CLI may have launched a legacy daemon while this CLI waited.
|
||||||
|
anyhow::ensure!(
|
||||||
|
managed_install::package_root(home) == root,
|
||||||
|
"daemon package location changed; retry the command"
|
||||||
|
);
|
||||||
|
anyhow::ensure!(
|
||||||
|
daemon.running_backend_instance(settings).await?.is_none()
|
||||||
|
&& crate::client::probe(&daemon.socket_path).await.is_err(),
|
||||||
|
"an app server started while preparing the daemon; retry the command"
|
||||||
|
);
|
||||||
|
let selected = managed_install::managed_codex_bin(home);
|
||||||
|
let missing = !selected.is_file();
|
||||||
|
if !missing {
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
anyhow::ensure!(
|
||||||
|
matches!(root.join("current").symlink_metadata(), Err(error) if error.kind() == std::io::ErrorKind::NotFound),
|
||||||
|
"the selected daemon package is incomplete; repair its installation before starting"
|
||||||
|
);
|
||||||
|
let source = source.context(
|
||||||
|
"this CLI has no complete local package; install a packaged Codex CLI or use the standalone installer",
|
||||||
|
)?;
|
||||||
|
anyhow::ensure!(
|
||||||
|
!root.canonicalize()?.starts_with(source.canonicalize()?),
|
||||||
|
"CODEX_HOME must be outside the source CLI package"
|
||||||
|
);
|
||||||
|
let manifest_bytes = std::fs::read(source.join("codex-package.json"))?;
|
||||||
|
let manifest: CodexPackageManifest = serde_json::from_slice(&manifest_bytes)?;
|
||||||
|
let version = manifest.version.to_string();
|
||||||
|
let target = platform_target()?;
|
||||||
|
let metadata: serde_json::Value = serde_json::from_slice(&manifest_bytes)?;
|
||||||
|
let entrypoint = if cfg!(windows) {
|
||||||
|
"bin/codex.exe"
|
||||||
|
} else {
|
||||||
|
"bin/codex"
|
||||||
|
};
|
||||||
|
anyhow::ensure!(
|
||||||
|
metadata["target"] == target && metadata["entrypoint"] == entrypoint,
|
||||||
|
"the CLI package does not match this platform or executable"
|
||||||
|
);
|
||||||
|
validate_package(source)?;
|
||||||
|
eprintln!(
|
||||||
|
"Installing daemon from CLI version {version} into {}...",
|
||||||
|
root.display()
|
||||||
|
);
|
||||||
|
let stable = stable_version(&version).is_some();
|
||||||
|
let running_identity = managed_install::executable_identity(running_exe).await?;
|
||||||
|
let releases = root.join("releases");
|
||||||
|
std::fs::create_dir_all(&releases)?;
|
||||||
|
let stage = tempfile::Builder::new()
|
||||||
|
.prefix(".staging.")
|
||||||
|
.tempdir_in(&releases)?;
|
||||||
|
let digest = package_tree(source, Some(stage.path()))?;
|
||||||
|
validate_package(stage.path())?;
|
||||||
|
let staged_exe = if cfg!(target_os = "macos") && stage.path().join("CodexCLI.app").is_dir() {
|
||||||
|
stage.path().join("CodexCLI.app/Contents/MacOS/codex")
|
||||||
|
} else {
|
||||||
|
stage.path().join(entrypoint)
|
||||||
|
};
|
||||||
|
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,
|
||||||
|
"the CLI package changed while preparing the daemon or differs from the running executable"
|
||||||
|
);
|
||||||
|
let binary_version =
|
||||||
|
managed_install::managed_codex_version(&stage.path().join(entrypoint)).await?;
|
||||||
|
anyhow::ensure!(
|
||||||
|
!stable || version == binary_version,
|
||||||
|
"the CLI package version does not match its executable"
|
||||||
|
);
|
||||||
|
let name = if stable {
|
||||||
|
format!("{version}-{target}")
|
||||||
|
} else {
|
||||||
|
format!("local-{digest}-{target}")
|
||||||
|
};
|
||||||
|
let release = releases.join(&name);
|
||||||
|
if release.try_exists()? {
|
||||||
|
anyhow::ensure!(
|
||||||
|
!release.symlink_metadata()?.file_type().is_symlink()
|
||||||
|
&& package_tree(&release, /*destination*/ None)? == digest,
|
||||||
|
"an existing daemon release has different contents; refusing to overwrite it"
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
#[cfg(unix)]
|
||||||
|
if !stage.path().join("codex").exists() {
|
||||||
|
std::os::unix::fs::symlink("bin/codex", stage.path().join("codex"))?;
|
||||||
|
}
|
||||||
|
std::fs::rename(stage.path(), &release)?;
|
||||||
|
}
|
||||||
|
let standalone = home.join("packages/standalone");
|
||||||
|
let canonical_source = source.canonicalize()?;
|
||||||
|
let follows_latest = stable
|
||||||
|
&& (standalone.join("current").canonicalize().ok().as_deref()
|
||||||
|
!= Some(canonical_source.as_path())
|
||||||
|
|| std::fs::read_to_string(standalone.join("auto-update-version"))
|
||||||
|
.ok()
|
||||||
|
.as_deref()
|
||||||
|
== canonical_source.file_name().and_then(|name| name.to_str()));
|
||||||
|
anyhow::ensure!(
|
||||||
|
managed_install::package_root(home) == root
|
||||||
|
&& daemon.running_backend_instance(settings).await?.is_none()
|
||||||
|
&& crate::client::probe(&daemon.socket_path).await.is_err(),
|
||||||
|
"daemon state changed while preparing its package; retry the command"
|
||||||
|
);
|
||||||
|
let marker = root.join("auto-update-version");
|
||||||
|
if follows_latest {
|
||||||
|
let temporary = tempfile::NamedTempFile::new_in(&root)?;
|
||||||
|
std::fs::write(temporary.path(), &name)?;
|
||||||
|
temporary.persist(marker)?;
|
||||||
|
} else if marker.exists() {
|
||||||
|
std::fs::remove_file(marker)?;
|
||||||
|
}
|
||||||
|
#[cfg(unix)]
|
||||||
|
{
|
||||||
|
let temporary = tempfile::TempDir::new_in(&root)?;
|
||||||
|
let link = temporary.path().join("current");
|
||||||
|
std::os::unix::fs::symlink(&release, &link)?;
|
||||||
|
std::fs::rename(link, root.join("current"))?;
|
||||||
|
}
|
||||||
|
#[cfg(windows)]
|
||||||
|
windows::select_release(&root, &release)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Hash the complete tree and optionally copy those same bytes. Relative file
|
||||||
|
/// links are materialized; escaping links and directory links are rejected.
|
||||||
|
fn package_tree(root: &Path, destination: Option<&Path>) -> Result<String> {
|
||||||
|
let canonical_root = root.canonicalize()?;
|
||||||
|
let mut hasher = blake3::Hasher::new();
|
||||||
|
let mut paths = vec![root.to_path_buf()];
|
||||||
|
while let Some(path) = paths.pop() {
|
||||||
|
let relative = path.strip_prefix(root)?;
|
||||||
|
// The Unix installer adds this alias outside the package layout.
|
||||||
|
if cfg!(unix)
|
||||||
|
&& relative == Path::new("codex")
|
||||||
|
&& std::fs::read_link(&path).ok().as_deref() == Some(Path::new("bin/codex"))
|
||||||
|
{
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
anyhow::ensure!(
|
||||||
|
path.canonicalize()?.starts_with(&canonical_root),
|
||||||
|
"package link escapes its root"
|
||||||
|
);
|
||||||
|
let metadata = path.metadata()?;
|
||||||
|
hasher.update(relative.as_os_str().as_encoded_bytes());
|
||||||
|
hasher.update(&[0]);
|
||||||
|
if metadata.is_dir() {
|
||||||
|
anyhow::ensure!(
|
||||||
|
!path.symlink_metadata()?.file_type().is_symlink(),
|
||||||
|
"package contains a directory link"
|
||||||
|
);
|
||||||
|
hasher.update(b"directory");
|
||||||
|
if let Some(destination) = destination
|
||||||
|
&& !relative.as_os_str().is_empty()
|
||||||
|
{
|
||||||
|
std::fs::create_dir(destination.join(relative))?;
|
||||||
|
}
|
||||||
|
let mut entries = std::fs::read_dir(&path)?
|
||||||
|
.map(|entry| entry.map(|entry| entry.path()))
|
||||||
|
.collect::<std::io::Result<Vec<_>>>()?;
|
||||||
|
entries.sort();
|
||||||
|
paths.extend(entries);
|
||||||
|
} else {
|
||||||
|
anyhow::ensure!(metadata.is_file(), "package contains an unsupported file");
|
||||||
|
let bytes = std::fs::read(&path)?;
|
||||||
|
hasher.update(b"file");
|
||||||
|
hasher.update(blake3::hash(&bytes).as_bytes());
|
||||||
|
#[cfg(unix)]
|
||||||
|
{
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
hasher.update(&(metadata.permissions().mode() & 0o777).to_le_bytes());
|
||||||
|
}
|
||||||
|
if let Some(destination) = destination {
|
||||||
|
let target = destination.join(relative);
|
||||||
|
std::fs::write(&target, bytes)?;
|
||||||
|
std::fs::set_permissions(target, metadata.permissions())?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(hasher.finalize().to_hex().to_string())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn stable_version(value: &str) -> Option<semver::Version> {
|
||||||
|
let version = semver::Version::parse(value).ok()?;
|
||||||
|
(version.pre.is_empty()
|
||||||
|
&& version.build.is_empty()
|
||||||
|
&& (version.major, version.minor, version.patch) != (0, 0, 0))
|
||||||
|
.then_some(version)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn validate_package(root: &Path) -> Result<()> {
|
||||||
|
let mut names = vec![
|
||||||
|
"codex-package.json",
|
||||||
|
if cfg!(windows) {
|
||||||
|
"bin/codex.exe"
|
||||||
|
} else {
|
||||||
|
"bin/codex"
|
||||||
|
},
|
||||||
|
if cfg!(windows) {
|
||||||
|
"bin/codex-code-mode-host.exe"
|
||||||
|
} else {
|
||||||
|
"bin/codex-code-mode-host"
|
||||||
|
},
|
||||||
|
if cfg!(windows) {
|
||||||
|
"codex-path/rg.exe"
|
||||||
|
} else {
|
||||||
|
"codex-path/rg"
|
||||||
|
},
|
||||||
|
];
|
||||||
|
if cfg!(windows) {
|
||||||
|
names.extend([
|
||||||
|
"codex-resources/codex-command-runner.exe",
|
||||||
|
"codex-resources/codex-windows-sandbox-setup.exe",
|
||||||
|
]);
|
||||||
|
} else if cfg!(target_os = "linux") {
|
||||||
|
names.push("codex-resources/bwrap");
|
||||||
|
}
|
||||||
|
for name in names {
|
||||||
|
if !root.join(name).is_file() {
|
||||||
|
return Err(anyhow!(
|
||||||
|
"local Codex package is missing {name}; reinstall the CLI or use the standalone installer"
|
||||||
|
));
|
||||||
|
}
|
||||||
|
#[cfg(unix)]
|
||||||
|
if name != "codex-package.json" {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
if std::fs::metadata(root.join(name))?.permissions().mode() & 0o111 == 0 {
|
||||||
|
return Err(anyhow!(
|
||||||
|
"local Codex package file {name} is not executable; reinstall the CLI or use the standalone installer"
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn platform_target() -> Result<&'static str> {
|
||||||
|
match (std::env::consts::OS, std::env::consts::ARCH) {
|
||||||
|
("macos", "aarch64") => Ok("aarch64-apple-darwin"),
|
||||||
|
("macos", "x86_64") => Ok("x86_64-apple-darwin"),
|
||||||
|
("linux", "aarch64") if cfg!(target_env = "gnu") => Ok("aarch64-unknown-linux-gnu"),
|
||||||
|
("linux", "aarch64") => Ok("aarch64-unknown-linux-musl"),
|
||||||
|
("linux", "x86_64") if cfg!(target_env = "gnu") => Ok("x86_64-unknown-linux-gnu"),
|
||||||
|
("linux", "x86_64") => Ok("x86_64-unknown-linux-musl"),
|
||||||
|
("windows", "aarch64") => Ok("aarch64-pc-windows-msvc"),
|
||||||
|
("windows", "x86_64") => Ok("x86_64-pc-windows-msvc"),
|
||||||
|
(os, arch) => Err(anyhow!("unsupported packaged daemon platform {os}/{arch}")),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(windows)]
|
||||||
|
#[path = "prepare_install_windows.rs"]
|
||||||
|
mod windows;
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
#[path = "prepare_install_tests.rs"]
|
||||||
|
mod tests;
|
||||||
@@ -0,0 +1,223 @@
|
|||||||
|
//! Covers complete-package staging, conservative selection, and legacy preservation.
|
||||||
|
#![cfg(unix)]
|
||||||
|
use super::prepare_from_package;
|
||||||
|
use super::validate_package;
|
||||||
|
use crate::settings::DaemonSettings;
|
||||||
|
use pretty_assertions::assert_eq;
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
use std::path::Path;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
fn daemon(home: &std::path::Path) -> crate::Daemon {
|
||||||
|
let state = home.join("app-server-daemon");
|
||||||
|
crate::Daemon {
|
||||||
|
socket_path: state.join("app-server.sock"),
|
||||||
|
pid_file: state.join("app-server.pid"),
|
||||||
|
update_pid_file: state.join("app-server-updater.pid"),
|
||||||
|
operation_lock_file: state.join("daemon.lock"),
|
||||||
|
settings_file: state.join("settings.json"),
|
||||||
|
managed_codex_bin: crate::managed_install::managed_codex_bin(home),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn package(root: &Path, version: &str) -> PathBuf {
|
||||||
|
let target = super::platform_target().expect("target");
|
||||||
|
for dir in ["bin", "codex-path", "codex-resources/nested"] {
|
||||||
|
std::fs::create_dir_all(root.join(dir)).expect("package directory");
|
||||||
|
}
|
||||||
|
let bin = root.join("bin/codex");
|
||||||
|
std::fs::write(&bin, format!("#!/bin/sh\necho 'codex {version}'\n")).expect("codex executable");
|
||||||
|
for file in [
|
||||||
|
"bin/codex-code-mode-host",
|
||||||
|
"codex-path/rg",
|
||||||
|
"codex-resources/nested/runtime",
|
||||||
|
] {
|
||||||
|
std::fs::write(root.join(file), b"runtime").expect("package file");
|
||||||
|
if file != "codex-resources/nested/runtime" {
|
||||||
|
std::fs::set_permissions(root.join(file), std::fs::Permissions::from_mode(0o755))
|
||||||
|
.expect("executable helper");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if cfg!(target_os = "linux") {
|
||||||
|
std::fs::write(root.join("codex-resources/bwrap"), b"runtime").expect("bwrap");
|
||||||
|
std::fs::set_permissions(
|
||||||
|
root.join("codex-resources/bwrap"),
|
||||||
|
std::fs::Permissions::from_mode(0o755),
|
||||||
|
)
|
||||||
|
.expect("executable bwrap");
|
||||||
|
}
|
||||||
|
std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755))
|
||||||
|
.expect("executable permission");
|
||||||
|
std::fs::write(
|
||||||
|
root.join("codex-package.json"),
|
||||||
|
serde_json::json!({
|
||||||
|
"version": version, "target": target, "entrypoint": "bin/codex"
|
||||||
|
})
|
||||||
|
.to_string(),
|
||||||
|
)
|
||||||
|
.expect("manifest");
|
||||||
|
bin
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn seeds_full_package() {
|
||||||
|
let temp = tempfile::TempDir::new().expect("temp");
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
let daemon = daemon(&home);
|
||||||
|
let settings = DaemonSettings::default();
|
||||||
|
let old = temp.path().join("old");
|
||||||
|
let old_bin = package(&old, "0.152.0");
|
||||||
|
prepare_from_package(&daemon, &settings, Some(&old), &old_bin)
|
||||||
|
.await
|
||||||
|
.expect("seed");
|
||||||
|
|
||||||
|
let standalone = home.join("packages/app-server-daemon");
|
||||||
|
let selected = std::fs::canonicalize(standalone.join("current")).expect("selected");
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read(selected.join("codex-resources/nested/runtime")).expect("runtime"),
|
||||||
|
b"runtime"
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read_to_string(standalone.join("auto-update-version")).expect("marker"),
|
||||||
|
selected.file_name().expect("name").to_string_lossy()
|
||||||
|
);
|
||||||
|
assert!(validate_package(&selected).is_ok());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn incomplete_source_fails_without_selecting_it() {
|
||||||
|
let temp = tempfile::TempDir::new().expect("temp");
|
||||||
|
let source = temp.path().join("package");
|
||||||
|
let bin = package(&source, "0.152.0");
|
||||||
|
std::fs::remove_file(source.join("bin/codex-code-mode-host")).expect("remove helper");
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
let error = prepare_from_package(
|
||||||
|
&daemon(&home),
|
||||||
|
&DaemonSettings::default(),
|
||||||
|
Some(&source),
|
||||||
|
&bin,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect_err("incomplete package");
|
||||||
|
assert!(error.to_string().contains("bin/codex-code-mode-host"));
|
||||||
|
assert!(!home.join("packages/app-server-daemon/current").exists());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_os = "macos")]
|
||||||
|
#[tokio::test]
|
||||||
|
async fn provisioned_macos_bundle_seeds_from_its_running_executable() {
|
||||||
|
let temp = tempfile::TempDir::new().expect("temp");
|
||||||
|
let source = temp.path().join("package");
|
||||||
|
let launcher = package(&source, "0.1.0-internal-test.202609091200.1");
|
||||||
|
std::fs::write(&launcher, b"#!/bin/sh\necho codex 0.0.0\n").expect("launcher");
|
||||||
|
let bundle = source.join("CodexCLI.app/Contents/MacOS/codex");
|
||||||
|
std::fs::create_dir_all(bundle.parent().expect("bundle parent")).expect("bundle dir");
|
||||||
|
std::fs::write(&bundle, b"provisioned executable").expect("bundle executable");
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
prepare_from_package(
|
||||||
|
&daemon(&home),
|
||||||
|
&DaemonSettings::default(),
|
||||||
|
Some(&source),
|
||||||
|
&bundle,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect("seed provisioned bundle");
|
||||||
|
let selected = std::fs::canonicalize(home.join("packages/app-server-daemon/current"))
|
||||||
|
.expect("selected release");
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read(selected.join("CodexCLI.app/Contents/MacOS/codex"))
|
||||||
|
.expect("bundled executable"),
|
||||||
|
b"provisioned executable"
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
!home
|
||||||
|
.join("packages/app-server-daemon/auto-update-version")
|
||||||
|
.exists()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn legacy_selection_is_not_migrated_or_refreshed() {
|
||||||
|
let temp = tempfile::TempDir::new().unwrap();
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
let legacy = home.join("packages/standalone");
|
||||||
|
let bin = package(&legacy.join("releases/old"), "0.150.0");
|
||||||
|
std::os::unix::fs::symlink("releases/old", legacy.join("current")).unwrap();
|
||||||
|
let state = home.join("app-server-daemon");
|
||||||
|
std::fs::create_dir(&state).unwrap();
|
||||||
|
std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
|
||||||
|
let source = temp.path().join("new");
|
||||||
|
let new_bin = package(&source, "0.160.0");
|
||||||
|
prepare_from_package(
|
||||||
|
&daemon(&home),
|
||||||
|
&DaemonSettings::default(),
|
||||||
|
Some(&source),
|
||||||
|
&new_bin,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
crate::managed_install::managed_codex_bin(&home)
|
||||||
|
.canonicalize()
|
||||||
|
.unwrap(),
|
||||||
|
bin.canonicalize().unwrap()
|
||||||
|
);
|
||||||
|
assert!(!home.join("packages/app-server-daemon").exists());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn standalone_seed_preserves_explicit_pin_or_latest_channel() {
|
||||||
|
for follows_latest in [false, true] {
|
||||||
|
let temp = tempfile::TempDir::new().unwrap();
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
let standalone = home.join("packages/standalone");
|
||||||
|
let source = standalone.join("releases/0.152.0-local-target");
|
||||||
|
let bin = package(&source, "0.152.0");
|
||||||
|
std::os::unix::fs::symlink(&source, standalone.join("current")).unwrap();
|
||||||
|
if follows_latest {
|
||||||
|
std::fs::write(
|
||||||
|
standalone.join("auto-update-version"),
|
||||||
|
"0.152.0-local-target",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
prepare_from_package(
|
||||||
|
&daemon(&home),
|
||||||
|
&DaemonSettings::default(),
|
||||||
|
Some(&source),
|
||||||
|
&bin,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
let root = home.join("packages/app-server-daemon");
|
||||||
|
let selected = root.join("current").canonicalize().unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read_to_string(root.join("auto-update-version")).ok(),
|
||||||
|
follows_latest.then(|| selected.file_name().unwrap().to_string_lossy().into_owned())
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn broken_selection_is_not_a_missing_installation() {
|
||||||
|
let temp = tempfile::TempDir::new().unwrap();
|
||||||
|
let home = temp.path().join("home");
|
||||||
|
let source = temp.path().join("source");
|
||||||
|
let bin = package(&source, "0.152.0");
|
||||||
|
let daemon = daemon(&home);
|
||||||
|
let current = home.join("packages/app-server-daemon/current");
|
||||||
|
std::fs::create_dir_all(current.parent().unwrap()).unwrap();
|
||||||
|
std::os::unix::fs::symlink("missing-release", ¤t).unwrap();
|
||||||
|
let error = prepare_from_package(&daemon, &DaemonSettings::default(), Some(&source), &bin)
|
||||||
|
.await
|
||||||
|
.unwrap_err();
|
||||||
|
assert!(
|
||||||
|
error
|
||||||
|
.to_string()
|
||||||
|
.contains("repair the existing installation")
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read_link(current).unwrap(),
|
||||||
|
PathBuf::from("missing-release")
|
||||||
|
);
|
||||||
|
}
|
||||||
@@ -0,0 +1,87 @@
|
|||||||
|
//! Selects a Windows managed release by creating or retargeting the installer junction.
|
||||||
|
|
||||||
|
use std::os::windows::ffi::OsStrExt;
|
||||||
|
use std::os::windows::fs::OpenOptionsExt;
|
||||||
|
use std::os::windows::io::AsRawHandle;
|
||||||
|
use std::path::Path;
|
||||||
|
|
||||||
|
use anyhow::Context;
|
||||||
|
use anyhow::Result;
|
||||||
|
use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS;
|
||||||
|
use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OPEN_REPARSE_POINT;
|
||||||
|
use windows_sys::Win32::Storage::FileSystem::FILE_SHARE_DELETE;
|
||||||
|
use windows_sys::Win32::Storage::FileSystem::FILE_SHARE_READ;
|
||||||
|
use windows_sys::Win32::Storage::FileSystem::FILE_SHARE_WRITE;
|
||||||
|
use windows_sys::Win32::System::IO::DeviceIoControl;
|
||||||
|
|
||||||
|
pub(super) fn select_release(root: &Path, release: &Path) -> Result<()> {
|
||||||
|
let release = release.canonicalize()?;
|
||||||
|
let current = root.join("current");
|
||||||
|
if current.symlink_metadata().is_err() {
|
||||||
|
let temporary = tempfile::TempDir::new_in(root)?;
|
||||||
|
let junction = temporary.path().join("current");
|
||||||
|
std::fs::create_dir(&junction)?;
|
||||||
|
retarget_junction(&junction, &release)?;
|
||||||
|
std::fs::rename(junction, ¤t)?;
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
anyhow::ensure!(
|
||||||
|
current.canonicalize()?.parent() == Some(root.join("releases").canonicalize()?.as_path()),
|
||||||
|
"refusing to replace a daemon selection outside its releases directory"
|
||||||
|
);
|
||||||
|
retarget_junction(¤t, &release)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn retarget_junction(current: &Path, release: &Path) -> Result<()> {
|
||||||
|
// Use the same mount-point reparse operation as the standalone installer.
|
||||||
|
// Retargeting in place keeps current available to concurrent readers.
|
||||||
|
const FSCTL_SET_REPARSE_POINT: u32 = 0x0009_00a4;
|
||||||
|
const IO_REPARSE_TAG_MOUNT_POINT: u32 = 0xa000_0003;
|
||||||
|
const GENERIC_WRITE: u32 = 0x4000_0000;
|
||||||
|
let release: Vec<u16> = release.as_os_str().encode_wide().collect();
|
||||||
|
let prefix: Vec<u16> = r"\\?\".encode_utf16().collect();
|
||||||
|
let release = release.strip_prefix(prefix.as_slice()).unwrap_or(&release);
|
||||||
|
let substitute: Vec<u8> = r"\??\"
|
||||||
|
.encode_utf16()
|
||||||
|
.chain(release.iter().copied())
|
||||||
|
.flat_map(u16::to_le_bytes)
|
||||||
|
.collect();
|
||||||
|
u16::try_from(substitute.len() + 20).context("managed release path is too long")?;
|
||||||
|
let length = substitute.len() as u16;
|
||||||
|
// REPARSE_DATA_BUFFER: an 8-byte header, then four u16 byte offsets/lengths
|
||||||
|
// for substitute and print names. The UTF-16 path buffer starts at byte 16;
|
||||||
|
// both names have a trailing NUL, and the print name is empty.
|
||||||
|
let mut data = vec![0; substitute.len() + 20];
|
||||||
|
data[0..4].copy_from_slice(&IO_REPARSE_TAG_MOUNT_POINT.to_le_bytes());
|
||||||
|
data[4..6].copy_from_slice(&(length + 12).to_le_bytes());
|
||||||
|
data[10..12].copy_from_slice(&length.to_le_bytes());
|
||||||
|
data[12..14].copy_from_slice(&(length + 2).to_le_bytes());
|
||||||
|
data[16..16 + substitute.len()].copy_from_slice(&substitute);
|
||||||
|
let handle = std::fs::OpenOptions::new()
|
||||||
|
.access_mode(GENERIC_WRITE)
|
||||||
|
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
|
||||||
|
.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT)
|
||||||
|
.open(current)?;
|
||||||
|
let mut returned = 0;
|
||||||
|
if unsafe {
|
||||||
|
DeviceIoControl(
|
||||||
|
handle.as_raw_handle() as isize,
|
||||||
|
FSCTL_SET_REPARSE_POINT,
|
||||||
|
data.as_ptr().cast(),
|
||||||
|
data.len() as u32,
|
||||||
|
std::ptr::null_mut(),
|
||||||
|
0,
|
||||||
|
&mut returned,
|
||||||
|
std::ptr::null_mut(),
|
||||||
|
)
|
||||||
|
} == 0
|
||||||
|
{
|
||||||
|
return Err(std::io::Error::last_os_error())
|
||||||
|
.context("failed to retarget managed daemon junction");
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
#[path = "prepare_install_windows_tests.rs"]
|
||||||
|
mod tests;
|
||||||
@@ -0,0 +1,19 @@
|
|||||||
|
//! Verifies Windows selection without requiring an elevated daemon.
|
||||||
|
use pretty_assertions::assert_eq;
|
||||||
|
|
||||||
|
#[cfg(windows)]
|
||||||
|
#[test]
|
||||||
|
fn daemon_junction_can_be_created_and_retargeted_without_cli_links() {
|
||||||
|
let home = tempfile::TempDir::new().unwrap();
|
||||||
|
let root = home.path().join("packages/app-server-daemon");
|
||||||
|
for version in ["first", "second"] {
|
||||||
|
let release = root.join("releases").join(version);
|
||||||
|
std::fs::create_dir_all(&release).unwrap();
|
||||||
|
super::select_release(&root, &release).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
root.join("current").canonicalize().unwrap(),
|
||||||
|
release.canonicalize().unwrap()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
assert!(!home.path().join("packages/standalone").exists());
|
||||||
|
}
|
||||||
@@ -323,3 +323,107 @@ fn manual_update_rejects_an_unowned_installation() -> Result<()> {
|
|||||||
assert!(daemon.pid("app-server-updater.pid").is_err());
|
assert!(daemon.pid("app-server-updater.pid").is_err());
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn packaged_daemon_launch(action: &str) -> 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" {
|
||||||
|
standalone.join("releases/caller")
|
||||||
|
} else {
|
||||||
|
daemon.home.path().join("cli-package")
|
||||||
|
};
|
||||||
|
for directory in ["bin", "codex-path", "codex-resources"] {
|
||||||
|
std::fs::create_dir_all(package.join(directory))?;
|
||||||
|
}
|
||||||
|
std::fs::copy(&daemon.codex, package.join("bin/codex"))?;
|
||||||
|
daemon.codex = package.join("bin/codex");
|
||||||
|
for helper in [
|
||||||
|
"bin/codex-code-mode-host",
|
||||||
|
"codex-path/rg",
|
||||||
|
"codex-resources/bwrap",
|
||||||
|
] {
|
||||||
|
std::fs::write(package.join(helper), b"runtime fixture")?;
|
||||||
|
std::fs::set_permissions(package.join(helper), std::fs::Permissions::from_mode(0o755))?;
|
||||||
|
}
|
||||||
|
let target = format!(
|
||||||
|
"{}-{}",
|
||||||
|
std::env::consts::ARCH,
|
||||||
|
if cfg!(target_os = "macos") {
|
||||||
|
"apple-darwin"
|
||||||
|
} else if cfg!(target_env = "gnu") {
|
||||||
|
"unknown-linux-gnu"
|
||||||
|
} else {
|
||||||
|
"unknown-linux-musl"
|
||||||
|
}
|
||||||
|
);
|
||||||
|
std::fs::write(
|
||||||
|
package.join("codex-package.json"),
|
||||||
|
serde_json::to_vec(&serde_json::json!({
|
||||||
|
"version": env!("CARGO_PKG_VERSION"), "target": target, "entrypoint": "bin/codex"
|
||||||
|
}))?,
|
||||||
|
)?;
|
||||||
|
if action == "start" {
|
||||||
|
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"))?;
|
||||||
|
std::fs::write(
|
||||||
|
state.join("settings.json"),
|
||||||
|
br#"{"shutdownGraceSeconds":0}"#,
|
||||||
|
)?;
|
||||||
|
let cli_before = daemon.codex.canonicalize()?;
|
||||||
|
let result = daemon
|
||||||
|
.command()
|
||||||
|
.args(["app-server", "daemon", action])
|
||||||
|
.output()?;
|
||||||
|
ensure!(
|
||||||
|
result.status.success(),
|
||||||
|
"{}",
|
||||||
|
String::from_utf8_lossy(&result.stderr)
|
||||||
|
);
|
||||||
|
assert!(String::from_utf8_lossy(&result.stderr).contains("Installing daemon from CLI version"));
|
||||||
|
let output: Value = serde_json::from_slice(&result.stdout)?;
|
||||||
|
let dedicated = daemon
|
||||||
|
.home
|
||||||
|
.path()
|
||||||
|
.canonicalize()?
|
||||||
|
.join("packages/app-server-daemon");
|
||||||
|
assert_eq!(
|
||||||
|
output["managedCodexPath"],
|
||||||
|
dedicated
|
||||||
|
.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());
|
||||||
|
if action == "bootstrap" {
|
||||||
|
assert_eq!(output["autoUpdateEnabled"], false);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn packaged_daemon_start_seeds_local_package() -> Result<()> {
|
||||||
|
packaged_daemon_launch("start")
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn packaged_daemon_restart_seeds_local_package() -> Result<()> {
|
||||||
|
packaged_daemon_launch("restart")
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn packaged_daemon_bootstrap_seeds_local_package() -> Result<()> {
|
||||||
|
packaged_daemon_launch("bootstrap")
|
||||||
|
}
|
||||||
Reference in new issue
Block a user