mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## What changed Move permission selection into `codex-config` with a shared `PermissionConfig` representation for legacy sandbox settings and named profiles. Resolve selectors using config layer precedence while preserving explicit session profile selection and sandbox mode overrides. Share legacy permission translation between config derivation and core loading, preserving merged workspace roots, network access, temporary-directory exclusions, and platform sandbox availability without modifying source layers or field origins. ## Testing Add coverage for mixed selector precedence, merged legacy settings, unchanged source metadata, and the Windows read-only fallback. Extend the managed preferences loader test to verify settings merged across layers and the absence of an active named profile for legacy permissions. GitOrigin-RevId: a435be7af38424ac33711e6a7557f52b9b672577
977 lines
36 KiB
Rust
977 lines
36 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> {
|
||
crate::boxed_future!(App::run(
|
||
tui,
|
||
initial_backends,
|
||
config.clone(),
|
||
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);
|
||
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, @"
|
||
› Ask Codex to do anything
|
||
|
||
GPT-6.1-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(())
|
||
}
|