tryaudex_core/

approval.rs

use serde::{Deserialize, Serialize};

use crate::error::{AvError, Result};
use crate::policy::{ActionPattern, ScopedPolicy};

/// Approval workflow configuration in `[approval]` config section.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ApprovalConfig {
    /// Action patterns that require approval (e.g. ["iam:*", "billing:*", "organizations:*"])
    #[serde(default)]
    pub require_for: Vec<String>,
    /// Slack webhook URL to send approval requests to
    pub slack_webhook: Option<String>,
    /// Whether to auto-deny without prompting (for CI environments)
    pub auto_deny: Option<bool>,
}

/// Result of an approval check.
#[derive(Debug)]
pub struct ApprovalRequired {
    /// The actions that triggered the approval requirement
    pub triggered_actions: Vec<String>,
    /// The rules that were matched
    pub matched_rules: Vec<String>,
}

/// Check if a policy contains actions that require approval.
/// Returns None if no approval needed, Some with details if approval is required.
pub fn check(policy: &ScopedPolicy, config: &ApprovalConfig) -> Option<ApprovalRequired> {
    if config.require_for.is_empty() {
        return None;
    }

    let approval_patterns: Vec<ActionPattern> = config
        .require_for
        .iter()
        .filter_map(|p| ActionPattern::parse(p).ok())
        .collect();

    let mut triggered = Vec::new();
    let mut matched = Vec::new();

    for action in &policy.actions {
        for pattern in &approval_patterns {
            if pattern.matches(action) {
                triggered.push(action.to_iam_action());
                matched.push(pattern.to_iam_action());
            }
        }
    }

    if triggered.is_empty() {
        None
    } else {
        triggered.sort();
        triggered.dedup();
        matched.sort();
        matched.dedup();
        Some(ApprovalRequired {
            triggered_actions: triggered,
            matched_rules: matched,
        })
    }
}

/// Send an approval request to Slack and return the message text.
pub async fn notify_slack(
    webhook_url: &str,
    session_id: &str,
    actions: &[String],
    command: &[String],
) -> Result<()> {
    let action_list = actions
        .iter()
        .map(|a| format!("  • `{}`", a))
        .collect::<Vec<_>>()
        .join("\n");

    let payload = serde_json::json!({
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": "🔐 Audex Approval Required"
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": format!(
                        "*Session:* `{}`\n*Command:* `{}`\n\n*High-risk actions requested:*\n{}",
                        &session_id[..8],
                        command.join(" "),
                        action_list
                    )
                }
            },
            {
                "type": "context",
                "elements": [{
                    "type": "mrkdwn",
                    "text": "Approve by running: `audex approve {}`"
                }]
            }
        ]
    });

    let client = reqwest::Client::new();
    let resp = client
        .post(webhook_url)
        .json(&payload)
        .send()
        .await
        .map_err(|e| {
            AvError::InvalidPolicy(format!("Failed to send Slack approval request: {}", e))
        })?;

    if !resp.status().is_success() {
        return Err(AvError::InvalidPolicy(format!(
            "Slack webhook returned {}",
            resp.status()
        )));
    }

    Ok(())
}

/// Prompt for interactive approval on the CLI. Returns true if approved.
/// In non-TTY environments (CI, piped stdin), always denies to prevent
/// unattended execution of high-risk actions.
pub fn prompt_cli(required: &ApprovalRequired) -> bool {
    use std::io::{IsTerminal, Write};

    eprintln!("\n⚠  APPROVAL REQUIRED");
    eprintln!("The following high-risk actions need approval:\n");
    for action in &required.triggered_actions {
        eprintln!("  • {}", action);
    }
    eprintln!(
        "\nMatched approval rules: {}",
        required.matched_rules.join(", ")
    );

    if !std::io::stdin().is_terminal() {
        eprintln!("\nNon-interactive environment detected — denying by default.");
        eprintln!("Set [approval] auto_deny = false or use a TTY for interactive approval.");
        return false;
    }

    eprint!("\nProceed? [y/N] ");
    let _ = std::io::stderr().flush();

    let mut input = String::new();
    if std::io::stdin().read_line(&mut input).is_ok() {
        let trimmed = input.trim().to_lowercase();
        trimmed == "y" || trimmed == "yes"
    } else {
        false
    }
}

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

    fn make_policy(actions: &[&str]) -> ScopedPolicy {
        ScopedPolicy::from_allow_str(&actions.join(",")).unwrap()
    }

    fn make_config(patterns: &[&str]) -> ApprovalConfig {
        ApprovalConfig {
            require_for: patterns.iter().map(|s| s.to_string()).collect(),
            slack_webhook: None,
            auto_deny: None,
        }
    }

    #[test]
    fn test_no_approval_when_empty_config() {
        let policy = make_policy(&["s3:GetObject", "s3:PutObject"]);
        let config = ApprovalConfig::default();
        assert!(check(&policy, &config).is_none());
    }

    #[test]
    fn test_no_approval_when_no_match() {
        let policy = make_policy(&["s3:GetObject", "s3:PutObject"]);
        let config = make_config(&["iam:*", "billing:*"]);
        assert!(check(&policy, &config).is_none());
    }

    #[test]
    fn test_approval_required_exact_match() {
        let policy = make_policy(&["iam:CreateRole", "s3:GetObject"]);
        let config = make_config(&["iam:*"]);
        let result = check(&policy, &config);
        assert!(result.is_some());
        let req = result.unwrap();
        assert!(req
            .triggered_actions
            .contains(&"iam:CreateRole".to_string()));
        assert_eq!(req.triggered_actions.len(), 1);
    }

    #[test]
    fn test_approval_required_multiple_matches() {
        let policy = make_policy(&["iam:CreateRole", "iam:DeleteRole", "s3:GetObject"]);
        let config = make_config(&["iam:*"]);
        let req = check(&policy, &config).unwrap();
        assert_eq!(req.triggered_actions.len(), 2);
        assert!(req
            .triggered_actions
            .contains(&"iam:CreateRole".to_string()));
        assert!(req
            .triggered_actions
            .contains(&"iam:DeleteRole".to_string()));
    }

    #[test]
    fn test_approval_multiple_rules() {
        let policy = make_policy(&["iam:CreateRole", "organizations:ListAccounts"]);
        let config = make_config(&["iam:*", "organizations:*"]);
        let req = check(&policy, &config).unwrap();
        assert_eq!(req.triggered_actions.len(), 2);
        assert_eq!(req.matched_rules.len(), 2);
    }

    #[test]
    fn test_approval_deduplicates() {
        let policy = make_policy(&["iam:CreateRole"]);
        let config = make_config(&["iam:*", "iam:CreateRole"]);
        let req = check(&policy, &config).unwrap();
        // triggered_actions should be deduped
        assert_eq!(req.triggered_actions.len(), 1);
    }
}