fix connections get errors

Author: pthurlow

src/api.rs

@@ -171,6 +171,24 @@ impl ApiClient {
         }
     }
 
+    /// GET request, exits only on connection error, returns raw (status, body).
+    /// Use for best-effort endpoints (e.g. health checks) where the caller wants
+    /// to handle non-2xx responses gracefully instead of aborting.
+    pub fn get_raw(&self, path: &str) -> (reqwest::StatusCode, String) {
+        let url = format!("{}{path}", self.api_url);
+        self.log_request("GET", &url, None);
+
+        let resp = match self.build_request(reqwest::Method::GET, &url).send() {
+            Ok(r) => r,
+            Err(e) => {
+                eprintln!("error connecting to API: {e}");
+                std::process::exit(1);
+            }
+        };
+
+        util::debug_response(resp)
+    }
+
     /// POST request with JSON body, exits on error, returns raw (status, body).
     pub fn post_raw(&self, path: &str, body: &serde_json::Value) -> (reqwest::StatusCode, String) {
         let url = format!("{}{path}", self.api_url);

src/connections.rs

@@ -12,23 +12,56 @@ struct HealthResponse {
     error: Option<String>,
 }
 
-fn fetch_health(api: &ApiClient, connection_id: &str, show_spinner: bool) -> HealthResponse {
+/// Result of a best-effort health check. Either the endpoint responded with a
+/// parseable body, or it did not — in which case we record why and keep going.
+enum HealthStatus {
+    Available(HealthResponse),
+    Unavailable(String),
+}
+
+impl HealthStatus {
+    fn is_confirmed_unhealthy(&self) -> bool {
+        matches!(self, HealthStatus::Available(h) if !h.healthy)
+    }
+}
+
+impl Serialize for HealthStatus {
+    fn serialize<S: serde::Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
+        match self {
+            HealthStatus::Available(h) => h.serialize(ser),
+            HealthStatus::Unavailable(_) => ser.serialize_none(),
+        }
+    }
+}
+
+fn fetch_health(api: &ApiClient, connection_id: &str, show_spinner: bool) -> HealthStatus {
     let spinner = show_spinner.then(|| crate::util::spinner("Checking connection health..."));
-    let health: HealthResponse = api.get(&format!("/connections/{connection_id}/health"));
+    let (status, body) = api.get_raw(&format!("/connections/{connection_id}/health"));
     if let Some(s) = spinner { s.finish_and_clear(); }
-    health
+
+    if !status.is_success() {
+        return HealthStatus::Unavailable(crate::util::api_error(body));
+    }
+    match serde_json::from_str::<HealthResponse>(&body) {
+        Ok(h) => HealthStatus::Available(h),
+        Err(e) => HealthStatus::Unavailable(format!("parse error: {e}")),
+    }
 }
 
-fn format_health(health: &HealthResponse) -> String {
+fn format_health(health: &HealthStatus) -> String {
     use crossterm::style::Stylize;
-    if health.healthy {
-        match health.latency_ms {
+    match health {
+        HealthStatus::Available(h) if h.healthy => match h.latency_ms {
             Some(ms) => format!("{} {}", "healthy".green(), format!("({ms}ms)").dark_grey()),
             None => "healthy".green().to_string(),
+        },
+        HealthStatus::Available(h) => {
+            let err = h.error.as_deref().unwrap_or("unknown error");
+            format!("{} — {}", "unhealthy".red(), err)
+        }
+        HealthStatus::Unavailable(err) => {
+            format!("{} — {}", "unavailable".yellow(), err)
         }
-    } else {
-        let err = health.error.as_deref().unwrap_or("unknown error");
-        format!("{} — {}", "unhealthy".red(), err)
     }
 }
 
@@ -260,7 +293,7 @@ pub fn create(
         _ => unreachable!(),
     }
 
-    if !health.healthy {
+    if health.is_confirmed_unhealthy() {
         std::process::exit(1);
     }
 }

src/connections_new.rs

@@ -277,6 +277,11 @@ pub fn run(workspace_id: &str) {
         error: Option<String>,
     }
 
+    enum HealthStatus {
+        Available(HealthResponse),
+        Unavailable(String),
+    }
+
     let create_spinner = crate::util::spinner("Creating connection...");
     let (status_code, resp_body) = api.post_raw("/connections", &body);
     create_spinner.finish_and_clear();
@@ -296,9 +301,18 @@ pub fn run(workspace_id: &str) {
     };
 
     let health_spinner = crate::util::spinner("Checking connection health...");
-    let health: HealthResponse = api.get(&format!("/connections/{}/health", result.id));
+    let (hstatus, hbody) = api.get_raw(&format!("/connections/{}/health", result.id));
     health_spinner.finish_and_clear();
 
+    let health = if !hstatus.is_success() {
+        HealthStatus::Unavailable(crate::util::api_error(hbody))
+    } else {
+        match serde_json::from_str::<HealthResponse>(&hbody) {
+            Ok(h) => HealthStatus::Available(h),
+            Err(e) => HealthStatus::Unavailable(format!("parse error: {e}")),
+        }
+    };
+
     println!("{}", "Connection created".green());
     println!("id:                {}", result.id);
     println!("name:              {}", result.name);
@@ -310,18 +324,22 @@ pub fn run(workspace_id: &str) {
         _         => result.discovery_status.yellow().to_string(),
     };
     println!("discovery_status:  {status}");
-    let health_str = if health.healthy {
-        match health.latency_ms {
+    let health_str = match &health {
+        HealthStatus::Available(h) if h.healthy => match h.latency_ms {
             Some(ms) => format!("{} {}", "healthy".green(), format!("({ms}ms)").dark_grey()),
             None => "healthy".green().to_string(),
+        },
+        HealthStatus::Available(h) => {
+            let err = h.error.as_deref().unwrap_or("unknown error");
+            format!("{} — {}", "unhealthy".red(), err)
+        }
+        HealthStatus::Unavailable(err) => {
+            format!("{} — {}", "unavailable".yellow(), err)
         }
-    } else {
-        let err = health.error.as_deref().unwrap_or("unknown error");
-        format!("{} — {}", "unhealthy".red(), err)
     };
     println!("health:            {health_str}");
 
-    if !health.healthy {
+    if matches!(&health, HealthStatus::Available(h) if !h.healthy) {
         std::process::exit(1);
     }
 }