repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/connection_settings.rs
Raw//! Typed host configuration resolution (`SMH-SPEC-SPEC0001`, Configuration).
//!
//! Only include_usage is configurable; authority and protocol features are not.
use crate::trust::TrustStore;
use smith::error::{Result, SmithError};
use smith::provider::{ProviderSettingsProvenance, ProviderSettingsRecord};
use std::path::Path;
const SETTINGS_BYTES_MAX: usize = 16 * 1024;
/// Resolve product → user → trusted project → explicit scalar replacement.
///
/// No list settings are declared by the supported protocol schema.
/// Returned values own their snapshot; no configuration is reread at dispatch.
/// The bool reports an unresolved project trust decision for visible diagnostics.
///
/// # Errors
/// Rejects unknown fields (including all host authority fields), invalid types,
/// oversized files, and filesystem or trust-store failures.
pub fn resolve(
user_file: &Path,
project: &Path,
trust: &TrustStore,
explicit: Option<bool>,
) -> Result<(ProviderSettingsRecord, bool)> {
// Resolve trust before inspecting any project configuration path.
let trusted = trust.decision(project)?.is_some();
let mut effective = ProviderSettingsRecord {
include_usage: true,
provenance: ProviderSettingsProvenance::BuiltIn,
};
replace_file(&mut effective, user_file, ProviderSettingsProvenance::User)?;
if trusted {
replace_file(
&mut effective,
&project.join(".smith/provider-settings.kdl"),
ProviderSettingsProvenance::TrustedProject,
)?;
}
if let Some(include_usage) = explicit {
effective = ProviderSettingsRecord {
include_usage,
provenance: ProviderSettingsProvenance::Explicit,
};
}
Ok((effective, !trusted))
}
fn replace_file(
effective: &mut ProviderSettingsRecord,
path: &Path,
source: ProviderSettingsProvenance,
) -> Result<()> {
match std::fs::metadata(path) {
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()),
Err(error) => return Err(setting_error(path, error)),
Ok(_) => {}
}
let bytes = crate::plugins::read_bounded(path, SETTINGS_BYTES_MAX, "provider settings")?;
let input = std::str::from_utf8(&bytes).map_err(|error| setting_error(path, error))?;
if let Some(include_usage) = crate::plugins::parse_provider_settings(input, path)? {
*effective = ProviderSettingsRecord {
include_usage,
provenance: source,
};
}
Ok(())
}
fn setting_error(path: &Path, error: impl std::fmt::Display) -> SmithError {
SmithError::Config {
field: path.display().to_string(),
message: format!("invalid provider settings: {error}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
use std::sync::atomic::{AtomicUsize, Ordering};
struct Fixture(PathBuf);
impl Fixture {
fn new() -> Self {
static NEXT: AtomicUsize = AtomicUsize::new(0);
let path = std::env::temp_dir().join(format!(
"smith-connection-settings-{}-{}",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
));
std::fs::create_dir(&path).unwrap();
std::fs::create_dir(path.join(".smith")).unwrap();
Self(path)
}
fn resolve(&self, explicit: Option<bool>) -> Result<(ProviderSettingsRecord, bool)> {
resolve(
&self.0.join("user.kdl"),
&self.0,
&TrustStore::at(self.0.join("trust")),
explicit,
)
}
fn trust(&self) {
TrustStore::at(self.0.join("trust"))
.grant(&self.0, &[])
.unwrap();
}
}
impl Drop for Fixture {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
#[test]
fn sources_replace_in_order_and_snapshots_do_not_follow_file_changes() {
let fixture = Fixture::new();
let (builtin, ignored) = fixture.resolve(None).unwrap();
assert!(ignored);
assert_eq!(
builtin,
ProviderSettingsRecord {
include_usage: true,
provenance: ProviderSettingsProvenance::BuiltIn
}
);
std::fs::write(fixture.0.join("user.kdl"), "include-usage #false").unwrap();
let (user, _) = fixture.resolve(None).unwrap();
assert_eq!(
user,
ProviderSettingsRecord {
include_usage: false,
provenance: ProviderSettingsProvenance::User
}
);
std::fs::write(
fixture.0.join(".smith/provider-settings.kdl"),
"include-usage #true",
)
.unwrap();
assert_eq!(fixture.resolve(None).unwrap().0, user);
fixture.trust();
let (project, ignored) = fixture.resolve(None).unwrap();
assert!(!ignored);
assert_eq!(
project,
ProviderSettingsRecord {
include_usage: true,
provenance: ProviderSettingsProvenance::TrustedProject
}
);
assert_eq!(
fixture.resolve(Some(false)).unwrap().0,
ProviderSettingsRecord {
include_usage: false,
provenance: ProviderSettingsProvenance::Explicit
}
);
std::fs::write(fixture.0.join("user.kdl"), "").unwrap();
std::fs::write(fixture.0.join(".smith/provider-settings.kdl"), "").unwrap();
assert_eq!(fixture.resolve(None).unwrap().0, builtin);
assert!(!user.include_usage);
assert_eq!(
project.provenance,
ProviderSettingsProvenance::TrustedProject
);
assert_eq!(std::mem::size_of::<ProviderSettingsRecord>(), 2);
}
#[test]
fn unknown_settings_and_host_authority_are_rejected_even_under_explicit_override() {
let fixture = Fixture::new();
for field in [
"typo",
"endpoint",
"bindings",
"grants",
"secret_refs",
"subscription",
"provenance",
"tools",
"thinking",
] {
std::fs::write(fixture.0.join("user.kdl"), field).unwrap();
let error = fixture.resolve(Some(true)).unwrap_err().to_string();
assert!(
error.contains("unknown provider setting"),
"{field}: {error}"
);
assert!(error.contains("user.kdl"), "{error}");
assert!(error.contains(field), "{error}");
}
for value in [
"include-usage #null",
"include-usage 1",
"include-usage \"false\"",
"include-usage #true extra",
"include-usage #true extra=#false",
"include-usage #true { child }",
"include-usage #true\ninclude-usage #false",
"include-usage true",
"include-usage false",
] {
std::fs::write(fixture.0.join("user.kdl"), value).unwrap();
let error = fixture.resolve(None).unwrap_err().to_string();
assert!(error.contains("user.kdl"), "{value}: {error}");
if value.starts_with("include-usage") {
assert!(error.contains("include-usage"), "{value}: {error}");
}
}
std::fs::write(
fixture.0.join("user.kdl"),
"include-usage #true // include-usage false\n\"include-usage true\"\n",
)
.unwrap();
assert!(fixture.resolve(None).is_err());
std::fs::write(
fixture.0.join("user.kdl"),
" ".repeat(SETTINGS_BYTES_MAX + 1),
)
.unwrap();
assert!(fixture.resolve(None).is_err());
}
#[test]
fn exact_file_byte_bound_is_accepted_and_metadata_failures_are_not_absence() {
let fixture = Fixture::new();
let mut bytes = b"include-usage #false".to_vec();
bytes.resize(16_384, b" "[0]);
std::fs::write(fixture.0.join("user.kdl"), bytes).unwrap();
assert!(!fixture.resolve(None).unwrap().0.include_usage);
#[cfg(unix)]
{
std::fs::remove_file(fixture.0.join("user.kdl")).unwrap();
std::os::unix::fs::symlink("user.kdl", fixture.0.join("user.kdl")).unwrap();
assert!(fixture.resolve(None).is_err());
}
}
#[test]
fn untrusted_project_settings_are_not_opened_or_parsed() {
let fixture = Fixture::new();
std::fs::create_dir(fixture.0.join(".smith/provider-settings.kdl")).unwrap();
assert!(fixture.resolve(None).unwrap().1);
fixture.trust();
assert!(fixture.resolve(None).is_err());
}
}