abyss-agent-hook 1.0.2

AI agent protocol parsing and normalized events for the Abyss runtime
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
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Built-in and configured Harness detection over generic request metadata.

mod claude_code;
mod claude_desktop;
mod codex;

use abyss_mitm::{FlowContext, HttpExchange, WebSocketMessage};
use http::HeaderMap;

use crate::config::HarnessUsageConfig;

use super::{HarnessDetection, matcher::HarnessMatcher};

/// Product-owned Harness recognition over generic flow and request metadata.
pub(super) trait HarnessDetector {
    fn detect(
        &self,
        flow: &FlowContext,
        headers: &HeaderMap,
        path: &str,
    ) -> Option<HarnessDetection>;
}

/// Stateless detector registry evaluated against the current policy snapshot.
pub struct HarnessRegistry;

impl HarnessRegistry {
    pub fn detect_http(
        exchange: &HttpExchange,
        config: &HarnessUsageConfig,
    ) -> Option<HarnessDetection> {
        Self::detect(
            &exchange.flow,
            exchange.request.headers(),
            exchange.request.uri().path(),
            config,
        )
    }

    pub fn detect_websocket(
        message: &WebSocketMessage,
        config: &HarnessUsageConfig,
    ) -> Option<HarnessDetection> {
        Self::detect(
            &message.flow,
            message.upgrade_request.headers(),
            message.upgrade_request.uri().path(),
            config,
        )
    }

    fn detect(
        flow: &FlowContext,
        headers: &HeaderMap,
        path: &str,
        config: &HarnessUsageConfig,
    ) -> Option<HarnessDetection> {
        let detectors: [&dyn HarnessDetector; 3] = [
            &codex::CodexDetector,
            &claude_desktop::ClaudeDesktopDetector,
            &claude_code::ClaudeCodeDetector,
        ];
        let mut detections = detectors
            .into_iter()
            .filter_map(|detector| detector.detect(flow, headers, path))
            .filter(|detection| config.enabled_for_harness(detection.harness_id.as_str()))
            .collect::<Vec<_>>();

        for (harness_id, harness) in &config.harnesses {
            if harness_id.is_reserved() || !harness.enabled.unwrap_or(true) {
                continue;
            }
            if let Some(evidence) = harness
                .matchers
                .iter()
                .find_map(|matcher| HarnessMatcher::new(matcher).matches(flow))
            {
                detections.push(HarnessDetection {
                    harness_id: harness_id.clone(),
                    evidence,
                    version: None,
                    working_directory: flow.source_working_directory().map(str::to_owned),
                });
            }
        }

        if detections.len() != 1 {
            if detections.len() > 1 {
                let harnesses = detections
                    .iter()
                    .map(|detection| detection.harness_id.as_str())
                    .collect::<Vec<_>>();
                tracing::warn!(?harnesses, "ambiguous Harness detection; skipping event");
            }
            return None;
        }
        detections.pop()
    }
}

fn header<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> {
    headers
        .get(name)?
        .to_str()
        .ok()
        .map(str::trim)
        .filter(|value| !value.is_empty())
}

fn client_version(user_agent: &str, prefixes: &[&str]) -> Option<String> {
    user_agent.split([' ', ';', ')', '(']).find_map(|token| {
        let normalized = token.to_ascii_lowercase();
        prefixes.iter().find_map(|prefix| {
            normalized
                .strip_prefix(prefix)
                .filter(|version| !version.is_empty())
                .map(str::to_owned)
        })
    })
}

#[cfg(test)]
mod tests {
    use std::net::SocketAddr;

    use abyss_mitm::{FlowContext, OriginalDestination, TransparentProtocol};
    use http::HeaderMap;

    use crate::config::HarnessUsageConfig;

    use super::HarnessRegistry;

    #[test]
    fn claude_web_route_alone_does_not_identify_claude_desktop() {
        let flow = FlowContext::from_optional_addrs(
            None,
            None,
            OriginalDestination::from(SocketAddr::from(([127, 0, 0, 1], 443))),
            TransparentProtocol::PlainHttp,
            None,
        );

        assert!(
            HarnessRegistry::detect(
                &flow,
                &HeaderMap::new(),
                "/api/organizations/org-id/chat_conversations/conversation-id/completion",
                &HarnessUsageConfig::default(),
            )
            .is_none()
        );
    }
}