fix(query): address four code review issues in Arrow IPC path

- Route get_bytes through send_debug_bytes so Arrow requests appear
  in --debug output (was bypassing debug logging entirely)
- Replace unwrap_or_default() with resp.bytes()? to propagate body
  read errors instead of silently returning empty bytes
- Remove dead req.build() error arm; send_debug_bytes handles it
- Change execution_time_ms to Option<u64>; async Arrow results show
  "—" in the table footer instead of a misleading "0 ms"
- Add 5-minute polling timeout to the async execute loop with a hint
  to re-check via `hotdata query status <run_id>`

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: eddietejeda

src/api.rs

@@ -282,22 +282,10 @@ impl ApiClient {
     pub fn get_bytes(&self, path: &str, accept: &str) -> (reqwest::StatusCode, Vec<u8>) {
         let url = format!("{}{path}", self.api_url);
         let req = self.build_request(reqwest::Method::GET, &url).header("Accept", accept);
-        match req.build() {
-            Ok(request) => {
-                match self.client.execute(request) {
-                    Ok(resp) => {
-                        let status = resp.status();
-                        let bytes = resp.bytes().unwrap_or_default().to_vec();
-                        (status, bytes)
-                    }
-                    Err(e) => {
-                        eprintln!("error connecting to API: {e}");
-                        std::process::exit(1);
-                    }
-                }
-            }
+        match util::send_debug_bytes(&self.client, req) {
+            Ok(pair) => pair,
             Err(e) => {
-                eprintln!("error building request: {e}");
+                eprintln!("error connecting to API: {e}");
                 std::process::exit(1);
             }
         }

src/query.rs

@@ -10,8 +10,7 @@ pub struct QueryResponse {
     pub columns: Vec<String>,
     pub rows: Vec<Vec<Value>>,
     pub row_count: u64,
-    #[serde(default)]
-    pub execution_time_ms: u64,
+    pub execution_time_ms: Option<u64>,
     pub warning: Option<String>,
 }
 
@@ -127,7 +126,7 @@ fn arrow_ipc_to_query_response(bytes: Vec<u8>, result_id: String) -> QueryRespon
         columns,
         rows,
         row_count,
-        execution_time_ms: 0,
+        execution_time_ms: None,
         warning: None,
     }
 }
@@ -182,9 +181,20 @@ pub fn execute(
 
         let run_id = &async_resp.query_run_id;
         let spinner = crate::util::spinner("waiting for query...");
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(300);
 
         loop {
             std::thread::sleep(std::time::Duration::from_millis(500));
+            if std::time::Instant::now() > deadline {
+                spinner.finish_and_clear();
+                use crossterm::style::Stylize;
+                eprintln!("{}", "query timed out after 5 minutes".red());
+                eprintln!(
+                    "{}",
+                    format!("Check status with: hotdata query status {run_id}").dark_grey()
+                );
+                std::process::exit(1);
+            }
             let run: QueryRunResponse = api.get(&format!("/query-runs/{run_id}"));
             match run.status.as_str() {
                 "succeeded" => {
@@ -312,13 +322,17 @@ pub fn print_result(result: &QueryResponse, format: &str) {
                 .as_deref()
                 .map(|id| format!(" [result-id: {id}]"))
                 .unwrap_or_default();
+            let time_part = match result.execution_time_ms {
+                Some(ms) => format!("{ms} ms"),
+                None => "\u{2014}".to_string(), // em dash
+            };
             eprintln!(
                 "{}",
                 format!(
-                    "\n{} row{} ({} ms){}",
+                    "\n{} row{} ({}){}",
                     result.row_count,
                     if result.row_count == 1 { "" } else { "s" },
-                    result.execution_time_ms,
+                    time_part,
                     id_part
                 )
                 .dark_grey()
@@ -327,3 +341,4 @@ pub fn print_result(result: &QueryResponse, format: &str) {
         _ => unreachable!(),
     }
 }
+

src/util.rs

@@ -132,6 +132,37 @@ pub fn send_debug(
     send_debug_with_redaction(client, builder, body_for_log, &[])
 }
 
+/// Like `send_debug` but for binary (non-UTF-8) responses such as Arrow IPC.
+/// Logs the request and response status in debug mode; prints the byte count
+/// instead of attempting to parse the body as JSON.
+pub fn send_debug_bytes(
+    client: &reqwest::blocking::Client,
+    builder: reqwest::blocking::RequestBuilder,
+) -> reqwest::Result<(reqwest::StatusCode, Vec<u8>)> {
+    let request = builder.build()?;
+    if is_debug() {
+        log_request_struct(&request, None);
+    }
+    let resp = client.execute(request)?;
+    let status = resp.status();
+    let bytes = resp.bytes()?;
+    if is_debug() {
+        use crossterm::style::Stylize;
+        let status_str = format!(
+            "<<< {} {}",
+            status.as_u16(),
+            status.canonical_reason().unwrap_or("")
+        );
+        if status.is_success() {
+            eprintln!("{}", status_str.dark_green());
+        } else {
+            eprintln!("{}", status_str.dark_red());
+        }
+        eprintln!("{}", format!("[binary: {} bytes]", bytes.len()).dark_grey());
+    }
+    Ok((status, bytes.to_vec()))
+}
+
 /// Like `send_debug` but masks the named JSON keys in the printed
 /// response body. The returned body string is always unredacted.
 pub fn send_debug_with_redaction(