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
|
use std::path::PathBuf;
use clap::Subcommand;
use eyre::{Result, WrapErr};
use atuin_client::{database::Sqlite, record::sqlite_store::SqliteStore, settings::Settings};
use env_logger::Builder;
#[cfg(feature = "sync")]
mod sync;
#[cfg(feature = "sync")]
mod account;
mod config;
mod default_config;
mod doctor;
mod history;
mod import;
mod init;
mod kv;
mod search;
mod stats;
mod store;
#[derive(Subcommand, Debug)]
#[command(infer_subcommands = true)]
pub enum Cmd {
/// Manipulate shell history
#[command(subcommand)]
History(history::Cmd),
/// Import shell history from file
#[command(subcommand)]
Import(import::Cmd),
/// Calculate statistics for your history
Stats(stats::Cmd),
/// Interactive history search
Search(search::Cmd),
#[cfg(feature = "sync")]
#[command(flatten)]
Sync(sync::Cmd),
#[cfg(feature = "sync")]
Account(account::Cmd),
#[command(subcommand)]
Kv(kv::Cmd),
#[command(subcommand)]
Store(store::Cmd),
#[command(subcommand)]
Config(config::Cmd),
#[command()]
Init(init::Cmd),
#[command()]
Doctor,
/// Print example configuration
#[command()]
DefaultConfig,
}
impl Cmd {
pub fn run(self) -> Result<()> {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let settings = Settings::new().wrap_err("could not load client settings")?;
let res = runtime.block_on(self.run_inner(settings));
runtime.shutdown_timeout(std::time::Duration::from_millis(50));
res
}
async fn run_inner(self, mut settings: Settings) -> Result<()> {
Builder::new()
.filter_level(log::LevelFilter::Off)
.filter_module("sqlx_sqlite::regexp", log::LevelFilter::Off)
.parse_env("ATUIN_LOG")
.init();
tracing::trace!(command = ?self, "client command");
let db_path = PathBuf::from(settings.db_path.as_str());
let record_store_path = PathBuf::from(settings.record_store_path.as_str());
let db = Sqlite::new(db_path, settings.local_timeout).await?;
let sqlite_store = SqliteStore::new(record_store_path, settings.local_timeout).await?;
match self {
Self::History(history) => history.run(&settings, &db, sqlite_store).await,
Self::Import(import) => import.run(&db).await,
Self::Stats(stats) => stats.run(&db, &settings).await,
Self::Search(search) => search.run(db, &mut settings, sqlite_store).await,
#[cfg(feature = "sync")]
Self::Sync(sync) => sync.run(settings, &db, sqlite_store).await,
#[cfg(feature = "sync")]
Self::Account(account) => account.run(settings, sqlite_store).await,
Self::Kv(kv) => kv.run(&settings, &sqlite_store).await,
Self::Store(store) => store.run(&settings, &db, sqlite_store).await,
Self::Config(config) => config.run(&settings, sqlite_store).await,
Self::Init(init) => init.run(&settings).await,
Self::Doctor => doctor::run(&settings),
Self::DefaultConfig => {
default_config::run();
Ok(())
}
}
}
}
|
