use std::path::{Path, PathBuf};
use anyhow::Context;
pub(super) fn check_daemon_key_transport(integration: &str) -> anyhow::Result<()> {
check_daemon_key_transport_to(
integration,
crate::auth::client_key().is_some(),
crate::daemon::connects_securely(),
&crate::daemon::server(),
)
}
fn check_daemon_key_transport_to(
integration: &str,
has_client_key: bool,
connects_securely: bool,
server: &str,
) -> anyhow::Result<()> {
anyhow::ensure!(
!has_client_key || connects_securely,
"{integration} needs a local llmman serve, or one over TLS: LLMMAN_HOST points at \
{server}, and the daemon API key would cross the network in cleartext."
);
Ok(())
}
pub(super) fn daemon_no_proxy_env(server: &str) -> Vec<(&'static str, String)> {
if !crate::daemon::connects_over_loopback() {
return Vec::new();
}
no_proxy_env(
server,
std::env::var("NO_PROXY").ok().as_deref(),
std::env::var("no_proxy").ok().as_deref(),
)
}
fn no_proxy_env(
server: &str,
upper: Option<&str>,
lower: Option<&str>,
) -> Vec<(&'static str, String)> {
let Some(host) = reqwest::Url::parse(server).ok().and_then(|url| {
url.host_str()
.map(|h| h.trim_matches(['[', ']']).to_string())
}) else {
return Vec::new();
};
[("NO_PROXY", upper, lower), ("no_proxy", lower, upper)]
.into_iter()
.map(|(name, own, other)| {
let inherited = [own, other]
.into_iter()
.flatten()
.map(|list| list.trim().trim_end_matches(','))
.find(|list| !list.is_empty());
let value = match inherited {
Some(list)
if list
.split(',')
.any(|e| e.trim().eq_ignore_ascii_case(&host)) =>
{
list.to_string()
}
Some(list) => format!("{list},{host}"),
None => host.clone(),
};
(name, value)
})
.collect()
}
pub(super) fn write_if_changed(path: &Path, contents: &str) -> anyhow::Result<()> {
if std::fs::read_to_string(path).ok().as_deref() == Some(contents) {
return Ok(());
}
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;
}
std::fs::write(path, contents).with_context(|| format!("write {}", path.display()))
}
pub(super) fn write_yaml_merged(
path: &Path,
label: &str,
merge: impl FnOnce(&serde_json::Value) -> serde_json::Value,
) -> anyhow::Result<()> {
write_structured_merged(
path,
label,
("YAML", "yml.bak"),
|text| Ok(yaml_serde::from_str(text)?),
|value| Ok(yaml_serde::to_string(value)?),
|raw, backup| {
if !backup.exists() {
return true;
}
yaml_serde::from_str::<serde_json::Value>(raw)
.and_then(|value| yaml_serde::to_string(&value))
.is_ok_and(|canonical| canonical != raw)
},
merge,
)
}
pub(super) fn yaml_quote(s: &str) -> String {
format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\""))
}
pub(super) fn forwarded_value<'a>(
extra_args: &'a [String],
long: &str,
short: &str,
) -> Option<&'a str> {
let mut found = None;
let mut args = super::before_terminator(extra_args)
.iter()
.map(String::as_str);
while let Some(a) = args.next() {
if a == long || a == short {
found = args.next().or(found);
} else if let Some(v) = [long, short]
.iter()
.find_map(|f| a.strip_prefix(*f).and_then(|rest| rest.strip_prefix('=')))
{
found = Some(v);
}
}
found.filter(|v| !v.is_empty())
}
pub(super) fn forwarded_model(extra_args: &[String]) -> Option<&str> {
forwarded_value(extra_args, "--model", "-m")
}
pub(super) fn expand_tilde(dir: &str, home: &Path) -> PathBuf {
match dir.strip_prefix('~') {
Some(rest) if rest.is_empty() || rest.starts_with(['/', '\\']) => {
home.join(rest.trim_start_matches(['/', '\\']))
}
_ => PathBuf::from(dir),
}
}
pub(super) fn write_json_merged(
path: &Path,
label: &str,
merge: impl FnOnce(&serde_json::Value) -> serde_json::Value,
) -> anyhow::Result<()> {
write_structured_merged(
path,
label,
("JSON", "json.bak"),
|text| {
let text = text.trim_start_matches('\u{feff}').trim();
Ok(serde_json::from_str(&strip_json_comments(text))?)
},
|value| {
let mut out = serde_json::to_string_pretty(value)?;
out.push('\n');
Ok(out)
},
|raw, backup| !backup.exists() || strip_json_comments(raw) != raw,
merge,
)
}
fn write_structured_merged(
path: &Path,
label: &str,
format: (&str, &str),
parse: impl FnOnce(&str) -> anyhow::Result<serde_json::Value>,
serialize: impl FnOnce(&serde_json::Value) -> anyhow::Result<String>,
should_backup: impl FnOnce(&str, &Path) -> bool,
merge: impl FnOnce(&serde_json::Value) -> serde_json::Value,
) -> anyhow::Result<()> {
let raw = match std::fs::read_to_string(path) {
Ok(raw) => Some(raw),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => return Err(e).with_context(|| format!("read {}", path.display())),
};
let existing = match raw.as_deref().map(str::trim) {
None | Some("") => serde_json::json!({}),
Some(text) => match parse(text) {
Ok(value) if value.is_object() => value,
_ => {
eprintln!(
"[llmman] {label}: {} is not a {} object; leaving it alone",
path.display(),
format.0
);
return Ok(());
}
},
};
let merged = merge(&existing);
if merged == existing {
return Ok(());
}
let dir = path.parent().context("settings path has no directory")?;
std::fs::create_dir_all(dir).with_context(|| format!("create {}", dir.display()))?;
if let Some(raw) = &raw {
let backup = path.with_extension(format.1);
if should_backup(raw, &backup) {
std::fs::copy(path, &backup)
.with_context(|| format!("back up {} to {}", path.display(), backup.display()))?;
}
}
let out = serialize(&merged)?;
crate::fsutil::write_atomic(path, out.as_bytes())
.with_context(|| format!("write {}", path.display()))
}
fn strip_json_comments(raw: &str) -> String {
let mut out = String::with_capacity(raw.len());
let mut chars = raw.chars().peekable();
let mut in_string = false;
let mut escaped = false;
while let Some(c) = chars.next() {
if in_string {
out.push(c);
if escaped {
escaped = false;
} else if c == '\\' {
escaped = true;
} else if c == '"' {
in_string = false;
}
continue;
}
match c {
'"' => {
in_string = true;
out.push(c);
}
'/' if chars.peek() == Some(&'/') => {
out.push(' ');
while chars.peek().is_some_and(|&n| n != '\n') {
chars.next();
out.push(' ');
}
}
'/' if chars.peek() == Some(&'*') => {
chars.next();
out.push_str(" ");
let mut prev = ' ';
for n in chars.by_ref() {
out.push(if n == '\n' { '\n' } else { ' ' });
if prev == '*' && n == '/' {
break;
}
prev = n;
}
}
_ => out.push(c),
}
}
out
}
pub(super) fn object_under<'a>(
parent: &'a mut serde_json::Map<String, serde_json::Value>,
key: &str,
) -> &'a mut serde_json::Map<String, serde_json::Value> {
let slot = parent.entry(key).or_insert_with(|| serde_json::json!({}));
if !slot.is_object() {
*slot = serde_json::json!({});
}
slot.as_object_mut().expect("set to an object just above")
}
pub(super) fn configured_pi_agent_dir() -> anyhow::Result<Option<PathBuf>> {
let Some(dir) = std::env::var("PI_CODING_AGENT_DIR")
.ok()
.filter(|dir| !dir.trim().is_empty())
else {
return Ok(None);
};
let dir = dir.trim();
if !dir.starts_with('~') {
return Ok(Some(PathBuf::from(dir)));
}
let home = crate::config::home_dir().context("no home directory")?;
Ok(Some(expand_tilde(dir, &home)))
}
pub(super) fn pi_model_entry(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
) -> serde_json::Value {
let input: &[&str] = if vision {
&["text", "image"]
} else {
&["text"]
};
let mut entry = serde_json::json!({
"id": model,
"name": model,
"input": input,
});
if reasons {
entry["reasoning"] = serde_json::json!(true);
}
if let Some(context) = context_window {
entry["contextWindow"] = serde_json::json!(context);
}
entry
}
pub(super) fn provider_models_merged(
existing: &serde_json::Value,
provider_name: &str,
entry: &serde_json::Value,
preserve_existing_model_fields: bool,
configure: impl FnOnce(&mut serde_json::Map<String, serde_json::Value>),
) -> serde_json::Value {
let mut root = existing.clone();
let Some(root_map) = root.as_object_mut() else {
return serde_json::json!({});
};
let provider = object_under(object_under(root_map, "providers"), provider_name);
let old_models = provider
.get("models")
.and_then(serde_json::Value::as_array)
.cloned()
.unwrap_or_default();
let mut replaced = false;
let mut models = Vec::with_capacity(old_models.len() + 1);
for old in old_models {
if old.get("id") != entry.get("id") {
models.push(old);
continue;
}
if replaced {
continue;
}
let mut merged = if preserve_existing_model_fields {
old
} else {
serde_json::json!({})
};
if let (Some(merged), Some(update)) = (merged.as_object_mut(), entry.as_object()) {
merged.extend(update.clone());
} else {
merged = entry.clone();
}
models.push(merged);
replaced = true;
}
if !replaced {
models.push(entry.clone());
}
configure(provider);
provider.insert("models".into(), serde_json::json!(models));
root
}
#[cfg(test)]
mod tests {
use super::super::{pair_context_window, served_context_window};
use super::*;
#[test]
fn no_proxy_adds_the_daemon_host_to_what_is_inherited() {
let server = "http://127.0.0.1:17434";
for (upper, lower, want_upper, want_lower) in [
(None, None, "127.0.0.1", "127.0.0.1"),
(Some("a.test"), None, "a.test,127.0.0.1", "a.test,127.0.0.1"),
(None, Some("b.test"), "b.test,127.0.0.1", "b.test,127.0.0.1"),
(
Some("a.test,"),
Some("b.test"),
"a.test,127.0.0.1",
"b.test,127.0.0.1",
),
(Some(""), Some(" "), "127.0.0.1", "127.0.0.1"),
(
Some("a.test"),
Some(""),
"a.test,127.0.0.1",
"a.test,127.0.0.1",
),
(
Some("a.test, 127.0.0.1"),
None,
"a.test, 127.0.0.1",
"a.test, 127.0.0.1",
),
] {
assert_eq!(
no_proxy_env(server, upper, lower),
[
("NO_PROXY", want_upper.to_string()),
("no_proxy", want_lower.to_string())
],
"{upper:?} {lower:?}"
);
}
}
#[test]
fn no_proxy_names_the_host_without_brackets_or_port() {
let env = no_proxy_env("http://[::1]:17434", Some("a.test"), None);
assert_eq!(env[0], ("NO_PROXY", "a.test,::1".to_string()));
let env = no_proxy_env("http://host.docker.internal:17434", None, None);
assert_eq!(env[1], ("no_proxy", "host.docker.internal".to_string()));
assert!(no_proxy_env("not a url", None, None).is_empty());
}
#[test]
fn a_real_daemon_key_never_crosses_remote_cleartext() {
let remote_http = "http://192.0.2.1:17434";
let error = check_daemon_key_transport_to("agent", true, false, remote_http)
.unwrap_err()
.to_string();
assert!(error.contains("agent"));
assert!(error.contains(remote_http));
assert!(error.contains("cleartext"));
assert!(check_daemon_key_transport_to("agent", false, false, remote_http).is_ok());
assert!(check_daemon_key_transport_to("agent", true, true, remote_http).is_ok());
}
#[test]
fn yaml_quote_escapes_keywords_and_metacharacters() {
assert_eq!(yaml_quote("qwen3.5:0.8b"), "\"qwen3.5:0.8b\"");
assert_eq!(yaml_quote("null"), "\"null\"");
assert_eq!(yaml_quote("true"), "\"true\"");
assert_eq!(
yaml_quote(r#"a "quoted" \ value"#),
r#""a \"quoted\" \\ value""#
);
}
#[test]
fn forwarded_model_takes_the_last_spelling() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert_eq!(forwarded_model(&args(&["--model", "b"])), Some("b"));
assert_eq!(forwarded_model(&args(&["-m=b", "--model", "c"])), Some("c"));
assert_eq!(forwarded_model(&args(&["--model=b", "-m", "c"])), Some("c"));
assert_eq!(forwarded_model(&args(&["-p", "x"])), None);
assert_eq!(forwarded_model(&args(&["--model"])), None);
assert_eq!(forwarded_model(&args(&["--model="])), None);
assert_eq!(forwarded_model(&args(&["--", "--model", "c"])), None);
assert_eq!(
forwarded_model(&args(&["--model", "b", "--", "--model", "c"])),
Some("b")
);
}
#[test]
fn forwarded_value_reads_either_spelling_of_any_flag() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
let cd = |a: &[&str]| forwarded_value(&args(a), "--cd", "-C").map(str::to_owned);
assert_eq!(cd(&["-C", "/b"]).as_deref(), Some("/b"));
assert_eq!(cd(&["--cd=/b", "--cd", "/c"]).as_deref(), Some("/c"));
assert_eq!(cd(&["exec", "-C=/b", "hi"]).as_deref(), Some("/b"));
assert_eq!(cd(&["--cdx=/b", "-Cx=/c"]), None);
assert_eq!(cd(&["--", "-C", "/b"]), None);
}
#[test]
fn strip_json_comments_keeps_strings_and_columns() {
let raw =
"{\n // note\n \"url\": \"http://h//v1\", /* block\n */ \"q\": \"a\\\"//b\"\n}\n";
let stripped = strip_json_comments(raw);
assert_eq!(stripped.chars().count(), raw.chars().count());
assert_eq!(stripped.lines().count(), raw.lines().count());
let v: serde_json::Value = serde_json::from_str(&stripped).unwrap();
assert_eq!(v["url"], "http://h//v1");
assert_eq!(v["q"], "a\"//b");
assert_eq!(strip_json_comments("{\"a\": 1}"), "{\"a\": 1}");
}
#[test]
fn expand_tilde_reads_the_forms_qwen_code_reads() {
let home = Path::new("/h");
assert_eq!(expand_tilde("~/alt", home), PathBuf::from("/h/alt"));
assert_eq!(expand_tilde("~", home), PathBuf::from("/h"));
assert_eq!(expand_tilde("/abs", home), PathBuf::from("/abs"));
assert_eq!(expand_tilde("~user/x", home), PathBuf::from("~user/x"));
}
#[test]
fn pi_model_entry_declares_what_the_daemon_serves() {
let entry = pi_model_entry("qwen3.5:0.8b", true, true, Some(32768));
assert_eq!(entry["id"], "qwen3.5:0.8b");
assert_eq!(entry["name"], "qwen3.5:0.8b");
assert_eq!(entry["input"], serde_json::json!(["text", "image"]));
assert_eq!(entry["reasoning"], true);
assert_eq!(entry["contextWindow"], 32768);
let plain = pi_model_entry("smol", false, false, None);
assert_eq!(plain["input"], serde_json::json!(["text"]));
assert_eq!(plain.get("reasoning"), None);
assert_eq!(plain.get("contextWindow"), None);
}
#[test]
fn pi_model_entry_declares_the_resolved_window_not_the_trained_context() {
let pair = pair_context_window(Some(32_768), Some(200_000));
assert_eq!(pair, Some(200_000));
let entry = pi_model_entry("gemma4", false, false, pair);
assert_eq!(entry["contextWindow"], 200_000);
let default = u64::from(crate::cmd::serve::DEFAULT_CTX_SIZE);
let served = served_context_window(None, Some(1 << 20));
assert_eq!(served, Some(default));
let entry = pi_model_entry("big", false, false, served);
assert_eq!(entry["contextWindow"], default);
}
}