Files
call-recorder/crates/core/src/settings.rs
T
haukeandClaude Opus 5.5 3358de7888 fix #14740: fixed backend url per build, key bound to its server
- the backend URL is no longer a setting: one constant per build
  (release/dev) in src-tauri/src/backend.rs; Settings shows the server
  read-only; an old backend_url in settings.json is ignored
- the stored key records the backend it was created for; a key of
  another backend is discarded before any use and never stored
- a refused key is discarded only if it still is the stored one
- the keyring is never called while the settings are locked
- one upload per call at a time, also visible after a view switch
- opener plugin without its link-click script (it also ran in the
  remote login page); a login error says to reload the login page

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-06 15:18:05 +01:00

301 lines
9.4 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! User settings, persisted as JSON in the app config directory.
//!
//! Secrets (API keys) are never part of the settings; they live in the OS
//! keyring (see [`crate::secrets`]).
use std::fs;
use std::io;
use std::ops::RangeInclusive;
use std::path::Path;
use chrono::{DateTime, Local};
use serde::{Deserialize, Serialize};
/// Executables whose mic use counts as a call (matched case-insensitively).
const DEFAULT_ALLOWLIST: [&str; 6] = [
"ms-teams.exe",
"teams.exe",
"microsip.exe",
"msedge.exe",
"chrome.exe",
"firefox.exe",
];
/// Allowed continuous mic use before a call counts as started, in seconds.
pub const START_AFTER_SECS: RangeInclusive<u64> = 1..=30;
/// Allowed mic release before a call counts as ended, in seconds. Too short
/// splits a call, e.g. when the headset is switched.
pub const END_AFTER_SECS: RangeInclusive<u64> = 3..=120;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(default)]
pub struct Settings {
pub allowlist: Vec<String>,
pub mic_device: Option<String>,
pub output_device: Option<String>,
pub language: String,
pub deepscript_model: String,
pub retention_days: u32,
pub autostart: bool,
pub start_after_secs: u64,
pub end_after_secs: u64,
/// Whose backend key is stored (the key itself is in the keyring). Set
/// by the app at login, not by the user.
pub backend_username: Option<String>,
/// When the stored backend key expires. Set by the app at login.
pub backend_key_expires_at: Option<DateTime<Local>>,
/// The backend the stored key was created for: it is sent to that one
/// only. Set by the app at login.
pub backend_key_base_url: Option<String>,
}
impl Default for Settings {
fn default() -> Self {
Self {
allowlist: DEFAULT_ALLOWLIST.iter().map(|s| s.to_string()).collect(),
mic_device: None,
output_device: None,
language: "de".to_string(),
deepscript_model: "premium".to_string(),
retention_days: 7,
autostart: true,
start_after_secs: 3,
end_after_secs: 10,
backend_username: None,
backend_key_expires_at: None,
backend_key_base_url: None,
}
}
}
impl Settings {
/// Checks the values the user can type in; the error is shown as is.
pub fn validate(&self) -> Result<(), String> {
if !START_AFTER_SECS.contains(&self.start_after_secs) {
return Err(format!(
"Start nach: {}–{} Sekunden",
START_AFTER_SECS.start(),
START_AFTER_SECS.end()
));
}
if !END_AFTER_SECS.contains(&self.end_after_secs) {
return Err(format!(
"Ende nach: {}–{} Sekunden",
END_AFTER_SECS.start(),
END_AFTER_SECS.end()
));
}
Ok(())
}
/// The settings after the user saved `edited` over these: checked, with
/// the backend login (which only the app changes) kept, so a settings
/// page loaded before a login cannot undo it.
pub fn edited(&self, mut edited: Settings) -> Result<Settings, String> {
edited.validate()?;
edited.backend_username = self.backend_username.clone();
edited.backend_key_expires_at = self.backend_key_expires_at;
edited.backend_key_base_url = self.backend_key_base_url.clone();
Ok(edited)
}
/// Reads the settings file. A missing or unreadable file yields the
/// defaults; fields missing from the file take their default value.
pub fn load(path: &Path) -> Settings {
fs::read_to_string(path)
.ok()
.and_then(|json| serde_json::from_str(&json).ok())
.unwrap_or_default()
}
/// Writes the settings file (creating its directory), replacing the old
/// file atomically so a crash never leaves a half-written file behind.
pub fn save(&self, path: &Path) -> io::Result<()> {
if let Some(dir) = path.parent() {
fs::create_dir_all(dir)?;
}
let json = serde_json::to_string_pretty(self).map_err(io::Error::other)?;
let tmp = path.with_extension("json.tmp");
fs::write(&tmp, json)?;
fs::rename(&tmp, path)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn settings_default_values() {
let s = Settings::default();
assert_eq!(
s.allowlist,
vec![
"ms-teams.exe",
"teams.exe",
"microsip.exe",
"msedge.exe",
"chrome.exe",
"firefox.exe"
]
);
assert_eq!(s.mic_device, None);
assert_eq!(s.output_device, None);
assert_eq!(s.language, "de");
assert_eq!(s.deepscript_model, "premium");
assert_eq!(s.retention_days, 7);
assert!(s.autostart);
assert_eq!(s.start_after_secs, 3);
assert_eq!(s.end_after_secs, 10);
assert_eq!(s.backend_username, None);
assert_eq!(s.backend_key_expires_at, None);
assert_eq!(s.backend_key_base_url, None);
}
#[test]
fn a_backend_url_in_an_older_file_is_ignored() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(
&path,
r#"{"retention_days": 9, "backend_url": "https://other.example"}"#,
)
.unwrap();
assert_eq!(
Settings::load(&path),
Settings {
retention_days: 9,
..Settings::default()
}
);
}
fn logged_in() -> Settings {
Settings {
backend_username: Some("hinrichs".into()),
backend_key_expires_at: Some(
chrono::DateTime::parse_from_rfc3339("2027-11-06T10:00:00+01:00")
.unwrap()
.into(),
),
backend_key_base_url: Some("https://test.euvinopro.eu".into()),
..Settings::default()
}
}
#[test]
fn an_edit_keeps_the_backend_login_which_only_the_app_changes() {
let current = logged_in();
let edited = Settings {
retention_days: 30,
backend_username: None,
backend_key_expires_at: None,
backend_key_base_url: Some("https://elsewhere.example".into()),
..Settings::default()
};
let saved = current.edited(edited).unwrap();
assert_eq!(
saved,
Settings {
retention_days: 30,
..logged_in()
}
);
}
#[test]
fn an_invalid_edit_is_refused() {
let edited = Settings {
start_after_secs: 0,
..Settings::default()
};
assert!(logged_in().edited(edited).is_err());
}
#[test]
fn validate_accepts_the_defaults_and_the_bounds() {
assert_eq!(Settings::default().validate(), Ok(()));
for (start, end) in [(1, 3), (30, 120)] {
let s = Settings {
start_after_secs: start,
end_after_secs: end,
..Settings::default()
};
assert_eq!(s.validate(), Ok(()), "start {start}, end {end}");
}
}
#[test]
fn validate_rejects_start_after_out_of_range() {
for start in [0, 31] {
let s = Settings {
start_after_secs: start,
..Settings::default()
};
assert_eq!(s.validate(), Err("Start nach: 1–30 Sekunden".to_string()));
}
}
#[test]
fn validate_rejects_end_after_out_of_range() {
for end in [2, 121] {
let s = Settings {
end_after_secs: end,
..Settings::default()
};
assert_eq!(s.validate(), Err("Ende nach: 3–120 Sekunden".to_string()));
}
}
#[test]
fn settings_load_missing_file_returns_default() {
let dir = tempfile::tempdir().unwrap();
assert_eq!(
Settings::load(&dir.path().join("settings.json")),
Settings::default()
);
}
#[test]
fn settings_load_corrupt_file_returns_default() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(&path, "{ not json").unwrap();
assert_eq!(Settings::load(&path), Settings::default());
}
#[test]
fn settings_load_partial_json_fills_defaults() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("settings.json");
fs::write(&path, r#"{"retention_days": 30, "mic_device": "headset"}"#).unwrap();
let s = Settings::load(&path);
assert_eq!(s.retention_days, 30);
assert_eq!(s.mic_device.as_deref(), Some("headset"));
assert_eq!(
s,
Settings {
retention_days: 30,
mic_device: Some("headset".into()),
..Settings::default()
}
);
}
#[test]
fn settings_save_then_load_roundtrips() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("nested").join("settings.json");
let s = Settings {
allowlist: vec!["zoom.exe".into()],
output_device: Some("speakers".into()),
autostart: false,
..Settings::default()
};
s.save(&path).unwrap();
assert_eq!(Settings::load(&path), s);
}
}