lade 0.8.1

Automatically load secrets from your preferred vault as environment variables, and clear them once your shell command is over.
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

use anyhow::{bail, Result};
use std::{
    collections::HashMap,
    path::{Path, PathBuf},
};
use sysinfo::{get_current_pid, ProcessExt, System, SystemExt};

#[cfg(debug_assertions)]
macro_rules! import {
    ($x:expr) => {
        include_str!($x)
            .replace("lade set", "cargo run -- set")
            .replace("lade unset", "cargo run -- unset")
    };
}

#[cfg(not(debug_assertions))]
macro_rules! import {
    ($x:expr) => {
        include_str!($x).to_string()
    };
}

pub enum Shell {
    Bash,
    Zsh,
    Fish,
}

impl Shell {
    pub fn detect() -> Result<Shell> {
        let sys = System::new_all();
        let process = sys
            .process(get_current_pid().expect("no pid"))
            .expect("pid does not exist");
        let parent = sys
            .process(process.parent().expect("no parent pid"))
            .expect("parent pid does not exist");
        let shell = parent.name().trim().to_lowercase();
        let shell = shell.strip_suffix(".exe").unwrap_or(&shell); // windows bad

        match shell {
            "bash" => Ok(Shell::Bash),
            "zsh" => Ok(Shell::Zsh),
            "fish" => Ok(Shell::Fish),
            _ => bail!("Unsupported shell"),
        }
    }

    pub fn on(&self) -> String {
        match self {
            Shell::Bash => format!(
                "{}\n{}",
                import!("../scripts/bash-preexec.sh"),
                import!("../scripts/on.bash")
            ),
            Shell::Zsh => import!("../scripts/on.zsh"),
            Shell::Fish => import!("../scripts/on.fish"),
        }
    }

    pub fn off(&self) -> String {
        match self {
            Shell::Bash => import!("../scripts/off.bash"),
            Shell::Zsh => import!("../scripts/off.zsh"),
            Shell::Fish => import!("../scripts/off.fish"),
        }
    }

    pub fn set(&self, env: HashMap<String, String>) -> String {
        env.into_iter()
            .map(|(k, v)| match self {
                Shell::Zsh | Shell::Bash => {
                    format!("declare -g -x {k}='{v}'")
                }
                Shell::Fish => {
                    format!("set --global --export {k} '{v}'")
                }
            })
            .collect::<Vec<_>>()
            .join(";")
    }

    pub fn unset(&self, keys: Vec<String>) -> String {
        let format = match self {
            Shell::Zsh | Shell::Bash => |k| format!("unset -v ${k}"),
            Shell::Fish => |k| format!("set --global --erase {k}"),
        };
        keys.into_iter().map(format).collect::<Vec<_>>().join(";")
    }

    pub fn install(&self) -> String {
        self.configure_auto_launch(true).display().to_string()
    }

    pub fn uninstall(&self) -> String {
        self.configure_auto_launch(false).display().to_string()
    }

    fn configure_auto_launch(&self, install: bool) -> PathBuf {
        let user = directories::UserDirs::new().expect("cannot get HOME location");
        let home_dir = user.home_dir();
        let curr_exe = std::env::current_exe().expect("cannot get current executable path");
        let command = match self {
            Shell::Bash => format!("source <(echo \"$({} on)\")", curr_exe.display()),
            Shell::Zsh => format!("eval \"$({} on)\"", curr_exe.display()),
            Shell::Fish => format!("eval \"$({} on)\"", curr_exe.display()),
        };
        let marker = "lade-do-not-edit".to_string();
        let config_file = match self {
            Shell::Bash => home_dir.join(".bashrc"),
            Shell::Zsh => home_dir.join(".zshrc"),
            Shell::Fish => home_dir.join(".config/fish/config.fish"),
        };
        edit_config(&config_file, command, marker, install);
        config_file
    }
}

fn edit_config<P: AsRef<Path>>(config_file: P, line: String, marker: String, install: bool) {
    let old_config = std::fs::read_to_string(&config_file).unwrap_or_default();
    let mut new_config = old_config
        .lines()
        .filter(|l| !l.contains(&marker))
        .collect::<Vec<_>>();
    let new_line = format!("{}  # {}", line, marker);
    if install {
        new_config.push(&new_line);
    }
    std::fs::write(config_file, new_config.join("\n")).expect("cannot write to config file");
}