openmoat 0.15.0

Policy checks for AI coding agents: decides allow, defer, review or deny for every tool call from Claude Code, Codex, Cursor, OpenClaw, GitHub Copilot CLI, pi and Gemini CLI, configures Claude Code's, Codex's and Cursor's own OS sandboxes from the same policy, and keeps a local audit log.
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

//! Other hook files a host runs for the event OpenMoat's hook answers
//! (`HostSpec::other_hooks`): Cline runs every `PreToolUse` file of its hook
//! directories, the person's and the workspace's, and its plugins, and any of
//! them can rewrite a call's input after OpenMoat checked it. OpenMoat pins
//! only its own file, so `moat status` and `moat doctor` name the others.

use std::fs;
use std::path::{Path, PathBuf};

use openmoat_hosts::{Host, OtherHooks};

use super::Warning;
use crate::home::Home;
use crate::install::HostConfig;

/// Every hook file and plugin `host` runs beside OpenMoat's `hook_file` for a
/// session in `cwd`, sorted within each directory; none for a host whose spec
/// names no other hooks.
#[must_use]
pub fn found(
    host: Host,
    config_dir: &Path,
    hook_file: &Path,
    cwd: &Path,
    user_home: &Path,
) -> Vec<PathBuf> {
    let Some(spec) = host.spec().other_hooks.as_ref() else {
        return Vec::new();
    };
    let ours = fs::canonicalize(hook_file).unwrap_or_else(|_| hook_file.to_path_buf());
    let dirs = spec
        .home_dirs
        .iter()
        .map(|dir| user_home.join(dir))
        .chain(spec.config_dirs.iter().map(|dir| config_dir.join(dir)))
        .chain(
            super::project_dirs(cwd, user_home)
                .into_iter()
                .flat_map(|root| spec.project_dirs.iter().map(move |dir| root.join(dir))),
        );
    let mut files: Vec<PathBuf> = dirs
        .flat_map(|dir| hook_files(&dir, spec))
        .filter(|path| fs::canonicalize(path).unwrap_or_else(|_| path.clone()) != ours)
        .collect();
    for dir in spec.plugin_dirs {
        files.extend(entries(&config_dir.join(dir)));
    }
    files
}

/// The files in `dir` named [`OtherHooks::stem`], with or without an
/// extension, sorted; none when `dir` cannot be read.
fn hook_files(dir: &Path, spec: &OtherHooks) -> Vec<PathBuf> {
    let mut files: Vec<PathBuf> = entries(dir)
        .into_iter()
        .filter(|path| path.is_file() && path.file_stem().is_some_and(|stem| stem == spec.stem))
        .collect();
    files.sort();
    files
}

/// Every entry of `dir` but hidden ones, sorted; none when it cannot be read.
fn entries(dir: &Path) -> Vec<PathBuf> {
    let Ok(read) = fs::read_dir(dir) else {
        return Vec::new();
    };
    let mut paths: Vec<PathBuf> = read
        .filter_map(|entry| Some(entry.ok()?.path()))
        .filter(|path| {
            path.file_name()
                .is_some_and(|name| !name.to_string_lossy().starts_with('.'))
        })
        .collect();
    paths.sort();
    paths
}

/// One warning per [`found`] file of every host on this machine whose spec
/// names other hooks, for the current directory; empty when it or the home
/// directory cannot be found.
#[must_use]
pub fn warnings_here(home: &Home) -> Vec<Warning> {
    let (Ok(cwd), Ok(user_home)) = (std::env::current_dir(), crate::home::user_home()) else {
        return Vec::new();
    };
    Host::ALL
        .into_iter()
        .filter_map(|host| Some((host, host.spec().other_hooks.as_ref()?)))
        .filter_map(|(host, spec)| {
            let config = HostConfig::for_host(home, host).ok()?;
            config.host_present().then_some((host, spec, config))
        })
        .flat_map(|(host, spec, config)| {
            found(host, config.dir(), &config.settings_path, &cwd, &user_home)
                .into_iter()
                .map(move |path| Warning {
                    host,
                    text: format!(
                        "{}: {}; review it and remove what you did not add",
                        path.display(),
                        spec.effect
                    ),
                })
        })
        .collect()
}

#[cfg(test)]
mod tests;