afar 0.0.0

Operate shells from afar: line-mode terminal panes over local PTY or SSH for egui, rendered through egui-elegance's MultiTerminal.
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
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! `LiveMultiTerminal` — wraps elegance's `MultiTerminal` with backends.
//!
//! See §4 of `terminal_crate_plan.md`. The widget owns one backend per
//! pane, drains `TerminalEvent::Command` from the inner `MultiTerminal`,
//! writes typed bytes to the backend, and pumps stdout/stderr lines back
//! into `push_line` via the [`crate::ansi::AnsiHandler`].

use std::collections::HashMap;
use std::hash::Hash;

use egui::{Response, Ui};
use elegance::MultiTerminal;

use crate::ansi::AnsiHandler;
use crate::backend::BackendHandle;

/// Policy for what to drop when a pane's output ring buffer fills.
///
/// Default is [`OverflowPolicy::DropNewest`]: when bytes arrive faster
/// than the UI can drain them, the new bytes are discarded and a
/// `[N bytes dropped]` marker is rendered at the truncation point. This
/// preserves the head of the buffer (where build/log streams keep their
/// first error). Switch to `DropOldest` for live-tail scenarios.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum OverflowPolicy {
    #[default]
    DropNewest,
    DropOldest,
}

#[allow(dead_code)]
struct Pane {
    backend: BackendHandle,
    ansi: AnsiHandler,
}

/// Multi-pane terminal widget driven by real backends.
///
/// See `terminal_crate_plan.md` §4.
#[allow(dead_code)] // `panes` and `overflow` are wired up in M1.
pub struct LiveMultiTerminal {
    inner: MultiTerminal,
    panes: HashMap<String, Pane>,
    overflow: OverflowPolicy,
}

impl LiveMultiTerminal {
    pub fn new(id_salt: impl Hash) -> Self {
        Self {
            inner: MultiTerminal::new(id_salt),
            panes: HashMap::new(),
            overflow: OverflowPolicy::default(),
        }
    }

    pub fn overflow_policy(mut self, policy: OverflowPolicy) -> Self {
        self.overflow = policy;
        self
    }

    /// Add a pane backed by a local shell. Requires the `local` feature.
    #[cfg(feature = "local")]
    pub fn add_local_pane(
        &mut self,
        _id: impl Into<String>,
        _config: crate::backend::local::LocalShellConfig,
    ) {
        todo!("LiveMultiTerminal::add_local_pane — M1")
    }

    /// Add a pane backed by an SSH session. Requires the `ssh` feature.
    #[cfg(feature = "ssh")]
    pub fn add_ssh_pane(
        &mut self,
        _id: impl Into<String>,
        _config: crate::backend::ssh::SshConfig,
    ) {
        todo!("LiveMultiTerminal::add_ssh_pane — M2")
    }

    /// Restricted view of the underlying [`MultiTerminal`]. Exposes the
    /// safe operations (broadcast, solo, collapse, focus, scrollback
    /// queries); structural mutators are deliberately not reachable so
    /// the wrapper invariant ("every pane has a backend") holds.
    pub fn controls(&mut self) -> LiveMultiTerminalControls<'_> {
        LiveMultiTerminalControls {
            inner: &mut self.inner,
        }
    }

    pub fn show(&mut self, _ui: &mut Ui) -> Response {
        // M1: drain `inner.take_events()`, forward Command events as input
        // bytes to the targeted backends; for each pane, drain BackendEvent
        // from its handle, feed bytes through `ansi`, and push each emitted
        // TerminalLine into `inner`. Then call `inner.show(ui)`.
        todo!("LiveMultiTerminal::show — M1")
    }
}

/// Restricted view of the inner [`MultiTerminal`]. See §4 of the plan.
pub struct LiveMultiTerminalControls<'a> {
    inner: &'a mut MultiTerminal,
}

impl<'a> LiveMultiTerminalControls<'a> {
    pub fn toggle_broadcast(&mut self, id: &str) {
        self.inner.toggle_broadcast(id);
    }

    pub fn solo(&mut self, id: &str) {
        self.inner.solo(id);
    }

    pub fn solo_focused(&mut self) {
        self.inner.solo_focused();
    }

    pub fn broadcast_all(&mut self) {
        self.inner.broadcast_all();
    }

    pub fn invert_broadcast(&mut self) {
        self.inner.invert_broadcast();
    }

    pub fn toggle_collapsed(&mut self, id: &str) {
        self.inner.toggle_collapsed(id);
    }

    pub fn collapse_all(&mut self) {
        self.inner.collapse_all();
    }

    pub fn expand_all(&mut self) {
        self.inner.expand_all();
    }

    pub fn focused(&self) -> Option<&str> {
        self.inner.focused()
    }

    pub fn set_focused(&mut self, id: Option<String>) {
        self.inner.set_focused(id);
    }
}