mod question;
use std::sync::Arc;
use async_trait::async_trait;
use haest::{
mods::{ApprovalAnswer, ApprovalRequest, Prompter},
runtime::Ui,
session::SessionPrompter,
};
use self::question::question;
use crate::{
ask::{self, NoTerminal},
term::TermUi,
};
pub(crate) struct TermPrompter {
ui: Arc<TermUi>,
interactive: Result<(), NoTerminal>,
}
impl TermPrompter {
pub(crate) fn new(ui: Arc<TermUi>, interactive: Result<(), NoTerminal>) -> Self {
Self { ui, interactive }
}
}
fn answer(line: Option<&str>) -> ApprovalAnswer {
match line.map(|l| l.trim().to_ascii_lowercase()).as_deref() {
Some("y" | "yes") => ApprovalAnswer::Allow,
Some("a" | "always") => ApprovalAnswer::AllowAlways,
_ => ApprovalAnswer::Deny,
}
}
#[async_trait]
impl Prompter for TermPrompter {
async fn prompt(&self, req: &ApprovalRequest) -> ApprovalAnswer {
if let Err(why) = self.interactive {
self.ui.refused(&format!(
"Denied {}: {} -- approval needed and {why} (--approvals=false turns approvals off).",
req.tool_name, req.description
));
return ApprovalAnswer::Deny;
}
let _terminal = match self.ui.stdin.try_lock() {
Ok(free) => free,
Err(_) => {
let when = if self.ui.prompting() {
"press Enter at the prompt to answer it"
} else {
"it is asked after the question before it"
};
self.ui.info(&format!(
"{} waits for your approval: {} -- {when}.",
req.tool_name, req.description
));
self.ui.stdin.lock().await
}
};
let mut answering = self.ui.ask(&question(req));
if !answering.drawn().await {
return ApprovalAnswer::Deny;
}
let line = ask::read_answer().await;
answering.answered(line.as_deref());
answer(line.as_deref())
}
fn auto_approved(&self, req: &ApprovalRequest) {
self.ui.info(&format!(
"Allowed {} (always): {}",
req.tool_name, req.description
));
}
}
pub(crate) enum CliPrompter {
Term(TermPrompter),
Session(SessionPrompter),
}
#[async_trait]
#[warn(clippy::missing_trait_methods)]
impl Prompter for CliPrompter {
async fn prompt(&self, req: &ApprovalRequest) -> ApprovalAnswer {
match self {
Self::Term(p) => p.prompt(req).await,
Self::Session(p) => p.prompt(req).await,
}
}
fn auto_approved(&self, req: &ApprovalRequest) {
match self {
Self::Term(p) => p.auto_approved(req),
Self::Session(p) => p.auto_approved(req),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_yes_or_always_allow_and_silence_is_no() {
assert_eq!(answer(Some("y\n")), ApprovalAnswer::Allow);
assert_eq!(answer(Some(" YES ")), ApprovalAnswer::Allow);
assert_eq!(answer(Some("a\n")), ApprovalAnswer::AllowAlways);
assert_eq!(answer(Some("\n")), ApprovalAnswer::Deny);
assert_eq!(answer(Some("sure")), ApprovalAnswer::Deny);
assert_eq!(answer(None), ApprovalAnswer::Deny);
}
}