entrust 0.5.1

A CLI password manager
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

use crate::dialog;
use anyhow::anyhow;
use clap::Args;
use color_print::cstr;
use const_format::formatcp;
use enigo::{Direction, Enigo, Key, Keyboard, Settings};
use entrust_core::{Backend, resolve_existing_location};
use std::path::{Path, PathBuf};
use std::thread;
use std::time::Duration;

pub(super) const ABOUT: &str = "Autotype into the previously active window";

const HELP: &str = "One or more keys, separated by a colon, and optionally {tab} or {enter}";

const LONG_HELP_ADDITION: &str = cstr!(
    "\
A prompt will be displayed for omitted keys. Examples:
<bold>something/user:{tab}:something/pass:{enter}</>
<bold>:{tab}::{enter}</>"
);

const LONG_HELP: &str = formatcp!("{HELP}\n{LONG_HELP_ADDITION}");

#[derive(Args, Debug)]
pub struct AutotypeArgs {
    #[arg(help = HELP, long_help = LONG_HELP, default_value = "", hide_default_value = true)]
    segments: String,
}

#[derive(Debug)]
enum Segment {
    Pass(String),
    Tab,
    Enter,
}

pub fn run(store: PathBuf, args: AutotypeArgs) -> anyhow::Result<()> {
    let segments = parse_segments(args.segments.as_str(), store.as_path())?;
    if !segments.is_empty() {
        autotype_alt_tab()?;
    }
    for segment in segments {
        match segment {
            Segment::Pass(pass) => autotype_text(pass)?,
            Segment::Tab => autotype_tab()?,
            Segment::Enter => autotype_enter()?,
        }
    }
    Ok(())
}

fn parse_segments(string: &str, store: &Path) -> anyhow::Result<Vec<Segment>> {
    string.split(':').map(|s| parse_segment(s, store)).collect()
}

fn parse_segment(string: &str, store: &Path) -> anyhow::Result<Segment> {
    match string {
        "{tab}" => Ok(Segment::Tab),
        "{enter}" => Ok(Segment::Enter),
        s if s.starts_with("{") && s.ends_with("}") => Err(anyhow!("Unsupported key press: {s}")),
        "" => {
            let key = store.join(dialog::select_existing_key(store)?);
            let pass = Backend::decrypt(&key)?;
            Ok(Segment::Pass(pass))
        }
        s => {
            let key = resolve_existing_location(store, s, false)?;
            let pass = Backend::decrypt(&key)?;
            Ok(Segment::Pass(pass))
        }
    }
}

fn autotype_alt_tab() -> anyhow::Result<()> {
    let mut enigo = Enigo::new(&Settings::default())?;
    enigo.key(Key::Alt, Direction::Press)?;
    enigo.key(Key::Tab, Direction::Click)?;
    enigo.key(Key::Alt, Direction::Release)?;
    Ok(())
}

fn autotype_tab() -> anyhow::Result<()> {
    let mut enigo = Enigo::new(&Settings::default())?;
    enigo.key(Key::Tab, Direction::Click)?;
    Ok(())
}

fn autotype_enter() -> anyhow::Result<()> {
    let mut enigo = Enigo::new(&Settings::default())?;
    enigo.key(Key::Return, Direction::Click)?;
    Ok(())
}

fn autotype_text(text: impl AsRef<str>) -> anyhow::Result<()> {
    let mut enigo = Enigo::new(&Settings::default())?;
    thread::sleep(Duration::from_millis(500));
    // workaround for https://github.com/enigo-rs/enigo/issues/303
    for line in itertools::intersperse(text.as_ref().split('\n'), "\n") {
        enigo.text(line)?;
    }
    Ok(())
}