pub mod app;
pub mod clip;
pub mod command;
pub mod data;
pub mod model;
pub mod view;
use app::{update, App, Effect, Event, Key};
use crossterm::event::{self as ct, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use ratatui::DefaultTerminal;
use std::sync::mpsc::{Receiver, Sender};
use std::time::Duration;
const TICK: Duration = Duration::from_millis(25);
pub fn should_open(args_len: usize, stdout_tty: bool, plain: bool, term: Option<&str>) -> bool {
args_len == 1 && stdout_tty && !plain && term != Some("dumb")
}
pub fn map_key(k: KeyEvent) -> Option<Key> {
Some(match k.code {
KeyCode::Char('c') if k.modifiers.contains(KeyModifiers::CONTROL) => Key::CtrlC,
KeyCode::Char(c) => Key::Char(c),
KeyCode::Enter => Key::Enter,
KeyCode::Esc => Key::Esc,
KeyCode::Tab => Key::Tab,
KeyCode::BackTab => Key::BackTab,
KeyCode::Up => Key::Up,
KeyCode::Down => Key::Down,
KeyCode::PageUp => Key::PageUp,
KeyCode::PageDown => Key::PageDown,
KeyCode::Home => Key::Home,
KeyCode::End => Key::End,
KeyCode::Left => Key::Left,
KeyCode::Right => Key::Right,
KeyCode::Backspace => Key::Backspace,
_ => return None,
})
}
pub fn run() -> i32 {
let (tx, rx) = std::sync::mpsc::channel::<Event>();
let dir = data::agent_dir();
let pollers = data::spawn_pollers(tx.clone(), dir.clone());
let mut app = App::new();
let mut terminal = ratatui::init();
let code = event_loop(&mut terminal, &mut app, &rx, &tx, &pollers, dir);
ratatui::restore();
if let Some(line) = app::exit_summary(&app) {
println!("{line}");
}
code
}
fn event_loop(
terminal: &mut DefaultTerminal,
app: &mut App,
rx: &Receiver<Event>,
tx: &Sender<Event>,
pollers: &data::Pollers,
dir: Option<std::path::PathBuf>,
) -> i32 {
loop {
if terminal.draw(|f| view::draw(f, app)).is_err() {
return 1;
}
while let Ok(ev) = rx.try_recv() {
let effects = update(app, ev);
run_effects(effects, terminal, tx, pollers, &dir);
}
if app.quit {
return 0;
}
let ev = match ct::poll(TICK) {
Ok(true) => match ct::read() {
Ok(ct::Event::Key(k)) if k.kind == KeyEventKind::Press => {
map_key(k).map(Event::Key)
}
Ok(_) => None,
Err(_) => return 1,
},
Ok(false) => Some(Event::Tick),
Err(_) => return 1,
};
if let Some(ev) = ev {
let effects = update(app, ev);
run_effects(effects, terminal, tx, pollers, &dir);
}
if app.quit {
return 0;
}
}
}
fn run_effects(
effects: Vec<Effect>,
terminal: &mut DefaultTerminal,
tx: &Sender<Event>,
pollers: &data::Pollers,
dir: &Option<std::path::PathBuf>,
) {
for e in effects {
match e {
Effect::Copy(text) => {
let via = clip::copy(&text);
let _ = tx.send(Event::Note(format!("copied {text} to the {via}")));
}
Effect::OpenUrl(url) => {
let opener = if cfg!(target_os = "macos") {
"open"
} else {
"xdg-open"
};
let ok = std::process::Command::new(opener)
.arg(&url)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.spawn()
.is_ok();
let note = if ok {
format!("opened {url}")
} else {
format!("could not open {url}")
};
let _ = tx.send(Event::Note(note));
}
Effect::Suspend(args) => {
suspend(terminal, &args);
pollers.refresh_mesh();
data::execute(Effect::RefreshAgent, tx, pollers, dir.clone());
}
other => data::execute(other, tx, pollers, dir.clone()),
}
}
}
fn run_ignoring_sigint(
mut cmd: std::process::Command,
) -> std::io::Result<std::process::ExitStatus> {
let mut child = cmd.spawn()?;
let previous = unsafe { libc::signal(libc::SIGINT, libc::SIG_IGN) };
let status = child.wait();
unsafe { libc::signal(libc::SIGINT, previous) };
status
}
fn wait_for_key(mut read: impl FnMut() -> std::io::Result<ct::Event>) {
loop {
match read() {
Ok(ct::Event::Key(k)) if k.kind == KeyEventKind::Press => return,
Ok(_) => {}
Err(_) => return,
}
}
}
fn suspend(terminal: &mut DefaultTerminal, args: &[String]) {
ratatui::restore();
println!("\n$ zc {}", args.join(" "));
let status = std::env::current_exe()
.map_err(|e| e.to_string())
.and_then(|exe| {
let mut cmd = std::process::Command::new(exe);
cmd.args(args);
run_ignoring_sigint(cmd).map_err(|e| e.to_string())
});
match status {
Ok(s) if s.success() => println!("\n✓ done — press any key to return to zc"),
Ok(s) => println!(
"\n✗ exited {} — press any key to return to zc",
s.code().unwrap_or(1)
),
Err(e) => println!("\n✗ {e} — press any key to return to zc"),
}
let _ = crossterm::terminal::enable_raw_mode();
wait_for_key(ct::read);
let _ = crossterm::terminal::disable_raw_mode();
*terminal = ratatui::init();
let _ = terminal.clear();
}
#[cfg(test)]
mod tests {
use super::*;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
#[test]
fn opens_only_for_bare_zc_on_a_real_terminal() {
assert!(should_open(1, true, false, Some("xterm-256color")));
assert!(should_open(1, true, false, None));
assert!(
!should_open(2, true, false, None),
"any argument: a one-shot command"
);
assert!(!should_open(1, false, false, None), "piped: help");
assert!(!should_open(1, true, true, None), "ZC_PLAIN");
assert!(!should_open(1, true, false, Some("dumb")));
}
#[test]
fn a_child_interrupting_its_parent_does_not_kill_the_session() {
let mut cmd = std::process::Command::new("sh");
cmd.args(["-c", "kill -INT $PPID; sleep 0.2; exit 3"]);
let status = run_ignoring_sigint(cmd).unwrap();
assert_eq!(status.code(), Some(3));
}
#[test]
fn waiting_for_a_key_stops_on_a_read_error() {
let mut calls = 0;
wait_for_key(|| {
calls += 1;
Err(std::io::Error::other("tty gone"))
});
assert_eq!(calls, 1);
}
#[test]
fn keys_map_including_ctrl_c_and_backtab() {
let k = |c, m| map_key(KeyEvent::new(c, m));
assert_eq!(
k(KeyCode::Char('c'), KeyModifiers::CONTROL),
Some(app::Key::CtrlC)
);
assert_eq!(
k(KeyCode::Char('c'), KeyModifiers::NONE),
Some(app::Key::Char('c'))
);
assert_eq!(
k(KeyCode::BackTab, KeyModifiers::SHIFT),
Some(app::Key::BackTab)
);
assert_eq!(k(KeyCode::F(5), KeyModifiers::NONE), None);
}
}