//! 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, ) -> 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) -> 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::(), 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()); } }