Merge pull request #122 from softwaremill/fix/flush-413-and-status-pending

fix(cli): fix flush 413 infinite loop, add timeout/progress, fix status pending check

Author: softberries

.gitmodules

@@ -1,6 +1,8 @@
 [submodule "enterprise"]
 	path = enterprise
 	url = git@github.com:softwaremill/tracevault-enterprise.git
+	update = none
 [submodule "website"]
 	path = website
-	url = git@github.com:softwaremill/tracevault-website.git
+	url = https://github.com/softwaremill/tracevault-website.git
+	update = none

crates/tracevault-cli/src/api_client.rs

@@ -142,7 +142,10 @@ impl ApiClient {
         Self {
             base_url: base_url.trim_end_matches('/').to_string(),
             api_key: api_key.map(String::from),
-            client: reqwest::Client::new(),
+            client: reqwest::Client::builder()
+                .timeout(std::time::Duration::from_secs(60))
+                .build()
+                .unwrap_or_default(),
         }
     }
 

crates/tracevault-cli/src/commands/flush.rs

@@ -39,25 +39,45 @@ pub async fn run_flush(project_root: &Path) -> Result<(), Box<dyn std::error::Er
             continue;
         }
 
+        let event_total = events.len();
         let mut failed_events: Vec<StreamEventRequest> = Vec::new();
 
-        for event in events {
+        for (i, mut event) in events.into_iter().enumerate() {
+            eprint!(
+                "\r  Session {} — event {}/{} ...",
+                &event.session_id[..8],
+                i + 1,
+                event_total
+            );
+            event.truncate_large_fields();
             match client.stream_event(&org_slug, &repo_id, &event).await {
                 Ok(_) => {
                     total_sent += 1;
                 }
                 Err(e) => {
-                    eprintln!(
-                        "Warning: failed to send event (session {}): {e}",
-                        event.session_id
-                    );
-                    failed_events.push(event);
-                    total_failed += 1;
+                    eprintln!();
+                    let err_str = e.to_string();
+                    if err_str.contains("413") {
+                        // Payload too large even after truncation — drop it.
+                        eprintln!(
+                            "  Warning: dropped event (session {}) — still too large after truncation",
+                            event.session_id
+                        );
+                        total_failed += 1;
+                    } else {
+                        eprintln!(
+                            "  Warning: failed to send event (session {}): {e}",
+                            event.session_id
+                        );
+                        failed_events.push(event);
+                        total_failed += 1;
+                    }
                 }
             }
         }
+        eprintln!();
 
-        // Re-enqueue failed events
+        // Re-enqueue transiently failed events (not 413s)
         if !failed_events.is_empty() {
             append_pending(&pending_path, &failed_events)?;
         }

crates/tracevault-cli/src/commands/status.rs

@@ -412,32 +412,47 @@ fn session_checks(project_root: &Path) -> Vec<Check> {
     let sessions_dir = project_root.join(".tracevault/sessions");
     if !sessions_dir.exists() {
         return vec![Check::skip(
-            "Unpushed sessions",
+            "Pending events",
             "no .tracevault/sessions/ yet (no captures recorded)",
         )];
     }
 
-    let mut total = 0usize;
-    let mut unpushed = 0usize;
+    let mut total_sessions = 0usize;
+    let mut sessions_with_pending = 0usize;
+    let mut pending_event_count = 0usize;
+
     if let Ok(read) = fs::read_dir(&sessions_dir) {
         for entry in read.flatten() {
             if !entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false) {
                 continue;
             }
-            total += 1;
-            if !entry.path().join(".pushed").exists() {
-                unpushed += 1;
+            total_sessions += 1;
+            let pending_path = entry.path().join("pending.jsonl");
+            if pending_path.exists() {
+                let count = fs::read_to_string(&pending_path)
+                    .unwrap_or_default()
+                    .lines()
+                    .filter(|l| !l.trim().is_empty())
+                    .count();
+                if count > 0 {
+                    sessions_with_pending += 1;
+                    pending_event_count += count;
+                }
             }
         }
     }
 
-    let detail = format!("{unpushed} pending / {total} total");
-    vec![if unpushed == 0 {
-        Check::ok("Unpushed sessions", detail)
+    vec![if sessions_with_pending == 0 {
+        Check::ok(
+            "Pending events",
+            format!("{total_sessions} session(s), all synced"),
+        )
     } else {
         Check::warn(
-            "Unpushed sessions",
-            format!("{detail} — will be pushed on next `tracevault push` or pre-push hook"),
+            "Pending events",
+            format!(
+                "{pending_event_count} event(s) in {sessions_with_pending}/{total_sessions} session(s) — run `tracevault flush`"
+            ),
         )
     }]
 }

crates/tracevault-cli/src/commands/stream.rs

@@ -114,7 +114,7 @@ pub async fn run_stream(
         _ => StreamEventType::ToolUse,
     };
 
-    let req = StreamEventRequest {
+    let mut req = StreamEventRequest {
         protocol_version: 1,
         tool: Some("claude-code".to_string()),
         event_type: stream_event_type,
@@ -136,6 +136,8 @@ pub async fn run_stream(
         final_stats: None,
     };
 
+    req.truncate_large_fields();
+
     // 6. Resolve credentials
     let (server_url, token) = crate::api_client::resolve_credentials(project_root);
 

crates/tracevault-core/src/streaming.rs

@@ -79,6 +79,26 @@ pub fn is_file_modifying_tool(tool_name: &str) -> bool {
     matches!(tool_name, "Write" | "Edit" | "Bash")
 }
 
+impl StreamEventRequest {
+    /// Drop optional fields largest-first until the serialized payload is
+    /// under 512 KB. Prevents 413 errors on both real-time sends and flush.
+    pub fn truncate_large_fields(&mut self) {
+        const MAX_BYTES: usize = 512 * 1024;
+        if serde_json::to_string(self).map(|s| s.len()).unwrap_or(0) <= MAX_BYTES {
+            return;
+        }
+        self.transcript_lines = None;
+        if serde_json::to_string(self).map(|s| s.len()).unwrap_or(0) <= MAX_BYTES {
+            return;
+        }
+        self.tool_response = None;
+        if serde_json::to_string(self).map(|s| s.len()).unwrap_or(0) <= MAX_BYTES {
+            return;
+        }
+        self.tool_input = None;
+    }
+}
+
 pub fn extract_file_change(
     tool_name: &str,
     tool_input: &serde_json::Value,