feat(jetsocat): add warning field to doctor diagnostic output

Adds support for surfacing warnings in the doctor tool's diagnostic
output, allowing external tools to distinguish between complete success,
success with warnings, and failure.

The diagnostic JSON output now includes an optional "warning" field, and
the human-readable output displays a warning emoji (⚠️) instead of a
success checkmark (✅) when warnings are present.

This enables better integration with external monitoring and diagnostic
tools that need to detect and report warning conditions even when the
overall diagnostic succeeds.

Author: thenextman

jetsocat/src/doctor/macros.rs

@@ -18,6 +18,7 @@ macro_rules! diagnostic {
         let diagnostic = Diagnostic {
             name: diagnostic_name.to_owned(),
             success: result.is_ok(),
+            warning: ctx.warning,
             output: (!output.is_empty()).then_some(output.trim_end().to_owned()),
             error: result.as_ref().err().map(|e| format!("{:?}", e)),
             help: ctx.help,

jetsocat/src/doctor/mod.rs

@@ -26,6 +26,7 @@ pub struct Args {
 pub struct Diagnostic {
     pub name: String,
     pub success: bool,
+    pub warning: Option<String>,
     pub output: Option<String>,
     pub error: Option<String>,
     pub help: Option<String>,
@@ -69,6 +70,10 @@ impl Diagnostic {
         object.insert("name".to_owned(), JsonValue::String(self.name));
         object.insert("success".to_owned(), JsonValue::Boolean(self.success));
 
+        if let Some(warning) = self.warning {
+            object.insert("warning".to_owned(), JsonValue::String(warning));
+        }
+
         if let Some(output) = self.output {
             object.insert("output".to_owned(), JsonValue::String(output));
         }
@@ -119,11 +124,19 @@ impl Diagnostic {
                 write!(f, "=> {} ", self.0.name)?;
 
                 if self.0.success {
-                    write!(f, "OK ✅")?;
+                    if self.0.warning.is_some() {
+                        write!(f, "OK ⚠️")?;
+                    } else {
+                        write!(f, "OK ✅")?;
+                    }
                 } else {
                     write!(f, "FAILED ❌")?;
                 }
 
+                if let Some(warning) = self.0.warning.as_deref() {
+                    write!(f, "\n\n### Warning\n{}", capitalize(warning))?;
+                }
+
                 if let Some(output) = self.0.output.as_deref() {
                     write!(f, "\n\n### Output\n{output}")?;
                 }
@@ -180,6 +193,7 @@ impl Link {
 #[derive(Default)]
 struct DiagnosticCtx {
     help: Option<String>,
+    warning: Option<String>,
     links: Vec<Link>,
 }
 
@@ -188,6 +202,10 @@ impl DiagnosticCtx {
         self.help = Some(message.into());
     }
 
+    fn attach_warning(&mut self, message: impl Into<String>) {
+        self.warning = Some(message.into());
+    }
+
     fn attach_link(&mut self, name: impl Into<String>, href: impl Into<String>, description: impl Into<String>) {
         self.links.push(Link {
             name: name.into(),

jetsocat/src/doctor/rustls.rs

@@ -34,21 +34,31 @@ pub(super) fn run(args: &Args, callback: &mut dyn FnMut(Diagnostic) -> bool) {
     }
 }
 
-fn rustls_load_native_certs(_: &mut DiagnosticCtx, root_store: &mut rustls::RootCertStore) -> anyhow::Result<()> {
+fn rustls_load_native_certs(ctx: &mut DiagnosticCtx, root_store: &mut rustls::RootCertStore) -> anyhow::Result<()> {
     let result = rustls_native_certs::load_native_certs();
 
+    let mut warning_messages = Vec::new();
+
     for error in result.errors {
-        warn!("Error when loading native certs: {:?}", anyhow::Error::new(error),);
+        let error_msg = format!("error when loading native certs: {:?}", anyhow::Error::new(error));
+        warn!("{}", error_msg);
+        warning_messages.push(error_msg);
     }
 
     for cert in result.certs {
         if let Err(e) = root_store.add(cert.clone()) {
-            warn!("Invalid root certificate: {e}");
+            let error_msg = format!("invalid root certificate: {e}");
+            warn!("{}", error_msg);
+            warning_messages.push(error_msg);
             let root_cert_pem = cert_to_pem(&cert).context("failed to write the certificate as PEM")?;
             info!("{root_cert_pem}");
         }
     }
 
+    if !warning_messages.is_empty() {
+        ctx.attach_warning(warning_messages.join("; "));
+    }
+
     Ok(())
 }
 

jetsocat/src/doctor/schannel.rs

@@ -312,10 +312,13 @@ fn schannel_fetch_chain(
         .context("failed to retrieve the remote chain")?;
 
     let mut certificates = Vec::new();
+    let mut warning_messages = Vec::new();
 
     remote_chain.for_each(|cert_idx, element| {
         if let Err(error) = chain_ctx.store.add_x509_encoded_certificate(element.cert.as_x509_der()) {
-            warn!(cert_idx, %error, "Failed to add certificate to the store");
+            let error_msg = format!("failed to add certificate {cert_idx} to the store: {error}");
+            warn!("{}", error_msg);
+            warning_messages.push(error_msg);
         }
 
         certificates.push(CertInspectProxy {
@@ -324,6 +327,10 @@ fn schannel_fetch_chain(
         });
     });
 
+    if !warning_messages.is_empty() {
+        ctx.attach_warning(warning_messages.join("; "));
+    }
+
     crate::doctor::log_chain(certificates.iter());
     help::x509_io_link(ctx, certificates.iter());