1use std::io::Write;
2use std::path::PathBuf;
3use std::sync::{Arc, Mutex, PoisonError};
4use std::thread::JoinHandle;
5
6use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
7use log::info;
8use portable_pty::{
9 ChildKiller, CommandBuilder, ExitStatus, MasterPty, NativePtySystem, PtySize, PtySystem,
10};
11use ratatui::prelude::*;
12use ratatui::symbols::border;
13use ratatui::widgets::{Block, Clear, Widget};
14use tui_term::widget::PseudoTerminal;
15use vt100_ctt::Parser;
16
17use crate::error::{CarchError, Result};
18use crate::ui::theme::Theme;
19
20const SCROLLBACK_LEN: usize = 1000;
21const PAGE_STEP: usize = 10;
22
23type ChildKillerSender = oneshot::Sender<Option<Box<dyn ChildKiller + Send + Sync>>>;
24type ChildKillerReceiver = oneshot::Receiver<Option<Box<dyn ChildKiller + Send + Sync>>>;
25
26pub enum PopupEvent {
27 Close,
28 None,
29}
30
31pub struct RunScriptPopup {
32 buffer: Arc<Mutex<Vec<u8>>>,
33 command_thread: Option<JoinHandle<ExitStatus>>,
34 child_killer: Option<ChildKillerReceiver>,
35 pty_master: Box<dyn MasterPty + Send>,
36 writer: Box<dyn Write + Send>,
37 status: Option<ExitStatus>,
38 parser: Option<Parser>,
39 parser_size: (u16, u16),
40 pty_size: (u16, u16),
41 processed_len: usize,
42 last_max_check: usize,
43 scroll_offset: usize,
44 actual_max: usize,
45 auto_scroll: bool,
46 theme: Theme,
47 was_finished: bool,
48}
49
50impl RunScriptPopup {
51 pub fn new(script_path: PathBuf, log_mode: bool, theme: Theme) -> Result<Self> {
52 let pty_system = NativePtySystem::default();
53
54 let mut cmd = CommandBuilder::new("bash");
55 cmd.arg(script_path);
56
57 let pair = pty_system
58 .openpty(PtySize {
59 rows: 24,
60 cols: 80,
61 pixel_width: 0,
62 pixel_height: 0,
63 })
64 .map_err(|e| CarchError::Pty(format!("openpty: {e}")))?;
65
66 let (tx, rx): (ChildKillerSender, ChildKillerReceiver) = oneshot::channel();
67 let pair_slave = pair.slave;
68 let command_handle = std::thread::spawn(move || -> ExitStatus {
69 match pair_slave.spawn_command(cmd) {
70 Ok(mut child) => {
71 let killer = child.clone_killer();
72 if tx.send(Some(killer)).is_err() {
73 log::warn!("child_killer receiver dropped before killer was sent");
74 }
75 child.wait().unwrap_or_else(|e| {
76 log::error!("child.wait failed: {e}");
77 ExitStatus::with_exit_code(1)
78 })
79 }
80 Err(e) => {
81 log::error!("spawn_command failed: {e}");
82 if tx.send(None).is_err() {
83 log::warn!("child_killer receiver dropped before None was sent");
84 }
85 ExitStatus::with_exit_code(1)
86 }
87 }
88 });
89
90 let mut reader = pair
91 .master
92 .try_clone_reader()
93 .map_err(|e| CarchError::Pty(format!("try_clone_reader: {e}")))?;
94
95 let command_buffer: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));
96 {
97 let command_buffer = command_buffer.clone();
98 std::thread::spawn(move || {
99 let mut buf = [0u8; 16384];
100 while let Ok(size) = reader.read(&mut buf) {
101 if size == 0 {
102 break;
103 }
104 let mut mutex = match command_buffer.lock() {
105 Ok(g) => g,
106 Err(p) => p.into_inner(),
107 };
108 let data = &buf[0..size];
109 if log_mode {
110 info!("{}", String::from_utf8_lossy(data));
111 }
112 mutex.extend_from_slice(data);
113 }
114 });
115 }
116
117 let writer =
118 pair.master.take_writer().map_err(|e| CarchError::Pty(format!("take_writer: {e}")))?;
119
120 Ok(Self {
121 buffer: command_buffer,
122 command_thread: Some(command_handle),
123 child_killer: Some(rx),
124 pty_master: pair.master,
125 writer,
126 status: None,
127 parser: None,
128 parser_size: (0, 0),
129 pty_size: (0, 0),
130 processed_len: 0,
131 last_max_check: 0,
132 scroll_offset: 0,
133 actual_max: 0,
134 auto_scroll: true,
135 theme,
136 was_finished: false,
137 })
138 }
139
140 pub fn has_new_data(&mut self) -> bool {
141 let now_finished = self.is_finished();
142 if now_finished != self.was_finished {
143 return true;
144 }
145 if self.auto_scroll
146 && let Ok(buf) = self.buffer.try_lock()
147 && buf.len() > self.processed_len
148 {
149 return true;
150 }
151 false
152 }
153
154 pub fn acknowledge_data(&mut self) {
155 self.was_finished = self.is_finished();
156 }
157
158 pub fn handle_key_event(&mut self, key: KeyEvent) -> PopupEvent {
159 let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
160 let _shift = key.modifiers.contains(KeyModifiers::SHIFT);
161
162 match key.code {
163 KeyCode::Char('c') if ctrl => {
164 let _ = self.writer.write_all(&[3]);
165 PopupEvent::None
166 }
167 KeyCode::Char('q') | KeyCode::Enter | KeyCode::Esc if self.is_finished() => {
168 PopupEvent::Close
169 }
170 KeyCode::PageUp => {
171 self.scroll_up(PAGE_STEP);
172 PopupEvent::None
173 }
174 KeyCode::PageDown => {
175 self.scroll_down(PAGE_STEP);
176 PopupEvent::None
177 }
178 _ => {
179 self.handle_passthrough_key_event(key);
180 PopupEvent::None
181 }
182 }
183 }
184
185 fn scroll_up(&mut self, n: usize) {
186 if n == 0 {
187 return;
188 }
189 let max = self.max_scrollback();
190 let next = self.scroll_offset.saturating_add(n).min(max);
191 self.scroll_offset = next;
192 self.auto_scroll = next == 0;
193 }
194
195 fn scroll_down(&mut self, n: usize) {
196 if n == 0 {
197 return;
198 }
199 if self.scroll_offset > n {
200 self.scroll_offset -= n;
201 } else {
202 self.scroll_offset = 0;
203 }
204 self.auto_scroll = self.scroll_offset == 0;
205 }
206
207 fn max_scrollback(&self) -> usize {
208 self.actual_max
209 }
210
211 fn is_finished(&self) -> bool {
212 self.command_thread.as_ref().is_none_or(JoinHandle::is_finished)
213 }
214
215 fn sync_parser(&mut self, size: Size) {
216 let (cols, rows) = (size.width, size.height);
217
218 if self.pty_size != (cols, rows) {
219 let _ = self.pty_master.resize(PtySize { rows, cols, pixel_width: 0, pixel_height: 0 });
220 self.pty_size = (cols, rows);
221 }
222
223 let parser = self.parser.get_or_insert_with(|| Parser::new(rows, cols, SCROLLBACK_LEN));
224
225 if self.parser_size != (cols, rows) {
226 parser.screen_mut().set_size(rows, cols);
227 self.parser_size = (cols, rows);
228 }
229
230 let new_bytes: Vec<u8> = {
231 let buf = self.buffer.lock().unwrap_or_else(PoisonError::into_inner);
232 if self.processed_len <= buf.len() {
233 buf[self.processed_len..].to_vec()
234 } else {
235 self.processed_len = 0;
236 buf[..].to_vec()
237 }
238 };
239 let got_new = !new_bytes.is_empty();
240 if got_new {
241 parser.process(&new_bytes);
242 self.processed_len += new_bytes.len();
243 }
244
245 if got_new || self.last_max_check == 0 {
246 parser.screen_mut().set_scrollback(usize::MAX);
247 self.actual_max = parser.screen().scrollback();
248 self.last_max_check = self.processed_len;
249 }
250
251 if self.scroll_offset > self.actual_max {
252 self.scroll_offset = self.actual_max;
253 self.auto_scroll = self.actual_max == 0;
254 }
255
256 parser.screen_mut().set_scrollback(self.scroll_offset);
257 }
258
259 fn get_exit_status(&mut self) -> ExitStatus {
260 if self.command_thread.is_some() {
261 let handle = self.command_thread.take().unwrap();
262 let exit_status = handle.join().unwrap_or_else(|_| ExitStatus::with_exit_code(1));
263 self.status = Some(exit_status.clone());
264 exit_status
265 } else {
266 self.status.clone().unwrap_or_else(|| ExitStatus::with_exit_code(1))
267 }
268 }
269
270 pub fn kill_child(&mut self) {
271 if !self.is_finished()
272 && let Some(killer_rx) = self.child_killer.take()
273 && let Ok(Some(mut killer)) = killer_rx.recv()
274 {
275 let _ = killer.kill();
276 }
277 }
278
279 fn handle_passthrough_key_event(&mut self, key: KeyEvent) {
280 let input_bytes = match key.code {
281 KeyCode::Char(ch) => ch.to_string().into_bytes(),
282 KeyCode::Enter => vec![b'\r'],
283 KeyCode::Backspace => vec![0x7f],
284 KeyCode::Left => vec![27, 91, 68],
285 KeyCode::Right => vec![27, 91, 67],
286 KeyCode::Up => vec![27, 91, 65],
287 KeyCode::Down => vec![27, 91, 66],
288 KeyCode::Tab => vec![9],
289 KeyCode::Home => vec![27, 91, 72],
290 KeyCode::End => vec![27, 91, 70],
291 KeyCode::BackTab => vec![27, 91, 90],
292 KeyCode::Delete => vec![27, 91, 51, 126],
293 KeyCode::Insert => vec![27, 91, 50, 126],
294 KeyCode::Esc => vec![27],
295 _ => return,
296 };
297 let _ = self.writer.write_all(&input_bytes);
298 }
299}
300
301impl Drop for RunScriptPopup {
302 fn drop(&mut self) {
303 if !self.is_finished()
304 && let Some(rx) = self.child_killer.take()
305 && let Ok(Some(mut killer)) = rx.recv()
306 {
307 let _ = killer.kill();
308 }
309 }
310}
311
312impl Widget for &mut RunScriptPopup {
313 fn render(self, area: Rect, buf: &mut Buffer) {
314 let running = !self.is_finished();
315
316 let block = if running {
317 Block::bordered()
318 .border_set(border::ROUNDED)
319 .border_style(Style::default().fg(self.theme.primary))
320 .title_style(Style::default().fg(self.theme.primary).reversed())
321 } else {
322 let (title_text, style_color) = if self.get_exit_status().success() {
323 (
324 Line::styled(
325 "Success! Press <Enter> to close",
326 Style::default().fg(self.theme.success).reversed(),
327 ),
328 self.theme.success,
329 )
330 } else {
331 (
332 Line::styled(
333 "Failed! Press <Enter> to close",
334 Style::default().fg(self.theme.error).reversed(),
335 ),
336 self.theme.error,
337 )
338 };
339
340 Block::bordered()
341 .border_set(border::ROUNDED)
342 .border_style(Style::default().fg(style_color))
343 .title_top(title_text.centered())
344 };
345
346 let inner_area = block.inner(area);
347 self.sync_parser(inner_area.as_size());
348
349 Clear.render(area, buf);
350 block.render(area, buf);
351
352 if let Some(parser) = self.parser.as_ref() {
353 let pseudo_term = PseudoTerminal::new(parser.screen());
354 pseudo_term.render(inner_area, buf);
355 }
356 }
357}