oxios-kernel 1.0.0

Oxios kernel: supervisor, event bus, state store
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

#![allow(missing_docs)]
//! Requirements evaluation.

use super::types::*;

fn has_bin(bin: &str) -> bool {
    std::process::Command::new("which")
        .arg(bin)
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

pub fn current_platform() -> &'static str {
    if cfg!(target_os = "macos") {
        "darwin"
    } else if cfg!(target_os = "windows") {
        "windows"
    } else {
        "linux"
    }
}

pub fn check_requirements(metadata: &SkillMetadata) -> RequirementsCheck {
    let platform = current_platform();
    let missing_bins: Vec<String> = metadata
        .requires
        .bins
        .iter()
        .filter(|b| !has_bin(b))
        .cloned()
        .collect();
    let missing_any_bins = if metadata.requires.any_bins.is_empty()
        || metadata.requires.any_bins.iter().any(|b| has_bin(b))
    {
        Vec::new()
    } else {
        metadata.requires.any_bins.clone()
    };
    let missing_env: Vec<String> = metadata
        .requires
        .env
        .iter()
        .filter(|e| std::env::var(e).is_err())
        .cloned()
        .collect();
    let config_checks: Vec<ConfigCheck> = metadata
        .requires
        .config
        .iter()
        .map(|path| ConfigCheck {
            path: path.clone(),
            satisfied: true,
        })
        .collect();
    let missing_config: Vec<String> = config_checks
        .iter()
        .filter(|c| !c.satisfied)
        .map(|c| c.path.clone())
        .collect();
    let missing_os = if metadata.os.is_empty() || metadata.os.iter().any(|o| o == platform) {
        Vec::new()
    } else {
        metadata.os.clone()
    };
    let eligible = metadata.always
        || (missing_bins.is_empty()
            && missing_any_bins.is_empty()
            && missing_env.is_empty()
            && missing_config.is_empty()
            && missing_os.is_empty());
    RequirementsCheck {
        missing_bins,
        missing_any_bins,
        missing_env,
        missing_config,
        missing_os,
        eligible,
        config_checks,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_no_reqs() {
        assert!(check_requirements(&SkillMetadata::default()).eligible);
    }
    #[test]
    fn test_always() {
        let mut m = SkillMetadata::default();
        m.always = true;
        m.requires.bins = vec!["nonexistent-xyz".into()];
        assert!(check_requirements(&m).eligible);
    }
    #[test]
    fn test_existing_bin() {
        let mut m = SkillMetadata::default();
        m.requires.bins = vec!["echo".into()];
        assert!(check_requirements(&m).eligible);
    }
    #[test]
    fn test_missing_bin() {
        let mut m = SkillMetadata::default();
        m.requires.bins = vec!["nonexistent-xyz".into()];
        assert!(!check_requirements(&m).eligible);
    }
    #[test]
    fn test_missing_env() {
        let mut m = SkillMetadata::default();
        m.requires.env = vec!["OXIOS_TEST_MISSING".into()];
        assert!(!check_requirements(&m).eligible);
    }
}