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(meetings): keep Meet calls alive across /home and suppressed old rooms (SCR-593) (#7612)
Ezra Elletteb9cff1112aff
diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rsindex ebeebe079..806020e47 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/resolve.rs@@ -1079,7 +1079,7 @@ pub(crate) async fn build_candidates(retain_candidates_with_required_call_signal(&mut candidates, profiles, &call_evidence);}- filter_suppressed_candidates(&mut candidates, suppressed_sessions);+ suppress_candidates(&mut candidates, suppressed_sessions, state);let live_candidates: Vec<_> = candidates.iter().filter(|candidate| {diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/suppress.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/suppress.rsindex 82adf60d8..ae679c2ed 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/suppress.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/suppress.rs@@ -131,6 +131,48 @@ pub(crate) fn candidate_session_key(candidate: &ResolvedMeetingCandidate) -> Opt}}+/// Applies session suppression for one detector tick. A suppressed room on the+/// live meeting's own audio session still proves that session holds the mic, so+/// it is kept as presence-only evidence: it can neither start nor switch a+/// meeting, but it cannot end the current one either.+pub(crate) fn suppress_candidates(+ candidates: &mut Vec<ResolvedMeetingCandidate>,+ suppressed_sessions: &[SuppressedSession],+ state: &AudioProcessMeetingState,+) {+ let live_key = match state {+ AudioProcessMeetingState::Active { session_key, .. }+ | AudioProcessMeetingState::Ending { session_key, .. } => Some(session_key),+ _ => None,+ };+ for candidate in candidates.iter_mut() {+ let keep_presence = matches!(candidate, ResolvedMeetingCandidate::Browser { .. })+ && live_key.is_some_and(|key| candidate_session_key(candidate) == Some(key))+ && candidate_is_suppressed(candidate, suppressed_sessions);+ if let (+ true,+ ResolvedMeetingCandidate::Browser {+ platform,+ browser_app,+ session_key,+ first_seen_at,+ process,+ ..+ },+ ) = (keep_presence, &*candidate)+ {+ debug!("audio-process meeting detector: suppressed {platform} room on the live session kept as presence only");+ *candidate = ResolvedMeetingCandidate::UnresolvedBrowser {+ browser_app: browser_app.clone(),+ session_key: session_key.clone(),+ first_seen_at: *first_seen_at,+ process: process.clone(),+ };+ }+ }+ filter_suppressed_candidates(candidates, suppressed_sessions);+}+pub(crate) fn filter_suppressed_candidates(candidates: &mut Vec<ResolvedMeetingCandidate>,suppressed_sessions: &[SuppressedSession],diff --git a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rsindex 57f014820..3e76c45a6 100644--- a/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/audio_process/tests.rs@@ -2754,7 +2754,7 @@ fn known_room_refuses_a_different_calendar_room() {chrono::Duration::minutes(30),&[],);- event.meeting_url = Some("https://meet.google.com/wrong-room-id".to_string());+ event.meeting_url = Some("https://meet.google.com/zzz-zzzz-zzz".to_string());assert!(find_calendar_event_for_meeting(&[event],@@ -4648,3 +4648,322 @@ async fn failed_room_change_close_restores_the_old_ending_state_for_retry() {} if url == ROOM_A && seen == first_seen_at && since == changed_at));}++// --- SCR-593: Meet /home must not split the call, and suppression must not end it ---++#[test]+fn meet_navigation_pages_are_not_room_identities() {+ use crate::meeting_watcher::shared::calendar::meeting_url_identity;+ for url in [+ "https://meet.google.com/home?authuser=0",+ "https://meet.google.com/landing",+ "https://meet.google.com/new",+ "https://meet.google.com/",+ ] {+ assert_eq!(meeting_url_identity(url), None, "{url}");+ }+ assert_eq!(+ meeting_url_identity(ROOM_A).as_deref(),+ Some(ROOM_A_IDENTITY)+ );+}++#[test]+fn meet_home_page_does_not_split_or_end_the_live_call() {+ let process = chrome_process();+ let t0 = Instant::now();+ let rooms = HashSet::new();+ let policy = RoomChangePolicy {+ confirm_window: ROOM_CHANGE_CONFIRM_WINDOW,+ prompt_window: ROOM_CHANGE_PROMPT_WINDOW,+ calendar_confirm_window: ROOM_CHANGE_CALENDAR_CONFIRM_WINDOW,+ calendar_room_identities: &rooms,+ calendar_boundary_crossed: false,+ };+ let mut tracker = RoomChangeTracker::default();+ let mut state = active_meet(113, &process, ROOM_A, t0);+ let urls = [ROOM_A, "https://meet.google.com/home?authuser=0", ROOM_A];+ for (tick, url) in urls.into_iter().enumerate() {+ let now = t0 + Duration::from_secs(tick as u64 + 1);+ let candidates = vec![meet_candidate(&process, url, now)];+ let room_change = detect_room_change(&state, &candidates, &mut tracker, now, &policy);+ assert!(+ room_change.is_none(),+ "{url} split the call: {room_change:?}"+ );+ let (next, action) = advance_audio_process_state(+ state,+ &candidates,+ &candidates,+ now,+ CANDIDATE_CONFIRM_WINDOW,+ ENDING_GRACE,+ );+ assert!(action.is_none(), "{url}: {action:?}");+ assert!(+ matches!(&next, AudioProcessMeetingState::Active { meeting_id: 113, meeting_url: Some(u), .. } if u == ROOM_A),+ "{url}: {next:?}"+ );+ state = next;+ }+}++#[test]+fn suppressed_old_room_on_the_live_session_keeps_the_current_call_alive() {+ let process = chrome_process();+ let key = ProcessKey::from_process(&process).unwrap();+ let t0 = Instant::now();+ let now = t0 + Duration::from_secs(1);+ let state = active_meet(114, &process, ROOM_B, t0);+ let suppressed = vec![SuppressedSession {+ session_key: key,+ platform: Some("Google Meet".to_string()),+ meeting_url: Some(ROOM_A.to_string()),+ }];++ // The live resolver emits one candidate per process; here it points back+ // to the suppressed room A while the same session still holds the mic.+ let mut candidates = vec![meet_candidate(&process, ROOM_A, now)];+ suppress_candidates(&mut candidates, &suppressed, &state);+ assert!(+ candidates+ .iter()+ .all(|candidate| candidate.resolved_session().is_none()),+ "a suppressed room must not be able to start or switch a meeting: {candidates:?}"+ );+ let rooms = HashSet::new();+ let mut tracker = RoomChangeTracker::default();+ assert!(detect_room_change(+ &state,+ &candidates,+ &mut tracker,+ now,+ &room_policy(&rooms, false)+ )+ .is_none());+ let (next, action) = advance_audio_process_state(+ state,+ &candidates,+ &candidates,+ now,+ CANDIDATE_CONFIRM_WINDOW,+ ENDING_GRACE,+ );+ assert!(action.is_none(), "{action:?}");+ assert!(+ matches!(&next, AudioProcessMeetingState::Active { meeting_id: 114, meeting_url: Some(u), .. } if u == ROOM_B),+ "the live call must stay active: {next:?}"+ );++ // With no live meeting, suppression still blocks a restart.+ let mut idle_candidates = vec![meet_candidate(&process, ROOM_A, now)];+ suppress_candidates(+ &mut idle_candidates,+ &suppressed,+ &AudioProcessMeetingState::Idle,+ );+ assert!(idle_candidates.is_empty());+}++async fn insert_chrome_frame(db: &DatabaseManager, url: &str, offset_ms: i64) {+ let at = Utc::now() + chrono::Duration::milliseconds(offset_ms);+ let writer = db.coordinated_writer().lock().await.unwrap();+ sqlx::query(+ "INSERT INTO frames (timestamp, app_name, window_name, browser_url) \+ VALUES (?1, 'Google Chrome', 'Meet', ?2)",+ )+ .bind(at.format("%Y-%m-%dT%H:%M:%S%.3f+00:00").to_string())+ .bind(url)+ .execute(writer.pool())+ .await+ .unwrap();+}++struct PipelineHarness {+ db: DatabaseManager,+ _dir: tempfile::TempDir,+ process: AudioInputProcess,+ tracker: StickyProcessTracker,+ room_tracker: RoomChangeTracker,+ suppressed: Vec<SuppressedSession>,+ state: AudioProcessMeetingState,+ manual_meeting: tokio::sync::RwLock<Option<i64>>,+ flap_count: u32,+ in_meeting: AtomicBool,+}++impl PipelineHarness {+ /// A Google Meet meeting already live in `room` on Chrome's audio session.+ async fn live_in(room: &str, at: Instant) -> Self {+ let (dir, db) = setup_db().await;+ let process = chrome_process();+ let mut harness = Self {+ db,+ _dir: dir,+ process: process.clone(),+ tracker: StickyProcessTracker::new(STICKY_PROCESS_WINDOW),+ room_tracker: RoomChangeTracker::default(),+ suppressed: Vec::new(),+ state: AudioProcessMeetingState::Idle,+ manual_meeting: tokio::sync::RwLock::new(None),+ flap_count: 0,+ in_meeting: AtomicBool::new(false),+ };+ harness+ .apply(+ AudioProcessStateAction::StartMeeting {+ platform: "Google Meet".to_string(),+ session_key: ProcessKey::from_process(&process).unwrap(),+ meeting_url: Some(room.to_string()),+ first_seen_at: at,+ is_browser: true,+ pid: process.pid,+ bundle_id: process.bundle_id.clone(),+ },+ at,+ )+ .await;+ harness+ }++ async fn apply(&mut self, action: AudioProcessStateAction, now: Instant) {+ apply_state_action(+ action,+ &self.db,+ &self.manual_meeting,+ &mut self.state,+ &mut self.suppressed,+ &mut self.flap_count,+ &self.in_meeting,+ &None,+ None,+ None,+ &[],+ now,+ Utc::now(),+ )+ .await;+ }++ /// One detector-loop tick with Chrome still holding the mic.+ async fn tick(&mut self, now: Instant) {+ let profiles = crate::meeting_watcher::shared::profiles::load_detection_profiles();+ let processes = vec![self.process.clone()];+ let (candidates, live_candidates) = build_candidates(+ &self.db,+ &profiles,+ &[],+ &processes,+ &mut self.tracker,+ &mut self.suppressed,+ &self.state,+ now,+ )+ .await;+ let rooms = HashSet::new();+ let policy = RoomChangePolicy {+ confirm_window: ROOM_CHANGE_CONFIRM_WINDOW,+ prompt_window: ROOM_CHANGE_PROMPT_WINDOW,+ calendar_confirm_window: ROOM_CHANGE_CALENDAR_CONFIRM_WINDOW,+ calendar_room_identities: &rooms,+ calendar_boundary_crossed: false,+ };+ let room_change = detect_room_change(+ &self.state,+ &candidates,+ &mut self.room_tracker,+ now,+ &policy,+ );+ let current = std::mem::replace(&mut self.state, AudioProcessMeetingState::Idle);+ let (next, action) = match room_change {+ Some(action) => (AudioProcessMeetingState::Idle, Some(action)),+ None => advance_audio_process_state(+ current,+ &live_candidates,+ &candidates,+ now,+ CANDIDATE_CONFIRM_WINDOW,+ ENDING_GRACE,+ ),+ };+ self.state = next;+ if let Some(action) = action {+ self.apply(action, now).await;+ }+ }++ fn live_meeting(&self) -> Option<(i64, Option<&str>)> {+ match &self.state {+ AudioProcessMeetingState::Active {+ meeting_id,+ meeting_url,+ ..+ } => Some((*meeting_id, meeting_url.as_deref())),+ _ => None,+ }+ }+}++#[tokio::test]+async fn pipeline_meet_home_round_trip_keeps_the_original_meeting_recording() {+ let t0 = Instant::now();+ let mut h = PipelineHarness::live_in(ROOM_A, t0).await;+ let (meeting_a, _) = h.live_meeting().expect("meeting A live");+ let urls = [ROOM_A, "https://meet.google.com/home?authuser=0", ROOM_A];+ for (tick, url) in urls.into_iter().enumerate() {+ insert_chrome_frame(&h.db, url, tick as i64).await;+ h.tick(t0 + Duration::from_secs(tick as u64 + 1)).await;+ assert_eq!(+ h.live_meeting(),+ Some((meeting_a, Some(ROOM_A))),+ "tick {tick} ({url}): {:?}",+ h.state+ );+ assert!(h.in_meeting.load(Ordering::Relaxed), "tick {tick}");+ }+ let row = h.db.get_meeting_by_id(meeting_a).await.unwrap();+ assert!(row.meeting_end.is_none(), "meeting A must not be closed");+ assert!(+ h.db.get_meeting_by_id(meeting_a + 1).await.is_err(),+ "no second meeting row"+ );+}++#[tokio::test]+async fn pipeline_suppressed_old_room_on_the_live_session_keeps_the_new_meeting() {+ let t0 = Instant::now();+ let mut h = PipelineHarness::live_in(ROOM_A, t0).await;+ let (meeting_a, _) = h.live_meeting().expect("meeting A live");++ insert_chrome_frame(&h.db, ROOM_A, 0).await;+ h.tick(t0 + Duration::from_secs(1)).await;+ insert_chrome_frame(&h.db, ROOM_B, 1).await;+ h.tick(t0 + Duration::from_secs(2)).await;+ let (meeting_b, url) = h.live_meeting().expect("room change starts meeting B");+ assert_ne!(meeting_b, meeting_a);+ assert_eq!(url, Some(ROOM_B));+ assert_eq!(+ h.db.meeting_end_reason(meeting_a).await.unwrap().as_deref(),+ Some(MEETING_END_REASON_ROOM_CHANGED)+ );++ // The sole candidate now points back to suppressed room A while the same+ // Chrome session keeps the mic.+ insert_chrome_frame(&h.db, ROOM_A, 2).await;+ h.tick(t0 + Duration::from_secs(3)).await;+ assert_eq!(+ h.live_meeting(),+ Some((meeting_b, Some(ROOM_B))),+ "the live call must not end: {:?}",+ h.state+ );+ assert!(h.in_meeting.load(Ordering::Relaxed));+ assert!(h+ .db+ .get_meeting_by_id(meeting_b)+ .await+ .unwrap()+ .meeting_end+ .is_none());+}diff --git a/crates/screenpipe-engine/src/meeting_watcher/shared/calendar.rs b/crates/screenpipe-engine/src/meeting_watcher/shared/calendar.rsindex 983ecd8fd..52150c9c5 100644--- a/crates/screenpipe-engine/src/meeting_watcher/shared/calendar.rs+++ b/crates/screenpipe-engine/src/meeting_watcher/shared/calendar.rs@@ -162,6 +162,8 @@ fn normalized_url(raw: &str) -> Option<Url> {/// notice the browser moved from one conference room to another (see/// `audio_process::room_change`).pub fn meeting_url_identity(raw: &str) -> Option<String> {+ use crate::meeting_watcher::audio_process::arc_window_title_meet_code;+let parsed = normalized_url(raw)?;let host = parsed.host_str()?@@ -176,7 +178,11 @@ pub fn meeting_url_identity(raw: &str) -> Option<String> {.collect();if host == "meet.google.com" {- return segments.first().map(|room| format!("google-meet:{room}"));+ // Only a meeting code is a room; /home, /landing and /new are navigation pages.+ return segments+ .first()+ .and_then(|room| arc_window_title_meet_code(room))+ .map(|room| format!("google-meet:{room}"));}if host == "zoom.us" || host.ends_with(".zoom.us") {