feat: Add Telegram, Discord, and Slack messenger support

Implements tier 1 CLI-based messengers using HTTP APIs:
- Telegram: Bot API (getUpdates, sendMessage)
- Discord: REST API v10 (channels/messages)
- Slack: Web API (chat.postMessage, conversations.history)

All use reqwest for HTTP (already a dep), no external CLI tools needed.
Feature flags: telegram-cli, discord-cli, slack-cli

Part of #115 (messenger support)

Author: rexlunae

crates/rustyclaw-core/Cargo.toml

@@ -22,9 +22,14 @@ browser = ["dep:chromiumoxide"]
 mcp = ["dep:rmcp", "dep:schemars"]
 matrix = ["dep:matrix-sdk"]
 whatsapp = ["dep:wa-rs", "dep:wa-rs-sqlite-storage", "dep:wa-rs-tokio-transport", "dep:wa-rs-ureq-http"]
+# CLI-based messengers (tier 1) - no heavy deps, just HTTP
+signal-cli = []
+telegram-cli = []
+discord-cli = []
+slack-cli = []
 # NOTE: matrix excluded from all-messengers due to matrix-sdk 0.16 recursion limit bug.
 # Use `--features matrix` explicitly if needed.
-all-messengers = ["whatsapp"]
+all-messengers = ["whatsapp", "signal-cli", "telegram-cli", "discord-cli", "slack-cli"]
 full = ["web-tools", "browser", "mcp", "all-messengers"]
 
 [dependencies]

crates/rustyclaw-core/src/messengers/discord_cli.rs

@@ -0,0 +1,216 @@
+//! Discord messenger using REST API.
+//!
+//! Uses Discord's REST API at https://discord.com/api/v10/
+//! For simplicity, this uses polling for receiving messages rather than
+//! WebSocket Gateway. Good for low-volume bot use cases.
+//!
+//! This requires the `discord-cli` feature to be enabled.
+
+use super::{Message, Messenger, SendOptions};
+use anyhow::{Context, Result};
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+const DISCORD_API_BASE: &str = "https://discord.com/api/v10";
+
+/// Discord User object
+#[derive(Debug, Deserialize)]
+struct DiscordUser {
+    id: String,
+    username: String,
+    discriminator: String,
+}
+
+/// Discord Message object
+#[derive(Debug, Deserialize)]
+struct DiscordMessage {
+    id: String,
+    channel_id: String,
+    author: DiscordUser,
+    content: String,
+    timestamp: String,
+}
+
+/// Discord messenger implementation
+pub struct DiscordCliMessenger {
+    name: String,
+    token: String,
+    client: Client,
+    connected: Arc<Mutex<bool>>,
+    last_message_ids: Arc<Mutex<std::collections::HashMap<String, String>>>,
+    watch_channels: Vec<String>,
+}
+
+impl DiscordCliMessenger {
+    /// Create a new Discord messenger with bot token
+    pub fn new(name: String, token: String) -> Self {
+        Self {
+            name,
+            token,
+            client: Client::new(),
+            connected: Arc::new(Mutex::new(false)),
+            last_message_ids: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            watch_channels: Vec::new(),
+        }
+    }
+
+    /// Add a channel to watch for incoming messages
+    pub fn watch_channel(mut self, channel_id: String) -> Self {
+        self.watch_channels.push(channel_id);
+        self
+    }
+
+    /// Get authorization header
+    fn auth_header(&self) -> String {
+        format!("Bot {}", self.token)
+    }
+
+    /// Get current user info to verify token
+    async fn get_me(&self) -> Result<DiscordUser> {
+        let url = format!("{}/users/@me", DISCORD_API_BASE);
+        let response = self.client
+            .get(&url)
+            .header("Authorization", self.auth_header())
+            .send()
+            .await?;
+        
+        let status = response.status();
+        if !status.is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Discord API error: {} - {}", status, error_text);
+        }
+
+        response.json().await.context("Failed to parse user info")
+    }
+
+    /// Send a message to a channel
+    async fn send_message_internal(&self, channel_id: &str, content: &str) -> Result<String> {
+        let url = format!("{}/channels/{}/messages", DISCORD_API_BASE, channel_id);
+        
+        let body = serde_json::json!({
+            "content": content
+        });
+
+        let response = self.client
+            .post(&url)
+            .header("Authorization", self.auth_header())
+            .json(&body)
+            .send()
+            .await
+            .context("Failed to send Discord message")?;
+
+        let status = response.status();
+        if !status.is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Failed to send message: {} - {}", status, error_text);
+        }
+
+        let msg: DiscordMessage = response.json().await?;
+        Ok(msg.id)
+    }
+
+    /// Get messages from a channel
+    async fn get_channel_messages(&self, channel_id: &str, limit: u32) -> Result<Vec<DiscordMessage>> {
+        let last_ids = self.last_message_ids.lock().await;
+        let after_id = last_ids.get(channel_id).cloned();
+        drop(last_ids);
+
+        let mut url = format!("{}/channels/{}/messages?limit={}", DISCORD_API_BASE, channel_id, limit);
+        
+        if let Some(after) = after_id {
+            url.push_str(&format!("&after={}", after));
+        }
+
+        let response = self.client
+            .get(&url)
+            .header("Authorization", self.auth_header())
+            .send()
+            .await?;
+        
+        let status = response.status();
+        if !status.is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Failed to get messages: {} - {}", status, error_text);
+        }
+
+        let messages: Vec<DiscordMessage> = response.json().await?;
+
+        // Update last seen message ID
+        if let Some(latest) = messages.first() {
+            self.last_message_ids.lock().await.insert(channel_id.to_string(), latest.id.clone());
+        }
+
+        Ok(messages)
+    }
+}
+
+impl std::fmt::Debug for DiscordCliMessenger {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DiscordCliMessenger")
+            .field("name", &self.name)
+            .field("watch_channels", &self.watch_channels)
+            .finish()
+    }
+}
+
+#[async_trait]
+impl Messenger for DiscordCliMessenger {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn messenger_type(&self) -> &str {
+        "discord"
+    }
+
+    async fn initialize(&mut self) -> Result<()> {
+        let user = self.get_me().await.context("Failed to verify Discord bot token")?;
+        *self.connected.lock().await = true;
+        tracing::info!("Discord bot connected as {}#{}", user.username, user.discriminator);
+        Ok(())
+    }
+
+    async fn send_message(&self, recipient: &str, content: &str) -> Result<String> {
+        self.send_message_internal(recipient, content).await
+    }
+
+    async fn receive_messages(&self) -> Result<Vec<Message>> {
+        let mut all_messages = Vec::new();
+
+        for channel in &self.watch_channels {
+            match self.get_channel_messages(channel, 100).await {
+                Ok(messages) => {
+                    for msg in messages {
+                        all_messages.push(Message {
+                            id: msg.id,
+                            sender: msg.author.username,
+                            content: msg.content,
+                            timestamp: 0, // Would need to parse ISO timestamp
+                            channel: Some(msg.channel_id),
+                            reply_to: None,
+                            media: None,
+                        });
+                    }
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to get messages for channel {}: {}", channel, e);
+                }
+            }
+        }
+
+        Ok(all_messages)
+    }
+
+    fn is_connected(&self) -> bool {
+        self.connected.try_lock().map(|g| *g).unwrap_or(false)
+    }
+
+    async fn disconnect(&mut self) -> Result<()> {
+        *self.connected.lock().await = false;
+        Ok(())
+    }
+}

crates/rustyclaw-core/src/messengers/mod.rs

@@ -193,3 +193,25 @@ pub use matrix::MatrixMessenger;
 mod whatsapp;
 #[cfg(feature = "whatsapp")]
 pub use whatsapp::WhatsAppMessenger;
+
+// ── Tier 1: CLI-based messengers (lightweight HTTP/process wrappers) ────────
+
+#[cfg(feature = "signal-cli")]
+mod signal_cli;
+#[cfg(feature = "signal-cli")]
+pub use signal_cli::SignalCliMessenger;
+
+#[cfg(feature = "telegram-cli")]
+mod telegram_cli;
+#[cfg(feature = "telegram-cli")]
+pub use telegram_cli::TelegramCliMessenger;
+
+#[cfg(feature = "discord-cli")]
+mod discord_cli;
+#[cfg(feature = "discord-cli")]
+pub use discord_cli::DiscordCliMessenger;
+
+#[cfg(feature = "slack-cli")]
+mod slack_cli;
+#[cfg(feature = "slack-cli")]
+pub use slack_cli::SlackCliMessenger;