Complete terminal management workflow

2026-10-21 23:25:31 +03:00
parent f718f739b4
commit 2ccd67d64c
19 changed files with 7313 additions and 53 deletions
@@ -0,0 +1,403 @@
+//! Secret-free navigation and session projections for the terminal interface.
+
+use std::collections::BTreeSet;
+use std::net::IpAddr;
+
+use crate::app::{Application, ClientDisplay};
+use crate::domain::{Client, PublicKey, RuntimeObservation};
+use crate::runtime::RuntimeObservation as Statistics;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Screen {
+    ClientList,
+    ClientDetails,
+    Help,
+    Progress,
+    Message,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Focus {
+    ClientList,
+    Details,
+    Dialog,
+    Help,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum DialogKind {
+    Rename,
+    Delete,
+    Create,
+    Commit,
+    Restart,
+    Exit,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum AppliedState {
+    Unknown,
+    Unavailable,
+    Verified,
+}
+
+/// Public client values for both states. No configuration bytes or secrets are
+/// retained in a view snapshot.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClientStateRow {
+    pub saved: Option<Client>,
+    pub draft: Option<Client>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SessionView {
+    pub generation: u64,
+    pub clients: Vec<ClientDisplay>,
+    pub client_states: std::collections::BTreeMap<PublicKey, ClientStateRow>,
+    pub document_issues: Vec<crate::wireguard::DocumentIssue>,
+    pub applied: AppliedState,
+    pub reserved_addresses: BTreeSet<IpAddr>,
+    pub statistics: Statistics,
+    pub has_draft: bool,
+    pub vault_initialized: bool,
+}
+
+impl SessionView {
+    pub fn from_application(app: &Application, generation: u64) -> Self {
+        let states = app.states();
+        let mut identities = BTreeSet::new();
+        identities.extend(states.saved().clients().map(|client| client.identity));
+        identities.extend(states.draft().clients().map(|client| client.identity));
+        let client_states = identities
+            .into_iter()
+            .map(|identity| {
+                (
+                    identity,
+                    ClientStateRow {
+                        saved: states.saved().get(&identity).cloned(),
+                        draft: states.draft().get(&identity).cloned(),
+                    },
+                )
+            })
+            .collect();
+        let applied = match states.applied() {
+            RuntimeObservation::Unknown => AppliedState::Unknown,
+            RuntimeObservation::Unavailable => AppliedState::Unavailable,
+            RuntimeObservation::Verified => AppliedState::Verified,
+        };
+        let projection = app.display_projection();
+        Self {
+            generation,
+            clients: projection.clients,
+            client_states,
+            document_issues: projection.document_issues,
+            applied,
+            reserved_addresses: states.reserved_addresses().clone(),
+            statistics: Statistics::unknown(),
+            has_draft: app.has_draft_changes(),
+            vault_initialized: app.vault_initialized(),
+        }
+    }
+
+    pub fn contains_identity(&self, identity: &PublicKey) -> bool {
+        self.clients
+            .iter()
+            .any(|client| client.identity == Some(*identity))
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum OperationKind {
+    CreateClient,
+    RenameClient,
+    DeleteClient,
+    DiscardDraft,
+    Commit,
+    CreateBackup,
+    ListBackups,
+    ImportSelectedFile,
+    InitialSetup,
+    PreviewRestart,
+    Restart,
+    DeliverClient,
+    Restore,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PendingOperation {
+    pub request_id: u64,
+    pub kind: OperationKind,
+    pub generation: u64,
+}
+
+/// Mutable UI navigation and latest accepted worker projection.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UiState {
+    pub screen: Screen,
+    pub focus: Focus,
+    pub dialog: Option<DialogKind>,
+    pub selected_identity: Option<PublicKey>,
+    /// Authoritative document index used only to inspect malformed peers that
+    /// have no public key. Mutating actions must always use selected_identity.
+    pub selected_peer_index: Option<usize>,
+    pub scroll_offset: usize,
+    pub generation: u64,
+    pub view: Option<SessionView>,
+    pub pending: Option<PendingOperation>,
+    pub status_message: Option<String>,
+}
+
+impl Default for UiState {
+    fn default() -> Self {
+        Self {
+            screen: Screen::ClientList,
+            focus: Focus::ClientList,
+            dialog: None,
+            selected_identity: None,
+            selected_peer_index: None,
+            scroll_offset: 0,
+            generation: 0,
+            view: None,
+            pending: None,
+            status_message: None,
+        }
+    }
+}
+
+impl UiState {
+    /// Replace the view only when it belongs to the current generation. The
+    /// selected full public key remains stable through sorting and refreshes.
+    pub fn apply_view(&mut self, view: SessionView) -> bool {
+        if view.generation != self.generation {
+            return false;
+        }
+        if self
+            .selected_identity
+            .is_some_and(|identity| !view.contains_identity(&identity))
+        {
+            self.selected_identity = None;
+        }
+        if let Some(identity) = self.selected_identity {
+            self.selected_peer_index = view
+                .clients
+                .iter()
+                .find(|client| client.identity == Some(identity))
+                .map(|client| client.peer_index);
+        } else if self
+            .selected_peer_index
+            .is_some_and(|index| !view.clients.iter().any(|client| client.peer_index == index))
+        {
+            self.selected_peer_index = None;
+        }
+        self.view = Some(view);
+        true
+    }
+
+    /// Apply only statistics sampled from the still-current saved/draft view.
+    /// This never changes the applied-state marker.
+    pub fn apply_statistics(&mut self, generation: u64, statistics: Statistics) -> bool {
+        if generation != self.generation {
+            return false;
+        }
+        let Some(view) = self.view.as_mut() else {
+            return false;
+        };
+        if view.generation != generation {
+            return false;
+        }
+        view.statistics = statistics;
+        true
+    }
+
+    pub fn begin_operation(&mut self, operation: PendingOperation) -> bool {
+        if self.pending.is_some() || operation.generation < self.generation {
+            return false;
+        }
+        self.generation = operation.generation;
+        self.pending = Some(operation);
+        self.screen = Screen::Progress;
+        true
+    }
+
+    /// Close a form/dialog without cancelling work already submitted to the
+    /// application worker. The pending progress state remains visible.
+    pub fn cancel_dialog(&mut self) {
+        self.dialog = None;
+        if self.pending.is_some() {
+            self.screen = Screen::Progress;
+        } else {
+            self.screen = if self.selected_identity.is_some() {
+                Screen::ClientDetails
+            } else {
+                Screen::ClientList
+            };
+        }
+    }
+
+    pub fn finish_operation(&mut self, operation: PendingOperation) -> bool {
+        if self.pending != Some(operation) {
+            return false;
+        }
+        self.pending = None;
+        self.screen = if self.dialog.is_some() {
+            Screen::Message
+        } else if self.selected_identity.is_some() {
+            Screen::ClientDetails
+        } else {
+            Screen::ClientList
+        };
+        true
+    }
+
+    pub fn select(&mut self, identity: PublicKey) -> bool {
+        if !self
+            .view
+            .as_ref()
+            .is_some_and(|view| view.contains_identity(&identity))
+        {
+            return false;
+        }
+        self.selected_identity = Some(identity);
+        self.selected_peer_index = self.view.as_ref().and_then(|view| {
+            view.clients
+                .iter()
+                .find(|client| client.identity == Some(identity))
+                .map(|client| client.peer_index)
+        });
+        self.screen = Screen::ClientDetails;
+        true
+    }
+
+    pub fn select_peer_index(&mut self, peer_index: usize) -> bool {
+        let Some(client) = self.view.as_ref().and_then(|view| {
+            view.clients
+                .iter()
+                .find(|client| client.peer_index == peer_index)
+        }) else {
+            return false;
+        };
+        self.selected_peer_index = Some(peer_index);
+        self.selected_identity = client.identity;
+        self.screen = Screen::ClientDetails;
+        true
+    }
+
+    pub fn selected_client_mutable(&self) -> bool {
+        let Some(identity) = self.selected_identity else {
+            return false;
+        };
+        self.view.as_ref().is_some_and(|view| {
+            view.clients.iter().any(|client| {
+                client.identity == Some(identity) && client.mutable_identity == Some(identity)
+            })
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::domain::PublicKey;
+    use crate::wireguard::PeerIssue;
+
+    fn row(identity: PublicKey, label: &str, mutable: bool) -> ClientDisplay {
+        ClientDisplay {
+            peer_index: 0,
+            line: 1,
+            identity: Some(identity),
+            label: label.to_owned(),
+            allowed_ips: vec!["10.0.0.2/32".to_owned()],
+            issues: if mutable {
+                Vec::new()
+            } else {
+                vec![PeerIssue::MissingIpv4HostRoute]
+            },
+            mutable_identity: mutable.then_some(identity),
+        }
+    }
+
+    fn view(generation: u64, clients: Vec<ClientDisplay>) -> SessionView {
+        SessionView {
+            generation,
+            clients,
+            client_states: Default::default(),
+            document_issues: Vec::new(),
+            applied: AppliedState::Unknown,
+            reserved_addresses: BTreeSet::new(),
+            statistics: Statistics::unknown(),
+            has_draft: false,
+            vault_initialized: true,
+        }
+    }
+
+    #[test]
+    fn refresh_preserves_selection_by_public_key_not_alias_or_row_position() {
+        let a = PublicKey::from_bytes([1; 32]);
+        let b = PublicKey::from_bytes([2; 32]);
+        let mut state = UiState::default();
+        assert!(state.apply_view(view(
+            0,
+            vec![row(a, "same alias", true), row(b, "same alias", true)]
+        )));
+        assert!(state.select(b));
+        assert!(state.apply_view(view(
+            0,
+            vec![row(b, "renamed", true), row(a, "same alias", true)]
+        )));
+        assert_eq!(state.selected_identity, Some(b));
+    }
+
+    #[test]
+    fn stale_view_is_rejected_and_unsupported_selected_peer_is_not_mutable() {
+        let key = PublicKey::from_bytes([3; 32]);
+        let mut state = UiState::default();
+        assert!(state.apply_view(view(0, vec![row(key, "legacy", false)])));
+        assert!(state.select(key));
+        assert!(!state.selected_client_mutable());
+        state.generation = 1;
+        assert!(!state.apply_view(view(0, vec![row(key, "stale", true)])));
+        assert_eq!(state.selected_identity, Some(key));
+    }
+
+    #[test]
+    fn malformed_peer_can_be_inspected_by_document_location_without_mutation_identity() {
+        let mut malformed = row(PublicKey::from_bytes([8; 32]), "malformed", false);
+        malformed.identity = None;
+        malformed.mutable_identity = None;
+        malformed.peer_index = 3;
+        let mut state = UiState::default();
+        assert!(state.apply_view(view(0, vec![malformed])));
+        assert!(state.select_peer_index(3));
+        assert_eq!(state.selected_identity, None);
+        assert_eq!(state.selected_peer_index, Some(3));
+        assert!(!state.selected_client_mutable());
+    }
+
+    #[test]
+    fn cancelling_a_dialog_does_not_claim_submitted_work_was_cancelled() {
+        let mut state = UiState {
+            dialog: Some(DialogKind::Commit),
+            ..UiState::default()
+        };
+        let operation = PendingOperation {
+            request_id: 4,
+            kind: OperationKind::Commit,
+            generation: 1,
+        };
+        assert!(state.begin_operation(operation));
+        state.cancel_dialog();
+        assert_eq!(state.pending, Some(operation));
+        assert_eq!(state.screen, Screen::Progress);
+    }
+
+    #[test]
+    fn statistics_refresh_is_generation_bound_and_never_changes_applied_state() {
+        let key = PublicKey::from_bytes([4; 32]);
+        let mut state = UiState::default();
+        assert!(state.apply_view(view(0, vec![row(key, "client", true)])));
+        assert!(state.apply_statistics(0, Statistics::unknown()));
+        assert_eq!(state.view.as_ref().unwrap().applied, AppliedState::Unknown);
+        state.generation = 1;
+        assert!(!state.apply_statistics(0, Statistics::unknown()));
+    }
+}