Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Report temporary directories in exec-server environment info (#37479)

iceweasel-oai92fb33b7583a
diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rs
index e6bf999ca1..44015eea90 100644
--- a/codex-rs/exec-server-protocol/src/protocol.rs
+++ b/codex-rs/exec-server-protocol/src/protocol.rs
@@ -93,6 +93,10 @@ pub struct EnvironmentInfo {
/// Working directory inherited by the exec-server process.
#[serde(default)]
pub cwd: Option<PathUri>,
+ /// Executor-local default directories for resolving `:tmpdir`, when reported.
+ /// On Windows, a command's `TEMP` or `TMP` overrides take precedence.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub temporary_directories: Option<Vec<PathUri>>,
/// Optional executor features that clients must gate before sending newer request fields.
#[serde(default)]
pub capabilities: EnvironmentCapabilities,
@@ -132,11 +136,36 @@ pub enum EnvironmentStatusKind {
impl EnvironmentInfo {
/// Returns information about the current local exec-server process.
pub fn local() -> Self {
+ let cwd = std::env::current_dir().ok();
+ let temporary_directory_env_vars: &[&str] = if cfg!(windows) {
+ &["TEMP", "TMP"]
+ } else {
+ &["TMPDIR"]
+ };
+ let mut temporary_directories = Vec::new();
+ for name in temporary_directory_env_vars {
+ if let Some(path) = std::env::var_os(name)
+ .filter(|path| !path.is_empty())
+ .filter(|path| cfg!(unix) || std::path::Path::new(path).is_absolute())
+ .and_then(|path| {
+ PathUri::from_host_native_path(&path).ok().or_else(|| {
+ if cfg!(unix) {
+ PathUri::from_host_native_path(cwd.as_ref()?.join(path)).ok()
+ } else {
+ None
+ }
+ })
+ })
+ && !temporary_directories.contains(&path)
+ {
+ temporary_directories.push(path);
+ }
+ }
+
Self {
shell: codex_shell_command::shell_detect::default_user_shell().into(),
- cwd: std::env::current_dir()
- .ok()
- .and_then(|cwd| PathUri::from_host_native_path(cwd).ok()),
+ cwd: cwd.and_then(|cwd| PathUri::from_host_native_path(cwd).ok()),
+ temporary_directories: Some(temporary_directories),
capabilities: EnvironmentCapabilities {
network_proxy_launch: true,
capability_discovery_sandbox: true,
@@ -868,11 +897,92 @@ mod tests {
path: "/bin/zsh".to_string(),
},
cwd: None,
+ temporary_directories: None,
capabilities: EnvironmentCapabilities::default(),
}
);
}
+ #[test]
+ fn environment_info_preserves_executor_temporary_directories() {
+ let expected = serde_json::json!({
+ "shell": { "name": "powershell", "path": "powershell.exe" },
+ "cwd": null,
+ "temporaryDirectories": ["file:///C:/Temp", "file:///D:/Temp"],
+ "capabilities": {
+ "networkProxyLaunch": false,
+ "capabilityDiscoverySandbox": false,
+ },
+ });
+ let info: EnvironmentInfo = serde_json::from_value(expected.clone())
+ .expect("environment info with executor temporary directories should deserialize");
+
+ assert_eq!(
+ serde_json::to_value(info).expect("environment info should serialize"),
+ expected,
+ );
+ }
+
+ #[test]
+ fn local_environment_info_reads_platform_temporary_directories() {
+ let cwd = std::env::current_dir().expect("current directory");
+ let names: &[&str] = if cfg!(windows) {
+ &["TEMP", "TMP"]
+ } else {
+ &["TMPDIR"]
+ };
+ let mut expected = names
+ .iter()
+ .filter_map(std::env::var_os)
+ .filter(|path| !path.is_empty())
+ .filter(|path| cfg!(unix) || std::path::Path::new(path).is_absolute())
+ .filter_map(|path| {
+ PathUri::from_host_native_path(&path).ok().or_else(|| {
+ if cfg!(unix) {
+ PathUri::from_host_native_path(cwd.join(path)).ok()
+ } else {
+ None
+ }
+ })
+ })
+ .collect::<Vec<_>>();
+ expected.dedup();
+
+ assert_eq!(
+ EnvironmentInfo::local().temporary_directories,
+ Some(expected)
+ );
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn local_environment_info_resolves_relative_temporary_directory() {
+ if std::env::var_os("CODEX_TEST_RELATIVE_TMPDIR").is_none() {
+ let status = std::process::Command::new(std::env::current_exe().expect("test binary"))
+ .arg("--exact")
+ .arg(
+ "protocol::tests::local_environment_info_resolves_relative_temporary_directory",
+ )
+ .env("CODEX_TEST_RELATIVE_TMPDIR", "1")
+ .env("TMPDIR", "relative-temp")
+ .status()
+ .expect("run relative TMPDIR subprocess");
+ assert!(status.success(), "relative TMPDIR subprocess failed");
+ return;
+ }
+
+ let expected = PathUri::from_host_native_path(
+ std::env::current_dir()
+ .expect("current directory")
+ .join("relative-temp"),
+ )
+ .expect("absolute temporary directory URI");
+ assert_eq!(
+ EnvironmentInfo::local().temporary_directories,
+ Some(vec![expected])
+ );
+ }
+
#[test]
fn filesystem_protocol_rejects_native_absolute_paths() {
let native_path = std::env::current_dir()
diff --git a/codex-rs/exec-server/tests/process.rs b/codex-rs/exec-server/tests/process.rs
index 0ca6ce4248..1b0289776a 100644
--- a/codex-rs/exec-server/tests/process.rs
+++ b/codex-rs/exec-server/tests/process.rs
@@ -93,7 +93,19 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {
/// Ordinary requests run one at a time when concurrent processing is not enabled.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Result<()> {
- let mut server = exec_server().await?;
+ let temporary_directory = tempfile::tempdir()?;
+ let temporary_directory_env_vars: &[&str] = if cfg!(windows) {
+ &["TEMP", "TMP"]
+ } else {
+ &["TMPDIR"]
+ };
+ let mut server = exec_server_with_env(
+ temporary_directory_env_vars
+ .iter()
+ .map(|name| (*name, temporary_directory.path())),
+ &[],
+ )
+ .await?;
let process_argv = if cfg!(windows) {
vec!["cmd.exe", "/D", "/C", "ping -n 601 127.0.0.1 >NUL"]
} else {
@@ -195,7 +207,14 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
panic!("expected the queued environment/info response after process/read");
};
assert_eq!(id, queued_environment_info_id);
- let _: EnvironmentInfo = serde_json::from_value(result)?;
+ let mut expected_environment_info = EnvironmentInfo::local();
+ expected_environment_info.temporary_directories = Some(vec![PathUri::from_host_native_path(
+ temporary_directory.path(),
+ )?]);
+ assert_eq!(
+ serde_json::from_value::<EnvironmentInfo>(result)?,
+ expected_environment_info
+ );
let response = server
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
.await?;