Hls recording fixes

apps/desktop/src-tauri/src/http_client.rs

@@ -8,7 +8,13 @@ pub struct HttpClient(reqwest::Client);
 
 impl Default for HttpClient {
     fn default() -> Self {
-        Self(reqwest::Client::new())
+        Self(
+            reqwest::Client::builder()
+                .connect_timeout(std::time::Duration::from_secs(10))
+                .timeout(std::time::Duration::from_secs(30))
+                .build()
+                .expect("Failed to build HTTP client"),
+        )
     }
 }
 
@@ -26,21 +32,17 @@ impl Default for RetryableHttpClient {
     fn default() -> Self {
         Self(
             reqwest::Client::builder()
+                .connect_timeout(std::time::Duration::from_secs(10))
                 .retry(
                     reqwest::retry::always()
-                        .classify_fn(|req_rep| {
-                            match req_rep.status() {
-                                // Server errors
-                                Some(s)
-                                    if s.is_server_error()
-                                        || s == StatusCode::TOO_MANY_REQUESTS =>
-                                {
-                                    req_rep.retryable()
-                                }
-                                // Network errors
-                                None => req_rep.retryable(),
-                                _ => req_rep.success(),
+                        .classify_fn(|req_rep| match req_rep.status() {
+                            Some(s)
+                                if s.is_server_error() || s == StatusCode::TOO_MANY_REQUESTS =>
+                            {
+                                req_rep.retryable()
                             }
+                            None => req_rep.retryable(),
+                            _ => req_rep.success(),
                         })
                         .max_retries_per_request(5)
                         .max_extra_load(5.0),

apps/desktop/src-tauri/src/lib.rs

@@ -1645,6 +1645,55 @@ pub(crate) async fn create_screenshot(
     result
 }
 
+pub(crate) async fn create_screenshot_source_from_segments(
+    segments_dir: &std::path::Path,
+) -> Result<PathBuf, String> {
+    let init_path = segments_dir.join("init.mp4");
+    if !init_path.exists() {
+        return Err(format!("init.mp4 not found in {}", segments_dir.display()));
+    }
+
+    let first_segment = find_first_segment(segments_dir)
+        .ok_or_else(|| format!("No .m4s segments found in {}", segments_dir.display()))?;
+
+    let temp_path = segments_dir.join(".screenshot_source.mp4");
+    let mut out = tokio::fs::File::create(&temp_path)
+        .await
+        .map_err(|e| format!("Failed to create screenshot source: {e}"))?;
+
+    let mut init_file = tokio::fs::File::open(&init_path)
+        .await
+        .map_err(|e| format!("Failed to open init.mp4: {e}"))?;
+    tokio::io::copy(&mut init_file, &mut out)
+        .await
+        .map_err(|e| format!("Failed to copy init.mp4: {e}"))?;
+
+    let mut seg_file = tokio::fs::File::open(&first_segment)
+        .await
+        .map_err(|e| format!("Failed to open {}: {e}", first_segment.display()))?;
+    tokio::io::copy(&mut seg_file, &mut out)
+        .await
+        .map_err(|e| format!("Failed to copy segment: {e}"))?;
+
+    Ok(temp_path)
+}
+
+fn find_first_segment(dir: &std::path::Path) -> Option<PathBuf> {
+    let mut segments: Vec<PathBuf> = std::fs::read_dir(dir)
+        .ok()?
+        .filter_map(|e| {
+            let path = e.ok()?.path();
+            if path.extension().is_some_and(|ext| ext == "m4s") {
+                Some(path)
+            } else {
+                None
+            }
+        })
+        .collect();
+    segments.sort();
+    segments.into_iter().next()
+}
+
 // async fn create_thumbnail(input: PathBuf, output: PathBuf, size: (u32, u32)) -> Result<(), String> {
 //     println!("Creating thumbnail: input={input:?}, output={output:?}, size={size:?}");