Luigit
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());
    }
}