tea_coding/config/
file.rs1use 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
13pub const MAX_SETTINGS_FILE_BYTES: usize = 256 * 1024;
15
16static SETTINGS_TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
17
18pub 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
30pub 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}