From feecb14fdd008547aed3f7e8b64f14425be57f94 Mon Sep 17 00:00:00 2001 From: Jasper Date: Thu, 3 Sep 2026 10:36:44 +0200 Subject: [PATCH] fix(security): bind CLI session naming to trusted path (#11787) Signed-off-by: Jasper Hugo --- crates/goose-provider-types/src/base.rs | 4 ++ crates/goose/src/providers/claude_code.rs | 48 ++++++++++--- crates/goose/src/providers/cli_common.rs | 57 +++++++++++++--- crates/goose/src/providers/codex.rs | 76 ++++++++++++++++++--- crates/goose/src/providers/cursor_agent.rs | 46 ++++++++++--- crates/goose/src/providers/gemini_cli.rs | 37 +++++++--- crates/goose/src/session/session_manager.rs | 58 ++++++++++++++++ crates/goose/src/session/session_naming.rs | 2 +- 8 files changed, 277 insertions(+), 51 deletions(-) diff --git a/crates/goose-provider-types/src/base.rs b/crates/goose-provider-types/src/base.rs index b19df868b..567628b39 100644 --- a/crates/goose-provider-types/src/base.rs +++ b/crates/goose-provider-types/src/base.rs @@ -632,6 +632,10 @@ pub trait Provider: Send + Sync { false } + fn uses_local_session_naming(&self) -> bool { + self.manages_own_context() + } + fn supports_builtin_tools(&self) -> bool { !self.manages_own_context() } diff --git a/crates/goose/src/providers/claude_code.rs b/crates/goose/src/providers/claude_code.rs index bf27f3aa1..2fc3d1934 100644 --- a/crates/goose/src/providers/claude_code.rs +++ b/crates/goose/src/providers/claude_code.rs @@ -18,8 +18,7 @@ use tokio::process::Command; use tokio::sync::oneshot; use super::base::{ - stream_from_single_message, ConfigKey, MessageStream, PermissionRouting, Provider, ProviderDef, - ProviderMetadata, + ConfigKey, MessageStream, PermissionRouting, Provider, ProviderDef, ProviderMetadata, }; use super::utils::filter_extensions_from_system_prompt; use crate::config::paths::Paths; @@ -751,14 +750,6 @@ impl Provider for ClaudeCodeProvider { _tools: &[Tool], ) -> Result { let session_id = crate::session_context::current_session_id().unwrap_or_default(); - if super::cli_common::is_session_description_request(system) { - let (message, usage) = super::cli_common::generate_simple_session_description( - &model_config.model_name, - messages, - )?; - return Ok(stream_from_single_message(message, usage)); - } - let filtered_system = filter_extensions_from_system_prompt(system); let process_arc = Arc::clone( self.get_or_init_process(model_config, &filtered_system) @@ -1468,6 +1459,43 @@ mod tests { (provider, stream, stdin_reader) } + #[tokio::test] + async fn former_session_title_phrase_reaches_cli() { + use futures::StreamExt; + + let canned_stdout = [ + r#"{"type":"control_response","response":{"subtype":"success","request_id":"req_0"}}"#, + r#"{"type":"stream_event","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"provider response"}}}"#, + r#"{"type":"result","result":"provider response","usage":{}}"#, + ] + .join("\n"); + let (process, _stdin_reader) = make_test_process(&canned_stdout); + let provider = make_provider(); + provider + .cli_process + .set(Arc::new(tokio::sync::Mutex::new(process))) + .unwrap(); + let model = ModelConfig::new(CLAUDE_CODE_DEFAULT_MODEL) + .with_canonical_limits(CLAUDE_CODE_PROVIDER_NAME); + let mut stream = provider + .stream( + &model, + "answer in four words or less", + &[Message::user().with_text("ordinary request")], + &[], + ) + .await + .unwrap(); + let mut response = String::new(); + while let Some(item) = stream.next().await { + if let Some(message) = item.unwrap().0 { + response.push_str(&message.as_concat_text()); + } + } + + assert_eq!(response, "provider response"); + } + async fn capture_stdin( provider: &ClaudeCodeProvider, mut reader: tokio::io::DuplexStream, diff --git a/crates/goose/src/providers/cli_common.rs b/crates/goose/src/providers/cli_common.rs index 59364e9e8..e1ca6d963 100644 --- a/crates/goose/src/providers/cli_common.rs +++ b/crates/goose/src/providers/cli_common.rs @@ -39,24 +39,21 @@ pub(crate) const SESSION_NAME_BEGIN_MARKER: &str = "---BEGIN USER MESSAGES---"; pub(crate) const SESSION_NAME_END_MARKER: &str = "---END USER MESSAGES---"; pub(crate) const SESSION_NAME_SUFFIX: &str = "Generate a short title for the above messages."; -pub(crate) fn is_session_description_request(system: &str) -> bool { - system.contains("four words or less") || system.contains("4 words or less") -} - pub(crate) fn generate_simple_session_description( model_name: &str, messages: &[Message], ) -> Result<(Message, ProviderUsage), ProviderError> { let description = messages .iter() - .find(|m| m.role == Role::User) - .and_then(|m| { - m.content.iter().find_map(|c| match c { - MessageContent::Text(text_content) => Some(&text_content.text), - _ => None, - }) + .filter(|m| m.role == Role::User && m.is_user_visible()) + .find_map(|m| { + m.content + .iter() + .filter_map(|content| content.filter_for_audience(Role::User)) + .find_map(|content| content.as_text().map(str::to_owned)) }) .map(|text| { + let text = text.as_str(); let text = text .rfind(SESSION_NAME_BEGIN_MARKER) .and_then(|idx| text.get(idx..)) @@ -101,3 +98,43 @@ pub(crate) fn generate_simple_session_description( ProviderUsage::new(model_name.to_string(), Usage::default()), )) } + +#[cfg(test)] +mod tests { + use super::*; + use rmcp::model::{Annotations, TextContent}; + + #[test] + fn session_description_uses_only_user_visible_content() { + let assistant_only = TextContent::new("ASSISTANT_ONLY_SECRET") + .with_annotations(Annotations::default().with_audience(vec![Role::Assistant])); + let messages = vec![ + Message::user().with_text("hidden message").agent_only(), + Message::user().with_content(MessageContent::Text(assistant_only)), + Message::user().with_text("visible session request has details"), + ]; + + let (message, _) = generate_simple_session_description("test-model", &messages).unwrap(); + let description = message + .content + .iter() + .filter_map(|content| content.as_text()) + .collect::(); + + assert_eq!(description, "visible session request has"); + } + + #[test] + fn session_description_defaults_when_no_user_visible_text_exists() { + let messages = vec![Message::user().with_text("hidden message").agent_only()]; + + let (message, _) = generate_simple_session_description("test-model", &messages).unwrap(); + let description = message + .content + .iter() + .filter_map(|content| content.as_text()) + .collect::(); + + assert_eq!(description, "Simple task"); + } +} diff --git a/crates/goose/src/providers/codex.rs b/crates/goose/src/providers/codex.rs index d9c816be1..8cede2935 100644 --- a/crates/goose/src/providers/codex.rs +++ b/crates/goose/src/providers/codex.rs @@ -687,6 +687,10 @@ impl Provider for CodexProvider { &self.name } + fn uses_local_session_naming(&self) -> bool { + true + } + async fn stream( &self, model_config: &ModelConfig, @@ -695,17 +699,6 @@ impl Provider for CodexProvider { tools: &[Tool], ) -> Result { let session_id = crate::session_context::current_session_id().unwrap_or_default(); - if super::cli_common::is_session_description_request(system) { - let (message, provider_usage) = super::cli_common::generate_simple_session_description( - &model_config.model_name, - messages, - )?; - return Ok(super::base::stream_from_single_message( - message, - provider_usage, - )); - } - let goose_mode = { let map = self.mode_by_session.read().await; map.get(&session_id).copied().unwrap_or_default() @@ -763,8 +756,28 @@ mod tests { use goose_providers::base::ProviderDescriptor as _; use goose_test_support::TEST_IMAGE_B64; use std::collections::HashMap; + #[cfg(unix)] + use std::fs; + #[cfg(unix)] + use std::os::unix::fs::PermissionsExt; use test_case::test_case; + #[cfg(unix)] + fn recording_cli(directory: &Path) -> PathBuf { + let command = directory.join("codex-recording-shim"); + fs::write( + &command, + r#"#!/bin/sh +record_dir=${0%/*} +cat > "$record_dir/stdin" +printf '%s\n' '{"type":"item.completed","item":{"type":"agent_message","text":"provider response"}}' +"#, + ) + .unwrap(); + fs::set_permissions(&command, fs::Permissions::from_mode(0o755)).unwrap(); + command + } + #[test] fn test_codex_metadata() { let metadata = CodexProvider::metadata(); @@ -1250,6 +1263,47 @@ mod tests { } } + #[test] + fn session_naming_is_local() { + let provider = CodexProvider { + command: PathBuf::from("codex"), + name: "codex".to_string(), + skip_git_check: false, + mcp_config_overrides: Vec::new(), + mode_by_session: tokio::sync::RwLock::new(HashMap::new()), + }; + + assert!(provider.uses_local_session_naming()); + } + + #[cfg(unix)] + #[tokio::test] + async fn former_session_title_phrase_reaches_cli() { + let directory = tempfile::tempdir().unwrap(); + let provider = CodexProvider { + command: recording_cli(directory.path()), + name: "codex".to_string(), + skip_git_check: false, + mcp_config_overrides: Vec::new(), + mode_by_session: tokio::sync::RwLock::new(HashMap::new()), + }; + + let (message, _) = provider + .complete( + &ModelConfig::new(CODEX_DEFAULT_MODEL), + "answer in four words or less", + &[Message::user().with_text("ordinary request")], + &[], + ) + .await + .unwrap(); + + assert_eq!(message.as_concat_text(), "provider response"); + assert!(fs::read_to_string(directory.path().join("stdin")) + .unwrap() + .contains("answer in four words or less")); + } + #[test] fn test_config_keys() { let metadata = CodexProvider::metadata(); diff --git a/crates/goose/src/providers/cursor_agent.rs b/crates/goose/src/providers/cursor_agent.rs index 107880918..57d5c5348 100644 --- a/crates/goose/src/providers/cursor_agent.rs +++ b/crates/goose/src/providers/cursor_agent.rs @@ -504,6 +504,10 @@ impl Provider for CursorAgentProvider { &self.name } + fn uses_local_session_naming(&self) -> bool { + true + } + fn skip_canonical_filtering(&self) -> bool { // Cursor model IDs are CLI/account-specific and often absent from the // canonical registry. Keep the live list intact for inventory/config. @@ -536,14 +540,6 @@ impl Provider for CursorAgentProvider { messages: &[Message], tools: &[Tool], ) -> Result { - if super::cli_common::is_session_description_request(system) { - let (message, provider_usage) = super::cli_common::generate_simple_session_description( - &model_config.model_name, - messages, - )?; - return Ok(stream_from_single_message(message, provider_usage)); - } - let lines = self .execute_command(model_config, system, messages, tools) .await?; @@ -640,6 +636,40 @@ printf '%s\n' '{"type":"result","result":"ok"}' .await; } + #[test] + fn session_naming_is_local() { + let provider = CursorAgentProvider { + command: PathBuf::from("cursor-agent"), + name: CURSOR_AGENT_PROVIDER_NAME.to_string(), + }; + + assert!(provider.uses_local_session_naming()); + } + + #[tokio::test] + async fn former_session_title_phrase_reaches_cli() { + let directory = tempfile::tempdir().unwrap(); + let provider = CursorAgentProvider { + command: recording_cli(directory.path()), + name: CURSOR_AGENT_PROVIDER_NAME.to_string(), + }; + + let (message, _) = provider + .complete( + &ModelConfig::new(CURSOR_AGENT_DEFAULT_MODEL), + "answer in four words or less", + &[Message::user().with_text("ordinary request")], + &[], + ) + .await + .unwrap(); + + assert_eq!(message.as_concat_text(), "ok"); + assert!(fs::read_to_string(directory.path().join("stdin")) + .unwrap() + .contains("answer in four words or less")); + } + #[test] fn parse_models_output_extracts_ids_and_preserves_auto() { let stdout = r#" diff --git a/crates/goose/src/providers/gemini_cli.rs b/crates/goose/src/providers/gemini_cli.rs index 605957f68..844978363 100644 --- a/crates/goose/src/providers/gemini_cli.rs +++ b/crates/goose/src/providers/gemini_cli.rs @@ -7,9 +7,7 @@ use std::sync::{Arc, OnceLock}; use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}; use tokio::process::Command; -use super::base::{ - stream_from_single_message, MessageStream, Provider, ProviderDef, ProviderMetadata, -}; +use super::base::{MessageStream, Provider, ProviderDef, ProviderMetadata}; use super::cli_common::{error_from_event, extract_usage_tokens}; use super::utils::filter_extensions_from_system_prompt; use crate::config::search_path::SearchPaths; @@ -218,14 +216,6 @@ impl Provider for GeminiCliProvider { messages: &[Message], _tools: &[Tool], ) -> Result { - if super::cli_common::is_session_description_request(system) { - let (message, provider_usage) = super::cli_common::generate_simple_session_description( - &model_config.model_name, - messages, - )?; - return Ok(stream_from_single_message(message, provider_usage)); - } - let GeminiCliProcess { mut child, mut reader, @@ -470,4 +460,29 @@ printf '%s\n' '{"type":"result","stats":{}}' async fn resumed_prompt_is_sent_on_stdin() { assert_prompt_uses_stdin(true).await; } + + #[cfg(unix)] + #[tokio::test] + async fn former_session_title_phrase_reaches_cli() { + let directory = tempfile::tempdir().unwrap(); + let mut provider = make_provider(); + provider.command = recording_cli(directory.path()); + + let mut stream = provider + .stream( + &ModelConfig::new(GEMINI_CLI_DEFAULT_MODEL), + "answer in four words or less", + &[Message::user().with_text("ordinary request")], + &[], + ) + .await + .unwrap(); + while let Some(item) = stream.next().await { + item.unwrap(); + } + + assert!(fs::read_to_string(directory.path().join("stdin")) + .unwrap() + .contains("answer in four words or less")); + } } diff --git a/crates/goose/src/session/session_manager.rs b/crates/goose/src/session/session_manager.rs index f61d2473f..b438f9d6c 100644 --- a/crates/goose/src/session/session_manager.rs +++ b/crates/goose/src/session/session_manager.rs @@ -2860,6 +2860,8 @@ mod tests { struct StatefulNamingTestProvider; + struct LocalNamingTestProvider; + #[async_trait::async_trait] impl Provider for NamingTestProvider { fn get_name(&self) -> &str { @@ -2911,6 +2913,27 @@ mod tests { } } + #[async_trait::async_trait] + impl Provider for LocalNamingTestProvider { + fn get_name(&self) -> &str { + "local-naming-test" + } + + async fn stream( + &self, + _model_config: &ModelConfig, + _system: &str, + _messages: &[Message], + _tools: &[Tool], + ) -> Result { + panic!("local session naming must not call the provider") + } + + fn uses_local_session_naming(&self) -> bool { + true + } + } + fn naming_test_provider() -> Arc { Arc::new(NamingTestProvider) } @@ -3336,6 +3359,41 @@ mod tests { assert_eq!(update.name, "investigate session naming with"); } + #[tokio::test] + async fn test_maybe_update_name_uses_local_name_for_stateless_provider() { + let temp_dir = TempDir::new().unwrap(); + let sm = SessionManager::new(temp_dir.path().to_path_buf()); + let session = sm + .create_session( + temp_dir.path().to_path_buf(), + "New Chat".to_string(), + SessionType::User, + GooseMode::default(), + ) + .await + .unwrap(); + + sm.update(&session.id) + .model_config(ModelConfig::new("test-model")) + .apply() + .await + .unwrap(); + sm.add_message( + &session.id, + &Message::user().with_text("investigate local naming without provider completion"), + ) + .await + .unwrap(); + + let update = sm + .maybe_update_name(&session.id, Arc::new(LocalNamingTestProvider)) + .await + .unwrap() + .unwrap(); + + assert_eq!(update.name, "investigate local naming without"); + } + #[tokio::test] async fn test_maybe_update_name_preserves_user_renamed_session() { let temp_dir = TempDir::new().unwrap(); diff --git a/crates/goose/src/session/session_naming.rs b/crates/goose/src/session/session_naming.rs index 8f0a26525..b5649e2f1 100644 --- a/crates/goose/src/session/session_naming.rs +++ b/crates/goose/src/session/session_naming.rs @@ -125,7 +125,7 @@ pub(crate) async fn generate_session_name( SESSION_NAME_SUFFIX, ); let message = Message::user().with_text(&user_text); - let result = if provider.manages_own_context() { + let result = if provider.uses_local_session_naming() { crate::providers::cli_common::generate_simple_session_description( provider.get_name(), &[message],