feat(http): surface full error source chain for download failures

The Linux sfw CI failure showed:

  Failed to download from .../SHASUMS256.txt: error sending request
  for url (https://.../SHASUMS256.txt)

The user-visible message stopped at reqwest's top-level Display and
dropped the actual cause (e.g. "invalid peer certificate:
UnknownIssuer" inside the rustls error chain). That hides why the
request failed — looks like a network blip when it's actually a TLS
trust problem.

Add `vite_shared::format_error_chain` that walks `Error::source()`
recursively and joins the messages with `: `. Use it in all four
`Error::DownloadFailed { reason }` map_err sites in
vite_js_runtime/src/download.rs.

Now the same failure renders as:

  Failed to download from .../SHASUMS256.txt: error sending request
  for url (...): client error (Connect): invalid peer certificate:
  UnknownIssuer

making the root cause grep-able from the CI log.

Author: fengmk2

crates/vite_js_runtime/src/download.rs

@@ -49,7 +49,10 @@ pub async fn download_file(
                 .with_max_times(3),
         )
         .await
-        .map_err(|e| Error::DownloadFailed { url: url.into(), reason: vite_str::format!("{e}") })?;
+        .map_err(|e| Error::DownloadFailed {
+            url: url.into(),
+            reason: vite_shared::format_error_chain(&e).into(),
+        })?;
 
     // Get Content-Length for progress bar
     let total_size = response.content_length();
@@ -125,7 +128,10 @@ pub async fn download_text(url: &str) -> Result<String, Error> {
                 .with_max_times(3),
         )
         .await
-        .map_err(|e| Error::DownloadFailed { url: url.into(), reason: vite_str::format!("{e}") })?;
+        .map_err(|e| Error::DownloadFailed {
+            url: url.into(),
+            reason: vite_shared::format_error_chain(&e).into(),
+        })?;
 
     Ok(content)
 }
@@ -158,7 +164,10 @@ pub async fn fetch_with_cache_headers(
             .with_max_times(3),
     )
     .await
-    .map_err(|e| Error::DownloadFailed { url: url.into(), reason: vite_str::format!("{e}") })?;
+    .map_err(|e| Error::DownloadFailed {
+        url: url.into(),
+        reason: vite_shared::format_error_chain(&e).into(),
+    })?;
 
     // Check for 304 Not Modified
     if response.status() == reqwest::StatusCode::NOT_MODIFIED {
@@ -181,10 +190,10 @@ pub async fn fetch_with_cache_headers(
         .and_then(|v| v.to_str().ok())
         .and_then(parse_max_age);
 
-    let body = response
-        .text()
-        .await
-        .map_err(|e| Error::DownloadFailed { url: url.into(), reason: vite_str::format!("{e}") })?;
+    let body = response.text().await.map_err(|e| Error::DownloadFailed {
+        url: url.into(),
+        reason: vite_shared::format_error_chain(&e).into(),
+    })?;
 
     Ok(CachedFetchResponse { body: Some(body), etag, max_age, not_modified: false })
 }

crates/vite_shared/src/error.rs

@@ -0,0 +1,64 @@
+//! Error-formatting helpers.
+
+use std::error::Error;
+
+/// Format an error and its full `source()` chain as `top: cause: deeper-cause`.
+///
+/// Use this when stringifying an error into a field of a higher-level error
+/// type — otherwise the Display impl of types like `reqwest::Error` only shows
+/// the top-level message, hiding the actual cause (TLS handshake failure,
+/// connection refused, etc.).
+#[must_use]
+pub fn format_error_chain(err: &(dyn Error + 'static)) -> String {
+    let mut out = err.to_string();
+    let mut current = err.source();
+    while let Some(source) = current {
+        out.push_str(": ");
+        out.push_str(&source.to_string());
+        current = source.source();
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{error::Error as StdError, fmt};
+
+    use super::*;
+
+    #[derive(Debug)]
+    struct Layer {
+        msg: &'static str,
+        cause: Option<Box<Layer>>,
+    }
+
+    impl fmt::Display for Layer {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.write_str(self.msg)
+        }
+    }
+
+    impl StdError for Layer {
+        fn source(&self) -> Option<&(dyn StdError + 'static)> {
+            self.cause.as_deref().map(|c| c as &(dyn StdError + 'static))
+        }
+    }
+
+    #[test]
+    fn single_error_no_chain() {
+        let e = Layer { msg: "top", cause: None };
+        assert_eq!(format_error_chain(&e), "top");
+    }
+
+    #[test]
+    fn walks_full_chain() {
+        let e = Layer {
+            msg: "send request",
+            cause: Some(Box::new(Layer {
+                msg: "tls handshake",
+                cause: Some(Box::new(Layer { msg: "UnknownIssuer", cause: None })),
+            })),
+        };
+        assert_eq!(format_error_chain(&e), "send request: tls handshake: UnknownIssuer");
+    }
+}

crates/vite_shared/src/lib.rs

@@ -9,6 +9,7 @@
 
 mod env_config;
 pub mod env_vars;
+mod error;
 pub mod header;
 mod home;
 mod http;
@@ -20,6 +21,7 @@ mod tls;
 mod tracing;
 
 pub use env_config::{EnvConfig, TestEnvGuard};
+pub use error::format_error_chain;
 pub use home::get_vp_home;
 pub use http::shared_http_client;
 pub use package_json::{DevEngines, Engines, PackageJson, RuntimeEngine, RuntimeEngineConfig};