tuff-core 0.1.8

Core lifecycle engine and adapter contract for Tuff.
Documentation 
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

use std::path::Path;

use serde::Serialize;

use crate::error::Result;
use crate::lockfile;
use crate::manifest::CapabilityType;

#[derive(Debug, Serialize)]
pub struct CheckResult {
    pub id: String,
    #[serde(rename = "type")]
    pub capability_type: CapabilityType,
    pub target: String,
    pub status: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub files: Vec<String>,
}

#[derive(Debug, Serialize)]
pub struct CheckOutcome {
    pub valid: bool,
    pub results: Vec<CheckResult>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CheckScope {
    ProjectAndGlobal,
    Global,
}

pub fn run_checks(repo_root: &Path, scope: CheckScope) -> Result<CheckOutcome> {
    let mut results = Vec::new();

    if scope == CheckScope::ProjectAndGlobal
        && let Ok(lf) = lockfile::require_lockfile(repo_root)
    {
        check_lockfile(repo_root, &lf, &mut results);
    }

    if let Some(home) = home_dir() {
        let lock_path = crate::paths::global_lockfile(&home);
        if let Ok(lf) = lockfile::read_lockfile_at(&lock_path) {
            check_lockfile(&home, &lf, &mut results);
        }
    }

    let valid = results.iter().all(|r| r.status == "ok");
    Ok(CheckOutcome { valid, results })
}

fn check_lockfile(scope_root: &Path, lf: &lockfile::Lockfile, results: &mut Vec<CheckResult>) {
    for (id, entry) in lf.capabilities.iter() {
        for (target_id, target_entry) in entry.targets.iter() {
            let mut failing_files = Vec::new();

            if target_entry.installed_path.is_empty() {
                failing_files.push(id.clone());
            } else {
                let path = scope_root.join(&target_entry.installed_path);
                match crate::cache::hash_tree(&path) {
                    Ok(hash) if hash == target_entry.sha256 => {}
                    Ok(_) | Err(_) => failing_files.push(target_entry.installed_path.clone()),
                }
            }

            for emitted in &target_entry.emitted_files {
                let file_path = scope_root.join(&emitted.path);

                if !file_path.exists() {
                    failing_files.push(emitted.path.clone());
                    continue;
                }

                if let Ok(content) = std::fs::read(&file_path) {
                    let hash = lockfile::hash_bytes(&content);
                    if hash != emitted.hash {
                        failing_files.push(emitted.path.clone());
                    }
                }
            }

            for hook in &target_entry.managed_hooks {
                if lockfile::managed_hook_status(scope_root, hook) != "clean" {
                    failing_files.push(format!("{}#{}", hook.settings_path, hook.event));
                }
            }

            if let Some(managed_entry) = &target_entry.managed_mcp_entry
                && lockfile::managed_mcp_entry_status(scope_root, id, managed_entry) != "clean"
            {
                failing_files.push(format!("{}#{}", managed_entry.config_path, id));
            }

            let status = if failing_files.is_empty() {
                "ok"
            } else {
                "modified"
            };

            results.push(CheckResult {
                id: id.clone(),
                capability_type: entry.capability_type,
                target: target_id.clone(),
                status: status.to_string(),
                files: failing_files,
            });
        }
    }
}

fn home_dir() -> Option<std::path::PathBuf> {
    std::env::var("HOME").ok().map(std::path::PathBuf::from)
}