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: serialize audio device recovery and label preset copies
louisfa4dbb0aa7b3
diff --git a/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx b/apps/screenpipe-app-tauri/components/settings/ai-presets.tsxindex 86d623ad2..6939f3563 100644--- a/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx+++ b/apps/screenpipe-app-tauri/components/settings/ai-presets.tsx@@ -1287,7 +1287,7 @@ const AISection = ({<ArrowLeft className="w-4 h-4" /> Back</Button><h1 className="text-xl font-semibold">- {preset ? ui("Update preset") : ui("Create preset")}+ {isDuplicating ? ui("Duplicate preset") : preset ? ui("Update preset") : ui("Create preset")}</h1></div>@@ -1952,7 +1952,7 @@ const AISection = ({) : (<AlertCircle className="w-4 h-4" />)}- {preset ? ui("Update preset") : ui("Create preset")}+ {isDuplicating ? ui("Create copy") : preset ? ui("Update preset") : ui("Create preset")}</Button></span></TooltipTrigger>diff --git a/crates/screenpipe-audio/src/audio_manager/manager.rs b/crates/screenpipe-audio/src/audio_manager/manager.rsindex 74d596424..81b8945f5 100644--- a/crates/screenpipe-audio/src/audio_manager/manager.rs+++ b/crates/screenpipe-audio/src/audio_manager/manager.rs@@ -721,12 +721,16 @@ impl AudioManager {// Stop producers FIRST: abort per-device recording tasks and the OS audio streams.// This must happen before killing the consumer so any audio already queued in the// audio channel (including the final 30s flush) can still be drained.- for pair in self.recording_handles.iter() {- let handle = pair.value();+ let device_stop_result = self.device_manager.stop_all_devices().await;+ let handles: Vec<_> = self+ .recording_handles+ .iter()+ .map(|p| p.value().clone())+ .collect();+ self.recording_handles.clear();+ for handle in handles {handle.lock().await.abort();}- self.recording_handles.clear();- self.device_manager.stop_all_devices().await?;// Drain the channel: wait until the pipeline handler has consumed all queued chunks// (or a hard timeout expires). The early persist — file write + DB insert — happens@@ -760,7 +764,7 @@ impl AudioManager {}info!("audio manager stopped");- Ok(())+ device_stop_result}pub async fn stop(&self) -> Result<()> {@@ -794,26 +798,27 @@ impl AudioManager {/// Idempotent — safe to call on already-stopped devices./// Used by device monitor for force-cycling devices after sleep/wake.pub async fn stop_device_recording(&self, device: &AudioDevice) -> Result<()> {+ let manager = self.clone();+ let target = device.clone();+ self.device_manager+ .run_device_operation(device, async move {+ manager.stop_device_recording_inner(&target).await+ })+ .await+ }++ async fn stop_device_recording_inner(&self, device: &AudioDevice) -> Result<()> {// Signal the recording loop to stop BEFORE aborting the handle,// so it exits cleanly without triggering "stream dead" warnings.if let Some(is_running) = self.device_manager.is_running_mut(device) {is_running.store(false, std::sync::atomic::Ordering::Relaxed);}- // Ignore "already stopped" errors- if let Err(e) = self.device_manager.stop_device(device).await {- let msg = e.to_string();- if !msg.contains("already stopped") && !msg.contains("not running") {- return Err(e);- }- }-- if let Some(pair) = self.recording_handles.get(device) {- let handle = pair.value();+ let result = self.device_manager.stop_device(device).await;+ if let Some((_, handle)) = self.recording_handles.remove(device) {handle.lock().await.abort();}-- self.recording_handles.remove(device);+ result?;Ok(())}@@ -827,7 +832,7 @@ impl AudioManager {}/// Temporarily pause a device without changing the configured device list.- /// Idempotent — safe to call if already paused. Never errors.+ /// Idempotent — safe to call if already paused. Reports native teardown failures.pub async fn pause_device(&self, device_name: &str) -> Result<()> {self.user_enabled_devices.write().await.remove(device_name);// Mark as disabled FIRST so no monitor path can race and restart it@@ -836,10 +841,8 @@ impl AudioManager {.await.insert(device_name.to_string());- // Best-effort stop — ignore all errors (already stopped, not found, etc.)- if let Ok(device) = parse_audio_device(device_name) {- let _ = self.stop_device_recording(&device).await;- }+ let device = parse_audio_device(device_name)?;+ self.stop_device_recording(&device).await?;info!("user paused audio device: {}", device_name);Ok(())}@@ -905,6 +908,20 @@ impl AudioManager {}pub async fn start_device(&self, device: &AudioDevice) -> Result<()> {+ let manager = self.clone();+ let target = device.clone();+ self.device_manager+ .run_device_operation(+ device,+ async move { manager.start_device_inner(&target).await },+ )+ .await+ }++ async fn start_device_inner(&self, device: &AudioDevice) -> Result<()> {+ if self.status().await != AudioManagerStatus::Running {+ return Err(anyhow!("audio manager is stopped"));+ }if self.options.read().await.is_disabled {debug!("skipping start of audio device because audio capture is disabled: {}",@@ -1013,11 +1030,22 @@ impl AudioManager {}}+ if self.status().await != AudioManagerStatus::Running+ || self+ .user_disabled_devices+ .read()+ .await+ .contains(&device.to_string())+ {+ self.stop_device_recording_inner(device).await?;+ return Ok(());+ }+// The meeting may end while the OS backend is opening the stream. The// pre-start gate cannot close that race, and the monitor cannot see the// stream until its recording handle is registered.if self.meetings_only_capture_waiting().await {- self.stop_device_recording(device).await?;+ self.stop_device_recording_inner(device).await?;debug!("stopped newly-opened audio device after meeting ended during startup: {}",device@@ -1028,7 +1056,7 @@ impl AudioManager {// Close the race where meeting detection changes while the backend is// opening a normal stream. Session streams never pass through here.if self.meeting_piggyback_owns_normal_capture().await {- self.stop_device_recording(device).await?;+ self.stop_device_recording_inner(device).await?;info!("smart recording engaged mid-open — stopped normal audio device: {}",device@@ -1041,7 +1069,7 @@ impl AudioManager {// cannot see this stream until its recording handle is registered.#[cfg(target_os = "macos")]if screenpipe_config::should_pause_audio_for_lock() {- self.stop_device_recording(device).await?;+ self.stop_device_recording_inner(device).await?;debug!("stopped newly-opened audio device after screen locked during startup: {}",device@@ -1078,6 +1106,23 @@ impl AudioManager {device: &AudioDevice,tap_pids: Option<Vec<i32>>,) -> Result<()> {+ let manager = self.clone();+ let target = device.clone();+ self.device_manager+ .run_device_operation(device, async move {+ manager.start_session_device_inner(&target, tap_pids).await+ })+ .await+ }++ async fn start_session_device_inner(+ &self,+ device: &AudioDevice,+ tap_pids: Option<Vec<i32>>,+ ) -> Result<()> {+ if self.status().await != AudioManagerStatus::Running {+ return Err(anyhow!("audio manager is stopped"));+ }if self.options.read().await.is_disabled {return Err(anyhow!("audio capture is disabled"));}@@ -1139,6 +1184,21 @@ impl AudioManager {}}+ if self.status().await != AudioManagerStatus::Running+ || self+ .user_disabled_devices+ .read()+ .await+ .contains(&device.to_string())+ {+ self.session_devices+ .write()+ .unwrap()+ .remove(&device.to_string());+ self.stop_device_recording_inner(device).await?;+ return Err(anyhow!("device {} capture was stopped during startup", device));+ }+// The meeting can end while the backend is opening the stream. Remove// session ownership before stopping so a racing callback cannot bypass// the persistence gate after the edge.@@ -1151,7 +1211,7 @@ impl AudioManager {.write().unwrap().remove(&device.to_string());- self.stop_device_recording(device).await?;+ self.stop_device_recording_inner(device).await?;debug!("stopped newly-opened meeting-session audio device after the meeting ended during startup: {}",device@@ -1167,7 +1227,7 @@ impl AudioManager {.write().unwrap().remove(&device.to_string());- self.stop_device_recording(device).await?;+ self.stop_device_recording_inner(device).await?;debug!("stopped newly-opened meeting-session audio device after screen locked during startup: {}",device@@ -1198,11 +1258,18 @@ impl AudioManager {/// Tear down a meeting-session stream. Never touches `enabled_devices`.pub async fn stop_session_device(&self, device: &AudioDevice) -> Result<()> {- self.session_devices- .write()- .unwrap()- .remove(&device.to_string());- self.stop_device_recording(device).await+ let manager = self.clone();+ let target = device.clone();+ self.device_manager+ .run_device_operation(device, async move {+ manager+ .session_devices+ .write()+ .unwrap()+ .remove(&target.to_string());+ manager.stop_device_recording_inner(&target).await+ })+ .await}/// Snapshot of the currently-registered meeting-session device names.@@ -1909,22 +1976,14 @@ impl AudioManager {output_devices.len());+ // Publish the gate before teardown so recovery cannot reopen an output.+ *self.drm_stopped_devices.write().await = output_devices.clone();for device in &output_devices {- // Stop the underlying stream- if let Err(e) = self.device_manager.stop_device(device).await {+ if let Err(e) = self.stop_device_recording(device).await {warn!("DRM: failed to stop audio device {}: {:?}", device, e);}-- // Abort the recording task- if let Some(pair) = self.recording_handles.get(device) {- pair.value().lock().await.abort();- }- self.recording_handles.remove(device);}- // Store stopped devices for later restart- *self.drm_stopped_devices.write().await = output_devices;-Ok(())}@@ -2409,14 +2468,7 @@ impl AudioManager {Err(_) => return Err(anyhow!("Device {} not found", device_name)),};- // Remove from recording handles- if let Some((_, handle)) = self.recording_handles.remove(&device) {- // Abort the handle if somehow still running- handle.lock().await.abort();- }-- // Stop the device in device manager (clears streams and states)- let _ = self.device_manager.stop_device(&device).await;+ self.stop_device_recording(&device).await?;debug!("cleaned up stale device {} for restart", device_name);diff --git a/crates/screenpipe-audio/src/core/stream.rs b/crates/screenpipe-audio/src/core/stream.rsindex 16266de88..84f875b85 100644--- a/crates/screenpipe-audio/src/core/stream.rs+++ b/crates/screenpipe-audio/src/core/stream.rs@@ -610,54 +610,47 @@ impl AudioStream {}pub async fn stop(&self) -> Result<()> {+ self.stop_with_timeout(std::time::Duration::from_secs(3))+ .await+ }++ async fn stop_with_timeout(&self, timeout: std::time::Duration) -> Result<()> {self.is_disconnected.store(true, Ordering::Relaxed);+ let deadline = tokio::time::Instant::now() + timeout;- // PulseAudio path: the capture thread checks is_disconnected and exits- // on its own — no stream_control message needed.#[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]{- // Sources without a cpal control channel (e.g. `from_wav`,- // `from_sender_for_test`) drop the receiver, so the send/recv- // here will error. That's expected — `is_disconnected` already- // signals the playback task to exit. Don't propagate this error.+ // Queue teardown without an unbounded acknowledgement wait. The+ // worker handle below proves native pause/drop actually completed.let (control, rx) = StreamControl::stop(StopMode::Immediate);if self.stream_control.send(control).is_ok() {- let _ = rx.await;+ tokio::time::timeout_at(deadline, rx)+ .await+ .map_err(|_| {+ anyhow::anyhow!("audio device {} teardown timed out", self.device)+ })?+ .ok();}}- if let Some(thread_arc) = self.stream_thread.as_ref() {- let thread_arc_clone = thread_arc.clone();- tokio::task::spawn_blocking(move || {- let mut thread_guard = thread_arc_clone.blocking_lock();- if let Some(join_handle) = thread_guard.take() {- // Wait up to 3s for the playback task to exit naturally so cpal- // stream.pause()+drop() can run before the stream resources go- // away — aborting mid-callback is what races the CoreAudio IO- // thread into UAF (issue #3261). If the task is wedged in cpal- // / CoreAudio though, fall back to abort() so stop() can't hang- // forever on quit/device-switch.- let deadline =- std::time::Instant::now() + std::time::Duration::from_secs(3);- while !join_handle.is_finished()- && std::time::Instant::now() < deadline- {- std::thread::sleep(std::time::Duration::from_millis(10));- }- if !join_handle.is_finished() {- // Fully-qualified — `use tracing::{error, warn}` above- // is cfg-gated to non-pulseaudio builds, so on linux+- // pulseaudio CI (Release CLI) `warn!` is out of scope.- tracing::warn!(- "audio stream thread did not exit within 3s; aborting (potential cpal/CoreAudio wedge)"- );- join_handle.abort();- }- }- })- .await?;+ if let Some(thread) = self.stream_thread.as_ref() {+ let mut worker = tokio::time::timeout_at(deadline, thread.lock())+ .await+ .map_err(|_| {+ anyhow::anyhow!("audio device {} teardown is still pending", self.device)+ })?;+ if let Some(handle) = worker.as_mut() {+ // Poll by mutable reference: timing out must retain ownership.+ // Aborting spawn_blocking does not cancel native CoreAudio work.+ let result = tokio::time::timeout_at(deadline, handle)+ .await+ .map_err(|_| {+ anyhow::anyhow!("audio device {} worker did not exit", self.device)+ })?;+ worker.take();+ result?;+ }}-Ok(())}@@ -1044,6 +1037,56 @@ mod from_wav_tests {use super::*;use std::time::Duration;+ #[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]+ #[tokio::test]+ async fn teardown_timeout_retains_native_worker_and_allows_later_cleanup() {+ let device = Arc::new(AudioDevice::new(+ "test mic".into(),+ super::super::device::DeviceType::Input,+ ));+ let (mut stream, _tx) = AudioStream::from_sender_for_test(device, 48_000, 1);+ let (control_tx, control_rx) = mpsc::channel();+ let (release_tx, release_rx) = mpsc::channel();+ stream.stream_control = control_tx;+ stream.stream_thread = Some(Arc::new(tokio::sync::Mutex::new(Some(+ tokio::task::spawn_blocking(move || {+ release_rx.recv().unwrap();+ if let Ok(StreamControl::Stop {+ _response: response,+ ..+ }) = control_rx.recv()+ {+ response.send(()).ok();+ }+ }),+ ))));+ let error = tokio::time::timeout(+ Duration::from_secs(1),+ stream.stop_with_timeout(Duration::from_millis(50)),+ )+ .await+ .expect("stop must be bounded")+ .unwrap_err();+ assert!(error.to_string().contains("teardown timed out"));+ assert!(stream.is_disconnected());+ assert!(stream+ .stream_thread+ .as_ref()+ .unwrap()+ .lock()+ .await+ .is_some());+ release_tx.send(()).unwrap();+ stream.stop().await.unwrap();+ assert!(stream+ .stream_thread+ .as_ref()+ .unwrap()+ .lock()+ .await+ .is_none());+ }+#[cfg(not(all(target_os = "linux", feature = "pulseaudio")))]#[test]fn detects_windows_mic_access_denied_without_hiding_other_failures() {diff --git a/crates/screenpipe-audio/src/device/device_manager.rs b/crates/screenpipe-audio/src/device/device_manager.rsindex ccf4f1755..ea471ab2d 100644--- a/crates/screenpipe-audio/src/device/device_manager.rs+++ b/crates/screenpipe-audio/src/device/device_manager.rs@@ -12,6 +12,8 @@ use std::sync::{atomic::{AtomicBool, Ordering},Arc,};+use std::{future::Future, time::Duration};+use tokio::sync::Mutex;use tracing::{debug, info, warn};#[derive(Clone, Copy)]@@ -27,6 +29,7 @@ impl DeviceResolution {}pub struct DeviceManager {+ operations: DashMap<AudioDevice, Arc<Mutex<()>>>,streams: Arc<DashMap<AudioDevice, Arc<AudioStream>>>,states: Arc<DashMap<AudioDevice, Arc<AtomicBool>>>,/// When true, System Audio (output) uses the CoreAudio Process Tap path@@ -54,6 +57,7 @@ impl DeviceManager {let states = Arc::new(DashMap::new());Ok(Self {+ operations: DashMap::new(),streams,states,use_coreaudio_tap: AtomicBool::new(use_coreaudio_tap),@@ -63,6 +67,34 @@ impl DeviceManager {})}+ /// Serialize the complete stream/recording-handle transition. Once admitted,+ /// an operation owns its guard in a task so a cancelled API request or monitor+ /// cannot release the device while native startup/teardown is still running.+ pub(crate) async fn run_device_operation<F>(+ &self,+ device: &AudioDevice,+ operation: F,+ ) -> Result<()>+ where+ F: Future<Output = Result<()>> + Send + 'static,+ {+ let lock = self.operations.entry(device.clone()).or_default().clone();+ let guard = tokio::time::timeout(Duration::from_secs(10), lock.lock_owned())+ .await+ .map_err(|_| anyhow!("device {device} is still completing a previous operation"))?;+ let task = tokio::spawn(async move {+ let _guard = guard;+ operation.await+ });+ tokio::time::timeout(Duration::from_secs(10), task)+ .await+ .map_err(|_| {+ anyhow!(+ "device {device} operation timed out; native teardown/startup is still owned"+ )+ })??+ }+pub fn configure_backend_flags(&self,use_coreaudio_tap: bool,@@ -155,6 +187,17 @@ impl DeviceManager {tap_pids: Option<Vec<i32>>,resolution: DeviceResolution,) -> Result<()> {+ // A published stream owns the native device even before its recording+ // loop has set is_running. Never replace that stream during startup.+ if let Some(stream) = self.stream(device) {+ if !stream.is_disconnected() {+ return Err(anyhow!("Device {} already running.", device));+ }+ // A timed-out stop retains its worker. Retry teardown before opening+ // a replacement; abort() cannot stop a running spawn_blocking task.+ self.stop_device(device).await?;+ }+// Generic starts validate against the inventory. Meeting-session// starts carry stronger, live process-resolution evidence and bypass// the cached inventory (the tap is virtual; a resolved mic may have@@ -203,15 +246,25 @@ impl DeviceManager {.unwrap_or(false)}- pub async fn stop_all_devices(&self) -> Result<()> {- for pair in self.states.iter() {- let device = pair.key();- let _ = self.stop_device(device).await;+ pub async fn stop_all_devices(self: &Arc<Self>) -> Result<()> {+ // Include admitted starts that have not published their stream yet.+ let mut devices: Vec<_> = self.operations.iter().map(|p| p.key().clone()).collect();+ devices.extend(self.streams.iter().map(|p| p.key().clone()));+ let mut seen = std::collections::HashSet::new();+ let mut failure = None;+ for device in devices.into_iter().filter(|d| seen.insert(d.clone())) {+ let manager = self.clone();+ let target = device.clone();+ if let Err(e) = self+ .run_device_operation(&device, async move { manager.stop_device(&target).await })+ .await+ {+ failure = Some(e);+ }+ }+ if let Some(e) = failure {+ return Err(e);}-- self.states.clear();- self.streams.clear();-Ok(())}@@ -240,8 +293,10 @@ impl DeviceManager {is_running.store(false, Ordering::Relaxed)}- if let Some(p) = self.streams.get(device) {- let _ = p.value().stop().await;+ // Never hold a DashMap guard across native teardown. Retain the stream+ // on timeout so a later start cannot orphan a still-running worker.+ if let Some(stream) = self.stream(device) {+ stream.stop().await?;}self.streams.remove(device);@@ -260,6 +315,107 @@ mod tests {use crate::core::device::DeviceType;use crate::core::stream::AudioStream;+ #[tokio::test]+ async fn published_stream_is_not_reopened_before_recording_handle_registration() {+ let dm = DeviceManager::new(false, false, false).await.unwrap();+ let device = mic();+ let (stream, _tx) = AudioStream::from_sender_for_test(Arc::new(device.clone()), 48_000, 1);+ let stream = Arc::new(stream);+ dm.streams.insert(device.clone(), stream.clone());+ dm.states+ .insert(device.clone(), Arc::new(AtomicBool::new(false)));+ let error = dm.start_process_resolved_device(&device).await.unwrap_err();+ assert!(error.to_string().contains("already running"));+ assert!(Arc::ptr_eq(&stream, &dm.stream(&device).unwrap()));+ dm.stop_device(&device).await.unwrap();+ }++ #[tokio::test]+ async fn cancelled_request_keeps_device_owned_until_transition_finishes() {+ let dm = Arc::new(DeviceManager::new(false, false, false).await.unwrap());+ let device = mic();+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();+ let first_manager = dm.clone();+ let first_device = device.clone();+ let first = tokio::spawn(async move {+ first_manager+ .run_device_operation(&first_device, async move {+ entered_tx.send(()).unwrap();+ release_rx.await.unwrap();+ Ok(())+ })+ .await+ });+ entered_rx.await.unwrap();+ first.abort();+ let _ = first.await;++ let (second_tx, mut second_rx) = tokio::sync::oneshot::channel();+ let second_manager = dm.clone();+ let second = tokio::spawn(async move {+ second_manager+ .run_device_operation(&device, async move {+ second_tx.send(()).unwrap();+ Ok(())+ })+ .await+ });+ assert!(+ tokio::time::timeout(Duration::from_millis(50), &mut second_rx)+ .await+ .is_err()+ );+ // The mic's stalled operation must not block independent system audio.+ let output = AudioDevice::new("System Audio".into(), DeviceType::Output);+ tokio::time::timeout(+ Duration::from_secs(1),+ dm.run_device_operation(&output, async { Ok(()) }),+ )+ .await+ .unwrap()+ .unwrap();+ release_tx.send(()).unwrap();+ tokio::time::timeout(Duration::from_secs(1), second_rx)+ .await+ .unwrap()+ .unwrap();+ second.await.unwrap().unwrap();+ }++ #[tokio::test]+ async fn global_stop_waits_for_startup_before_removing_the_stream() {+ let dm = Arc::new(DeviceManager::new(false, false, false).await.unwrap());+ let device = mic();+ let (stream, _tx) = AudioStream::from_sender_for_test(Arc::new(device.clone()), 48_000, 1);+ let stream = Arc::new(stream);+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();+ let owner = dm.clone();+ let starting = dm.clone();+ let target = device.clone();+ let starting_stream = stream.clone();+ let start = tokio::spawn(async move {+ owner.run_device_operation(&target.clone(), async move {+ entered_tx.send(()).unwrap();+ release_rx.await.unwrap();+ starting.streams.insert(target.clone(), starting_stream);+ starting.states.insert(target, Arc::new(AtomicBool::new(true)));+ Ok(())+ }).await+ });+ entered_rx.await.unwrap();+ let stopping = dm.clone();+ let mut stop = tokio::spawn(async move { stopping.stop_all_devices().await });+ assert!(tokio::time::timeout(Duration::from_millis(50), &mut stop).await.is_err());+ release_tx.send(()).unwrap();+ start.await.unwrap().unwrap();+ tokio::time::timeout(Duration::from_secs(1), stop).await.unwrap().unwrap().unwrap();+ assert!(stream.is_disconnected());+ assert!(dm.stream(&device).is_none());+ assert!(!dm.is_running(&device));+ }+#[test]fn process_resolved_meeting_devices_bypass_inventory_validation() {assert!(DeviceResolution::Inventory.requires_inventory());