1use std::fs::{self, File, OpenOptions};
43use std::path::{Path, PathBuf};
44use std::time::{Duration, SystemTime};
45
46use anyhow::{Context, Result};
47use tracing_subscriber::{EnvFilter, fmt, prelude::*};
48
49const DEFAULT_LOG_RETENTION_DAYS: u64 = 7;
50const LOG_RETENTION_ENV: &str = "DEEPSEEK_LOG_RETENTION_DAYS";
51const SECONDS_PER_DAY: u64 = 24 * 60 * 60;
52
53pub struct TuiLogGuard {
57 #[cfg(unix)]
58 saved_stderr_fd: Option<libc::c_int>,
59 #[cfg(windows)]
60 saved_stderr_handle: Option<windows::Win32::Foundation::HANDLE>,
61 #[cfg(windows)]
62 redirected_stderr_handle: Option<windows::Win32::Foundation::HANDLE>,
63 _file: File,
64}
65
66#[cfg(unix)]
67impl Drop for TuiLogGuard {
68 fn drop(&mut self) {
69 if let Some(saved) = self.saved_stderr_fd.take() {
70 unsafe {
75 let _ = libc::dup2(saved, libc::STDERR_FILENO);
76 let _ = libc::close(saved);
77 }
78 }
79 }
80}
81
82#[cfg(windows)]
83impl Drop for TuiLogGuard {
84 fn drop(&mut self) {
85 if let Some(handle) = self.saved_stderr_handle.take() {
86 unsafe {
88 let _ = windows::Win32::System::Console::SetStdHandle(
89 windows::Win32::System::Console::STD_ERROR_HANDLE,
90 handle,
91 );
92 }
93 }
94 if let Some(dup) = self.redirected_stderr_handle.take() {
98 unsafe {
100 let _ = windows::Win32::Foundation::CloseHandle(dup);
101 }
102 }
103 }
104}
105
106#[cfg(not(any(unix, windows)))]
107impl Drop for TuiLogGuard {
108 fn drop(&mut self) {}
109}
110
111pub fn init() -> Result<TuiLogGuard> {
118 let log_dir = log_directory().context("could not resolve TUI log directory")?;
119 fs::create_dir_all(&log_dir)
120 .with_context(|| format!("failed to create {}", log_dir.display()))?;
121 let _ = prune_old_logs(&log_dir, log_retention_days());
122
123 let date = chrono::Local::now().format("%Y-%m-%d").to_string();
124 let log_path = log_dir.join(log_file_name(&date, std::process::id()));
125
126 let file = open_log_file(&log_path)
127 .with_context(|| format!("failed to open {}", log_path.display()))?;
128
129 let subscriber_file = file
134 .try_clone()
135 .context("failed to clone log file handle for subscriber")?;
136
137 let env_filter = EnvFilter::try_from_default_env()
138 .or_else(|_| EnvFilter::try_new("info"))
139 .unwrap_or_else(|_| EnvFilter::new("info"));
140
141 let log_path_clone = log_path.clone();
142 let subscriber = tracing_subscriber::registry().with(env_filter).with(
143 fmt::layer()
144 .with_writer(move || -> Box<dyn std::io::Write + Send> {
145 match subscriber_file.try_clone() {
148 Ok(f) => Box::new(f),
149 Err(e) => {
150 tracing::warn!("Failed to clone log file handle: {e}, reopening");
151 match open_log_file(&log_path_clone) {
152 Ok(f) => Box::new(f),
153 Err(_) => Box::new(std::io::stderr()),
154 }
155 }
156 }
157 })
158 .with_ansi(false)
159 .with_target(true)
160 .with_thread_ids(false),
161 );
162
163 let _ = tracing::subscriber::set_global_default(subscriber);
167
168 #[cfg(unix)]
169 let saved_stderr_fd = redirect_stderr_to(&file).ok();
170 #[cfg(windows)]
171 let (saved_stderr_handle, redirected_stderr_handle) = match redirect_stderr_to(&file) {
172 Ok((saved, dup)) => (Some(saved), Some(dup)),
173 Err(e) => {
174 tracing::warn!("Failed to redirect stderr to log file: {e}");
175 (None, None)
176 }
177 };
178
179 Ok(TuiLogGuard {
180 #[cfg(unix)]
181 saved_stderr_fd,
182 #[cfg(windows)]
183 saved_stderr_handle,
184 #[cfg(windows)]
185 redirected_stderr_handle,
186 _file: file,
187 })
188}
189
190fn open_log_file(path: &Path) -> std::io::Result<std::fs::File> {
195 let mut options = OpenOptions::new();
196 options.create(true).append(true);
197 #[cfg(unix)]
198 {
199 use std::os::unix::fs::OpenOptionsExt as _;
200 options
201 .mode(0o600)
202 .custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC);
203 let file = options.open(path)?;
204 codewhale_config::private_directory::tighten_mode_of(&file, path, 0o600)
211 .map_err(|error| std::io::Error::other(error.to_string()))?;
212 Ok(file)
213 }
214 #[cfg(not(unix))]
215 {
216 options.open(path)
217 }
218}
219
220pub fn log_directory() -> Option<PathBuf> {
221 if let Some(home) = codewhale_paths::codewhale_home_override().ok().flatten() {
229 return Some(home.join("logs"));
230 }
231 let resolve = |base: PathBuf| -> Option<PathBuf> {
232 let primary = base.join(".codewhale").join("logs");
233 if primary.exists() {
234 return Some(primary);
235 }
236 let legacy = base.join(".deepseek").join("logs");
237 if legacy.exists() {
238 return Some(legacy);
239 }
240 Some(primary)
241 };
242 codewhale_paths::user_home().and_then(resolve)
243}
244
245fn log_file_name(date: &str, pid: u32) -> String {
246 format!("tui-{date}-{pid}.log")
247}
248
249fn log_retention_days() -> u64 {
250 std::env::var(LOG_RETENTION_ENV)
251 .ok()
252 .and_then(|raw| raw.trim().parse::<u64>().ok())
253 .filter(|days| *days > 0)
254 .unwrap_or(DEFAULT_LOG_RETENTION_DAYS)
255}
256
257fn prune_old_logs(log_dir: &Path, retention_days: u64) -> std::io::Result<usize> {
258 let retention = Duration::from_secs(retention_days.saturating_mul(SECONDS_PER_DAY));
259 let cutoff = SystemTime::now()
260 .checked_sub(retention)
261 .unwrap_or(SystemTime::UNIX_EPOCH);
262 let mut removed = 0usize;
263
264 for entry in fs::read_dir(log_dir)? {
265 let entry = entry?;
266 if !is_tui_log_file_name(&entry.file_name()) {
267 continue;
268 }
269 let metadata = match entry.metadata() {
270 Ok(metadata) if metadata.is_file() => metadata,
271 _ => continue,
272 };
273 let modified = match metadata.modified() {
274 Ok(modified) => modified,
275 Err(_) => continue,
276 };
277 if modified < cutoff && fs::remove_file(entry.path()).is_ok() {
278 removed += 1;
279 }
280 }
281
282 Ok(removed)
283}
284
285fn is_tui_log_file_name(file_name: &std::ffi::OsStr) -> bool {
286 file_name
287 .to_str()
288 .is_some_and(|name| name.starts_with("tui-") && name.ends_with(".log"))
289}
290
291#[cfg(unix)]
292fn redirect_stderr_to(file: &File) -> Result<libc::c_int> {
293 use std::os::fd::AsRawFd;
294 let target = file.as_raw_fd();
295 unsafe {
299 let saved = libc::dup(libc::STDERR_FILENO);
300 if saved < 0 {
301 return Err(
302 anyhow::Error::from(std::io::Error::last_os_error()).context("dup(STDERR_FILENO)")
303 );
304 }
305 if libc::dup2(target, libc::STDERR_FILENO) < 0 {
306 let err = std::io::Error::last_os_error();
307 let _ = libc::close(saved);
308 return Err(anyhow::Error::from(err).context("dup2(log_file, STDERR_FILENO)"));
309 }
310 Ok(saved)
311 }
312}
313
314#[cfg(windows)]
315fn redirect_stderr_to(
316 file: &File,
317) -> Result<(
318 windows::Win32::Foundation::HANDLE,
319 windows::Win32::Foundation::HANDLE,
320)> {
321 use std::os::windows::io::AsRawHandle;
322 use windows::Win32::Foundation::{CloseHandle, DUPLICATE_SAME_ACCESS, DuplicateHandle, HANDLE};
323 use windows::Win32::System::Console::{GetStdHandle, STD_ERROR_HANDLE, SetStdHandle};
324 use windows::Win32::System::Threading::GetCurrentProcess;
325
326 let saved =
329 unsafe { GetStdHandle(STD_ERROR_HANDLE) }.context("GetStdHandle(STD_ERROR_HANDLE)")?;
330 if saved.is_invalid() {
331 return Err(anyhow::anyhow!("GetStdHandle(STD_ERROR_HANDLE) failed"));
332 }
333
334 let raw = HANDLE(file.as_raw_handle());
339 let process = unsafe { GetCurrentProcess() };
341 let mut dup = HANDLE::default();
342 unsafe {
344 DuplicateHandle(
345 process,
346 raw,
347 process,
348 &mut dup,
349 0,
350 false,
351 DUPLICATE_SAME_ACCESS,
352 )
353 .context("DuplicateHandle for stderr redirect")?;
354 }
355
356 unsafe {
359 if let Err(e) = SetStdHandle(STD_ERROR_HANDLE, dup) {
360 let _ = CloseHandle(dup);
361 return Err(anyhow::anyhow!(
362 "SetStdHandle(STD_ERROR_HANDLE) failed: {e}"
363 ));
364 }
365 }
366 Ok((saved, dup))
367}
368
369#[cfg(test)]
370mod tests {
371 use super::*;
372 use std::fs::FileTimes;
373
374 #[cfg(unix)]
375 #[test]
376 fn log_file_is_owner_only_and_refuses_symlinks() {
377 use std::io::Write as _;
378 use std::os::unix::fs::{PermissionsExt as _, symlink};
379 let tmp = tempfile::TempDir::new().expect("temporary dir");
380 let mode = |path: &Path| {
381 std::fs::metadata(path)
382 .expect("metadata")
383 .permissions()
384 .mode()
385 & 0o777
386 };
387
388 let fresh = tmp.path().join("fresh.log");
389 open_log_file(&fresh)
390 .expect("create")
391 .write_all(b"one\n")
392 .expect("write");
393 assert_eq!(mode(&fresh), 0o600);
394
395 let old = tmp.path().join("old.log");
397 std::fs::write(&old, "before\n").expect("seed");
398 std::fs::set_permissions(&old, std::fs::Permissions::from_mode(0o644)).expect("chmod");
399 open_log_file(&old)
400 .expect("reopen")
401 .write_all(b"after\n")
402 .expect("write");
403 assert_eq!(mode(&old), 0o600);
404 assert_eq!(
405 std::fs::read_to_string(&old).expect("read"),
406 "before\nafter\n"
407 );
408
409 let target = tmp.path().join("target.txt");
411 std::fs::write(&target, "keep").expect("target");
412 std::fs::set_permissions(&target, std::fs::Permissions::from_mode(0o644)).expect("chmod");
413 let link = tmp.path().join("link.log");
414 symlink(&target, &link).expect("symlink");
415 assert!(open_log_file(&link).is_err());
416 assert_eq!(std::fs::read_to_string(&target).expect("read"), "keep");
417 assert_eq!(mode(&target), 0o644);
418 }
419
420 fn set_modified(path: &Path, modified: SystemTime) {
421 let file = OpenOptions::new().write(true).open(path).unwrap();
422 file.set_times(FileTimes::new().set_modified(modified))
423 .unwrap();
424 }
425
426 #[test]
427 fn log_directory_prefers_home() {
428 let _lock = crate::test_support::lock_test_env();
429 let tmp = tempfile::TempDir::new().unwrap();
430 let prev_home = std::env::var_os("HOME");
431 let prev_userprofile = std::env::var_os("USERPROFILE");
432 unsafe {
434 std::env::set_var("HOME", tmp.path());
435 std::env::set_var("USERPROFILE", "");
436 }
437
438 let resolved = log_directory().expect("log_directory should resolve");
439 assert_eq!(resolved, tmp.path().join(".codewhale").join("logs"));
440
441 unsafe {
443 match prev_home {
444 Some(v) => std::env::set_var("HOME", v),
445 None => std::env::remove_var("HOME"),
446 }
447 match prev_userprofile {
448 Some(v) => std::env::set_var("USERPROFILE", v),
449 None => std::env::remove_var("USERPROFILE"),
450 }
451 }
452 }
453
454 #[test]
455 fn log_directory_uses_existing_legacy_deepseek_logs() {
456 let _lock = crate::test_support::lock_test_env();
457 let tmp = tempfile::TempDir::new().unwrap();
458 let legacy = tmp.path().join(".deepseek").join("logs");
459 fs::create_dir_all(&legacy).unwrap();
460 let prev_home = std::env::var_os("HOME");
461 let prev_userprofile = std::env::var_os("USERPROFILE");
462 unsafe {
464 std::env::set_var("HOME", tmp.path());
465 std::env::set_var("USERPROFILE", "");
466 }
467
468 let resolved = log_directory().expect("log_directory should resolve");
469 assert_eq!(resolved, legacy);
470
471 unsafe {
473 match prev_home {
474 Some(v) => std::env::set_var("HOME", v),
475 None => std::env::remove_var("HOME"),
476 }
477 match prev_userprofile {
478 Some(v) => std::env::set_var("USERPROFILE", v),
479 None => std::env::remove_var("USERPROFILE"),
480 }
481 }
482 }
483
484 #[test]
485 fn log_file_name_includes_pid() {
486 assert_eq!(
487 log_file_name("2026-05-18", 12345),
488 "tui-2026-05-18-12345.log"
489 );
490 }
491
492 #[test]
493 fn log_retention_days_uses_positive_env_override() {
494 let _lock = crate::test_support::lock_test_env();
495 let previous = std::env::var_os(LOG_RETENTION_ENV);
496
497 unsafe {
499 std::env::set_var(LOG_RETENTION_ENV, "14");
500 }
501 assert_eq!(log_retention_days(), 14);
502
503 unsafe {
505 std::env::set_var(LOG_RETENTION_ENV, "0");
506 }
507 assert_eq!(log_retention_days(), DEFAULT_LOG_RETENTION_DAYS);
508
509 unsafe {
511 match previous {
512 Some(value) => std::env::set_var(LOG_RETENTION_ENV, value),
513 None => std::env::remove_var(LOG_RETENTION_ENV),
514 }
515 }
516 }
517
518 #[test]
519 fn prune_old_logs_drops_only_stale_tui_logs() {
520 let tmp = tempfile::TempDir::new().unwrap();
521 let fresh = tmp.path().join("tui-2026-05-18-1.log");
522 let stale = tmp.path().join("tui-2026-05-01-2.log");
523 let legacy_stale = tmp.path().join("tui-2026-05-01.log");
524 let unrelated = tmp.path().join("agent-2026-05-01.log");
525
526 fs::write(&fresh, "fresh").unwrap();
527 fs::write(&stale, "stale").unwrap();
528 fs::write(&legacy_stale, "legacy").unwrap();
529 fs::write(&unrelated, "other").unwrap();
530
531 let now = SystemTime::now();
532 let old = now - Duration::from_secs(10 * SECONDS_PER_DAY);
533 set_modified(&stale, old);
534 set_modified(&legacy_stale, old);
535 set_modified(&unrelated, old);
536
537 let removed = prune_old_logs(tmp.path(), 7).unwrap();
538
539 assert_eq!(removed, 2);
540 assert!(fresh.exists());
541 assert!(!stale.exists());
542 assert!(!legacy_stale.exists());
543 assert!(unrelated.exists());
544 }
545
546 #[test]
547 fn log_directory_honors_codewhale_home_as_hard_override() {
548 let _lock = crate::test_support::lock_test_env();
549 let tmp = tempfile::TempDir::new().unwrap();
550 unsafe {
552 std::env::set_var("CODEWHALE_HOME", tmp.path());
553 }
554 let resolved = log_directory().expect("log_directory should resolve");
557 assert_eq!(resolved, tmp.path().join("logs"));
558 unsafe {
560 std::env::remove_var("CODEWHALE_HOME");
561 }
562 }
563}