Fix post-rebase test fixtures

Author: ericjuta

codex-rs/app-server/tests/suite/v2/mcp_server_status.rs

@@ -2,6 +2,8 @@ use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::sync::Arc;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
 use anyhow::Result;
@@ -143,6 +145,13 @@ impl ServerHandler for McpStatusServer {
 #[derive(Clone)]
 struct SlowInventoryServer {
     tool_name: Arc<String>,
+    calls: SlowInventoryCallCounts,
+}
+
+#[derive(Clone, Default)]
+struct SlowInventoryCallCounts {
+    resources: Arc<AtomicUsize>,
+    resource_templates: Arc<AtomicUsize>,
 }
 
 impl ServerHandler for SlowInventoryServer {
@@ -186,6 +195,7 @@ impl ServerHandler for SlowInventoryServer {
         _request: Option<PaginatedRequestParams>,
         _context: RequestContext<rmcp::service::RoleServer>,
     ) -> Result<ListResourcesResult, rmcp::ErrorData> {
+        self.calls.resources.fetch_add(1, Ordering::SeqCst);
         tokio::time::sleep(Duration::from_secs(2)).await;
         Ok(ListResourcesResult {
             resources: Vec::new(),
@@ -199,6 +209,7 @@ impl ServerHandler for SlowInventoryServer {
         _request: Option<PaginatedRequestParams>,
         _context: RequestContext<rmcp::service::RoleServer>,
     ) -> Result<ListResourceTemplatesResult, rmcp::ErrorData> {
+        self.calls.resource_templates.fetch_add(1, Ordering::SeqCst);
         tokio::time::sleep(Duration::from_secs(2)).await;
         Ok(ListResourceTemplatesResult {
             resource_templates: Vec::new(),
@@ -211,7 +222,8 @@ impl ServerHandler for SlowInventoryServer {
 #[tokio::test]
 async fn mcp_server_status_list_tools_and_auth_only_skips_slow_inventory_calls() -> Result<()> {
     let server = create_mock_responses_server_sequence_unchecked(Vec::new()).await;
-    let (mcp_server_url, mcp_server_handle) = start_slow_inventory_mcp_server("lookup").await?;
+    let (mcp_server_url, mcp_server_handle, calls) =
+        start_slow_inventory_mcp_server("lookup").await?;
     let codex_home = TempDir::new()?;
     write_mock_responses_config_toml(
         codex_home.path(),
@@ -244,7 +256,7 @@ url = "{mcp_server_url}/mcp"
         })
         .await?;
     let response = timeout(
-        Duration::from_millis(500),
+        DEFAULT_READ_TIMEOUT,
         mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
     )
     .await??;
@@ -260,6 +272,8 @@ url = "{mcp_server_url}/mcp"
     );
     assert_eq!(status.resources, Vec::new());
     assert_eq!(status.resource_templates, Vec::new());
+    assert_eq!(calls.resources.load(Ordering::SeqCst), 0);
+    assert_eq!(calls.resource_templates.load(Ordering::SeqCst), 0);
 
     mcp_server_handle.abort();
     let _ = mcp_server_handle.await;
@@ -367,14 +381,19 @@ async fn start_mcp_server(tool_name: &str) -> Result<(String, JoinHandle<()>)> {
     Ok((format!("http://{addr}"), handle))
 }
 
-async fn start_slow_inventory_mcp_server(tool_name: &str) -> Result<(String, JoinHandle<()>)> {
+async fn start_slow_inventory_mcp_server(
+    tool_name: &str,
+) -> Result<(String, JoinHandle<()>, SlowInventoryCallCounts)> {
     let listener = TcpListener::bind("127.0.0.1:0").await?;
     let addr = listener.local_addr()?;
     let tool_name = Arc::new(tool_name.to_string());
+    let calls = SlowInventoryCallCounts::default();
+    let server_calls = calls.clone();
     let mcp_service = StreamableHttpService::new(
         move || {
             Ok(SlowInventoryServer {
                 tool_name: Arc::clone(&tool_name),
+                calls: server_calls.clone(),
             })
         },
         Arc::new(LocalSessionManager::default()),
@@ -386,5 +405,5 @@ async fn start_slow_inventory_mcp_server(tool_name: &str) -> Result<(String, Joi
         let _ = axum::serve(listener, router).await;
     });
 
-    Ok((format!("http://{addr}"), handle))
+    Ok((format!("http://{addr}"), handle, calls))
 }

codex-rs/app-server/tests/suite/v2/turn_start.rs

@@ -501,7 +501,8 @@ async fn turn_start_emits_thread_scoped_warning_notification_for_trimmed_skills(
     write_test_skill(codex_home.path(), "alpha-skill")?;
     write_test_skill(codex_home.path(), "beta-skill")?;
 
-    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    let home_dir = codex_home.path().to_string_lossy().to_string();
+    let mut mcp = McpProcess::new_with_env(codex_home.path(), &[("HOME", Some(&home_dir))]).await?;
     timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
 
     let thread_req = mcp

codex-rs/config/src/config_toml.rs

@@ -177,6 +177,9 @@ pub struct ConfigToml {
     #[serde(default = "default_allow_login_shell")]
     pub allow_login_shell: Option<bool>,
 
+    /// Optional absolute path to patched zsh used by the shell_zsh_fork feature.
+    pub zsh_path: Option<AbsolutePathBuf>,
+
     /// Sandbox mode to use.
     pub sandbox_mode: Option<SandboxMode>,
 

codex-rs/config/src/hooks_tests.rs

@@ -111,6 +111,7 @@ fn hook_command_timeout_accepts_timeout_sec_alias() {
         parsed.hooks.pre_tool_use[0].hooks[0],
         HookHandlerConfig::Command {
             command: "python3 /tmp/pre.py".to_string(),
+            command_windows: None,
             timeout_sec: Some(12),
             r#async: false,
             status_message: None,

codex-rs/core/config.schema.json

@@ -4978,6 +4978,14 @@
       ],
       "default": null,
       "description": "Windows-specific configuration."
+    },
+    "zsh_path": {
+      "allOf": [
+        {
+          "$ref": "#/definitions/AbsolutePathBuf"
+        }
+      ],
+      "description": "Optional absolute path to patched zsh used by the shell_zsh_fork feature."
     }
   },
   "title": "ConfigToml",

codex-rs/core/src/config/config_tests.rs

@@ -4489,6 +4489,25 @@ async fn default_zsh_path_sets_runtime_zsh_path() -> std::io::Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn configured_zsh_path_sets_runtime_zsh_path() -> std::io::Result<()> {
+    let codex_home = TempDir::new()?;
+    let configured_zsh_path = codex_home.path().join("configured-zsh");
+
+    let config = Config::load_from_base_config_with_overrides(
+        ConfigToml {
+            zsh_path: Some(configured_zsh_path.abs()),
+            ..Default::default()
+        },
+        ConfigOverrides::default(),
+        codex_home.abs(),
+    )
+    .await?;
+    assert_eq!(config.zsh_path, Some(configured_zsh_path));
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn sqlite_home_defaults_to_codex_home_for_workspace_write() -> std::io::Result<()> {
     let codex_home = TempDir::new()?;

codex-rs/core/src/config/mod.rs

@@ -3207,7 +3207,9 @@ impl Config {
         )
         .await?;
         let compact_prompt = compact_prompt.or(file_compact_prompt);
-        let zsh_path = default_zsh_path
+        let zsh_path = cfg
+            .zsh_path
+            .or(default_zsh_path)
             .or_else(|| InstallContext::current().bundled_zsh_path())
             .map(AbsolutePathBuf::into_path_buf);
 

codex-rs/core/src/session/turn.rs

@@ -962,7 +962,7 @@ async fn run_sampling_request(
                     return Err(CodexErr::ContextWindowExceeded);
                 }
                 context_window_compaction_retries += 1;
-                let reset_client_session = run_auto_compact(
+                run_auto_compact(
                     &sess,
                     &turn_context,
                     client_session,
@@ -971,9 +971,6 @@ async fn run_sampling_request(
                     CompactionPhase::MidTurn,
                 )
                 .await?;
-                if reset_client_session {
-                    client_session.reset_websocket_session();
-                }
                 retries = 0;
                 continue;
             }

codex-rs/hooks/src/engine/mod_tests.rs

@@ -337,6 +337,7 @@ Path(r"{marker_path}").write_text("done", encoding="utf-8")
     let request = PreToolUseRequest {
         session_id: ThreadId::new(),
         turn_id: "turn-1".to_string(),
+        subagent: None,
         cwd: cwd(),
         transcript_path: None,
         model: "gpt-test".to_string(),