mod app;
mod cli;
mod completions;
mod config;
mod errors;
mod logging;
mod manager;
mod shim;
mod theme;
mod tui;
mod version;
#[cfg(test)]
mod audit_trail;
use crate::{
app::{Action, App},
cli::Cli,
manager::GoManager,
};
use clap::Parser;
use crossterm::{
event::{self, Event, KeyCode, KeyModifiers},
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use std::{
env::consts::{ARCH, OS},
io,
sync::Arc,
sync::atomic::{AtomicBool, Ordering},
time::Duration,
};
use tokio::sync::mpsc;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let cli_args = Cli::parse();
logging::init();
install_panic_hook();
let mode = if cli_args.command.is_some() {
"cli"
} else {
"tui"
};
let args = if cli_args.command.is_some() {
let joined = std::env::args().skip(1).collect::<Vec<_>>().join(" ");
format!(" args=\"{joined}\"")
} else {
String::new()
};
logging::info(&format!(
"govmr {} started: mode={mode} os={OS} arch={ARCH}{args}",
config::current_govmr_version()
));
let manager = match GoManager::new() {
Ok(manager) => Arc::new(manager),
Err(e) => {
logging::error(&format!("startup failed: area=manager error=\"{e}\""));
log_session_end("startup", None);
return Err(e.into());
}
};
completions::ensure_completions();
if cli_args.command.is_some() {
let result = cli::handle_cli(cli_args, manager.clone()).await;
if let Err(e) = &result {
logging::error(&format!("cli: failed error=\"{e}\""));
}
log_session_end(
if result.is_ok() { "complete" } else { "error" },
Some(&manager),
);
return result;
}
enable_raw_mode()?;
let mut stdout = io::stdout();
execute!(stdout, EnterAlternateScreen)?;
let backend = CrosstermBackend::new(stdout);
let mut terminal = Terminal::new(backend)?;
let result = run_tui(&mut terminal, manager.clone()).await;
let _ = disable_raw_mode();
let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen);
let _ = terminal.show_cursor();
match &result {
Ok(reason) => log_session_end(reason.as_str(), Some(&manager)),
Err(e) => {
logging::error(&format!("tui run failed: error=\"{e}\""));
log_session_end("error", Some(&manager));
}
}
result.map(|_| ())
}
#[derive(Clone, Copy)]
enum QuitReason {
Quit,
Interrupt,
}
impl QuitReason {
fn as_str(self) -> &'static str {
match self {
QuitReason::Quit => "quit",
QuitReason::Interrupt => "interrupt",
}
}
}
async fn run_tui(
terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
manager: Arc<GoManager>,
) -> anyhow::Result<QuitReason> {
let shim_path = manager
.get_shim_manager()
.get_shim_dir()
.to_string_lossy()
.to_string();
let shim_in_path = manager.get_shim_manager().is_in_path();
let initial_theme = manager.theme();
let should_continue = tui::setup::run_setup_guide_if_needed(
terminal,
&shim_path,
shim_in_path,
&initial_theme,
&manager,
)?;
if !should_continue {
return Ok(QuitReason::Quit);
}
let mut app = App::new(manager.clone(), shim_path.clone());
let (action_tx, mut action_rx) = mpsc::unbounded_channel::<Action>();
let _ = action_tx.send(Action::Refresh);
let reason = loop {
terminal.draw(|f| {
tui::render(f, &mut app.state);
tui::render_overlays(f, &app.state);
})?;
app::handle_actions(&mut action_rx, &mut app, &manager, &action_tx).await?;
app.refresh_logs_if_open();
if event::poll(Duration::from_millis(100))?
&& let Event::Key(key) = event::read()?
&& let app::KeyOutcome::Quit = app::handle_key(key, &mut app, &action_tx)
{
let interrupted =
key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL);
break if interrupted {
QuitReason::Interrupt
} else {
QuitReason::Quit
};
}
};
Ok(reason)
}
fn log_session_end(reason: &str, manager: Option<&GoManager>) {
let (installed, active) = match manager {
Some(manager) => {
let versions = manager.installed_versions();
let installed = if versions.is_empty() {
"[]".to_string()
} else {
format!("[{}]", versions.join(", "))
};
(
installed,
manager
.get_active_version()
.unwrap_or_else(|| "none".to_string()),
)
}
None => ("unknown".to_string(), "unknown".to_string()),
};
logging::info(&format!(
"session ended: reason={reason} installed={installed} active={active}"
));
}
fn install_panic_hook() {
static PANIC_LOGGED: AtomicBool = AtomicBool::new(false);
let default_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
let _ = disable_raw_mode();
let _ = execute!(io::stdout(), LeaveAlternateScreen);
if !PANIC_LOGGED.swap(true, Ordering::SeqCst) {
logging::error(&format!("panic: {}", panic_report(info)));
log_session_end("panic", None);
}
default_hook(info);
}));
}
fn panic_report(info: &std::panic::PanicHookInfo<'_>) -> String {
let payload = info
.payload()
.downcast_ref::<&str>()
.map_or_else(
|| info.payload().downcast_ref::<String>().cloned(),
|s| Some((*s).to_string()),
)
.unwrap_or_else(|| "<non-string payload>".to_string());
let location = info.location().map_or_else(
|| "unknown".to_string(),
|loc| format!("{}:{}:{}", loc.file(), loc.line(), loc.column()),
);
format!("message=\"{payload}\" location=\"{location}\"")
}