feat: add notification support to --ask flags

Change-Id: I6a6a69642ac3443525df583fd200827414801d41

Author: r0chd

src/clean.rs

@@ -19,7 +19,8 @@ use tracing::{Level, debug, info, instrument, span, warn};
 use crate::{
   Result,
   commands::{Command, ElevationStrategy},
-  interface,
+  interface::{self, NotifyAskMode},
+  notify::NotificationSender,
 };
 
 // Nix impl:
@@ -306,12 +307,32 @@ impl interface::CleanMode {
     }
 
     // Clean the paths
-    if args.ask
-      && !Confirm::new("Confirm the cleanup plan?")
-        .with_default(false)
-        .prompt()?
-    {
-      bail!("User rejected the cleanup plan");
+    if let Some(ask) = args.ask.as_ref() {
+      let confirmation = match ask {
+        NotifyAskMode::Prompt => {
+          Confirm::new("Confirm the cleanup plan?")
+            .with_default(false)
+            .prompt()?
+        },
+        NotifyAskMode::Notify => {
+          let clean_mode = match self {
+            Self::Profile(_) => "profile",
+            Self::All(_) => "all",
+            Self::User(_) => "user",
+          };
+
+          NotificationSender::new(
+            &format!("nh clean {clean_mode}"),
+            "Confirm the cleanup plan?",
+          )
+          .ask()
+        },
+        NotifyAskMode::Both => unimplemented!(),
+      };
+
+      if !confirmation {
+        bail!("User rejected the cleanup plan");
+      }
     }
 
     if !args.dry {

src/commands.rs

@@ -15,23 +15,24 @@ use thiserror::Error;
 use tracing::{debug, info, warn};
 use which::which;
 
-use crate::{
-  installable::Installable,
-  interface::NixBuildPassthroughArgs,
-};
+use crate::{installable::Installable, interface::NixBuildPassthroughArgs};
 
 static PASSWORD_CACHE: OnceLock<Mutex<HashMap<String, SecretString>>> =
   OnceLock::new();
 
 fn get_cached_password(host: &str) -> Option<SecretString> {
   let cache = PASSWORD_CACHE.get_or_init(|| Mutex::new(HashMap::new()));
-  let guard = cache.lock().unwrap_or_else(|e| e.into_inner());
+  let guard = cache
+    .lock()
+    .unwrap_or_else(std::sync::PoisonError::into_inner);
   guard.get(host).cloned()
 }
 
 fn cache_password(host: &str, password: SecretString) {
   let cache = PASSWORD_CACHE.get_or_init(|| Mutex::new(HashMap::new()));
-  let mut guard = cache.lock().unwrap_or_else(|e| e.into_inner());
+  let mut guard = cache
+    .lock()
+    .unwrap_or_else(std::sync::PoisonError::into_inner);
   guard.insert(host.to_string(), password);
 }
 
@@ -452,7 +453,7 @@ impl Command {
         Some(cached_password)
       } else {
         let password =
-          inquire::Password::new(&format!("[sudo] password for {}:", host))
+          inquire::Password::new(&format!("[sudo] password for {host}:"))
             .without_confirmation()
             .prompt()
             .context("Failed to read sudo password")?;
@@ -495,11 +496,11 @@ impl Command {
       for (key, action) in &self.env_vars {
         match action {
           EnvAction::Set(value) => {
-            elev_cmd = elev_cmd.arg(format!("{}={}", key, value));
+            elev_cmd = elev_cmd.arg(format!("{key}={value}"));
           },
           EnvAction::Preserve => {
             if let Ok(value) = std::env::var(key) {
-              elev_cmd = elev_cmd.arg(format!("{}={}", key, value));
+              elev_cmd = elev_cmd.arg(format!("{key}={value}"));
             }
           },
           _ => {},

src/darwin.rs

@@ -1,21 +1,22 @@
-use std::{env, path::PathBuf};
+use std::{env, fmt, path::PathBuf};
 
 use color_eyre::eyre::{Context, bail, eyre};
 use tracing::{debug, warn};
 
 use crate::{
   Result,
-  commands,
-  commands::{Command, ElevationStrategy},
+  commands::{self, Command, ElevationStrategy},
   installable::Installable,
   interface::{
     DarwinArgs,
     DarwinRebuildArgs,
     DarwinReplArgs,
     DarwinSubcommand,
     DiffType,
+    NotifyAskMode,
   },
   nixos::toplevel_for,
+  notify::NotificationSender,
   update::update,
   util::{get_hostname, print_dix_diff},
 };
@@ -34,7 +35,7 @@ impl DarwinArgs {
     match self.subcommand {
       DarwinSubcommand::Switch(args) => args.rebuild(&Switch, elevation),
       DarwinSubcommand::Build(args) => {
-        if args.common.ask || args.common.dry {
+        if args.common.ask.is_some() || args.common.dry {
           warn!("`--ask` and `--dry` have no effect for `nh darwin build`");
         }
         args.rebuild(&Build, elevation)
@@ -49,6 +50,16 @@ enum DarwinRebuildVariant {
   Build,
 }
 
+impl fmt::Display for DarwinRebuildVariant {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    let s = match self {
+      DarwinRebuildVariant::Build => "build",
+      DarwinRebuildVariant::Switch => "switch",
+    };
+    write!(f, "{s}")
+  }
+}
+
 impl DarwinRebuildArgs {
   fn rebuild(
     self,
@@ -144,13 +155,29 @@ impl DarwinRebuildArgs {
       let _ = print_dix_diff(&PathBuf::from(CURRENT_PROFILE), &target_profile);
     }
 
-    if self.common.ask && !self.common.dry && !matches!(variant, Build) {
-      let confirmation = inquire::Confirm::new("Apply the config?")
-        .with_default(false)
-        .prompt()?;
+    if !self.common.dry && !matches!(variant, Build) {
+      if let Some(ask) = self.common.ask {
+        let confirmation = match ask {
+          NotifyAskMode::Prompt => {
+            inquire::Confirm::new("Apply the config?")
+              .with_default(false)
+              .prompt()?
+          },
+          // MacOS doesn't support notification actions
+          NotifyAskMode::Notify | NotifyAskMode::Both => {
+            NotificationSender::new(&format!("nh darwin {variant}"), "testing")
+              .send()
+              .unwrap();
+
+            inquire::Confirm::new("Apply the config?")
+              .with_default(false)
+              .prompt()?
+          },
+        };
 
-      if !confirmation {
-        bail!("User rejected the new config");
+        if !confirmation {
+          bail!("User rejected the new config");
+        }
       }
     }
 

src/generations.rs

@@ -339,11 +339,11 @@ pub fn print_info(
     .iter()
     .map(|f| {
       let (name, width) = f.column_info(widths);
-      format!("{:<width$}", name)
+      format!("{name:<width$}")
     })
     .collect::<Vec<String>>()
     .join(" ");
-  println!("{}", header);
+  println!("{header}");
 
   // Print generations in descending order
   for generation in generations.iter().rev() {
@@ -382,11 +382,11 @@ pub fn print_info(
           Field::Spec => specialisations.clone(),
           Field::Size => generation.closure_size.clone(),
         };
-        format!("{:width$}", cell_content)
+        format!("{cell_content:width$}")
       })
       .collect::<Vec<String>>()
       .join(" ");
-    println!("{}", row);
+    println!("{row}");
   }
 
   Ok(())

src/home.rs

@@ -1,4 +1,4 @@
-use std::{env, ffi::OsString, path::PathBuf};
+use std::{env, ffi::OsString, fmt, path::PathBuf};
 
 use color_eyre::{
   Result,
@@ -7,10 +7,17 @@ use color_eyre::{
 use tracing::{debug, info, warn};
 
 use crate::{
-  commands,
-  commands::Command,
+  commands::{self, Command},
   installable::Installable,
-  interface::{self, DiffType, HomeRebuildArgs, HomeReplArgs, HomeSubcommand},
+  interface::{
+    self,
+    DiffType,
+    HomeRebuildArgs,
+    HomeReplArgs,
+    HomeSubcommand,
+    NotifyAskMode,
+  },
+  notify::NotificationSender,
   update::update,
   util::{get_hostname, print_dix_diff},
 };
@@ -26,7 +33,7 @@ impl interface::HomeArgs {
     match self.subcommand {
       HomeSubcommand::Switch(args) => args.rebuild(&Switch),
       HomeSubcommand::Build(args) => {
-        if args.common.ask || args.common.dry {
+        if args.common.ask.is_some() || args.common.dry {
           warn!("`--ask` and `--dry` have no effect for `nh home build`");
         }
         args.rebuild(&Build)
@@ -42,6 +49,16 @@ enum HomeRebuildVariant {
   Switch,
 }
 
+impl fmt::Display for HomeRebuildVariant {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    let s = match self {
+      HomeRebuildVariant::Build => "build",
+      HomeRebuildVariant::Switch => "switch",
+    };
+    write!(f, "{s}")
+  }
+}
+
 impl HomeRebuildArgs {
   fn rebuild(self, variant: &HomeRebuildVariant) -> Result<()> {
     use HomeRebuildVariant::Build;
@@ -150,16 +167,24 @@ impl HomeRebuildArgs {
     }
 
     if self.common.dry || matches!(variant, Build) {
-      if self.common.ask {
+      if self.common.ask.is_some() {
         warn!("--ask has no effect as dry run was requested");
       }
       return Ok(());
     }
 
-    if self.common.ask {
-      let confirmation = inquire::Confirm::new("Apply the config?")
-        .with_default(false)
-        .prompt()?;
+    if let Some(ask) = self.common.ask {
+      let confirmation = match ask {
+        NotifyAskMode::Prompt => {
+          inquire::Confirm::new("Apply the config?")
+            .with_default(false)
+            .prompt()?
+        },
+        NotifyAskMode::Notify => {
+          NotificationSender::new("nh os rollback", "testing").ask()
+        },
+        NotifyAskMode::Both => unimplemented!(),
+      };
 
       if !confirmation {
         bail!("User rejected the new config");

src/interface.rs

@@ -256,15 +256,25 @@ pub enum DiffType {
   Never,
 }
 
+#[derive(Debug, Clone, ValueEnum, PartialEq)]
+pub enum NotifyAskMode {
+  /// Ask in the terminal (stdin prompt)
+  Prompt,
+  /// Ask via a desktop notification action
+  Notify,
+  /// Show both notification and terminal prompt (fallback-safe)
+  Both,
+}
+
 #[derive(Debug, Args)]
 pub struct OsRollbackArgs {
   /// Only print actions, without performing them
   #[arg(long, short = 'n')]
   pub dry: bool,
 
   /// Ask for confirmation
-  #[arg(long, short)]
-  pub ask: bool,
+  #[arg(long, short, value_enum, default_missing_value = "prompt", num_args = 0..=1)]
+  pub ask: Option<NotifyAskMode>,
 
   /// Explicitly select some specialisation
   #[arg(long, short)]
@@ -295,8 +305,8 @@ pub struct CommonRebuildArgs {
   pub dry: bool,
 
   /// Ask for confirmation
-  #[arg(long, short)]
-  pub ask: bool,
+  #[arg(long, short, default_missing_value = "prompt", num_args = 0..=1)]
+  pub ask: Option<NotifyAskMode>,
 
   #[command(flatten)]
   pub installable: Installable,
@@ -427,8 +437,8 @@ pub struct CleanArgs {
   pub dry: bool,
 
   /// Ask for confirmation
-  #[arg(long, short)]
-  pub ask: bool,
+  #[arg(long, short, default_missing_value = "prompt", num_args = 0..=1)]
+  pub ask: Option<NotifyAskMode>,
 
   /// Don't run nix store --gc
   #[arg(long = "no-gc", alias = "nogc")]

src/logging.rs

@@ -93,7 +93,7 @@ pub fn setup_logging(
 macro_rules! nh_trace {
     ($($arg:tt)*) => {
         use notify_rust::Urgency;
-        use crate::notify::NotificationSender;
+        use $crate::notify::NotificationSender;
         let message = format!($($arg)*);
         tracing::trace!($($arg)*);
         NotificationSender::new("nh trace", &message).urgency(Urgency::Low).send().unwrap();
@@ -104,7 +104,7 @@ macro_rules! nh_trace {
 macro_rules! nh_debug {
     ($($arg:tt)*) => {
         use notify_rust::Urgency;
-        use crate::notify::NotificationSender;
+        use $crate::notify::NotificationSender;
 
         let message = format!($($arg)*);
         tracing::debug!($($arg)*);
@@ -116,7 +116,7 @@ macro_rules! nh_debug {
 macro_rules! nh_info {
     ($($arg:tt)*) => {
         use notify_rust::Urgency;
-        use crate::notify::NotificationSender;
+        use $crate::notify::NotificationSender;
         let message = format!($($arg)*);
         tracing::info!($($arg)*);
         NotificationSender::new("nh info", &message).urgency(Urgency::Normal).send().unwrap();
@@ -127,10 +127,9 @@ macro_rules! nh_info {
 macro_rules! nh_warn {
     ($($arg:tt)*) => {
         use notify_rust::Urgency;
-        use crate::notify::NotificationSender;
+        use $crate::notify::NotificationSender;
         let message = format!($($arg)*);
         tracing::warn!($($arg)*);
         NotificationSender::new("nh warn", &message).urgency(Urgency::Normal).send().unwrap();
     };
 }
-