enya-agent 0.1.0

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

@@ -0,0 +1,601 @@
+//! Microsoft Teams channel implementation.
+//!
+//! Integrates with the Bot Framework REST API for Teams messaging.
+
+use crate::config::{build_runtime_proxy_client, StreamMode, TeamsConfig};
+use crate::traits::{Channel, ChannelMessage, SendMessage};
+use anyhow::Context;
+use async_trait::async_trait;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::mpsc;
+
+/// Bot Framework token endpoint.
+const BOT_FRAMEWORK_TOKEN_URL: &str =
+    "https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token";
+
+/// Bot Framework API scope.
+const BOT_FRAMEWORK_SCOPE: &str = "https://api.botframework.com/.default";
+
+/// Teams message activity type.
+const ACTIVITY_TYPE_MESSAGE: &str = "message";
+
+/// Teams Activity from Bot Framework.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TeamsActivity {
+    #[serde(rename = "type")]
+    pub activity_type: String,
+    pub id: String,
+    pub timestamp: Option<String>,
+    pub service_url: String,
+    pub channel_id: String,
+    pub from: TeamsAccount,
+    pub conversation: TeamsConversation,
+    pub recipient: Option<TeamsAccount>,
+    pub text: Option<String>,
+    pub text_format: Option<String>,
+    #[serde(default)]
+    pub attachments: Vec<TeamsAttachment>,
+    pub reply_to_id: Option<String>,
+}
+
+/// Teams account (user or bot).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TeamsAccount {
+    pub id: String,
+    pub name: Option<String>,
+    #[serde(rename = "aadObjectId")]
+    pub aad_object_id: Option<String>,
+}
+
+/// Teams conversation reference.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TeamsConversation {
+    pub id: String,
+    pub conversation_type: Option<String>,
+    pub tenant_id: Option<String>,
+    pub name: Option<String>,
+}
+
+/// Teams attachment.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TeamsAttachment {
+    pub content_type: String,
+    pub content_url: Option<String>,
+    pub name: Option<String>,
+}
+
+/// Token response from Bot Framework.
+#[derive(Debug, Deserialize)]
+struct TokenResponse {
+    access_token: String,
+    expires_in: u64,
+}
+
+/// Cached access token.
+struct CachedToken {
+    token: String,
+    expires_at: Instant,
+}
+
+/// Microsoft Teams channel.
+pub struct TeamsChannel {
+    /// Microsoft App ID.
+    app_id: String,
+    /// Microsoft App Password.
+    app_password: String,
+    /// Bot display name.
+    bot_name: String,
+    /// Allowed user IDs (empty = allow all).
+    allowed_users: Vec<String>,
+    /// HTTP client for API calls.
+    client: reqwest::Client,
+    /// Cached access token.
+    token_cache: Arc<Mutex<Option<CachedToken>>>,
+    /// Pending activities from webhook (for listen to consume).
+    pending_activities: Arc<Mutex<Vec<TeamsActivity>>>,
+    /// Webhook receiver channel.
+    webhook_rx: Arc<tokio::sync::Mutex<Option<mpsc::Receiver<TeamsActivity>>>>,
+    /// Webhook sender (for external webhook handler to send activities).
+    webhook_tx: mpsc::Sender<TeamsActivity>,
+    /// Stream mode for draft updates.
+    stream_mode: StreamMode,
+    /// Draft update interval in milliseconds.
+    draft_update_interval_ms: u64,
+}
+
+impl TeamsChannel {
+    /// Create a new Teams channel.
+    pub fn new(config: &TeamsConfig) -> Self {
+        let (webhook_tx, webhook_rx) = mpsc::channel(100);
+
+        Self {
+            app_id: config.app_id.clone(),
+            app_password: config.app_password.clone(),
+            bot_name: config.bot_name.clone(),
+            allowed_users: config.allowed_users.clone(),
+            client: build_runtime_proxy_client("channel.teams"),
+            token_cache: Arc::new(Mutex::new(None)),
+            pending_activities: Arc::new(Mutex::new(Vec::new())),
+            webhook_rx: Arc::new(tokio::sync::Mutex::new(Some(webhook_rx))),
+            webhook_tx,
+            stream_mode: StreamMode::Off,
+            draft_update_interval_ms: 1000,
+        }
+    }
+
+    /// Create with custom streaming settings.
+    pub fn with_streaming(mut self, mode: StreamMode, interval_ms: u64) -> Self {
+        self.stream_mode = mode;
+        self.draft_update_interval_ms = interval_ms;
+        self
+    }
+
+    /// Get the webhook sender for external webhook handlers.
+    pub fn webhook_sender(&self) -> mpsc::Sender<TeamsActivity> {
+        self.webhook_tx.clone()
+    }
+
+    /// Get a valid access token, refreshing if needed.
+    async fn get_access_token(&self) -> anyhow::Result<String> {
+        // Check cache first
+        {
+            let cache = self.token_cache.lock();
+            if let Some(ref cached) = *cache {
+                if Instant::now() < cached.expires_at {
+                    return Ok(cached.token.clone());
+                }
+            }
+        }
+
+        // Fetch new token
+        tracing::debug!("Teams: fetching new access token");
+
+        let params = [
+            ("grant_type", "client_credentials"),
+            ("client_id", &self.app_id),
+            ("client_secret", &self.app_password),
+            ("scope", BOT_FRAMEWORK_SCOPE),
+        ];
+
+        let response = self
+            .client
+            .post(BOT_FRAMEWORK_TOKEN_URL)
+            .form(&params)
+            .send()
+            .await
+            .context("Failed to request Teams access token")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            anyhow::bail!("Teams token request failed ({}): {}", status, body);
+        }
+
+        let token_response: TokenResponse = response
+            .json()
+            .await
+            .context("Failed to parse Teams token response")?;
+
+        // Cache the token (with 60 second buffer)
+        let expires_at = Instant::now() + Duration::from_secs(token_response.expires_in.saturating_sub(60));
+        let token = token_response.access_token.clone();
+
+        {
+            let mut cache = self.token_cache.lock();
+            *cache = Some(CachedToken {
+                token: token.clone(),
+                expires_at,
+            });
+        }
+
+        tracing::debug!("Teams: access token acquired");
+        Ok(token)
+    }
+
+    /// Send a reply to a conversation.
+    async fn send_reply(
+        &self,
+        service_url: &str,
+        conversation_id: &str,
+        text: &str,
+        reply_to_id: Option<&str>,
+    ) -> anyhow::Result<String> {
+        let token = self.get_access_token().await?;
+
+        // Ensure service URL ends with /
+        let service_url = if service_url.ends_with('/') {
+            service_url.to_string()
+        } else {
+            format!("{}/", service_url)
+        };
+
+        let url = format!(
+            "{}v3/conversations/{}/activities",
+            service_url, conversation_id
+        );
+
+        let mut activity = serde_json::json!({
+            "type": "message",
+            "from": {
+                "id": self.app_id,
+                "name": self.bot_name
+            },
+            "conversation": {
+                "id": conversation_id
+            },
+            "text": text,
+            "textFormat": "markdown"
+        });
+
+        if let Some(reply_id) = reply_to_id {
+            activity["replyToId"] = serde_json::json!(reply_id);
+        }
+
+        let response = self
+            .client
+            .post(&url)
+            .bearer_auth(&token)
+            .json(&activity)
+            .send()
+            .await
+            .context("Failed to send Teams message")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            anyhow::bail!("Teams send failed ({}): {}", status, body);
+        }
+
+        // Parse response to get activity ID
+        let result: serde_json::Value = response
+            .json()
+            .await
+            .unwrap_or_else(|_| serde_json::json!({}));
+
+        let activity_id = result["id"]
+            .as_str()
+            .unwrap_or("unknown")
+            .to_string();
+
+        Ok(activity_id)
+    }
+
+    /// Update an existing message.
+    async fn update_message(
+        &self,
+        service_url: &str,
+        conversation_id: &str,
+        activity_id: &str,
+        text: &str,
+    ) -> anyhow::Result<()> {
+        let token = self.get_access_token().await?;
+
+        let service_url = if service_url.ends_with('/') {
+            service_url.to_string()
+        } else {
+            format!("{}/", service_url)
+        };
+
+        let url = format!(
+            "{}v3/conversations/{}/activities/{}",
+            service_url, conversation_id, activity_id
+        );
+
+        let activity = serde_json::json!({
+            "type": "message",
+            "id": activity_id,
+            "from": {
+                "id": self.app_id,
+                "name": self.bot_name
+            },
+            "conversation": {
+                "id": conversation_id
+            },
+            "text": text,
+            "textFormat": "markdown"
+        });
+
+        let response = self
+            .client
+            .put(&url)
+            .bearer_auth(&token)
+            .json(&activity)
+            .send()
+            .await
+            .context("Failed to update Teams message")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            anyhow::bail!("Teams update failed ({}): {}", status, body);
+        }
+
+        Ok(())
+    }
+
+    /// Send typing indicator.
+    async fn send_typing_indicator(
+        &self,
+        service_url: &str,
+        conversation_id: &str,
+    ) -> anyhow::Result<()> {
+        let token = self.get_access_token().await?;
+
+        let service_url = if service_url.ends_with('/') {
+            service_url.to_string()
+        } else {
+            format!("{}/", service_url)
+        };
+
+        let url = format!(
+            "{}v3/conversations/{}/activities",
+            service_url, conversation_id
+        );
+
+        let activity = serde_json::json!({
+            "type": "typing",
+            "from": {
+                "id": self.app_id,
+                "name": self.bot_name
+            },
+            "conversation": {
+                "id": conversation_id
+            }
+        });
+
+        let _ = self
+            .client
+            .post(&url)
+            .bearer_auth(&token)
+            .json(&activity)
+            .send()
+            .await;
+
+        Ok(())
+    }
+
+    /// Check if a user is allowed.
+    fn is_user_allowed(&self, user_id: &str) -> bool {
+        if self.allowed_users.is_empty() {
+            return true;
+        }
+        self.allowed_users.iter().any(|u| u == user_id)
+    }
+
+    /// Strip bot mentions from message text.
+    fn strip_mentions(text: &str) -> String {
+        // Teams mentions are in format <at>BotName</at>
+        let re = regex::Regex::new(r"<at>[^<]*</at>").unwrap();
+        re.replace_all(text, "").trim().to_string()
+    }
+
+    /// Parse a conversation reference for reply routing.
+    fn parse_recipient(recipient: &str) -> Option<(String, String)> {
+        // Format: "service_url|conversation_id"
+        let parts: Vec<&str> = recipient.split('|').collect();
+        if parts.len() == 2 {
+            Some((parts[0].to_string(), parts[1].to_string()))
+        } else {
+            None
+        }
+    }
+
+    /// Build a recipient string from service URL and conversation ID.
+    fn build_recipient(service_url: &str, conversation_id: &str) -> String {
+        format!("{}|{}", service_url, conversation_id)
+    }
+}
+
+#[async_trait]
+impl Channel for TeamsChannel {
+    fn name(&self) -> &str {
+        "teams"
+    }
+
+    async fn send(&self, message: &SendMessage) -> anyhow::Result<()> {
+        let (service_url, conversation_id) = Self::parse_recipient(&message.recipient)
+            .ok_or_else(|| anyhow::anyhow!("Invalid Teams recipient format"))?;
+
+        self.send_reply(&service_url, &conversation_id, &message.content, None)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn listen(&self, tx: mpsc::Sender<ChannelMessage>) -> anyhow::Result<()> {
+        // Take ownership of the webhook receiver
+        let mut webhook_rx = {
+            let mut guard = self.webhook_rx.lock().await;
+            guard.take().ok_or_else(|| anyhow::anyhow!("Teams listener already started"))?
+        };
+
+        tracing::info!("Teams: channel listener started, waiting for webhook activities");
+
+        while let Some(activity) = webhook_rx.recv().await {
+            // Only process message activities
+            if activity.activity_type != ACTIVITY_TYPE_MESSAGE {
+                tracing::debug!(
+                    "Teams: ignoring activity type: {}",
+                    activity.activity_type
+                );
+                continue;
+            }
+
+            // Check if text is present
+            let Some(text) = activity.text.as_ref() else {
+                continue;
+            };
+
+            // Check user authorization
+            if !self.is_user_allowed(&activity.from.id) {
+                tracing::debug!(
+                    "Teams: ignoring message from unauthorized user: {}",
+                    activity.from.id
+                );
+                continue;
+            }
+
+            // Strip bot mentions
+            let clean_text = Self::strip_mentions(text);
+            if clean_text.is_empty() {
+                continue;
+            }
+
+            // Build recipient for replies
+            let recipient = Self::build_recipient(
+                &activity.service_url,
+                &activity.conversation.id,
+            );
+
+            let channel_message = ChannelMessage {
+                id: activity.id.clone(),
+                sender: activity.from.id.clone(),
+                reply_target: recipient,
+                content: clean_text,
+                channel: "teams".to_string(),
+                timestamp: chrono::Utc::now().timestamp() as u64,
+            };
+
+            tracing::debug!(
+                "Teams: received message from {} in conversation {}",
+                activity.from.name.as_deref().unwrap_or("unknown"),
+                activity.conversation.id
+            );
+
+            if tx.send(channel_message).await.is_err() {
+                tracing::warn!("Teams: message channel closed, stopping listener");
+                break;
+            }
+        }
+
+        tracing::info!("Teams: channel listener stopped");
+        Ok(())
+    }
+
+    async fn health_check(&self) -> bool {
+        // Try to get an access token as health check
+        self.get_access_token().await.is_ok()
+    }
+
+    async fn start_typing(&self, recipient: &str) -> anyhow::Result<()> {
+        if let Some((service_url, conversation_id)) = Self::parse_recipient(recipient) {
+            self.send_typing_indicator(&service_url, &conversation_id).await?;
+        }
+        Ok(())
+    }
+
+    fn supports_draft_updates(&self) -> bool {
+        self.stream_mode != StreamMode::Off
+    }
+
+    async fn send_draft(&self, message: &SendMessage) -> anyhow::Result<Option<String>> {
+        let (service_url, conversation_id) = Self::parse_recipient(&message.recipient)
+            .ok_or_else(|| anyhow::anyhow!("Invalid Teams recipient format"))?;
+
+        // Send initial message with typing indicator
+        let activity_id = self
+            .send_reply(&service_url, &conversation_id, &message.content, None)
+            .await?;
+
+        // Return composite ID for updates: "service_url|conversation_id|activity_id"
+        Ok(Some(format!("{}|{}|{}", service_url, conversation_id, activity_id)))
+    }
+
+    async fn update_draft(
+        &self,
+        _recipient: &str,
+        message_id: &str,
+        text: &str,
+    ) -> anyhow::Result<()> {
+        // Parse composite ID
+        let parts: Vec<&str> = message_id.split('|').collect();
+        if parts.len() != 3 {
+            anyhow::bail!("Invalid Teams draft message ID format");
+        }
+
+        let (service_url, conversation_id, activity_id) = (parts[0], parts[1], parts[2]);
+        self.update_message(service_url, conversation_id, activity_id, text).await
+    }
+
+    async fn finalize_draft(
+        &self,
+        recipient: &str,
+        message_id: &str,
+        text: &str,
+    ) -> anyhow::Result<()> {
+        // Same as update for Teams
+        self.update_draft(recipient, message_id, text).await
+    }
+}
+
+/// Axum handler for Teams webhook.
+///
+/// Use this with your Axum router:
+/// ```ignore
+/// let teams = TeamsChannel::new(&config);
+/// let webhook_tx = teams.webhook_sender();
+///
+/// let app = Router::new()
+///     .route("/api/messages", post(teams_webhook_handler))
+///     .with_state(webhook_tx);
+/// ```
+pub async fn teams_webhook_handler(
+    axum::extract::State(tx): axum::extract::State<mpsc::Sender<TeamsActivity>>,
+    axum::extract::Json(activity): axum::extract::Json<TeamsActivity>,
+) -> impl axum::response::IntoResponse {
+    tracing::debug!(
+        "Teams webhook: received {} activity from {}",
+        activity.activity_type,
+        activity.from.name.as_deref().unwrap_or("unknown")
+    );
+
+    if let Err(e) = tx.send(activity).await {
+        tracing::error!("Teams webhook: failed to forward activity: {}", e);
+        return axum::http::StatusCode::INTERNAL_SERVER_ERROR;
+    }
+
+    axum::http::StatusCode::OK
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_strip_mentions() {
+        assert_eq!(
+            TeamsChannel::strip_mentions("<at>BotName</at> hello"),
+            "hello"
+        );
+        assert_eq!(
+            TeamsChannel::strip_mentions("hello <at>Bot</at> world"),
+            "hello  world"
+        );
+        assert_eq!(TeamsChannel::strip_mentions("no mentions"), "no mentions");
+    }
+
+    #[test]
+    fn test_parse_recipient() {
+        let result = TeamsChannel::parse_recipient("https://smba.trafficmanager.net/|19:abc123");
+        assert!(result.is_some());
+        let (url, conv) = result.unwrap();
+        assert_eq!(url, "https://smba.trafficmanager.net/");
+        assert_eq!(conv, "19:abc123");
+    }
+
+    #[test]
+    fn test_build_recipient() {
+        let recipient = TeamsChannel::build_recipient(
+            "https://smba.trafficmanager.net/",
+            "19:abc123",
+        );
+        assert_eq!(recipient, "https://smba.trafficmanager.net/|19:abc123");
+    }
+}