git-custom-cli 2.4.0

Fast, keyboard-driven terminal UI for dated Git commits
//! Session log of every git command gct ran (the Commands mode shows it).
//!
//! A ring of the last 200 calls, kept in memory only. Arguments are masked before they are
//! stored (URL passwords, GitHub tokens, `-c http.extraheader=...`); stdin is never recorded.

use std::collections::VecDeque;
use std::sync::Mutex;

const CAPACITY: usize = 200;

static LOG: Mutex<VecDeque<Entry>> = Mutex::new(VecDeque::new());

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Entry {
    /// The masked argument list after `git`, shell-style quoted where needed.
    pub args: String,
    /// Exit code; None when git could not start or was killed.
    pub code: Option<i32>,
    pub ms: u128,
    /// Local time of day, HH:MM:SS.
    pub at: String,
}

/// Records one finished git call.
pub fn record(args: &[&str], code: Option<i32>, ms: u128) {
    let entry = Entry {
        args: display_args(args),
        code,
        ms,
        at: chrono::Local::now().format("%H:%M:%S").to_string(),
    };
    let mut log = LOG.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
    log.push_front(entry);
    log.truncate(CAPACITY);
}

/// Every recorded call, newest first.
pub fn entries() -> Vec<Entry> {
    let log = LOG.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
    log.iter().cloned().collect()
}

/// Joins the arguments for display, masking the value after `-c http.extraheader` and secrets.
fn display_args(args: &[&str]) -> String {
    let mut parts = Vec::with_capacity(args.len());
    let mut after_c = false;
    for arg in args {
        let shown = if after_c && arg.to_ascii_lowercase().contains("extraheader") {
            match arg.split_once('=') {
                Some((key, _)) => format!("{key}=***"),
                None => (*arg).to_string(),
            }
        } else {
            (*arg).to_string()
        };
        after_c = *arg == "-c";
        parts.push(quote(&shown));
    }
    mask(&parts.join(" "))
}

fn quote(arg: &str) -> String {
    if arg.is_empty() || arg.contains(char::is_whitespace) || arg.contains('"') {
        format!("\"{}\"", arg.replace('"', "\\\""))
    } else {
        arg.to_string()
    }
}

/// Hides credentials: `scheme://user:pass@host` -> `scheme://***@host`, and GitHub tokens
/// (`ghp_`, `gho_`, `ghs_`, `ghu_`, `ghr_`, `github_pat_`) and `x-access-token:<value>` -> `***`.
pub fn mask(text: &str) -> String {
    mask_tokens(&mask_userinfo(text))
}

fn mask_userinfo(text: &str) -> String {
    let mut out = String::with_capacity(text.len());
    let mut rest = text;
    while let Some(at) = rest.find("://") {
        let start = at + 3;
        out.push_str(&rest[..start]);
        let tail = &rest[start..];
        let end = tail
            .find(|c: char| c == '/' || c == '?' || c == '#' || c.is_whitespace())
            .unwrap_or(tail.len());
        let authority = &tail[..end];
        match authority.rfind('@') {
            Some(sign) if sign > 0 => {
                out.push_str("***");
                out.push_str(&authority[sign..]);
            }
            _ => out.push_str(authority),
        }
        rest = &tail[end..];
    }
    out.push_str(rest);
    out
}

fn mask_tokens(text: &str) -> String {
    const PREFIXES: [(&str, bool); 7] = [
        // (prefix, underscores allowed in the value)
        ("github_pat_", true),
        ("ghp_", false),
        ("gho_", false),
        ("ghs_", false),
        ("ghu_", false),
        ("ghr_", false),
        ("x-access-token:", true),
    ];
    let bytes = text.as_bytes();
    let mut out = String::with_capacity(text.len());
    let mut i = 0;
    'scan: while i < bytes.len() {
        for (prefix, underscore) in PREFIXES {
            if text[i..].starts_with(prefix) {
                let value_start = i + prefix.len();
                let mut j = value_start;
                while j < bytes.len() {
                    let b = bytes[j];
                    let ok = if prefix.starts_with("x-access") {
                        !(b.is_ascii_whitespace() || b == b'@' || b == b'/' || b == b'"')
                    } else {
                        b.is_ascii_alphanumeric() || (underscore && b == b'_')
                    };
                    if !ok {
                        break;
                    }
                    j += 1;
                }
                if j > value_start {
                    out.push_str("***");
                    i = j;
                    continue 'scan;
                }
            }
        }
        // Prefixes are ASCII, so `i` is always on a char boundary here.
        let ch = text[i..].chars().next().unwrap_or_default();
        out.push(ch);
        i += ch.len_utf8().max(1);
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn masks_secrets() {
        let cases = [
            (
                "push https://user:pa55@github.com/o/r.git main",
                "push https://***@github.com/o/r.git main",
            ),
            (
                "https://ghp_abc123@github.com/x",
                "https://***@github.com/x",
            ),
            ("token ghp_ABCdef0123456789 end", "token *** end"),
            ("gho_x ghs_y ghu_z ghr_w", "*** *** *** ***"),
            ("github_pat_11AB_cd99 rest", "*** rest"),
            ("x-access-token:abc.def@github.com", "***@github.com"),
            ("ssh://git@host/repo", "ssh://***@host/repo"),
            ("https://github.com/o/r.git", "https://github.com/o/r.git"),
            ("ghp_ alone", "ghp_ alone"),
            ("plain ünïcode text", "plain ünïcode text"),
            ("", ""),
        ];
        for (input, expected) in cases {
            assert_eq!(mask(input), expected, "{input}");
        }
    }

    #[test]
    fn display_masks_extraheader_and_quotes() {
        let shown = display_args(&[
            "-c",
            "http.extraheader=AUTHORIZATION: basic c2VjcmV0",
            "commit",
            "-m",
            "two words",
            "",
        ]);
        assert_eq!(
            shown,
            "-c http.extraheader=*** commit -m \"two words\" \"\""
        );
        let shown = display_args(&["-c", "http.https://x.com/.extraHeader=Bearer t", "fetch"]);
        assert_eq!(shown, "-c http.https://x.com/.extraHeader=*** fetch");
    }

    #[test]
    fn records_newest_first_and_masked() {
        record(
            &["remote", "add", "o", "https://u:secret-zz91@h/r"],
            Some(0),
            3,
        );
        record(&["status", "--probe-zz91"], Some(1), 4);
        let all = entries();
        let first = all
            .iter()
            .position(|e| e.args == "status --probe-zz91")
            .unwrap();
        let second = all
            .iter()
            .position(|e| e.args.contains("https://***@h/r"))
            .unwrap();
        assert!(first < second);
        assert_eq!(all[first].code, Some(1));
        assert!(!all.iter().any(|e| e.args.contains("secret-zz91")));
        assert!(all.len() <= CAPACITY);
    }
}