Add pass plugin

Author: fxdave

Cargo.toml

@@ -12,9 +12,10 @@ name = "vonalc"
 path = "src/vonal_client/main.rs"
 
 [features]
-default = ["launcher_plugin", "math_plugin"]
+default = ["launcher_plugin", "math_plugin", "pass_plugin"]
 launcher_plugin = ["freedesktop-desktop-entry", "regex"]
 math_plugin = []
+pass_plugin = []
 
 [dependencies]
 egui = "0.20.1"

src/vonal_daemon/plugins/mod.rs

@@ -9,6 +9,8 @@ use crate::{
 mod launcher;
 #[cfg(feature = "math_plugin")]
 mod math;
+#[cfg(feature = "pass_plugin")]
+mod pass;
 
 pub enum PluginFlowControl {
     /// check other plugins as well
@@ -79,6 +81,8 @@ impl PluginManager {
                 "math_plugin".to_string(),
                 #[cfg(feature = "launcher_plugin")]
                 "launcher_plugin".to_string(),
+                #[cfg(feature = "pass_plugin")]
+                "pass_plugin".to_string(),
             ],
         )?;
 
@@ -89,6 +93,8 @@ impl PluginManager {
                 match plugin.as_str() {
                     #[cfg(feature = "math_plugin")]
                     "math_plugin" => self.plugins.push(Box::new(math::Math::new())),
+                    #[cfg(feature = "pass_plugin")]
+                    "pass_plugin" => self.plugins.push(Box::new(pass::Pass::new())),
                     #[cfg(feature = "launcher_plugin")]
                     "launcher_plugin" => self.plugins.push(Box::new(launcher::Launcher::new())),
                     plugin_name => return Err(ConfigError::BadEntryError {

src/vonal_daemon/plugins/pass/mod.rs

@@ -0,0 +1,185 @@
+use std::{
+    error::Error,
+    fmt::Display,
+    io::{BufRead, BufReader},
+    process::{Command, Stdio},
+};
+
+use crate::{
+    config::{ConfigBuilder, ConfigError},
+    theme::list::{CreateList, ListState},
+};
+
+use super::{Plugin, PluginFlowControl};
+
+#[derive(Default)]
+pub struct Pass {
+    list_state: ListState,
+    config_command_list_passwords: String,
+    config_command_copy_password: String,
+    config_command_type_password: String,
+    config_prefix: String,
+}
+
+impl Pass {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    fn list_passwords(&self) -> Result<Vec<String>, Box<dyn Error>> {
+        let call = Command::new("bash")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .arg("-c")
+            .arg(&self.config_command_list_passwords)
+            .spawn()?
+            .wait_with_output()?;
+
+        let stderr = String::from_utf8_lossy(&call.stderr);
+        if !stderr.is_empty() {
+            return Err(Box::new(PassError(stderr.to_string())));
+        }
+
+        let stdout = String::from_utf8_lossy(&call.stdout);
+        let passwords = stdout.lines().map(ToString::to_string).collect();
+        Ok(passwords)
+    }
+
+    fn copy_password(&self, pw: &str) -> Result<(), std::io::Error> {
+        let stdout = Command::new("sh")
+            .stdout(Stdio::piped())
+            .arg("-c")
+            .arg(self.config_command_copy_password.replace("{name}", &pw))
+            .spawn()?
+            .stdout;
+        if let Some(stdout) = stdout {
+            let reader = BufReader::new(stdout);
+            if let Some(result) = reader.lines().next() {
+                Command::new("notify-send").arg(result?).spawn()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn type_password(&self, pw: &str) -> Result<(), std::io::Error> {
+        Command::new("bash")
+            .stdout(Stdio::piped())
+            .arg("-c")
+            .arg(self.config_command_type_password.replace("{name}", &pw))
+            .spawn()?;
+        Ok(())
+    }
+
+    fn render_copy_button(
+        &mut self,
+        ui: &mut crate::theme::list::RowUi,
+        gl_window: &crate::windowing::GlutinWindowContext,
+        pw: &String,
+        query: &mut String,
+    ) {
+        if ui.secondary_action("Copy").activated {
+            gl_window.window.set_visible(false);
+            if let Err(e) = self.copy_password(pw) {
+                gl_window.window.set_visible(true);
+                ui.label(&e.to_string())
+            } else {
+                *query = "".into();
+            }
+        }
+    }
+
+    fn render_type_button(
+        &mut self,
+        mut ui: crate::theme::list::RowUi,
+        gl_window: &crate::windowing::GlutinWindowContext,
+        pw: String,
+        query: &mut String,
+    ) {
+        if ui.secondary_action("Type").activated {
+            gl_window.window.set_visible(false);
+            if let Err(e) = self.type_password(&pw) {
+                gl_window.window.set_visible(true);
+                ui.label(&e.to_string())
+            } else {
+                *query = "".into();
+            }
+        }
+    }
+}
+
+const DEFAULT_PREFIX: &str = "pass_plugin";
+const DEFAULT_LIST_PASSWORDS_COMMAND: &str = r#"
+shopt -s nullglob globstar
+prefix=${PASSWORD_STORE_DIR-~/.password-store}
+password_files=( "$prefix"/**/*.gpg )
+password_files=( "${password_files[@]#"$prefix"/}" )
+password_files=( "${password_files[@]%.gpg}" )
+printf '%s\n' "${password_files[@]}"
+"#;
+const DEFAULT_COPY_PASSWORD_COMMAND: &str = r#"pass show -c {name}"#;
+const DEFAULT_TYPE_PASSWORD_COMMAND: &str =
+    r#"pass show {name} | { IFS= read -r pass; printf %s "$pass"; } | xdotool"#;
+
+impl Plugin for Pass {
+    fn search(
+        &mut self,
+        query: &mut String,
+        ui: &mut egui::Ui,
+        gl_window: &crate::windowing::GlutinWindowContext,
+    ) -> PluginFlowControl {
+        if !query.starts_with("pass_plugin") {
+            return PluginFlowControl::Continue;
+        }
+        match self.list_passwords() {
+            Ok(passwords) => {
+                const NUMBER_OF_BUTTONS: usize = 2;
+                self.list_state.update(ui.ctx(), passwords.len(), |_| NUMBER_OF_BUTTONS);
+                ui.list(self.list_state, |mut ui| {
+                    for pw in passwords {
+                        ui.row(|mut ui| {
+                            ui.label(&pw);
+                            self.render_copy_button(&mut ui, gl_window, &pw, query);
+                            self.render_type_button(ui, gl_window, pw, query);
+                        })
+                    }
+                });
+            }
+            Err(err) => {
+                ui.label(err.to_string());
+            }
+        }
+        PluginFlowControl::Break
+    }
+
+    fn configure(&mut self, mut builder: ConfigBuilder) -> Result<ConfigBuilder, ConfigError> {
+        builder.group("pass_plugin", |builder| {
+            self.config_prefix = builder.get_or_create("prefix", DEFAULT_PREFIX.into())?;
+            self.config_command_list_passwords = builder.get_or_create(
+                "command_list_password",
+                DEFAULT_LIST_PASSWORDS_COMMAND.trim_start().into(),
+            )?;
+            self.config_command_copy_password = builder.get_or_create(
+                "command_copy_password",
+                DEFAULT_COPY_PASSWORD_COMMAND.into(),
+            )?;
+            self.config_command_type_password = builder.get_or_create(
+                "command_type_password",
+                DEFAULT_TYPE_PASSWORD_COMMAND.into(),
+            )?;
+            Ok(())
+        })?;
+
+        Ok(builder)
+    }
+}
+
+#[derive(Debug)]
+struct PassError(String);
+
+impl Display for PassError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+impl Error for PassError {}