Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
workspace: Fix trust scope paths when connecting to Windows hosts from Unix (#63102)
Xin Zhao5504e87bfdaa
diff --git a/crates/path/src/path.rs b/crates/path/src/path.rsindex 58381bcdd9b..75f03b2af34 100644--- a/crates/path/src/path.rs+++ b/crates/path/src/path.rs@@ -311,7 +311,7 @@ impl PathStyle {})}- pub fn starts_with<P: AsRef<Path>>(&self, path: P, prefix: P) -> bool {+ pub fn starts_with(&self, path: impl AsRef<Path>, prefix: impl AsRef<Path>) -> bool {iter_after(self.components(path.as_ref()),self.components(prefix.as_ref()),diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rsindex 86bb621874d..d1f9c97db84 100644--- a/crates/project/src/trusted_worktrees.rs+++ b/crates/project/src/trusted_worktrees.rs@@ -287,6 +287,7 @@ impl TrustedWorktreesStore {let mut new_trusted_single_file_worktrees = HashSet::default();let mut new_trusted_other_worktrees = HashSet::default();let mut new_trusted_abs_paths = HashSet::default();+ let path_style = worktree_store.read(cx).path_style();for trusted_path in trusted_paths.iter().chain(self.trusted_paths.remove(&weak_worktree_store)@@ -337,9 +338,9 @@ impl TrustedWorktreesStore {}new_trusted_other_worktrees.retain(|(worktree_abs_path, _)| {- new_trusted_abs_paths- .iter()- .all(|new_trusted_path| !worktree_abs_path.starts_with(new_trusted_path))+ new_trusted_abs_paths.iter().all(|new_trusted_path| {+ !path_style.starts_with(worktree_abs_path, new_trusted_path)+ })});if !new_trusted_other_worktrees.is_empty() {new_trusted_single_file_worktrees.clear();@@ -366,7 +367,7 @@ impl TrustedWorktreesStore {let restricted_worktree_path = worktree.read(cx).abs_path();let retain = (!is_file || new_trusted_other_worktrees.is_empty())&& new_trusted_abs_paths.iter().all(|new_trusted_path| {- !restricted_worktree_path.starts_with(new_trusted_path)+ !path_style.starts_with(&restricted_worktree_path, new_trusted_path)});if !retain {trusted_paths.insert(PathTrust::Worktree(*restricted_worktree));@@ -472,6 +473,7 @@ impl TrustedWorktreesStore {return false;};let worktree_path = worktree.read(cx).abs_path();+ let path_style = worktree.read(cx).path_style();// Zed opened an "internal" directory: e.g. a tmp dir for `keymap_editor.rs` needs.if !worktree.read(cx).is_visible() {log::debug!("Skipping worktree trust checks for not visible {worktree_path:?}");@@ -496,7 +498,7 @@ impl TrustedWorktreesStore {}// * Single files are auto-approved when something else (not a single file) was approved on this host already.- // * If parent path is trusted already, this worktree is stusted also.+ // * If parent path is trusted already, this worktree is trusted also.//// See module documentation for details on trust level.if let Some(trusted_paths) = self.trusted_paths.get(&weak_worktree_store) {@@ -506,11 +508,11 @@ impl TrustedWorktreesStore {.worktree_for_id(*worktree_id, cx).is_some_and(|worktree| {let worktree = worktree.read(cx);- worktree_path.starts_with(&worktree.abs_path())+ path_style.starts_with(&worktree_path, &worktree.abs_path())|| (is_file && !worktree.is_single_file())}),PathTrust::AbsPath(trusted_path) => {- is_file || worktree_path.starts_with(trusted_path)+ is_file || path_style.starts_with(&worktree_path, trusted_path)}})});diff --git a/crates/project/tests/integration/trusted_worktrees.rs b/crates/project/tests/integration/trusted_worktrees.rsindex 5974a32ca8c..7b21b766b05 100644--- a/crates/project/tests/integration/trusted_worktrees.rs+++ b/crates/project/tests/integration/trusted_worktrees.rs@@ -955,3 +955,121 @@ async fn test_invisible_worktree_stores_do_not_affect_trust(cx: &mut TestAppCont"only visible worktrees should be restricted");}++#[gpui::test]+async fn test_windows_style_abs_path_trust_from_unix_client(cx: &mut TestAppContext) {+ use gpui::AppContext as _;+ use project::worktree_store::WorktreeIdCounter;+ use rpc::{AnyProtoClient, NoopProtoClient, proto};+ use util::paths::PathStyle;+ use worktree::Worktree;++ init_test(cx);++ let client = AnyProtoClient::new(NoopProtoClient::new());+ let worktree_store = cx.update(|cx| {+ cx.new(|_| {+ WorktreeStore::remote(+ true,+ client.clone(),+ 1,+ PathStyle::Windows,+ WorktreeIdCounter::default(),+ )+ })+ });++ let make_worktree = |id: u64, name: &str, abs_path: &str, cx: &mut TestAppContext| {+ let metadata = proto::WorktreeMetadata {+ id,+ root_name: name.to_string(),+ visible: true,+ abs_path: abs_path.to_string(),+ root_repo_common_dir: None,+ root_repo_is_linked_worktree: false,+ };+ let worktree = cx.update(|cx| {+ Worktree::remote(+ 1,+ clock::ReplicaId::new(1),+ metadata,+ client.clone(),+ PathStyle::Windows,+ cx,+ )+ });+ worktree.update(cx, |worktree, _| {+ worktree+ .as_remote()+ .unwrap()+ .update_from_remote(proto::UpdateWorktree {+ project_id: 1,+ worktree_id: id,+ abs_path: abs_path.to_string(),+ root_name: name.to_string(),+ updated_entries: vec![proto::Entry {+ id: 1,+ is_dir: true,+ path: "".to_string(),+ inode: 1,+ mtime: Some(proto::Timestamp {+ seconds: 0,+ nanos: 0,+ }),+ is_ignored: false,+ is_hidden: false,+ is_external: false,+ is_fifo: false,+ size: None,+ canonical_path: None,+ is_unloaded: false,+ }],+ removed_entries: vec![],+ scan_id: 1,+ is_last_update: true,+ updated_repositories: vec![],+ removed_repositories: vec![],+ root_repo_common_dir: None,+ root_repo_is_linked_worktree: false,+ });+ });+ cx.run_until_parked();+ worktree+ };++ let worktree_t1 = make_worktree(1, "t1", r"C:\Users\me\dev\wt\t1", cx);+ let worktree_t2 = make_worktree(2, "t2", r"C:\Users\me\dev\wt\t2", cx);+ let t1_id = worktree_t1.read_with(cx, |worktree, _| worktree.id());+ let t2_id = worktree_t2.read_with(cx, |worktree, _| worktree.id());+ worktree_store.update(cx, |store, cx| {+ store.add(&worktree_t1, cx);+ store.add(&worktree_t2, cx);+ });+ assert!(+ !worktree_t1.read_with(cx, |worktree, _| worktree.is_single_file()),+ "t1 must be a folder worktree for this test to be meaningful"+ );++ let trusted_worktrees = init_trust_global(worktree_store.clone(), cx);++ assert!(+ !trusted_worktrees.update(cx, |store, cx| store.can_trust(&worktree_store, t1_id, cx)),+ "t1 should be restricted by default"+ );++ trusted_worktrees.update(cx, |store, cx| {+ store.trust(+ &worktree_store,+ HashSet::from_iter([+ PathTrust::Worktree(t1_id),+ PathTrust::AbsPath(PathBuf::from(r"C:\Users\me\dev\wt")),+ ]),+ cx,+ );+ });++ assert!(+ trusted_worktrees.update(cx, |store, cx| store.can_trust(&worktree_store, t2_id, cx)),+ "t2 should be auto-trusted by the trusted parent scope C:\\Users\\me\\dev\\wt"+ );+}diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rsindex 10179861370..467a9a356ce 100644--- a/crates/workspace/src/security_modal.rs+++ b/crates/workspace/src/security_modal.rs@@ -7,7 +7,9 @@ use std::{};use collections::{HashMap, HashSet};-use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ScrollHandle, WeakEntity};+use gpui::{+ DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ScrollHandle, Task, WeakEntity,+};use project::{WorktreeId,@@ -22,13 +24,14 @@ use ui::{};use ui_input::InputField;-use util::paths::PathStyle;+use util::{ResultExt, paths::PathStyle};use crate::{DismissDecision, ModalView, ToggleWorktreeSecurity};pub struct SecurityModal {restricted_paths: HashMap<WorktreeId, RestrictedPath>,home_dir: Option<PathBuf>,+ _home_dir_task: Task<()>,trust_parents: bool,worktree_store: WeakEntity<WorktreeStore>,remote_host: Option<RemoteHostLocation>,@@ -90,7 +93,8 @@ impl Render for SecurityModal {format!("Unrecognized Projects ({})", restricted_count).into()};- let trust_label = self.build_trust_label();+ let path_style = self.path_style(cx);+ let trust_label = self.build_trust_label(path_style);// The editable trust-scope field is shown only when a single project is// being prompted for (Delta opens one worktree per thread).@@ -138,7 +142,7 @@ impl Render for SecurityModal {self.restricted_paths.values().filter_map(|restricted_path| {let abs_path = if restricted_path.is_file {- restricted_path.abs_path.parent()+ path_style.parent(&restricted_path.abs_path)} else {Some(restricted_path.abs_path.as_ref())}?;@@ -147,21 +151,21 @@ impl Render for SecurityModal {match &remote_host.user_name {Some(user_name) => format!("{} ({}@{})",- self.shorten_path(abs_path)+ self.shorten_path(abs_path, path_style).display(),user_name,remote_host.host_identifier),None => format!("{} ({})",- self.shorten_path(abs_path)+ self.shorten_path(abs_path, path_style).display(),remote_host.host_identifier),}}None => self- .shorten_path(abs_path)+ .shorten_path(abs_path, path_style).display().to_string(),};@@ -309,10 +313,19 @@ impl SecurityModal {pub fn new(worktree_store: WeakEntity<WorktreeStore>,remote_host: Option<impl Into<RemoteHostLocation>>,+ home_dir_task: Task<Option<PathBuf>>,window: &mut Window,cx: &mut Context<Self>,) -> Self {let trust_path_input = cx.new(|cx| InputField::new(window, cx, "Folder to trust"));+ let task = cx.spawn(async |this, cx| {+ let home_dir = home_dir_task.await;+ this.update(cx, |this, cx| {+ this.home_dir = home_dir;+ cx.notify();+ })+ .log_err();+ });let mut this = Self {worktree_store,remote_host: remote_host.map(|host| host.into()),@@ -320,7 +333,8 @@ impl SecurityModal {focus_handle: cx.focus_handle(),project_list_scroll_handle: ScrollHandle::new(),trust_parents: false,- home_dir: std::env::home_dir(),+ home_dir: None,+ _home_dir_task: task,trusted: None,trust_path_input,};@@ -329,7 +343,11 @@ impl SecurityModal {// Pre-fill with the single project's parent folder (today's static// scope), read-only until the checkbox is ticked.if let Some(project) = this.single_trustable_path() {- let default_scope = project.parent().unwrap_or(&project).to_path_buf();+ let path_style = this.path_style(cx);+ let default_scope = path_style+ .parent(&project)+ .unwrap_or(&project)+ .to_path_buf();this.trust_path_input.update(cx, |field, cx| {field.set_text(&default_scope.to_string_lossy(), window, cx);});@@ -340,7 +358,7 @@ impl SecurityModal {this}- fn build_trust_label(&self) -> Option<Cow<'static, str>> {+ fn build_trust_label(&self, path_style: PathStyle) -> Option<Cow<'static, str>> {let mut has_restricted_files = false;let available_parents = self.restricted_paths@@ -349,7 +367,7 @@ impl SecurityModal {has_restricted_files |= restricted_path.is_file;!restricted_path.is_file})- .filter_map(|restricted_path| restricted_path.abs_path.parent())+ .filter_map(|restricted_path| path_style.parent(&restricted_path.abs_path)).collect::<SmallVec<[_; 2]>>();match available_parents.len() {0 => {@@ -361,18 +379,27 @@ impl SecurityModal {}1 => Some(Cow::Owned(format!("Trust all projects in the {:} folder",- self.shorten_path(available_parents[0]).display()+ self.shorten_path(available_parents[0], path_style)+ .display()))),_ => Some(Cow::Borrowed("Trust all projects in the parent folders")),}}- fn shorten_path<'a>(&self, path: &'a Path) -> Cow<'a, Path> {+ fn path_style(&self, cx: &App) -> PathStyle {+ self.worktree_store+ .upgrade()+ .map(|store| store.read(cx).path_style())+ .unwrap_or_else(PathStyle::local)+ }++ fn shorten_path<'a>(&self, path: &'a Path, path_style: PathStyle) -> Cow<'a, Path> {match &self.home_dir {- Some(home_dir) => path- .strip_prefix(home_dir)- .map(|stripped| Path::new("~").join(stripped))- .map(Cow::Owned)+ Some(home_dir) => path_style+ .strip_prefix(path, home_dir)+ .ok()+ .and_then(|stripped| path_style.join("~", stripped))+ .map(|joined| Cow::Owned(PathBuf::from(joined))).unwrap_or(Cow::Borrowed(path)),None => Cow::Borrowed(path),}@@ -389,11 +416,7 @@ impl SecurityModal {return Ok(None);};let typed = self.trust_path_input.read(cx).text(cx);- let path_style = self- .worktree_store- .upgrade()- .map(|store| store.read(cx).path_style())- .unwrap_or_else(PathStyle::local);+ let path_style = self.path_style(cx);validate_trust_scope(&typed, &project, self.home_dir.as_deref(), path_style).map(Some)}@@ -422,13 +445,14 @@ impl SecurityModal {if let Some(scope) = scope_override {paths_to_trust.insert(PathTrust::AbsPath(scope));} else {+ let path_style = self.path_style(cx);paths_to_trust.extend(self.restricted_paths.values().filter_map(|restricted_paths| {if restricted_paths.is_file {None} else {let parent_abs_path =- restricted_paths.abs_path.parent()?.to_owned();+ path_style.parent(&restricted_paths.abs_path)?.to_owned();Some(PathTrust::AbsPath(parent_abs_path))}},@@ -511,23 +535,33 @@ fn validate_trust_scope(if trimmed.is_empty() {return Err("Enter a folder to trust".into());}+ if home_dir.is_none() && trimmed.starts_with('~') {+ return Err("Home directory not available".into());+ }let expanded = match (trimmed.strip_prefix('~'), home_dir) {- (Some(rest), Some(home_dir)) => home_dir.join(- rest.strip_prefix(path_style.primary_separator())- .unwrap_or(rest),- ),+ (Some(rest), Some(home_dir)) => {+ let rest = rest.trim_start_matches(path_style.separators_ch());+ if path_style == PathStyle::local() {+ home_dir.join(rest)+ } else {+ path_style+ .join_path_preserving_components(home_dir, rest)+ .map_err(|error| SharedString::from(error.to_string()))?+ }+ }_ => PathBuf::from(trimmed),};if !path_style.is_absolute(&expanded) {return Err("Enter an absolute folder path".into());}- if !project.starts_with(&expanded) {++ if !path_style.starts_with(project, expanded.as_path()) {return Err("Must be a parent folder of the project".into());}Ok(expanded)}-#[cfg(all(test, unix))]+#[cfg(test)]mod tests {use super::*;@@ -561,6 +595,61 @@ mod tests {);}+ #[test]+ fn accepts_windows_style_ancestor() {+ let project = Path::new(r"C:\Users\me\dev\wt\t1");+ let style = PathStyle::Windows;++ assert_eq!(+ validate_trust_scope(r"C:\Users\me\dev\wt", project, None, style).unwrap(),+ PathBuf::from(r"C:\Users\me\dev\wt"),+ );++ assert!(validate_trust_scope(r"C:\Users\me", project, None, style).is_ok());++ assert_eq!(+ validate_trust_scope(r"C:\Users\me\dev\wt\t1", project, None, style).unwrap(),+ PathBuf::from(r"C:\Users\me\dev\wt\t1")+ );++ // Drive letters are matched case-insensitively.+ assert_eq!(+ validate_trust_scope(r"c:\Users\me\dev\wt", project, None, style).unwrap(),+ PathBuf::from(r"c:\Users\me\dev\wt")+ );+ }++ #[test]+ fn rejects_windows_style_non_ancestor() {+ let project = Path::new(r"C:\Users\me\dev\wt\t1");+ let style = PathStyle::Windows;+ assert!(validate_trust_scope(r"C:\Users\other", project, None, style).is_err());+ // Relative paths are not absolute.+ assert!(validate_trust_scope(r"dev\wt", project, None, style).is_err());+ // Deeper than the project is not an ancestor.+ assert!(validate_trust_scope(r"C:\Users\me\dev\wt\t1\sub", project, None, style).is_err());+ // A prefix that is not a component boundary is not an ancestor.+ assert!(+ validate_trust_scope(+ r"C:\Users\me\dev\wt",+ Path::new(r"C:\Users\me\dev\wt2"),+ None,+ style,+ )+ .is_err()+ );++ assert!(+ validate_trust_scope(+ r"\\server",+ Path::new(r"\\server\share\project"),+ None,+ style+ )+ .is_err()+ );+ }+#[test]fn expands_leading_tilde() {let home = Path::new("/Users/me");diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rsindex d1dc10081ab..6ddb3431056 100644--- a/crates/workspace/src/workspace.rs+++ b/crates/workspace/src/workspace.rs@@ -9089,8 +9089,20 @@ impl Workspace {.remote_connection_options(cx).map(RemoteHostLocation::from);let worktree_store = project.worktree_store().downgrade();+ let home_dir_task = if project.is_local() {+ Task::ready(std::env::home_dir())+ } else {+ let resolve_task = project.resolve_abs_path("~", cx);+ cx.spawn(async |_, _| {+ let resolved_path = resolve_task+ .await+ .and_then(|path| path.into_abs_path())+ .map(PathBuf::from);+ resolved_path+ })+ };self.toggle_modal(window, cx, |window, cx| {- SecurityModal::new(worktree_store, remote_host, window, cx)+ SecurityModal::new(worktree_store, remote_host, home_dir_task, window, cx)});}}