diff --git a/AGENTS.md b/AGENTS.md index 62f303769e..fc545c5080 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -60,7 +60,14 @@ See `codex-rs/tui/styles.md`. ### Snapshot tests -This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output. When UI or text output changes intentionally, update the snapshots as follows: +This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output. + +**Requirement:** any change that affects user-visible UI (including adding new UI) must include +corresponding `insta` snapshot coverage (add a new snapshot test if one doesn't exist yet, or +update the existing snapshot). Review and accept snapshot updates as part of the PR so UI impact +is easy to review and future diffs stay visual. + +When UI or text output changes intentionally, update the snapshots as follows: - Run tests to generate any updated snapshots: - `cargo test -p codex-tui` diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 79170e64bc..c1f36e1ef3 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -4,6 +4,7 @@ use crate::codex_message_processor::read_summary_from_rollout; use crate::codex_message_processor::summary_to_thread; use crate::error_code::INTERNAL_ERROR_CODE; use crate::error_code::INVALID_REQUEST_ERROR_CODE; +use crate::outgoing_message::ClientRequestResult; use crate::outgoing_message::ThreadScopedOutgoingMessageSender; use crate::thread_state::ThreadState; use crate::thread_state::TurnSummary; @@ -1408,12 +1409,25 @@ async fn handle_error( async fn on_patch_approval_response( call_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, codex: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + if let Err(submit_err) = codex + .submit(Op::PatchApproval { + id: call_id.clone(), + decision: ReviewDecision::Denied, + }) + .await + { + error!("failed to submit denied PatchApproval after request failure: {submit_err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); if let Err(submit_err) = codex @@ -1451,12 +1465,16 @@ async fn on_patch_approval_response( async fn on_exec_approval_response( call_id: String, turn_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + return; + } Err(err) => { error!("request failed: {err:?}"); return; @@ -1488,12 +1506,28 @@ async fn on_exec_approval_response( async fn on_request_user_input_response( event_turn_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + let empty = CoreRequestUserInputResponse { + answers: HashMap::new(), + }; + if let Err(err) = conversation + .submit(Op::UserInputAnswer { + id: event_turn_id, + response: empty, + }) + .await + { + error!("failed to submit UserInputAnswer: {err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); let empty = CoreRequestUserInputResponse { @@ -1628,14 +1662,14 @@ async fn on_file_change_request_approval_response( conversation_id: ThreadId, item_id: String, changes: Vec, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, codex: Arc, outgoing: ThreadScopedOutgoingMessageSender, thread_state: Arc>, ) { let response = receiver.await; let (decision, completion_status) = match response { - Ok(value) => { + Ok(Ok(value)) => { let response = serde_json::from_value::(value) .unwrap_or_else(|err| { error!("failed to deserialize FileChangeRequestApprovalResponse: {err}"); @@ -1650,6 +1684,10 @@ async fn on_file_change_request_approval_response( // Only short-circuit on declines/cancels/failures. (decision, completion_status) } + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + (ReviewDecision::Denied, Some(PatchApplyStatus::Failed)) + } Err(err) => { error!("request failed: {err:?}"); (ReviewDecision::Denied, Some(PatchApplyStatus::Failed)) @@ -1688,13 +1726,13 @@ async fn on_command_execution_request_approval_response( command: String, cwd: PathBuf, command_actions: Vec, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, outgoing: ThreadScopedOutgoingMessageSender, ) { let response = receiver.await; let (decision, completion_status) = match response { - Ok(value) => { + Ok(Ok(value)) => { let response = serde_json::from_value::(value) .unwrap_or_else(|err| { error!("failed to deserialize CommandExecutionRequestApprovalResponse: {err}"); @@ -1729,6 +1767,10 @@ async fn on_command_execution_request_approval_response( }; (decision, completion_status) } + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + (ReviewDecision::Denied, Some(CommandExecutionStatus::Failed)) + } Err(err) => { error!("request failed: {err:?}"); (ReviewDecision::Denied, Some(CommandExecutionStatus::Failed)) diff --git a/codex-rs/app-server/src/dynamic_tools.rs b/codex-rs/app-server/src/dynamic_tools.rs index ed284452b4..31374d80b6 100644 --- a/codex-rs/app-server/src/dynamic_tools.rs +++ b/codex-rs/app-server/src/dynamic_tools.rs @@ -7,14 +7,35 @@ use std::sync::Arc; use tokio::sync::oneshot; use tracing::error; +use crate::outgoing_message::ClientRequestResult; + pub(crate) async fn on_call_response( call_id: String, - receiver: oneshot::Receiver, + receiver: oneshot::Receiver, conversation: Arc, ) { let response = receiver.await; let value = match response { - Ok(value) => value, + Ok(Ok(value)) => value, + Ok(Err(err)) => { + error!("request failed with client error: {err:?}"); + let fallback = CoreDynamicToolResponse { + content_items: vec![CoreDynamicToolCallOutputContentItem::InputText { + text: "dynamic tool request failed".to_string(), + }], + success: false, + }; + if let Err(err) = conversation + .submit(Op::DynamicToolResponse { + id: call_id.clone(), + response: fallback, + }) + .await + { + error!("failed to submit DynamicToolResponse: {err}"); + } + return; + } Err(err) => { error!("request failed: {err:?}"); let fallback = CoreDynamicToolResponse { diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rs index f4b949ed28..cb645ff3f8 100644 --- a/codex-rs/app-server/src/message_processor.rs +++ b/codex-rs/app-server/src/message_processor.rs @@ -86,9 +86,20 @@ impl ExternalAuthRefresher for ExternalAuthRefreshBridge { .await; let result = match timeout(EXTERNAL_AUTH_REFRESH_TIMEOUT, rx).await { - Ok(result) => result.map_err(|err| { - std::io::Error::other(format!("auth refresh request canceled: {err}")) - })?, + Ok(result) => { + // Two failure scenarios: + // 1) `oneshot::Receiver` failed (sender dropped) => request canceled/channel closed. + // 2) client answered with JSON-RPC error payload => propagate code/message. + let result = result.map_err(|err| { + std::io::Error::other(format!("auth refresh request canceled: {err}")) + })?; + result.map_err(|err| { + std::io::Error::other(format!( + "auth refresh request failed: code={} message={}", + err.code, err.message + )) + })? + } Err(_) => { let _canceled = self.outgoing.cancel_request(&request_id).await; return Err(std::io::Error::other(format!( diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rs index 45f33b49d9..2d8b748c90 100644 --- a/codex-rs/app-server/src/outgoing_message.rs +++ b/codex-rs/app-server/src/outgoing_message.rs @@ -20,6 +20,8 @@ use crate::error_code::INTERNAL_ERROR_CODE; #[cfg(test)] use codex_protocol::account::PlanType; +pub(crate) type ClientRequestResult = std::result::Result; + /// Stable identifier for a transport connection. #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub(crate) struct ConnectionId(pub(crate) u64); @@ -46,7 +48,7 @@ pub(crate) enum OutgoingEnvelope { pub(crate) struct OutgoingMessageSender { next_server_request_id: AtomicI64, sender: mpsc::Sender, - request_id_to_callback: Mutex>>, + request_id_to_callback: Mutex>>, } #[derive(Clone)] @@ -69,7 +71,7 @@ impl ThreadScopedOutgoingMessageSender { pub(crate) async fn send_request( &self, payload: ServerRequestPayload, - ) -> oneshot::Receiver { + ) -> oneshot::Receiver { if self.connection_ids.is_empty() { let (_tx, rx) = oneshot::channel(); return rx; @@ -118,7 +120,7 @@ impl OutgoingMessageSender { &self, connection_ids: &[ConnectionId], request: ServerRequestPayload, - ) -> oneshot::Receiver { + ) -> oneshot::Receiver { let (_id, rx) = self .send_request_with_id_to_connections(connection_ids, request) .await; @@ -128,7 +130,7 @@ impl OutgoingMessageSender { pub(crate) async fn send_request_with_id( &self, request: ServerRequestPayload, - ) -> (RequestId, oneshot::Receiver) { + ) -> (RequestId, oneshot::Receiver) { self.send_request_with_id_to_connections(&[], request).await } @@ -136,7 +138,7 @@ impl OutgoingMessageSender { &self, connection_ids: &[ConnectionId], request: ServerRequestPayload, - ) -> (RequestId, oneshot::Receiver) { + ) -> (RequestId, oneshot::Receiver) { let id = RequestId::Integer(self.next_server_request_id.fetch_add(1, Ordering::Relaxed)); let outgoing_message_id = id.clone(); let (tx_approve, rx_approve) = oneshot::channel(); @@ -190,7 +192,7 @@ impl OutgoingMessageSender { match entry { Some((id, sender)) => { - if let Err(err) = sender.send(result) { + if let Err(err) = sender.send(Ok(result)) { warn!("could not notify callback for {id:?} due to: {err:?}"); } } @@ -207,8 +209,11 @@ impl OutgoingMessageSender { }; match entry { - Some((id, _sender)) => { + Some((id, sender)) => { warn!("client responded with error for {id:?}: {error:?}"); + if let Err(err) = sender.send(Err(error)) { + warn!("could not notify callback for {id:?} due to: {err:?}"); + } } None => { warn!("could not find callback for {id:?}"); @@ -390,11 +395,13 @@ mod tests { use codex_app_server_protocol::AccountLoginCompletedNotification; use codex_app_server_protocol::AccountRateLimitsUpdatedNotification; use codex_app_server_protocol::AccountUpdatedNotification; + use codex_app_server_protocol::ApplyPatchApprovalParams; use codex_app_server_protocol::AuthMode; use codex_app_server_protocol::ConfigWarningNotification; use codex_app_server_protocol::LoginChatGptCompleteNotification; use codex_app_server_protocol::RateLimitSnapshot; use codex_app_server_protocol::RateLimitWindow; + use codex_protocol::ThreadId; use pretty_assertions::assert_eq; use serde_json::json; use tokio::time::timeout; @@ -609,4 +616,38 @@ mod tests { other => panic!("expected targeted error envelope, got: {other:?}"), } } + + #[tokio::test] + async fn notify_client_error_forwards_error_to_waiter() { + let (tx, _rx) = mpsc::channel::(4); + let outgoing = OutgoingMessageSender::new(tx); + + let (request_id, wait_for_result) = outgoing + .send_request_with_id(ServerRequestPayload::ApplyPatchApproval( + ApplyPatchApprovalParams { + conversation_id: ThreadId::new(), + call_id: "call-id".to_string(), + file_changes: HashMap::new(), + reason: None, + grant_root: None, + }, + )) + .await; + + let error = JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: "refresh failed".to_string(), + data: None, + }; + + outgoing + .notify_client_error(request_id, error.clone()) + .await; + + let result = timeout(Duration::from_secs(1), wait_for_result) + .await + .expect("wait should not time out") + .expect("waiter should receive a callback"); + assert_eq!(result, Err(error)); + } } diff --git a/codex-rs/app-server/tests/suite/v2/review.rs b/codex-rs/app-server/tests/suite/v2/review.rs index a3a60cece1..05397d485d 100644 --- a/codex-rs/app-server/tests/suite/v2/review.rs +++ b/codex-rs/app-server/tests/suite/v2/review.rs @@ -255,6 +255,7 @@ async fn review_start_rejects_empty_base_branch() -> Result<()> { Ok(()) } +#[cfg_attr(target_os = "windows", ignore = "flaky on windows CI")] #[tokio::test] async fn review_start_with_detached_delivery_returns_new_thread_id() -> Result<()> { let review_payload = json!({ diff --git a/codex-rs/core/README.md b/codex-rs/core/README.md index 9974a591cf..8a66b47b48 100644 --- a/codex-rs/core/README.md +++ b/codex-rs/core/README.md @@ -14,6 +14,30 @@ When using the workspace-write sandbox policy, the Seatbelt profile allows writes under the configured writable roots while keeping `.git` (directory or pointer file), the resolved `gitdir:` target, and `.codex` read-only. +Network access and filesystem read/write roots are controlled by +`SandboxPolicy`. Seatbelt consumes the resolved policy and enforces it. + +Seatbelt also supports macOS permission-profile extensions layered on top of +`SandboxPolicy`: + +- no extension profile provided: + keeps legacy default preferences read access (`user-preference-read`). +- extension profile provided with no `macos_preferences` grant: + does not add preferences access clauses. +- `macos_preferences = "readonly"`: + enables cfprefs read clauses and `user-preference-read`. +- `macos_preferences = "readwrite"`: + includes readonly clauses plus `user-preference-write` and cfprefs shm write + clauses. +- `macos_automation = true`: + enables broad Apple Events send permissions. +- `macos_automation = ["com.apple.Notes", ...]`: + enables Apple Events send only to listed bundle IDs. +- `macos_accessibility = true`: + enables `com.apple.axserver` mach lookup. +- `macos_calendar = true`: + enables `com.apple.CalendarAgent` mach lookup. + ### Linux Expects the binary containing `codex-core` to run the equivalent of `codex sandbox linux` (legacy alias: `codex debug landlock`) when `arg0` is `codex-linux-sandbox`. See the `codex-arg0` crate for details. diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 4c571a6c2e..1bd7c1a938 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -224,6 +224,9 @@ "js_repl": { "type": "boolean" }, + "js_repl_tools_only": { + "type": "boolean" + }, "memory_tool": { "type": "boolean" }, @@ -1308,6 +1311,9 @@ "js_repl": { "type": "boolean" }, + "js_repl_tools_only": { + "type": "boolean" + }, "memory_tool": { "type": "boolean" }, diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index 75a2551f79..4405635ce3 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -5515,6 +5515,7 @@ mod tests { use crate::tools::handlers::ShellHandler; use crate::tools::handlers::UnifiedExecHandler; use crate::tools::registry::ToolHandler; + use crate::tools::router::ToolCallSource; use crate::turn_diff_tracker::TurnDiffTracker; use codex_app_server_protocol::AppInfo; use codex_otel::TelemetryAuthMode; @@ -7452,6 +7453,7 @@ mod tests { Arc::clone(&turn_context), tracker, call, + ToolCallSource::Direct, ) .await .expect_err("expected fatal error"); diff --git a/codex-rs/core/src/features.rs b/codex-rs/core/src/features.rs index 4a64d81f89..9df518b816 100644 --- a/codex-rs/core/src/features.rs +++ b/codex-rs/core/src/features.rs @@ -80,6 +80,8 @@ pub enum Feature { // Experimental /// Enable JavaScript REPL tools backed by a persistent Node kernel. JsRepl, + /// Only expose js_repl tools directly to the model. + JsReplToolsOnly, /// Use the single unified PTY-backed exec tool. UnifiedExec, /// Include the freeform apply_patch tool. @@ -322,6 +324,10 @@ impl Features { } overrides.apply(&mut features); + if features.enabled(Feature::JsReplToolsOnly) && !features.enabled(Feature::JsRepl) { + tracing::warn!("js_repl_tools_only requires js_repl; disabling js_repl_tools_only"); + features.disable(Feature::JsReplToolsOnly); + } features } @@ -430,6 +436,12 @@ pub const FEATURES: &[FeatureSpec] = &[ stage: Stage::UnderDevelopment, default_enabled: false, }, + FeatureSpec { + id: Feature::JsReplToolsOnly, + key: "js_repl_tools_only", + stage: Stage::UnderDevelopment, + default_enabled: false, + }, FeatureSpec { id: Feature::WebSearchRequest, key: "web_search_request", diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs index 764fc4fbba..e3888ecf86 100644 --- a/codex-rs/core/src/lib.rs +++ b/codex-rs/core/src/lib.rs @@ -77,6 +77,7 @@ pub use model_provider_info::create_oss_provider_with_base_url; mod event_mapping; pub mod review_format; pub mod review_prompts; +mod seatbelt_permissions; mod thread_manager; pub mod web_search; pub mod windows_sandbox_read_grants; diff --git a/codex-rs/core/src/project_doc.rs b/codex-rs/core/src/project_doc.rs index a530a83379..3d2b55ab5b 100644 --- a/codex-rs/core/src/project_doc.rs +++ b/codex-rs/core/src/project_doc.rs @@ -48,6 +48,12 @@ fn render_js_repl_instructions(config: &Config) -> Option { section.push_str("- Top-level bindings persist across cells. If you hit `SyntaxError: Identifier 'x' has already been declared`, reuse the binding, pick a new name, wrap in `{ ... }` for block scope, or reset the kernel with `js_repl_reset`.\n"); section.push_str("- Top-level static import declarations (for example `import x from \"pkg\"`) are currently unsupported in `js_repl`; use dynamic imports with `await import(\"pkg\")` instead.\n"); + if config.features.enabled(Feature::JsReplToolsOnly) { + section.push_str("- Do not call tools directly; use `js_repl` + `codex.tool(...)` for all tool calls, including shell commands.\n"); + section + .push_str("- MCP tools (if any) can also be called by name via `codex.tool(...)`.\n"); + } + section.push_str("- Avoid direct access to `process.stdout` / `process.stderr` / `process.stdin`; it can corrupt the JSON line protocol. Use `console.log` and `codex.tool(...)`."); Some(section) @@ -413,6 +419,21 @@ mod tests { assert_eq!(res, expected); } + #[tokio::test] + async fn js_repl_tools_only_instructions_are_feature_gated() { + let tmp = tempfile::tempdir().expect("tempdir"); + let mut cfg = make_config(&tmp, 4096, None).await; + cfg.features + .enable(Feature::JsRepl) + .enable(Feature::JsReplToolsOnly); + + let res = get_user_instructions(&cfg, None) + .await + .expect("js_repl instructions expected"); + let expected = "## JavaScript REPL (Node)\n- Use `js_repl` for Node-backed JavaScript with top-level await in a persistent kernel. `codex.state` persists for the session (best effort) and is cleared by `js_repl_reset`.\n- `js_repl` is a freeform/custom tool. Direct `js_repl` calls must send raw JavaScript tool input (optionally with first-line `// codex-js-repl: timeout_ms=15000`). Do not wrap code in JSON (for example `{\"code\":\"...\"}`), quotes, or markdown code fences.\n- Helpers: `codex.state`, `codex.tmpDir`, and `codex.tool(name, args?)`.\n- `codex.tool` executes a normal tool call and resolves to the raw tool output object. Use it for shell and non-shell tools alike.\n- To share generated images with the model, write a file under `codex.tmpDir`, call `await codex.tool(\"view_image\", { path: \"/absolute/path\" })`, then delete the file.\n- Top-level bindings persist across cells. If you hit `SyntaxError: Identifier 'x' has already been declared`, reuse the binding, pick a new name, wrap in `{ ... }` for block scope, or reset the kernel with `js_repl_reset`.\n- Top-level static import declarations (for example `import x from \"pkg\"`) are currently unsupported in `js_repl`; use dynamic imports with `await import(\"pkg\")` instead.\n- Do not call tools directly; use `js_repl` + `codex.tool(...)` for all tool calls, including shell commands.\n- MCP tools (if any) can also be called by name via `codex.tool(...)`.\n- Avoid direct access to `process.stdout` / `process.stderr` / `process.stdin`; it can corrupt the JSON line protocol. Use `console.log` and `codex.tool(...)`."; + assert_eq!(res, expected); + } + /// When both system instructions *and* a project doc are present the two /// should be concatenated with the separator. #[tokio::test] diff --git a/codex-rs/core/src/seatbelt.rs b/codex-rs/core/src/seatbelt.rs index fc425f2184..29c05e0183 100644 --- a/codex-rs/core/src/seatbelt.rs +++ b/codex-rs/core/src/seatbelt.rs @@ -14,6 +14,9 @@ use tokio::process::Child; use url::Url; use crate::protocol::SandboxPolicy; +use crate::seatbelt_permissions::MacOsPreferencesPermission; +use crate::seatbelt_permissions::MacOsSeatbeltProfileExtensions; +use crate::seatbelt_permissions::build_seatbelt_extensions; use crate::spawn::CODEX_SANDBOX_ENV_VAR; use crate::spawn::SpawnChildRequest; use crate::spawn::StdioPolicy; @@ -179,6 +182,24 @@ pub(crate) fn create_seatbelt_command_args( sandbox_policy_cwd: &Path, enforce_managed_network: bool, network: Option<&NetworkProxy>, +) -> Vec { + create_seatbelt_command_args_with_extensions( + command, + sandbox_policy, + sandbox_policy_cwd, + enforce_managed_network, + network, + None, + ) +} + +pub(crate) fn create_seatbelt_command_args_with_extensions( + command: Vec, + sandbox_policy: &SandboxPolicy, + sandbox_policy_cwd: &Path, + enforce_managed_network: bool, + network: Option<&NetworkProxy>, + extensions: Option<&MacOsSeatbeltProfileExtensions>, ) -> Vec { let (file_write_policy, file_write_dir_params) = { if sandbox_policy.has_full_disk_write_access() { @@ -275,15 +296,33 @@ pub(crate) fn create_seatbelt_command_args( let proxy = proxy_policy_inputs(network); let network_policy = dynamic_network_policy(sandbox_policy, enforce_managed_network, &proxy); - - let full_policy = format!( - "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}" + let seatbelt_extensions = extensions.map_or_else( + || { + // Backward-compatibility default when no extension profile is provided. + build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadOnly, + ..Default::default() + }) + }, + build_seatbelt_extensions, ); + let full_policy = if seatbelt_extensions.policy.is_empty() { + format!( + "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}" + ) + } else { + format!( + "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}\n{}", + seatbelt_extensions.policy + ) + }; + let dir_params = [ file_read_dir_params, file_write_dir_params, macos_dir_params(), + seatbelt_extensions.dir_params, ] .concat(); @@ -328,10 +367,14 @@ mod tests { use super::MACOS_SEATBELT_BASE_POLICY; use super::ProxyPolicyInputs; use super::create_seatbelt_command_args; + use super::create_seatbelt_command_args_with_extensions; use super::dynamic_network_policy; use super::macos_dir_params; use crate::protocol::SandboxPolicy; use crate::seatbelt::MACOS_PATH_TO_SEATBELT_EXECUTABLE; + use crate::seatbelt_permissions::MacOsAutomationPermission; + use crate::seatbelt_permissions::MacOsPreferencesPermission; + use crate::seatbelt_permissions::MacOsSeatbeltProfileExtensions; use pretty_assertions::assert_eq; use std::fs; use std::path::Path; @@ -395,6 +438,66 @@ mod tests { ); } + #[test] + fn seatbelt_args_include_macos_permission_extensions() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args_with_extensions( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + Some(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadWrite, + macos_automation: MacOsAutomationPermission::BundleIds(vec![ + "com.apple.Notes".to_string(), + ]), + macos_accessibility: true, + macos_calendar: true, + }), + ); + let policy = &args[1]; + + assert!(policy.contains("(allow user-preference-write)")); + assert!(policy.contains("(appleevent-destination \"com.apple.Notes\")")); + assert!(policy.contains("com.apple.axserver")); + assert!(policy.contains("com.apple.CalendarAgent")); + } + + #[test] + fn seatbelt_args_without_extension_profile_keep_legacy_preferences_read_access() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + ); + let policy = &args[1]; + assert!(policy.contains("(allow user-preference-read)")); + assert!(!policy.contains("(allow user-preference-write)")); + } + + #[test] + fn seatbelt_args_omit_macos_extensions_when_profile_is_empty() { + let cwd = std::env::temp_dir(); + let args = create_seatbelt_command_args_with_extensions( + vec!["echo".to_string(), "ok".to_string()], + &SandboxPolicy::new_read_only_policy(), + cwd.as_path(), + false, + None, + Some(&MacOsSeatbeltProfileExtensions::default()), + ); + let policy = &args[1]; + assert!(!policy.contains("appleevent-send")); + assert!(!policy.contains("com.apple.axserver")); + assert!(!policy.contains("com.apple.CalendarAgent")); + assert!(!policy.contains("user-preference-read")); + assert!(!policy.contains("user-preference-write")); + } + #[test] fn create_seatbelt_args_allows_local_binding_when_explicitly_enabled() { let policy = dynamic_network_policy( @@ -564,6 +667,14 @@ mod tests { (allow file-write* (require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) (require-not (subpath (param "WRITABLE_ROOT_0_RO_1"))) ) (subpath (param "WRITABLE_ROOT_1")) (subpath (param "WRITABLE_ROOT_2")) ) + +; macOS permission profile extensions +(allow ipc-posix-shm-read* (ipc-posix-name-prefix "apple.cfprefs.")) +(allow mach-lookup + (global-name "com.apple.cfprefsd.daemon") + (global-name "com.apple.cfprefsd.agent") + (local-name "com.apple.cfprefsd.agent")) +(allow user-preference-read) "#, ); @@ -851,6 +962,14 @@ mod tests { (allow file-write* (require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) (require-not (subpath (param "WRITABLE_ROOT_0_RO_1"))) ) (subpath (param "WRITABLE_ROOT_1")){tempdir_policy_entry} ) + +; macOS permission profile extensions +(allow ipc-posix-shm-read* (ipc-posix-name-prefix "apple.cfprefs.")) +(allow mach-lookup + (global-name "com.apple.cfprefsd.daemon") + (global-name "com.apple.cfprefsd.agent") + (local-name "com.apple.cfprefsd.agent")) +(allow user-preference-read) "#, ); diff --git a/codex-rs/core/src/seatbelt_base_policy.sbpl b/codex-rs/core/src/seatbelt_base_policy.sbpl index 00676a86f4..72b13c96cd 100644 --- a/codex-rs/core/src/seatbelt_base_policy.sbpl +++ b/codex-rs/core/src/seatbelt_base_policy.sbpl @@ -12,9 +12,6 @@ (allow process-fork) (allow signal (target same-sandbox)) -; Allow cf prefs to work. -(allow user-preference-read) - ; process-info (allow process-info* (target same-sandbox)) diff --git a/codex-rs/core/src/seatbelt_permissions.rs b/codex-rs/core/src/seatbelt_permissions.rs new file mode 100644 index 0000000000..29313d7a3c --- /dev/null +++ b/codex-rs/core/src/seatbelt_permissions.rs @@ -0,0 +1,246 @@ +#![cfg(target_os = "macos")] + +use std::collections::BTreeSet; +use std::path::PathBuf; + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub enum MacOsPreferencesPermission { + #[default] + None, + ReadOnly, + ReadWrite, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub enum MacOsAutomationPermission { + #[default] + None, + All, + BundleIds(Vec), +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct MacOsSeatbeltProfileExtensions { + pub macos_preferences: MacOsPreferencesPermission, + pub macos_automation: MacOsAutomationPermission, + pub macos_accessibility: bool, + pub macos_calendar: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub(crate) struct SeatbeltExtensionPolicy { + pub(crate) policy: String, + pub(crate) dir_params: Vec<(String, PathBuf)>, +} + +impl MacOsSeatbeltProfileExtensions { + pub fn normalized(&self) -> Self { + let mut normalized = self.clone(); + if let MacOsAutomationPermission::BundleIds(bundle_ids) = &self.macos_automation { + let bundle_ids = normalize_bundle_ids(bundle_ids); + normalized.macos_automation = if bundle_ids.is_empty() { + MacOsAutomationPermission::None + } else { + MacOsAutomationPermission::BundleIds(bundle_ids) + }; + } + normalized + } +} + +pub(crate) fn build_seatbelt_extensions( + extensions: &MacOsSeatbeltProfileExtensions, +) -> SeatbeltExtensionPolicy { + let extensions = extensions.normalized(); + let mut clauses = Vec::new(); + + match extensions.macos_preferences { + MacOsPreferencesPermission::None => {} + MacOsPreferencesPermission::ReadOnly => { + clauses.push( + "(allow ipc-posix-shm-read* (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.cfprefsd.daemon\")\n (global-name \"com.apple.cfprefsd.agent\")\n (local-name \"com.apple.cfprefsd.agent\"))" + .to_string(), + ); + clauses.push("(allow user-preference-read)".to_string()); + } + MacOsPreferencesPermission::ReadWrite => { + clauses.push( + "(allow ipc-posix-shm-read* (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.cfprefsd.daemon\")\n (global-name \"com.apple.cfprefsd.agent\")\n (local-name \"com.apple.cfprefsd.agent\"))" + .to_string(), + ); + clauses.push("(allow user-preference-read)".to_string()); + clauses.push("(allow user-preference-write)".to_string()); + clauses.push( + "(allow ipc-posix-shm-write-data (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + clauses.push( + "(allow ipc-posix-shm-write-create (ipc-posix-name-prefix \"apple.cfprefs.\"))" + .to_string(), + ); + } + } + + match extensions.macos_automation { + MacOsAutomationPermission::None => {} + MacOsAutomationPermission::All => { + clauses.push( + "(allow mach-lookup\n (global-name \"com.apple.coreservices.launchservicesd\")\n (global-name \"com.apple.coreservices.appleevents\"))" + .to_string(), + ); + clauses.push("(allow appleevent-send)".to_string()); + } + MacOsAutomationPermission::BundleIds(bundle_ids) => { + if !bundle_ids.is_empty() { + clauses.push( + "(allow mach-lookup (global-name \"com.apple.coreservices.appleevents\"))" + .to_string(), + ); + let destinations = bundle_ids + .iter() + .map(|bundle_id| format!(" (appleevent-destination \"{bundle_id}\")")) + .collect::>() + .join("\n"); + clauses.push(format!("(allow appleevent-send\n{destinations}\n)")); + } + } + } + + if extensions.macos_accessibility { + clauses.push("(allow mach-lookup (local-name \"com.apple.axserver\"))".to_string()); + } + + if extensions.macos_calendar { + clauses.push("(allow mach-lookup (global-name \"com.apple.CalendarAgent\"))".to_string()); + } + + if clauses.is_empty() { + SeatbeltExtensionPolicy::default() + } else { + SeatbeltExtensionPolicy { + policy: format!( + "; macOS permission profile extensions\n{}\n", + clauses.join("\n") + ), + dir_params: Vec::new(), + } + } +} + +fn normalize_bundle_ids(bundle_ids: &[String]) -> Vec { + let mut unique = BTreeSet::new(); + for bundle_id in bundle_ids { + let candidate = bundle_id.trim(); + if is_valid_bundle_id(candidate) { + unique.insert(candidate.to_string()); + } + } + unique.into_iter().collect() +} + +fn is_valid_bundle_id(bundle_id: &str) -> bool { + if bundle_id.len() < 3 || !bundle_id.contains('.') { + return false; + } + bundle_id + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-' || c == '_') +} + +#[cfg(test)] +mod tests { + use super::MacOsAutomationPermission; + use super::MacOsPreferencesPermission; + use super::MacOsSeatbeltProfileExtensions; + use super::build_seatbelt_extensions; + use pretty_assertions::assert_eq; + + #[test] + fn preferences_read_only_emits_read_clauses_only() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadOnly, + ..Default::default() + }); + assert!(policy.policy.contains("(allow user-preference-read)")); + assert!(!policy.policy.contains("(allow user-preference-write)")); + } + + #[test] + fn preferences_read_write_emits_write_clauses() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_preferences: MacOsPreferencesPermission::ReadWrite, + ..Default::default() + }); + assert!(policy.policy.contains("(allow user-preference-read)")); + assert!(policy.policy.contains("(allow user-preference-write)")); + assert!(policy.policy.contains( + "(allow ipc-posix-shm-write-create (ipc-posix-name-prefix \"apple.cfprefs.\"))" + )); + } + + #[test] + fn automation_all_emits_unscoped_appleevents() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_automation: MacOsAutomationPermission::All, + ..Default::default() + }); + assert!(policy.policy.contains("(allow appleevent-send)")); + assert!( + policy + .policy + .contains("com.apple.coreservices.launchservicesd") + ); + } + + #[test] + fn automation_bundle_ids_are_normalized_and_scoped() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_automation: MacOsAutomationPermission::BundleIds(vec![ + " com.apple.Notes ".to_string(), + "com.apple.Calendar".to_string(), + "bad bundle".to_string(), + "com.apple.Notes".to_string(), + ]), + ..Default::default() + }); + assert!( + policy + .policy + .contains("(appleevent-destination \"com.apple.Calendar\")") + ); + assert!( + policy + .policy + .contains("(appleevent-destination \"com.apple.Notes\")") + ); + assert!(!policy.policy.contains("bad bundle")); + } + + #[test] + fn accessibility_and_calendar_emit_mach_lookups() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions { + macos_accessibility: true, + macos_calendar: true, + ..Default::default() + }); + assert!(policy.policy.contains("com.apple.axserver")); + assert!(policy.policy.contains("com.apple.CalendarAgent")); + } + + #[test] + fn empty_extensions_emit_empty_policy() { + let policy = build_seatbelt_extensions(&MacOsSeatbeltProfileExtensions::default()); + assert_eq!(policy.policy, ""); + } +} diff --git a/codex-rs/core/src/tools/js_repl/mod.rs b/codex-rs/core/src/tools/js_repl/mod.rs index 4285c29889..8b362ab8f3 100644 --- a/codex-rs/core/src/tools/js_repl/mod.rs +++ b/codex-rs/core/src/tools/js_repl/mod.rs @@ -680,7 +680,13 @@ impl JsReplManager { }; match router - .dispatch_tool_call(exec.session, exec.turn, exec.tracker, call) + .dispatch_tool_call( + exec.session, + exec.turn, + exec.tracker, + call, + crate::tools::router::ToolCallSource::JsRepl, + ) .await { Ok(response) => match serde_json::to_value(response) { diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs index ca08048bd8..04d505c584 100644 --- a/codex-rs/core/src/tools/parallel.rs +++ b/codex-rs/core/src/tools/parallel.rs @@ -85,7 +85,13 @@ impl ToolCallRuntime { }; router - .dispatch_tool_call(session, turn, tracker, call.clone()) + .dispatch_tool_call( + session, + turn, + tracker, + call.clone(), + crate::tools::router::ToolCallSource::Direct, + ) .instrument(dispatch_span.clone()) .await } => res, diff --git a/codex-rs/core/src/tools/router.rs b/codex-rs/core/src/tools/router.rs index 1eb6190bcb..1cc8b91778 100644 --- a/codex-rs/core/src/tools/router.rs +++ b/codex-rs/core/src/tools/router.rs @@ -28,6 +28,12 @@ pub struct ToolCall { pub payload: ToolPayload, } +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ToolCallSource { + Direct, + JsRepl, +} + pub struct ToolRouter { registry: ToolRegistry, specs: Vec, @@ -138,6 +144,7 @@ impl ToolRouter { turn: Arc, tracker: SharedTurnDiffTracker, call: ToolCall, + source: ToolCallSource, ) -> Result { let ToolCall { tool_name, @@ -147,6 +154,21 @@ impl ToolRouter { let payload_outputs_custom = matches!(payload, ToolPayload::Custom { .. }); let failure_call_id = call_id.clone(); + if source == ToolCallSource::Direct + && turn.tools_config.js_repl_tools_only + && !matches!(tool_name.as_str(), "js_repl" | "js_repl_reset") + { + let err = FunctionCallError::RespondToModel( + "direct tool calls are disabled; use js_repl and codex.tool(...) instead" + .to_string(), + ); + return Ok(Self::failure_response( + failure_call_id, + payload_outputs_custom, + err, + )); + } + let invocation = ToolInvocation { session, turn, @@ -189,3 +211,118 @@ impl ToolRouter { } } } +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use crate::codex::make_session_and_context; + use crate::tools::context::ToolPayload; + use crate::turn_diff_tracker::TurnDiffTracker; + use codex_protocol::models::ResponseInputItem; + + use super::ToolCall; + use super::ToolCallSource; + use super::ToolRouter; + + #[tokio::test] + async fn js_repl_tools_only_blocks_direct_tool_calls() -> anyhow::Result<()> { + let (session, mut turn) = make_session_and_context().await; + turn.tools_config.js_repl_tools_only = true; + + let session = Arc::new(session); + let turn = Arc::new(turn); + let mcp_tools = session + .services + .mcp_connection_manager + .read() + .await + .list_all_tools() + .await; + let router = ToolRouter::from_config( + &turn.tools_config, + Some( + mcp_tools + .into_iter() + .map(|(name, tool)| (name, tool.tool)) + .collect(), + ), + turn.dynamic_tools.as_slice(), + ); + + let call = ToolCall { + tool_name: "shell".to_string(), + call_id: "call-1".to_string(), + payload: ToolPayload::Function { + arguments: "{}".to_string(), + }, + }; + let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())); + let response = router + .dispatch_tool_call(session, turn, tracker, call, ToolCallSource::Direct) + .await?; + + match response { + ResponseInputItem::FunctionCallOutput { output, .. } => { + let content = output.text_content().unwrap_or_default(); + assert!( + content.contains("direct tool calls are disabled"), + "unexpected tool call message: {content}", + ); + } + other => panic!("expected function call output, got {other:?}"), + } + + Ok(()) + } + + #[tokio::test] + async fn js_repl_tools_only_allows_js_repl_source_calls() -> anyhow::Result<()> { + let (session, mut turn) = make_session_and_context().await; + turn.tools_config.js_repl_tools_only = true; + + let session = Arc::new(session); + let turn = Arc::new(turn); + let mcp_tools = session + .services + .mcp_connection_manager + .read() + .await + .list_all_tools() + .await; + let router = ToolRouter::from_config( + &turn.tools_config, + Some( + mcp_tools + .into_iter() + .map(|(name, tool)| (name, tool.tool)) + .collect(), + ), + turn.dynamic_tools.as_slice(), + ); + + let call = ToolCall { + tool_name: "shell".to_string(), + call_id: "call-2".to_string(), + payload: ToolPayload::Function { + arguments: "{}".to_string(), + }, + }; + let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())); + let response = router + .dispatch_tool_call(session, turn, tracker, call, ToolCallSource::JsRepl) + .await?; + + match response { + ResponseInputItem::FunctionCallOutput { output, .. } => { + let content = output.text_content().unwrap_or_default(); + assert!( + !content.contains("direct tool calls are disabled"), + "js_repl source should bypass direct-call policy gate" + ); + } + other => panic!("expected function call output, got {other:?}"), + } + + Ok(()) + } +} diff --git a/codex-rs/core/src/tools/spec.rs b/codex-rs/core/src/tools/spec.rs index b8618e0c07..82e34298c1 100644 --- a/codex-rs/core/src/tools/spec.rs +++ b/codex-rs/core/src/tools/spec.rs @@ -34,6 +34,7 @@ pub(crate) struct ToolsConfig { pub web_search_mode: Option, pub search_tool: bool, pub js_repl_enabled: bool, + pub js_repl_tools_only: bool, pub collab_tools: bool, pub collaboration_modes_tools: bool, pub request_rule_enabled: bool, @@ -55,6 +56,8 @@ impl ToolsConfig { } = params; let include_apply_patch_tool = features.enabled(Feature::ApplyPatchFreeform); let include_js_repl = features.enabled(Feature::JsRepl); + let include_js_repl_tools_only = + include_js_repl && features.enabled(Feature::JsReplToolsOnly); let include_collab_tools = features.enabled(Feature::Collab); let include_collaboration_modes_tools = features.enabled(Feature::CollaborationModes); let request_rule_enabled = features.enabled(Feature::RequestRule); @@ -91,6 +94,7 @@ impl ToolsConfig { web_search_mode: *web_search_mode, search_tool: include_search_tool, js_repl_enabled: include_js_repl, + js_repl_tools_only: include_js_repl_tools_only, collab_tools: include_collab_tools, collaboration_modes_tools: include_collaboration_modes_tools, request_rule_enabled, @@ -99,8 +103,15 @@ impl ToolsConfig { } } -pub(crate) fn filter_tools_for_model(tools: Vec, _config: &ToolsConfig) -> Vec { +pub(crate) fn filter_tools_for_model(tools: Vec, config: &ToolsConfig) -> Vec { + if !config.js_repl_tools_only { + return tools; + } + tools + .into_iter() + .filter(|spec| matches!(spec.name(), "js_repl" | "js_repl_reset")) + .collect() } /// Generic JSON‑Schema subset needed for our tool definitions @@ -1685,6 +1696,27 @@ mod tests { } } + fn assert_contains_tool_specs(tools: &[ToolSpec], expected_subset: &[&str]) { + use std::collections::HashSet; + let mut names = HashSet::new(); + let mut duplicates = Vec::new(); + for name in tools.iter().map(tool_name) { + if !names.insert(name) { + duplicates.push(name); + } + } + assert!( + duplicates.is_empty(), + "duplicate tool entries detected: {duplicates:?}" + ); + for expected in expected_subset { + assert!( + names.contains(expected), + "expected tool {expected} to be present; had: {names:?}" + ); + } + } + fn shell_tool_name(config: &ToolsConfig) -> Option<&'static str> { match config.shell_type { ConfigShellToolType::Default => Some("shell"), @@ -1910,6 +1942,77 @@ mod tests { assert_contains_tool_names(&tools, &["js_repl", "js_repl_reset"]); } + #[test] + fn js_repl_tools_only_filters_model_tools() { + let config = test_config(); + let model_info = + ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config); + let mut features = Features::with_defaults(); + features.enable(Feature::JsRepl); + features.enable(Feature::JsReplToolsOnly); + + let tools_config = ToolsConfig::new(&ToolsConfigParams { + model_info: &model_info, + features: &features, + web_search_mode: Some(WebSearchMode::Cached), + }); + let (tools, _) = build_specs(&tools_config, None, &[]).build(); + let filtered = filter_tools_for_model( + tools.iter().map(|tool| tool.spec.clone()).collect(), + &tools_config, + ); + assert_contains_tool_specs(&filtered, &["js_repl", "js_repl_reset"]); + assert!( + !filtered.iter().any(|tool| tool_name(tool) == "shell"), + "expected non-js_repl tools to be hidden when js_repl_tools_only is enabled" + ); + } + + #[test] + fn js_repl_tools_only_hides_dynamic_tools_from_model_tools() { + let config = test_config(); + let model_info = + ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config); + let mut features = Features::with_defaults(); + features.enable(Feature::JsRepl); + features.enable(Feature::JsReplToolsOnly); + + let tools_config = ToolsConfig::new(&ToolsConfigParams { + model_info: &model_info, + features: &features, + web_search_mode: Some(WebSearchMode::Cached), + }); + let dynamic_tools = vec![DynamicToolSpec { + name: "dynamic_echo".to_string(), + description: "echo dynamic payload".to_string(), + input_schema: serde_json::json!({ + "type": "object", + "properties": { + "text": {"type": "string"} + }, + "required": ["text"], + "additionalProperties": false + }), + }]; + let (tools, _) = build_specs(&tools_config, None, &dynamic_tools).build(); + assert!( + tools.iter().any(|tool| tool.spec.name() == "dynamic_echo"), + "expected dynamic tool in full router specs" + ); + + let filtered = filter_tools_for_model( + tools.iter().map(|tool| tool.spec.clone()).collect(), + &tools_config, + ); + assert!( + !filtered + .iter() + .any(|tool| tool_name(tool) == "dynamic_echo"), + "expected dynamic tools to be hidden from direct model tools in js_repl_tools_only mode" + ); + assert_contains_tool_specs(&filtered, &["js_repl", "js_repl_reset"]); + } + fn assert_model_tools( model_slug: &str, features: &Features, diff --git a/codex-rs/core/templates/memories/stage_one_system.md b/codex-rs/core/templates/memories/stage_one_system.md index b4f16a07d7..38031e8d2f 100644 --- a/codex-rs/core/templates/memories/stage_one_system.md +++ b/codex-rs/core/templates/memories/stage_one_system.md @@ -153,7 +153,6 @@ distilled into MEMORY.md and memory_summary.md. There is no strict size limit, and you should feel free to list a lot of points here as long as they are helpful. Instructional notes in angle brackets are guidance only; do not include them verbatim in the rollout summary. -Use absolute paths for any file paths and commands. You should refer to the cwd of the rollout. Template (items are flexible; include only what is useful): diff --git a/codex-rs/core/tests/suite/compact_resume_fork.rs b/codex-rs/core/tests/suite/compact_resume_fork.rs index ff90d4baf4..fc77a2621f 100644 --- a/codex-rs/core/tests/suite/compact_resume_fork.rs +++ b/codex-rs/core/tests/suite/compact_resume_fork.rs @@ -932,9 +932,16 @@ async fn mount_second_compact_flow(server: &MockServer) -> Vec { ]); let sse7 = sse(vec![ev_completed("r7")]); + // Keep this matcher broad enough to survive prompt-shape differences across + // platforms/config (history may include either marker text or compact prompt + // fragments), but explicitly exclude the final resume turn so these two + // one-shot mocks cannot race for the same request. let match_second_compact = |req: &wiremock::Request| { let body = std::str::from_utf8(&req.body).unwrap_or(""); - body.contains("AFTER_FORK") + (body.contains("AFTER_FORK") + || body_contains_text(body, SUMMARIZATION_PROMPT) + || body.contains(&json_fragment(FIRST_REPLY))) + && !body.contains(&format!("\"text\":\"{AFTER_SECOND_RESUME}\"")) }; let second_compact = mount_sse_once_match(server, match_second_compact, sse6).await; @@ -984,7 +991,13 @@ async fn compact_conversation(conversation: &Arc) { .submit(Op::Compact) .await .expect("compact conversation"); - let warning_event = wait_for_event(conversation, |ev| matches!(ev, EventMsg::Warning(_))).await; + let warning_event = wait_for_event(conversation, |ev| { + matches!( + ev, + EventMsg::Warning(WarningEvent { message }) if message == COMPACT_WARNING_MESSAGE + ) + }) + .await; let EventMsg::Warning(WarningEvent { message }) = warning_event else { panic!("expected warning event after compact"); }; diff --git a/docs/js_repl.md b/docs/js_repl.md index 2c550b4581..1b19740748 100644 --- a/docs/js_repl.md +++ b/docs/js_repl.md @@ -11,6 +11,16 @@ js_repl = true ``` +`js_repl_tools_only` can be enabled to force direct model tool calls through `js_repl`: + +```toml +[features] +js_repl = true +js_repl_tools_only = true +``` + +When enabled, direct model tool calls are restricted to `js_repl` and `js_repl_reset`; other tools remain available via `await codex.tool(...)` inside js_repl. + ## Node runtime `js_repl` requires a Node version that meets or exceeds `codex-rs/node-version.txt`.