Skip to main content

tea_coding/config/
file.rs

1use std::ffi::OsString;
2use std::fs::{self, File, OpenOptions};
3use std::io::{self, Write as _};
4use std::path::{Path, PathBuf};
5use std::sync::atomic::{AtomicU64, Ordering};
6
7use serde_json::{Map, Value};
8use tea_protocol::{ModelRef, ReasoningEffort};
9
10use crate::config::SettingsLayer;
11use crate::{CodingError, CodingErrorCode};
12
13/// Maximum encoded settings file bytes.
14pub const MAX_SETTINGS_FILE_BYTES: usize = 256 * 1024;
15
16static SETTINGS_TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
17
18/// Loads one optional strict JSON settings layer.
19///
20/// # Errors
21///
22/// Rejects oversized, invalid UTF-8/JSON, unknown-field, and unsupported-version files.
23pub fn load_settings_file(path: &Path) -> Result<Option<SettingsLayer>, CodingError> {
24    let Some(bytes) = read_optional(path)? else {
25        return Ok(None);
26    };
27    parse_settings(&bytes).map(Some)
28}
29
30/// Atomically updates only the global model and reasoning defaults.
31///
32/// Existing unrelated sparse settings are preserved. A missing file is created
33/// with the current schema version and private permissions.
34///
35/// # Errors
36///
37/// Rejects invalid or oversized existing settings and reports durable-write
38/// failures without replacing the old file before the atomic rename succeeds.
39pub fn persist_global_model_settings(
40    path: &Path,
41    model: &ModelRef,
42    reasoning_effort: ReasoningEffort,
43) -> Result<(), CodingError> {
44    let mut document = match read_optional(path)? {
45        Some(bytes) => {
46            parse_settings(&bytes)?;
47            serde_json::from_slice::<Value>(&bytes).map_err(|_| invalid())?
48        }
49        None => Value::Object(Map::from_iter([(
50            "schemaVersion".to_owned(),
51            Value::from(crate::config::CODING_SETTINGS_SCHEMA_VERSION),
52        )])),
53    };
54    let object = document.as_object_mut().ok_or_else(invalid)?;
55    object.insert(
56        "provider".to_owned(),
57        Value::String(model.provider_id().to_string()),
58    );
59    object.insert(
60        "model".to_owned(),
61        Value::String(model.model_id().to_string()),
62    );
63    object.insert(
64        "thinking".to_owned(),
65        Value::String(reasoning_effort.as_str().to_owned()),
66    );
67    let mut encoded = serde_json::to_vec_pretty(&document).map_err(|_| persistence_write())?;
68    encoded.push(b'\n');
69    if encoded.len() > MAX_SETTINGS_FILE_BYTES {
70        return Err(invalid());
71    }
72    atomic_write(path, &encoded).map_err(|_| persistence_write())
73}
74
75fn read_optional(path: &Path) -> Result<Option<Vec<u8>>, CodingError> {
76    let bytes = match fs::read(path) {
77        Ok(bytes) => bytes,
78        Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
79        Err(_) => return Err(persistence()),
80    };
81    if bytes.len() > MAX_SETTINGS_FILE_BYTES {
82        return Err(invalid());
83    }
84    Ok(Some(bytes))
85}
86
87fn parse_settings(bytes: &[u8]) -> Result<SettingsLayer, CodingError> {
88    let layer = serde_json::from_slice::<SettingsLayer>(bytes).map_err(|_| invalid())?;
89    if layer
90        .schema_version
91        .is_some_and(|version| version != crate::config::CODING_SETTINGS_SCHEMA_VERSION)
92    {
93        return Err(invalid());
94    }
95    Ok(layer)
96}
97
98fn atomic_write(path: &Path, bytes: &[u8]) -> io::Result<()> {
99    atomic_write_with(path, bytes, |from, to| fs::rename(from, to))
100}
101
102fn atomic_write_with(
103    path: &Path,
104    bytes: &[u8],
105    rename: impl FnOnce(&Path, &Path) -> io::Result<()>,
106) -> io::Result<()> {
107    let parent = path
108        .parent()
109        .filter(|parent| !parent.as_os_str().is_empty())
110        .unwrap_or_else(|| Path::new("."));
111    let file_name = path
112        .file_name()
113        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "missing settings filename"))?;
114    let (temporary_path, mut temporary) = create_temporary(parent, file_name)?;
115    let result = (|| {
116        temporary.write_all(bytes)?;
117        temporary.sync_all()?;
118        drop(temporary);
119        rename(&temporary_path, path)?;
120        sync_directory(parent)
121    })();
122    if result.is_err() {
123        let _ = fs::remove_file(&temporary_path);
124    }
125    result
126}
127
128fn create_temporary(parent: &Path, file_name: &std::ffi::OsStr) -> io::Result<(PathBuf, File)> {
129    for _ in 0..32 {
130        let sequence = SETTINGS_TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
131        let mut temporary_name = OsString::from(".");
132        temporary_name.push(file_name);
133        temporary_name.push(format!(".{}.{}.tmp", std::process::id(), sequence));
134        let temporary_path = parent.join(temporary_name);
135        let mut options = OpenOptions::new();
136        options.write(true).create_new(true);
137        #[cfg(unix)]
138        {
139            use std::os::unix::fs::OpenOptionsExt as _;
140            options.mode(0o600);
141        }
142        match options.open(&temporary_path) {
143            Ok(file) => return Ok((temporary_path, file)),
144            Err(error) if error.kind() == io::ErrorKind::AlreadyExists => {}
145            Err(error) => return Err(error),
146        }
147    }
148    Err(io::Error::new(
149        io::ErrorKind::AlreadyExists,
150        "settings temporary file is unavailable",
151    ))
152}
153
154#[cfg(unix)]
155fn sync_directory(path: &Path) -> io::Result<()> {
156    File::open(path)?.sync_all()
157}
158
159#[cfg(not(unix))]
160fn sync_directory(_path: &Path) -> io::Result<()> {
161    Ok(())
162}
163
164fn invalid() -> CodingError {
165    CodingError::new(CodingErrorCode::InvalidInput, "settings file is invalid")
166}
167
168fn persistence() -> CodingError {
169    CodingError::new(CodingErrorCode::Persistence, "settings file cannot be read")
170}
171
172fn persistence_write() -> CodingError {
173    CodingError::new(
174        CodingErrorCode::Persistence,
175        "settings file cannot be persisted",
176    )
177}
178
179#[cfg(test)]
180mod tests {
181    use super::*;
182
183    #[test]
184    fn failed_rename_leaves_existing_settings_intact() {
185        let root = std::env::temp_dir().join(format!(
186            "tea-coding-settings-rename-{}-{}",
187            std::process::id(),
188            SETTINGS_TEMP_COUNTER.fetch_add(1, Ordering::Relaxed)
189        ));
190        fs::create_dir_all(&root).unwrap();
191        let path = root.join("settings.json");
192        let original = br#"{"schemaVersion":1,"model":"old"}"#;
193        fs::write(&path, original).unwrap();
194
195        let result = atomic_write_with(&path, b"replacement", |_, _| {
196            Err(io::Error::other("injected rename failure"))
197        });
198        assert!(result.is_err());
199        assert_eq!(fs::read(&path).unwrap(), original);
200        assert_eq!(fs::read_dir(&root).unwrap().count(), 1);
201        fs::remove_dir_all(root).unwrap();
202    }
203}