feat: show p2p config in doctor info

Author: St4NNi

aruna-doctor/src/error.rs

@@ -73,4 +73,10 @@ pub enum CliError {
     MissingInitialOnboardingSecret,
     #[error("Arbitrary user ids require --unsafe-arbitrary-user-id")]
     UnsafeUserIdRequired,
+    #[error("invalid {key} value {value:?}: {message}")]
+    InvalidConfigValue {
+        key: &'static str,
+        value: String,
+        message: String,
+    },
 }

aruna-doctor/src/info.rs

@@ -28,6 +28,10 @@ struct ConfigView {
     p2p_socket_addr: String,
     max_concurrent_uni_streams: Option<u64>,
     max_concurrent_bidi_streams: Option<u64>,
+    p2p_discovery_methods: Vec<String>,
+    p2p_discovery_dns_origins: Vec<String>,
+    p2p_relay_method: String,
+    p2p_relay_urls: Vec<String>,
     bootstrap_nodes: Vec<String>,
     bootstrap_endpoints: Vec<String>,
     default_metadata_replication_factor: u32,
@@ -158,6 +162,10 @@ impl ConfigView {
                 .unwrap_or_else(|_| http_socket_addr.to_string()),
             max_concurrent_uni_streams: parse_optional_env("MAX_CONCURRENT_UNI_STREAMS")?,
             max_concurrent_bidi_streams: parse_optional_env("MAX_CONCURRENT_BIDI_STREAMS")?,
+            p2p_discovery_methods: discovery_methods_from_env()?,
+            p2p_discovery_dns_origins: parse_list_env("P2P_DISCOVERY_DNS_ORIGINS"),
+            p2p_relay_method: relay_method_from_env()?,
+            p2p_relay_urls: parse_list_env("P2P_RELAY_URLS"),
             bootstrap_nodes: parse_list_env("BOOTSTRAP_NODES"),
             bootstrap_endpoints: parse_list_env("BOOTSTRAP_ENDPOINTS"),
             default_metadata_replication_factor: parse_optional_env("METADATA_REPLICATION_FACTOR")?
@@ -208,6 +216,56 @@ fn parse_list_env(key: &str) -> Vec<String> {
         .collect()
 }
 
+fn discovery_methods_from_env() -> Result<Vec<String>, CliError> {
+    let value = optional_env("P2P_DISCOVERY_METHOD").unwrap_or_else(|| "none".to_string());
+    match normalize_env_value(&value).as_str() {
+        "none" => Ok(Vec::new()),
+        "n0" | "n0_dns" => Ok(vec!["n0_dns".to_string()]),
+        "custom_dns" => Ok(vec!["custom_dns".to_string()]),
+        _ => Err(invalid_config_value(
+            "P2P_DISCOVERY_METHOD",
+            value,
+            "expected one of none, n0, n0_dns, custom_dns",
+        )),
+    }
+}
+
+fn relay_method_from_env() -> Result<String, CliError> {
+    let value = optional_env("P2P_RELAY_METHOD").unwrap_or_else(|| "none".to_string());
+    match normalize_env_value(&value).as_str() {
+        "none" => Ok("none".to_string()),
+        "n0" => Ok("n0".to_string()),
+        "custom" => Ok("custom".to_string()),
+        _ => Err(invalid_config_value(
+            "P2P_RELAY_METHOD",
+            value,
+            "expected one of none, n0, custom",
+        )),
+    }
+}
+
+fn optional_env(key: &str) -> Option<String> {
+    dotenvy::var(key)
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+}
+
+fn normalize_env_value(value: &str) -> String {
+    value.trim().to_ascii_lowercase().replace('-', "_")
+}
+
+fn invalid_config_value(
+    key: &'static str,
+    value: impl Into<String>,
+    message: impl std::fmt::Display,
+) -> CliError {
+    CliError::InvalidConfigValue {
+        key,
+        value: value.into(),
+        message: message.to_string(),
+    }
+}
+
 fn env_key(id: &str) -> String {
     id.to_ascii_uppercase().replace('-', "_")
 }
@@ -397,6 +455,28 @@ mod tests {
 
         assert_eq!(view.http_base_url, "http://127.0.0.1:3000");
         assert!(view.onboarding_secret_present);
+        assert!(view.p2p_discovery_methods.is_empty());
+        assert_eq!(view.p2p_relay_method, "none");
+    }
+
+    #[tokio::test]
+    async fn config_view_reports_p2p_discovery_and_relay_config() {
+        let _env_lock = env_lock().lock().await;
+        let _guard = TestEnvGuard::set(&[
+            ("P2P_DISCOVERY_METHOD", "n0".to_string()),
+            ("P2P_RELAY_METHOD", "custom".to_string()),
+            ("P2P_RELAY_URLS", "https://relay.example.com".to_string()),
+            ("BOOTSTRAP_ENDPOINTS", "node.example.invalid".to_string()),
+        ]);
+        let view = ConfigView::from_env("0.0.0.0:3000".parse().unwrap()).unwrap();
+
+        assert_eq!(view.p2p_discovery_methods, vec!["n0_dns"]);
+        assert_eq!(view.p2p_relay_method, "custom");
+        assert_eq!(
+            view.p2p_relay_urls,
+            vec!["https://relay.example.com".to_string()]
+        );
+        assert_eq!(view.bootstrap_endpoints, vec!["node.example.invalid"]);
     }
 
     #[tokio::test]
@@ -410,6 +490,8 @@ mod tests {
             info.net_state.status,
             aruna_api::routes::info::ServiceStatus::Available
         );
+        assert!(info.net_state.discovery_methods.is_empty());
+        assert_eq!(info.net_state.relay_method.as_deref(), Some("none"));
         assert_eq!(
             info.interface_status.rest.status,
             aruna_api::routes::info::ServiceStatus::Available