mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## Why Fresh TUI sessions sent the locally resolved approval policy in `thread/start`, overriding the app server's configured default. Local constraints could also prevent the TUI from adopting the policy returned by the server. ## What changed - Send explicit approval policy overrides at startup and otherwise let the server resolve the policy. Preserve the resolved-config behavior for selected profiles. - Forward granular `approval_policy` overrides with their replacement and dotted-key merge semantics. - Forward eligible projectless approval defaults only when allowed by the server's approval policy requirements. - Accept the server's startup policy before submitting initial or queued input, including when local constraints would reject it. ## Testing Extend startup tests to cover explicit override precedence, granular policy merging, projectless defaults, and use of the server's approval policy on the first turn. GitOrigin-RevId: 995ce5f21b04b058d60c2ea80a139c0cf48c0e98
872 lines
33 KiB
Rust
872 lines
33 KiB
Rust
//! 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> {
|
||
App::run(
|
||
tui,
|
||
initial_backends,
|
||
config.clone(),
|
||
config.cwd.to_path_buf(),
|
||
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(())
|
||
}
|
||
|
||
#[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!(recorded_params(&requests, "config/read").is_empty());
|
||
drop(run);
|
||
proxy.abort();
|
||
Ok(())
|
||
}
|
||
|
||
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),
|
||
] {
|
||
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" => 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) = if choice == "embedded_saved" {
|
||
(AppServerTarget::Embedded, &client_home)
|
||
} else {
|
||
(remote_target(), &server_home)
|
||
};
|
||
let mut launch_choices = crate::app_server_session::StartupLaunchChoices::from_launch(
|
||
&cli_kv_overrides,
|
||
&harness_overrides,
|
||
&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()));
|
||
assert!(
|
||
prepare_fresh_startup_config(
|
||
&mut config,
|
||
&server,
|
||
&target,
|
||
&cli_kv_overrides,
|
||
&harness_overrides,
|
||
&EnvironmentManager::default_for_tests(),
|
||
)
|
||
.await?
|
||
.server_defaults_read
|
||
);
|
||
bootstrap_server_owned_start(
|
||
&mut server,
|
||
&mut config,
|
||
&mut launch_choices,
|
||
/*server_defaults_read*/ true,
|
||
&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?;
|
||
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 choice == "saved" {
|
||
assert_eq!(started.session.approvals_reviewer, ApprovalsReviewer::User);
|
||
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(),
|
||
AskForApproval::OnRequest.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_eq!(turn["approvalsReviewer"], "user");
|
||
assert_eq!(turn["approvalPolicy"], "on-request");
|
||
}
|
||
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, "stale-client-model");
|
||
let defaults_read = prepare_fresh_startup_config(
|
||
&mut config,
|
||
&server,
|
||
&target,
|
||
&[],
|
||
&ConfigOverrides::default(),
|
||
&EnvironmentManager::default_for_tests(),
|
||
)
|
||
.await?;
|
||
assert!(defaults_read.server_defaults_read);
|
||
assert!(!defaults_read.prompt_windows_sandbox);
|
||
assert_eq!(config.model, None);
|
||
let selected_model = startup_model(&config, &bootstrap, defaults_read.server_defaults_read);
|
||
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);
|
||
assert!(
|
||
!started
|
||
.session
|
||
.permission_profile
|
||
.file_system_sandbox_policy()
|
||
.can_write_local_path_with_cwd(
|
||
started.session.cwd.as_path(),
|
||
started.session.cwd.as_path()
|
||
)
|
||
);
|
||
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, @r"
|
||
› Ask Codex to do anything
|
||
|
||
GPT-6.1-Sol high · <PROJECT>
|
||
");
|
||
}
|
||
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_falls_back_only_for_unsupported_config_read() -> Result<()> {
|
||
for capabilities in [
|
||
HistoryCapabilities::ConfigReadUnsupported(-32601),
|
||
HistoryCapabilities::ConfigReadUnsupported(-32600),
|
||
] {
|
||
let home = tempdir()?;
|
||
std::fs::write(
|
||
home.path().join("config.toml"),
|
||
"model = \"client-model\"\nmodel_reasoning_effort = \"low\"\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_app_server_with_history(
|
||
&config,
|
||
capabilities,
|
||
/*blocked_thread_list*/ None,
|
||
/*failed_thread_name*/ None,
|
||
crate::app_server_session::ThreadParamsMode::Embedded,
|
||
LoaderOverrides::default(),
|
||
)
|
||
.await?;
|
||
let bootstrap = server.bootstrap(&config).await?;
|
||
run_until_thread_start(server, config, bootstrap, &requests).await?;
|
||
let starts = recorded_params(&requests, "thread/start");
|
||
assert_eq!(starts.len(), 1);
|
||
assert_eq!(
|
||
(
|
||
&starts[0]["model"],
|
||
&starts[0]["config"]["model_reasoning_effort"]
|
||
),
|
||
(&serde_json::Value::Null, &serde_json::Value::Null)
|
||
);
|
||
tokio::time::timeout(Duration::from_secs(/*secs*/ 15), proxy).await???;
|
||
}
|
||
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),
|
||
);
|
||
tokio::time::timeout(Duration::from_secs(/*secs*/ 15), 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 bootstrap_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 tui = crate::tui::test_support::make_test_tui()?;
|
||
let (result, ()) = tokio::join!(
|
||
run_startup_for_test(
|
||
&mut tui,
|
||
InitialBackendSessions::multiple(first, vec![second]),
|
||
app.config.clone(),
|
||
/*bootstrap*/ None,
|
||
SessionSelection::StartFresh,
|
||
AppServerTarget::Embedded,
|
||
),
|
||
async {
|
||
let request = first_commands.recv().await.expect("initial account read");
|
||
assert!(matches!(
|
||
request.operation,
|
||
CloudOperation::Request(request)
|
||
if matches!(*request, codex_app_server_protocol::ClientRequest::GetAccount { .. })
|
||
));
|
||
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("account/read"));
|
||
Ok(())
|
||
}
|