vaultic 1.0.0

Secure your secrets. Sync your team. Trust your configs.
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

use chrono::{NaiveDate, TimeZone, Utc};
use colored::Colorize;

use crate::adapters::audit::json_audit_logger::JsonAuditLogger;
use crate::cli::output;
use crate::config::app_config::AppConfig;
use crate::core::errors::{Result, VaulticError};
use crate::core::models::audit_entry::{AuditAction, AuditEntry};
use crate::core::traits::audit::AuditLogger;

/// Execute the `vaultic log` command.
///
/// Displays the audit log with optional filters for author, date,
/// and entry count.
pub fn execute(author: Option<&str>, since: Option<&str>, last: Option<usize>) -> Result<()> {
    let vaultic_dir = crate::cli::context::vaultic_dir();
    if !vaultic_dir.exists() {
        return Err(VaulticError::InvalidConfig {
            detail: "Vaultic not initialized. Run 'vaultic init' first.".into(),
        });
    }

    let config = AppConfig::load(vaultic_dir)?;
    let audit_section = config.audit.as_ref();
    let logger = JsonAuditLogger::from_config(vaultic_dir, audit_section);

    // Parse the --since flag as a date
    let since_dt = since.map(parse_since).transpose()?;

    let entries = logger.query(author, since_dt)?;

    if entries.is_empty() {
        output::header("vaultic log");
        output::warning("No audit entries found");
        if author.is_some() || since.is_some() {
            println!("  Try removing filters to see all entries.");
        }
        return Ok(());
    }

    // Apply --last N (take from the end)
    let display: Vec<&AuditEntry> = match last {
        Some(n) => entries
            .iter()
            .rev()
            .take(n)
            .collect::<Vec<_>>()
            .into_iter()
            .rev()
            .collect(),
        None => entries.iter().collect(),
    };

    output::header(&format!("vaultic log ({} entries)", display.len()));
    println!();

    for entry in &display {
        print_entry(entry);
    }

    Ok(())
}

/// Parse a date string (ISO 8601: `YYYY-MM-DD`) into a UTC DateTime.
fn parse_since(s: &str) -> Result<chrono::DateTime<Utc>> {
    NaiveDate::parse_from_str(s, "%Y-%m-%d")
        .map_err(|_| VaulticError::InvalidConfig {
            detail: format!(
                "Invalid date format: '{s}'. Expected ISO 8601 (YYYY-MM-DD), e.g. 2026-01-15"
            ),
        })
        .map(|d| Utc.from_utc_datetime(&d.and_hms_opt(0, 0, 0).expect("midnight is always valid")))
}

/// Print a single audit entry as a formatted row.
fn print_entry(entry: &AuditEntry) {
    let date = entry.timestamp.format("%Y-%m-%d %H:%M:%S");
    let author = truncate_author(&entry.author, 10);
    let action = format_action(&entry.action);
    let files = if entry.files.is_empty() {
        "—".dimmed().to_string()
    } else {
        entry.files.join(", ")
    };
    let detail = entry.detail.as_deref().unwrap_or("").dimmed().to_string();
    let sep = "│".dimmed();

    println!(
        "  {} {sep} {:<10} {sep} {:<10} {sep} {} {}",
        date.to_string().dimmed(),
        author,
        action,
        files,
        detail,
    );
}

/// Truncate an author name for display.
fn truncate_author(author: &str, max_len: usize) -> String {
    let char_count = author.chars().count();
    if char_count <= max_len {
        author.to_string()
    } else {
        author
            .chars()
            .take(max_len.saturating_sub(1))
            .collect::<String>()
            + "…"
    }
}

/// Format an AuditAction as a colored string.
fn format_action(action: &AuditAction) -> String {
    match action {
        AuditAction::Init => "init".cyan().to_string(),
        AuditAction::Encrypt => "encrypt".green().to_string(),
        AuditAction::Decrypt => "decrypt".blue().to_string(),
        AuditAction::KeyAdd => "key add".green().to_string(),
        AuditAction::KeyRemove => "key rm".red().to_string(),
        AuditAction::Check => "check".yellow().to_string(),
        AuditAction::Diff => "diff".yellow().to_string(),
        AuditAction::Resolve => "resolve".blue().to_string(),
        AuditAction::HookInstall => "hook +".green().to_string(),
        AuditAction::HookUninstall => "hook -".red().to_string(),
    }
}