Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Honor the system clock preference in TUI completion timestamps (#46845)

Eric Traut79ef00ded170
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index b8b31805b8..f10c7ba8a7 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -4847,6 +4847,7 @@ dependencies = [
"lazy_static",
"libc",
"objc2-app-kit",
+ "objc2-foundation",
"pathdiff",
"pretty_assertions",
"pulldown-cmark",
diff --git a/codex-rs/tui/Cargo.toml b/codex-rs/tui/Cargo.toml
index b43c25bf7d..779459bbbf 100644
--- a/codex-rs/tui/Cargo.toml
+++ b/codex-rs/tui/Cargo.toml
@@ -142,6 +142,7 @@ libc = { workspace = true }
[target.'cfg(target_os = "macos")'.dependencies]
objc2-app-kit = { version = "0.3.2", default-features = false, features = ["std", "NSAccessibility", "NSWorkspace"] }
+objc2-foundation = { version = "0.3.2", default-features = false, features = ["std", "NSDateFormatter", "NSFormatter", "NSLocale", "NSString"] }
[target.'cfg(target_os = "linux")'.dependencies]
# Keep the same executor features as the credential store, which also uses zbus.
@@ -151,6 +152,7 @@ zbus = "4.4.0"
which = { workspace = true }
windows-sys = { version = "0.52", features = [
"Win32_Foundation",
+ "Win32_Globalization",
"Win32_Security",
"Win32_Storage_FileSystem",
"Win32_System_Console",
diff --git a/codex-rs/tui/src/app/tests/pagination_completion_tests.rs b/codex-rs/tui/src/app/tests/pagination_completion_tests.rs
index ede94f0a16..a6a30a13e8 100644
--- a/codex-rs/tui/src/app/tests/pagination_completion_tests.rs
+++ b/codex-rs/tui/src/app/tests/pagination_completion_tests.rs
@@ -176,7 +176,12 @@ async fn older_pagination_completion_footers_follow_answers_without_overlap_dupl
.join("\n"),
);
}
- insta::assert_snapshot!(snapshots.join("\n\n--- next overlapping page ---\n\n"));
+ // Canonicalize the fixture's afternoon clock while retaining minute differences.
+ let afternoon_clock = regex_lite::Regex::new(r"at 14:(\d\d)").unwrap();
+ insta::assert_snapshot!(afternoon_clock.replace_all(
+ &snapshots.join("\n\n--- next overlapping page ---\n\n"),
+ "at 2:$1 PM",
+ ));
app_server.shutdown().await?;
proxy.await??;
Ok(())
diff --git a/codex-rs/tui/src/chatwidget/completion.rs b/codex-rs/tui/src/chatwidget/completion.rs
index d538a18628..1778b49135 100644
--- a/codex-rs/tui/src/chatwidget/completion.rs
+++ b/codex-rs/tui/src/chatwidget/completion.rs
@@ -46,7 +46,9 @@ impl ChatWidget {
/*runtime_metrics*/ None,
);
Some(match completed_at {
- Some(completed_at) => cell.with_completed_at(completed_at),
+ Some(completed_at) => {
+ cell.with_completed_at(completed_at, crate::clock_format::ClockFormat::system())
+ }
None => cell,
})
}
diff --git a/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs b/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs
index ae9da4d2f0..acc4d28d40 100644
--- a/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests/completion_styling_tests.rs
@@ -1,6 +1,7 @@
//! Exercises completion metadata through live notifications and restored turn history.
use super::*;
+use crate::clock_format::ClockFormat;
use chrono::Local;
use chrono::TimeZone;
use pretty_assertions::assert_eq;
@@ -56,7 +57,10 @@ fn saved_completion_label() -> String {
Local
.timestamp_opt(COMPLETED_AT, /*nsecs*/ 0)
.unwrap()
- .format("%b %-d, %Y at %-I:%M %p")
+ .format(&format!(
+ "%b %-d, %Y at {}",
+ ClockFormat::system().time_format()
+ ))
.to_string()
}
@@ -109,7 +113,7 @@ async fn completion_live_applies_duration_threshold_and_preserves_timestamp_fall
let time = if completed_at.is_some() {
saved_completion_label()
} else {
- time.format("%-I:%M %p").to_string()
+ time.format(ClockFormat::system().time_format()).to_string()
};
format!("{prefix}{time}")
});
@@ -192,7 +196,11 @@ async fn completion_replay_waits_for_older_turn_items_to_load() {
let older_time = Local
.timestamp_opt(older_completed_at, /*nsecs*/ 0)
.unwrap()
- .format("%b %-d, %Y at %-I:%M %p");
+ .format(&format!(
+ "%b %-d, %Y at {}",
+ ClockFormat::system().time_format()
+ ))
+ .to_string();
assert_eq!(
completion_labels(&mut rx),
format!("Worked for 2m 5s · {older_time}"),
@@ -245,14 +253,19 @@ fn completion_snapshot_normalization_preserves_clock_only_message_lines() {
transcript
);
- let footer =
- history_cell::FinalMessageSeparator::new(Some(3_723), /*runtime_metrics*/ None)
- .with_completed_at(Local.timestamp_opt(COMPLETED_AT, /*nsecs*/ 0).unwrap());
- assert_eq!(
- normalize_completion_timestamps(
- &footer,
- lines_to_single_string(&footer.display_lines(/*width*/ 80))
- ),
- " Worked for [duration] · [completion time]\n"
- );
+ for clock_format in [ClockFormat::TwelveHour, ClockFormat::TwentyFourHour] {
+ let footer =
+ history_cell::FinalMessageSeparator::new(Some(3_723), /*runtime_metrics*/ None)
+ .with_completed_at(
+ Local.timestamp_opt(COMPLETED_AT, /*nsecs*/ 0).unwrap(),
+ clock_format,
+ );
+ assert_eq!(
+ normalize_completion_timestamps(
+ &footer,
+ lines_to_single_string(&footer.display_lines(/*width*/ 80))
+ ),
+ " Worked for [duration] · [completion time]\n"
+ );
+ }
}
diff --git a/codex-rs/tui/src/chatwidget/tests/helpers.rs b/codex-rs/tui/src/chatwidget/tests/helpers.rs
index 84480ac073..2bd49e470f 100644
--- a/codex-rs/tui/src/chatwidget/tests/helpers.rs
+++ b/codex-rs/tui/src/chatwidget/tests/helpers.rs
@@ -1861,7 +1861,7 @@ pub(crate) fn normalize_completion_timestamps(
}
static COMPLETION_FOOTER: std::sync::LazyLock<regex_lite::Regex> = std::sync::LazyLock::new(
|| {
- regex_lite::Regex::new(r"(?m)^(?P<indent>[ \t]*)(?P<duration>Worked for (?:[0-9]+h )?(?:[0-9]+m )?[0-9]+s · )?(?:[A-Z][a-z]{2} [0-9]{1,2}(?:, [0-9]{4})? at )?[0-9]{1,2}:[0-9]{2} (?:AM|PM)(?P<padding>[ \t]*)$")
+ regex_lite::Regex::new(r"(?m)^(?P<indent>[ \t]*)(?P<duration>Worked for (?:[0-9]+h )?(?:[0-9]+m )?[0-9]+s · )?(?:[A-Z][a-z]{2} [0-9]{1,2}(?:, [0-9]{4})? at )?[0-9]{1,2}:[0-9]{2}(?: (?:AM|PM))?(?P<padding>[ \t]*)$")
.expect("valid completion footer pattern")
},
);
diff --git a/codex-rs/tui/src/clock_format.rs b/codex-rs/tui/src/clock_format.rs
new file mode 100644
index 0000000000..50de9f74b6
--- /dev/null
+++ b/codex-rs/tui/src/clock_format.rs
@@ -0,0 +1,191 @@
+//! Detects the TUI host's clock preference once. Unknown preferences preserve 12-hour output;
+//! detection never changes the process locale or runs while rendering a history cell.
+
+use std::sync::OnceLock;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ClockFormat {
+ TwelveHour,
+ TwentyFourHour,
+}
+
+impl ClockFormat {
+ pub(crate) fn system() -> Self {
+ static FORMAT: OnceLock<ClockFormat> = OnceLock::new();
+ *FORMAT.get_or_init(|| detect().unwrap_or(Self::TwelveHour))
+ }
+
+ pub(crate) fn time_format(self) -> &'static str {
+ match self {
+ Self::TwelveHour => "%-I:%M %p",
+ Self::TwentyFourHour => "%H:%M",
+ }
+ }
+}
+
+#[cfg(any(target_os = "linux", target_os = "android", test))]
+fn time_locale(
+ mut get: impl FnMut(&str) -> Option<std::ffi::OsString>,
+) -> Option<std::ffi::OsString> {
+ ["LC_ALL", "LC_TIME", "LANG"]
+ .into_iter()
+ .find_map(|name| get(name).filter(|value| !value.is_empty()))
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn detect() -> Option<ClockFormat> {
+ let locale = time_locale(|name| std::env::var_os(name))?;
+ detect_time_locale(locale.to_str()?)
+}
+
+#[cfg(any(target_os = "linux", target_os = "android", test))]
+fn detect_time_locale(locale: &str) -> Option<ClockFormat> {
+ if matches!(locale, "C" | "POSIX" | "C.UTF-8" | "C.utf8") {
+ return Some(ClockFormat::TwentyFourHour);
+ }
+ #[cfg(all(target_os = "linux", target_env = "gnu"))]
+ {
+ let name = std::ffi::CString::new(locale).ok()?;
+ // SAFETY: name is NUL-terminated, the mask is valid, and a null base creates
+ // an independent locale. Its borrowed pattern is read before freeing it.
+ unsafe {
+ let locale = libc::newlocale(libc::LC_TIME_MASK, name.as_ptr(), std::ptr::null_mut());
+ if locale.is_null() {
+ return None;
+ }
+ let pattern = libc::nl_langinfo_l(libc::T_FMT, locale);
+ let result = if pattern.is_null() {
+ None
+ } else {
+ parse_strftime(std::ffi::CStr::from_ptr(pattern).to_bytes())
+ };
+ libc::freelocale(locale);
+ result
+ }
+ }
+ // musl and bionic can return C patterns for unsupported locales. Do not
+ // mistake that fallback for the user's actual clock preference.
+ #[cfg(not(all(target_os = "linux", target_env = "gnu")))]
+ None
+}
+
+#[cfg(any(all(target_os = "linux", target_env = "gnu"), test))]
+fn parse_strftime(pattern: &[u8]) -> Option<ClockFormat> {
+ let mut chars = pattern.iter().copied().peekable();
+ let mut twelve = false;
+ let mut twenty_four = false;
+ while let Some(ch) = chars.next() {
+ if ch != b'%' {
+ continue;
+ }
+ while chars
+ .next_if(|ch| matches!(ch, b'_' | b'-' | b'0' | b'^' | b'#') || ch.is_ascii_digit())
+ .is_some()
+ {}
+ chars.next_if(|ch| matches!(ch, b'E' | b'O'));
+ match chars.next()? {
+ b'I' | b'l' | b'r' => twelve = true,
+ b'H' | b'k' | b'R' | b'T' => twenty_four = true,
+ b'%' | b'M' | b'S' | b'p' | b'P' | b'Z' | b'z' | b'n' | b't' => {}
+ // In particular, do not recurse into %X or %c.
+ _ => return None,
+ }
+ }
+ match (twelve, twenty_four) {
+ (true, false) => Some(ClockFormat::TwelveHour),
+ (false, true) => Some(ClockFormat::TwentyFourHour),
+ _ => None,
+ }
+}
+
+#[cfg(target_os = "macos")]
+fn detect() -> Option<ClockFormat> {
+ use objc2_foundation::NSDateFormatter;
+ use objc2_foundation::NSLocale;
+ use objc2_foundation::NSString;
+
+ let locale = NSLocale::currentLocale();
+ let pattern = NSDateFormatter::dateFormatFromTemplate_options_locale(
+ &NSString::from_str("j"),
+ /*opts*/ 0,
+ Some(&locale),
+ )?;
+ parse_native_pattern(&pattern.to_string(), "hHKk")
+}
+
+#[cfg(windows)]
+fn detect() -> Option<ClockFormat> {
+ use windows_sys::Win32::Globalization::GetLocaleInfoEx;
+ use windows_sys::Win32::Globalization::LOCALE_SSHORTTIME;
+
+ // SAFETY: the first call queries the size; the second receives a writable
+ // buffer of that size. A null locale name selects the user's default locale,
+ // and user overrides remain enabled.
+ let pattern = unsafe {
+ let length = GetLocaleInfoEx(
+ std::ptr::null(),
+ LOCALE_SSHORTTIME,
+ std::ptr::null_mut(),
+ /*cchdata*/ 0,
+ );
+ if length <= 1 {
+ return None;
+ }
+ let mut buffer = vec![0; length as usize];
+ let written = GetLocaleInfoEx(
+ std::ptr::null(),
+ LOCALE_SSHORTTIME,
+ buffer.as_mut_ptr(),
+ length,
+ );
+ if written <= 1 {
+ return None;
+ }
+ String::from_utf16(&buffer[..written as usize - 1]).ok()?
+ };
+ parse_native_pattern(&pattern, "hH")
+}
+
+#[cfg(any(target_os = "macos", windows, test))]
+fn parse_native_pattern(pattern: &str, hour_symbols: &str) -> Option<ClockFormat> {
+ let mut quoted = false;
+ let mut twelve = false;
+ let mut twenty_four = false;
+ for ch in pattern.chars() {
+ if ch == '\'' {
+ // Two adjacent apostrophes restore the quote state, representing
+ // a literal apostrophe in both native pattern syntaxes.
+ quoted = !quoted;
+ } else if !quoted {
+ if ch == ';' {
+ break; // Windows lists the preferred pattern first.
+ }
+ if hour_symbols.contains(ch) {
+ match ch {
+ 'h' | 'K' => twelve = true,
+ 'H' | 'k' => twenty_four = true,
+ _ => return None,
+ }
+ }
+ }
+ }
+ match (quoted, twelve, twenty_four) {
+ (false, true, false) => Some(ClockFormat::TwelveHour),
+ (false, false, true) => Some(ClockFormat::TwentyFourHour),
+ _ => None,
+ }
+}
+
+#[cfg(not(any(
+ target_os = "linux",
+ target_os = "android",
+ target_os = "macos",
+ windows
+)))]
+fn detect() -> Option<ClockFormat> {
+ None
+}
+
+#[cfg(test)]
+#[path = "clock_format_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/clock_format_tests.rs b/codex-rs/tui/src/clock_format_tests.rs
new file mode 100644
index 0000000000..fe2aaf7097
--- /dev/null
+++ b/codex-rs/tui/src/clock_format_tests.rs
@@ -0,0 +1,99 @@
+//! Preference precedence and native pattern parsing without changing host settings.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn time_locale_uses_first_nonempty_setting() {
+ for (values, expected) in [
+ (
+ [Some("C"), Some("en_US.UTF-8"), Some("de_DE.UTF-8")],
+ Some("C"),
+ ),
+ (
+ [Some(""), Some("C.UTF-8"), Some("en_US.UTF-8")],
+ Some("C.UTF-8"),
+ ),
+ ([None, Some(""), Some("C.utf8")], Some("C.utf8")),
+ ([Some("invalid"), Some("C"), None], Some("invalid")),
+ ([None, Some(""), None], None),
+ ] {
+ let environment = ["LC_ALL", "LC_TIME", "LANG"].into_iter().zip(values);
+ assert_eq!(
+ time_locale(|name| environment
+ .clone()
+ .find(|(key, _)| *key == name)
+ .unwrap()
+ .1
+ .map(Into::into)),
+ expected.map(std::ffi::OsString::from),
+ );
+ }
+}
+
+#[test]
+fn standard_locales_and_unavailable_locales() {
+ for locale in ["C", "POSIX", "C.UTF-8", "C.utf8"] {
+ assert_eq!(
+ detect_time_locale(locale),
+ Some(ClockFormat::TwentyFourHour)
+ );
+ }
+ for locale in [
+ "codex_missing_locale",
+ "C.codex_missing_encoding",
+ "invalid\0locale",
+ ] {
+ assert_eq!(detect_time_locale(locale), None);
+ }
+ #[cfg(not(all(target_os = "linux", target_env = "gnu")))]
+ assert_eq!(detect_time_locale("de_DE.UTF-8"), None);
+}
+
+#[test]
+fn strftime_hour_fields_determine_the_clock() {
+ for (pattern, expected) in [
+ ("%I:%M:%S %p", Some(ClockFormat::TwelveHour)),
+ ("%l:%M %P", Some(ClockFormat::TwelveHour)),
+ ("%r", Some(ClockFormat::TwelveHour)),
+ ("%H:%M:%S", Some(ClockFormat::TwentyFourHour)),
+ ("%k:%M", Some(ClockFormat::TwentyFourHour)),
+ ("%R", Some(ClockFormat::TwentyFourHour)),
+ ("%T %Z", Some(ClockFormat::TwentyFourHour)),
+ ("%%I %_2OH:%M", Some(ClockFormat::TwentyFourHour)),
+ ("%%H %-I:%M", Some(ClockFormat::TwelveHour)),
+ ("%H %I", None),
+ ("%H %X", None),
+ ("%H %", None),
+ ("%H %Q", None),
+ ("%p", None),
+ ("%%H", None),
+ ("", None),
+ ] {
+ assert_eq!(parse_strftime(pattern.as_bytes()), expected, "{pattern}");
+ }
+}
+
+#[test]
+fn native_patterns_ignore_literals_and_use_the_first_alternative() {
+ for (pattern, symbols, expected) in [
+ ("h:mm tt", "hH", Some(ClockFormat::TwelveHour)),
+ ("HH:mm", "hH", Some(ClockFormat::TwentyFourHour)),
+ ("h 'H; o''clock' a", "hHKk", Some(ClockFormat::TwelveHour)),
+ ("'h' HH:mm;h:mm tt", "hH", Some(ClockFormat::TwentyFourHour)),
+ ("h:mm tt;HH:mm", "hH", Some(ClockFormat::TwelveHour)),
+ ("K a", "hHKk", Some(ClockFormat::TwelveHour)),
+ ("kk", "hHKk", Some(ClockFormat::TwentyFourHour)),
+ ("K HH:mm", "hH", Some(ClockFormat::TwentyFourHour)),
+ ("h 'unterminated", "hH", None),
+ ("h HH", "hH", None),
+ ("'HH' mm", "hH", None),
+ ("", "hH", None),
+ ] {
+ assert_eq!(
+ parse_native_pattern(pattern, symbols),
+ expected,
+ "{pattern}"
+ );
+ }
+}
diff --git a/codex-rs/tui/src/history_cell/separators.rs b/codex-rs/tui/src/history_cell/separators.rs
index 2019581603..c1df99746f 100644
--- a/codex-rs/tui/src/history_cell/separators.rs
+++ b/codex-rs/tui/src/history_cell/separators.rs
@@ -1,6 +1,7 @@
//! Subtle completion timestamps, elapsed durations, and runtime metrics for transcript history.
use super::*;
+use crate::clock_format::ClockFormat;
use chrono::DateTime;
use chrono::Datelike;
use chrono::Local;
@@ -9,7 +10,7 @@ use chrono::NaiveDate;
/// Completion metadata shown after the assistant's final response.
///
/// The timestamp records when the turn actually finished, including when restored from history.
-/// Times use a twelve-hour clock; other local days include the date and other years include the year.
+/// Times use the host's clock preference; other local days include the date and other years the year.
/// Durations are shown only above sixty seconds; shorter turns still show their timestamp.
/// Absent metadata occupies no transcript rows.
/// The display date is fixed at construction so crossing midnight cannot invalidate cached heights;
@@ -20,6 +21,7 @@ pub struct FinalMessageSeparator {
runtime_metrics: Option<RuntimeMetricsSummary>,
completed_at: Option<DateTime<Local>>,
display_date: NaiveDate,
+ clock_format: ClockFormat,
}
impl FinalMessageSeparator {
/// Creates completion metadata using the protocol turn duration when available.
@@ -32,11 +34,17 @@ impl FinalMessageSeparator {
runtime_metrics,
completed_at: None,
display_date: Local::now().date_naive(),
+ clock_format: ClockFormat::TwelveHour,
}
}
- pub(crate) fn with_completed_at(mut self, completed_at: DateTime<Local>) -> Self {
+ pub(crate) fn with_completed_at(
+ mut self,
+ completed_at: DateTime<Local>,
+ clock_format: ClockFormat,
+ ) -> Self {
self.completed_at = Some(completed_at);
+ self.clock_format = clock_format;
self
}
@@ -64,14 +72,18 @@ impl FinalMessageSeparator {
label_parts.push(format!("Worked for {elapsed}"));
}
if let Some(completed_at) = self.completed_at {
- let format = if completed_at.date_naive() == today {
- "%-I:%M %p"
+ let date_format = if completed_at.date_naive() == today {
+ ""
} else if completed_at.year() == today.year() {
- "%b %-d at %-I:%M %p"
+ "%b %-d at "
} else {
- "%b %-d, %Y at %-I:%M %p"
+ "%b %-d, %Y at "
};
- label_parts.push(completed_at.format(format).to_string());
+ label_parts.push(format!(
+ "{}{}",
+ completed_at.format(date_format),
+ completed_at.format(self.clock_format.time_format()),
+ ));
}
if let Some(metrics_label) = self.runtime_metrics.and_then(runtime_metrics_label) {
label_parts.push(metrics_label);
diff --git a/codex-rs/tui/src/history_cell/separators_tests.rs b/codex-rs/tui/src/history_cell/separators_tests.rs
index b727fb1b3d..4770cb324c 100644
--- a/codex-rs/tui/src/history_cell/separators_tests.rs
+++ b/codex-rs/tui/src/history_cell/separators_tests.rs
@@ -33,7 +33,7 @@ fn completion_label_shows_duration_only_above_sixty_seconds() {
.into_iter()
.map(|elapsed_seconds| {
FinalMessageSeparator::new(elapsed_seconds, /*runtime_metrics*/ None)
- .with_completed_at(completed_at)
+ .with_completed_at(completed_at, ClockFormat::TwelveHour)
.label(completed_at.date_naive())
.expect("completion label")
})
@@ -57,7 +57,7 @@ fn completion_label_includes_date_when_viewed_on_another_day() {
/*elapsed_seconds*/ Some(125),
/*runtime_metrics*/ None,
)
- .with_completed_at(completed_at);
+ .with_completed_at(completed_at, ClockFormat::TwelveHour);
let tomorrow = completed_at.date_naive().succ_opt().expect("next day");
insta::assert_snapshot!(cell.label(tomorrow).expect("completion label"), @"Worked for 2m 5s · Sep 6 at 2:32 PM");
@@ -70,7 +70,7 @@ fn completion_uses_twelve_hour_time_at_midnight_noon_and_afternoon() {
let labels = [0, 12, 15].map(|hour| {
let completed_at = completed_at().with_hour(hour).expect("valid hour");
FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)
- .with_completed_at(completed_at)
+ .with_completed_at(completed_at, ClockFormat::TwelveHour)
.label(completed_at.date_naive())
.expect("completion label")
});
@@ -81,6 +81,39 @@ fn completion_uses_twelve_hour_time_at_midnight_noon_and_afternoon() {
");
}
+#[test]
+fn completion_uses_twenty_four_hour_time_with_dates_and_wrapping() {
+ let today = completed_at().date_naive();
+ let tomorrow = today.succ_opt().unwrap();
+ let next_year = today.with_year(/*year*/ 2001).unwrap();
+ let mut labels = Vec::new();
+ for hour in [0, 12, 23] {
+ let completed_at = completed_at()
+ .with_hour(hour)
+ .unwrap()
+ .with_minute(/*min*/ 25)
+ .unwrap();
+ let mut cell = FinalMessageSeparator::new(Some(125), /*runtime_metrics*/ None)
+ .with_completed_at(completed_at, ClockFormat::TwentyFourHour);
+ for date in [today, tomorrow, next_year] {
+ labels.push(cell.label(date).unwrap());
+ }
+ cell.display_date = next_year;
+ labels.push(
+ cell.display_lines(/*width*/ 24)
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<_>>()
+ .join("\n"),
+ );
+ assert_eq!(
+ cell.raw_lines(),
+ vec![Line::from(cell.label(next_year).unwrap())]
+ );
+ }
+ insta::assert_snapshot!(labels.join("\n"));
+}
+
#[test]
fn completion_without_metadata_has_no_visible_or_raw_lines() {
let cell =
@@ -104,7 +137,7 @@ fn completion_wraps_metadata_and_preserves_unwrapped_raw_text() {
/*elapsed_seconds*/ Some(125),
/*runtime_metrics*/ None,
)
- .with_completed_at(completed_at())
+ .with_completed_at(completed_at(), ClockFormat::TwelveHour)
.with_runtime_metrics(Some(RuntimeMetricsSummary {
tool_calls: RuntimeMetricTotals {
count: 3,
@@ -135,7 +168,7 @@ fn completion_wraps_metadata_and_preserves_unwrapped_raw_text() {
fn completion_renders_with_dim_default_colors() {
let cell: Box<dyn HistoryCell> = Box::new(
FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)
- .with_completed_at(completed_at()),
+ .with_completed_at(completed_at(), ClockFormat::TwelveHour),
);
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 1,
@@ -160,7 +193,7 @@ fn completion_rendering_uses_the_captured_display_date() {
let completed_at = completed_at();
let mut cell =
FinalMessageSeparator::new(/*elapsed_seconds*/ None, /*runtime_metrics*/ None)
- .with_completed_at(completed_at);
+ .with_completed_at(completed_at, ClockFormat::TwelveHour);
cell.display_date = completed_at.date_naive();
insta::assert_snapshot!(cell.display_lines(/*width*/ 80)[0].to_string(), @" 2:32 PM");
diff --git a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__separators__tests__completion_uses_twenty_four_hour_time_with_dates_and_wrapping.snap b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__separators__tests__completion_uses_twenty_four_hour_time_with_dates_and_wrapping.snap
new file mode 100644
index 0000000000..0897371be0
--- /dev/null
+++ b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__separators__tests__completion_uses_twenty_four_hour_time_with_dates_and_wrapping.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/history_cell/separators_tests.rs
+assertion_line: 101
+expression: "labels.join(\"\\n\")"
+---
+Worked for 2m 5s · 00:25
+Worked for 2m 5s · Sep 6 at 00:25
+Worked for 2m 5s · Sep 6, 2000 at 00:25
+ Worked for 2m 5s · Sep
+ 6, 2000 at 00:25
+Worked for 2m 5s · 12:25
+Worked for 2m 5s · Sep 6 at 12:25
+Worked for 2m 5s · Sep 6, 2000 at 12:25
+ Worked for 2m 5s · Sep
+ 6, 2000 at 12:25
+Worked for 2m 5s · 23:25
+Worked for 2m 5s · Sep 6 at 23:25
+Worked for 2m 5s · Sep 6, 2000 at 23:25
+ Worked for 2m 5s · Sep
+ 6, 2000 at 23:25
diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs
index afacb0a286..e602ca2018 100644
--- a/codex-rs/tui/src/lib.rs
+++ b/codex-rs/tui/src/lib.rs
@@ -121,6 +121,7 @@ mod cli;
mod clipboard_copy;
mod clipboard_html;
mod clipboard_paste;
+mod clock_format;
mod collaboration_modes;
mod color;
mod config_update;