feat: added REPL support for interacting with the Loki vault

src/vault/mod.rs

@@ -0,0 +1,125 @@
+mod utils;
+
+use crate::cli::Cli;
+use crate::config::Config;
+use crate::vault::utils::ensure_password_file_initialized;
+use anyhow::{Context, Result};
+use gman::providers::local::LocalProvider;
+use gman::providers::SecretProvider;
+use inquire::{required, Password, PasswordDisplayMode};
+use tokio::runtime::Handle;
+
+#[derive(Debug, Default, Clone)]
+pub struct Vault {
+    local_provider: LocalProvider,
+}
+
+impl Vault {
+    pub fn init(config: &Config) -> Self {
+        let vault_password_file = config.vault_password_file();
+        let mut local_provider = LocalProvider {
+            password_file: Some(vault_password_file),
+            git_branch: None,
+            ..LocalProvider::default()
+        };
+
+        ensure_password_file_initialized(&mut local_provider)
+            .expect("Failed to initialize password file");
+
+        Self { local_provider }
+    }
+
+    pub fn add_secret(&self, secret_name: &str) -> Result<()> {
+        let secret_value = Password::new("Enter the secret value:")
+            .with_validator(required!())
+            .with_display_mode(PasswordDisplayMode::Masked)
+            .prompt()
+            .with_context(|| "unable to read secret from input")?;
+
+        let h = Handle::current();
+        tokio::task::block_in_place(|| {
+            h.block_on(self.local_provider.set_secret(secret_name, &secret_value))
+        })?;
+        println!("✓ Secret '{secret_name}' added to the vault.");
+
+        Ok(())
+    }
+
+    pub fn get_secret(&self, secret_name: &str) -> Result<()> {
+        let h = Handle::current();
+        let secret = tokio::task::block_in_place(|| {
+            h.block_on(self.local_provider.get_secret(secret_name))
+        })?;
+        println!("{}", secret);
+
+        Ok(())
+    }
+
+    pub fn update_secret(&self, secret_name: &str) -> Result<()> {
+        let secret_value = Password::new("Enter the secret value:")
+            .with_validator(required!())
+            .with_display_mode(PasswordDisplayMode::Masked)
+            .prompt()
+            .with_context(|| "unable to read secret from input")?;
+        let h = Handle::current();
+        tokio::task::block_in_place(|| {
+            h.block_on(
+                self.local_provider
+                    .update_secret(secret_name, &secret_value),
+            )
+        })?;
+        println!("✓ Secret '{secret_name}' updated in the vault.");
+
+        Ok(())
+    }
+
+    pub fn delete_secret(&self, secret_name: &str) -> Result<()> {
+        let h = Handle::current();
+        tokio::task::block_in_place(|| h.block_on(self.local_provider.delete_secret(secret_name)))?;
+        println!("✓ Secret '{secret_name}' deleted from the vault.");
+
+        Ok(())
+    }
+
+    pub fn list_secrets(&self, display_output: bool) -> Result<Vec<String>> {
+        let h = Handle::current();
+        let secrets =
+            tokio::task::block_in_place(|| h.block_on(self.local_provider.list_secrets()))?;
+
+        if display_output {
+            if secrets.is_empty() {
+                println!("The vault is empty.");
+            } else {
+                for key in &secrets {
+                    println!("{}", key);
+                }
+            }
+        }
+
+        Ok(secrets)
+    }
+
+    pub fn handle_vault_flags(cli: Cli, config: Config) -> Result<()> {
+        if let Some(secret_name) = cli.add_secret {
+            config.vault.add_secret(&secret_name)?;
+        }
+
+        if let Some(secret_name) = cli.get_secret {
+            config.vault.get_secret(&secret_name)?;
+        }
+
+        if let Some(secret_name) = cli.update_secret {
+            config.vault.update_secret(&secret_name)?;
+        }
+
+        if let Some(secret_name) = cli.delete_secret {
+            config.vault.delete_secret(&secret_name)?;
+        }
+
+        if cli.list_secrets {
+            config.vault.list_secrets(true)?;
+        }
+
+        Ok(())
+    }
+}

src/vault/utils.rs

@@ -0,0 +1,132 @@
+use crate::config::ensure_parent_exists;
+use anyhow::anyhow;
+use anyhow::Result;
+use gman::providers::local::LocalProvider;
+use indoc::formatdoc;
+use inquire::validator::Validation;
+use inquire::{min_length, required, Confirm, Password, PasswordDisplayMode, Text};
+use std::path::PathBuf;
+
+pub fn ensure_password_file_initialized(local_provider: &mut LocalProvider) -> Result<()> {
+    let vault_password_file = local_provider
+        .password_file
+        .clone()
+        .ok_or_else(|| anyhow!("Password file is not configured"))?;
+
+    if vault_password_file.exists() {
+        {
+            let file_contents = std::fs::read_to_string(&vault_password_file)?;
+            if !file_contents.trim().is_empty() {
+                return Ok(());
+            }
+        }
+
+        let ans = Confirm::new(
+            format!(
+                "The configured password file '{}' is empty. Create a password?",
+                vault_password_file.display()
+            )
+            .as_str(),
+        )
+        .with_default(true)
+        .prompt()?;
+
+        if !ans {
+            return Err(anyhow!("The configured password file '{}' is empty. Please populate it with a password and try again.", vault_password_file.display()));
+        }
+
+        let password = Password::new("Enter a password to encrypt all vault secrets:")
+            .with_validator(required!())
+            .with_validator(min_length!(10))
+            .with_display_mode(PasswordDisplayMode::Masked)
+            .prompt();
+
+        match password {
+            Ok(pw) => {
+                std::fs::write(&vault_password_file, pw.as_bytes())?;
+                println!(
+                    "✓ Password file '{}' updated.",
+                    vault_password_file.display()
+                );
+            }
+            Err(_) => {
+                return Err(anyhow!(
+                    "Failed to read password from input. Password file not updated."
+                ));
+            }
+        }
+    } else {
+        let ans = Confirm::new("No password file configured. Do you want to create one now?")
+            .with_default(true)
+            .prompt()?;
+
+        if !ans {
+            return Err(anyhow!("A password file is required to utilize the Loki vault. Please configure a password file in your config file and try again."));
+        }
+
+        let password_file: PathBuf = Text::new("Enter the path to the password file to create:")
+            .with_default(&vault_password_file.display().to_string())
+            .with_validator(required!("Password file path is required"))
+            .with_validator(|input: &str| {
+                let path = PathBuf::from(input);
+                if path.exists() {
+                    Ok(Validation::Invalid(
+                        "File already exists. Please choose a different path.".into(),
+                    ))
+                } else if let Some(parent) = path.parent() {
+                    if !parent.exists() {
+                        Ok(Validation::Invalid(
+                            "Parent directory does not exist.".into(),
+                        ))
+                    } else {
+                        Ok(Validation::Valid)
+                    }
+                } else {
+                    Ok(Validation::Valid)
+                }
+            })
+            .prompt()?
+            .into();
+
+        if password_file != vault_password_file {
+            println!(
+                "{}",
+                formatdoc!(
+                    "
+					Note: The default password file path is '{}'.
+					You have chosen to create a different path: '{}'.
+					Please ensure your configuration is updated accordingly.
+					",
+                    vault_password_file.display(),
+                    password_file.display()
+                )
+            );
+        }
+
+        ensure_parent_exists(&password_file)?;
+
+        let password = Password::new("Enter a password to encrypt all vault secrets:")
+            .with_display_mode(PasswordDisplayMode::Masked)
+            .with_validator(required!())
+            .with_validator(min_length!(10))
+            .prompt();
+
+        match password {
+            Ok(pw) => {
+                std::fs::write(&password_file, pw.as_bytes())?;
+                local_provider.password_file = Some(password_file);
+                println!(
+                    "✓ Password file '{}' created.",
+                    vault_password_file.display()
+                );
+            }
+            Err(_) => {
+                return Err(anyhow!(
+                    "Failed to read password from input. Password file not created."
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}