Merge branch 'main' into max/add-dataset-snapshots

Author: max-braintrust

src/config/mod.rs

@@ -202,17 +202,15 @@ pub(crate) fn trimmed_option(value: Option<&str>) -> Option<&str> {
 }
 
 pub fn save_file(path: &Path, config: &Config) -> Result<()> {
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)?;
-    }
+    let parent = path.parent().unwrap_or_else(|| Path::new("."));
+    fs::create_dir_all(parent)?;
 
     let json = serde_json::to_string_pretty(config)?;
-    let temp_path = path.with_extension("tmp");
-    let mut file = fs::File::create(&temp_path)?;
+    let mut file = tempfile::NamedTempFile::new_in(parent)?;
     file.write_all(json.as_bytes())?;
     file.write_all(b"\n")?;
-    file.sync_all()?;
-    fs::rename(&temp_path, path)?;
+    file.as_file().sync_all()?;
+    file.persist(path)?;
 
     Ok(())
 }

src/sync.rs

@@ -26,6 +26,7 @@ use crate::experiments::api::create_experiment;
 use crate::http::ApiClient;
 use crate::projects::api::{create_project, list_projects, Project};
 use crate::ui::{animations_enabled, fuzzy_select, is_quiet};
+use crate::utils::parse_duration_to_seconds;
 
 const STATE_SCHEMA_VERSION: u32 = 1;
 const DEFAULT_PULL_LIMIT: usize = 100;
@@ -2615,16 +2616,20 @@ fn parse_duration_to_seconds(input: &str) -> Result<u64> {
         return Ok(seconds);
     }
 
-    let (num_str, unit) = trimmed.split_at(trimmed.len().saturating_sub(1));
+    let suffix = trimmed.chars().last().filter(|ch| ch.is_ascii_alphabetic());
+    let (num_str, unit) = match suffix {
+        Some(unit) => (&trimmed[..trimmed.len() - unit.len_utf8()], unit),
+        None => (trimmed, 's'),
+    };
     let value: u64 = num_str
         .trim()
         .parse()
         .with_context(|| format!("invalid duration '{input}'"))?;
-    let multiplier = match unit.to_ascii_lowercase().as_str() {
-        "s" => 1,
-        "m" => 60,
-        "h" => 60 * 60,
-        "d" => 60 * 60 * 24,
+    let multiplier = match unit.to_ascii_lowercase() {
+        's' => 1,
+        'm' => 60,
+        'h' => 60 * 60,
+        'd' => 60 * 60 * 24,
         _ => bail!("invalid duration '{input}'. expected suffix s/m/h/d"),
     };
     Ok(value.saturating_mul(multiplier))
@@ -4291,6 +4296,14 @@ fn spinner_bar(message: &str) -> ProgressBar {
 mod tests {
     use super::*;
 
+    #[test]
+    fn parse_duration_to_seconds_rejects_non_ascii_suffix_without_panicking() {
+        for input in ["1–", "1é", "1🙂"] {
+            let err = parse_duration_to_seconds(input).expect_err("invalid unicode suffix");
+            assert!(err.to_string().contains("invalid duration"));
+        }
+    }
+
     #[test]
     fn push_checkpoint_line_offset_advances_only_after_commit() {
         let mut state =

src/traces.rs

@@ -36,6 +36,7 @@ use crate::args::BaseArgs;
 use crate::auth::{self, login};
 use crate::http::ApiClient;
 use crate::ui::{fuzzy_select, is_interactive, with_spinner};
+use crate::utils::parse_duration_to_seconds;
 
 const MAX_TRACE_SPANS: usize = 5000;
 const MAX_BTQL_PAGE_LIMIT: usize = 1000;
@@ -5039,16 +5040,20 @@ fn parse_duration_to_seconds(input: &str) -> Result<u64> {
         return Ok(seconds);
     }
 
-    let (num_str, unit) = trimmed.split_at(trimmed.len().saturating_sub(1));
+    let suffix = trimmed.chars().last().filter(|ch| ch.is_ascii_alphabetic());
+    let (num_str, unit) = match suffix {
+        Some(unit) => (&trimmed[..trimmed.len() - unit.len_utf8()], unit),
+        None => (trimmed, 's'),
+    };
     let value: u64 = num_str
         .trim()
         .parse()
         .with_context(|| format!("invalid duration '{input}'"))?;
-    let multiplier = match unit.to_ascii_lowercase().as_str() {
-        "s" => 1,
-        "m" => 60,
-        "h" => 60 * 60,
-        "d" => 60 * 60 * 24,
+    let multiplier = match unit.to_ascii_lowercase() {
+        's' => 1,
+        'm' => 60,
+        'h' => 60 * 60,
+        'd' => 60 * 60 * 24,
         _ => bail!("invalid duration '{input}'. expected suffix s/m/h/d"),
     };
     Ok(value.saturating_mul(multiplier))
@@ -6187,6 +6192,14 @@ mod tests {
         assert_eq!(parse_duration_to_seconds("1d").expect("days"), 86_400);
     }
 
+    #[test]
+    fn parse_duration_to_seconds_rejects_non_ascii_suffix_without_panicking() {
+        for input in ["1–", "1é", "1🙂"] {
+            let err = parse_duration_to_seconds(input).expect_err("invalid unicode suffix");
+            assert!(err.to_string().contains("invalid duration"));
+        }
+    }
+
     #[test]
     fn build_base_filter_clause_uses_window_or_since() {
         let from_window = build_base_filter_clause(None, "1h", Some("metadata.model IS NOT NULL"))

src/utils/duration.rs

@@ -0,0 +1,50 @@
+use anyhow::{bail, Context, Result};
+
+pub fn parse_duration_to_seconds(input: &str) -> Result<u64> {
+    let trimmed = input.trim();
+    if trimmed.is_empty() {
+        bail!("duration cannot be empty");
+    }
+    if let Ok(seconds) = trimmed.parse::<u64>() {
+        return Ok(seconds);
+    }
+
+    let suffix = trimmed.chars().last().filter(|ch| ch.is_ascii_alphabetic());
+    let (num_str, unit) = match suffix {
+        Some(unit) => (&trimmed[..trimmed.len() - unit.len_utf8()], unit),
+        None => (trimmed, 's'),
+    };
+    let value: u64 = num_str
+        .trim()
+        .parse()
+        .with_context(|| format!("invalid duration '{input}'"))?;
+    let multiplier = match unit.to_ascii_lowercase() {
+        's' => 1,
+        'm' => 60,
+        'h' => 60 * 60,
+        'd' => 60 * 60 * 24,
+        _ => bail!("invalid duration '{input}'. expected suffix s/m/h/d"),
+    };
+    Ok(value.saturating_mul(multiplier))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn supports_units() {
+        assert_eq!(parse_duration_to_seconds("90").expect("seconds"), 90);
+        assert_eq!(parse_duration_to_seconds("15m").expect("minutes"), 900);
+        assert_eq!(parse_duration_to_seconds("2h").expect("hours"), 7_200);
+        assert_eq!(parse_duration_to_seconds("1d").expect("days"), 86_400);
+    }
+
+    #[test]
+    fn rejects_non_ascii_suffix_without_panicking() {
+        for input in ["1–", "1é", "1🙂"] {
+            let err = parse_duration_to_seconds(input).expect_err("invalid unicode suffix");
+            assert!(err.to_string().contains("invalid duration"));
+        }
+    }
+}

src/utils/mod.rs

@@ -1,10 +1,12 @@
+mod duration;
 mod fs_atomic;
 mod git;
 mod ids;
 mod json_object;
 mod plurals;
 mod profile;
 
+pub use duration::parse_duration_to_seconds;
 pub use fs_atomic::write_text_atomic;
 pub use git::GitRepo;
 pub(crate) use ids::new_uuid_id;