YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
fix(audio): flush stopped recordings once (#7235)
Ezra Ellette89a09898c025
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/feedback_upload.rs b/apps/screenpipe-app-tauri/src-tauri/src/feedback_upload.rsindex 1cebd6935..b4cfb92de 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/feedback_upload.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/feedback_upload.rs@@ -760,6 +760,78 @@ mod tests {}}+ #[tokio::test]+ async fn audio_flush_and_persistence_diagnostics_reach_mocked_support_upload() {+ let Some(native_trace) = std::env::var_os("SCREENPIPE_TEST_AUDIO_TRACE_PATH") else {+ return;+ };+ let logs = tempfile::tempdir().unwrap();+ for day in 20..23 {+ let body = if day == 22 {+ let mut emitted = std::fs::read_to_string(&native_trace)+ .expect("native recorder diagnostic trace");+ emitted.push_str("[email protected]\n");+ emitted+ } else {+ "ordinary rotated log\n".to_string()+ };+ std::fs::write(+ logs.path()+ .join(format!("screenpipe-app.2026-09-{day}.log")),+ body,+ )+ .unwrap();+ }++ let files = crate::log_files::collect_log_files(&[logs.path().to_path_buf()]).await;+ let raw = collect_log_text_from_files(files).await;+ let redacted = crate::feedback_redact::redact_pii_for_feedback(raw, "{}".into())+ .await+ .unwrap();+ let unattended =+ crate::diagnostic_logs::collect_redacted_from_dirs(&[logs.path().to_path_buf()])+ .await+ .unwrap();+ for report in [&redacted, &unattended] {+ assert!(report.contains("audio recorder final flush queued successfully"));+ assert!(report.contains("samples=16000"));+ assert!(report.contains("duration=1.000s"));+ assert!(report.contains("audio recorder final flush queue failed"));+ assert!(report.contains("cause=whisper channel disconnected"));+ assert!(!report.contains("[email protected]"));+ }++ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path("/api/logs"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({"data": {+ "signedUrl": format!("{}/upload/log", server.uri()), "path": "logs/report.log"+ }})))+ .mount(&server)+ .await;+ Mock::given(method("PUT"))+ .and(path("/upload/log"))+ .and(body_bytes(redacted.as_bytes()))+ .respond_with(ResponseTemplate::new(200))+ .mount(&server)+ .await;+ Mock::given(method("POST"))+ .and(path("/api/logs/confirm"))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({"data": {"id": 42}})))+ .mount(&server)+ .await;+ upload_report(+ &Client::new(),+ &server.uri(),+ &request(),+ redacted,+ None,+ None,+ )+ .await+ .unwrap();+ }+#[tokio::test]async fn parity_scan_failure_reaches_support_without_rolling_logs() {use screenpipe_db::{storage, DatabaseManager};diff --git a/crates/screenpipe-audio/src/audio_manager/manager.rs b/crates/screenpipe-audio/src/audio_manager/manager.rsindex f890fb5d5..caf4e14ee 100644--- a/crates/screenpipe-audio/src/audio_manager/manager.rs+++ b/crates/screenpipe-audio/src/audio_manager/manager.rs@@ -1474,6 +1474,9 @@ impl AudioManager {// ALWAYS persist audio to disk immediately, before any deferral.// This ensures audio survives app restarts and can be retranscribed later.let persisted_file_path = if let Some(ref out) = output_path {+ let queued_sample_count = audio.data.len();+ let queued_duration_seconds =+ queued_sample_count as f64 / audio.sample_rate as f64;let resampled = if audio.sample_rate != SAMPLE_RATE {match resample(audio.data.as_ref(), audio.sample_rate, SAMPLE_RATE) {Ok(r) => r,@@ -1503,7 +1506,15 @@ impl AudioManager {match write_result {Ok(Ok(path)) => {- debug!("audio persisted to disk: {}", path);+ info!(+ "audio persistence write succeeded for {}: samples={}, sample_rate={}Hz, duration={:.3}s, capture_timestamp={}, path={}",+ audio.device,+ queued_sample_count,+ audio.sample_rate,+ queued_duration_seconds,+ audio.capture_timestamp,+ path+ );// Insert into DB immediately so retranscribe can find this audio// even if transcription is deferred. No transcription yet — just the chunk.// Use the original capture timestamp so audio appears at the correct@@ -1567,11 +1578,25 @@ impl AudioManager {Some(path)}Ok(Err(e)) => {- error!("failed to persist audio before deferral: {:?}", e);+ error!(+ "audio persistence write failed for {}: samples={}, sample_rate={}Hz, duration={:.3}s, cause={:?}",+ audio.device,+ queued_sample_count,+ audio.sample_rate,+ queued_duration_seconds,+ e+ );None}Err(e) => {- error!("audio persistence worker failed: {}", e);+ error!(+ "audio persistence worker failed for {}: samples={}, sample_rate={}Hz, duration={:.3}s, cause={}",+ audio.device,+ queued_sample_count,+ audio.sample_rate,+ queued_duration_seconds,+ e+ );None}}diff --git a/crates/screenpipe-audio/src/core/run_record_and_transcribe.rs b/crates/screenpipe-audio/src/core/run_record_and_transcribe.rsindex bdf20c007..c39aa2197 100644--- a/crates/screenpipe-audio/src/core/run_record_and_transcribe.rs+++ b/crates/screenpipe-audio/src/core/run_record_and_transcribe.rs@@ -1,5 +1,5 @@// screenpipe — AI that knows everything you've seen, said, or heard-// https://screenpi.pe+// https://screenpipe.comuse std::{sync::{@@ -377,6 +377,10 @@ pub async fn run_record_and_transcribe(}}+ if !is_running.load(Ordering::Relaxed) {+ break;+ }+flush_audio(&mut collected_audio,overlap_samples,@@ -386,6 +390,7 @@ pub async fn run_record_and_transcribe(&device_name,&metrics,true, // aec_active = true (16kHz)+ false,).await?;segment_start_time = now_epoch_secs();@@ -401,6 +406,7 @@ pub async fn run_record_and_transcribe(&device_name,&metrics,true, // aec_active = true+ true,).await{@@ -519,6 +525,10 @@ pub async fn run_record_and_transcribe(source_buffer.log_stats();}+ if !is_running.load(Ordering::Relaxed) {+ break;+ }+flush_audio(&mut collected_audio,overlap_samples,@@ -528,6 +538,7 @@ pub async fn run_record_and_transcribe(&device_name,&metrics,false, // aec_active = false+ false,).await?;segment_start_time = now_epoch_secs();@@ -542,6 +553,7 @@ pub async fn run_record_and_transcribe(&device_name,&metrics,false,+ true,).await{@@ -805,6 +817,7 @@ async fn flush_audio(device_name: &str,metrics: &Arc<AudioPipelineMetrics>,aec_active: bool,+ final_flush: bool,) -> Result<()> {if collected_audio.is_empty() {return Ok(());@@ -826,7 +839,9 @@ async fn flush_audio(} else {audio_stream.device_config.sample_rate().0};-+ let sample_count = send_data.len();+ let duration_seconds = sample_count as f64 / sample_rate as f64;+ let flush_kind = if final_flush { "final" } else { "regular" };match whisper_sender.send_timeout(AudioInput {data: Arc::new(send_data),@@ -838,18 +853,24 @@ async fn flush_audio(Duration::from_secs(30),) {Ok(_) => {- debug!("sent audio segment to audio model");+ info!(+ "audio recorder {} flush queued successfully for {}: samples={}, sample_rate={}Hz, duration={:.3}s, capture_timestamp={}",+ flush_kind, device_name, sample_count, sample_rate, duration_seconds, capture_timestamp+ );metrics.record_chunk_sent();}Err(e) => {if e.is_disconnected() {- error!("whisper channel disconnected, restarting recording process");+ error!(+ "audio recorder {} flush queue failed for {}: samples={}, sample_rate={}Hz, duration={:.3}s, cause=whisper channel disconnected",+ flush_kind, device_name, sample_count, sample_rate, duration_seconds+ );return Err(anyhow!("Whisper channel disconnected"));} else if e.is_timeout() {metrics.record_channel_full();warn!(- "whisper channel still full after 30s, dropping audio segment for {}",- device_name+ "audio recorder {} flush queue failed for {}: samples={}, sample_rate={}Hz, duration={:.3}s, cause=whisper channel still full after 30s; dropping audio segment",+ flush_kind, device_name, sample_count, sample_rate, duration_seconds);}}@@ -863,6 +884,246 @@ mod tests {use super::*;use crate::core::device::AudioDevice;+ async fn run_stopped_recorder(+ samples: Vec<f32>,+ segment_duration: Duration,+ aec: bool,+ ) -> (u64, Vec<AudioInput>) {+ let sample_rate = 16_000_u32;+ let device = Arc::new(AudioDevice::new(+ "Stopped recorder regression fixture".to_string(),+ if aec {+ DeviceType::Input+ } else {+ DeviceType::Output+ },+ ));+ let (audio_stream, tx) = AudioStream::from_sender_for_test(device, sample_rate, 1);+ let audio_stream = Arc::new(audio_stream);+ let (whisper_tx, whisper_rx) = crossbeam::channel::bounded::<AudioInput>(8);+ let is_running = Arc::new(AtomicBool::new(true));+ let metrics = Arc::new(AudioPipelineMetrics::new());+ let metrics_for_wait = metrics.clone();+ metrics+ .audio_level_rms_x10000+ .store(u64::MAX, Ordering::Relaxed);+ let started_before_spawn = now_epoch_secs();+ let pipeline = tokio::spawn({+ let audio_stream = audio_stream.clone();+ let is_running = is_running.clone();+ let metrics = metrics.clone();+ async move {+ run_record_and_transcribe(+ audio_stream,+ segment_duration,+ Arc::new(whisper_tx),+ is_running,+ metrics,+ None,+ None,+ aec,+ )+ .await+ }+ });++ tokio::time::timeout(Duration::from_secs(1), async {+ while tx.receiver_count() == 0 {+ tokio::task::yield_now().await;+ }+ })+ .await+ .expect("recorder subscription timeout");+ let started_after_subscription = now_epoch_secs();+ if !samples.is_empty() {+ tx.send(samples).expect("send recorder fixture");+ tokio::time::timeout(Duration::from_secs(1), async {+ while metrics_for_wait+ .audio_level_rms_x10000+ .load(Ordering::Relaxed)+ == u64::MAX+ {+ tokio::task::yield_now().await;+ }+ })+ .await+ .expect("recorder sample-consumption timeout");+ if segment_duration == Duration::from_secs(1) {+ tokio::time::timeout(Duration::from_secs(1), async {+ while metrics_for_wait.chunks_sent.load(Ordering::Relaxed) == 0 {+ tokio::task::yield_now().await;+ }+ })+ .await+ .expect("regular recorder flush timeout");+ }+ }+ is_running.store(false, Ordering::Relaxed);+ tx.send(Vec::new()).ok();+ tokio::time::timeout(Duration::from_secs(2), pipeline)+ .await+ .expect("recorder shutdown timeout")+ .expect("recorder task")+ .expect("recorder result");++ let segments = whisper_rx.try_iter().collect::<Vec<_>>();+ if let Some(first) = segments.first() {+ assert!(first.capture_timestamp >= started_before_spawn);+ assert!(first.capture_timestamp <= started_after_subscription);+ }+ for pair in segments.windows(2) {+ assert!(pair[1].capture_timestamp >= pair[0].capture_timestamp);+ }+ (started_before_spawn, segments)+ }++ #[tokio::test]+ async fn stopped_raw_recorder_flushes_each_final_fragment_once() {+ let cases = [+ ("one_second", vec![0.25; 16_000]),+ ("three_point_two_seconds", vec![0.5; 51_200]),+ ("legitimate_silence", vec![0.0; 16_000]),+ ];+ for (name, samples) in cases {+ let (_, segments) =+ run_stopped_recorder(samples.clone(), Duration::from_secs(30), false).await;+ assert_eq!(segments.len(), 1, "{name} must produce one final fragment");+ assert_eq!(segments[0].data.as_ref(), &samples, "{name} samples");+ }++ let (_, empty_segments) =+ run_stopped_recorder(Vec::new(), Duration::from_secs(30), false).await;+ assert!(+ empty_segments.is_empty(),+ "empty stop must not create a fragment"+ );+ }++ #[tokio::test]+ async fn stopped_raw_recorder_keeps_regular_chunk_and_one_retained_tail() {+ let samples = (0..48_000).map(|n| n as f32).collect::<Vec<_>>();+ let (started_at, segments) =+ run_stopped_recorder(samples.clone(), Duration::from_secs(1), false).await;++ assert_eq!(+ segments+ .iter()+ .map(|segment| segment.data.len())+ .sum::<usize>(),+ samples.len()+ );++ assert_eq!(segments.len(), 2, "one regular chunk plus one final tail");+ assert_eq!(segments[0].data.as_ref(), &samples[..16_000]);+ assert_eq!(segments[1].data.as_ref(), &samples[16_000..]);+ assert!(segments[1].capture_timestamp >= started_at);+ }++ #[tokio::test]+ async fn stopped_aec_recorder_flushes_processed_tail_once() {+ let samples = vec![0.25; 3_200];+ let (_, segments) = run_stopped_recorder(samples, Duration::from_secs(30), true).await;+ assert_eq!(segments.len(), 1);+ assert_eq!(segments[0].sample_rate, 16_000);+ assert!(!segments[0].data.is_empty());+ assert_eq!(+ segments[0].data.len() % crate::core::aec::FRAME_SIZE_10MS,+ 0+ );+ assert!(segments[0].data.len() <= 3_200);+ }++ #[tokio::test]+ async fn stopped_recorder_emits_real_final_flush_outcomes_for_support() {+ use tracing::instrument::WithSubscriber;++ let Some(trace_path) = std::env::var_os("SCREENPIPE_TEST_AUDIO_TRACE_PATH") else {+ return;+ };+ let subscriber = tracing_subscriber::fmt()+ .with_ansi(false)+ .with_writer(std::fs::File::create(trace_path).unwrap())+ .finish();+ async {+ let device = Arc::new(AudioDevice::new(+ "Stopped recorder diagnostic fixture".to_string(),+ DeviceType::Output,+ ));+ let (stream, _tx) = AudioStream::from_sender_for_test(device, 16_000, 1);+ let stream = Arc::new(stream);+ let (success_sender, success_receiver) = crossbeam::channel::bounded::<AudioInput>(1);+ let mut final_fragment = vec![0.25; 16_000];+ flush_audio(+ &mut final_fragment,+ 0,+ now_epoch_secs(),+ &stream,+ &Arc::new(success_sender),+ "Stopped recorder diagnostic fixture (output)",+ &Arc::new(AudioPipelineMetrics::new()),+ false,+ true,+ )+ .await+ .expect("final flush success");+ assert_eq!(success_receiver.recv().unwrap().data.len(), 16_000);++ let (sender, receiver) = crossbeam::channel::bounded::<AudioInput>(1);+ drop(receiver);+ let mut retained = vec![0.5; 51_200];+ let error = flush_audio(+ &mut retained,+ 0,+ now_epoch_secs(),+ &stream,+ &Arc::new(sender),+ "Stopped recorder queue failure fixture (output)",+ &Arc::new(AudioPipelineMetrics::new()),+ false,+ true,+ )+ .await+ .expect_err("disconnected queue must fail");+ assert!(error.to_string().contains("disconnected"));+ }+ .with_subscriber(subscriber)+ .await;+ }++ #[cfg(target_os = "windows")]+ #[tokio::test]+ async fn stopped_raw_recorder_persists_short_fragments_with_production_writer() {+ let Some(output_dir) = std::env::var_os("SCREENPIPE_TEST_AUDIO_EVIDENCE_DIR") else {+ return;+ };+ let output_dir = std::path::PathBuf::from(output_dir);+ std::fs::create_dir_all(&output_dir).unwrap();++ for (name, samples) in [+ ("one_second", vec![0.25; 16_000]),+ ("three_point_two_seconds", vec![0.5; 51_200]),+ ] {+ let (_, segments) =+ run_stopped_recorder(samples.clone(), Duration::from_secs(30), false).await;+ assert_eq!(segments.len(), 1, "{name} fragment count");+ assert_eq!(segments[0].data.len(), samples.len(), "{name} sample count");+ let path = crate::utils::ffmpeg::write_audio_to_new_file(+ segments[0].data.as_ref(),+ segments[0].sample_rate,+ name,+ &output_dir,+ chrono::DateTime::from_timestamp(segments[0].capture_timestamp as i64, 0),+ )+ .expect("production MP4 writer");+ println!(+ "native persisted fixture: case={name} samples={} sample_rate={} expected_duration={:.3}s path={path}",+ segments[0].data.len(),+ segments[0].sample_rate,+ segments[0].data.len() as f64 / segments[0].sample_rate as f64+ );+ }+ }+#[test]fn live_tap_marks_recorder_mono_output_as_mono() {let device = Arc::new(AudioDevice::new(