zeph 0.21.1

Lightweight AI agent with hybrid inference, skills-first architecture, and multi-channel I/O
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// SPDX-FileCopyrightText: 2026 Andrei G <bug-ops>
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Startup mutual-exclusion checks for CLI mode flags.

use zeph_core::config::Config;

use crate::cli::Cli;

/// Validate that the selected mode flags are mutually compatible.
///
/// Called once at startup before any channel or subsystem is constructed.
///
/// # Errors
///
/// Returns an error string if two incompatible flags are active simultaneously.
pub(crate) fn validate_mode_compatibility(cli: &Cli, config: &Config) -> anyhow::Result<()> {
    #[cfg(feature = "tui")]
    if cli.json && cli.tui {
        anyhow::bail!("--json and --tui are mutually exclusive (both claim stdout)");
    }

    #[cfg(feature = "acp")]
    if cli.json && cli.acp {
        anyhow::bail!(
            "--json and --acp are mutually exclusive (both claim stdout; ACP owns JSON-RPC framing)"
        );
    }

    if cli.json
        && config
            .telegram
            .as_ref()
            .and_then(|t| t.token.as_ref())
            .is_some()
    {
        anyhow::bail!(
            "--json cannot be used while a Telegram token is configured; \
             JSON events are stdout-only and Telegram is a separate transport"
        );
    }

    #[cfg(feature = "discord")]
    if cli.json
        && config
            .discord
            .as_ref()
            .and_then(|d| d.token.as_ref())
            .is_some()
    {
        anyhow::bail!("--json cannot be used alongside a configured Discord channel");
    }

    #[cfg(feature = "slack")]
    if cli.json
        && config
            .slack
            .as_ref()
            .and_then(|s| s.bot_token.as_ref())
            .is_some()
    {
        anyhow::bail!("--json cannot be used alongside a configured Slack channel");
    }

    Ok(())
}

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

    fn cli_json() -> Cli {
        Cli {
            json: true,
            ..Default::default()
        }
    }

    #[test]
    fn json_with_telegram_token_is_rejected() {
        use zeph_config::{ChannelSkillsConfig, TelegramConfig};
        let cli = cli_json();
        let cfg = Config {
            telegram: Some(TelegramConfig {
                token: Some("tok".into()),
                allowed_users: vec![],
                skills: ChannelSkillsConfig::default(),
                stream_interval_ms: 3000,
                guest_mode: false,
                bot_to_bot: false,
                allowed_bots: vec![],
                max_bot_chain_depth: 3,
            }),
            ..Default::default()
        };
        assert!(validate_mode_compatibility(&cli, &cfg).is_err());
    }

    #[test]
    fn json_without_conflicts_is_ok() {
        let cli = cli_json();
        let cfg = Config::default();
        assert!(validate_mode_compatibility(&cli, &cfg).is_ok());
    }

    #[test]
    #[cfg(feature = "tui")]
    fn json_with_tui_is_rejected() {
        let cli = Cli {
            json: true,
            tui: true,
            ..Default::default()
        };
        let cfg = Config::default();
        assert!(validate_mode_compatibility(&cli, &cfg).is_err());
    }

    #[test]
    #[cfg(feature = "discord")]
    fn json_with_discord_token_is_rejected() {
        use zeph_config::{ChannelSkillsConfig, DiscordConfig};
        let cli = cli_json();
        let cfg = Config {
            discord: Some(DiscordConfig {
                token: Some("discord-tok".into()),
                application_id: None,
                allowed_user_ids: vec![],
                allowed_role_ids: vec![],
                allowed_channel_ids: vec![],
                skills: ChannelSkillsConfig::default(),
            }),
            ..Default::default()
        };
        assert!(validate_mode_compatibility(&cli, &cfg).is_err());
    }

    #[test]
    #[cfg(feature = "slack")]
    fn json_with_slack_token_is_rejected() {
        use zeph_config::{ChannelSkillsConfig, SlackConfig};
        let cli = cli_json();
        let cfg = Config {
            slack: Some(SlackConfig {
                bot_token: Some("xoxb-slack".into()),
                signing_secret: None,
                webhook_host: "0.0.0.0".into(),
                port: 3000,
                allowed_user_ids: vec![],
                allowed_channel_ids: vec![],
                skills: ChannelSkillsConfig::default(),
            }),
            ..Default::default()
        };
        assert!(validate_mode_compatibility(&cli, &cfg).is_err());
    }
}