slash-lib 0.1.0

Executor types and high-level API for the slash-command language
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

use obfsck::{obfuscate_text, ObfuscationLevel};
use slash_lang::parser::ast::Arg;

use crate::command::{MethodDef, SlashCommand};
use crate::executor::{CommandOutput, ExecutionError, PipeValue};

/// `/obfsck` — redact secrets and PII from piped content.
///
/// `/read(.env) | /obfsck` — redact at Standard level (default).
/// `/read(logs.txt) | /obfsck.level(paranoid)` — redact at Paranoid level.
/// `/obfsck(some inline text)` — redact the primary arg directly.
///
/// Levels: `minimal`, `standard` (default), `paranoid`.
///
/// Pure Rust via the obfsck library. No subprocess.
pub struct Obfsck;

impl SlashCommand for Obfsck {
    fn name(&self) -> &str {
        "obfsck"
    }

    fn methods(&self) -> &[MethodDef] {
        static METHODS: [MethodDef; 1] = [MethodDef::with_value("level")];
        &METHODS
    }

    fn execute(
        &self,
        primary: Option<&str>,
        args: &[Arg],
        input: Option<&PipeValue>,
    ) -> Result<CommandOutput, ExecutionError> {
        let level_str = args
            .iter()
            .find(|a| a.name == "level")
            .and_then(|a| a.value.as_deref())
            .unwrap_or("standard");

        let level = ObfuscationLevel::parse(level_str).ok_or_else(|| {
            ExecutionError::Runner(format!(
                "/obfsck: unknown level '{}' — use minimal, standard, or paranoid",
                level_str
            ))
        })?;

        let text = if let Some(primary) = primary {
            primary.to_string()
        } else {
            match input {
                Some(PipeValue::Bytes(b)) => String::from_utf8_lossy(b).into_owned(),
                Some(PipeValue::Context(ctx)) => ctx.to_json(),
                None => return Err(ExecutionError::Runner("/obfsck: no input to redact".into())),
            }
        };

        let (redacted, _map) = obfuscate_text(&text, level);

        Ok(CommandOutput {
            stdout: Some(redacted.into_bytes()),
            stderr: None,
            success: true,
        })
    }
}