purple-ssh 2.40.0

Open-source terminal SSH manager and SSH config editor. Search hundreds of hosts, sync from 16 clouds, transfer files, manage Docker and Podman over SSH, sign short-lived Vault SSH certs and expose an MCP server for AI agents. Rust TUI, MIT licensed.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use crossterm::event::{KeyCode, KeyEvent};
use std::sync::mpsc;

use crate::app::App;
use crate::event::AppEvent;

pub(super) fn handle_command_palette(
    app: &mut App,
    key: KeyEvent,
    events_tx: &mpsc::Sender<AppEvent>,
) {
    let palette = match app.palette.as_mut() {
        Some(p) => p,
        None => return,
    };

    match key.code {
        KeyCode::Esc => {
            log::debug!("palette: closed via Esc");
            app.palette = None;
        }
        KeyCode::Down => {
            let count = palette.filtered_commands().len();
            if count > 0 {
                palette.selected = (palette.selected + 1).min(count - 1);
            }
        }
        KeyCode::Up => {
            palette.selected = palette.selected.saturating_sub(1);
        }
        KeyCode::Enter => {
            let filtered = palette.filtered_commands();
            // Clamp selected in case the filter shrank since last navigation
            let clamped = palette.selected.min(filtered.len().saturating_sub(1));
            if let Some(cmd) = filtered.get(clamped) {
                let key_char = cmd.key;
                log::debug!(
                    "palette: executing '{}' ({}) via Enter",
                    key_char,
                    cmd.label
                );
                app.palette = None;
                execute_command(app, key_char, events_tx);
            }
        }
        KeyCode::Backspace => {
            if palette.query.is_empty() {
                log::debug!("palette: closed via Backspace on empty query");
                app.palette = None;
            } else {
                palette.pop_query();
            }
        }
        KeyCode::Char(c) => {
            palette.push_query(c);
        }
        _ => {}
    }
}

/// Execute a palette command by dispatching to the host list handler.
fn execute_command(app: &mut App, key_char: char, events_tx: &mpsc::Sender<AppEvent>) {
    use crossterm::event::KeyModifiers;
    let key = KeyEvent::new(KeyCode::Char(key_char), KeyModifiers::NONE);
    super::host_list::handle_host_list(app, key, events_tx);
}