atman_runtime/

trust.rs

use crate::tool::ApprovalLevel;

/// Trust mode controls how aggressively tools auto-approve.
#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Default,
    serde::Serialize,
    serde::Deserialize,
    documented::DocumentedVariants,
)]
#[serde(rename_all = "lowercase")]
pub enum TrustMode {
    /// Auto-approve only Tier::Zero (read-only) tools; everything else needs manual approval.
    Calm,
    #[default]
    /// Auto-approve Tier::Zero and Tier::One; Tier::Two+ needs approval.
    Steady,
    /// Auto-approve up to Tier::Two; Tier::Three+ needs approval.
    Eager,
    /// Auto-approve everything including dangerous operations.
    Reckless,
}

impl TrustMode {
    pub fn auto_ceiling(self) -> ApprovalLevel {
        match self {
            Self::Calm => ApprovalLevel::Auto,
            Self::Steady => ApprovalLevel::Approve,
            Self::Eager | Self::Reckless => ApprovalLevel::Dangerous,
        }
    }

    pub fn sandbox_enabled(self) -> bool {
        !matches!(self, Self::Reckless)
    }

    pub fn level(self) -> u8 {
        match self {
            Self::Calm => 1,
            Self::Steady => 2,
            Self::Eager => 3,
            Self::Reckless => 4,
        }
    }

    pub fn needs_warning(self) -> bool {
        matches!(self, Self::Eager | Self::Reckless)
    }

    pub fn warning(self, display: &ModeDisplay) -> Option<String> {
        match self {
            Self::Eager => Some(format!(
                "⚠ {} mode: sandbox guards bash/fs. Workspace-internal ops auto-approved. \
                 Network is unrestricted. Operations touching outside the workspace follow \
                 the outside switch (deny / approve / allow).",
                display.name
            )),
            Self::Reckless => Some(format!(
                "⚠ {} mode: sandbox is off. The agent can read/write outside the workspace, \
                 run arbitrary commands, and access the network — all without confirmation. \
                 Make sure you understand the risk.\n\n\
                 Recommended only for one-off / sandbox projects, not for production repos \
                 or directories with sensitive data.",
                display.name
            )),
            _ => None,
        }
    }

    pub fn all() -> [TrustMode; 4] {
        [Self::Calm, Self::Steady, Self::Eager, Self::Reckless]
    }
}

impl std::str::FromStr for TrustMode {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "calm" | "1" => Ok(Self::Calm),
            "steady" | "2" | "default" => Ok(Self::Steady),
            "eager" | "3" => Ok(Self::Eager),
            "reckless" | "yolo" | "4" => Ok(Self::Reckless),
            other => Err(format!("unknown trust mode `{other}`")),
        }
    }
}

/// What to do when a tool outside the flow's declared tool list is invoked (Eager mode only).
#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Default,
    serde::Serialize,
    serde::Deserialize,
    documented::DocumentedVariants,
)]
#[serde(rename_all = "lowercase")]
pub enum OutsideBehavior {
    /// Deny any tool not in the declared list.
    Deny,
    #[default]
    /// Prompt the user to approve undeclared tools.
    Approve,
    /// Allow all tools without prompting.
    Allow,
}

impl OutsideBehavior {
    pub fn all() -> [Self; 3] {
        [Self::Deny, Self::Approve, Self::Allow]
    }

    pub fn next(self) -> Self {
        match self {
            Self::Deny => Self::Approve,
            Self::Approve => Self::Allow,
            Self::Allow => Self::Deny,
        }
    }
}

impl std::str::FromStr for OutsideBehavior {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "deny" => Ok(Self::Deny),
            "approve" | "confirm" => Ok(Self::Approve),
            "allow" | "auto" => Ok(Self::Allow),
            other => Err(format!("unknown outside behavior `{other}`")),
        }
    }
}

/// Display theme for trust mode labels in the TUI.
#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    serde::Serialize,
    serde::Deserialize,
    Default,
    documented::DocumentedVariants,
)]
#[serde(rename_all = "lowercase")]
pub enum Theme {
    #[default]
    /// Standard English labels.
    Default,
    /// Wuxia (martial arts) themed labels.
    Wuxia,
    /// Animal-themed labels.
    Animal,
    /// Weather-themed labels.
    Weather,
    /// Drink-themed labels.
    Drink,
}

impl std::str::FromStr for Theme {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "default" => Ok(Self::Default),
            "wuxia" => Ok(Self::Wuxia),
            "animal" => Ok(Self::Animal),
            "weather" => Ok(Self::Weather),
            "drink" => Ok(Self::Drink),
            other => Err(format!("unknown theme `{other}`")),
        }
    }
}

impl std::fmt::Display for Theme {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Default => write!(f, "default"),
            Self::Wuxia => write!(f, "wuxia"),
            Self::Animal => write!(f, "animal"),
            Self::Weather => write!(f, "weather"),
            Self::Drink => write!(f, "drink"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ModeColor {
    Cyan,
    Green,
    Yellow,
    Red,
    Orange,
}

#[derive(Debug, Clone)]
pub struct ModeDisplay {
    pub name: &'static str,
    pub emoji: &'static str,
    pub color: ModeColor,
    pub description: &'static str,
}

#[derive(Debug, Clone)]
pub struct OutsideDisplay {
    pub name: &'static str,
    pub emoji: &'static str,
    pub color: ModeColor,
}

impl Theme {
    pub fn display(&self, mode: TrustMode) -> ModeDisplay {
        match (self, mode) {
            (Theme::Default, TrustMode::Calm) => ModeDisplay {
                name: "calm",
                emoji: "🌙",
                color: ModeColor::Cyan,
                description: "confirm every step",
            },
            (Theme::Default, TrustMode::Steady) => ModeDisplay {
                name: "steady",
                emoji: "✓",
                color: ModeColor::Green,
                description: "free inside workspace, confirm outside",
            },
            (Theme::Default, TrustMode::Eager) => ModeDisplay {
                name: "eager",
                emoji: "⚡",
                color: ModeColor::Yellow,
                description: "auto inside, outside switch controls",
            },
            (Theme::Default, TrustMode::Reckless) => ModeDisplay {
                name: "reckless",
                emoji: "🔥",
                color: ModeColor::Red,
                description: "all off, you decide",
            },

            (Theme::Wuxia, TrustMode::Calm) => ModeDisplay {
                name: "守拙",
                emoji: "🧘",
                color: ModeColor::Cyan,
                description: "大巧若拙，步步为营",
            },
            (Theme::Wuxia, TrustMode::Steady) => ModeDisplay {
                name: "行云",
                emoji: "☁️",
                color: ModeColor::Green,
                description: "行云流水，任意所至",
            },
            (Theme::Wuxia, TrustMode::Eager) => ModeDisplay {
                name: "破竹",
                emoji: "🎋",
                color: ModeColor::Yellow,
                description: "势如破竹，迎刃而解",
            },
            (Theme::Wuxia, TrustMode::Reckless) => ModeDisplay {
                name: "逍遥",
                emoji: "🕊️",
                color: ModeColor::Red,
                description: "逍遥御风，无招胜有招",
            },

            (Theme::Animal, TrustMode::Calm) => ModeDisplay {
                name: "hedgehog",
                emoji: "🦔",
                color: ModeColor::Cyan,
                description: "curls up, asks about everything",
            },
            (Theme::Animal, TrustMode::Steady) => ModeDisplay {
                name: "cat",
                emoji: "🐱",
                color: ModeColor::Green,
                description: "roams its territory, wary of strangers",
            },
            (Theme::Animal, TrustMode::Eager) => ModeDisplay {
                name: "dog",
                emoji: "🐶",
                color: ModeColor::Yellow,
                description: "fence guards, charges ahead",
            },
            (Theme::Animal, TrustMode::Reckless) => ModeDisplay {
                name: "honey-badger",
                emoji: "🦡",
                color: ModeColor::Red,
                description: "doesn't give a damn",
            },

            (Theme::Weather, TrustMode::Calm) => ModeDisplay {
                name: "drizzle",
                emoji: "🌧",
                color: ModeColor::Cyan,
                description: "light rain, step carefully",
            },
            (Theme::Weather, TrustMode::Steady) => ModeDisplay {
                name: "clear",
                emoji: "☀️",
                color: ModeColor::Green,
                description: "clear sky, normal pace",
            },
            (Theme::Weather, TrustMode::Eager) => ModeDisplay {
                name: "storm",
                emoji: "⛈",
                color: ModeColor::Yellow,
                description: "storm, coat on, push forward",
            },
            (Theme::Weather, TrustMode::Reckless) => ModeDisplay {
                name: "tornado",
                emoji: "🌪",
                color: ModeColor::Red,
                description: "tornado, hold nothing back",
            },

            (Theme::Drink, TrustMode::Calm) => ModeDisplay {
                name: "water",
                emoji: "💧",
                color: ModeColor::Cyan,
                description: "plain and safe",
            },
            (Theme::Drink, TrustMode::Steady) => ModeDisplay {
                name: "coffee",
                emoji: "☕",
                color: ModeColor::Green,
                description: "normal kick",
            },
            (Theme::Drink, TrustMode::Eager) => ModeDisplay {
                name: "espresso",
                emoji: "☕",
                color: ModeColor::Yellow,
                description: "double shot, go fast",
            },
            (Theme::Drink, TrustMode::Reckless) => ModeDisplay {
                name: "bleach",
                emoji: "🧪",
                color: ModeColor::Red,
                description: "drink it and it's gone",
            },
        }
    }

    pub fn outside_display(&self, outside: OutsideBehavior) -> OutsideDisplay {
        match (self, outside) {
            (Theme::Default, OutsideBehavior::Deny) => OutsideDisplay {
                name: "deny",
                emoji: "🔒",
                color: ModeColor::Orange,
            },
            (Theme::Default, OutsideBehavior::Approve) => OutsideDisplay {
                name: "approve",
                emoji: "⚠️",
                color: ModeColor::Yellow,
            },
            (Theme::Default, OutsideBehavior::Allow) => OutsideDisplay {
                name: "allow",
                emoji: "✅",
                color: ModeColor::Green,
            },

            (Theme::Wuxia, OutsideBehavior::Deny) => OutsideDisplay {
                name: "画地为牢",
                emoji: "⛩️",
                color: ModeColor::Orange,
            },
            (Theme::Wuxia, OutsideBehavior::Approve) => OutsideDisplay {
                name: "请示",
                emoji: "📜",
                color: ModeColor::Yellow,
            },
            (Theme::Wuxia, OutsideBehavior::Allow) => OutsideDisplay {
                name: "放行",
                emoji: "🎋",
                color: ModeColor::Green,
            },

            (Theme::Animal, OutsideBehavior::Deny) => OutsideDisplay {
                name: "turtle",
                emoji: "🐢",
                color: ModeColor::Orange,
            },
            (Theme::Animal, OutsideBehavior::Approve) => OutsideDisplay {
                name: "owl",
                emoji: "🦉",
                color: ModeColor::Yellow,
            },
            (Theme::Animal, OutsideBehavior::Allow) => OutsideDisplay {
                name: "bird",
                emoji: "🐦",
                color: ModeColor::Green,
            },

            (Theme::Weather, OutsideBehavior::Deny) => OutsideDisplay {
                name: "fog",
                emoji: "🌫",
                color: ModeColor::Orange,
            },
            (Theme::Weather, OutsideBehavior::Approve) => OutsideDisplay {
                name: "cloud",
                emoji: "☁️",
                color: ModeColor::Yellow,
            },
            (Theme::Weather, OutsideBehavior::Allow) => OutsideDisplay {
                name: "clear",
                emoji: "☀️",
                color: ModeColor::Green,
            },

            (Theme::Drink, OutsideBehavior::Deny) => OutsideDisplay {
                name: "lock-in",
                emoji: "🍺",
                color: ModeColor::Orange,
            },
            (Theme::Drink, OutsideBehavior::Approve) => OutsideDisplay {
                name: "card",
                emoji: "💳",
                color: ModeColor::Yellow,
            },
            (Theme::Drink, OutsideBehavior::Allow) => OutsideDisplay {
                name: "open-tab",
                emoji: "🧾",
                color: ModeColor::Green,
            },
        }
    }
}

/// User-configurable trust settings: mode, display theme, and outside-tool behavior.
#[derive(
    Debug,
    Clone,
    Default,
    serde::Serialize,
    serde::Deserialize,
    documented::Documented,
    documented::DocumentedFields,
)]
pub struct TrustConfig {
    /// How aggressively tools are auto-approved.
    #[serde(default)]
    pub mode: TrustMode,
    /// Display theme for trust mode labels.
    #[serde(default)]
    pub theme: Theme,
    /// Behavior for tools outside the declared list (Eager mode only).
    #[serde(default)]
    pub outside: OutsideBehavior,
}

impl TrustConfig {
    pub fn display(&self) -> ModeDisplay {
        self.theme.display(self.mode)
    }

    pub fn outside_display(&self) -> OutsideDisplay {
        self.theme.outside_display(self.outside)
    }
}

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

    #[test]
    fn auto_ceiling_maps_correctly() {
        assert_eq!(TrustMode::Calm.auto_ceiling(), ApprovalLevel::Auto);
        assert_eq!(TrustMode::Steady.auto_ceiling(), ApprovalLevel::Approve);
        assert_eq!(TrustMode::Eager.auto_ceiling(), ApprovalLevel::Dangerous);
        assert_eq!(TrustMode::Reckless.auto_ceiling(), ApprovalLevel::Dangerous);
    }

    #[test]
    fn sandbox_disabled_only_for_reckless() {
        assert!(TrustMode::Calm.sandbox_enabled());
        assert!(TrustMode::Steady.sandbox_enabled());
        assert!(TrustMode::Eager.sandbox_enabled());
        assert!(!TrustMode::Reckless.sandbox_enabled());
    }

    #[test]
    fn needs_warning_for_eager_and_reckless() {
        assert!(!TrustMode::Calm.needs_warning());
        assert!(!TrustMode::Steady.needs_warning());
        assert!(TrustMode::Eager.needs_warning());
        assert!(TrustMode::Reckless.needs_warning());
    }

    #[test]
    fn warning_text_includes_mode_name() {
        let cfg = TrustConfig {
            mode: TrustMode::Eager,
            theme: Theme::Default,
            outside: OutsideBehavior::default(),
        };
        let display = cfg.display();
        let warning = TrustMode::Eager.warning(&display).unwrap();
        assert!(warning.contains("eager"));

        let cfg2 = TrustConfig {
            mode: TrustMode::Reckless,
            theme: Theme::Animal,
            outside: OutsideBehavior::default(),
        };
        let display2 = cfg2.display();
        let warning2 = TrustMode::Reckless.warning(&display2).unwrap();
        assert!(warning2.contains("honey-badger"));
    }

    #[test]
    fn all_themes_produce_displays() {
        let themes = [
            Theme::Default,
            Theme::Wuxia,
            Theme::Animal,
            Theme::Weather,
            Theme::Drink,
        ];
        for theme in &themes {
            for mode in &TrustMode::all() {
                let d = theme.display(*mode);
                assert!(!d.name.is_empty());
                assert!(!d.emoji.is_empty());
                assert!(!d.description.is_empty());
            }
            for outside in &OutsideBehavior::all() {
                let d = theme.outside_display(*outside);
                assert!(!d.name.is_empty());
                assert!(!d.emoji.is_empty());
            }
        }
    }

    #[test]
    fn mode_from_str_parses_all_variants() {
        assert_eq!("calm".parse::<TrustMode>().unwrap(), TrustMode::Calm);
        assert_eq!("steady".parse::<TrustMode>().unwrap(), TrustMode::Steady);
        assert_eq!("eager".parse::<TrustMode>().unwrap(), TrustMode::Eager);
        assert_eq!(
            "reckless".parse::<TrustMode>().unwrap(),
            TrustMode::Reckless
        );
        assert_eq!("yolo".parse::<TrustMode>().unwrap(), TrustMode::Reckless);
        assert_eq!("1".parse::<TrustMode>().unwrap(), TrustMode::Calm);
        assert_eq!("4".parse::<TrustMode>().unwrap(), TrustMode::Reckless);
        assert!("unknown".parse::<TrustMode>().is_err());
    }

    #[test]
    fn outside_from_str_parses_all_variants() {
        assert_eq!(
            "deny".parse::<OutsideBehavior>().unwrap(),
            OutsideBehavior::Deny
        );
        assert_eq!(
            "approve".parse::<OutsideBehavior>().unwrap(),
            OutsideBehavior::Approve
        );
        assert_eq!(
            "allow".parse::<OutsideBehavior>().unwrap(),
            OutsideBehavior::Allow
        );
        assert_eq!(
            "auto".parse::<OutsideBehavior>().unwrap(),
            OutsideBehavior::Allow
        );
        assert!("unknown".parse::<OutsideBehavior>().is_err());
    }

    #[test]
    fn outside_next_cycles() {
        assert_eq!(OutsideBehavior::Deny.next(), OutsideBehavior::Approve);
        assert_eq!(OutsideBehavior::Approve.next(), OutsideBehavior::Allow);
        assert_eq!(OutsideBehavior::Allow.next(), OutsideBehavior::Deny);
    }

    #[test]
    fn theme_from_str_parses_all_variants() {
        assert_eq!("default".parse::<Theme>().unwrap(), Theme::Default);
        assert_eq!("wuxia".parse::<Theme>().unwrap(), Theme::Wuxia);
        assert_eq!("animal".parse::<Theme>().unwrap(), Theme::Animal);
        assert_eq!("weather".parse::<Theme>().unwrap(), Theme::Weather);
        assert_eq!("drink".parse::<Theme>().unwrap(), Theme::Drink);
        assert!("unknown".parse::<Theme>().is_err());
    }

    #[test]
    fn theme_display_roundtrip() {
        for theme in &[
            Theme::Default,
            Theme::Wuxia,
            Theme::Animal,
            Theme::Weather,
            Theme::Drink,
        ] {
            let s = theme.to_string();
            let back: Theme = s.parse().unwrap();
            assert_eq!(*theme, back);
        }
    }

    #[test]
    fn default_config_is_steady_approve() {
        let cfg = TrustConfig::default();
        assert_eq!(cfg.mode, TrustMode::Steady);
        assert_eq!(cfg.theme, Theme::Default);
        assert_eq!(cfg.outside, OutsideBehavior::Approve);
    }

    #[test]
    fn wuxia_descriptions_are_chinese() {
        let d = Theme::Wuxia.display(TrustMode::Calm);
        assert!(d.description.contains("拙"));
        let d = Theme::Wuxia.display(TrustMode::Steady);
        assert!(d.description.contains("行云"));
    }

    #[test]
    fn non_wuxia_descriptions_are_english() {
        for mode in &TrustMode::all() {
            let d = Theme::Default.display(*mode);
            assert!(
                d.description.is_ascii(),
                "default theme should be ASCII: {}",
                d.description
            );
            let d = Theme::Animal.display(*mode);
            assert!(
                d.description.is_ascii(),
                "animal theme should be ASCII: {}",
                d.description
            );
        }
    }

    #[test]
    fn four_levels_ordered() {
        assert_eq!(TrustMode::Calm.level(), 1);
        assert_eq!(TrustMode::Steady.level(), 2);
        assert_eq!(TrustMode::Eager.level(), 3);
        assert_eq!(TrustMode::Reckless.level(), 4);
    }
}