flawz 0.3.0

A Terminal UI for browsing CVEs
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

use clap::Parser;
use flawz::app::{App, AppResult};
use flawz::args::Args;
use flawz::cve::Cve;
use flawz::error::Error;
use flawz::event::{Event, EventHandler};
use flawz::handler::{handle_key_events, handle_mouse_events};
use flawz::terminal::Tui;
use flawz::widgets::SelectableList;
use ratatui::backend::CrosstermBackend;
use ratatui::Terminal;
use std::path::Path;
use std::{io, thread};

use nvd_cve::cache::{get_all, sync_blocking, CacheConfig};
use nvd_cve::client::{BlockingHttpClient, ReqwestBlockingClient};

fn main() -> AppResult<()> {
    // Parse command-line arguments.
    let args = Args::parse();

    // Fetch CVEs.
    let config = CacheConfig {
        url: args.url.to_string(),
        feeds: args.feeds()?,
        db: args.db.unwrap_or_else(CacheConfig::default_db_path),
        show_progress: true,
        force_update: args.force_update,
    };
    if !args.offline && !Path::new(&config.db).exists() || args.force_update {
        let client = ReqwestBlockingClient::new(&config.url, None, None, None);
        sync_blocking(&config, client).map_err(Error::CacheError)?;
    }
    let cves = get_all(&config).map_err(Error::CacheError)?;

    // Create an application.
    let mut app = App::new(
        cves.into_iter().map(Cve::from).collect(),
        args.theme
            .get_theme()
            .ok_or_else(|| Error::ParseColorError)?,
        args.query.clone().unwrap_or_default(),
    );

    // Initialize the terminal user interface.
    let backend = CrosstermBackend::new(io::stderr());
    let terminal = Terminal::new(backend)?;
    let events = EventHandler::new(250);
    let mut tui = Tui::new(terminal, events);
    tui.init()?;

    if !args.query.unwrap_or_default().is_empty() {
        tui.events.sender.send(Event::Search)?;
    }

    // Start the main loop.
    while app.running {
        // Render the user interface.
        tui.draw(&mut app)?;
        // Handle events.
        match tui.events.next()? {
            Event::Key(key_event) => handle_key_events(key_event, &mut app, &tui.events.sender)?,
            Event::Mouse(mouse_event) => {
                handle_mouse_events(mouse_event, &mut app, &tui.events.sender)?
            }
            Event::Resize(_, _) => {}
            Event::Search => {
                let query = app.input.value().to_lowercase();
                let items = app.cves.clone();
                let sender = tui.events.sender.clone();
                thread::spawn(move || {
                    let items = items
                        .into_iter()
                        .filter(|cve| {
                            query.is_empty()
                                || cve.id.to_lowercase().contains(&query)
                                || cve
                                    .description
                                    .clone()
                                    .unwrap_or_default()
                                    .to_lowercase()
                                    .contains(&query)
                        })
                        .collect();
                    sender
                        .send(Event::SearchResult(SelectableList::with_items(items)))
                        .unwrap();
                });
            }
            Event::SearchResult(v) => {
                app.list = v;
            }
        }
    }

    // Exit the user interface.
    tui.exit()?;
    Ok(())
}