onehis 0.3.0

All your history in one file
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

mod backup;
mod database;
mod export;
mod progress;
mod source;
mod types;
mod util;
mod web;

use crate::util::{DEFAULT_CSV_FILE, DEFAULT_DB_FILE};
use anyhow::Result;
use clap::{Parser, Subcommand};
use env_logger::Env;
use export::export_csv;
use log::{debug, error, info, LevelFilter};
use std::io::Write;
use util::detect_history_files;

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Cli {
    /// Database path
    #[clap(short, long, env("OH_DB_FILE"), default_value(&**DEFAULT_DB_FILE))]
    db_file: String,

    #[clap(short, long)]
    verbose: bool,

    #[clap(subcommand)]
    command: Command,
}

#[derive(Subcommand, Debug)]
enum Command {
    /// Backup browser history to 1History
    Backup(Backup),
    /// Start HTTP server to visualize history
    Serve(Serve),
    /// Show default history files on your computer
    Show,
    Export(Export),
}

#[derive(Parser, Debug)]
struct Backup {
    /// SQLite file path of different browsers(History.db/places.sqlite...)
    #[clap(short('f'), long, required(false))]
    history_files: Vec<String>,
    /// Disable auto detect history files
    #[clap(short('d'), long)]
    disable_detect: bool,
    #[clap(short('D'), long)]
    dry_run: bool,
}

#[derive(Parser, Debug)]
struct Serve {
    /// Listening address
    #[clap(short, long, default_value("127.0.0.1:9960"))]
    addr: String,
}

#[derive(Parser, Debug)]
struct Export {
    /// Output cse file
    #[clap(short, long, env("OH_EXPORT_CSV_FILE"), default_value(&**DEFAULT_CSV_FILE))]
    csv_file: String,
}

// https://stackoverflow.com/a/27841363/2163429
const PKG_NAME: &str = env!("CARGO_PKG_NAME");

fn main() {
    let cli = Cli::parse();

    let mut builder =
        env_logger::Builder::from_env(Env::default().default_filter_or(format!("{PKG_NAME}=info")));
    if cli.verbose {
        builder.filter(Some(PKG_NAME), LevelFilter::Debug);
    };
    builder
        .format(|buf, record| {
            writeln!(
                buf,
                "{} {} [{}:{}] {}",
                chrono::Local::now().format("%Y-%m-%dT%H:%M:%S.%3f"),
                buf.default_styled_level(record.level()),
                record.file().unwrap_or("unknown"),
                record.line().unwrap_or(0),
                record.args()
            )
        })
        .init();

    debug!("args:{cli:?}");
    if let Err(e) = run(cli) {
        error!("Run failed, err:{:?}", e);
    }
}

fn show(db_file: String) -> Result<()> {
    info!("Local database:{}", db_file);
    let mut cnt = 0;
    for f in detect_history_files() {
        cnt += 1;
        info!("found:{}", f);
    }
    info!("Total:{cnt}");
    Ok(())
}

fn run(cli: Cli) -> Result<()> {
    match cli.command {
        Command::Show => show(cli.db_file),
        Command::Export(Export { csv_file }) => export_csv(csv_file, cli.db_file),
        Command::Serve(Serve { addr }) => web::serve(addr, cli.db_file),
        Command::Backup(Backup {
            history_files,
            disable_detect,
            dry_run,
        }) => {
            let mut files = if disable_detect {
                Vec::new()
            } else {
                detect_history_files()
            };
            files.extend(history_files);
            backup::backup(files, cli.db_file, dry_run)
        }
    }
}