diff --git a/crates/goose/src/config/permission.rs b/crates/goose/src/config/permission.rs index d12b6f5ec..ab5ded785 100644 --- a/crates/goose/src/config/permission.rs +++ b/crates/goose/src/config/permission.rs @@ -1,10 +1,13 @@ use crate::config::paths::Paths; +use fs2::FileExt; use rmcp::model::Tool; use serde::{Deserialize, Serialize}; use std::collections::HashMap; -use std::fs; +use std::fs::{self, OpenOptions}; +use std::io::Write; use std::path::{Path, PathBuf}; use std::sync::{Arc, LazyLock, RwLock}; +use tempfile::NamedTempFile; use tracing; const PERMISSION_FILE: &str = "permission.yaml"; @@ -44,19 +47,7 @@ impl PermissionManager { pub fn new(config_dir: PathBuf) -> Self { let permission_path = config_dir.join(PERMISSION_FILE); let permission_map = if permission_path.exists() { - let file_contents = - fs::read_to_string(&permission_path).expect("Failed to read permission.yaml"); - serde_yaml::from_str(&file_contents).unwrap_or_else(|e| { - tracing::error!( - "Failed to parse {}: {}. Refusing to start with corrupted permission config.", - permission_path.display(), - e, - ); - panic!( - "Corrupted permission config at {}. Fix or remove the file to continue.", - permission_path.display(), - ); - }) + Self::load_permission_map(&permission_path) } else { // Consolidate directory creation for re-use in global singleton or ACP. fs::create_dir_all(&config_dir).expect("Failed to create config directory"); @@ -116,30 +107,27 @@ impl PermissionManager { } fn bulk_update_smart_approve_permissions(&self, tool_names: &[String], level: PermissionLevel) { - let mut map = self.permission_map.write().unwrap(); - let permission_config = map.entry(SMART_APPROVE_PERMISSION.to_string()).or_default(); + self.mutate_permission_map(|map| { + let permission_config = map.entry(SMART_APPROVE_PERMISSION.to_string()).or_default(); - for tool_name in tool_names { - // Remove from all lists to avoid duplicates - permission_config.always_allow.retain(|p| p != tool_name); - permission_config.ask_before.retain(|p| p != tool_name); - permission_config.never_allow.retain(|p| p != tool_name); + for tool_name in tool_names { + permission_config.always_allow.retain(|p| p != tool_name); + permission_config.ask_before.retain(|p| p != tool_name); + permission_config.never_allow.retain(|p| p != tool_name); - // Add to the appropriate list - match &level { - PermissionLevel::AlwaysAllow => { - permission_config.always_allow.push(tool_name.clone()) - } - PermissionLevel::AskBefore => permission_config.ask_before.push(tool_name.clone()), - PermissionLevel::NeverAllow => { - permission_config.never_allow.push(tool_name.clone()) + match &level { + PermissionLevel::AlwaysAllow => { + permission_config.always_allow.push(tool_name.clone()) + } + PermissionLevel::AskBefore => { + permission_config.ask_before.push(tool_name.clone()) + } + PermissionLevel::NeverAllow => { + permission_config.never_allow.push(tool_name.clone()) + } } } - } - - let yaml_content = - serde_yaml::to_string(&*map).expect("Failed to serialize permission config"); - fs::write(&self.config_path, yaml_content).expect("Failed to write to permission.yaml"); + }); } /// Helper function to retrieve the permission level for a specific permission category and tool. @@ -180,64 +168,133 @@ impl PermissionManager { /// Helper function to update a permission level for a specific tool in a given permission category. fn update_permission(&self, name: &str, principal_name: &str, level: PermissionLevel) { - let mut map = self.permission_map.write().unwrap(); - // Get or create a new PermissionConfig for the specified category - let permission_config = map.entry(name.to_string()).or_default(); + self.mutate_permission_map(|map| { + let permission_config = map.entry(name.to_string()).or_default(); - // Remove the principal from all existing lists to avoid duplicates - permission_config - .always_allow - .retain(|p| p != principal_name); - permission_config.ask_before.retain(|p| p != principal_name); - permission_config - .never_allow - .retain(|p| p != principal_name); - - // Add the principal to the appropriate list - match level { - PermissionLevel::AlwaysAllow => permission_config + permission_config .always_allow - .push(principal_name.to_string()), - PermissionLevel::AskBefore => permission_config - .ask_before - .push(principal_name.to_string()), - PermissionLevel::NeverAllow => permission_config + .retain(|p| p != principal_name); + permission_config.ask_before.retain(|p| p != principal_name); + permission_config .never_allow - .push(principal_name.to_string()), - } + .retain(|p| p != principal_name); - // Serialize the updated permission map and write it back to the config file + match level { + PermissionLevel::AlwaysAllow => permission_config + .always_allow + .push(principal_name.to_string()), + PermissionLevel::AskBefore => permission_config + .ask_before + .push(principal_name.to_string()), + PermissionLevel::NeverAllow => permission_config + .never_allow + .push(principal_name.to_string()), + } + }); + } + + fn mutate_permission_map(&self, mutation: F) + where + F: FnOnce(&mut HashMap), + { + let mut in_memory_map = self.permission_map.write().unwrap(); + let storage_path = Self::permission_storage_path(&self.config_path); + let lock_path = storage_path.with_extension("yaml.lock"); + let lock_file = OpenOptions::new() + .read(true) + .write(true) + .create(true) + .truncate(false) + .open(lock_path) + .expect("Failed to open permission.yaml lock file"); + lock_file + .lock_exclusive() + .expect("Failed to lock permission.yaml"); + + let mut latest_map = if storage_path.exists() { + Self::load_permission_map(&storage_path) + } else { + HashMap::new() + }; + mutation(&mut latest_map); + Self::write_permission_map(&storage_path, &latest_map); + *in_memory_map = latest_map; + } + + fn load_permission_map(config_path: &Path) -> HashMap { + let file_contents = + fs::read_to_string(config_path).expect("Failed to read permission.yaml"); + serde_yaml::from_str(&file_contents).unwrap_or_else(|error| { + tracing::error!( + "Failed to parse {}: {}. Refusing to start with corrupted permission config.", + config_path.display(), + error, + ); + panic!( + "Corrupted permission config at {}. Fix or remove the file to continue.", + config_path.display(), + ); + }) + } + + fn permission_storage_path(config_path: &Path) -> PathBuf { + match fs::symlink_metadata(config_path) { + Ok(metadata) if metadata.file_type().is_symlink() => { + let target = + fs::read_link(config_path).expect("Failed to resolve permission.yaml symlink"); + if target.is_absolute() { + target + } else { + config_path + .parent() + .expect("permission.yaml must have a parent directory") + .join(target) + } + } + Ok(_) => config_path.to_path_buf(), + Err(error) if error.kind() == std::io::ErrorKind::NotFound => config_path.to_path_buf(), + Err(error) => panic!("Failed to inspect permission.yaml: {error}"), + } + } + + fn write_permission_map(storage_path: &Path, map: &HashMap) { let yaml_content = - serde_yaml::to_string(&*map).expect("Failed to serialize permission config"); - fs::write(&self.config_path, yaml_content).expect("Failed to write to permission.yaml"); + serde_yaml::to_string(map).expect("Failed to serialize permission config"); + let config_dir = storage_path + .parent() + .expect("permission.yaml must have a parent directory"); + let mut temporary_file = + NamedTempFile::new_in(config_dir).expect("Failed to write to permission.yaml"); + temporary_file + .write_all(yaml_content.as_bytes()) + .expect("Failed to write to permission.yaml"); + temporary_file + .as_file() + .sync_all() + .expect("Failed to write to permission.yaml"); + temporary_file + .persist(storage_path) + .expect("Failed to write to permission.yaml"); } pub fn remove_extension(&self, extension_name: &str) { - let mut map = self.permission_map.write().unwrap(); - for permission_config in map.values_mut() { - permission_config - .always_allow - .retain(|p| !Self::belongs_to_extension(p, extension_name)); - permission_config - .ask_before - .retain(|p| !Self::belongs_to_extension(p, extension_name)); - permission_config - .never_allow - .retain(|p| !Self::belongs_to_extension(p, extension_name)); - } - - let yaml_content = - serde_yaml::to_string(&*map).expect("Failed to serialize permission config"); - fs::write(&self.config_path, yaml_content).expect("Failed to write to permission.yaml"); + self.mutate_permission_map(|map| { + for permission_config in map.values_mut() { + permission_config + .always_allow + .retain(|p| !Self::belongs_to_extension(p, extension_name)); + permission_config + .ask_before + .retain(|p| !Self::belongs_to_extension(p, extension_name)); + permission_config + .never_allow + .retain(|p| !Self::belongs_to_extension(p, extension_name)); + } + }); } pub fn clear_permissions(&self) { - let mut map = self.permission_map.write().unwrap(); - map.clear(); - - let yaml_content = - serde_yaml::to_string(&*map).expect("Failed to serialize permission config"); - fs::write(&self.config_path, yaml_content).expect("Failed to write to permission.yaml"); + self.mutate_permission_map(HashMap::clear); } fn belongs_to_extension(principal_name: &str, extension_name: &str) -> bool { @@ -436,6 +493,76 @@ mod tests { PermissionManager::new(temp_dir.path().to_path_buf()); } + #[cfg(unix)] + #[test] + fn symlink_and_target_managers_share_storage_lock() { + use std::os::unix::fs::symlink; + use std::sync::mpsc; + use std::thread; + + let root = TempDir::new().unwrap(); + let symlink_config_dir = root.path().join("symlink-config"); + let target_config_dir = root.path().join("target-config"); + fs::create_dir_all(&symlink_config_dir).unwrap(); + fs::create_dir_all(&target_config_dir).unwrap(); + + let symlink_path = symlink_config_dir.join(PERMISSION_FILE); + let target_path = target_config_dir.join(PERMISSION_FILE); + fs::write(&target_path, "{}\n").unwrap(); + symlink("../target-config/permission.yaml", &symlink_path).unwrap(); + + let symlink_manager = PermissionManager::new(symlink_config_dir); + let target_manager = PermissionManager::new(target_config_dir.clone()); + let (symlink_locked_tx, symlink_locked_rx) = mpsc::channel(); + let (release_symlink_tx, release_symlink_rx) = mpsc::channel(); + + let symlink_thread = thread::spawn(move || { + symlink_manager.mutate_permission_map(|map| { + map.entry(USER_PERMISSION.to_string()) + .or_default() + .always_allow + .push("symlink_tool".to_string()); + symlink_locked_tx.send(()).unwrap(); + release_symlink_rx.recv().unwrap(); + }); + }); + symlink_locked_rx.recv().unwrap(); + + let (target_started_tx, target_started_rx) = mpsc::channel(); + let target_thread = thread::spawn(move || { + target_started_tx.send(()).unwrap(); + target_manager.update_user_permission("target_tool", PermissionLevel::AskBefore); + }); + target_started_rx.recv().unwrap(); + + let target_lock = OpenOptions::new() + .read(true) + .write(true) + .open(target_path.with_extension("yaml.lock")) + .unwrap(); + let target_lock_is_held = target_lock.try_lock_exclusive().is_err(); + drop(target_lock); + + release_symlink_tx.send(()).unwrap(); + symlink_thread.join().unwrap(); + target_thread.join().unwrap(); + + assert!(target_lock_is_held); + assert!(fs::symlink_metadata(&symlink_path) + .unwrap() + .file_type() + .is_symlink()); + let reloaded_manager = PermissionManager::new(target_config_dir); + assert_eq!( + reloaded_manager.get_user_permission("symlink_tool"), + Some(PermissionLevel::AlwaysAllow) + ); + assert_eq!( + reloaded_manager.get_user_permission("target_tool"), + Some(PermissionLevel::AskBefore) + ); + } + use test_case::test_case; #[test_case( diff --git a/crates/goose/tests/permission_persistence.rs b/crates/goose/tests/permission_persistence.rs new file mode 100644 index 000000000..1e11fd3d6 --- /dev/null +++ b/crates/goose/tests/permission_persistence.rs @@ -0,0 +1,129 @@ +use goose::config::permission::{PermissionConfig, PermissionLevel, PermissionManager}; +use std::collections::HashMap; + +#[test] +fn stale_manager_cannot_restore_revoked_permission() { + let config_dir = tempfile::tempdir().unwrap(); + let current_manager = PermissionManager::new(config_dir.path().to_path_buf()); + + current_manager.update_user_permission("dangerous_tool", PermissionLevel::AlwaysAllow); + let stale_manager = PermissionManager::new(config_dir.path().to_path_buf()); + + current_manager.update_user_permission("dangerous_tool", PermissionLevel::NeverAllow); + stale_manager.update_user_permission("unrelated_tool", PermissionLevel::AlwaysAllow); + + assert_eq!( + stale_manager.get_user_permission("dangerous_tool"), + Some(PermissionLevel::NeverAllow) + ); + + let reloaded_manager = PermissionManager::new(config_dir.path().to_path_buf()); + assert_eq!( + reloaded_manager.get_user_permission("dangerous_tool"), + Some(PermissionLevel::NeverAllow) + ); + assert_eq!( + reloaded_manager.get_user_permission("unrelated_tool"), + Some(PermissionLevel::AlwaysAllow) + ); +} + +#[test] +fn permission_updates_persist_across_manager_instances() { + let config_dir = tempfile::tempdir().unwrap(); + let manager = PermissionManager::new(config_dir.path().to_path_buf()); + + manager.update_user_permission("user_tool", PermissionLevel::AskBefore); + manager.update_smart_approve_permission("smart_tool", PermissionLevel::NeverAllow); + + let reloaded_manager = PermissionManager::new(config_dir.path().to_path_buf()); + assert_eq!( + reloaded_manager.get_user_permission("user_tool"), + Some(PermissionLevel::AskBefore) + ); + assert_eq!( + reloaded_manager.get_smart_approve_permission("smart_tool"), + Some(PermissionLevel::NeverAllow) + ); +} + +#[cfg(unix)] +#[test] +fn permission_updates_atomically_replace_storage_file() { + use std::os::unix::fs::MetadataExt; + + let config_dir = tempfile::tempdir().unwrap(); + let manager = PermissionManager::new(config_dir.path().to_path_buf()); + manager.update_user_permission("first_tool", PermissionLevel::AlwaysAllow); + + let permission_path = manager.get_config_path(); + let old_file = std::fs::File::open(permission_path).unwrap(); + let old_inode = old_file.metadata().unwrap().ino(); + + manager.update_user_permission("second_tool", PermissionLevel::AskBefore); + + assert_ne!(std::fs::metadata(permission_path).unwrap().ino(), old_inode); + let old_values: HashMap = serde_yaml::from_reader(old_file).unwrap(); + assert!(old_values["user"] + .always_allow + .contains(&"first_tool".to_string())); + assert!(!old_values["user"] + .ask_before + .contains(&"second_tool".to_string())); + + let current_manager = PermissionManager::new(config_dir.path().to_path_buf()); + assert_eq!( + current_manager.get_user_permission("first_tool"), + Some(PermissionLevel::AlwaysAllow) + ); + assert_eq!( + current_manager.get_user_permission("second_tool"), + Some(PermissionLevel::AskBefore) + ); +} + +#[cfg(unix)] +#[test] +fn permission_updates_preserve_storage_symlink() { + use std::os::unix::fs::symlink; + + let config_dir = tempfile::tempdir().unwrap(); + let permission_path = config_dir.path().join("permission.yaml"); + let target_path = config_dir.path().join("managed-permissions.yaml"); + std::fs::write(&target_path, "{}\n").unwrap(); + symlink("managed-permissions.yaml", &permission_path).unwrap(); + + let manager = PermissionManager::new(config_dir.path().to_path_buf()); + manager.update_user_permission("user_tool", PermissionLevel::AlwaysAllow); + + assert!(std::fs::symlink_metadata(&permission_path) + .unwrap() + .file_type() + .is_symlink()); + let persisted = PermissionManager::new(config_dir.path().to_path_buf()); + assert_eq!( + persisted.get_user_permission("user_tool"), + Some(PermissionLevel::AlwaysAllow) + ); +} + +#[test] +fn permission_removal_and_clear_persist() { + let config_dir = tempfile::tempdir().unwrap(); + let manager = PermissionManager::new(config_dir.path().to_path_buf()); + + manager.update_user_permission("git__status", PermissionLevel::AlwaysAllow); + manager.update_user_permission("github__status", PermissionLevel::AskBefore); + manager.remove_extension("git"); + + let reloaded_manager = PermissionManager::new(config_dir.path().to_path_buf()); + assert_eq!(reloaded_manager.get_user_permission("git__status"), None); + assert_eq!( + reloaded_manager.get_user_permission("github__status"), + Some(PermissionLevel::AskBefore) + ); + + reloaded_manager.clear_permissions(); + let cleared_manager = PermissionManager::new(config_dir.path().to_path_buf()); + assert!(cleared_manager.get_permission_names().is_empty()); +}