mk 0.7.12

Yet another simple task runner 🦀
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use clap::{
  Args,
  Subcommand,
};
use context::Context;
use key::KEY_LOCATION_HELP;
use mk_lib::schema::TaskRoot;

mod context;
mod doctor;
mod key;
mod utils;
mod vault;

/// The struct that represents the secrets command
#[derive(Debug, Args)]
pub struct Secrets {
  #[command(subcommand)]
  command: Option<SecretsCommand>,

  #[arg(long, help = "The path to the secret vault")]
  vault_location: Option<String>,

  #[arg(long, help = KEY_LOCATION_HELP)]
  keys_location: Option<String>,

  #[arg(long, help = "The key name", conflicts_with = "gpg_key_id")]
  key_name: Option<String>,

  #[arg(
    long,
    conflicts_with = "key_name",
    help = "GPG key ID or fingerprint for hardware/passphrase-protected keys (delegates crypto to the system gpg binary). Cannot be combined with --key-name."
  )]
  gpg_key_id: Option<String>,
}

/// The available subcommands for the secrets command
#[derive(Debug, Subcommand)]
enum SecretsCommand {
  /// Access private keys using this subcommand
  #[command(visible_aliases = ["k"], arg_required_else_help = true, about = "Access private keys")]
  Key(key::Key),

  /// Access secret stores using this subcommand
  #[command(visible_aliases = ["v"], arg_required_else_help = true, about = "Access secret vault")]
  Vault(vault::Vault),

  /// List private keys
  #[command(visible_aliases = ["K"], about = "List private keys")]
  ListKeys(key::ListKeys),

  /// Initialize a new secret store
  #[command(visible_aliases = ["init"], about = "Initialize a new secret vault")]
  InitVault(vault::InitVault),

  /// Print resolved secret configuration
  #[command(about = "Inspect resolved secret configuration")]
  Doctor(doctor::Doctor),

  /// Export a secret
  #[command(visible_aliases = ["export", "e"], about = "Export a secret to file")]
  ExportSecret(vault::ExportSecret),
}

impl Secrets {
  pub fn execute(&self, task_root: &TaskRoot) -> anyhow::Result<()> {
    let mut context = Context::new(task_root);
    if let Some(keys_location) = &self.keys_location {
      context.set_keys_location(keys_location);
    }

    if let Some(vault_location) = &self.vault_location {
      context.set_vault_location(vault_location);
    }

    if let Some(key_name) = &self.key_name {
      context.set_key_name(key_name);
    }

    if let Some(gpg_key_id) = &self.gpg_key_id {
      context.set_gpg_key_id(gpg_key_id);
    }

    match &self.command {
      Some(SecretsCommand::Key(key)) => key.execute(&mut context),
      Some(SecretsCommand::Vault(vault)) => vault.execute(&mut context),
      Some(SecretsCommand::ListKeys(list_keys)) => list_keys.execute(&context),
      Some(SecretsCommand::InitVault(init_store)) => init_store.execute(&context),
      Some(SecretsCommand::Doctor(doctor)) => doctor.execute(&context),
      Some(SecretsCommand::ExportSecret(export_secret)) => export_secret.execute(&context),
      None => Err(anyhow::anyhow!(
        "No secrets subcommand given. Run 'mk secrets --help' to see available subcommands."
      )),
    }
  }
}