use std::path::{Path, PathBuf};
use anyhow::{anyhow, bail, Context, Result};
use clap::{Args, Subcommand};
use toml_edit::{DocumentMut, Item, Key, Table, TableLike, Value};
#[derive(Args, Debug)]
pub struct ConfigArgs {
#[command(subcommand)]
pub command: ConfigCommand,
#[arg(long, global = true, conflicts_with_all = ["user", "file"])]
pub system: bool,
#[arg(long, global = true, conflicts_with = "file")]
pub user: bool,
#[arg(long, global = true, value_name = "PATH")]
pub file: Option<PathBuf>,
}
#[derive(Subcommand, Debug)]
pub enum ConfigCommand {
List(ListArgs),
Get(GetArgs),
Set(SetArgs),
Unset(UnsetArgs),
Edit,
}
#[derive(Args, Debug)]
pub struct ListArgs {
#[arg(long)]
pub show_origin: bool,
}
#[derive(Args, Debug)]
pub struct GetArgs {
#[arg(value_name = "KEY")]
pub key: String,
}
#[derive(Args, Debug)]
pub struct SetArgs {
#[arg(value_name = "KEY")]
pub key: String,
#[arg(value_name = "VALUE")]
pub value: String,
}
#[derive(Args, Debug)]
pub struct UnsetArgs {
#[arg(value_name = "KEY")]
pub key: String,
}
pub fn run(args: &ConfigArgs) -> Result<()> {
match &args.command {
ConfigCommand::List(a) => list(args, a),
ConfigCommand::Get(a) => get(args, a),
ConfigCommand::Set(a) => set(args, a),
ConfigCommand::Unset(a) => unset(args, a),
ConfigCommand::Edit => edit(args),
}
}
impl ConfigArgs {
fn selected(&self) -> Result<Option<PathBuf>> {
if let Some(file) = &self.file {
return Ok(Some(file.clone()));
}
if self.system {
return Ok(Some(crate::config::system_path()));
}
if self.user {
return Ok(Some(user_path()?));
}
Ok(None)
}
fn read_paths(&self) -> Result<Vec<PathBuf>> {
Ok(match self.selected()? {
Some(path) => vec![path],
None => crate::config::search_paths(),
})
}
fn write_path(&self) -> Result<PathBuf> {
match self.selected()? {
Some(path) => Ok(path),
None => user_path(),
}
}
}
fn user_path() -> Result<PathBuf> {
crate::config::user_path()
.ok_or_else(|| anyhow!("no home directory to hold llmman.conf; use --file"))
}
fn entries(doc: &DocumentMut) -> Vec<(String, String)> {
let mut out = Vec::new();
walk_item(doc.as_item(), "", &mut out);
out
}
fn walk_item(item: &Item, prefix: &str, out: &mut Vec<(String, String)>) {
match item {
Item::Table(table) => walk_table(table, prefix, out),
Item::ArrayOfTables(tables) => {
for (i, table) in tables.iter().enumerate() {
walk_table(table, &format!("{prefix}[{i}]"), out);
}
}
Item::Value(value) => walk_value(value, prefix, out),
Item::None => {}
}
}
fn walk_table(table: &Table, prefix: &str, out: &mut Vec<(String, String)>) {
for (key, item) in table.iter() {
walk_item(item, &join(prefix, key), out);
}
}
fn walk_value(value: &Value, prefix: &str, out: &mut Vec<(String, String)>) {
match value {
Value::InlineTable(table) => {
for (key, value) in table.iter() {
walk_value(value, &join(prefix, key), out);
}
}
Value::Array(array) => {
for (i, value) in array.iter().enumerate() {
walk_value(value, &format!("{prefix}[{i}]"), out);
}
}
Value::String(s) => out.push((prefix.to_string(), s.value().clone())),
other => out.push((prefix.to_string(), other.to_string().trim().to_string())),
}
}
fn join(prefix: &str, key: &str) -> String {
let key = crate::config::toml_key(key);
if prefix.is_empty() {
key
} else {
format!("{prefix}.{key}")
}
}
fn parse_key(name: &str) -> Result<Vec<Key>> {
let keys = Key::parse(name).map_err(|e| anyhow!("invalid key `{name}`: {e}"))?;
if keys.is_empty() {
bail!("invalid key `{name}`: a key cannot be empty");
}
Ok(keys.iter().map(|key| Key::new(key.get())).collect())
}
fn is_credential(key: &str) -> bool {
key == "api_key" || key.ends_with(".api_key") || key == "auth.api_keys"
}
fn carries_key(doc: &DocumentMut) -> bool {
entries(doc)
.iter()
.any(|(key, value)| is_credential(key) && !value.trim().is_empty())
}
fn read(path: &Path) -> Result<DocumentMut> {
match std::fs::read_to_string(path) {
Ok(text) => text
.parse::<DocumentMut>()
.with_context(|| format!("parsing {}", path.display())),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(DocumentMut::new()),
Err(e) => Err(e).with_context(|| format!("reading {}", path.display())),
}
}
fn read_effective(path: &Path) -> Result<DocumentMut> {
let doc = read(path)?;
if carries_key(&doc) {
if let Err(e) = crate::config::owner_readable_only(path) {
eprintln!(
"[llmman] warning: the API keys in {} are ignored: {e}",
path.display()
);
}
}
Ok(doc)
}
fn list(args: &ConfigArgs, opts: &ListArgs) -> Result<()> {
for path in args.read_paths()? {
for (key, value) in entries(&read_effective(&path)?) {
let value = if is_credential(&key) {
"<redacted>"
} else {
&value
};
if opts.show_origin {
println!("{}\t{key}={value}", path.display());
} else {
println!("{key}={value}");
}
}
}
Ok(())
}
fn get(args: &ConfigArgs, opts: &GetArgs) -> Result<()> {
let mut found = None;
for path in args.read_paths()? {
if let Some((_, value)) = entries(&read_effective(&path)?)
.into_iter()
.rev()
.find(|(key, _)| *key == opts.key)
{
found = Some(value);
}
}
match found {
Some(value) => {
println!("{value}");
Ok(())
}
None => bail!("{}: not set", opts.key),
}
}
fn set(args: &ConfigArgs, opts: &SetArgs) -> Result<()> {
let path = args.write_path()?;
let mut doc = read(&path)?;
set_in(&mut doc, &opts.key, &opts.value)?;
save(&path, &doc)
}
fn unset(args: &ConfigArgs, opts: &UnsetArgs) -> Result<()> {
let path = args.write_path()?;
let mut doc = read(&path)?;
unset_in(&mut doc, &opts.key)?;
save(&path, &doc)
}
pub(crate) fn write_provider_key(path: &Path, id: &str, key: Option<&str>) -> Result<bool> {
static WRITING: std::sync::Mutex<()> = std::sync::Mutex::new(());
let _one = WRITING
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let name = format!("providers.{}.api_key", crate::config::toml_key(id));
let mut doc = read(path)?;
let changed = match key {
Some(key) => {
set_in(&mut doc, &name, key)?;
true
}
None => unset_in(&mut doc, &name).is_ok(),
};
if changed {
save(path, &doc)?;
}
crate::config::reload_provider_keys().map_err(|e| anyhow!(e))?;
Ok(changed)
}
fn set_in(doc: &mut DocumentMut, name: &str, value: &str) -> Result<()> {
let keys = parse_key(name)?;
let (leaf, parents) = keys.split_last().expect("parse_key rejects an empty key");
let mut table: &mut dyn TableLike = doc.as_table_mut();
for key in parents {
table = table
.entry_format(key)
.or_insert_with(|| {
let mut new = Table::new();
new.set_implicit(true);
Item::Table(new)
})
.as_table_like_mut()
.ok_or_else(|| anyhow!("{name}: {} is not a table", key.display_repr()))?;
}
let item = table.entry_format(leaf).or_insert(Item::None);
let mut replacement = toml_edit::value(value);
if let (Some(old), Some(new)) = (item.as_value(), replacement.as_value_mut()) {
*new.decor_mut() = old.decor().clone();
}
*item = replacement;
Ok(())
}
fn unset_in(doc: &mut DocumentMut, name: &str) -> Result<()> {
let keys = parse_key(name)?;
let (leaf, parents) = keys.split_last().expect("parse_key rejects an empty key");
let mut table: &mut dyn TableLike = doc.as_table_mut();
for key in parents {
table = table
.get_mut(key.get())
.and_then(Item::as_table_like_mut)
.ok_or_else(|| anyhow!("{name}: not set"))?;
}
if table.remove(leaf.get()).is_none() {
bail!("{name}: not set");
}
Ok(())
}
fn save(path: &Path, doc: &DocumentMut) -> Result<()> {
let text = doc.to_string();
crate::config::parse(&text)
.map_err(|e| anyhow!("refusing to write {}: {e}", path.display()))?;
write_atomic(path, &text, carries_key(doc))
}
fn write_atomic(path: &Path, text: &str, carries_key: bool) -> Result<()> {
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))?;
}
let tmp = path.with_extension(format!("{}.tmp", std::process::id()));
#[cfg(unix)]
{
use std::io::Write as _;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let existing = std::fs::metadata(path)
.ok()
.map(|m| m.permissions().mode() & 0o7777);
let mut mode = existing.unwrap_or(0o644);
if carries_key && mode & 0o077 != 0 {
if existing.is_some() {
eprintln!(
"[llmman] tightening {} to 0600: it now holds an API key",
path.display()
);
}
mode = 0o600;
}
std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(mode)
.open(&tmp)
.and_then(|mut f| {
f.set_permissions(std::fs::Permissions::from_mode(mode))?;
f.write_all(text.as_bytes())
})
.with_context(|| format!("writing {}", tmp.display()))?;
}
#[cfg(not(unix))]
{
let _ = carries_key;
std::fs::write(&tmp, text).with_context(|| format!("writing {}", tmp.display()))?;
}
std::fs::rename(&tmp, path)
.inspect_err(|_| {
let _ = std::fs::remove_file(&tmp);
})
.with_context(|| format!("replacing {}", path.display()))
}
fn edit(args: &ConfigArgs) -> Result<()> {
let path = args.write_path()?;
prepare(&path)?;
let editor = editor();
let status = editor_command(&editor, &path)?
.status()
.with_context(|| format!("running {editor}"))?;
if !status.success() {
bail!("{editor} exited with {status}");
}
if !path.exists() {
return Ok(()); }
let doc = read(&path)?;
let text = doc.to_string();
crate::config::parse(&text).map_err(|e| anyhow!("{} is not valid: {e}", path.display()))?;
write_atomic(&path, &text, carries_key(&doc))
}
fn prepare(path: &Path) -> Result<()> {
match path.parent() {
Some(dir) => {
std::fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))
}
None => Ok(()),
}
}
fn editor_command(editor: &str, path: &Path) -> Result<std::process::Command> {
if editor.trim().is_empty() {
bail!("$VISUAL/$EDITOR is set but empty");
}
#[cfg(unix)]
{
let mut cmd = std::process::Command::new("sh");
cmd.arg("-c")
.arg(format!("{editor} \"$1\""))
.arg("sh")
.arg(path);
Ok(cmd)
}
#[cfg(not(unix))]
{
let mut words = editor.split_whitespace();
let program = words.next().expect("a non-empty editor has a program");
let mut cmd = std::process::Command::new(program);
cmd.args(words).arg(path);
Ok(cmd)
}
}
fn editor() -> String {
for var in ["VISUAL", "EDITOR"] {
match std::env::var(var) {
Ok(value) if !value.trim().is_empty() => return value,
_ => {}
}
}
if cfg!(windows) {
"notepad".to_string()
} else {
"vi".to_string()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn doc(text: &str) -> DocumentMut {
text.parse::<DocumentMut>().expect("valid toml")
}
fn keys(text: &str) -> Vec<String> {
entries(&doc(text))
.into_iter()
.map(|(k, v)| format!("{k}={v}"))
.collect()
}
fn scratch(label: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("llmman-{label}-{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
dir
}
#[test]
fn every_scalar_is_addressable_including_one_in_an_array_of_tables() {
let listed = keys(
r#"
[aliases]
gemma4 = "docker.io/ai/gemma4"
[verify]
default = "warn"
[[verify.trust]]
pattern = "docker.io/myorg/**"
keys = ["keys/myorg.pub", "keys/old.pub"]
"#,
);
assert_eq!(
listed,
vec![
"aliases.gemma4=docker.io/ai/gemma4",
"verify.default=warn",
"verify.trust[0].pattern=docker.io/myorg/**",
"verify.trust[0].keys[0]=keys/myorg.pub",
"verify.trust[0].keys[1]=keys/old.pub",
],
"{listed:?}"
);
}
#[test]
fn a_key_needing_quotes_is_printed_and_parsed_the_way_toml_spells_it() {
let listed = keys("[providers.\"wafer.ai\"]\napi_key = \"sk-x\"");
assert_eq!(
listed,
vec![r#"providers."wafer.ai".api_key=sk-x"#],
"{listed:?}"
);
let mut d = doc("");
set_in(&mut d, r#"providers."wafer.ai".api_key"#, "sk-y").expect("set");
assert_eq!(
entries(&d),
vec![(
r#"providers."wafer.ai".api_key"#.to_string(),
"sk-y".to_string()
)],
"{d}"
);
}
#[test]
fn set_preserves_the_comments_and_layout_of_everything_it_did_not_touch() {
let mut d = doc("# my models\n[aliases]\ngemma4 = \"docker.io/ai/gemma4\" # local\n");
set_in(&mut d, "aliases.qwen", "docker.io/ai/qwen").expect("set");
set_in(&mut d, "providers.openai.api_key", "sk-new").expect("set");
let rendered = d.to_string();
assert!(
rendered.starts_with("# my models\n[aliases]\n"),
"{rendered}"
);
assert!(
rendered.contains("gemma4 = \"docker.io/ai/gemma4\" # local"),
"{rendered}"
);
assert!(
rendered.contains("qwen = \"docker.io/ai/qwen\""),
"{rendered}"
);
assert!(rendered.contains("[providers.openai]"), "{rendered}");
assert!(!rendered.contains("[providers]\n"), "{rendered}");
}
#[test]
fn set_replaces_a_value_in_place_keeping_its_comment() {
let mut d = doc("[verify]\ndefault = \"off\"\n");
set_in(&mut d, "verify.default", "enforce").expect("set");
assert_eq!(
entries(&d),
vec![("verify.default".to_string(), "enforce".to_string())],
"{d}"
);
crate::config::parse(&d.to_string()).expect("still valid");
let mut d = doc("[aliases]\ngemma4 = \"old\" # what I usually pull\n");
set_in(&mut d, "aliases.gemma4", "new").expect("set");
assert_eq!(
d.to_string(),
"[aliases]\ngemma4 = \"new\" # what I usually pull\n",
"{d}"
);
}
#[test]
fn a_section_written_as_an_inline_table_is_still_writable() {
let mut d = doc("aliases = { gemma4 = \"docker.io/ai/gemma4\" }\n");
assert_eq!(
keys("aliases = { gemma4 = \"docker.io/ai/gemma4\" }"),
vec!["aliases.gemma4=docker.io/ai/gemma4"]
);
set_in(&mut d, "aliases.gemma4", "docker.io/ai/gemma5").expect("set");
set_in(&mut d, "aliases.qwen", "docker.io/ai/qwen").expect("set");
assert_eq!(
entries(&d),
vec![
(
"aliases.gemma4".to_string(),
"docker.io/ai/gemma5".to_string()
),
("aliases.qwen".to_string(), "docker.io/ai/qwen".to_string()),
],
"{d}"
);
unset_in(&mut d, "aliases.qwen").expect("unset");
assert_eq!(entries(&d).len(), 1, "{d}");
crate::config::parse(&d.to_string()).expect("still valid");
}
#[test]
fn a_key_no_section_of_the_format_has_is_rejected_before_it_is_written() {
let mut d = doc("");
set_in(&mut d, "providers.openai.api_kye", "sk-x").expect("toml accepts it");
let err = crate::config::parse(&d.to_string()).expect_err("llmman.conf must not");
assert!(err.contains("api_kye"), "{err}");
let mut d = doc("");
set_in(&mut d, "alias.gemma4", "docker.io/ai/gemma4").expect("toml accepts it");
assert!(crate::config::parse(&d.to_string()).is_err(), "{d}");
}
#[test]
fn launch_defaults_are_settable_and_checked_before_they_are_written() {
let mut d = doc("");
for (key, value) in [
("launch.opencode.provider", "anthropic"),
("launch.opencode.model", "claude-sonnet-5-5"),
("launch.opencode.variant", "xhigh"),
] {
set_in(&mut d, key, value).unwrap();
}
crate::config::parse(&d.to_string()).expect("a valid launch table");
assert_eq!(
keys(&d.to_string()),
[
"launch.opencode.provider=anthropic",
"launch.opencode.model=claude-sonnet-5-5",
"launch.opencode.variant=xhigh"
]
);
for (key, value) in [
("launch.opencod.model", "m"),
("launch.opencode.variant", "turbo"),
("launch.opencode.modle", "m"),
] {
let mut d = doc("");
set_in(&mut d, key, value).unwrap();
assert!(crate::config::parse(&d.to_string()).is_err(), "{key}");
}
}
#[test]
fn invalid_managed_values_never_replace_the_saved_configuration() {
let dir = scratch("managed-validation");
let path = dir.join("llmman.conf");
let original = "[managed]\nenabled = \"true\"\nread_timeout_seconds = \"300\"\n";
std::fs::write(&path, original).unwrap();
for (key, value) in [
("managed.enabled", "yes"),
("managed.enabled", ""),
("managed.read_timeout_seconds", "-1"),
("managed.read_timeout_seconds", "1.5"),
("managed.read_timeout_seconds", "4294967296"),
] {
let mut edited = read(&path).unwrap();
set_in(&mut edited, key, value).unwrap();
assert!(save(&path, &edited).is_err(), "{key}={value}");
assert_eq!(std::fs::read_to_string(&path).unwrap(), original);
}
let mut edited = read(&path).unwrap();
set_in(&mut edited, "managed.enabled", "false").unwrap();
set_in(&mut edited, "managed.read_timeout_seconds", "0").unwrap();
save(&path, &edited).unwrap();
crate::config::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn unset_reports_a_key_that_was_never_set() {
let mut d = doc("[providers.openai]\napi_key = \"sk-x\"\n");
let err = unset_in(&mut d, "providers.groq.api_key").expect_err("absent section");
assert!(err.to_string().contains("not set"), "{err}");
let err = unset_in(&mut d, "providers.openai.token").expect_err("absent key");
assert!(err.to_string().contains("not set"), "{err}");
unset_in(&mut d, "providers.openai.api_key").expect("set, so removable");
assert!(entries(&d).is_empty(), "{d}");
}
#[test]
fn only_a_credential_is_treated_as_one() {
assert!(carries_key(&doc("[providers.openai]\napi_key = \"sk-x\"")));
assert!(!carries_key(&doc("[providers.openai]\napi_key = \"\"")));
assert!(!carries_key(&doc("[aliases]\napi_keyring = \"x\"")));
assert!(!carries_key(&doc("[verify]\ndefault = \"off\"")));
}
#[cfg(unix)]
#[test]
fn only_a_file_holding_a_key_is_made_owner_only() {
use std::os::unix::fs::PermissionsExt;
let dir = scratch("mode");
let path = dir.join("llmman.conf");
let mode = |p: &Path| std::fs::metadata(p).expect("metadata").permissions().mode() & 0o777;
let mut d = doc("");
set_in(&mut d, "aliases.gemma4", "docker.io/ai/gemma4").expect("set");
save(&path, &d).expect("save");
assert_eq!(mode(&path), 0o644, "a new file with no key in it");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o640)).expect("chmod");
let mut d = read(&path).expect("read");
set_in(&mut d, "aliases.qwen", "docker.io/ai/qwen").expect("set");
save(&path, &d).expect("save");
assert_eq!(mode(&path), 0o640, "a mode an admin chose is kept");
let mut d = read(&path).expect("read");
set_in(&mut d, "providers.openai.api_key", "sk-x").expect("set");
save(&path, &d).expect("save");
assert_eq!(mode(&path), 0o600, "tightened once it holds a key");
std::fs::remove_file(&path).expect("rm");
let mut d = doc("");
set_in(&mut d, "providers.openai.api_key", "sk-x").expect("set");
save(&path, &d).expect("save");
assert_eq!(mode(&path), 0o600, "a new file holding a key");
for key in ["auth.api_keys", "aggregation.api_key"] {
std::fs::remove_file(&path).expect("rm");
let mut d = doc("");
set_in(&mut d, key, "k").expect("set");
save(&path, &d).expect("save");
assert_eq!(mode(&path), 0o600, "{key}");
}
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn concurrent_provider_key_writes_keep_both() {
let _one = crate::config::PROVIDER_KEYS_TEST_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let dir = scratch("provider-keys-race");
let path = dir.join("llmman.conf");
std::fs::remove_file(&path).ok();
let ids: Vec<String> = (0..8).map(|i| format!("p{i}")).collect();
std::thread::scope(|s| {
for id in &ids {
let path = &path;
s.spawn(move || {
write_provider_key(path, id, Some(&format!("key-{id}"))).expect("write")
});
}
});
let conf =
crate::config::parse(&std::fs::read_to_string(&path).expect("read")).expect("parses");
let keys = conf.provider_keys();
for id in &ids {
assert_eq!(
keys.get(id).map(String::as_str),
Some(format!("key-{id}").as_str()),
"{id}"
);
}
std::fs::remove_dir_all(&dir).ok();
}
#[cfg(unix)]
#[test]
fn provider_key_writes_keep_the_file_owner_only() {
use std::os::unix::fs::PermissionsExt;
let _one = crate::config::PROVIDER_KEYS_TEST_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let dir = scratch("provider-keys-mode");
let path = dir.join("llmman.conf");
let mode = |p: &Path| std::fs::metadata(p).expect("metadata").permissions().mode() & 0o777;
std::fs::remove_file(&path).ok();
assert!(write_provider_key(&path, "anthropic", Some("sk-a")).expect("set"));
assert_eq!(mode(&path), 0o600, "a new file holding a key");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o400)).expect("chmod");
assert!(write_provider_key(&path, "openai", Some("sk-o")).expect("set"));
assert_eq!(mode(&path), 0o400, "a stricter mode is kept");
assert!(write_provider_key(&path, "anthropic", None).expect("unset"));
assert!(!write_provider_key(&path, "anthropic", None).expect("unset again"));
let conf =
crate::config::parse(&std::fs::read_to_string(&path).expect("read")).expect("parses");
assert_eq!(conf.provider_keys().get("anthropic"), None);
assert_eq!(
conf.provider_keys().get("openai").map(String::as_str),
Some("sk-o")
);
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn an_absent_file_reads_as_empty() {
let path = std::env::temp_dir().join(format!("llmman-absent-{}.conf", std::process::id()));
std::fs::remove_file(&path).ok();
assert!(entries(&read(&path).expect("absent is empty")).is_empty());
}
#[test]
fn a_second_write_replaces_the_file_in_place() {
let dir = scratch("rewrite");
let path = dir.join("llmman.conf");
let mut d = doc("");
set_in(&mut d, "aliases.gemma4", "docker.io/ai/gemma4").expect("set");
save(&path, &d).expect("first save");
let mut d = read(&path).expect("read back");
set_in(&mut d, "aliases.gemma4", "docker.io/ai/gemma5").expect("set");
save(&path, &d).expect("second save must replace, not fail");
assert_eq!(
entries(&read(&path).expect("read back")),
vec![(
"aliases.gemma4".to_string(),
"docker.io/ai/gemma5".to_string()
)]
);
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn edit_prepares_the_directory_but_not_the_file() {
let root = scratch("edit");
let path = root.join("never").join("existed").join("llmman.conf");
prepare(&path).expect("prepare");
assert!(path.parent().expect("a parent").is_dir());
assert!(!path.exists(), "{}", path.display());
std::fs::remove_dir_all(&root).ok();
}
#[cfg(unix)]
#[test]
fn an_editor_with_spaces_and_flags_reaches_the_file() {
use std::os::unix::fs::PermissionsExt;
let dir = scratch("editor");
let script = dir.join("my editor.sh");
std::fs::write(&script, "#!/bin/sh\nprintf '%s\\n' \"$1\" > \"$2\"\n").expect("write");
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o700)).expect("chmod");
let out = dir.join("out");
let status = editor_command(&format!("\"{}\" --flag", script.display()), &out)
.expect("a command")
.status()
.expect("run");
assert!(status.success(), "{status}");
assert_eq!(
std::fs::read_to_string(&out).expect("read"),
"--flag\n",
"the flag and the path both arrived"
);
assert!(editor_command(" ", &out).is_err(), "an empty editor");
std::fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_malformed_key_is_refused() {
assert!(parse_key("").is_err());
assert!(parse_key("providers..api_key").is_err());
assert!(parse_key("providers.\"unterminated").is_err());
assert_eq!(parse_key("aliases.gemma4").expect("valid").len(), 2);
}
}