vifu-server 0.1.13

HTTP, WebSocket, and persistent server implementation for Vifu.
Documentation
use std::fmt::Write;

use serde_json::Value;
use sha2::{Digest, Sha256};

use vifu_gateway::protocol::AgentDescriptor;

use crate::models::AvailableAgent;

const HASH_BYTES: usize = 12;
const MAX_IDENTIFIER_LEN: usize = 128;
const MAX_GATEWAY_NAME_CHARS: usize = 128;

pub(crate) fn scoped_provider_key(gateway_id: &str, runtime_provider_key: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(gateway_id.as_bytes());
    hasher.update([0]);
    hasher.update(runtime_provider_key.as_bytes());
    let digest = hasher.finalize();
    let mut suffix = String::with_capacity(HASH_BYTES * 2);
    for byte in &digest[..HASH_BYTES] {
        let _ = write!(&mut suffix, "{byte:02x}");
    }
    let separator = "--";
    let prefix_len = MAX_IDENTIFIER_LEN - separator.len() - suffix.len();
    let prefix = runtime_provider_key
        .chars()
        .take(prefix_len)
        .collect::<String>();
    format!("{prefix}{separator}{suffix}")
}

pub(crate) fn scope_available_agent(mut agent: AvailableAgent) -> AvailableAgent {
    let Some(metadata) = agent.metadata.as_object_mut() else {
        return agent;
    };
    let Some(runtime_provider_key) = metadata
        .get("providerKey")
        .and_then(Value::as_str)
        .map(str::to_string)
    else {
        return agent;
    };
    metadata.insert(
        "runtimeProviderKey".to_string(),
        Value::String(runtime_provider_key.clone()),
    );
    metadata.insert(
        "providerKey".to_string(),
        Value::String(scoped_provider_key(
            &agent.gateway_id,
            &runtime_provider_key,
        )),
    );
    agent
}

pub(crate) fn normalized_gateway_metadata(metadata: Value, agents: &[AgentDescriptor]) -> Value {
    let mut metadata = metadata.as_object().cloned().unwrap_or_default();
    let reported_name = metadata
        .get("name")
        .and_then(Value::as_str)
        .and_then(bounded_gateway_name)
        .or_else(|| {
            metadata
                .get("application")
                .and_then(Value::as_object)
                .and_then(|application| application.get("name"))
                .and_then(Value::as_str)
                .and_then(bounded_gateway_name)
        })
        .or_else(|| {
            agents
                .first()
                .and_then(|agent| bounded_gateway_name(&agent.name))
        })
        .unwrap_or_else(|| "Vifu Gateway".to_string());
    metadata.insert("name".to_string(), Value::String(reported_name));
    Value::Object(metadata)
}

fn bounded_gateway_name(value: &str) -> Option<String> {
    let value = value.trim();
    if value.is_empty() || value.chars().count() > MAX_GATEWAY_NAME_CHARS {
        return None;
    }
    Some(value.to_string())
}

#[cfg(test)]
mod tests {
    use serde_json::json;
    use vifu_gateway::protocol::AgentDescriptor;

    use super::{normalized_gateway_metadata, scoped_provider_key};

    #[test]
    fn provider_identity_is_stable_and_gateway_scoped() {
        let first = scoped_provider_key("gateway-one", "android-llama");
        let repeated = scoped_provider_key("gateway-one", "android-llama");
        let second = scoped_provider_key("gateway-two", "android-llama");

        assert_eq!(first, repeated);
        assert_ne!(first, second);
        assert!(first.starts_with("android-llama--"));
        assert!(first.len() <= 128);
        assert!(vifu_gateway::protocol::validate_identifier("provider key", &first).is_ok());
    }

    #[test]
    fn provider_identity_bounds_long_runtime_keys() {
        let key = scoped_provider_key("gateway-one", &"a".repeat(128));

        assert_eq!(key.len(), 128);
        assert!(vifu_gateway::protocol::validate_identifier("provider key", &key).is_ok());
    }

    #[test]
    fn gateway_metadata_preserves_a_reported_device_name() {
        let metadata = normalized_gateway_metadata(
            json!({
                "name": "Kitchen light",
                "kind": "light",
                "device": { "manufacturer": "Example" },
            }),
            &[],
        );

        assert_eq!(metadata["name"], "Kitchen light");
    }

    #[test]
    fn gateway_metadata_uses_the_agent_name_for_legacy_clients() {
        let metadata = normalized_gateway_metadata(
            json!({ "adapter": "vifu" }),
            &[AgentDescriptor {
                id: "light-agent".to_string(),
                name: "Legacy kitchen light".to_string(),
                metadata: json!({}),
            }],
        );

        assert_eq!(metadata["name"], "Legacy kitchen light");
    }
}