use anyhow::Result; use clap::Parser; mod campaign; mod command; mod handlers; mod install; mod tui; mod util; use command::*; use handlers::*; use util::*; /// Die quietly when stdout is closed early, the way every other Unix tool does. /// /// Rust sets `SIGPIPE` to `SIG_IGN` at startup, which turns a closed pipe into an /// io error that `println!` panics on. So `worklane ls | head -3` printed a panic /// and a backtrace instead of three lines, which is both alarming and easy to /// mistake for a real fault. Restoring the default handler makes `| head` behave. /// /// The cost is that a truncated pipe now kills the process with signal 13 rather /// than returning a code, so `pipefail` sees 141 instead of 101. That is what /// `head` and `sort` do, and it is recorded in the README. fn quiet_broken_pipe() { // SAFETY: setting a signal disposition to the default is always valid, and // this runs before any thread is spawned. unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL); } } fn main() -> Result<()> { // Before any output, so no write can beat it to a closed pipe. quiet_broken_pipe(); let cli = Cli::parse(); let start = std::env::current_dir()?; match cli.command { // No subcommand opens the board, the way a bare `frig` does, and with no path // it opens the board above the working directory. None => run_tui(&[], &start), Some(Command::Tui { paths }) => run_tui(&paths, &start), Some(Command::Init) => cmd_init(&start), Some(Command::Add(args)) => cmd_add(&args, &start), Some(Command::Ls { status, priority, campaign, }) => { let worklane_dir = find_worklane_dir(&start)?; cmd_ls(&status, priority, &campaign, &worklane_dir) } Some(Command::Show { id }) => { let worklane_dir = find_worklane_dir(&start)?; cmd_show(&id, &worklane_dir) } Some(Command::Mv { ticket, status, force, }) => cmd_mv(&ticket, &status, force, &start), Some(Command::Set(args)) => cmd_set(&args, &start), Some(Command::Append(args)) => cmd_append(&args, &start), Some(Command::Relate(args)) => cmd_relate(&args, &start), Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start), Some(Command::Check(args)) => cmd_check(&args, true, &start), Some(Command::Uncheck(args)) => cmd_check(&args, false, &start), Some(Command::Comment { ticket, body, owner, }) => cmd_comment(&ticket, &body, &owner, &start), Some(Command::Campaign { command }) => match command { CampaignCommand::Add(args) => cmd_campaign_add(&args, &start), CampaignCommand::Ls => { let worklane_dir = find_worklane_dir(&start)?; cmd_campaign_ls(&worklane_dir) } CampaignCommand::Show { campaign } => { let worklane_dir = find_worklane_dir(&start)?; cmd_campaign_show(&campaign, &worklane_dir) } }, Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start), // No board is looked for: the point of the skill is to teach an agent worklane // before there is a `.worklane` anywhere. Some(Command::InstallSkill { skill, force, print }) => { cmd_install_skill(skill.as_deref(), force, print) } } } // ---------------------------------------------------------------------- tui -- /// Restore the terminal whatever happens. /// /// A panic inside the draw loop with raw mode still on leaves the shell unusable and /// the backtrace unreadable, so the hook runs before the default one. fn install_panic_hook() { let previous = std::panic::take_hook(); std::panic::set_hook(Box::new(move |info| { let _ = restore_terminal(); previous(info); })); } fn restore_terminal() -> std::io::Result<()> { crossterm::terminal::disable_raw_mode()?; crossterm::execute!( std::io::stdout(), crossterm::terminal::LeaveAlternateScreen ) } fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()> { use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers}; use std::io::IsTerminal; // The boards are looked for before the terminal is, so running this outside a // worklane directory gives the same message every other command gives rather than // a complaint about the terminal. let projects = tui::projects(paths, start)?; // Without this, entering raw mode on a pipe fails with a bare "No such device or // address (os error 6)", which says nothing about the actual mistake. A bare // `worklane` is how the board is opened, so a script that reaches it by accident // has to be pointed at a subcommand. if !std::io::stdin().is_terminal() { return Err(anyhow::anyhow!( "`worklane` with no subcommand opens the board, which needs a terminal.\n\ For scripted use try `worklane ls` or `worklane show`; `worklane --help` \ lists everything." )); } let mut board = tui::Board::new(projects)?; install_panic_hook(); crossterm::terminal::enable_raw_mode()?; crossterm::execute!(std::io::stdout(), crossterm::terminal::EnterAlternateScreen)?; let mut terminal = ratatui::Terminal::new(ratatui::backend::CrosstermBackend::new(std::io::stdout()))?; let result = (|| -> Result<()> { while !board.should_quit { board.tick()?; terminal.draw(|frame| tui::draw(frame, &board))?; // Taken after the draw, so a scroll measures the overlay that is on screen. let screen = terminal.size()?; // Bounded, so the tick still runs when nobody is typing. if !event::poll(tui::POLL)? { continue; } let Event::Key(key) = event::read()? else { continue; }; if key.kind != KeyEventKind::Press { continue; } match key.code { KeyCode::Char('q') => board.should_quit = true, KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => { board.should_quit = true } // Esc closes the detail view, and only quits when there is nothing // left to dismiss. KeyCode::Esc => match board.detail { Some(_) => board.toggle_detail(), None => board.should_quit = true, }, KeyCode::Enter | KeyCode::Char(' ') => board.toggle_detail(), KeyCode::Left | KeyCode::Char('h') => board.select_column(-1, screen), KeyCode::Right | KeyCode::Char('l') => board.select_column(1, screen), // Up and down stay on the selection, open detail view or not, so a // column can be read through without closing the modal. Scrolling the // open ticket is a page at a time. KeyCode::Up | KeyCode::Char('k') => board.select_card(-1, screen), KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen), KeyCode::PageUp => board.scroll_detail(-1, screen), KeyCode::PageDown => board.scroll_detail(1, screen), // Tabs cycle rather than clamp, the way tabs everywhere do, and are // a no-op with a single board. Free of every other binding: the // columns took hjkl and the arrows. KeyCode::Tab => board.select_tab(1, screen), KeyCode::BackTab => board.select_tab(-1, screen), // Free of the other bindings, and the footer names it in both states. KeyCode::Char('d') => board.toggle_done(screen), _ => {} } } Ok(()) })(); // Before the error surfaces, so a failure does not leave the shell in raw mode. restore_terminal()?; result }