esk 0.8.0

Encrypted Secrets Keeper with multi-target deploy
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
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
131
132
133
134
135
136
137
138
139
140
141
142
143

use anyhow::Result;
use clap::Parser;
use console::style;
use esk::cli::{Cli, Commands};
use esk::config::Config;

fn main() {
    if let Err(e) = run() {
        eprintln!("\n {} {:#}\n", style("✖").red().bold(), e);
        std::process::exit(1);
    }
}

fn run() -> Result<()> {
    cliclack::set_theme(esk::ui::EskTheme);
    let cli = Cli::parse();

    match &cli.command {
        Commands::Delete {
            key,
            env,
            no_sync,
            strict,
        } => {
            let config = Config::find_and_load()?;
            esk::cli::delete::run(
                &config,
                &esk::cli::delete::DeleteOptions {
                    key,
                    env,
                    no_sync: *no_sync,
                    strict: *strict,
                },
            )?;
        }
        Commands::Doctor => {
            let cwd = std::env::current_dir()?;
            esk::cli::doctor::run(&cwd)?;
        }
        Commands::Deploy {
            env,
            force,
            dry_run,
            verbose,
            skip_validation,
            strict,
            allow_empty,
            prune,
        } => {
            let config = Config::find_and_load()?;
            esk::cli::deploy::run(
                &config,
                &esk::cli::deploy::DeployOptions {
                    env: env.as_deref(),
                    force: *force,
                    dry_run: *dry_run,
                    verbose: *verbose,
                    skip_validation: *skip_validation,
                    strict: *strict,
                    allow_empty: *allow_empty,
                    prune: *prune,
                },
            )?;
        }
        Commands::Init { keychain } => {
            let cwd = std::env::current_dir()?;
            esk::cli::init::run(&cwd, *keychain)?;
        }
        Commands::Set {
            key,
            env,
            value,
            group,
            no_sync,
            strict,
            skip_validation,
            force,
        } => {
            let config = Config::find_and_load()?;
            esk::cli::set::run(
                &config,
                &esk::cli::set::SetOptions {
                    key,
                    env,
                    value: value.as_deref(),
                    group: group.as_deref(),
                    no_sync: *no_sync,
                    strict: *strict,
                    skip_validation: *skip_validation,
                    force: *force,
                },
            )?;
        }
        Commands::Get { key, env } => {
            let config = Config::find_and_load()?;
            esk::cli::get::run(&config, key, env)?;
        }
        Commands::Generate {
            format,
            output,
            preview,
        } => {
            let config = Config::find_and_load()?;
            esk::cli::generate::run(&config, format.as_ref(), output.as_deref(), *preview)?;
        }
        Commands::LlmContext => {
            esk::cli::llm_context::run()?;
        }
        Commands::List { env } => {
            let config = Config::find_and_load()?;
            esk::cli::list::run(&config, env.as_deref())?;
        }
        Commands::Status { env, all } => {
            let config = Config::find_and_load()?;
            esk::cli::status::run(&config, env.as_deref(), *all)?;
        }
        Commands::Sync {
            env,
            only,
            dry_run,
            strict,
            force,
            with_deploy,
            prefer,
        } => {
            let config = Config::find_and_load()?;
            esk::cli::sync::run(
                &config,
                esk::cli::sync::SyncOptions {
                    env: env.as_deref(),
                    only: only.as_deref(),
                    dry_run: *dry_run,
                    strict: *strict,
                    force: *force,
                    auto_deploy: *with_deploy,
                    prefer: *prefer,
                },
            )?;
        }
    }

    Ok(())
}