susshi 0.21.1

Terminal SSH manager with YAML inventories, multi-hop jump hosts, Wallix bastion, tunnels, SCP, and Catppuccin TUI
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use super::*;
use crate::fl;

impl App {
    /// Démarre le wizard de première configuration.
    pub fn start_wizard(&mut self) {
        self.wizard_state = WizardState::Form {
            form: WizardForm::default(),
            focus: WizardField::GroupName,
            error: None,
        };
    }

    fn wizard_focused_field(&mut self) -> Option<&mut String> {
        if let WizardState::Form { form, focus, .. } = &mut self.wizard_state {
            Some(match focus {
                WizardField::GroupName => &mut form.group_name,
                WizardField::ServerName => &mut form.server_name,
                WizardField::Host => &mut form.host,
                WizardField::User => &mut form.user,
            })
        } else {
            None
        }
    }

    pub fn wizard_push_char(&mut self, c: char) {
        if let WizardState::Form { error, .. } = &mut self.wizard_state {
            *error = None;
        }
        if let Some(field) = self.wizard_focused_field() {
            field.push(c);
        }
    }

    pub fn wizard_backspace(&mut self) {
        if let WizardState::Form { error, .. } = &mut self.wizard_state {
            *error = None;
        }
        if let Some(field) = self.wizard_focused_field() {
            field.pop();
        }
    }

    pub fn wizard_next_field(&mut self) {
        if let WizardState::Form { focus, .. } = &mut self.wizard_state {
            *focus = focus.next();
        }
    }

    pub fn wizard_prev_field(&mut self) {
        if let WizardState::Form { focus, .. } = &mut self.wizard_state {
            *focus = focus.prev();
        }
    }

    /// Ferme le wizard sans écrire de serveur : `~/.susshi.yml` reste tel
    /// qu'écrit au premier lancement (squelette `groups: []`).
    pub fn wizard_cancel(&mut self) {
        self.wizard_state = WizardState::Idle;
    }

    /// Valide le formulaire, écrit le groupe/serveur dans `~/.susshi.yml` et
    /// recharge la config. En cas de champ requis manquant, affiche une
    /// erreur dans l'overlay sans fermer le wizard.
    pub fn wizard_submit(&mut self) -> Result<(), ConfigError> {
        let WizardState::Form { form, error, .. } = &mut self.wizard_state else {
            return Ok(());
        };

        if form.group_name.trim().is_empty() {
            *error = Some(fl!("wizard-error-group-name"));
            return Ok(());
        }
        if form.server_name.trim().is_empty() {
            *error = Some(fl!("wizard-error-server-name"));
            return Ok(());
        }
        if form.host.trim().is_empty() {
            *error = Some(fl!("wizard-error-host"));
            return Ok(());
        }

        let yaml = render_group_yaml(form);
        std::fs::write(&self.config_path, yaml)?;

        self.wizard_state = WizardState::Idle;
        self.reload()?;
        self.set_status_message(fl!("wizard-created"));
        Ok(())
    }
}

/// Construit le contenu YAML complet de `~/.susshi.yml` pour un unique
/// groupe/serveur saisi via le wizard. Fonction pure — testable sans I/O.
pub fn render_group_yaml(form: &WizardForm) -> String {
    let mut out = String::new();
    out.push_str("groups:\n");
    out.push_str(&format!(
        "  - name: \"{}\"\n",
        escape_yaml(&form.group_name)
    ));
    out.push_str("    servers:\n");
    out.push_str(&format!(
        "      - name: \"{}\"\n",
        escape_yaml(&form.server_name)
    ));
    out.push_str(&format!("        host: \"{}\"\n", escape_yaml(&form.host)));
    if !form.user.trim().is_empty() {
        out.push_str(&format!("        user: \"{}\"\n", escape_yaml(&form.user)));
    }
    out
}

fn escape_yaml(s: &str) -> String {
    s.trim().replace('\\', "\\\\").replace('"', "\\\"")
}