yapper 0.4.0

A modern, ergonomic UART serial TUI terminal for embedded workflows
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

use std::fs::{self, File, OpenOptions};
use std::io::Write;
use std::path::PathBuf;

use chrono::Local;

/// Session logger that writes serial output to a file.
pub struct SessionLogger {
    file: Option<File>,
    file_path: Option<PathBuf>,
    format: LogFormat,
    pub is_active: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub enum LogFormat {
    /// Raw bytes as received.
    Raw,
    /// Lines prefixed with timestamps.
    Timestamped,
}

impl SessionLogger {
    pub fn new() -> Self {
        Self {
            file: None,
            file_path: None,
            format: LogFormat::Timestamped,
            is_active: false,
        }
    }

    /// Start logging to a file. Creates a new timestamped log file.
    pub fn start(&mut self) -> Result<PathBuf, String> {
        let log_dir = dirs::data_dir()
            .map(|d| d.join("yapper").join("logs"))
            .ok_or_else(|| "Could not determine data directory".to_string())?;

        fs::create_dir_all(&log_dir)
            .map_err(|e| format!("Failed to create log directory: {}", e))?;

        let timestamp = Local::now().format("%Y%m%d_%H%M%S");
        let filename = format!("yapper_{}.log", timestamp);
        let path = log_dir.join(&filename);

        let file = OpenOptions::new()
            .create(true)
            .write(true)
            .append(true)
            .open(&path)
            .map_err(|e| format!("Failed to create log file: {}", e))?;

        self.file = Some(file);
        self.file_path = Some(path.clone());
        self.is_active = true;

        // Write header
        self.write_line(&format!(
            "--- yapper session started at {} ---",
            Local::now().format("%Y-%m-%d %H:%M:%S")
        ));

        Ok(path)
    }

    /// Stop logging.
    pub fn stop(&mut self) {
        if self.is_active {
            self.write_line(&format!(
                "--- yapper session ended at {} ---",
                Local::now().format("%Y-%m-%d %H:%M:%S")
            ));
        }
        self.file = None;
        self.is_active = false;
    }

    /// Toggle logging on/off.
    pub fn toggle(&mut self) -> Result<Option<PathBuf>, String> {
        if self.is_active {
            self.stop();
            Ok(None)
        } else {
            self.start().map(Some)
        }
    }

    /// Log raw bytes.
    pub fn log_bytes(&mut self, data: &[u8]) {
        if !self.is_active {
            return;
        }

        if let Some(file) = &mut self.file {
            match self.format {
                LogFormat::Raw => {
                    let _ = file.write_all(data);
                }
                LogFormat::Timestamped => {
                    // For timestamped mode, we write as UTF-8 text
                    if let Ok(text) = std::str::from_utf8(data) {
                        let _ = write!(file, "{}", text);
                    } else {
                        let _ = file.write_all(data);
                    }
                }
            }
            let _ = file.flush();
        }
    }

    /// Write a metadata line to the log.
    fn write_line(&mut self, line: &str) {
        if let Some(file) = &mut self.file {
            let _ = writeln!(file, "{}", line);
            let _ = file.flush();
        }
    }

    /// Get the current log file path.
    pub fn file_path(&self) -> Option<&PathBuf> {
        self.file_path.as_ref()
    }
}