use std::collections::{BTreeMap, HashMap};
use std::path::{Path, PathBuf};
use std::sync::{OnceLock, PoisonError, RwLock};
use serde::Deserialize;
const FILE: &str = "llmman.conf";
#[derive(Deserialize, Default, Debug)]
#[serde(deny_unknown_fields)]
pub struct Conf {
#[serde(default)]
pub core: CoreConf,
#[serde(default)]
pub pager: PagerConf,
#[serde(default)]
pub aliases: HashMap<String, String>,
#[serde(default)]
providers: HashMap<String, ProviderConf>,
#[serde(default)]
pub verify: VerifyConf,
#[serde(default)]
pub aggregation: AggregationConf,
#[serde(default)]
auth: AuthConf,
#[serde(default)]
pub managed: ManagedConf,
#[serde(default)]
pub registries: HashMap<String, RegistryConf>,
#[serde(default)]
pub launch: HashMap<String, LaunchConf>,
}
#[derive(Deserialize, Default, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct CoreConf {
#[serde(default)]
pub pager: Option<String>,
}
#[derive(Deserialize, Default, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct PagerConf {
#[serde(default)]
pub log: Option<String>,
#[serde(default)]
pub providers: Option<String>,
#[serde(default)]
pub list: Option<String>,
#[serde(default)]
pub search: Option<String>,
#[serde(default)]
pub ps: Option<String>,
}
pub(crate) fn pager(command: &str) -> (Option<String>, Option<String>) {
pager_from_files(files().unwrap_or_default(), command)
}
fn pager_from_files(files: &[File], command: &str) -> (Option<String>, Option<String>) {
let mut core = None;
let mut specific = None;
for file in files {
if let Some(value) = &file.conf.core.pager {
core = Some(value.clone());
}
let value = match command {
"log" => &file.conf.pager.log,
"providers" => &file.conf.pager.providers,
"list" => &file.conf.pager.list,
"search" => &file.conf.pager.search,
"ps" => &file.conf.pager.ps,
_ => continue,
};
if let Some(value) = value {
specific = Some(value.clone());
}
}
(core, specific)
}
#[derive(Deserialize, Default, Clone)]
#[serde(deny_unknown_fields)]
pub struct AggregationConf {
#[serde(default)]
pub peers: Option<String>,
#[serde(default)]
api_key: Option<String>,
}
impl std::fmt::Debug for AggregationConf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AggregationConf")
.field("peers", &self.peers)
.field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
.finish()
}
}
#[derive(Deserialize, Default, Clone)]
#[serde(deny_unknown_fields)]
struct AuthConf {
#[serde(default)]
api_keys: Option<String>,
}
#[derive(Deserialize, Default, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct ManagedConf {
#[serde(default)]
pub enabled: Option<String>,
#[serde(default)]
pub read_timeout_seconds: Option<String>,
}
#[derive(Default, Debug, Clone)]
pub struct Managed {
pub enabled: bool,
pub read_timeout: Option<std::time::Duration>,
}
pub fn managed() -> Result<Managed, String> {
managed_from_files(files()?)
}
fn managed_from_files(files: &[File]) -> Result<Managed, String> {
let mut managed = Managed::default();
for file in files {
managed.apply(&file.conf.managed)?;
}
Ok(managed)
}
impl Managed {
fn apply(&mut self, conf: &ManagedConf) -> Result<(), String> {
if let Some(enabled) = &conf.enabled {
self.enabled = enabled
.parse()
.map_err(|_| "managed.enabled must be \"true\" or \"false\"".to_string())?;
}
if let Some(seconds) = &conf.read_timeout_seconds {
let seconds: u32 = seconds.parse().map_err(|_| {
"managed.read_timeout_seconds must be an unsigned 32-bit integer".to_string()
})?;
self.read_timeout =
(seconds != 0).then(|| std::time::Duration::from_secs(seconds.into()));
}
Ok(())
}
}
impl std::fmt::Debug for AuthConf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AuthConf")
.field("api_keys", &self.api_keys.as_ref().map(|_| "<redacted>"))
.finish()
}
}
#[derive(Deserialize, Default, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct RegistryConf {
#[serde(default)]
pub mirrors: Option<String>,
}
#[derive(Deserialize, Default, Debug, Clone, PartialEq, Eq)]
#[serde(deny_unknown_fields)]
pub struct LaunchConf {
#[serde(default)]
pub provider: Option<String>,
#[serde(default)]
pub model: Option<String>,
#[serde(default)]
pub variant: Option<String>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ProviderConf {
#[serde(default)]
api_key: Option<String>,
#[serde(default)]
base_url: Option<String>,
#[serde(default)]
wire: Option<crate::providers::Wire>,
#[serde(default)]
api_key_env: Option<String>,
#[serde(default)]
name: Option<String>,
}
impl std::fmt::Debug for ProviderConf {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ProviderConf")
.field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
.field("base_url", &self.base_url)
.field("wire", &self.wire)
.field("api_key_env", &self.api_key_env)
.field("name", &self.name)
.finish()
}
}
impl ProviderConf {
fn defines(&self) -> bool {
self.base_url.is_some()
}
fn definition_only_fields(&self) -> Vec<&'static str> {
let mut set = Vec::new();
if self.wire.is_some() {
set.push("wire");
}
if self.api_key_env.is_some() {
set.push("api_key_env");
}
if self.name.is_some() {
set.push("name");
}
set
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ConfiguredProvider {
pub id: String,
pub name: String,
pub base_url: String,
pub wire: crate::providers::Wire,
pub key_env: Option<String>,
}
#[derive(Deserialize, Default, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct VerifyConf {
#[serde(default)]
pub default: Option<String>,
#[serde(default)]
pub layers: Option<String>,
#[serde(default)]
pub trust: Vec<TrustConf>,
#[serde(default)]
pub trusted_root: Option<String>,
}
#[derive(Deserialize, Debug, Clone)]
#[serde(deny_unknown_fields)]
pub struct TrustConf {
pub pattern: String,
#[serde(default)]
pub keys: Vec<String>,
#[serde(default)]
pub mode: Option<String>,
#[serde(default)]
pub claims: Option<String>,
#[serde(default)]
pub issuer: Option<String>,
#[serde(default)]
pub subject: Option<String>,
}
impl Conf {
pub(crate) fn provider_keys(&self) -> HashMap<String, String> {
self.providers
.iter()
.filter_map(|(id, p)| Some((id.clone(), p.api_key.as_deref()?.trim().to_string())))
.collect()
}
}
#[derive(Debug)]
pub struct File {
pub path: PathBuf,
pub dir: PathBuf,
pub conf: Conf,
}
pub fn search_paths() -> Vec<PathBuf> {
let mut paths = vec![system_dir().join(FILE)];
paths.extend(user_dir().map(|d| d.join(FILE)));
paths
}
#[cfg(not(windows))]
fn system_dir() -> PathBuf {
PathBuf::from("/etc/llmman")
}
#[cfg(windows)]
fn system_dir() -> PathBuf {
let drive = std::env::var("SystemDrive").unwrap_or_else(|_| "C:".to_string());
PathBuf::from(format!("{drive}\\etc\\llmman"))
}
fn user_dir() -> Option<PathBuf> {
home_dir().map(|h| h.join(".config").join("llmman"))
}
pub(crate) fn home_dir() -> Option<PathBuf> {
env_home().or_else(dirs::home_dir)
}
const HOME_KEYS: &[&str] = if cfg!(windows) {
&["USERPROFILE"]
} else {
&["HOME"]
};
fn env_home() -> Option<PathBuf> {
env_home_from(HOME_KEYS, |key| std::env::var_os(key))
}
fn env_home_from(
keys: &[&str],
lookup: impl Fn(&str) -> Option<std::ffi::OsString>,
) -> Option<PathBuf> {
keys.iter()
.filter_map(|key| lookup(key))
.map(PathBuf::from)
.find(|value| value.is_absolute())
}
pub fn user_path() -> Option<PathBuf> {
user_dir().map(|d| d.join(FILE))
}
pub fn system_path() -> PathBuf {
system_dir().join(FILE)
}
pub fn toml_key(key: &str) -> String {
toml_edit::Key::new(key).display_repr().into_owned()
}
pub fn files() -> Result<&'static [File], &'static str> {
cache().as_deref().map_err(String::as_str)
}
fn cache() -> &'static Result<Vec<File>, String> {
static CACHE: OnceLock<Result<Vec<File>, String>> = OnceLock::new();
CACHE.get_or_init(|| {
let loaded = load();
if let Err(e) = &loaded {
eprintln!("[llmman] warning: {e}");
}
loaded
})
}
fn load() -> Result<Vec<File>, String> {
if cfg!(test) {
return Ok(Vec::new());
}
load_from(search_paths())
}
fn load_from(paths: Vec<PathBuf>) -> Result<Vec<File>, String> {
let mut files = Vec::new();
for path in paths {
let text = match std::fs::read_to_string(&path) {
Ok(text) => text,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => return Err(format!("ignoring {}: {e}", path.display())),
};
let conf = parse(&text).map_err(|e| format!("ignoring {}: {e}", path.display()))?;
let dir = path.parent().unwrap_or(Path::new(".")).to_path_buf();
files.push(File { path, dir, conf });
}
Ok(files)
}
pub(crate) fn parse(text: &str) -> Result<Conf, String> {
let conf: Conf = toml::from_str(text).map_err(|e| e.to_string())?;
validate(&conf)?;
Ok(conf)
}
fn validate(conf: &Conf) -> Result<(), String> {
Managed::default().apply(&conf.managed)?;
let mut seen: HashMap<String, &str> = HashMap::new();
for (host, r) in &conf.registries {
let canonical = canonical_registry_host(host).ok_or_else(|| {
format!(
"[registries.{host:?}]: expected a host[:port], as in [registries.\"docker.io\"]"
)
})?;
if let Some(other) = seen.insert(canonical, host) {
return Err(format!(
"[registries.{host:?}] and [registries.{other:?}] name the same registry"
));
}
for mirror in split_list(r.mirrors.as_deref()) {
mirror_url_of(&mirror).map_err(|e| format!("[registries.{host:?}] mirrors: {e}"))?;
}
}
validate_launch(&conf.launch)?;
for (id, p) in &conf.providers {
if id.is_empty() || id.contains('/') {
return Err(format!(
"[providers.{id:?}]: a provider id cannot be empty or contain '/'"
));
}
match &p.base_url {
Some(url) => {
base_url_of(url).map_err(|e| format!("[providers.{id}] base_url: {e}"))?;
}
None => {
let only_on_definition = p.definition_only_fields();
if !only_on_definition.is_empty() {
return Err(format!(
"[providers.{id}] sets {} but no base_url, so it only keys the catalog \
provider {id:?}",
only_on_definition.join(", ")
));
}
}
}
}
Ok(())
}
fn validate_launch(launch: &HashMap<String, LaunchConf>) -> Result<(), String> {
let mut seen: HashMap<&str, &str> = HashMap::new();
for (name, l) in launch {
let canonical = crate::cmd::launch::canonical_integration(name).ok_or_else(|| {
format!(
"[launch.{name:?}]: not an integration `llmman launch` knows; \
run `llmman launch` to list them"
)
})?;
if let Some(other) = seen.insert(canonical, name) {
return Err(format!(
"[launch.{name:?}] and [launch.{other:?}] name the same integration"
));
}
if let Some(variant) = set_value(l.variant.as_deref()) {
if !crate::cmd::run::variants().any(|v| v == variant) {
return Err(format!(
"[launch.{name}] variant: {variant:?} is not one of {}",
crate::cmd::run::variants().collect::<Vec<_>>().join(", ")
));
}
}
}
Ok(())
}
fn set_value(value: Option<&str>) -> Option<&str> {
value.map(str::trim).filter(|v| !v.is_empty())
}
fn plain_http_url(url: &str, credential: &str) -> Result<reqwest::Url, String> {
let parsed = reqwest::Url::parse(url).map_err(|e| format!("{url:?}: {e}"))?;
match parsed.scheme() {
"http" | "https" => {}
other => {
return Err(format!(
"{url:?}: scheme must be http or https, not {other}"
))
}
}
if parsed.host_str().is_none() {
return Err(format!("{url:?}: no host"));
}
if !parsed.username().is_empty() || parsed.password().is_some() {
return Err(format!(
"{url:?}: cannot carry a username or password; use {credential}"
));
}
if parsed.query().is_some() || parsed.fragment().is_some() {
return Err(format!("{url:?}: no query or fragment allowed"));
}
Ok(parsed)
}
fn base_url_of(url: &str) -> Result<String, String> {
let parsed = plain_http_url(url.trim(), "api_key")?;
Ok(parsed.as_str().trim_end_matches('/').to_string())
}
fn mirror_url_of(mirror: &str) -> Result<String, String> {
let mirror = mirror.trim();
if mirror.is_empty() {
return Err("an empty entry".to_string());
}
let with_scheme = if mirror.contains("://") {
mirror.to_string()
} else {
format!("https://{mirror}")
};
let parsed = plain_http_url(&with_scheme, "`llmman login`")?;
Ok(parsed.as_str().trim_end_matches('/').to_string())
}
fn canonical_registry_host(host: &str) -> Option<String> {
let host = host.trim();
if host.is_empty() || host.contains("://") || host.contains(['/', '*']) {
return None;
}
let parsed = plain_http_url(&format!("https://{host}"), "").ok()?;
if parsed.path() != "/" {
return None;
}
let mut canonical = parsed.host_str()?.to_string();
if let Some(port) = parsed.port() {
canonical = format!("{canonical}:{port}");
}
Some(match canonical.as_str() {
"index.docker.io" | "registry-1.docker.io" => "docker.io".to_string(),
_ => canonical,
})
}
fn split_list(value: Option<&str>) -> Vec<String> {
value
.unwrap_or_default()
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
.collect()
}
pub fn registry_mirrors() -> BTreeMap<String, Vec<String>> {
registry_mirrors_from(
std::env::var("LLMMAN_REGISTRY_MIRRORS").ok().as_deref(),
files().unwrap_or_default(),
)
}
pub fn has_registry_mirrors(host: &str) -> bool {
static CACHE: OnceLock<BTreeMap<String, Vec<String>>> = OnceLock::new();
canonical_registry_host(host)
.is_some_and(|host| CACHE.get_or_init(registry_mirrors).contains_key(&host))
}
fn registry_mirrors_from(env: Option<&str>, files: &[File]) -> BTreeMap<String, Vec<String>> {
let mut by_host: BTreeMap<String, Vec<String>> = BTreeMap::new();
for file in files {
for (host, r) in &file.conf.registries {
let Some(mirrors) = r.mirrors.as_deref() else {
continue;
};
let host = canonical_registry_host(host).expect("validated at parse");
let mirrors = split_list(Some(mirrors))
.iter()
.map(|m| mirror_url_of(m).expect("validated at parse"))
.collect();
by_host.insert(host, mirrors);
}
}
if let Some(env) = env {
let mut mirrors = Vec::new();
for m in split_list(Some(env)) {
match mirror_url_of(&m) {
Ok(m) => mirrors.push(m),
Err(e) => eprintln!("[llmman] warning: ignoring LLMMAN_REGISTRY_MIRRORS entry {e}"),
}
}
by_host.insert("docker.io".to_string(), mirrors);
}
by_host.retain(|_, mirrors| !mirrors.is_empty());
by_host
}
pub fn launch_defaults(integration: &str) -> Result<LaunchConf, &'static str> {
Ok(launch_defaults_from(files()?, integration))
}
fn launch_defaults_from(files: &[File], integration: &str) -> LaunchConf {
let wanted = crate::cmd::launch::canonical_integration(integration);
let mut merged = LaunchConf::default();
for conf in files.iter().filter_map(|file| {
file.conf
.launch
.iter()
.find(|(name, _)| crate::cmd::launch::canonical_integration(name) == wanted)
.map(|(_, conf)| conf)
}) {
for (field, value) in [
(&mut merged.provider, &conf.provider),
(&mut merged.model, &conf.model),
(&mut merged.variant, &conf.variant),
] {
if value.is_some() {
*field = set_value(value.as_deref()).map(str::to_string);
}
}
}
merged
}
#[cfg(test)]
pub(crate) fn launch_conf(
provider: Option<&str>,
model: Option<&str>,
variant: Option<&str>,
) -> LaunchConf {
let own = |v: Option<&str>| v.map(str::to_string);
LaunchConf {
provider: own(provider),
model: own(model),
variant: own(variant),
}
}
pub fn configured_providers() -> &'static [ConfiguredProvider] {
static CACHE: OnceLock<Vec<ConfiguredProvider>> = OnceLock::new();
CACHE.get_or_init(|| configured_from(files().unwrap_or_default()))
}
fn configured_from(files: &[File]) -> Vec<ConfiguredProvider> {
let mut merged: HashMap<&str, ConfiguredProvider> = HashMap::new();
for file in files {
for (id, p) in file.conf.providers.iter().filter(|(_, p)| p.defines()) {
let base_url = p
.base_url
.as_deref()
.and_then(|u| base_url_of(u).ok())
.expect("validated at parse");
let entry = merged.entry(id).or_insert_with(|| ConfiguredProvider {
id: id.clone(),
name: id.clone(),
base_url: String::new(),
wire: crate::providers::Wire::OpenAi,
key_env: None,
});
entry.base_url = base_url;
if let Some(wire) = p.wire {
entry.wire = wire;
}
if let Some(var) = p.api_key_env.as_deref().map(str::trim) {
entry.key_env = (!var.is_empty()).then(|| var.to_string());
}
if let Some(name) = p.name.as_deref().map(str::trim).filter(|n| !n.is_empty()) {
entry.name = name.to_string();
}
}
}
let mut out: Vec<ConfiguredProvider> = merged.into_values().collect();
out.sort_by(|a, b| a.id.cmp(&b.id));
out
}
pub fn provider_api_key(provider_id: &str) -> Option<String> {
if let Some(keys) = PROVIDER_KEYS
.read()
.unwrap_or_else(PoisonError::into_inner)
.as_ref()
{
return keys.get(provider_id).cloned();
}
PROVIDER_KEYS
.write()
.unwrap_or_else(PoisonError::into_inner)
.get_or_insert_with(|| provider_keys_in(files().unwrap_or_default()))
.get(provider_id)
.cloned()
}
static PROVIDER_KEYS: RwLock<Option<HashMap<String, String>>> = RwLock::new(None);
pub fn reload_provider_keys() -> Result<(), String> {
reload_provider_keys_from(provider_key_paths())
}
#[cfg(not(test))]
fn provider_key_paths() -> Vec<PathBuf> {
search_paths()
}
#[cfg(test)]
fn provider_key_paths() -> Vec<PathBuf> {
TEST_PROVIDER_FILES
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
#[cfg(not(test))]
pub fn provider_key_file() -> Option<PathBuf> {
user_path()
}
#[cfg(test)]
pub fn provider_key_file() -> Option<PathBuf> {
provider_key_paths().last().cloned()
}
#[cfg(test)]
pub(crate) static TEST_PROVIDER_FILES: std::sync::Mutex<Vec<PathBuf>> =
std::sync::Mutex::new(Vec::new());
#[cfg(test)]
pub(crate) static PROVIDER_KEYS_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
fn reload_provider_keys_from(paths: Vec<PathBuf>) -> Result<(), String> {
let files = load_from(paths)?;
*PROVIDER_KEYS
.write()
.unwrap_or_else(PoisonError::into_inner) = Some(provider_keys_in(&files));
Ok(())
}
fn provider_keys_in(files: &[File]) -> HashMap<String, String> {
let mut accepted = Vec::new();
for file in files {
let keys = file.conf.provider_keys();
if !keys.values().all(String::is_empty) {
if let Err(e) = owner_readable_only(&file.path) {
eprintln!(
"[llmman] warning: ignoring the API keys in {}: {e}",
file.path.display()
);
continue;
}
}
accepted.push(keys);
}
merge_keys(accepted)
}
fn merge_keys(per_file: Vec<HashMap<String, String>>) -> HashMap<String, String> {
let mut merged: HashMap<String, String> = HashMap::new();
for keys in per_file {
merged.extend(keys);
}
merged.retain(|_, key| !key.is_empty());
merged
}
pub fn peers() -> Vec<String> {
peers_from(
std::env::var("LLMMAN_PEERS").ok().as_deref(),
files().unwrap_or_default(),
)
}
fn peers_from(env: Option<&str>, files: &[File]) -> Vec<String> {
split_list(env.or_else(|| {
files
.iter()
.rev()
.find_map(|f| f.conf.aggregation.peers.as_deref())
}))
}
pub fn auth_api_keys() -> Vec<String> {
split_list(
std::env::var("LLMMAN_API_KEYS")
.ok()
.or_else(|| {
secret_from_files(files().unwrap_or_default(), "auth.api_keys", |f| {
f.conf.auth.api_keys.as_deref()
})
})
.as_deref(),
)
}
pub fn peer_api_key() -> Option<String> {
std::env::var("LLMMAN_PEER_API_KEY")
.ok()
.or_else(|| {
secret_from_files(files().unwrap_or_default(), "aggregation.api_key", |f| {
f.conf.aggregation.api_key.as_deref()
})
})
.map(|k| k.trim().to_string())
.filter(|k| !k.is_empty())
}
fn secret_from_files<'a>(
files: &'a [File],
field: &str,
pick: impl Fn(&'a File) -> Option<&'a str>,
) -> Option<String> {
for file in files.iter().rev() {
let Some(value) = pick(file) else { continue };
if !value.trim().is_empty() {
if let Err(e) = owner_readable_only(&file.path) {
eprintln!(
"[llmman] warning: ignoring {field} in {}: {e}",
file.path.display()
);
continue;
}
}
return Some(value.to_string());
}
None
}
#[cfg(unix)]
pub(crate) fn owner_readable_only(path: &Path) -> Result<(), String> {
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(path)
.map_err(|e| e.to_string())?
.permissions()
.mode();
if mode & 0o077 != 0 {
return Err(format!(
"mode {:04o} lets other users read it. Run: chmod 600 {}",
mode & 0o7777,
path.display()
));
}
Ok(())
}
#[cfg(not(unix))]
pub(crate) fn owner_readable_only(_path: &Path) -> Result<(), String> {
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn reloaded_provider_keys_take_effect_without_a_restart() {
use std::os::unix::fs::PermissionsExt;
let _one = PROVIDER_KEYS_TEST_LOCK
.lock()
.unwrap_or_else(PoisonError::into_inner);
let id = "llmman-test-reload";
let dir = std::env::temp_dir().join(format!("llmman-reload-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
let path = dir.join(FILE);
std::fs::write(&path, format!("[providers.{id}]\napi_key = \"sk-new\"\n")).expect("write");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).expect("chmod");
reload_provider_keys_from(vec![path.clone()]).expect("reload");
assert_eq!(
provider_api_key(id),
None,
"a world-readable file's key is ignored"
);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).expect("chmod");
reload_provider_keys_from(vec![path.clone()]).expect("reload");
assert_eq!(provider_api_key(id).as_deref(), Some("sk-new"));
std::fs::write(&path, format!("[providers.{id}]\napi_key = \"sk-broken\n")).expect("write");
assert!(reload_provider_keys_from(vec![path.clone()]).is_err());
assert_eq!(provider_api_key(id).as_deref(), Some("sk-new"));
reload_provider_keys_from(Vec::new()).expect("reload");
assert_eq!(provider_api_key(id), None);
std::fs::remove_dir_all(&dir).ok();
}
fn conf(text: &str) -> Conf {
parse(text).expect("valid conf")
}
#[test]
fn pager_configuration_merges_each_key_independently() {
let system = file(
r#"[core]
pager = "less -S"
[pager]
providers = "false"
log = "more""#,
);
let user = file(
r#"[pager]
log = """#,
);
assert_eq!(
pager_from_files(&[system, user], "log"),
(Some("less -S".into()), Some("".into()))
);
let system = file(
r#"[core]
pager = "less"
[pager]
providers = "false""#,
);
let user = file(
r#"[core]
pager = "cat""#,
);
assert_eq!(
pager_from_files(&[system, user], "providers"),
(Some("cat".into()), Some("false".into()))
);
assert!(parse(
r#"[core]
pagr = "less""#
)
.is_err());
assert!(parse(
r#"[pager]
provider = "false""#
)
.is_err());
}
#[test]
fn pager_settings_support_model_listing_commands() {
let settings = file(
r#"[pager]
list = "yes"
search = "less -S"
ps = "off""#,
);
for (command, value) in [("list", "yes"), ("search", "less -S"), ("ps", "off")] {
assert_eq!(
pager_from_files(std::slice::from_ref(&settings), command),
(None, Some(value.into()))
);
}
}
#[test]
fn a_home_comes_from_the_environment_when_it_is_absolute() {
let expected: &[&str] = if cfg!(windows) {
&["USERPROFILE"]
} else {
&["HOME"]
};
assert_eq!(HOME_KEYS, expected);
let take = |value: &str| {
let value = value.to_string();
env_home_from(HOME_KEYS, move |_| {
Some(std::ffi::OsString::from(value.clone()))
})
};
let home = if cfg!(windows) {
"C:\\Users\\u"
} else {
"/home/u"
};
assert_eq!(take(home), Some(PathBuf::from(home)));
assert_eq!(take(""), None);
assert_eq!(take("relative/home"), None);
#[cfg(windows)]
assert_eq!(take("/c/Users/u"), None);
assert_eq!(env_home_from(HOME_KEYS, |_| None), None);
}
#[test]
fn debug_output_never_carries_a_key() {
let c = conf("[providers.openai]\napi_key = \"sk-secret-value\"");
let rendered = format!("{c:?}");
assert!(!rendered.contains("sk-secret-value"), "{rendered}");
assert!(rendered.contains("redacted"), "{rendered}");
}
#[test]
fn parses_every_section_of_one_file() {
let c = conf(
r#"
[aliases]
gemma4 = "docker.io/ai/gemma4"
[providers.openrouter]
api_key = "sk-or-abc"
[verify]
default = "warn"
trusted_root = "sigstore/trusted_root.json"
[[verify.trust]]
pattern = "docker.io/myorg/**"
keys = ["keys/myorg.pub"]
mode = "enforce"
claims = "docker.io/myorg/**"
[[verify.trust]]
pattern = "ghcr.io/myorg/**"
issuer = "https://token.actions.githubusercontent.com"
subject = "https://github.com/myorg/models/.github/workflows/sign.yml@refs/heads/main"
mode = "enforce"
[aggregation]
peers = "asahi,spark:17434"
[registries."docker.io"]
mirrors = "https://mirror.gcr.io,registry-mirror.corp:5000"
"#,
);
assert_eq!(
c.aliases.get("gemma4").map(String::as_str),
Some("docker.io/ai/gemma4")
);
assert_eq!(c.aggregation.peers.as_deref(), Some("asahi,spark:17434"));
assert_eq!(
c.registries["docker.io"].mirrors.as_deref(),
Some("https://mirror.gcr.io,registry-mirror.corp:5000")
);
assert_eq!(
c.provider_keys().get("openrouter").map(String::as_str),
Some("sk-or-abc")
);
assert_eq!(c.verify.default.as_deref(), Some("warn"));
assert_eq!(
c.verify.trusted_root.as_deref(),
Some("sigstore/trusted_root.json")
);
assert_eq!(c.verify.trust.len(), 2);
assert_eq!(c.verify.trust[0].mode.as_deref(), Some("enforce"));
assert_eq!(
c.verify.trust[0].claims.as_deref(),
Some("docker.io/myorg/**")
);
assert!(c.verify.trust[0].issuer.is_none());
assert!(c.verify.trust[0].subject.is_none());
assert!(c.verify.trust[1].keys.is_empty());
assert_eq!(
c.verify.trust[1].issuer.as_deref(),
Some("https://token.actions.githubusercontent.com")
);
assert_eq!(
c.verify.trust[1].subject.as_deref(),
Some("https://github.com/myorg/models/.github/workflows/sign.yml@refs/heads/main")
);
}
#[test]
fn every_section_is_optional() {
let c = conf("");
assert!(c.aliases.is_empty());
assert!(c.provider_keys().is_empty());
assert!(c.verify.default.is_none());
assert!(c.verify.trust.is_empty());
assert!(!conf("[aliases]\nx = \"y\"").aliases.is_empty());
assert!(conf("[verify]\ndefault = \"off\"").aliases.is_empty());
}
#[test]
fn a_key_is_trimmed_and_an_unset_one_is_absent() {
let keys = conf(
r#"
[providers.openai]
api_key = " sk-padded "
[providers.groq]
api_key = " "
[providers.mistral]
"#,
)
.provider_keys();
assert_eq!(keys.get("openai").map(String::as_str), Some("sk-padded"));
assert_eq!(keys.get("groq").map(String::as_str), Some(""));
assert_eq!(keys.get("mistral"), None);
}
#[test]
fn a_later_blank_shadows_an_earlier_key_and_is_never_spent() {
let system = HashMap::from([
("openai".to_string(), "sk-system".to_string()),
("groq".to_string(), "sk-groq".to_string()),
]);
let user = HashMap::from([("openai".to_string(), String::new())]);
let merged = merge_keys(vec![system, user]);
assert_eq!(merged.get("openai"), None, "blanked out by the user file");
assert_eq!(merged.get("groq").map(String::as_str), Some("sk-groq"));
let merged = merge_keys(vec![
HashMap::from([("openai".to_string(), "sk-system".to_string())]),
HashMap::from([("openai".to_string(), "sk-user".to_string())]),
]);
assert_eq!(merged.get("openai").map(String::as_str), Some("sk-user"));
}
#[test]
fn a_misspelled_section_or_field_is_rejected_rather_than_ignored() {
assert!(parse("[provider.openai]\napi_key = \"x\"").is_err());
assert!(parse("[providers.openai]\napi_kye = \"x\"").is_err());
assert!(parse("[alias]\nx = \"y\"").is_err());
assert!(parse("[verify]\ndefualt = \"off\"").is_err());
assert!(parse("[verify]\nlayres = \"off\"").is_err());
assert!(parse("[[verify.trust]]\npattern = \"a/b\"\nkyes = []").is_err());
assert!(parse("[[verify.trust]]\npattern = \"a/b\"\nclaim = \"c/d\"").is_err());
assert!(parse("[registry.\"docker.io\"]\nmirrors = \"m\"").is_err());
assert!(parse("[registries.\"docker.io\"]\nmirror = \"m\"").is_err());
assert!(parse("api_key = \"x\"").is_err());
}
#[test]
fn malformed_toml_is_an_error() {
assert!(parse("[providers.openai").is_err());
}
#[test]
fn a_base_url_turns_a_provider_table_into_a_definition() {
let files = [file(
r#"
[providers.inferencebox]
base_url = "http://inferencebox:8000/v1/"
[providers.relay]
base_url = "https://relay.example/v1"
wire = "anthropic"
api_key_env = "RELAY_KEY"
name = "Claude relay"
api_key = "sk-relay"
[providers.openrouter]
api_key = "sk-or"
"#,
)];
let configured = configured_from(&files);
assert_eq!(
configured,
vec![
ConfiguredProvider {
id: "inferencebox".into(),
name: "inferencebox".into(),
base_url: "http://inferencebox:8000/v1".into(),
wire: crate::providers::Wire::OpenAi,
key_env: None,
},
ConfiguredProvider {
id: "relay".into(),
name: "Claude relay".into(),
base_url: "https://relay.example/v1".into(),
wire: crate::providers::Wire::Anthropic,
key_env: Some("RELAY_KEY".into()),
},
]
);
assert_eq!(
files[0]
.conf
.provider_keys()
.get("relay")
.map(String::as_str),
Some("sk-relay")
);
assert!(configured_from(&[]).is_empty());
}
#[test]
fn a_later_definition_overrides_field_by_field() {
let system = file(
"[providers.inferencebox]\nbase_url = \"http://inferencebox:8000/v1\"\nname = \"Shared box\"\n\
api_key_env = \"SHARED_KEY\"",
);
let user = file(
"[providers.inferencebox]\nbase_url = \"http://10.0.0.5:8000/v1\"\nwire = \"anthropic\"\n\
api_key_env = \"\"",
);
let merged = configured_from(&[system, user]);
assert_eq!(merged.len(), 1);
assert_eq!(merged[0].base_url, "http://10.0.0.5:8000/v1");
assert_eq!(merged[0].name, "Shared box");
assert_eq!(merged[0].wire, crate::providers::Wire::Anthropic);
assert_eq!(merged[0].key_env, None);
}
#[test]
fn a_bad_provider_definition_is_a_parse_error() {
let bad = |body: &str| parse(&format!("[providers.inferencebox]\n{body}")).expect_err(body);
assert!(bad("base_url = \"inferencebox:8000\"").contains("base_url"));
assert!(bad("base_url = \"inferencebox:8000/v1\"").contains("base_url"));
assert!(bad("base_url = \"ftp://inferencebox/v1\"").contains("http or https"));
assert!(bad("base_url = \"http://\"").contains("base_url"));
assert!(bad("base_url = \"http://inferencebox/v1?x=1\"").contains("query"));
assert!(bad("base_url = \"\"").contains("base_url"));
assert!(bad("base_url = \"https://user:pw@inferencebox/v1\"").contains("api_key"));
assert!(bad("base_url = \"https://user@inferencebox/v1\"").contains("api_key"));
assert!(
parse("[providers.\"team/gpu\"]\nbase_url = \"http://g/v1\"")
.expect_err("slash id")
.contains("'/'")
);
assert!(parse("[providers.\"\"]\napi_key = \"x\"").is_err());
let err = bad("wire = \"anthropic\"");
assert!(err.contains("no base_url"), "{err}");
assert!(err.contains("wire"), "{err}");
let err = bad("api_key_env = \"X\"\nname = \"n\"");
assert!(err.contains("api_key_env, name"), "{err}");
assert!(bad("base_url = \"http://g/v1\"\nwire = \"ollama\"").contains("wire"));
assert!(bad("base_url = \"http://g/v1\"\nbase_ulr = \"x\"").contains("base_ulr"));
for (url, want) in [
("http://inferencebox:8000/v1", "http://inferencebox:8000/v1"),
("http://inferencebox", "http://inferencebox"),
(
"HTTP://InferenceBox:8000/v1/",
"http://inferencebox:8000/v1",
),
("http://127.0.0.1:11434/v1", "http://127.0.0.1:11434/v1"),
("http://[::1]:8000/v1", "http://[::1]:8000/v1"),
(
"https://relay.example/api/v1",
"https://relay.example/api/v1",
),
] {
assert_eq!(base_url_of(url).expect(url), want);
parse(&format!("[providers.inferencebox]\nbase_url = {url:?}")).expect(url);
}
}
#[test]
fn debug_output_shows_a_definition_but_never_a_key() {
let c = conf(
"[providers.inferencebox]\nbase_url = \"http://inferencebox:8000/v1\"\napi_key = \"sk-secret-value\"",
);
let rendered = format!("{c:?}");
assert!(rendered.contains("inferencebox:8000"), "{rendered}");
assert!(!rendered.contains("sk-secret-value"), "{rendered}");
}
#[test]
fn managed_configuration_is_opt_in_strict_and_uses_field_precedence() {
assert!(!managed_from_files(&[]).unwrap().enabled);
let base = file("[managed]\nenabled = \"true\"\nread_timeout_seconds = \"600\"");
let override_file = file("[managed]\nread_timeout_seconds = \"0\"");
let settings = managed_from_files(&[base, override_file]).unwrap();
assert!(settings.enabled);
assert!(settings.read_timeout.is_none());
let settings =
managed_from_files(&[file("[managed]\nread_timeout_seconds = \"300\"")]).unwrap();
assert_eq!(
settings.read_timeout,
Some(std::time::Duration::from_secs(300))
);
assert!(!settings.enabled);
for text in [
"[managed]\nenabled = \"yes\"",
"[managed]\nread_timeout_seconds = \"-1\"",
"[managed]\nread_timeout_seconds = \"4294967296\"",
] {
assert!(parse(text).is_err(), "{text}");
}
assert!(parse("[managed]\nenabled = true").is_err());
assert!(parse("[managed]\nenabeld = \"true\"").is_err());
}
fn file(text: &str) -> File {
File {
path: PathBuf::from("llmman.conf"),
dir: PathBuf::from("."),
conf: conf(text),
}
}
#[test]
fn peers_come_from_the_environment_then_the_last_file_that_sets_them() {
let system = || file("[aggregation]\npeers = \"a, b\"");
let user = file("[aggregation]\npeers = \"c\"");
let silent = file("");
let opted_out = file("[aggregation]\npeers = \"\"");
assert_eq!(
peers_from(Some(" x , ,y:1 "), &[]),
vec!["x".to_string(), "y:1".to_string()]
);
assert!(peers_from(Some(""), &[system()]).is_empty());
assert_eq!(
peers_from(None, &[system(), silent]),
vec!["a".to_string(), "b".to_string()]
);
assert_eq!(peers_from(None, &[system(), user]), vec!["c".to_string()]);
assert!(peers_from(None, &[system(), opted_out]).is_empty());
assert!(peers_from(None, &[]).is_empty());
assert!(parse("[aggregation]\npeer = \"a\"").is_err());
}
#[cfg(unix)]
#[test]
fn daemon_and_peer_keys_are_redacted_and_gated_on_the_file_mode() {
use std::os::unix::fs::PermissionsExt;
let c = conf("[auth]\napi_keys = \"k-secret,k2\"\n[aggregation]\napi_key = \"p-secret\"");
let rendered = format!("{c:?}");
assert!(!rendered.contains("secret"), "{rendered}");
assert!(
parse("[auth]\napi_key = \"k\"").is_err(),
"the field is plural"
);
let dir = std::env::temp_dir().join(format!("llmman-auth-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
let write = |name: &str, text: &str, mode: u32| {
let path = dir.join(name);
std::fs::write(&path, text).expect("write");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(mode)).expect("chmod");
};
write(
"system.conf",
"[auth]\napi_keys = \"a, b\"\n[aggregation]\napi_key = \"pa\"",
0o600,
);
write(
"loose.conf",
"[auth]\napi_keys = \"c\"\n[aggregation]\napi_key = \"pc\"",
0o644,
);
write(
"out.conf",
"[auth]\napi_keys = \"\"\n[aggregation]\napi_key = \"\"",
0o644,
);
let files = |names: &[&str]| -> Vec<File> {
names
.iter()
.map(|n| {
let path = dir.join(n);
File {
dir: dir.clone(),
conf: parse(&std::fs::read_to_string(&path).unwrap()).unwrap(),
path,
}
})
.collect()
};
let keys = |files: &[File]| {
split_list(
secret_from_files(files, "auth.api_keys", |f| f.conf.auth.api_keys.as_deref())
.as_deref(),
)
};
let peer = |files: &[File]| {
secret_from_files(files, "aggregation.api_key", |f| {
f.conf.aggregation.api_key.as_deref()
})
};
let ab = vec!["a".to_string(), "b".to_string()];
assert_eq!(keys(&files(&["system.conf"])), ab);
assert_eq!(peer(&files(&["system.conf"])).as_deref(), Some("pa"));
assert_eq!(keys(&files(&["system.conf", "loose.conf"])), ab);
assert_eq!(
peer(&files(&["system.conf", "loose.conf"])).as_deref(),
Some("pa")
);
assert!(keys(&files(&["system.conf", "out.conf"])).is_empty());
assert_eq!(
peer(&files(&["system.conf", "out.conf"])).as_deref(),
Some("")
);
assert!(keys(&[]).is_empty());
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_mirror_is_normalized_and_defaults_to_https() {
assert_eq!(
mirror_url_of("mirror.gcr.io").as_deref(),
Ok("https://mirror.gcr.io")
);
assert_eq!(
mirror_url_of(" HTTP://Mirror.Corp:5000/ ").as_deref(),
Ok("http://mirror.corp:5000")
);
assert_eq!(
mirror_url_of("https://proxy.corp/registry/").as_deref(),
Ok("https://proxy.corp/registry")
);
for bad in [
"",
"ftp://mirror",
"https://",
"https://user:pw@mirror",
"https://mirror?x=1",
"https://mirror#frag",
] {
assert!(mirror_url_of(bad).is_err(), "{bad:?}");
}
}
#[test]
fn a_registry_key_is_a_host_and_hub_has_one_name() {
assert_eq!(
canonical_registry_host("Index.Docker.io").as_deref(),
Some("docker.io")
);
assert_eq!(
canonical_registry_host("registry-1.docker.io").as_deref(),
Some("docker.io")
);
assert_eq!(
canonical_registry_host("localhost:5000").as_deref(),
Some("localhost:5000")
);
assert_eq!(
canonical_registry_host("ghcr.io").as_deref(),
Some("ghcr.io")
);
assert_eq!(
canonical_registry_host("[::1]:5000").as_deref(),
Some("[::1]:5000")
);
assert_eq!(
canonical_registry_host("ghcr.io:443").as_deref(),
Some("ghcr.io")
);
for bad in [
"",
"https://ghcr.io",
"ghcr.io/org",
"*.example.com",
"host:port",
":5000",
"user@registry",
"registry?q=1",
"registry#f",
"[not-an-ip]:5000",
"a b",
] {
assert_eq!(canonical_registry_host(bad), None, "{bad:?}");
}
assert!(parse("[registries.\"https://ghcr.io\"]\nmirrors = \"m\"").is_err());
assert!(parse("[registries.\"ghcr.io\"]\nmirrors = \"ftp://m\"").is_err());
assert!(parse("[registries.\"ghcr.io\"]\nmirrors = \"m\"").is_ok());
assert!(parse(
"[registries.\"docker.io\"]\nmirrors = \"a\"\n[registries.\"index.docker.io\"]\nmirrors = \"b\""
)
.is_err());
assert!(parse(
"[registries.\"ghcr.io\"]\nmirrors = \"a\"\n[registries.\"GHCR.io\"]\nmirrors = \"b\""
)
.is_err());
}
#[test]
fn mirrors_come_from_the_environment_then_the_last_file_that_sets_them() {
let system = || {
file(
r#"
[registries."docker.io"]
mirrors = "https://a, b:5000"
[registries."ghcr.io"]
mirrors = "http://g"
"#,
)
};
let user = file("[registries.\"index.docker.io\"]\nmirrors = \"c\"");
let opted_out = file("[registries.\"docker.io\"]\nmirrors = \"\"");
let silent = file("[registries.\"docker.io\"]");
let got = registry_mirrors_from(None, &[system(), silent]);
assert_eq!(
got.get("docker.io").map(Vec::as_slice),
Some(&["https://a".to_string(), "https://b:5000".to_string()][..])
);
assert_eq!(
got.get("ghcr.io").map(Vec::as_slice),
Some(&["http://g".to_string()][..])
);
let got = registry_mirrors_from(None, &[system(), user]);
assert_eq!(
got.get("docker.io").map(Vec::as_slice),
Some(&["https://c".to_string()][..]),
"a Hub alias replaces docker.io's own entry"
);
let got = registry_mirrors_from(None, &[system(), opted_out]);
assert!(!got.contains_key("docker.io"));
assert!(
got.contains_key("ghcr.io"),
"opting Hub out leaves ghcr.io alone"
);
let got = registry_mirrors_from(Some(" x , ,http://y:1/ "), &[system()]);
assert_eq!(
got.get("docker.io").map(Vec::as_slice),
Some(&["https://x".to_string(), "http://y:1".to_string()][..])
);
assert!(!registry_mirrors_from(Some(""), &[system()]).contains_key("docker.io"));
assert!(registry_mirrors_from(Some("ftp://nope"), &[]).is_empty());
assert!(registry_mirrors_from(None, &[]).is_empty());
}
#[test]
fn launch_defaults_come_from_the_integrations_own_table() {
let f = [file(
"[launch.opencode]\nprovider = \"anthropic\"\nmodel = \"claude-sonnet-5-5\"\n\
variant = \"xhigh\"\n[launch.claude]\nmodel = \"qwen3.8\"",
)];
assert_eq!(
launch_defaults_from(&f, "opencode"),
launch_conf(Some("anthropic"), Some("claude-sonnet-5-5"), Some("xhigh"))
);
assert_eq!(
launch_defaults_from(&f, "claude"),
launch_conf(None, Some("qwen3.8"), None)
);
for other in ["codex", "nonesuch"] {
assert_eq!(
launch_defaults_from(&f, other),
LaunchConf::default(),
"{other}"
);
}
assert_eq!(launch_defaults_from(&[], "opencode"), LaunchConf::default());
}
#[test]
fn launch_defaults_are_found_through_case_and_alias() {
let f = [file(
"[launch.OpenCode]\nmodel = \"m\"\n[launch.copilot-cli]\nmodel = \"c\"",
)];
assert_eq!(
launch_defaults_from(&f, "OPENCODE").model.as_deref(),
Some("m")
);
for name in ["copilot", "copilot-cli", "Copilot"] {
assert_eq!(
launch_defaults_from(&f, name).model.as_deref(),
Some("c"),
"{name}"
);
}
}
#[test]
fn a_later_file_overrides_launch_defaults_one_key_at_a_time() {
let system = file(
"[launch.opencode]\nprovider = \"anthropic\"\nmodel = \"sys\"\nvariant = \"high\"",
);
let user = file("[launch.opencode]\nmodel = \"mine\"\nvariant = \"\"");
assert_eq!(
launch_defaults_from(&[system, user], "opencode"),
launch_conf(Some("anthropic"), Some("mine"), None)
);
let blank = file("[launch.opencode]\nprovider = \" \"\nmodel = \" m \"");
assert_eq!(
launch_defaults_from(&[blank], "opencode"),
launch_conf(None, Some("m"), None)
);
}
#[test]
fn a_launch_table_must_name_an_integration_a_key_and_a_variant() {
let err = |text: &str| parse(text).expect_err("must not parse");
assert!(err("[launch.opencod]\nmodel = \"m\"").contains("opencod"));
assert!(err("[launch.opencode]\nmodle = \"m\"").contains("modle"));
assert!(err("[launch.opencode]\nvariant = \"turbo\"").contains("turbo"));
assert!(err("[launch.opencode]\nvariant = 3").contains("string"));
assert!(err("[launch]\nmodel = \"m\"").contains("model"));
let both = "[launch.copilot]\nmodel = \"a\"\n[launch.copilot-cli]\nmodel = \"b\"";
assert!(err(both).contains("same integration"));
for variant in crate::cmd::run::variants().chain(["", " "]) {
parse(&format!("[launch.opencode]\nvariant = {variant:?}")).expect(variant);
}
}
#[test]
fn the_search_path_is_etc_then_the_user_directory() {
let paths = search_paths();
assert_eq!(
paths.first().expect("a system path"),
&system_dir().join(FILE)
);
assert!(system_dir().ends_with("etc/llmman"), "{:?}", system_dir());
assert!(system_dir().is_absolute(), "{:?}", system_dir());
assert!(
!paths.iter().any(|p| p.starts_with("/usr/share")),
"{paths:?}"
);
if let Some(user) = user_path() {
assert_eq!(paths.last(), Some(&user));
assert!(user.ends_with("llmman/llmman.conf"), "{}", user.display());
}
}
#[test]
fn there_is_one_user_directory_on_every_platform() {
assert_eq!(search_paths().len(), user_dir().iter().count() + 1);
if let Some(dir) = user_dir() {
assert!(dir.ends_with(".config/llmman"), "{}", dir.display());
}
}
#[cfg(unix)]
#[test]
fn a_group_or_world_readable_file_is_refused() {
use std::os::unix::fs::PermissionsExt;
let dir = std::env::temp_dir().join(format!("llmman-conf-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
let path = dir.join(FILE);
std::fs::write(&path, "[providers.openai]\napi_key = \"sk-x\"\n").expect("write");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).expect("chmod");
let err = owner_readable_only(&path).expect_err("0644 is refused");
assert!(err.contains("chmod 600"), "{err}");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).expect("chmod");
assert!(owner_readable_only(&path).is_ok());
std::fs::remove_dir_all(&dir).ok();
}
}