From c5932990be6c8588588ced673ec9fd25faafef03 Mon Sep 17 00:00:00 2001 From: squid Date: Sun, 1 Nov 2026 21:17:40 +0100 Subject: [PATCH] Added a ssh key selector for profiles --- src/main.rs | 213 +++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 193 insertions(+), 20 deletions(-) diff --git a/src/main.rs b/src/main.rs index 108af21..473eee4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -371,6 +371,7 @@ struct Profile { auth: AuthMethod, password: String, start_path: String, + private_key: String, } /// Editable state of the "add profile" dialog. @@ -387,6 +388,7 @@ struct ProfileDraft { password: String, password_visible: bool, start_path: String, + private_key: String, } impl ProfileDraft { @@ -403,6 +405,7 @@ impl ProfileDraft { password: String::new(), password_visible: false, start_path: default_start_path(), + private_key: String::new(), } } @@ -434,19 +437,33 @@ impl std::fmt::Display for FolderChoice { } } -/// In-app directory browser state. +/// Which profile field a path picker is filling. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum PickerTarget { + StartPath, + PrivateKey, +} + +/// In-app path browser state. In folder mode only directories are listed and +/// the current directory can be chosen; in file mode files are listed too. #[derive(Debug, Clone)] struct DirPicker { path: PathBuf, entries: Vec, + selected: Option, + files: bool, + target: PickerTarget, error: Option, } impl DirPicker { - fn open(path: PathBuf) -> Self { + fn open(path: PathBuf, files: bool, target: PickerTarget) -> Self { let mut picker = Self { path, entries: Vec::new(), + selected: None, + files, + target, error: None, }; picker.reload(); @@ -456,17 +473,28 @@ impl DirPicker { fn reload(&mut self) { match std::fs::read_dir(&self.path) { Ok(read) => { - let mut entries: Vec = read - .filter_map(|entry| entry.ok()) - .map(|entry| entry.path()) - .filter(|path| path.is_dir()) - .collect(); - entries.sort(); - self.entries = entries; + let mut directories = Vec::new(); + let mut files = Vec::new(); + + for entry in read.filter_map(|entry| entry.ok()) { + let path = entry.path(); + if path.is_dir() { + directories.push(path); + } else if self.files { + files.push(path); + } + } + + directories.sort(); + files.sort(); + self.entries = directories; + self.entries.extend(files); + self.selected = None; self.error = None; } Err(error) => { self.entries.clear(); + self.selected = None; self.error = Some(error.to_string()); } } @@ -476,6 +504,10 @@ impl DirPicker { self.path = path; self.reload(); } + + fn can_confirm(&self) -> bool { + !self.files || self.selected.is_some() + } } fn home_dir() -> PathBuf { @@ -674,8 +706,11 @@ enum Message { ProfilePasswordChanged(String), TogglePasswordVisibility, ProfileStartPathChanged(String), + ProfilePrivateKeyChanged(String), OpenDirectoryPicker, + OpenPrivateKeyPicker, DirPickerEnter(PathBuf), + DirPickerSelect(PathBuf), DirPickerUp, ConfirmDirectoryPicker, CancelDirectoryPicker, @@ -852,6 +887,11 @@ fn update(state: &mut Moorly, message: Message) -> Task { draft.start_path = value; } } + Message::ProfilePrivateKeyChanged(value) => { + if let Some(draft) = state.profile_dialog.as_mut() { + draft.private_key = value; + } + } Message::OpenDirectoryPicker => { let path = state .profile_dialog @@ -860,13 +900,37 @@ fn update(state: &mut Moorly, message: Message) -> Task { .filter(|path| path.is_dir()) .unwrap_or_else(home_dir); - state.dir_picker = Some(DirPicker::open(path)); + state.dir_picker = Some(DirPicker::open(path, false, PickerTarget::StartPath)); + } + Message::OpenPrivateKeyPicker => { + let typed = state + .profile_dialog + .as_ref() + .map(|draft| resolve_start_path(&draft.private_key)) + .unwrap_or_default(); + + let directory = if typed.is_dir() { + typed + } else { + typed + .parent() + .filter(|path| path.is_dir()) + .map(PathBuf::from) + .unwrap_or_else(home_dir) + }; + + state.dir_picker = Some(DirPicker::open(directory, true, PickerTarget::PrivateKey)); } Message::DirPickerEnter(path) => { if let Some(picker) = state.dir_picker.as_mut() { picker.navigate(path); } } + Message::DirPickerSelect(path) => { + if let Some(picker) = state.dir_picker.as_mut() { + picker.selected = Some(path); + } + } Message::DirPickerUp => { if let Some(picker) = state.dir_picker.as_mut() { if let Some(parent) = picker.path.parent().map(PathBuf::from) { @@ -876,8 +940,17 @@ fn update(state: &mut Moorly, message: Message) -> Task { } Message::ConfirmDirectoryPicker => { if let Some(picker) = state.dir_picker.take() { - if let Some(draft) = state.profile_dialog.as_mut() { - draft.start_path = picker.path.to_string_lossy().into_owned(); + let value = match picker.target { + PickerTarget::StartPath => Some(picker.path.clone()), + PickerTarget::PrivateKey => picker.selected.clone(), + }; + + if let (Some(value), Some(draft)) = (value, state.profile_dialog.as_mut()) { + let value = value.to_string_lossy().into_owned(); + match picker.target { + PickerTarget::StartPath => draft.start_path = value, + PickerTarget::PrivateKey => draft.private_key = value, + } } } } @@ -906,6 +979,7 @@ fn update(state: &mut Moorly, message: Message) -> Task { auth: draft.auth, password: draft.password.clone(), start_path: draft.start_path.clone(), + private_key: draft.private_key.clone(), }); folder.expanded = true; state.selected = Some(Selection::Profile { @@ -1481,7 +1555,7 @@ fn profiles_panel(state: &Moorly) -> Element<'_, Message> { layers.into() } -/// Folder browser used by the Terminal "Start path" field. +/// Folder/file browser used by the Terminal start path and SSH private key. fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { let mut entries = column![].width(Length::Fill); @@ -1496,21 +1570,32 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { } for path in &picker.entries { + let is_dir = path.is_dir(); let name = path .file_name() .map(|name| name.to_string_lossy().into_owned()) .unwrap_or_else(|| path.display().to_string()); + let glyph = if is_dir { "📁" } else { "📄" }; + let message = if is_dir { + Message::DirPickerEnter(path.clone()) + } else { + Message::DirPickerSelect(path.clone()) + }; + let selected = picker.selected.as_ref() == Some(path); + entries = entries.push( button( - row![text("📁").size(14), text(name)] + row![text(glyph).size(14), text(name)] .spacing(8) .align_y(Alignment::Center), ) - .on_press(Message::DirPickerEnter(path.clone())) + .on_press(message) .width(Length::Fill) .padding([6, 8]) - .style(button::text), + .style(move |theme, status| { + theme::selectable_row(theme, status, selected) + }), ); } @@ -1519,14 +1604,24 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { .height(240) .style(theme::settings_frame); + let title = if picker.files { + "Select private key" + } else { + "Select folder" + }; + let mut content = column![ - text("Select folder").size(16), + text(title).size(16), text(picker.path.display().to_string()).size(12), listing, ] .spacing(10) .width(Length::Fill); + if let Some(selected) = &picker.selected { + content = content.push(text(selected.display().to_string()).size(12)); + } + if let Some(error) = &picker.error { content = content.push(text(error).size(12).color(theme::DANGER)); } @@ -1538,7 +1633,7 @@ fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> { .on_press(Message::CancelDirectoryPicker) .style(theme::danger_option), button("Select") - .on_press(Message::ConfirmDirectoryPicker) + .on_press_maybe(picker.can_confirm().then_some(Message::ConfirmDirectoryPicker)) .style(theme::positive_option), ] .spacing(8), @@ -1669,7 +1764,9 @@ fn profile_kind_view(draft: &ProfileDraft) -> Element<'_, Message> { button("...") .on_press(Message::OpenDirectoryPicker) .padding([2, 6]) - .style(button::text), + .style(|theme, status| { + theme::selectable_row(theme, status, false) + }), ) .width(Length::Fill) .height(Length::Fill) @@ -1760,6 +1857,10 @@ fn profile_kind_view(draft: &ProfileDraft) -> Element<'_, Message> { content = content.push(password_field(draft)); } + if draft.auth == AuthMethod::Key { + content = content.push(private_key_field(draft)); + } + content.into() } } @@ -1825,6 +1926,41 @@ fn password_field(draft: &ProfileDraft) -> Element<'_, Message> { .into() } +/// Private key label and file field with a browse button. +fn private_key_field(draft: &ProfileDraft) -> Element<'_, Message> { + let field = text_input("Private key", &draft.private_key) + .on_input(Message::ProfilePrivateKeyChanged) + .padding(Padding { + top: 6.0, + right: 40.0, + bottom: 6.0, + left: 8.0, + }) + .style(theme::filter_field) + .width(Length::Fill); + + let browse = container( + button("...") + .on_press(Message::OpenPrivateKeyPicker) + .padding([2, 6]) + .style(|theme, status| { + theme::selectable_row(theme, status, false) + }), + ) + .width(Length::Fill) + .height(Length::Fill) + .align_x(Alignment::End) + .align_y(Alignment::Center) + .padding(Padding::ZERO.right(6.0)); + + column![ + text("Private Key").size(12), + stack![field, browse].width(Length::Fill), + ] + .spacing(4) + .into() +} + /// One folder heading followed by its profiles. Clicking the heading toggles /// the profile list; clicking a row selects it. fn profile_folder_row( @@ -2653,13 +2789,50 @@ mod tests { let child = root.join("child"); std::fs::create_dir_all(&child).unwrap(); - let picker = super::DirPicker::open(root.clone()); + let picker = super::DirPicker::open( + root.clone(), + false, + super::PickerTarget::StartPath, + ); assert_eq!(picker.entries, vec![child]); assert!(picker.error.is_none()); std::fs::remove_dir_all(&root).unwrap(); } + #[test] + fn private_key_picker_selects_a_file() { + let stamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(); + let root = std::env::temp_dir().join(format!("moorly-key-test-{stamp}")); + std::fs::create_dir_all(&root).unwrap(); + let key = root.join("id_test"); + std::fs::write(&key, b"key").unwrap(); + + let mut picker = + super::DirPicker::open(root.clone(), true, super::PickerTarget::PrivateKey); + assert_eq!(picker.entries, vec![key.clone()]); + assert!(!picker.can_confirm()); + + picker.selected = Some(key.clone()); + assert!(picker.can_confirm()); + + let mut state = state(); + state.profile_dialog = Some(super::ProfileDraft::new(0)); + state.dir_picker = Some(picker); + let _ = update(&mut state, Message::ConfirmDirectoryPicker); + + assert_eq!( + state.profile_dialog.as_ref().unwrap().private_key, + key.to_string_lossy() + ); + assert!(state.dir_picker.is_none()); + + std::fs::remove_dir_all(&root).unwrap(); + } + #[test] fn adding_a_folder_selects_it() { let mut state = state();