siggy 1.8.0

Terminal-based Signal messenger client with vim keybindings
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
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
134
135
136
137
138
139
140

//! Optional debug logger — writes to ~/.cache/siggy/debug.log when --debug is passed.
//! Rotates log file when it exceeds MAX_LOG_SIZE bytes.
//!
//! `--debug` enables logging with PII redaction (phone numbers masked, message bodies omitted).
//! `--debug-full` enables logging with full unredacted output.

use std::fs::{File, OpenOptions};
use std::io::Write;
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};

static ENABLED: AtomicBool = AtomicBool::new(false);
static REDACT: AtomicBool = AtomicBool::new(true);
static FILE: Mutex<Option<File>> = Mutex::new(None);
static PATH: Mutex<Option<std::path::PathBuf>> = Mutex::new(None);

const MAX_LOG_SIZE: u64 = 10 * 1024 * 1024; // 10 MB

fn log_path() -> std::path::PathBuf {
    dirs::cache_dir()
        .unwrap_or_else(|| std::path::PathBuf::from(".cache"))
        .join("siggy")
        .join("debug.log")
}

fn setup_file() {
    let path = log_path();
    if let Some(parent) = path.parent() {
        let _ = std::fs::create_dir_all(parent);
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let _ = std::fs::set_permissions(parent, std::fs::Permissions::from_mode(0o700));
        }
    }
    // Rotate if existing log exceeds size limit
    if path.exists()
        && let Ok(meta) = std::fs::metadata(&path)
        && meta.len() > MAX_LOG_SIZE
    {
        let backup = path.with_extension("log.old");
        let _ = std::fs::rename(&path, &backup);
    }
    if let Ok(f) = OpenOptions::new().create(true).append(true).open(&path) {
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
        }
        if let Ok(mut guard) = FILE.lock() {
            *guard = Some(f);
        }
        if let Ok(mut guard) = PATH.lock() {
            *guard = Some(path.clone());
        }
    }
    eprintln!("Debug logging enabled: {}", path.display());
}

/// Enable debug logging with PII redaction (--debug).
pub fn enable() {
    ENABLED.store(true, Ordering::Relaxed);
    REDACT.store(true, Ordering::Relaxed);
    setup_file();
}

/// Enable debug logging without PII redaction (--debug-full).
pub fn enable_full() {
    ENABLED.store(true, Ordering::Relaxed);
    REDACT.store(false, Ordering::Relaxed);
    setup_file();
}

/// Whether PII should be redacted in log output.
pub fn redact() -> bool {
    REDACT.load(Ordering::Relaxed)
}

/// Mask a phone number for redacted logging: "+15551234567" → "+1***...567"
pub fn mask_phone(phone: &str) -> String {
    if !redact() {
        return phone.to_string();
    }
    if phone.starts_with('+') && phone.len() > 5 {
        let suffix = &phone[phone.len() - 3..];
        format!("+{}***...{}", &phone[1..2], suffix)
    } else if phone.len() > 8 {
        // Group IDs or other long identifiers
        format!("{}...{}", &phone[..4], &phone[phone.len() - 4..])
    } else {
        "[redacted]".to_string()
    }
}

/// Summarize a message body for redacted logging: "hello world" → "[msg: 11 chars]"
pub fn mask_body(body: &str) -> String {
    if !redact() {
        return body.to_string();
    }
    format!("[msg: {} chars]", body.len())
}

pub fn log(msg: &str) {
    if !ENABLED.load(Ordering::Relaxed) {
        return;
    }
    if let Ok(mut guard) = FILE.lock()
        && let Some(ref mut f) = *guard
    {
        let now = chrono::Local::now().format("%H:%M:%S%.3f");
        let _ = writeln!(f, "[{now}] {msg}");
    }
}

pub fn logf(args: std::fmt::Arguments<'_>) {
    if !ENABLED.load(Ordering::Relaxed) {
        return;
    }
    log(&format!("{args}"));
}

/// Always-on warning log: writes to the debug log file regardless of whether
/// --debug is enabled. Used for diagnostics the user should see even without
/// opting into full debug logging (e.g. pathologically slow image decodes
/// surfaced by issue #444).
///
/// Lazy-initialises the log file on first call so the warning lands somewhere
/// inspectable. Subsequent warnings reuse the open handle.
pub fn warnf(args: std::fmt::Arguments<'_>) {
    if FILE.lock().map(|g| g.is_none()).unwrap_or(true) {
        setup_file();
    }
    let msg = format!("WARN: {args}");
    if let Ok(mut guard) = FILE.lock()
        && let Some(ref mut f) = *guard
    {
        let now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
        let _ = writeln!(f, "[{now}] {msg}");
    }
}