dirge-agent 0.18.6

Minimalistic coding agent written in Rust, optimized for memory footprint and performance
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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_visible_bang() {
        assert_eq!(
            parse_shell_prefix("! ls"),
            Some(ShellPrefix::Visible("ls".into()))
        );
    }

    #[test]
    fn test_invisible_bang() {
        assert_eq!(
            parse_shell_prefix("!! ls"),
            Some(ShellPrefix::Invisible("ls".into()))
        );
    }

    #[test]
    fn test_no_bang() {
        assert_eq!(parse_shell_prefix("ls"), None);
    }

    #[test]
    fn test_bang_without_space() {
        assert_eq!(
            parse_shell_prefix("!ls"),
            Some(ShellPrefix::Visible("ls".into()))
        );
    }

    #[test]
    fn test_double_bang_without_space() {
        assert_eq!(
            parse_shell_prefix("!!ls"),
            Some(ShellPrefix::Invisible("ls".into()))
        );
    }

    #[test]
    fn test_block_cd() {
        assert_eq!(parse_shell_prefix("! cd /tmp"), None);
        assert_eq!(parse_shell_prefix("!! cd /tmp"), None);
        assert_eq!(parse_shell_prefix("!cd /tmp"), None);
    }

    #[test]
    fn test_is_forbidden_skips_env_assignments() {
        assert!(is_forbidden("cd /x"));
        // Leading `VAR=value` must not evade the block.
        assert!(is_forbidden("FOO=1 cd /x"));
        assert!(!is_forbidden("ls"));
        assert!(!is_forbidden("BAR=2 ls"));
    }
}

#[derive(Debug, PartialEq)]
pub enum ShellPrefix {
    Visible(String),
    Invisible(String),
}

pub fn parse_shell_prefix(text: &str) -> Option<ShellPrefix> {
    let trimmed = text.trim();
    if let Some(rest) = trimmed.strip_prefix("!!") {
        let cmd = rest.trim().to_string();
        if cmd.is_empty() || is_forbidden(&cmd) {
            return None;
        }
        return Some(ShellPrefix::Invisible(cmd));
    }
    if let Some(rest) = trimmed.strip_prefix('!') {
        let cmd = rest.trim().to_string();
        if cmd.is_empty() || is_forbidden(&cmd) {
            return None;
        }
        return Some(ShellPrefix::Visible(cmd));
    }
    None
}

fn is_forbidden(cmd: &str) -> bool {
    // Skip leading `name=value` env-assignment tokens so a prefix like
    // `FOO=1 cd /x` is still caught.
    let first = cmd
        .split_whitespace()
        .find(|tok| !is_env_assignment(tok))
        .unwrap_or("");
    matches!(
        first.to_ascii_lowercase().as_str(),
        "cd" | "pushd" | "popd" | "exit" | "exec"
    )
}

/// True for a leading `NAME=value` env-assignment token (NAME is `[A-Za-z_][A-Za-z0-9_]*`).
fn is_env_assignment(tok: &str) -> bool {
    let mut bytes = tok.bytes();
    match bytes.next() {
        Some(b) if b.is_ascii_alphabetic() || b == b'_' => {}
        _ => return false,
    }
    for b in bytes {
        match b {
            b'=' => return true,
            b if b.is_ascii_alphanumeric() || b == b'_' => {}
            _ => return false,
        }
    }
    false
}