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
|
use clap::CommandFactory;
use clap::Subcommand;
use clap_complete::Shell;
use clap_complete::{generate, generate_to};
use eyre::{Result, WrapErr};
use atuin_client::database::Sqlite;
use atuin_client::settings::Settings;
use atuin_common::utils::uuid_v4;
mod event;
mod history;
mod import;
mod init;
mod login;
mod logout;
mod register;
mod search;
mod stats;
mod sync;
use std::path::PathBuf;
#[derive(Subcommand)]
#[clap(infer_subcommands = true)]
pub enum Cmd {
/// Manipulate shell history
#[clap(subcommand)]
History(history::Cmd),
/// Import shell history from file
#[clap(subcommand)]
Import(import::Cmd),
/// Calculate statistics for your history
#[clap(subcommand)]
Stats(stats::Cmd),
/// Output shell setup
#[clap(subcommand)]
Init(init::Cmd),
/// Generate a UUID
Uuid,
/// Interactive history search
Search(search::Cmd),
/// Sync with the configured server
Sync {
/// Force re-download everything
#[clap(long, short)]
force: bool,
},
/// Login to the configured server
Login(login::Cmd),
/// Log out
Logout,
/// Register with the configured server
Register(register::Cmd),
/// Print the encryption key for transfer to another machine
Key,
/// Generate shell completions
GenCompletions {
/// Set the shell for generating completions
#[clap(long, short)]
shell: Shell,
/// Set the output directory
#[clap(long, short)]
out_dir: Option<String>,
},
}
impl Cmd {
pub async fn run(self) -> Result<()> {
pretty_env_logger::init();
let settings = Settings::new().wrap_err("could not load client settings")?;
let db_path = PathBuf::from(settings.db_path.as_str());
let mut db = Sqlite::new(db_path).await?;
match self {
Self::History(history) => history.run(&settings, &mut db).await,
Self::Import(import) => import.run(&mut db).await,
Self::Stats(stats) => stats.run(&mut db, &settings).await,
Self::Init(init) => {
init.run();
Ok(())
}
Self::Search(search) => search.run(&mut db, &settings).await,
Self::Sync { force } => sync::run(&settings, force, &mut db).await,
Self::Login(l) => l.run(&settings).await,
Self::Logout => logout::run(),
Self::Register(r) => r.run(&settings).await,
Self::Key => {
use atuin_client::encryption::{encode_key, load_key};
let key = load_key(&settings).wrap_err("could not load encryption key")?;
let encode = encode_key(key).wrap_err("could not encode encryption key")?;
println!("{}", encode);
Ok(())
}
Self::Uuid => {
println!("{}", uuid_v4());
Ok(())
}
Self::GenCompletions { shell, out_dir } => {
let mut cli = crate::Atuin::command();
match out_dir {
Some(out_dir) => {
generate_to(shell, &mut cli, env!("CARGO_PKG_NAME"), &out_dir)?;
}
None => {
generate(
shell,
&mut cli,
env!("CARGO_PKG_NAME"),
&mut std::io::stdout(),
);
}
}
Ok(())
}
}
}
}
|
