enya-agent 0.1.0

package/crates/enact-tools/src/http_request.rs

@@ -0,0 +1,417 @@
+//! HTTP request tool for API interactions
+
+use crate::security::SecurityPolicy;
+use crate::traits::{Tool, ToolResult};
+use async_trait::async_trait;
+use serde_json::json;
+use std::sync::Arc;
+use std::time::Duration;
+
+/// HTTP request tool for API interactions.
+/// Supports GET, POST, PUT, DELETE methods with configurable security.
+pub struct HttpRequestTool {
+    security: Arc<SecurityPolicy>,
+    allowed_domains: Vec<String>,
+    max_response_size: usize,
+    timeout_secs: u64,
+}
+
+impl HttpRequestTool {
+    pub fn new(
+        security: Arc<SecurityPolicy>,
+        allowed_domains: Vec<String>,
+        max_response_size: usize,
+        timeout_secs: u64,
+    ) -> Self {
+        Self {
+            security,
+            allowed_domains: normalize_allowed_domains(allowed_domains),
+            max_response_size,
+            timeout_secs,
+        }
+    }
+
+    fn validate_url(&self, raw_url: &str) -> anyhow::Result<String> {
+        let url = raw_url.trim();
+
+        if url.is_empty() {
+            anyhow::bail!("URL cannot be empty");
+        }
+
+        if url.chars().any(char::is_whitespace) {
+            anyhow::bail!("URL cannot contain whitespace");
+        }
+
+        if !url.starts_with("http://") && !url.starts_with("https://") {
+            anyhow::bail!("Only http:// and https:// URLs are allowed");
+        }
+
+        if self.allowed_domains.is_empty() {
+            anyhow::bail!(
+                "HTTP request tool is enabled but no allowed_domains are configured"
+            );
+        }
+
+        let host = extract_host(url)?;
+
+        if is_private_or_local_host(&host) {
+            anyhow::bail!("Blocked local/private host: {host}");
+        }
+
+        if !host_matches_allowlist(&host, &self.allowed_domains) {
+            anyhow::bail!("Host '{host}' is not in allowed_domains");
+        }
+
+        Ok(url.to_string())
+    }
+
+    fn validate_method(&self, method: &str) -> anyhow::Result<reqwest::Method> {
+        match method.to_uppercase().as_str() {
+            "GET" => Ok(reqwest::Method::GET),
+            "POST" => Ok(reqwest::Method::POST),
+            "PUT" => Ok(reqwest::Method::PUT),
+            "DELETE" => Ok(reqwest::Method::DELETE),
+            "PATCH" => Ok(reqwest::Method::PATCH),
+            "HEAD" => Ok(reqwest::Method::HEAD),
+            "OPTIONS" => Ok(reqwest::Method::OPTIONS),
+            _ => anyhow::bail!("Unsupported HTTP method: {method}"),
+        }
+    }
+
+    fn parse_headers(&self, headers: &serde_json::Value) -> Vec<(String, String)> {
+        let mut result = Vec::new();
+        if let Some(obj) = headers.as_object() {
+            for (key, value) in obj {
+                if let Some(str_val) = value.as_str() {
+                    result.push((key.clone(), str_val.to_string()));
+                }
+            }
+        }
+        result
+    }
+
+    async fn execute_request(
+        &self,
+        url: &str,
+        method: reqwest::Method,
+        headers: Vec<(String, String)>,
+        body: Option<&str>,
+    ) -> anyhow::Result<reqwest::Response> {
+        let client = reqwest::Client::builder()
+            .timeout(Duration::from_secs(self.timeout_secs))
+            .connect_timeout(Duration::from_secs(10))
+            .redirect(reqwest::redirect::Policy::none())
+            .build()?;
+
+        let mut request = client.request(method, url);
+
+        for (key, value) in headers {
+            request = request.header(&key, &value);
+        }
+
+        if let Some(body_str) = body {
+            request = request.body(body_str.to_string());
+        }
+
+        Ok(request.send().await?)
+    }
+
+    fn truncate_response(&self, text: &str) -> String {
+        if text.len() > self.max_response_size {
+            let mut truncated = text
+                .chars()
+                .take(self.max_response_size)
+                .collect::<String>();
+            truncated.push_str("\n\n... [Response truncated due to size limit] ...");
+            truncated
+        } else {
+            text.to_string()
+        }
+    }
+}
+
+#[async_trait]
+impl Tool for HttpRequestTool {
+    fn name(&self) -> &str {
+        "http_request"
+    }
+
+    fn description(&self) -> &str {
+        "Make HTTP requests to external APIs. Supports GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS methods."
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "HTTP or HTTPS URL to request"
+                },
+                "method": {
+                    "type": "string",
+                    "description": "HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)",
+                    "default": "GET"
+                },
+                "headers": {
+                    "type": "object",
+                    "description": "Optional HTTP headers as key-value pairs",
+                    "default": {}
+                },
+                "body": {
+                    "type": "string",
+                    "description": "Optional request body (for POST, PUT, PATCH requests)"
+                }
+            },
+            "required": ["url"]
+        })
+    }
+
+    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
+        let url = args
+            .get("url")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing 'url' parameter"))?;
+
+        let method_str = args.get("method").and_then(|v| v.as_str()).unwrap_or("GET");
+        let headers_val = args.get("headers").cloned().unwrap_or(json!({}));
+        let body = args.get("body").and_then(|v| v.as_str());
+
+        if !self.security.can_act() {
+            return Ok(ToolResult::failure("Action blocked: autonomy is read-only"));
+        }
+
+        if !self.security.record_action() {
+            return Ok(ToolResult::failure("Action blocked: rate limit exceeded"));
+        }
+
+        let url = match self.validate_url(url) {
+            Ok(v) => v,
+            Err(e) => return Ok(ToolResult::failure(e.to_string())),
+        };
+
+        let method = match self.validate_method(method_str) {
+            Ok(m) => m,
+            Err(e) => return Ok(ToolResult::failure(e.to_string())),
+        };
+
+        let request_headers = self.parse_headers(&headers_val);
+
+        match self.execute_request(&url, method, request_headers, body).await {
+            Ok(response) => {
+                let status = response.status();
+                let status_code = status.as_u16();
+
+                let response_text = match response.text().await {
+                    Ok(text) => self.truncate_response(&text),
+                    Err(e) => format!("[Failed to read response body: {e}]"),
+                };
+
+                let output = format!(
+                    "Status: {} {}\n\nResponse Body:\n{}",
+                    status_code,
+                    status.canonical_reason().unwrap_or("Unknown"),
+                    response_text
+                );
+
+                Ok(ToolResult {
+                    success: status.is_success(),
+                    output,
+                    error: if status.is_client_error() || status.is_server_error() {
+                        Some(format!("HTTP {}", status_code))
+                    } else {
+                        None
+                    },
+                })
+            }
+            Err(e) => Ok(ToolResult::failure(format!("HTTP request failed: {e}"))),
+        }
+    }
+}
+
+// Helper functions
+
+fn normalize_allowed_domains(domains: Vec<String>) -> Vec<String> {
+    let mut normalized = domains
+        .into_iter()
+        .filter_map(|d| normalize_domain(&d))
+        .collect::<Vec<_>>();
+    normalized.sort_unstable();
+    normalized.dedup();
+    normalized
+}
+
+fn normalize_domain(raw: &str) -> Option<String> {
+    let mut d = raw.trim().to_lowercase();
+    if d.is_empty() {
+        return None;
+    }
+
+    if let Some(stripped) = d.strip_prefix("https://") {
+        d = stripped.to_string();
+    } else if let Some(stripped) = d.strip_prefix("http://") {
+        d = stripped.to_string();
+    }
+
+    if let Some((host, _)) = d.split_once('/') {
+        d = host.to_string();
+    }
+
+    d = d.trim_start_matches('.').trim_end_matches('.').to_string();
+
+    if let Some((host, _)) = d.split_once(':') {
+        d = host.to_string();
+    }
+
+    if d.is_empty() || d.chars().any(char::is_whitespace) {
+        return None;
+    }
+
+    Some(d)
+}
+
+fn extract_host(url: &str) -> anyhow::Result<String> {
+    let rest = url
+        .strip_prefix("http://")
+        .or_else(|| url.strip_prefix("https://"))
+        .ok_or_else(|| anyhow::anyhow!("Only http:// and https:// URLs are allowed"))?;
+
+    let authority = rest
+        .split(['/', '?', '#'])
+        .next()
+        .ok_or_else(|| anyhow::anyhow!("Invalid URL"))?;
+
+    if authority.is_empty() {
+        anyhow::bail!("URL must include a host");
+    }
+
+    if authority.contains('@') {
+        anyhow::bail!("URL userinfo is not allowed");
+    }
+
+    if authority.starts_with('[') {
+        anyhow::bail!("IPv6 hosts are not supported");
+    }
+
+    let host = authority
+        .split(':')
+        .next()
+        .unwrap_or_default()
+        .trim()
+        .trim_end_matches('.')
+        .to_lowercase();
+
+    if host.is_empty() {
+        anyhow::bail!("URL must include a valid host");
+    }
+
+    Ok(host)
+}
+
+fn host_matches_allowlist(host: &str, allowed_domains: &[String]) -> bool {
+    allowed_domains.iter().any(|domain| {
+        host == domain
+            || host
+                .strip_suffix(domain)
+                .is_some_and(|prefix| prefix.ends_with('.'))
+    })
+}
+
+fn is_private_or_local_host(host: &str) -> bool {
+    let bare = host
+        .strip_prefix('[')
+        .and_then(|h| h.strip_suffix(']'))
+        .unwrap_or(host);
+
+    let has_local_tld = bare
+        .rsplit('.')
+        .next()
+        .is_some_and(|label| label == "local");
+
+    if bare == "localhost" || bare.ends_with(".localhost") || has_local_tld {
+        return true;
+    }
+
+    if let Ok(ip) = bare.parse::<std::net::IpAddr>() {
+        return match ip {
+            std::net::IpAddr::V4(v4) => is_non_global_v4(v4),
+            std::net::IpAddr::V6(v6) => is_non_global_v6(v6),
+        };
+    }
+
+    false
+}
+
+fn is_non_global_v4(v4: std::net::Ipv4Addr) -> bool {
+    let [a, b, c, _] = v4.octets();
+    v4.is_loopback()
+        || v4.is_private()
+        || v4.is_link_local()
+        || v4.is_unspecified()
+        || v4.is_broadcast()
+        || v4.is_multicast()
+        || (a == 100 && (64..=127).contains(&b))
+        || a >= 240
+        || (a == 192 && b == 0 && (c == 0 || c == 2))
+        || (a == 198 && b == 51)
+        || (a == 203 && b == 0)
+        || (a == 198 && (18..=19).contains(&b))
+}
+
+fn is_non_global_v6(v6: std::net::Ipv6Addr) -> bool {
+    let segs = v6.segments();
+    v6.is_loopback()
+        || v6.is_unspecified()
+        || v6.is_multicast()
+        || (segs[0] & 0xfe00) == 0xfc00
+        || (segs[0] & 0xffc0) == 0xfe80
+        || (segs[0] == 0x2001 && segs[1] == 0x0db8)
+        || v6.to_ipv4_mapped().is_some_and(is_non_global_v4)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::security::AutonomyLevel;
+
+    fn test_tool(allowed_domains: Vec<&str>) -> HttpRequestTool {
+        let security = Arc::new(SecurityPolicy {
+            autonomy: AutonomyLevel::Supervised,
+            ..SecurityPolicy::default()
+        });
+        HttpRequestTool::new(
+            security,
+            allowed_domains.into_iter().map(String::from).collect(),
+            1_000_000,
+            30,
+        )
+    }
+
+    #[test]
+    fn validate_accepts_exact_domain() {
+        let tool = test_tool(vec!["example.com"]);
+        let got = tool.validate_url("https://example.com/docs").unwrap();
+        assert_eq!(got, "https://example.com/docs");
+    }
+
+    #[test]
+    fn validate_rejects_allowlist_miss() {
+        let tool = test_tool(vec!["example.com"]);
+        let err = tool.validate_url("https://google.com").unwrap_err().to_string();
+        assert!(err.contains("allowed_domains"));
+    }
+
+    #[test]
+    fn validate_rejects_localhost() {
+        let tool = test_tool(vec!["localhost"]);
+        let err = tool.validate_url("https://localhost:8080").unwrap_err().to_string();
+        assert!(err.contains("local/private"));
+    }
+
+    #[test]
+    fn validate_rejects_private_ipv4() {
+        let tool = test_tool(vec!["192.168.1.5"]);
+        let err = tool.validate_url("https://192.168.1.5").unwrap_err().to_string();
+        assert!(err.contains("local/private"));
+    }
+}

package/crates/enact-tools/src/lib.rs

@@ -0,0 +1,104 @@
+//! Built-in tools for Enact agents
+//!
+//! This crate provides essential tools for agent execution:
+//! - Shell command execution with sandboxing
+//! - File read/write with path security
+//! - HTTP requests with domain allowlists
+//! - Git operations with structured JSON output
+
+pub mod file_read;
+pub mod file_write;
+pub mod git_operations;
+pub mod http_request;
+pub mod security;
+pub mod shell;
+pub mod traits;
+
+pub use file_read::FileReadTool;
+pub use file_write::FileWriteTool;
+pub use git_operations::GitOperationsTool;
+pub use http_request::HttpRequestTool;
+pub use security::{AutonomyLevel, SecurityPolicy};
+pub use shell::ShellTool;
+pub use traits::{Tool, ToolResult, ToolSpec};
+
+use std::sync::Arc;
+
+/// Create the default tool registry with standard tools
+pub fn default_tools(security: Arc<SecurityPolicy>) -> Vec<Box<dyn Tool>> {
+    vec![
+        Box::new(ShellTool::new(security.clone())),
+        Box::new(FileReadTool::new(security.clone())),
+        Box::new(FileWriteTool::new(security)),
+    ]
+}
+
+/// Create a full tool registry including all tools
+pub fn all_tools(
+    security: Arc<SecurityPolicy>,
+    workspace_dir: &std::path::Path,
+    http_allowed_domains: Vec<String>,
+) -> Vec<Box<dyn Tool>> {
+    let mut tools: Vec<Box<dyn Tool>> = vec![
+        Box::new(ShellTool::new(security.clone())),
+        Box::new(FileReadTool::new(security.clone())),
+        Box::new(FileWriteTool::new(security.clone())),
+        Box::new(GitOperationsTool::new(
+            security.clone(),
+            workspace_dir.to_path_buf(),
+        )),
+    ];
+
+    if !http_allowed_domains.is_empty() {
+        tools.push(Box::new(HttpRequestTool::new(
+            security,
+            http_allowed_domains,
+            1_000_000, // 1MB max response
+            30,        // 30 second timeout
+        )));
+    }
+
+    tools
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_tools_has_three() {
+        let security = Arc::new(SecurityPolicy::default());
+        let tools = default_tools(security);
+        assert_eq!(tools.len(), 3);
+    }
+
+    #[test]
+    fn default_tools_names() {
+        let security = Arc::new(SecurityPolicy::default());
+        let tools = default_tools(security);
+        let names: Vec<&str> = tools.iter().map(|t| t.name()).collect();
+        assert!(names.contains(&"shell"));
+        assert!(names.contains(&"file_read"));
+        assert!(names.contains(&"file_write"));
+    }
+
+    #[test]
+    fn all_tools_includes_git() {
+        let security = Arc::new(SecurityPolicy::default());
+        let tools = all_tools(security, std::path::Path::new("/tmp"), vec![]);
+        let names: Vec<&str> = tools.iter().map(|t| t.name()).collect();
+        assert!(names.contains(&"git_operations"));
+    }
+
+    #[test]
+    fn all_tools_includes_http_when_domains_provided() {
+        let security = Arc::new(SecurityPolicy::default());
+        let tools = all_tools(
+            security,
+            std::path::Path::new("/tmp"),
+            vec!["example.com".into()],
+        );
+        let names: Vec<&str> = tools.iter().map(|t| t.name()).collect();
+        assert!(names.contains(&"http_request"));
+    }
+}