enya-agent 0.1.0

package/crates/enact-channels/src/traits.rs

@@ -0,0 +1,200 @@
+use async_trait::async_trait;
+
+/// A message received from or sent to a channel
+#[derive(Debug, Clone)]
+pub struct ChannelMessage {
+    pub id: String,
+    pub sender: String,
+    pub reply_target: String,
+    pub content: String,
+    pub channel: String,
+    pub timestamp: u64,
+}
+
+/// Message to send through a channel
+#[derive(Debug, Clone)]
+pub struct SendMessage {
+    pub content: String,
+    pub recipient: String,
+    pub subject: Option<String>,
+}
+
+impl SendMessage {
+    /// Create a new message with content and recipient
+    pub fn new(content: impl Into<String>, recipient: impl Into<String>) -> Self {
+        Self {
+            content: content.into(),
+            recipient: recipient.into(),
+            subject: None,
+        }
+    }
+
+    /// Create a new message with content, recipient, and subject
+    pub fn with_subject(
+        content: impl Into<String>,
+        recipient: impl Into<String>,
+        subject: impl Into<String>,
+    ) -> Self {
+        Self {
+            content: content.into(),
+            recipient: recipient.into(),
+            subject: Some(subject.into()),
+        }
+    }
+}
+
+/// Core channel trait — implement for any messaging platform
+#[async_trait]
+pub trait Channel: Send + Sync {
+    /// Human-readable channel name
+    fn name(&self) -> &str;
+
+    /// Send a message through this channel
+    async fn send(&self, message: &SendMessage) -> anyhow::Result<()>;
+
+    /// Start listening for incoming messages (long-running)
+    async fn listen(&self, tx: tokio::sync::mpsc::Sender<ChannelMessage>) -> anyhow::Result<()>;
+
+    /// Check if channel is healthy
+    async fn health_check(&self) -> bool {
+        true
+    }
+
+    /// Signal that the bot is processing a response (e.g. "typing" indicator).
+    /// Implementations should repeat the indicator as needed for their platform.
+    async fn start_typing(&self, _recipient: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    /// Stop any active typing indicator.
+    async fn stop_typing(&self, _recipient: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    /// Whether this channel supports progressive message updates via draft edits.
+    fn supports_draft_updates(&self) -> bool {
+        false
+    }
+
+    /// Send an initial draft message. Returns a platform-specific message ID for later edits.
+    async fn send_draft(&self, _message: &SendMessage) -> anyhow::Result<Option<String>> {
+        Ok(None)
+    }
+
+    /// Update a previously sent draft message with new accumulated content.
+    async fn update_draft(
+        &self,
+        _recipient: &str,
+        _message_id: &str,
+        _text: &str,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    /// Finalize a draft with the complete response (e.g. apply Markdown formatting).
+    async fn finalize_draft(
+        &self,
+        _recipient: &str,
+        _message_id: &str,
+        _text: &str,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct DummyChannel;
+
+    #[async_trait]
+    impl Channel for DummyChannel {
+        fn name(&self) -> &str {
+            "dummy"
+        }
+
+        async fn send(&self, _message: &SendMessage) -> anyhow::Result<()> {
+            Ok(())
+        }
+
+        async fn listen(
+            &self,
+            tx: tokio::sync::mpsc::Sender<ChannelMessage>,
+        ) -> anyhow::Result<()> {
+            tx.send(ChannelMessage {
+                id: "1".into(),
+                sender: "tester".into(),
+                reply_target: "tester".into(),
+                content: "hello".into(),
+                channel: "dummy".into(),
+                timestamp: 123,
+            })
+            .await
+            .map_err(|e| anyhow::anyhow!(e.to_string()))
+        }
+    }
+
+    #[test]
+    fn channel_message_clone_preserves_fields() {
+        let message = ChannelMessage {
+            id: "42".into(),
+            sender: "alice".into(),
+            reply_target: "alice".into(),
+            content: "ping".into(),
+            channel: "dummy".into(),
+            timestamp: 999,
+        };
+
+        let cloned = message.clone();
+        assert_eq!(cloned.id, "42");
+        assert_eq!(cloned.sender, "alice");
+        assert_eq!(cloned.reply_target, "alice");
+        assert_eq!(cloned.content, "ping");
+        assert_eq!(cloned.channel, "dummy");
+        assert_eq!(cloned.timestamp, 999);
+    }
+
+    #[tokio::test]
+    async fn default_trait_methods_return_success() {
+        let channel = DummyChannel;
+
+        assert!(channel.health_check().await);
+        assert!(channel.start_typing("bob").await.is_ok());
+        assert!(channel.stop_typing("bob").await.is_ok());
+        assert!(channel
+            .send(&SendMessage::new("hello", "bob"))
+            .await
+            .is_ok());
+    }
+
+    #[tokio::test]
+    async fn default_draft_methods_return_success() {
+        let channel = DummyChannel;
+
+        assert!(!channel.supports_draft_updates());
+        assert!(channel
+            .send_draft(&SendMessage::new("draft", "bob"))
+            .await
+            .unwrap()
+            .is_none());
+        assert!(channel.update_draft("bob", "msg_1", "text").await.is_ok());
+        assert!(channel
+            .finalize_draft("bob", "msg_1", "final text")
+            .await
+            .is_ok());
+    }
+
+    #[tokio::test]
+    async fn listen_sends_message_to_channel() {
+        let channel = DummyChannel;
+        let (tx, mut rx) = tokio::sync::mpsc::channel(1);
+
+        channel.listen(tx).await.unwrap();
+
+        let received = rx.recv().await.expect("message should be sent");
+        assert_eq!(received.sender, "tester");
+        assert_eq!(received.content, "hello");
+        assert_eq!(received.channel, "dummy");
+    }
+}

package/crates/enact-channels/src/webhook.rs

@@ -0,0 +1,262 @@
+use crate::traits::{Channel, ChannelMessage, SendMessage};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use uuid::Uuid;
+
+/// Generic webhook channel for receiving HTTP callbacks
+pub struct WebhookChannel {
+    endpoint_path: String,
+    secret_token: Option<String>,
+    message_queue: Arc<Mutex<Vec<ChannelMessage>>>,
+    response_map: Arc<Mutex<HashMap<String, String>>>,
+}
+
+impl WebhookChannel {
+    pub fn new(endpoint_path: impl Into<String>) -> Self {
+        Self {
+            endpoint_path: endpoint_path.into(),
+            secret_token: None,
+            message_queue: Arc::new(Mutex::new(Vec::new())),
+            response_map: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub fn with_secret(mut self, secret: impl Into<String>) -> Self {
+        self.secret_token = Some(secret.into());
+        self
+    }
+
+    /// Parse incoming webhook payload
+    pub fn parse_payload(
+        &self,
+        payload: &serde_json::Value,
+        headers: &HashMap<String, String>,
+    ) -> anyhow::Result<Option<ChannelMessage>> {
+        // Verify secret if configured
+        if let Some(ref secret) = self.secret_token {
+            let auth_header = headers
+                .get("authorization")
+                .or_else(|| headers.get("Authorization"))
+                .map(String::as_str)
+                .unwrap_or("");
+            
+            if !auth_header.contains(secret) {
+                anyhow::bail!("Invalid or missing authorization header");
+            }
+        }
+
+        // Extract message fields
+        let from = payload
+            .get("from")
+            .and_then(|v| v.as_str())
+            .unwrap_or("webhook")
+            .to_string();
+
+        let content = payload
+            .get("message")
+            .or_else(|| payload.get("content"))
+            .and_then(|v| v.as_str())
+            .unwrap_or_default()
+            .to_string();
+
+        if content.is_empty() {
+            return Ok(None);
+        }
+
+        let id = payload
+            .get("id")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| Uuid::new_v4().to_string());
+
+        let timestamp = payload
+            .get("timestamp")
+            .and_then(|v| v.as_u64())
+            .unwrap_or_else(|| {
+                std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .unwrap_or_default()
+                    .as_secs()
+            });
+
+        let message = ChannelMessage {
+            id,
+            reply_target: from.clone(),
+            sender: from,
+            content,
+            channel: "webhook".to_string(),
+            timestamp,
+        };
+
+        Ok(Some(message))
+    }
+
+    /// Queue a message for processing
+    pub async fn queue_message(&self, message: ChannelMessage) {
+        let mut queue = self.message_queue.lock().await;
+        queue.push(message);
+    }
+
+    /// Get queued messages (and clear the queue)
+    pub async fn drain_messages(&self) -> Vec<ChannelMessage> {
+        let mut queue = self.message_queue.lock().await;
+        std::mem::take(&mut *queue)
+    }
+
+    /// Store a response for a message
+    pub async fn store_response(&self, message_id: &str, response: &str) {
+        let mut map = self.response_map.lock().await;
+        map.insert(message_id.to_string(), response.to_string());
+    }
+
+    /// Get a stored response
+    pub async fn get_response(&self, message_id: &str) -> Option<String> {
+        let map = self.response_map.lock().await;
+        map.get(message_id).cloned()
+    }
+
+    pub fn endpoint_path(&self) -> &str {
+        &self.endpoint_path
+    }
+}
+
+#[async_trait]
+impl Channel for WebhookChannel {
+    fn name(&self) -> &str {
+        "webhook"
+    }
+
+    async fn send(&self, message: &SendMessage) -> anyhow::Result<()> {
+        // For webhook channel, we store responses that can be retrieved via HTTP
+        self.store_response(&message.recipient, &message.content).await;
+        Ok(())
+    }
+
+    async fn listen(
+        &self,
+        _tx: tokio::sync::mpsc::Sender<ChannelMessage>,
+    ) -> anyhow::Result<()> {
+        // Webhook channel doesn't actively listen - it receives via HTTP
+        // This method should be called in a loop that checks for queued messages
+        loop {
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+        }
+    }
+
+    async fn health_check(&self) -> bool {
+        true
+    }
+}
+
+/// Webhook payload format
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebhookPayload {
+    pub from: String,
+    pub message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<u64>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_webhook_channel_creation() {
+        let channel = WebhookChannel::new("/webhook");
+        assert_eq!(channel.name(), "webhook");
+        assert_eq!(channel.endpoint_path(), "/webhook");
+    }
+
+    #[test]
+    fn test_parse_payload() {
+        let channel = WebhookChannel::new("/webhook");
+        let payload = serde_json::json!({
+            "from": "test-system",
+            "message": "Hello from webhook"
+        });
+        let headers = HashMap::new();
+
+        let result = channel.parse_payload(&payload, &headers).unwrap();
+        assert!(result.is_some());
+        
+        let msg = result.unwrap();
+        assert_eq!(msg.sender, "test-system");
+        assert_eq!(msg.content, "Hello from webhook");
+        assert_eq!(msg.channel, "webhook");
+    }
+
+    #[test]
+    fn test_parse_payload_with_secret() {
+        let channel = WebhookChannel::new("/webhook").with_secret("my-secret");
+        let payload = serde_json::json!({
+            "from": "test",
+            "message": "Hello"
+        });
+        
+        // Without auth header, should fail
+        let headers = HashMap::new();
+        let result = channel.parse_payload(&payload, &headers);
+        assert!(result.is_err());
+
+        // With correct auth header, should succeed
+        let mut headers = HashMap::new();
+        headers.insert("Authorization".to_string(), "Bearer my-secret".to_string());
+        let result = channel.parse_payload(&payload, &headers).unwrap();
+        assert!(result.is_some());
+    }
+
+    #[test]
+    fn test_parse_empty_payload() {
+        let channel = WebhookChannel::new("/webhook");
+        let payload = serde_json::json!({
+            "from": "test",
+            "other": "field"
+        });
+        let headers = HashMap::new();
+
+        let result = channel.parse_payload(&payload, &headers).unwrap();
+        assert!(result.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_message_queue() {
+        let channel = WebhookChannel::new("/webhook");
+        let msg = ChannelMessage {
+            id: "1".to_string(),
+            sender: "test".to_string(),
+            reply_target: "test".to_string(),
+            content: "Hello".to_string(),
+            channel: "webhook".to_string(),
+            timestamp: 0,
+        };
+
+        channel.queue_message(msg).await;
+        let messages = channel.drain_messages().await;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].content, "Hello");
+        
+        // Queue should be empty now
+        let messages = channel.drain_messages().await;
+        assert!(messages.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_response_storage() {
+        let channel = WebhookChannel::new("/webhook");
+        channel.store_response("msg-1", "Response content").await;
+        
+        let response = channel.get_response("msg-1").await;
+        assert_eq!(response.as_deref(), Some("Response content"));
+        
+        let response = channel.get_response("unknown").await;
+        assert!(response.is_none());
+    }
+}