diff --git a/codex-rs/app-server-protocol/src/protocol/thread_history.rs b/codex-rs/app-server-protocol/src/protocol/thread_history.rs index 9f7ffa4447..ca8487b792 100644 --- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs +++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs @@ -600,6 +600,7 @@ impl ThreadHistoryBuilder { let should_upsert = match item { codex_protocol::items::TurnItem::Plan(plan) => !plan.text.is_empty(), codex_protocol::items::TurnItem::Sleep(_) + | codex_protocol::items::TurnItem::HookPrompt(_) | codex_protocol::items::TurnItem::CommandExecution(_) | codex_protocol::items::TurnItem::DynamicToolCall(_) | codex_protocol::items::TurnItem::CollabAgentToolCall(_) @@ -608,7 +609,6 @@ impl ThreadHistoryBuilder { | codex_protocol::items::TurnItem::EnteredReviewMode(_) | codex_protocol::items::TurnItem::ExitedReviewMode(_) => true, codex_protocol::items::TurnItem::UserMessage(_) - | codex_protocol::items::TurnItem::HookPrompt(_) | codex_protocol::items::TurnItem::AgentMessage(_) | codex_protocol::items::TurnItem::Reasoning(_) | codex_protocol::items::TurnItem::WebSearch(_) @@ -4027,6 +4027,37 @@ mod tests { ); } + #[test] + fn canonical_hook_prompt_completion_updates_turn_history() { + let hook_prompt = CoreTurnItem::HookPrompt(codex_protocol::items::HookPromptItem { + id: "hook-prompt-1".into(), + fragments: vec![CoreHookPromptFragment::from_single_hook( + "Retry with tests.", + "hook-run-1", + )], + }); + let expected_item = ThreadItem::from(hook_prompt.clone()); + let mut builder = ThreadHistoryBuilder::new(); + builder.handle_event(&EventMsg::TurnStarted(TurnStartedEvent { + turn_id: "turn-a".into(), + trace_id: None, + started_at: None, + model_context_window: None, + collaboration_mode_kind: Default::default(), + })); + builder.handle_event(&EventMsg::ItemCompleted(ItemCompletedEvent { + thread_id: ThreadId::new(), + turn_id: "turn-a".into(), + item: hook_prompt, + completed_at_ms: 0, + })); + + assert_eq!( + builder.active_turn_snapshot().expect("active turn").items, + vec![expected_item] + ); + } + #[test] fn ignores_plain_user_response_items_in_rollout_replay() { let items = vec![ diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index db5e505eb4..829aa3f126 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -89,7 +89,6 @@ use codex_core::ThreadManager; use codex_protocol::ThreadId; use codex_protocol::items::CollabAgentTool as CoreCollabAgentTool; use codex_protocol::items::TurnItem as CoreTurnItem; -use codex_protocol::items::parse_hook_prompt_message; use codex_protocol::models::AdditionalPermissionProfile as CoreAdditionalPermissionProfile; use codex_protocol::plan_tool::UpdatePlanArgs; use codex_protocol::protocol::CodexErrorInfo as CoreCodexErrorInfo; @@ -1022,13 +1021,6 @@ pub(crate) async fn apply_bespoke_event_handling( .await; } EventMsg::RawResponseItem(raw_response_item_event) => { - maybe_emit_hook_prompt_item_completed( - conversation_id, - &event_turn_id, - &raw_response_item_event.item, - &outgoing, - ) - .await; maybe_emit_raw_response_item_completed( conversation_id, &event_turn_id, @@ -1406,45 +1398,6 @@ async fn maybe_emit_raw_response_item_completed( .await; } -pub(crate) async fn maybe_emit_hook_prompt_item_completed( - conversation_id: ThreadId, - turn_id: &str, - item: &codex_protocol::models::ResponseItem, - outgoing: &ThreadScopedOutgoingMessageSender, -) { - let codex_protocol::models::ResponseItem::Message { - role, content, id, .. - } = item - else { - return; - }; - - if role != "user" { - return; - } - - let Some(hook_prompt) = parse_hook_prompt_message(id.as_ref(), content) else { - return; - }; - - let notification = ItemCompletedNotification { - thread_id: conversation_id.to_string(), - turn_id: turn_id.to_string(), - completed_at_ms: now_unix_timestamp_ms(), - item: ThreadItem::HookPrompt { - id: hook_prompt.id, - fragments: hook_prompt - .fragments - .into_iter() - .map(codex_app_server_protocol::HookPromptFragment::from) - .collect(), - }, - }; - outgoing - .send_server_notification(ServerNotification::ItemCompleted(notification)) - .await; -} - async fn find_and_remove_turn_summary( _conversation_id: ThreadId, thread_state: &Arc>, @@ -2104,10 +2057,8 @@ mod tests { use codex_protocol::AgentPath; use codex_protocol::items::DynamicToolCallItem; use codex_protocol::items::DynamicToolCallStatus as CoreDynamicToolCallStatus; - use codex_protocol::items::HookPromptFragment; use codex_protocol::items::SubAgentActivityItem; use codex_protocol::items::TurnItem as CoreTurnItem; - use codex_protocol::items::build_hook_prompt_message; use codex_protocol::models::FileSystemPermissions as CoreFileSystemPermissions; use codex_protocol::models::NetworkPermissions as CoreNetworkPermissions; use codex_protocol::models::PermissionProfile; @@ -3993,55 +3944,4 @@ mod tests { assert!(rx.try_recv().is_err(), "no extra messages expected"); Ok(()) } - - #[tokio::test] - async fn test_hook_prompt_raw_response_emits_item_completed() -> Result<()> { - let (tx, mut rx) = mpsc::channel(CHANNEL_CAPACITY); - let outgoing = Arc::new(OutgoingMessageSender::new( - tx, - codex_analytics::AnalyticsEventsClient::disabled(), - )); - let conversation_id = ThreadId::new(); - let outgoing = ThreadScopedOutgoingMessageSender::new( - outgoing, - vec![ConnectionId(1)], - conversation_id, - ); - let item = build_hook_prompt_message(&[ - HookPromptFragment::from_single_hook("Retry with tests.", "hook-run-1"), - HookPromptFragment::from_single_hook("Then summarize cleanly.", "hook-run-2"), - ]) - .expect("hook prompt message"); - - maybe_emit_hook_prompt_item_completed(conversation_id, "turn-1", &item, &outgoing).await; - - let msg = recv_broadcast_message(&mut rx).await?; - match msg { - OutgoingMessage::AppServerNotification(ServerNotification::ItemCompleted( - notification, - )) => { - assert_eq!(notification.thread_id, conversation_id.to_string()); - assert_eq!(notification.turn_id, "turn-1"); - assert_eq!( - notification.item, - ThreadItem::HookPrompt { - id: notification.item.id().to_string(), - fragments: vec![ - codex_app_server_protocol::HookPromptFragment { - text: "Retry with tests.".into(), - hook_run_id: "hook-run-1".into(), - }, - codex_app_server_protocol::HookPromptFragment { - text: "Then summarize cleanly.".into(), - hook_run_id: "hook-run-2".into(), - }, - ], - } - ); - } - other => bail!("unexpected message: {other:?}"), - } - assert!(rx.try_recv().is_err(), "no extra messages expected"); - Ok(()) - } } diff --git a/codex-rs/app-server/src/request_processors.rs b/codex-rs/app-server/src/request_processors.rs index 42ec2063b4..a7a1f6ce81 100644 --- a/codex-rs/app-server/src/request_processors.rs +++ b/codex-rs/app-server/src/request_processors.rs @@ -1,5 +1,4 @@ use crate::bespoke_event_handling::apply_bespoke_event_handling; -use crate::bespoke_event_handling::maybe_emit_hook_prompt_item_completed; use crate::command_exec::CommandExecManager; use crate::command_exec::StartCommandExecParams; use crate::config_manager::ConfigManager; diff --git a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs index 82a49bae0b..784cd51add 100644 --- a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs +++ b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs @@ -316,6 +316,9 @@ pub(super) async fn ensure_listener_task_running( thread_state.track_current_turn_event(&event.id, &event.msg); thread_state.experimental_raw_events }; + if matches!(&event.msg, EventMsg::RawResponseItem(_)) && !raw_events_enabled { + continue; + } let subscribed_connection_ids = thread_state_manager .subscribed_connection_ids(conversation_id) .await; @@ -325,19 +328,6 @@ pub(super) async fn ensure_listener_task_running( conversation_id, ); - if let EventMsg::RawResponseItem(raw_response_item_event) = &event.msg - && !raw_events_enabled - { - maybe_emit_hook_prompt_item_completed( - conversation_id, - &event.id, - &raw_response_item_event.item, - &thread_outgoing, - ) - .await; - continue; - } - apply_bespoke_event_handling( event.clone(), conversation_id, diff --git a/codex-rs/core/src/session/step_context.rs b/codex-rs/core/src/session/step_context.rs index 3210eb0286..1d7316d914 100644 --- a/codex-rs/core/src/session/step_context.rs +++ b/codex-rs/core/src/session/step_context.rs @@ -5,6 +5,8 @@ use crate::environment_selection::TurnEnvironmentSnapshot; use crate::session::McpRuntimeSnapshot; use crate::session::turn_context::TurnContext; use codex_exec_server::ResolvedSelectedCapabilityRoot; +use codex_mcp::ToolInfo; +use tokio::sync::OnceCell; /// Request-scoped state that may change between model sampling requests. #[derive(Debug)] @@ -15,6 +17,8 @@ pub(crate) struct StepContext { pub(crate) selected_capability_roots: Vec, /// The exact MCP config and manager used to advertise and execute tools for this step. pub(crate) mcp: Arc, + /// The fixed MCP tool list used for this exact sampling request. + mcp_tool_snapshot: OnceCell>, /// The canonical AGENTS.md value observed with this environment snapshot. pub(crate) loaded_agents_md: Option>, } @@ -32,7 +36,14 @@ impl StepContext { environments, selected_capability_roots, mcp, + mcp_tool_snapshot: OnceCell::new(), loaded_agents_md, } } + + pub(crate) async fn mcp_tools(&self) -> &[ToolInfo] { + self.mcp_tool_snapshot + .get_or_init(|| self.mcp.manager().list_all_tools()) + .await + } } diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index ac8f9d049e..90f43f2bc3 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -112,6 +112,8 @@ use codex_otel::TelemetryAuthMode; use codex_protocol::config_types::CollaborationMode; use codex_protocol::config_types::ModeKind; use codex_protocol::config_types::Settings; +use codex_protocol::items::HookPromptFragment; +use codex_protocol::items::build_hook_prompt_message; use codex_protocol::models::BaseInstructions; use codex_protocol::models::ContentItem; use codex_protocol::models::InternalChatMessageMetadataPassthrough; @@ -1763,6 +1765,44 @@ async fn record_conversation_items_stamps_missing_turn_id_and_preserves_existing ); } +#[tokio::test] +async fn record_response_item_and_emit_turn_item_emits_hook_prompt_lifecycle() { + let (session, turn_context, rx) = make_session_and_context_with_rx().await; + let response_item = build_hook_prompt_message(&[HookPromptFragment::from_single_hook( + "Retry with tests.", + "hook-run-1", + )]) + .expect("hook prompt message"); + let response_item_id = response_item.id().expect("hook prompt id").to_string(); + + session + .record_response_item_and_emit_turn_item(&turn_context, response_item) + .await; + + let raw_response = rx.recv().await.expect("raw response item event"); + assert!(matches!(raw_response.msg, EventMsg::RawResponseItem(_))); + + let started = rx.recv().await.expect("started hook prompt event"); + assert!(matches!( + started.msg, + EventMsg::ItemStarted(ItemStartedEvent { + item: TurnItem::HookPrompt(item), + .. + }) if item.id == response_item_id + )); + + let completed = rx.recv().await.expect("completed hook prompt event"); + assert!(matches!( + completed.msg, + EventMsg::ItemCompleted(ItemCompletedEvent { + item: TurnItem::HookPrompt(item), + .. + }) if item.id == response_item_id + )); + + assert!(rx.try_recv().is_err(), "no extra events expected"); +} + #[tokio::test] async fn record_inter_agent_communication_sets_turn_id_in_rollout_and_resume() { let (mut session, turn_context) = make_session_and_context().await; diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index e231f6af86..41098b2c1e 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -382,9 +382,9 @@ pub(crate) async fn run_turn( if let Some(hook_prompt_message) = build_hook_prompt_message(&stop_outcome.continuation_fragments) { - sess.record_conversation_items( + sess.record_response_item_and_emit_turn_item( &turn_context, - std::slice::from_ref(&hook_prompt_message), + hook_prompt_message, ) .await; stop_hook_active = true; @@ -1222,8 +1222,8 @@ pub(crate) async fn built_tools( let turn_context = step_context.turn.as_ref(); let mcp_connection_manager = step_context.mcp.manager(); let has_mcp_servers = mcp_connection_manager.has_servers(); - let all_mcp_tools = mcp_connection_manager - .list_all_tools() + let all_mcp_tools = step_context + .mcp_tools() .or_cancel(cancellation_token) .await?; let loaded_plugins = sess @@ -1236,7 +1236,7 @@ pub(crate) async fn built_tools( let apps_enabled = turn_context.apps_enabled(); let accessible_connectors = - apps_enabled.then(|| connectors::accessible_connectors_from_mcp_tools(&all_mcp_tools)); + apps_enabled.then(|| connectors::accessible_connectors_from_mcp_tools(all_mcp_tools)); let accessible_connectors_with_enabled_state = accessible_connectors.as_ref().map(|connectors| { connectors::with_app_enabled_state(connectors.clone(), &turn_context.config) @@ -1329,7 +1329,7 @@ pub(crate) async fn built_tools( .await }; let mcp_tool_exposure = build_mcp_tool_exposure( - &all_mcp_tools, + all_mcp_tools, connectors.as_deref(), &turn_context.config, search_tool_enabled(turn_context), diff --git a/codex-rs/core/src/session/world_state.rs b/codex-rs/core/src/session/world_state.rs index a0d93cac83..c7743c3fe1 100644 --- a/codex-rs/core/src/session/world_state.rs +++ b/codex-rs/core/src/session/world_state.rs @@ -41,9 +41,9 @@ impl Session { } let apps_available = if turn_context.config.include_apps_instructions && turn_context.apps_enabled() { - let tools = step_context.mcp.manager().list_all_tools().await; + let tools = step_context.mcp_tools().await; connectors::with_app_enabled_state( - connectors::accessible_connectors_from_mcp_tools(&tools), + connectors::accessible_connectors_from_mcp_tools(tools), &turn_context.config, ) .into_iter() diff --git a/codex-rs/core/src/tools/events.rs b/codex-rs/core/src/tools/events.rs index 5b30c6a156..628e6ce9bc 100644 --- a/codex-rs/core/src/tools/events.rs +++ b/codex-rs/core/src/tools/events.rs @@ -3,7 +3,6 @@ use crate::session::session::Session; use crate::session::turn_context::TurnContext; use crate::tools::context::SharedTurnDiffTracker; use crate::tools::sandboxing::ToolError; -use crate::turn_timing::now_unix_timestamp_ms; use codex_apply_patch::AppliedPatchDelta; use codex_protocol::error::CodexErr; use codex_protocol::error::SandboxErr; @@ -14,8 +13,6 @@ use codex_protocol::items::FileChangeItem; use codex_protocol::items::TurnItem; use codex_protocol::parse_command::ParsedCommand; use codex_protocol::protocol::EventMsg; -use codex_protocol::protocol::ExecCommandBeginEvent; -use codex_protocol::protocol::ExecCommandEndEvent; use codex_protocol::protocol::ExecCommandSource; use codex_protocol::protocol::ExecCommandStatus; use codex_protocol::protocol::FileChange; @@ -104,25 +101,6 @@ pub(crate) async fn emit_exec_command_begin( interaction_input: Option, process_id: Option<&str>, ) { - if matches!(source, ExecCommandSource::UnifiedExecInteraction) { - ctx.session - .send_event( - ctx.turn, - EventMsg::ExecCommandBegin(ExecCommandBeginEvent { - call_id: ctx.call_id.to_string(), - process_id: process_id.map(str::to_owned), - turn_id: ctx.turn.sub_id.clone(), - started_at_ms: now_unix_timestamp_ms(), - command: command.to_vec(), - cwd: cwd.clone(), - parsed_cmd: parsed_cmd.to_vec(), - source, - interaction_input, - }), - ) - .await; - return; - } ctx.session .emit_turn_item_started( ctx.turn, @@ -568,32 +546,6 @@ async fn emit_exec_end( exec_input: ExecCommandInput<'_>, exec_result: ExecCommandResult, ) { - if matches!(exec_input.source, ExecCommandSource::UnifiedExecInteraction) { - ctx.session - .send_event( - ctx.turn, - EventMsg::ExecCommandEnd(ExecCommandEndEvent { - call_id: ctx.call_id.to_string(), - process_id: exec_input.process_id.map(str::to_owned), - turn_id: ctx.turn.sub_id.clone(), - completed_at_ms: now_unix_timestamp_ms(), - command: exec_input.command.to_vec(), - cwd: exec_input.cwd.clone(), - parsed_cmd: exec_input.parsed_cmd.to_vec(), - source: exec_input.source, - interaction_input: exec_input.interaction_input.map(str::to_owned), - stdout: exec_result.stdout, - stderr: exec_result.stderr, - aggregated_output: exec_result.aggregated_output, - exit_code: exec_result.exit_code, - duration: exec_result.duration, - formatted_output: exec_result.formatted_output, - status: exec_result.status, - }), - ) - .await; - return; - } ctx.session .emit_turn_item_completed( ctx.turn, diff --git a/codex-rs/model-provider/src/amazon_bedrock/catalog.rs b/codex-rs/model-provider/src/amazon_bedrock/catalog.rs index 95e522e0c4..48c24ad5c8 100644 --- a/codex-rs/model-provider/src/amazon_bedrock/catalog.rs +++ b/codex-rs/model-provider/src/amazon_bedrock/catalog.rs @@ -19,26 +19,28 @@ pub(crate) fn static_model_catalog() -> ModelsResponse { gpt_5_bedrock_model( GPT_5_5_OPENAI_MODEL_ID, AMAZON_BEDROCK_GPT_5_5_MODEL_ID, + "GPT-5.5", /*priority*/ 0, ), gpt_5_bedrock_model( GPT_5_4_OPENAI_MODEL_ID, AMAZON_BEDROCK_GPT_5_4_MODEL_ID, + "GPT-5.4", /*priority*/ 1, ), gpt_5_6_bedrock_model( AMAZON_BEDROCK_GPT_5_6_SOL_MODEL_ID, - "Sol", + "GPT-5.6 Sol", /*priority*/ 2, ), gpt_5_6_bedrock_model( AMAZON_BEDROCK_GPT_5_6_TERRA_MODEL_ID, - "Terra", + "GPT-5.6 Terra", /*priority*/ 3, ), gpt_5_6_bedrock_model( AMAZON_BEDROCK_GPT_5_6_LUNA_MODEL_ID, - "Luna", + "GPT-5.6 Luna", /*priority*/ 4, ), ], @@ -55,9 +57,15 @@ pub(crate) fn with_default_only_service_tier(mut catalog: ModelsResponse) -> Mod catalog } -fn gpt_5_bedrock_model(openai_slug: &str, bedrock_slug: &str, priority: i32) -> ModelInfo { +fn gpt_5_bedrock_model( + openai_slug: &str, + bedrock_slug: &str, + display_name: &str, + priority: i32, +) -> ModelInfo { let mut model = bundled_openai_model(openai_slug); model.slug = bedrock_slug.to_string(); + model.display_name = display_name.to_string(); model.priority = priority; model.context_window = Some(GPT_5_BEDROCK_CONTEXT_WINDOW); model.max_context_window = Some(GPT_5_BEDROCK_CONTEXT_WINDOW); @@ -67,8 +75,12 @@ fn gpt_5_bedrock_model(openai_slug: &str, bedrock_slug: &str, priority: i32) -> } fn gpt_5_6_bedrock_model(bedrock_slug: &str, display_name: &str, priority: i32) -> ModelInfo { - let mut model = gpt_5_bedrock_model(GPT_5_5_OPENAI_MODEL_ID, bedrock_slug, priority); - model.display_name = display_name.to_string(); + let mut model = gpt_5_bedrock_model( + GPT_5_5_OPENAI_MODEL_ID, + bedrock_slug, + display_name, + priority, + ); model .supported_reasoning_levels .push(ReasoningEffortPreset { @@ -148,9 +160,9 @@ mod tests { .expect("Bedrock catalog should include GPT-5.5"); for (slug, display_name, priority) in [ - (AMAZON_BEDROCK_GPT_5_6_SOL_MODEL_ID, "Sol", 2), - (AMAZON_BEDROCK_GPT_5_6_TERRA_MODEL_ID, "Terra", 3), - (AMAZON_BEDROCK_GPT_5_6_LUNA_MODEL_ID, "Luna", 4), + (AMAZON_BEDROCK_GPT_5_6_SOL_MODEL_ID, "GPT-5.6 Sol", 2), + (AMAZON_BEDROCK_GPT_5_6_TERRA_MODEL_ID, "GPT-5.6 Terra", 3), + (AMAZON_BEDROCK_GPT_5_6_LUNA_MODEL_ID, "GPT-5.6 Luna", 4), ] { let mut expected = gpt_5_5.clone(); expected.slug = slug.to_string(); diff --git a/codex-rs/model-provider/src/provider.rs b/codex-rs/model-provider/src/provider.rs index ab059ce3c4..054da9f281 100644 --- a/codex-rs/model-provider/src/provider.rs +++ b/codex-rs/model-provider/src/provider.rs @@ -669,20 +669,20 @@ mod tests { ); let catalog = manager.raw_model_catalog(RefreshStrategy::Online).await; - let model_ids = catalog + let models = catalog .models .iter() - .map(|model| model.slug.as_str()) + .map(|model| (model.slug.as_str(), model.display_name.as_str())) .collect::>(); assert_eq!( - model_ids, + models, vec![ - "openai.gpt-5.5", - "openai.gpt-5.4", - "openai.gpt-5.6-sol", - "openai.gpt-5.6-terra", - "openai.gpt-5.6-luna", + ("openai.gpt-5.5", "GPT-5.5"), + ("openai.gpt-5.4", "GPT-5.4"), + ("openai.gpt-5.6-sol", "GPT-5.6 Sol"), + ("openai.gpt-5.6-terra", "GPT-5.6 Terra"), + ("openai.gpt-5.6-luna", "GPT-5.6 Luna"), ] ); diff --git a/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin.rs b/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin.rs index 509670e36b..8b0498d756 100644 --- a/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin.rs +++ b/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin.rs @@ -10,20 +10,22 @@ use windows_sys::Win32::Security::OBJECT_INHERIT_ACE; use windows_sys::Win32::Storage::FileSystem::FILE_GENERIC_EXECUTE; use windows_sys::Win32::Storage::FileSystem::FILE_GENERIC_READ; +#[cfg(test)] +#[path = "setup_runtime_bin_tests.rs"] +mod tests; + pub(super) fn ensure_codex_app_runtime_paths_readable( sandbox_group_psid: *mut c_void, refresh_errors: &mut Vec, log: &mut dyn Write, ) -> Result<()> { - let local_app_data = local_app_data_root(); - let Some(local_app_data) = local_app_data else { - return Ok(()); - }; - let read_execute_mask = FILE_GENERIC_READ | FILE_GENERIC_EXECUTE; - let codex_root = local_app_data.join("OpenAI").join("Codex"); + let runtime_paths = runtime_paths( + local_app_data_root(), + std::env::var_os("USERPROFILE").map(PathBuf::from), + ); - for runtime_path in [codex_root.join("bin"), codex_root.join("runtimes")] { + for runtime_path in runtime_paths { if !runtime_path.is_dir() { continue; } @@ -86,6 +88,20 @@ pub(super) fn ensure_codex_app_runtime_paths_readable( Ok(()) } +fn runtime_paths(local_app_data: Option, user_profile: Option) -> Vec { + let mut runtime_paths = Vec::new(); + if let Some(local_app_data) = local_app_data { + let codex_root = local_app_data.join("OpenAI").join("Codex"); + runtime_paths.extend([codex_root.join("bin"), codex_root.join("runtimes")]); + } + // The managed primary runtime is installed outside the LocalAppData runtime roots. + if let Some(user_profile) = user_profile { + runtime_paths.push(user_profile.join(".cache").join("codex-runtimes")); + } + + runtime_paths +} + fn local_app_data_root() -> Option { std::env::var_os("LOCALAPPDATA") .map(PathBuf::from) diff --git a/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin_tests.rs b/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin_tests.rs new file mode 100644 index 0000000000..a3fa300d0b --- /dev/null +++ b/codex-rs/windows-sandbox-rs/src/bin/setup_main/win/setup_runtime_bin_tests.rs @@ -0,0 +1,28 @@ +use super::runtime_paths; +use pretty_assertions::assert_eq; +use std::path::PathBuf; + +#[test] +fn runtime_paths_include_desktop_and_primary_runtime_roots() { + let local_app_data = PathBuf::from(r"C:\Users\user\AppData\Local"); + let user_profile = PathBuf::from(r"C:\Users\user"); + + assert_eq!( + runtime_paths(Some(local_app_data), Some(user_profile)), + vec![ + PathBuf::from(r"C:\Users\user\AppData\Local\OpenAI\Codex\bin"), + PathBuf::from(r"C:\Users\user\AppData\Local\OpenAI\Codex\runtimes"), + PathBuf::from(r"C:\Users\user\.cache\codex-runtimes"), + ] + ); +} + +#[test] +fn primary_runtime_path_does_not_depend_on_local_app_data() { + let user_profile = PathBuf::from(r"C:\Users\user"); + + assert_eq!( + runtime_paths(/*local_app_data*/ None, Some(user_profile)), + vec![PathBuf::from(r"C:\Users\user\.cache\codex-runtimes")] + ); +}