Fix external STT server lifecycle to ensure single instance and proper cleanup (#2050)

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: yujonglee

Cargo.lock

@@ -7,3 +7,4 @@ edition = "2021"
 mac_address2 = "2.0.2"
 machine-uid = "0.5.4"
 sysinfo = { workspace = true }
+tokio = { workspace = true, features = ["time"] }

crates/host/Cargo.toml

@@ -22,6 +22,46 @@ pub enum ProcessMatcher {
     Sidecar,
 }
 
+pub fn has_processes_matching(matcher: &ProcessMatcher) -> bool {
+    let target = match matcher {
+        ProcessMatcher::Name(name) => name.clone(),
+        ProcessMatcher::Sidecar => "stt".to_string(),
+    };
+
+    let mut sys = sysinfo::System::new();
+    sys.refresh_processes(sysinfo::ProcessesToUpdate::All, true);
+
+    for (_, process) in sys.processes() {
+        let process_name = process.name().to_string_lossy();
+        if process_name.contains(&target) {
+            return true;
+        }
+    }
+
+    false
+}
+
+pub async fn wait_for_processes_to_terminate(
+    matcher: ProcessMatcher,
+    max_wait_ms: u64,
+    check_interval_ms: u64,
+) -> bool {
+    if check_interval_ms == 0 {
+        return false;
+    }
+
+    let max_iterations = max_wait_ms / check_interval_ms;
+
+    for _ in 0..max_iterations {
+        if !has_processes_matching(&matcher) {
+            return true;
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(check_interval_ms)).await;
+    }
+
+    !has_processes_matching(&matcher)
+}
+
 pub fn kill_processes_by_matcher(matcher: ProcessMatcher) -> u16 {
     let target = match matcher {
         ProcessMatcher::Name(name) => name,

crates/host/src/lib.rs

@@ -125,6 +125,10 @@ pub async fn stop_stt_server(
         ServerType::External => wait_for_actor_shutdown(ExternalSTTActor::name()).await,
     }
 
+    if matches!(server_type, ServerType::External) {
+        wait_for_process_cleanup().await;
+    }
+
     Ok(())
 }
 
@@ -144,3 +148,18 @@ async fn wait_for_actor_shutdown(actor_name: ractor::ActorName) {
         tokio::time::sleep(std::time::Duration::from_millis(100)).await;
     }
 }
+
+async fn wait_for_process_cleanup() {
+    let process_terminated =
+        hypr_host::wait_for_processes_to_terminate(hypr_host::ProcessMatcher::Sidecar, 5000, 100)
+            .await;
+
+    if !process_terminated {
+        tracing::warn!("external_stt_process_did_not_terminate_in_time");
+        let killed = hypr_host::kill_processes_by_matcher(hypr_host::ProcessMatcher::Sidecar);
+        if killed > 0 {
+            tracing::info!("force_killed_stt_processes: {}", killed);
+            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+        }
+    }
+}