ralon 0.1.6

Filesystem policy for AI coding agents: kernel-enforced write protection driven by an agent.lock file
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

//! Ralon — `agent.lock` declares what AI agents may not modify, and this
//! binary makes the kernel agree.

mod audit;
mod cli;
mod commands;
mod enforce;
mod hook;
mod matcher;
mod policy;
mod scan;
mod service;
mod supervisor;

use std::process::ExitCode;

use anyhow::Result;
use clap::Parser;

use cli::{Cli, Command, HookAction, ScopeAction};

/// Something went wrong; nothing was enforced.
const ERROR: u8 = 2;

/// Rust ignores `SIGPIPE`, which turns `ralon check | head` into a panic
/// about a broken pipe instead of a quiet exit. Put the default back.
#[cfg(target_os = "linux")]
fn restore_sigpipe() {
    // Safety: called once, at startup, before any thread exists.
    unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
}

#[cfg(not(target_os = "linux"))]
fn restore_sigpipe() {}

fn main() -> ExitCode {
    restore_sigpipe();
    match dispatch() {
        Ok(code) => code,
        Err(error) => {
            eprintln!("ralon: {error:#}");
            ExitCode::from(ERROR)
        }
    }
}

fn dispatch() -> Result<ExitCode> {
    let cli = Cli::parse();
    let directory = match cli.directory {
        Some(directory) => directory,
        None => std::env::current_dir()?,
    };

    match cli.command {
        Command::Install {
            scope,
            depth,
            no_hooks,
            dry_run,
        } => commands::install(&scope, depth, no_hooks, dry_run),
        Command::Scope { action } => match action {
            ScopeAction::Add { directories } => commands::scope_add(&directories),
            ScopeAction::List => commands::scope_list(),
            ScopeAction::Remove { directories } => commands::scope_remove(&directories),
        },
        Command::Uninstall { keep_enforcement } => commands::uninstall(keep_enforcement),
        Command::Pause {
            minutes,
            indefinitely,
        } => commands::pause(&directory, minutes, indefinitely),
        Command::Resume => commands::resume(&directory),
        Command::Daemon {
            foreground,
            once,
            home,
        } => commands::daemon(foreground, once, home),
        Command::Init { force, no_hooks } => commands::init(&directory, force, no_hooks),
        Command::Check { paths } => commands::check(&directory, &paths),
        Command::Status => commands::status(&directory),
        Command::Guard {
            detach,
            stop,
            detached,
        } => commands::guard(&directory, detach, stop, detached),
        Command::Hook { action } => match action {
            HookAction::Install { agent, dry_run } => {
                commands::hook_install(&directory, agent, dry_run)
            }
            HookAction::Check => commands::hook_check(&directory),
        },
        Command::Run {
            backend,
            dry_run,
            quiet,
            command,
        } => commands::run(&directory, backend, dry_run, quiet, &command),
    }
}