Add support for sending more media types

Author: dcvz

Cargo.lock

@@ -73,3 +73,6 @@ rustls = { version = "0.23", features = ["aws-lc-rs"] }
 
 # Lightweight regex for Slack markdown conversion
 regex-lite = "0.1"
+
+# MIME type detection for file uploads
+mime_guess = "2"

Cargo.toml

@@ -255,21 +255,24 @@ pub async fn execute_action(
     }
 }
 
-/// Extract image paths from Claude's response text.
+/// Extract media file paths from Claude's response text.
 ///
-/// Looks for file paths in the response that point to image files.
-/// Specifically looks for paths in the skills/nano-banana/generated/ directory.
-fn extract_image_attachments(response: &str) -> Vec<PathBuf> {
+/// Looks for file paths in the response that point to image or video files.
+fn extract_media_attachments(response: &str) -> Vec<PathBuf> {
     let mut attachments = Vec::new();
 
-    // Look for file paths that end in image extensions
-    let image_extensions = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+    // Look for file paths that end in media extensions
+    let media_extensions = [
+        // Images
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", // Videos
+        ".mp4", ".mov", ".webm", ".avi",
+    ];
 
     for line in response.lines() {
         let line = line.trim();
 
         // Check if line contains a file path
-        for ext in &image_extensions {
+        for ext in &media_extensions {
             if line.contains(ext) {
                 // Try to extract the path - look for paths starting with /Users/
                 if let Some(start) = line.find("/Users/") {
@@ -279,7 +282,7 @@ fn extract_image_attachments(response: &str) -> Vec<PathBuf> {
                         let path_str = &line[start..end_pos];
                         if std::path::Path::new(path_str).exists() {
                             attachments.push(PathBuf::from(path_str));
-                            break; // Found the image on this line, move to next line
+                            break;
                         }
                     }
                 }
@@ -293,17 +296,19 @@ fn extract_image_attachments(response: &str) -> Vec<PathBuf> {
 /// Remove lines from the response that contain file paths.
 ///
 /// This cleans up responses to avoid showing technical file paths to the user
-/// when images are being sent as attachments.
+/// when media files are being sent as attachments.
 fn remove_file_path_lines(response: &str) -> String {
     let lines: Vec<&str> = response
         .lines()
         .filter(|line| {
             let trimmed = line.trim();
-            // Skip lines that contain /Users/ (file paths)
-            // Skip lines that are just "The image has been saved to:" or similar
+            let lower = trimmed.to_lowercase();
+            // Skip lines that contain file paths or mention saving files
             !trimmed.contains("/Users/")
-                && !trimmed.to_lowercase().contains("saved to")
-                && !trimmed.to_lowercase().contains("image has been saved")
+                && !lower.contains("saved to")
+                && !lower.contains("image has been saved")
+                && !lower.contains("video has been saved")
+                && !lower.contains("file has been saved")
                 && !trimmed.is_empty()
         })
         .collect();
@@ -368,8 +373,8 @@ pub async fn execute_claude_query(channel: Arc<dyn Channel>, user_id: &str, mess
         }
     };
 
-    // Extract any image attachments from the response
-    let attachments = extract_image_attachments(&response);
+    // Extract any media attachments (images, videos) from the response
+    let attachments = extract_media_attachments(&response);
 
     // Send response with attachments if any
     if !attachments.is_empty() {

src/channels/mod.rs

@@ -221,6 +221,88 @@ impl Channel for SlackChannel {
         }
     }
 
+    async fn send_message_with_attachments(
+        &self,
+        message: &str,
+        attachment_paths: &[PathBuf],
+    ) -> Result<()> {
+        // If no attachments, just send the text message
+        if attachment_paths.is_empty() {
+            return self.send_message(message).await;
+        }
+
+        let session = self.client.open_session(&self.token);
+
+        let mut uploaded_files = Vec::new();
+
+        for path in attachment_paths {
+            if !path.exists() {
+                warn!("Attachment path does not exist: {:?}", path);
+                continue;
+            }
+
+            let file_bytes = std::fs::read(path)?;
+            let filename = path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or("file")
+                .to_string();
+
+            let get_url_req =
+                SlackApiFilesGetUploadUrlExternalRequest::new(filename.clone(), file_bytes.len());
+
+            let get_url_resp = session
+                .get_upload_url_external(&get_url_req)
+                .await
+                .map_err(|e| anyhow::anyhow!("Failed to get upload URL: {}", e))?;
+
+            let content_type = mime_guess::from_path(path)
+                .first_or_octet_stream()
+                .to_string();
+
+            let upload_req = SlackApiFilesUploadViaUrlRequest::new(
+                get_url_resp.upload_url,
+                file_bytes,
+                content_type,
+            );
+
+            session
+                .files_upload_via_url(&upload_req)
+                .await
+                .map_err(|e| anyhow::anyhow!("Failed to upload file: {}", e))?;
+
+            uploaded_files
+                .push(SlackApiFilesComplete::new(get_url_resp.file_id).with_title(filename));
+        }
+
+        if uploaded_files.is_empty() {
+            if !message.is_empty() {
+                return self.send_message(message).await;
+            }
+            return Ok(());
+        }
+
+        let mut complete_req = SlackApiFilesCompleteUploadExternalRequest::new(uploaded_files)
+            .with_channel_id(self.channel_id.clone());
+
+        if !message.is_empty() {
+            let mrkdwn_message = markdown_to_mrkdwn(message);
+            complete_req = complete_req.with_initial_comment(mrkdwn_message);
+        }
+
+        if let Some(ts) = &self.thread_ts {
+            complete_req = complete_req.with_thread_ts(ts.clone());
+        }
+
+        session
+            .files_complete_upload_external(&complete_req)
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to complete file upload: {}", e))?;
+
+        info!("Sent message with attachments to Slack");
+        Ok(())
+    }
+
     fn start_typing(&self) -> TypingGuard {
         // For Slack AI assistants, we use assistant.threads.setStatus
         // to show a "thinking" indicator

src/channels/slack.rs

@@ -59,30 +59,40 @@ impl Channel for TelegramChannel {
             return self.send_message(message).await;
         }
 
-        // Send images as photos
+        let is_first_attachment = |path: &PathBuf| -> bool {
+            attachment_paths.first().map(|p| p == path).unwrap_or(false)
+        };
+
+        // Send each attachment using the appropriate Telegram method
         for path in attachment_paths {
             if !path.exists() {
                 warn!("Attachment path does not exist: {:?}", path);
                 continue;
             }
 
-            // Create InputFile from path
             let input_file = InputFile::file(path);
+            let caption = if is_first_attachment(path) && !message.is_empty() {
+                Some(message)
+            } else {
+                None
+            };
 
-            // Send the photo with the message as caption (only on first photo)
-            if path == attachment_paths.first().unwrap() && !message.is_empty() {
-                // First photo gets the caption
-                self.bot
-                    .send_photo(self.chat_id, input_file)
-                    .caption(message)
-                    .await?;
+            if is_video_file(path) {
+                let mut req = self.bot.send_video(self.chat_id, input_file);
+                if let Some(caption) = caption {
+                    req = req.caption(caption);
+                }
+                req.await?;
             } else {
-                // Subsequent photos without caption
-                self.bot.send_photo(self.chat_id, input_file).await?;
+                let mut req = self.bot.send_photo(self.chat_id, input_file);
+                if let Some(caption) = caption {
+                    req = req.caption(caption);
+                }
+                req.await?;
             }
         }
 
-        // If message exists but all photos failed, send just the text
+        // If message exists but all attachments were missing, send just the text
         if !message.is_empty() && attachment_paths.iter().all(|p| !p.exists()) {
             self.send_message(message).await?;
         }
@@ -118,9 +128,23 @@ impl Channel for TelegramChannel {
 }
 
 // ============================================================================
-// Photo Handling
+// Media Handling
 // ============================================================================
 
+/// Video file extensions supported for sending
+const VIDEO_EXTENSIONS: &[&str] = &[".mp4", ".mov", ".webm", ".avi"];
+
+/// Check if a file path points to a video based on its extension
+fn is_video_file(path: &std::path::Path) -> bool {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .map(|ext| {
+            let dot_ext = format!(".{}", ext.to_lowercase());
+            VIDEO_EXTENSIONS.contains(&dot_ext.as_str())
+        })
+        .unwrap_or(false)
+}
+
 /// Get the directory where Telegram attachments are stored
 fn get_telegram_attachments_dir() -> Result<PathBuf> {
     let paths = config::paths()?;