Files
codex/codex-rs/tui/src/app/tests/startup_defaults_tests.rs
T
Eric Traut b82943092c Preserve app-server thread working directories across platforms (#62375)
## Why

A remote app server can report a working directory in a different path
convention from the client. Decoding a Windows drive path as a client-native
absolute path can make a Unix client reject the thread response.

## What changed

Keep thread `cwd` values as server-native strings in summaries, settings,
and start, resume, and fork responses. Preserve the JSON and generated SDK
types. In the TUI, store the session directory as a `PathUri` using the
server's path convention when available. Use that directory to match diff
and skill results and to display the project name in the terminal title.

## Testing

Add regression coverage for foreign-path response round trips, diff results
matched against a remote session directory, and terminal titles derived
from a Windows path. Verify that the server rejects a working directory
that cannot be encoded as UTF-8.

GitOrigin-RevId: 600f0b531939db4cd4ec884de166224082995e00
2026-11-18 22:13:26 +00:00

976 lines
36 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Startup boundary coverage for server defaults and connection ownership.
use super::*;
use crate::app::backend_sessions::InitialBackendSessions;
use crate::app::startup::prepare_fresh_startup_config;
use crate::app::startup::startup_model;
use crate::app::startup_bootstrap::bootstrap_server_owned_start;
use pretty_assertions::assert_eq;
fn remote_target() -> AppServerTarget {
AppServerTarget::Remote {
endpoint: crate::RemoteAppServerEndpoint::WebSocket {
websocket_url: "ws://127.0.0.1:1".into(),
auth_token: None,
},
}
}
pub(super) async fn run_startup_for_test(
tui: &mut crate::tui::Tui,
initial_backends: InitialBackendSessions,
config: Config,
bootstrap: Option<AppServerBootstrap>,
selection: SessionSelection,
app_server_target: AppServerTarget,
) -> Result<AppExitInfo> {
crate::boxed_future!(App::run(
tui,
initial_backends,
config.clone(),
Default::default(),
config.cwd.to_path_buf(),
backend_selection::BackendPreferenceContext::new(
&config,
crate::backend_preference_local_cwd(
config.cwd.as_path(),
&app_server_target,
&EnvironmentManager::default_for_tests(),
),
),
Vec::new(),
ConfigOverrides::default(),
LoaderOverrides::default(),
CloudConfigBundleLoader::default(),
/*initial_prompt*/ None,
Vec::new(),
selection,
codex_feedback::CodexFeedback::new(),
/*is_first_run*/ false,
/*should_prompt_windows_sandbox_nux_at_startup*/ false,
app_server_target,
/*state_db*/ None,
Arc::new(EnvironmentManager::default_for_tests()),
Duration::ZERO,
bootstrap,
/*startup_hooks_browser*/ None,
/*daemon_startup_warning*/ None,
/*managed_daemon*/ false,
crate::startup_draft::tests::quiet_startup_test_pump(),
/*managed_worktree*/ None,
/*daemon_cli_executable*/ None,
))
.await
}
#[tokio::test]
async fn agents_overview_startup_restores_saved_grouping() -> Result<()> {
let home = tempdir()?;
std::fs::write(
home.path().join("config.toml"),
"[tui]\nagents_overview_grouping = \"status\"\nanimations = false\n",
)?;
let config = ConfigBuilder::default()
.codex_home(home.path().to_path_buf())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
.build()
.await?;
let (mut server, requests, proxy) = start_recording_remote_app_server(&config).await?;
let bootstrap = server.bootstrap(&config).await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
tui.pause_events();
let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:4500")?;
let mut run = Box::pin(run_startup_for_test(
&mut tui,
InitialBackendSessions::singleton(server),
config,
Some(bootstrap),
SessionSelection::AgentsOverview,
AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint,
},
));
tokio::time::timeout(Duration::from_secs(/*secs*/ 15), async {
loop {
if !recorded_params(&requests, "thread/list").is_empty() {
return Ok::<(), color_eyre::eyre::Report>(());
}
tokio::select! {
_ = &mut run => return Ok(()),
() = tokio::time::sleep(Duration::from_millis(/*millis*/ 20)) => {}
}
}
})
.await??;
drop(run);
let buffer = crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal);
let rendered = buffer
.content
.chunks(buffer.area.width as usize)
.map(|row| {
row.iter()
.map(ratatui::buffer::Cell::symbol)
.collect::<String>()
})
.collect::<Vec<_>>()
.join("\n");
let grouping_header = rendered
.lines()
.find(|line| line.contains("Group:"))
.expect("production startup renders Command Center grouping")
.trim();
insta::assert_snapshot!(grouping_header, @"Agent command center Group: Status g");
proxy.abort();
Ok(())
}
fn layered_config_read_count(requests: &RecordedRequests) -> usize {
recorded_params(requests, "config/read")
.iter()
.filter(|params| params["includeLayers"] == true)
.count()
}
#[tokio::test]
async fn cli_fork_omits_implicit_model_and_effort() -> Result<()> {
let home = tempdir()?;
std::fs::write(
home.path().join("config.toml"),
"model = \"gpt-5.5\"\nmodel_reasoning_effort = \"low\"\nfeatures.fast_mode = true\n",
)?;
let config = ConfigBuilder::default()
.codex_home(home.path().to_path_buf())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
.build()
.await?;
let source = ThreadId::from_string(
&app_test_support::create_fake_rollout(
home.path(),
"2026-01-01T00-00-00",
"2026-01-01T00:00:00Z",
"source prompt",
Some(config.model_provider_id.as_str()),
/*git_info*/ None,
)
.expect("create source rollout"),
)?;
let (mut server, requests, proxy) = start_recording_remote_app_server(&config).await?;
let backend_id = server.backend_id();
let mut bootstrap = server.bootstrap(&config).await?;
let mut target_preset = bootstrap
.available_models
.iter()
.find(|preset| preset.show_in_picker)
.expect("visible migration target")
.clone();
target_preset.id = "server-model".into();
target_preset.model = "server-model".into();
bootstrap.available_models.push(target_preset);
let client_preset = bootstrap
.available_models
.iter_mut()
.find(|preset| preset.model == "gpt-5.5")
.expect("client model in catalog");
client_preset.upgrade = Some(codex_protocol::openai_models::ModelUpgrade {
id: "server-model".into(),
migration_config_key: "test-fork-migration".into(),
model_link: None,
upgrade_copy: None,
migration_markdown: None,
retirement_at: None,
});
assert!(
crate::app::startup_prompts::should_show_model_migration_prompt(
"openai",
"gpt-5.5",
"server-model",
&Default::default(),
&bootstrap.available_models,
)
);
std::fs::write(
home.path().join("config.toml"),
"model = \"server-model\"\nmodel_reasoning_effort = \"high\"\n",
)?;
let mut tui = crate::tui::test_support::make_test_tui()?;
let mut run = Box::pin(run_startup_for_test(
&mut tui,
InitialBackendSessions::singleton(server),
config,
Some(bootstrap),
SessionSelection::Fork(crate::resume_picker::SessionTarget {
backend_id,
path: None,
thread_id: source,
cwd: None,
history_mode: None,
}),
AppServerTarget::Embedded,
));
tokio::time::timeout(Duration::from_secs(/*secs*/ 15), async {
loop {
if !recorded_params(&requests, "thread/fork").is_empty() {
return Ok::<(), color_eyre::eyre::Report>(());
}
tokio::select! {
result = &mut run => {
result?;
return Err(color_eyre::eyre::eyre!("startup exited before thread/fork"));
}
() = tokio::time::sleep(Duration::from_millis(/*millis*/ 20)) => {}
}
}
})
.await??;
let fork = recorded_params(&requests, "thread/fork");
assert_eq!(fork.len(), 1);
assert_eq!(fork[0]["model"], serde_json::Value::Null);
assert!(fork[0]["config"].get("model_reasoning_effort").is_none());
assert_eq!(fork[0]["serviceTier"], serde_json::Value::Null);
assert_eq!(layered_config_read_count(&requests), 0);
drop(run);
proxy.abort();
Ok(())
}
// These tests drop startup with thread/start still in flight. Its recorder
// can still be waiting for a reply after the request assertions have passed.
async fn stop_interrupted_startup_recorder(
proxy: tokio::task::JoinHandle<Result<()>>,
) -> Result<()> {
proxy.abort();
match tokio::time::timeout(Duration::from_secs(15), proxy).await? {
Err(error) if error.is_cancelled() => Ok(()),
result => result?,
}
}
async fn run_until_thread_start(
server: AppServerSession,
config: Config,
bootstrap: AppServerBootstrap,
requests: &RecordedRequests,
) -> Result<()> {
let mut tui = crate::tui::test_support::make_test_tui()?;
tui.pause_events();
let mut run = Box::pin(run_startup_for_test(
&mut tui,
InitialBackendSessions::singleton(server),
config,
Some(bootstrap),
SessionSelection::StartFresh,
AppServerTarget::Embedded,
));
tokio::time::timeout(Duration::from_secs(/*secs*/ 15), async {
loop {
if !recorded_params(requests, "thread/start").is_empty() {
return Ok::<(), color_eyre::eyre::Report>(());
}
tokio::select! {
result = &mut run => {
result?;
return Err(color_eyre::eyre::eyre!("startup exited before thread/start"));
}
() = tokio::time::sleep(Duration::from_millis(/*millis*/ 20)) => {}
}
}
})
.await??;
Ok(())
}
#[tokio::test]
async fn fresh_startup_uses_server_defaults_with_explicit_and_managed_precedence() -> Result<()> {
for (choice, managed, expected_model, expected_effort, expected_provider) in [
("saved", false, None, None, None),
("embedded_saved", false, None, None, None),
("typed_reviewer", false, None, None, None),
("kv_reviewer", false, None, None, None),
("cli_model", true, Some("cli-model"), None, None),
("kv_model", false, Some("kv-model"), None, None),
(
"migration",
false,
Some("upgraded-model"),
Some("high"),
None,
),
("cli_effort", true, None, Some("low"), None),
("cli_provider", false, None, None, Some("openai")),
("kv_provider", false, None, None, Some("openai")),
(
"profile_model",
false,
Some("profile-model"),
Some("high"),
None,
),
(
"profile_effort",
false,
Some("server-model"),
Some("low"),
None,
),
("managed", true, Some("managed-model"), Some("medium"), None),
]
.into_iter()
.chain(
["managed_embedded", "managed_daemon", "managed_remote"].map(|choice| {
(
choice,
true,
Some("managed-model"),
Some("medium"),
Some("openai"),
)
}),
) {
let client_home = tempdir()?;
let server_home = tempdir()?;
std::fs::write(
client_home.path().join("config.toml"),
r#"
model = "client-model"
model_reasoning_effort = "low"
model_provider = "client-provider"
approval_policy = "never"
approvals_reviewer = "auto_review"
[model_providers.client-provider]
name = "Client provider"
base_url = "http://127.0.0.1:9/v1"
wire_api = "responses"
requires_openai_auth = false
"#,
)?;
std::fs::write(
server_home.path().join("config.toml"),
match choice {
"managed" => "",
"kv_reviewer" => {
"model = \"server-model\"\napproval_policy = { granular = { sandbox_approval = false, rules = false, request_permissions = true, mcp_elicitations = false } }\n"
}
_ => {
"model = \"server-model\"\nmodel_reasoning_effort = \"high\"\napproval_policy = \"on-request\"\napprovals_reviewer = \"user\"\n"
}
},
)?;
if managed {
std::fs::write(
server_home.path().join("requirements.toml"),
"[models.new_thread]\nmodel = \"managed-model\"\nmodel_reasoning_effort = \"medium\"\n",
)?;
}
let mut harness_overrides = ConfigOverrides::default();
let mut cli_kv_overrides = Vec::new();
let mut loader_overrides = LoaderOverrides::without_managed_config_for_tests();
match choice {
"cli_model" => harness_overrides.model = Some("cli-model".to_string()),
"kv_model" => cli_kv_overrides.extend([
("model".into(), "earlier-model".into()),
("model".into(), "kv-model".into()),
("approval_policy".into(), "never".into()),
]),
"migration" => harness_overrides.model = Some("old-model".into()),
"cli_provider" => harness_overrides.model_provider = Some("openai".into()),
"kv_provider" | "managed_embedded" | "managed_daemon" | "managed_remote" => {
cli_kv_overrides.push(("model_provider".into(), "openai".into()))
}
"cli_effort" => cli_kv_overrides.push((
"model_reasoning_effort".to_string(),
TomlValue::String("low".to_string()),
)),
"typed_reviewer" => {
harness_overrides.approval_policy = Some(AskForApproval::OnRequest.to_core());
harness_overrides.approvals_reviewer = Some(ApprovalsReviewer::User);
cli_kv_overrides.push(("approval_policy".into(), "never".into()));
cli_kv_overrides.push(("approvals_reviewer".into(), "auto_review".into()));
}
"kv_reviewer" => {
cli_kv_overrides.extend([
("approvals_reviewer".into(), "user".into()),
("approvals_reviewer".into(), "auto_review".into()),
]);
cli_kv_overrides.extend(
["sandbox_approval", "rules", "mcp_elicitations"]
.map(|key| (format!("approval_policy.granular.{key}"), true.into())),
);
}
"profile_model" | "profile_effort" => {
let path = client_home.path().join("work.config.toml");
std::fs::write(
&path,
if choice == "profile_model" {
"model = \"profile-model\"\n"
} else {
"model_reasoning_effort = \"low\"\n"
},
)?;
loader_overrides.user_config_path = Some(path.abs());
loader_overrides.user_config_profile = Some("work".parse()?);
}
_ => {}
}
let (target, server_home) = match choice {
"embedded_saved" => (AppServerTarget::Embedded, &client_home),
"managed_embedded" => (AppServerTarget::Embedded, &server_home),
"managed_daemon" => (
AppServerTarget::LocalDaemon {
endpoint: crate::resolve_remote_addr("ws://127.0.0.1:4500")?,
allow_embedded_fallback: true,
},
&server_home,
),
_ => (remote_target(), &server_home),
};
let mut launch_choices = crate::app_server_session::StartupLaunchChoices::from_launch(
&cli_kv_overrides,
&harness_overrides,
&loader_overrides,
);
let server_owned = crate::app::startup_bootstrap::uses_server_owned_fresh_bootstrap(
&SessionSelection::StartFresh,
&loader_overrides,
);
let mut config = ConfigBuilder::default()
.codex_home(client_home.path().to_path_buf())
.loader_overrides(loader_overrides)
.cli_overrides(cli_kv_overrides.clone())
.harness_overrides(harness_overrides.clone())
.build()
.await?;
let mut server_config = config.clone();
server_config.codex_home = server_home.path().to_path_buf().abs();
server_config.sqlite = SqliteConfig::new_for_testing(server_home.path().abs());
server_config.model_catalog = Some(Default::default());
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&server_config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
target.thread_params_mode(),
LoaderOverrides {
user_config_path: Some(server_home.path().join("config.toml").abs()),
system_requirements_path: Some(server_home.path().join("requirements.toml")),
..LoaderOverrides::default()
},
)
.await?;
server = server.with_remote_cwd_override(Some(server_config.cwd.to_path_buf()));
if !server_owned {
server.bootstrap(&config).await?;
}
prepare_fresh_startup_config(
&mut config,
&server,
&target,
&cli_kv_overrides,
&harness_overrides,
&EnvironmentManager::default_for_tests(),
)
.await?;
if server_owned {
bootstrap_server_owned_start(
&mut server,
&mut config,
&mut launch_choices,
&cli_kv_overrides,
&harness_overrides,
)
.await?;
}
if choice == "migration" {
let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
apply_accepted_model_migration(
&mut config,
&mut launch_choices,
&AppEventSender::new(tx),
"old-model".into(),
"upgraded-model".into(),
ReasoningEffortConfig::High,
);
}
let started = crate::app_server_session::start_thread_with_request_handle(
server.request_handle(),
&crate::local_settings::LocalSettings::from(&config),
config,
server.thread_params_mode(),
server.remote_cwd_override().map(Path::to_path_buf),
server.thread_tool_transport(),
launch_choices,
)
.await?;
if choice.starts_with("managed_") {
assert_eq!(started.session.model, "managed-model");
assert_eq!(
started.session.reasoning_effort,
Some(ReasoningEffortConfig::Medium)
);
}
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 1, "{choice}");
let expected_reviewer = match choice {
"kv_reviewer" | "profile_model" | "profile_effort" => Some("auto_review"),
"typed_reviewer" => Some("user"),
_ => None,
};
assert_eq!(
starts[0]["approvalsReviewer"],
serde_json::json!(expected_reviewer),
"{choice}"
);
let expected_policy = match choice {
"typed_reviewer" => Some(AskForApproval::OnRequest),
"kv_model" | "profile_model" | "profile_effort" => Some(AskForApproval::Never),
_ => None,
};
assert_eq!(
starts[0]["approvalPolicy"],
serde_json::json!(expected_policy),
"{choice}"
);
if choice == "kv_reviewer" {
assert_eq!(
started.session.approval_policy,
AskForApproval::Granular {
sandbox_approval: true,
rules: true,
skill_approval: false,
request_permissions: true,
mcp_elicitations: true,
}
);
}
if choice == "embedded_saved" {
assert_eq!(
started.session.approvals_reviewer,
ApprovalsReviewer::AutoReview
);
}
assert_eq!(
(
starts[0]["model"].clone(),
starts[0]["config"].get("model_reasoning_effort").cloned(),
starts[0]["modelProvider"].clone()
),
(
serde_json::json!(expected_model),
expected_effort.map(serde_json::Value::from),
serde_json::json!(expected_provider),
),
"{choice}"
);
assert_eq!(
recorded_params(&requests, "config/read")
.into_iter()
.filter(|params| !params["cwd"].is_null())
.collect::<Vec<_>>(),
vec![
serde_json::json!({"cwd": server_config.cwd.display().to_string(), "includeLayers": true})
],
);
if matches!(choice, "saved" | "embedded_saved") {
let expected_turn_policy = if choice == "saved" {
AskForApproval::OnRequest
} else {
AskForApproval::Never
};
assert_eq!(
started.session.approvals_reviewer,
if choice == "saved" {
ApprovalsReviewer::User
} else {
ApprovalsReviewer::AutoReview
}
);
let (mut app, _events, mut ops) = make_test_app_with_channels().await;
app.app_server_target = target;
app.config.permissions.approval_policy =
codex_config::Constrained::allow_only(AskForApproval::Never.to_core());
app.set_approvals_reviewer_in_app_and_widget(ApprovalsReviewer::AutoReview);
app.pending_startup_thread_start = true;
let thread_id = started.session.thread_id;
app.handle_startup_thread_started(&mut server, Ok(started))
.await?;
assert_eq!(
app.config.permissions.approval_policy.value(),
expected_turn_policy.to_core()
);
app.chat_widget.insert_str("first turn");
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Enter));
app.submit_thread_op(&mut server, thread_id, next_user_turn_op(&mut ops))
.await?;
let turn = &recorded_params(&requests, "turn/start")[0];
assert!(turn["approvalsReviewer"].is_null());
assert_eq!(
turn["approvalPolicy"],
serde_json::json!(expected_turn_policy)
);
}
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn fresh_startup_reads_destination_and_cleared_model_uses_catalog() -> Result<()> {
for (remote, override_cwd) in [(false, false), (true, false), (true, true)] {
let client_home = tempdir()?;
let server_home = tempdir()?;
let destination = tempdir()?;
let launch_cwd = tempdir()?;
std::fs::write(
client_home.path().join("config.toml"),
"model = \"stale-client-model\"\nmodel_reasoning_effort = \"low\"\nmodel_reasoning_summary = \"detailed\"\nfeatures.concurrent_reasoning_summaries = true\n",
)?;
std::fs::write(
server_home.path().join("config.toml"),
"model_reasoning_effort = \"high\"\nsandbox_mode = \"read-only\"\nmodel_reasoning_summary = \"concise\"\n",
)?;
let mut config = ConfigBuilder::default()
.codex_home(client_home.path().to_path_buf())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
.harness_overrides(ConfigOverrides {
cwd: Some(destination.path().to_path_buf()),
..Default::default()
})
.build()
.await?;
let mut server_config = config.clone();
server_config.codex_home = server_home.path().to_path_buf().abs();
server_config.sqlite = SqliteConfig::new_for_testing(server_home.path().abs());
let mode = if remote {
crate::app_server_session::ThreadParamsMode::Remote
} else {
crate::app_server_session::ThreadParamsMode::Embedded
};
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&server_config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
mode,
LoaderOverrides {
user_config_path: Some(server_home.path().join("config.toml").abs()),
..LoaderOverrides::default()
},
)
.await?;
if override_cwd {
server = server.with_remote_cwd_override(Some(launch_cwd.path().to_path_buf()));
}
if !remote {
// Direct starts must inherit summaries even without a preceding defaults read.
server.start_thread(&config).await?;
}
assert!(config.config_layer_stack.is_projectless());
let target = if remote {
remote_target()
} else {
AppServerTarget::Embedded
};
let bootstrap = server.bootstrap(&config).await?;
assert_eq!(
bootstrap.default_model.as_deref(),
Some("stale-client-model")
);
let defaults_read = prepare_fresh_startup_config(
&mut config,
&server,
&target,
&[],
&ConfigOverrides::default(),
&EnvironmentManager::default_for_tests(),
)
.await?;
assert!(!defaults_read.prompt_windows_sandbox);
assert_eq!(config.model, None);
let selected_model =
startup_model(&config, &bootstrap, /*server_defaults_read*/ true)?;
assert_ne!(selected_model, "stale-client-model");
let started = crate::app_server_session::start_thread_with_request_handle(
server.request_handle(),
&crate::local_settings::LocalSettings::from(&config),
config,
server.thread_params_mode(),
server.remote_cwd_override().map(Path::to_path_buf),
server.thread_tool_transport(),
crate::app_server_session::StartupLaunchChoices::default(),
)
.await?;
assert_eq!(started.session.model, selected_model);
let cwd = started.session.cwd.to_path_buf();
assert!(
!started
.session
.permission_profile
.file_system_sandbox_policy()
.can_write_local_path_with_cwd(&cwd, &cwd)
);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), if remote { 1 } else { 2 });
let latest = starts.last().unwrap();
assert_eq!(latest["model"], serde_json::Value::Null);
assert!(latest["config"].get("model_reasoning_effort").is_none());
for start in &starts {
assert!(start["config"].get("model_reasoning_summary").is_none());
assert!(
start["config"]["features"]
.get("concurrent_reasoning_summaries")
.is_none()
);
}
let (mut app, _, _) = make_test_app_with_channels().await;
app.chat_widget.handle_thread_session_quiet(started.session);
if !remote {
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 80)
.replace(&destination.path().display().to_string(), "<PROJECT>");
insta::assert_snapshot!(rendered, @"
› Ask Codex to do anything
GPT-6.2-Sol high · <PROJECT>
? for shortcuts
");
}
let expected_cwd = if override_cwd {
launch_cwd.path().display().to_string()
} else if !remote {
destination.path().display().to_string()
} else {
".".to_string()
};
let reads = recorded_params(&requests, "config/read")
.into_iter()
.filter(|params| !params["cwd"].is_null())
.collect::<Vec<_>>();
assert!(!reads.is_empty());
assert!(
reads.iter().all(|params| params["cwd"] == expected_cwd),
"{reads:?}"
);
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn fresh_startup_observes_config_edits_after_directory_trust() -> Result<()> {
let home = tempdir()?;
let destination = tempdir()?;
std::fs::create_dir(destination.path().join(".git"))?;
let config_path = home.path().join("config.toml");
let project = serde_json::to_string(&destination.path().display().to_string())?;
let write_tier = |tier: &str| {
std::fs::write(
&config_path,
format!("service_tier = \"{tier}\"\n[projects.{project}]\ntrust_level = \"trusted\"\n"),
)
};
write_tier("priority")?;
let config = ConfigBuilder::default()
.codex_home(home.path().to_path_buf())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
.harness_overrides(ConfigOverrides {
cwd: Some(destination.path().to_path_buf()),
..Default::default()
})
.build()
.await?;
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides {
user_config_path: Some(config_path.clone().abs()),
..LoaderOverrides::default()
},
)
.await?;
let bootstrap = server.bootstrap(&config).await?;
let reads_before = layered_config_read_count(&requests);
let trust = crate::config_update::read_remote_project_trust(
server.request_handle(),
config.cwd.as_path(),
crate::config_update::ProjectTrustHost::Local,
)
.await?;
assert_eq!(trust, None);
// A different process can edit this file even when the app server is embedded.
write_tier("flex")?;
run_until_thread_start(server, config, bootstrap, &requests).await?;
let starts = recorded_params(&requests, "thread/start");
assert_eq!(
(
starts.len(),
&starts[0]["serviceTier"],
layered_config_read_count(&requests) - reads_before,
),
(1, &serde_json::json!("flex"), 2),
);
proxy.abort();
Ok(())
}
#[tokio::test]
async fn startup_reads_server_defaults_before_starting_thread() -> Result<()> {
let client_home = tempdir()?;
let server_home = tempdir()?;
let projectless_cwd = tempdir()?;
std::fs::write(
client_home.path().join("config.toml"),
"model = \"client-model\"\nmodel_reasoning_effort = \"low\"\n",
)?;
std::fs::write(
server_home.path().join("config.toml"),
"model = \"server-model\"\nmodel_reasoning_effort = \"high\"\n",
)?;
let config = ConfigBuilder::default()
.codex_home(client_home.path().to_path_buf())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
.harness_overrides(ConfigOverrides {
cwd: Some(projectless_cwd.path().to_path_buf()),
..Default::default()
})
.build()
.await?;
let mut server_config = config.clone();
server_config.codex_home = server_home.path().to_path_buf().abs();
server_config.sqlite = SqliteConfig::new_for_testing(server_home.path().abs());
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&server_config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides {
user_config_path: Some(server_home.path().join("config.toml").abs()),
..LoaderOverrides::without_managed_config_for_tests()
},
)
.await?;
let bootstrap = server.bootstrap(&config).await?;
run_until_thread_start(server, config, bootstrap, &requests).await?;
{
let recorded = requests.lock().expect("request recorder lock");
let read = recorded
.iter()
.position(|request| request.method == "config/read")
.expect("startup must read server defaults");
let start = recorded
.iter()
.position(|request| request.method == "thread/start")
.expect("startup must start a thread");
assert!(read < start);
}
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 1);
assert!(starts[0]["approvalPolicy"]["granular"].is_object());
assert_eq!(
(
&starts[0]["model"],
&starts[0]["config"]["model_reasoning_effort"]
),
(&serde_json::Value::Null, &serde_json::Value::Null),
);
stop_interrupted_startup_recorder(proxy).await?;
Ok(())
}
#[tokio::test]
async fn startup_read_failure_exits_before_thread_creation() -> Result<()> {
let (app, _, _) = make_test_app_with_channels().await;
let home = tempdir()?;
let mut config = app.config.clone();
config.codex_home = home.path().to_path_buf().abs();
config.sqlite = SqliteConfig::new_for_testing(home.path().abs());
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&config,
HistoryCapabilities::ConfigReadFails,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let bootstrap = server.bootstrap(&config).await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
let result = run_startup_for_test(
&mut tui,
InitialBackendSessions::singleton(server),
config,
Some(bootstrap),
SessionSelection::StartFresh,
AppServerTarget::Embedded,
)
.await;
insta::assert_snapshot!(result.expect_err("startup read must fail").to_string(), @"config/read failed in TUI");
assert_eq!(recorded_params(&requests, "config/read").len(), 1);
assert!(recorded_params(&requests, "thread/start").is_empty());
proxy.await??;
Ok(())
}
#[tokio::test]
async fn startup_failure_shuts_down_every_initial_backend() -> Result<()> {
use codex_app_server_client::AppServerClient;
use codex_app_server_client::CloudClient;
use codex_app_server_client::CloudOperation;
let app = make_test_app().await;
let (first, mut first_commands, _first_events) = CloudClient::channel(/*capacity*/ 1);
let (second, mut second_commands, _second_events) = CloudClient::channel(/*capacity*/ 1);
let [first, second] = [first, second].map(|client| {
AppServerSession::new(
crate::backend_id::BackendId::new(),
AppServerClient::Cloud(client),
crate::app_server_session::ThreadParamsMode::Embedded,
)
});
let mut initial_backends = InitialBackendSessions::singleton(first);
initial_backends.register(
second,
AppServerTarget::Embedded,
app.config.clone(),
app.local_settings.clone(),
);
let mut tui = crate::tui::test_support::make_test_tui()?;
let (result, ()) = tokio::join!(
run_startup_for_test(
&mut tui,
initial_backends,
app.config.clone(),
/*bootstrap*/ None,
SessionSelection::StartFresh,
AppServerTarget::Embedded,
),
async {
let request = first_commands.recv().await.expect("initial config read");
assert!(matches!(
request.operation,
CloudOperation::Request(request)
if matches!(*request, codex_app_server_protocol::ClientRequest::ConfigRead { .. })
));
request
.response
.send(Err(std::io::Error::other("bootstrap unavailable")))
.unwrap();
for commands in [&mut first_commands, &mut second_commands] {
let command = commands.recv().await.expect("startup shutdown");
assert!(matches!(command.operation, CloudOperation::Shutdown));
command
.response
.send(Ok(Ok(serde_json::Value::Null)))
.unwrap();
}
}
);
assert!(result.unwrap_err().to_string().contains("config/read"));
Ok(())
}