mur_chat/

slack.rs

//! Slack integration — Bot API, slash commands, interactive buttons, progress threads.

use crate::platform::{
    ApprovalRequest, ChatPlatform, OutgoingMessage, ProgressStatus, ProgressUpdate,
    WorkflowNotification,
};
use anyhow::{Context, Result};
use serde::Deserialize;

/// Slack bot configuration.
#[derive(Debug, Clone)]
pub struct SlackConfig {
    pub bot_token: String,
    pub signing_secret: Option<String>,
    pub default_channel: Option<String>,
}

impl SlackConfig {
    /// Create from environment variables.
    pub fn from_env() -> Result<Self> {
        let bot_token =
            std::env::var("SLACK_BOT_TOKEN").context("SLACK_BOT_TOKEN not set")?;
        let signing_secret = std::env::var("SLACK_SIGNING_SECRET").ok();
        let default_channel = std::env::var("SLACK_DEFAULT_CHANNEL").ok();

        Ok(Self {
            bot_token,
            signing_secret,
            default_channel,
        })
    }
}

/// Slack bot client.
pub struct SlackBot {
    config: SlackConfig,
    client: reqwest::Client,
}

#[derive(Deserialize)]
struct SlackApiResponse {
    ok: bool,
    #[serde(default)]
    error: Option<String>,
    #[serde(default)]
    ts: Option<String>,
}

impl SlackBot {
    pub fn new(config: SlackConfig) -> Self {
        Self {
            config,
            client: reqwest::Client::builder().connect_timeout(std::time::Duration::from_secs(10)).timeout(std::time::Duration::from_secs(30)).build().unwrap_or_else(|_| reqwest::Client::new()),
        }
    }

    async fn api_call(
        &self,
        method: &str,
        body: serde_json::Value,
    ) -> Result<SlackApiResponse> {
        // NOTE: Slack API base URL is hardcoded. Consider making it configurable
        // for testing or enterprise Slack instances.
        let url = format!("https://slack.com/api/{}", method);
        let response = self
            .client
            .post(&url)
            .header(
                "Authorization",
                format!("Bearer {}", self.config.bot_token),
            )
            .json(&body)
            .send()
            .await
            .context("Slack API request failed")?;

        let api_response: SlackApiResponse = response.json().await?;
        if !api_response.ok {
            anyhow::bail!(
                "Slack API error: {}",
                api_response.error.unwrap_or_default()
            );
        }
        Ok(api_response)
    }

    /// Build a progress bar string: [████░░░░░░] 2/5
    fn progress_bar(current: usize, total: usize) -> String {
        let filled = if total > 0 {
            (current * 10) / total
        } else {
            0
        };
        let empty = 10 - filled;
        format!(
            "[{}{}] {}/{}",
            "█".repeat(filled),
            "░".repeat(empty),
            current,
            total
        )
    }
}

impl ChatPlatform for SlackBot {
    async fn send_message(&self, msg: &OutgoingMessage) -> Result<String> {
        let mut body = serde_json::json!({
            "channel": msg.channel_id,
            "text": msg.text,
        });

        if let Some(ref thread) = msg.thread_id {
            body["thread_ts"] = serde_json::Value::String(thread.clone());
        }

        if let Some(ref blocks) = msg.blocks {
            body["blocks"] = blocks.clone();
        }

        let response = self.api_call("chat.postMessage", body).await?;
        Ok(response.ts.unwrap_or_default())
    }

    async fn send_approval(
        &self,
        channel_id: &str,
        request: &ApprovalRequest,
    ) -> Result<String> {
        let blocks = serde_json::json!([
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": format!(
                        "⚠️ *Approval Required*\n\nStep: `{}`\n{}\n\nCommand: `{}`",
                        request.step_name, request.description, request.action
                    )
                }
            },
            {
                "type": "actions",
                "block_id": format!("approve_{}", request.execution_id),
                "elements": [
                    {
                        "type": "button",
                        "text": { "type": "plain_text", "text": "✅ Approve" },
                        "style": "primary",
                        "action_id": "approve",
                        "value": request.execution_id,
                    },
                    {
                        "type": "button",
                        "text": { "type": "plain_text", "text": "❌ Deny" },
                        "style": "danger",
                        "action_id": "deny",
                        "value": request.execution_id,
                    }
                ]
            }
        ]);

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text: format!("Approval needed for step: {}", request.step_name),
            thread_id: None,
            blocks: Some(blocks),
        };

        self.send_message(&msg).await
    }

    async fn update_message(
        &self,
        channel_id: &str,
        message_id: &str,
        text: &str,
    ) -> Result<()> {
        self.api_call(
            "chat.update",
            serde_json::json!({
                "channel": channel_id,
                "ts": message_id,
                "text": text,
            }),
        )
        .await?;
        Ok(())
    }

    async fn add_reaction(
        &self,
        channel_id: &str,
        message_id: &str,
        emoji: &str,
    ) -> Result<()> {
        self.api_call(
            "reactions.add",
            serde_json::json!({
                "channel": channel_id,
                "timestamp": message_id,
                "name": emoji,
            }),
        )
        .await?;
        Ok(())
    }

    async fn send_progress(
        &self,
        channel_id: &str,
        thread_id: &str,
        progress: &ProgressUpdate,
    ) -> Result<String> {
        let (icon, status_text) = match progress.status {
            ProgressStatus::Started => ("🚀", "Workflow started"),
            ProgressStatus::StepRunning => ("⏳", "Running"),
            ProgressStatus::StepDone => ("✅", "Completed"),
            ProgressStatus::StepFailed => ("❌", "Failed"),
            ProgressStatus::Completed => ("🎉", "Workflow completed"),
            ProgressStatus::Failed => ("💥", "Workflow failed"),
        };

        let bar = Self::progress_bar(progress.step_index + 1, progress.total_steps);
        let duration = progress
            .duration_ms
            .map(|ms| format!(" ({}ms)", ms))
            .unwrap_or_default();

        let text = format!(
            "{} *{}* — `{}`{}\n{}",
            icon, status_text, progress.step_name, duration, bar
        );

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text,
            thread_id: Some(thread_id.to_string()),
            blocks: None,
        };

        self.send_message(&msg).await
    }

    async fn send_notification(
        &self,
        channel_id: &str,
        thread_id: Option<&str>,
        notification: &WorkflowNotification,
    ) -> Result<String> {
        let (icon, title) = if notification.success {
            ("✅", "Workflow Completed")
        } else {
            ("❌", "Workflow Failed")
        };

        let error_line = notification
            .error
            .as_ref()
            .map(|e| format!("\nError: `{}`", e))
            .unwrap_or_default();

        let text = format!(
            "{} *{}*\n\nWorkflow: `{}`\nSteps: {}/{}\nDuration: {}ms{}",
            icon,
            title,
            notification.workflow_id,
            notification.steps_completed,
            notification.total_steps,
            notification.duration_ms,
            error_line,
        );

        let blocks = serde_json::json!([
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": text
                }
            }
        ]);

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text: format!(
                "{} {} — {}",
                icon, title, notification.workflow_id
            ),
            thread_id: thread_id.map(String::from),
            blocks: Some(blocks),
        };

        self.send_message(&msg).await
    }

    async fn start_thread(
        &self,
        channel_id: &str,
        execution_id: &str,
        workflow_id: &str,
        total_steps: usize,
        shadow: bool,
    ) -> Result<String> {
        let mode = if shadow { "shadow" } else { "live" };
        let text = format!(
            "🚀 *Workflow `{}` started* ({} mode, {} steps)\nExecution: `{}`",
            workflow_id, mode, total_steps, execution_id
        );

        let blocks = serde_json::json!([
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": text
                }
            }
        ]);

        let msg = OutgoingMessage {
            channel_id: channel_id.to_string(),
            text: format!("Workflow {} started ({})", workflow_id, mode),
            thread_id: None,
            blocks: Some(blocks),
        };

        // The returned message timestamp becomes the thread ID
        self.send_message(&msg).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_slack_config_fields() {
        let config = SlackConfig {
            bot_token: "xoxb-test".into(),
            signing_secret: Some("secret".into()),
            default_channel: Some("#general".into()),
        };
        assert_eq!(config.bot_token, "xoxb-test");
    }

    #[test]
    fn test_progress_bar_empty() {
        let bar = SlackBot::progress_bar(0, 5);
        assert!(bar.contains("░░░░░░░░░░"));
        assert!(bar.contains("0/5"));
    }

    #[test]
    fn test_progress_bar_half() {
        let bar = SlackBot::progress_bar(5, 10);
        assert!(bar.contains("█████"));
        assert!(bar.contains("5/10"));
    }

    #[test]
    fn test_progress_bar_full() {
        let bar = SlackBot::progress_bar(10, 10);
        assert!(bar.contains("██████████"));
        assert!(bar.contains("10/10"));
    }

    #[test]
    fn test_progress_bar_zero_total() {
        let bar = SlackBot::progress_bar(0, 0);
        assert!(bar.contains("0/0"));
    }
}