xbp 10.17.2

XBP is a zero-config build pack that can also interact with proxies, kafka, sockets, synthetic monitors.
Documentation 
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

use clap::error::ErrorKind as ClapErrorKind;
use colored::Colorize;
use thiserror::Error;

/// Unified CLI error type to keep propagation consistent across handlers.
#[derive(Debug, Error)]
pub enum CliError {
    #[error("{0}")]
    Message(String),
    #[error(transparent)]
    Anyhow(#[from] anyhow::Error),
}

pub type CliResult<T> = Result<T, CliError>;

#[derive(Debug, Clone, Copy)]
pub enum ErrorKindTag {
    Parse,
    Validation,
    Dependency,
    Permission,
    Operation,
    Config,
    Runtime,
}

impl ErrorKindTag {
    fn label(self) -> &'static str {
        match self {
            ErrorKindTag::Parse => "PARSE",
            ErrorKindTag::Validation => "VALIDATION",
            ErrorKindTag::Dependency => "DEPENDENCY",
            ErrorKindTag::Permission => "PERMISSION",
            ErrorKindTag::Operation => "OPERATION",
            ErrorKindTag::Config => "CONFIG",
            ErrorKindTag::Runtime => "RUNTIME",
        }
    }
}

/// Centralized CLI error factory used across handlers for consistent UX.
pub struct ErrorFactory;

impl ErrorFactory {
    pub fn parse(message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Parse, "cli", message, hint, None)
    }

    pub fn validation(component: &str, message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Validation, component, message, hint, None)
    }

    pub fn dependency(component: &str, message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Dependency, component, message, hint, None)
    }

    pub fn permission(component: &str, message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Permission, component, message, hint, None)
    }

    pub fn config(component: &str, message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Config, component, message, hint, None)
    }

    pub fn operation(
        component: &str,
        action: &str,
        source: impl Into<String>,
        hint: Option<&str>,
    ) -> CliError {
        let message = format!("{} failed", action);
        Self::build(
            ErrorKindTag::Operation,
            component,
            message,
            hint,
            Some(source.into()),
        )
    }

    pub fn runtime(component: &str, message: impl Into<String>, hint: Option<&str>) -> CliError {
        Self::build(ErrorKindTag::Runtime, component, message, hint, None)
    }

    pub fn clap_parse(err: clap::Error) -> CliError {
        let hint = Self::clap_hint(err.kind());
        Self::parse(err.to_string(), hint)
    }

    fn clap_hint(kind: ClapErrorKind) -> Option<&'static str> {
        match kind {
            ClapErrorKind::InvalidSubcommand => {
                Some("Run `xbp --help` to list available commands.")
            }
            ClapErrorKind::UnknownArgument | ClapErrorKind::InvalidValue => {
                Some("Use `-h` with your subcommand to see supported options.")
            }
            ClapErrorKind::MissingRequiredArgument => {
                Some("Check the usage block above and provide required arguments.")
            }
            _ => None,
        }
    }

    fn build(
        kind: ErrorKindTag,
        component: &str,
        message: impl Into<String>,
        hint: Option<&str>,
        details: Option<String>,
    ) -> CliError {
        let header = format!("[{}] {}", kind.label(), component)
            .bright_red()
            .bold();
        let mut lines = vec![header.to_string(), format!("  {}", message.into())];
        if let Some(details) = details {
            lines.push(format!("  {} {}", "Details:".bright_black(), details));
        }
        if let Some(hint) = hint {
            lines.push(format!("  {} {}", "Hint:".bright_yellow().bold(), hint));
        }
        CliError::Message(lines.join("\n"))
    }
}

impl From<String> for CliError {
    fn from(value: String) -> Self {
        CliError::Message(value)
    }
}

impl From<&str> for CliError {
    fn from(value: &str) -> Self {
        CliError::Message(value.to_string())
    }
}