auberge 0.8.1

CLI tool for managing self-hosted infrastructure with Ansible
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::output;
use crate::selector;
use crate::user_config::UserConfig;
use clap::Subcommand;
use dialoguer::{Input, theme::ColorfulTheme};
use eyre::Result;

#[derive(Subcommand)]
pub enum ConfigCommands {
    #[command(alias = "i", about = "Create template config.toml with all known keys")]
    Init,
    #[command(alias = "s", about = "Set a config value")]
    Set {
        #[arg(help = "Key name (e.g. admin_user_name)")]
        key: Option<String>,
        #[arg(help = "Value to set")]
        value: Option<String>,
    },
    #[command(alias = "g", about = "Get a config value")]
    Get {
        #[arg(help = "Key name")]
        key: Option<String>,
    },
    #[command(
        alias = "l",
        about = "List all config keys (sensitive values redacted)"
    )]
    List,
    #[command(alias = "rm", about = "Remove a key from config")]
    Remove {
        #[arg(help = "Key name")]
        key: Option<String>,
    },
    #[command(alias = "e", about = "Open config in $EDITOR")]
    Edit,
    #[command(alias = "p", about = "Print config file path")]
    Path,
}

fn select_key(config: &UserConfig, prompt: &str) -> Result<String> {
    let keys = config.keys();
    if keys.is_empty() {
        eyre::bail!("No config keys found");
    }
    selector::select(&keys, prompt).ok_or_else(|| eyre::eyre!("No key selected"))
}

fn resolve_key(key: Option<String>, config: &UserConfig, prompt: &str) -> Result<String> {
    match key {
        Some(k) => Ok(k),
        None if selector::has_skim_support() => select_key(config, prompt),
        None => eyre::bail!("Key argument required in non-interactive mode"),
    }
}

pub fn run_config_init() -> Result<()> {
    let path = UserConfig::init()?;
    output::success(&format!("Created config at {}", path.display()));
    Ok(())
}

pub fn run_config_set(key: Option<String>, value: Option<String>) -> Result<()> {
    let mut config = UserConfig::load()?;
    let key = resolve_key(key, &config, "Select key to set")?;
    let value = match value {
        Some(v) => v,
        None if selector::has_skim_support() => {
            let current = config.get(&key).unwrap_or_default();
            Input::<String>::with_theme(&ColorfulTheme::default())
                .with_prompt(format!("Value for '{}'", key))
                .default(current)
                .allow_empty(true)
                .interact_text()?
        }
        None => eyre::bail!("Value argument required in non-interactive mode"),
    };
    config.set(&key, &value)?;
    output::success(&format!("{} = {}", key, value));
    Ok(())
}

pub fn run_config_get(key: Option<String>) -> Result<()> {
    let config = UserConfig::load()?;
    let key = resolve_key(key, &config, "Select key to get")?;
    match config.get(&key) {
        Some(value) => println!("{}", value),
        None => eyre::bail!("Key '{}' not found", key),
    }
    Ok(())
}

pub fn run_config_list() -> Result<()> {
    let config = UserConfig::load()?;
    for (key, value) in config.keys_redacted() {
        println!("{} = {}", key, value);
    }
    Ok(())
}

pub fn run_config_remove(key: Option<String>) -> Result<()> {
    let mut config = UserConfig::load()?;
    let key = resolve_key(key, &config, "Select key to remove")?;
    if config.remove(&key)? {
        output::success(&format!("Removed '{}'", key));
    } else {
        eyre::bail!("Key '{}' not found", key);
    }
    Ok(())
}

pub fn run_config_edit() -> Result<()> {
    let path = UserConfig::path()?;
    if !path.exists() {
        eyre::bail!(
            "Config not found at {}. Run `auberge config init` first.",
            path.display()
        );
    }
    let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
    std::process::Command::new(&editor)
        .arg(&path)
        .status()
        .map_err(|e| eyre::eyre!("Failed to open editor '{}': {}", editor, e))?;
    Ok(())
}

pub fn run_config_path() -> Result<()> {
    println!("{}", UserConfig::path()?.display());
    Ok(())
}