eoka-cli 0.1.15

Browser automation CLI for AI agents and pentesting
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
115
116

use base64::Engine;
use serde_json::{json, Value};

use super::BodyCapture;

pub(super) trait BodyCaptureExt {
    fn omitted(reason: impl Into<String>) -> Self;
    fn len(&self) -> usize;
    fn to_text(&self) -> Option<String>;
}

impl BodyCaptureExt for BodyCapture {
    fn omitted(reason: impl Into<String>) -> Self {
        Self {
            bytes: Vec::new(),
            base64_encoded: false,
            mime_type: None,
            omitted: Some(reason.into()),
        }
    }

    fn len(&self) -> usize {
        self.bytes.len()
    }

    fn to_text(&self) -> Option<String> {
        if self.omitted.is_some() {
            return None;
        }
        if self.base64_encoded {
            return Some(base64::engine::general_purpose::STANDARD.encode(&self.bytes));
        }
        String::from_utf8(self.bytes.clone()).ok()
    }
}

pub(super) fn capture_text_body(data: &str, limit: usize, enabled: bool) -> BodyCapture {
    if !enabled {
        return BodyCapture::omitted("disabled");
    }
    if data.len() > limit {
        return BodyCapture::omitted("too large");
    }
    BodyCapture {
        bytes: data.as_bytes().to_vec(),
        base64_encoded: false,
        mime_type: None,
        omitted: None,
    }
}

pub(super) fn decode_response_body(value: Value, limit: usize) -> BodyCapture {
    let Some(text) = value.get("body").and_then(Value::as_str) else {
        return BodyCapture::omitted("empty");
    };
    let encoded = value
        .get("base64Encoded")
        .and_then(Value::as_bool)
        .unwrap_or(false);
    let bytes = if encoded {
        match base64::engine::general_purpose::STANDARD.decode(text) {
            Ok(bytes) => bytes,
            Err(error) => return BodyCapture::omitted(format!("decode failed: {}", error)),
        }
    } else {
        text.as_bytes().to_vec()
    };
    if bytes.len() > limit {
        return BodyCapture::omitted("too large");
    }
    BodyCapture {
        bytes,
        base64_encoded: encoded,
        mime_type: None,
        omitted: None,
    }
}

pub(super) fn body_summary(body: Option<&BodyCapture>) -> Value {
    match body {
        Some(body) => json!({
            "bytes": body.len(),
            "base64": body.base64_encoded,
            "omitted": body.omitted,
        }),
        None => Value::Null,
    }
}

pub(super) fn body_json(body: Option<&BodyCapture>) -> Value {
    match body {
        Some(body) => json!({
            "bytes": body.len(),
            "base64": body.base64_encoded,
            "text": body.to_text(),
            "omitted": body.omitted,
            "mime_type": body.mime_type,
        }),
        None => Value::Null,
    }
}

pub(super) fn limit_body_json(body: &mut Value, max_body: usize) {
    let Some(text) = body
        .get_mut("text")
        .and_then(|value| value.as_str())
        .map(str::to_string)
    else {
        return;
    };
    if text.len() <= max_body {
        return;
    }
    body["text"] = Value::String(text.chars().take(max_body).collect());
    body["truncated"] = Value::Bool(true);
}