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(windows): give Enterprise priority over running Consumer (#7543)
Ezra Ellettef2a57e2a36a0
diff --git a/apps/screenpipe-app-tauri/src-tauri/Cargo.toml b/apps/screenpipe-app-tauri/src-tauri/Cargo.tomlindex 6617edb6c..e5f11b154 100644--- a/apps/screenpipe-app-tauri/src-tauri/Cargo.toml+++ b/apps/screenpipe-app-tauri/src-tauri/Cargo.toml@@ -261,6 +261,7 @@ windows = { version = "0.58", features = ["Win32_System_ErrorReporting","Win32_System_Registry","Win32_System_Threading",+ "Win32_System_RemoteDesktop","Win32_Security_Cryptography",# GetLastInputInfo/GetTickCount for the recording-health user-presence tier"Win32_UI_Input_KeyboardAndMouse",diff --git a/apps/screenpipe-app-tauri/src-tauri/src/diagnostic_logs.rs b/apps/screenpipe-app-tauri/src-tauri/src/diagnostic_logs.rsindex 6d68708e9..18a45e6f9 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/diagnostic_logs.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/diagnostic_logs.rs@@ -79,6 +79,7 @@ fn owned_log_files(files: Vec<LogFile>) -> Vec<LogFile> {fn is_screenpipe_owned_log_name(name: &str) -> bool {crate::log_files::is_panic_log(name)|| name == crate::recording::recovery_log::LOG_NAME+ || is_enterprise_takeover_log(name)|| crate::update_diagnostics::is_update_log(name)|| matches!(name,@@ -92,6 +93,16 @@ fn is_screenpipe_owned_log_name(name: &str) -> bool {|| is_dated_rolling_log(name, "screenpipe-app.")}+#[cfg(target_os = "windows")]+fn is_enterprise_takeover_log(name: &str) -> bool {+ crate::windows_enterprise_takeover::is_takeover_log(name)+}++#[cfg(not(target_os = "windows"))]+fn is_enterprise_takeover_log(_name: &str) -> bool {+ false+}+fn is_dated_rolling_log(name: &str, prefix: &str) -> bool {let Some(rest) = name.strip_prefix(prefix) else {return false;diff --git a/apps/screenpipe-app-tauri/src-tauri/src/log_files.rs b/apps/screenpipe-app-tauri/src-tauri/src/log_files.rsindex 274920559..8ad77183f 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/log_files.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/log_files.rs@@ -127,6 +127,7 @@ pub(crate) async fn collect_log_files(dirs: &[PathBuf]) -> Vec<LogFile> {.is_some_and(|name| {is_panic_log(name)|| name == crate::recording::recovery_log::LOG_NAME+ || is_enterprise_takeover_log(name)|| crate::update_diagnostics::is_update_log(name)}),std::cmp::Reverse(@@ -163,6 +164,16 @@ pub(crate) async fn collect_log_files(dirs: &[PathBuf]) -> Vec<LogFile> {.collect()}+#[cfg(target_os = "windows")]+fn is_enterprise_takeover_log(name: &str) -> bool {+ crate::windows_enterprise_takeover::is_takeover_log(name)+}++#[cfg(not(target_os = "windows"))]+fn is_enterprise_takeover_log(_name: &str) -> bool {+ false+}+/// Push log entries from a single directory into `entries`, deduping by/// canonical path via `seen`. A directory that can't be opened is logged and/// skipped rather than propagated as an error.diff --git a/apps/screenpipe-app-tauri/src-tauri/src/main.rs b/apps/screenpipe-app-tauri/src-tauri/src/main.rsindex e831ac401..6f513cb9f 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/main.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/main.rs@@ -154,6 +154,8 @@ mod workflows_runtime;mod workflows_media;mod windows_ca_bundle;#[cfg(target_os = "windows")]+mod windows_enterprise_takeover;+#[cfg(target_os = "windows")]mod windows_crash_dump;#[cfg(target_os = "windows")]mod windows_overlay;@@ -621,7 +623,27 @@ async fn main() {.ok().and_then(|v| v.parse().ok()).unwrap_or(11435);- if let Ok(resp) = reqwest::Client::new()++ #[cfg(all(target_os = "windows", feature = "enterprise-build"))]+ let enterprise_duplicate = {+ let api_port = std::env::var("SCREENPIPE_PORT")+ .ok()+ .and_then(|v| v.parse().ok())+ .unwrap_or_else(|| recording::LocalApiContext::default().port);+ match windows_enterprise_takeover::take_over_screenpipe_owners(focus_port, api_port)+ .await+ {+ Ok(windows_enterprise_takeover::TakeoverOutcome::SameExecutable) => true,+ Ok(windows_enterprise_takeover::TakeoverOutcome::NoOwner)+ | Ok(windows_enterprise_takeover::TakeoverOutcome::ReplacedCompetingOwner) => false,+ Err(error) => {+ eprintln!("screenpipe: enterprise takeover failed: {error}");+ std::process::exit(1);+ }+ }+ };++ let focus_response = reqwest::Client::new().post(format!("http://127.0.0.1:{}/focus", focus_port)).timeout(std::time::Duration::from_secs(2)).json(&serde_json::json!({@@ -631,16 +653,29 @@ async fn main() {"launchd_job_label": launchd_job_label,})).send()- .await- {+ .await;++ #[cfg(all(target_os = "windows", feature = "enterprise-build"))]+ if enterprise_duplicate {+ eprintln!("screenpipe: Enterprise is already running — focused existing window, exiting.");+ std::process::exit(0);+ }++ if let Ok(resp) = focus_response {if resp.status().is_success() {- eprintln!("screenpipe: another instance is already running — focused existing window, exiting.");- std::process::exit(0);+ #[cfg(not(all(target_os = "windows", feature = "enterprise-build")))]+ {+ eprintln!("screenpipe: another instance is already running — focused existing window, exiting.");+ std::process::exit(0);+ }} else if resp.status() == reqwest::StatusCode::CONFLICT {+ #[cfg(not(all(target_os = "windows", feature = "enterprise-build")))]+ {// The control endpoint answered with Screenpipe's explicit// cross-install rejection. Preserve that healthy instance;// the bind path will report it instead of reclaiming its port.crate::port_conflict::mark_healthy_control_server_present();+ }}}}@@ -2650,6 +2685,7 @@ async fn main() {});}+#[cfg(target_os = "macos")]fn manual_reopen(app: &tauri::AppHandle) {if crate::search_only::is_active() {diff --git a/apps/screenpipe-app-tauri/src-tauri/src/windows_enterprise_takeover.rs b/apps/screenpipe-app-tauri/src-tauri/src/windows_enterprise_takeover.rsnew file mode 100644index 000000000..765e9c5ce--- /dev/null+++ b/apps/screenpipe-app-tauri/src-tauri/src/windows_enterprise_takeover.rs@@ -0,0 +1,632 @@+// screenpipe — AI that knows everything you've seen, said, or heard+// https://screenpipe.com++//! Windows Enterprise takes priority over a consumer instance at the shared+//! control port. This runs before Tauri or the embedded database is opened.++use std::io::{Read, Seek, SeekFrom, Write};+use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};+use std::path::{Path, PathBuf};+use std::sync::Mutex;+use std::time::{Duration, Instant};++use sysinfo::{Pid, PidExt, ProcessExt, System, SystemExt};++pub(crate) const LOG_NAME: &str = "enterprise-takeover.log";+const MAX_LOG_BYTES: u64 = 32 * 1024;+const CREATE_NO_WINDOW: u32 = 0x08000000;+static LOG_WRITER: Mutex<()> = Mutex::new(());++pub(crate) fn is_takeover_log(name: &str) -> bool {+ name == LOG_NAME+ || name+ .strip_prefix("enterprise-takeover.")+ .and_then(|suffix| suffix.strip_suffix(".log"))+ .is_some_and(|rotation| {+ !rotation.is_empty()+ && rotation+ .bytes()+ .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-')+ })+}++#[derive(Debug)]+struct Owner {+ pid: u32,+ exe: PathBuf,+ process: OwnedHandle,+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum TakeoverOutcome {+ NoOwner,+ SameExecutable,+ ReplacedCompetingOwner,+}++pub(crate) async fn take_over_screenpipe_owners(+ control_port: u16,+ api_port: u16,+) -> Result<TakeoverOutcome, String> {+ let mut saw_same_executable = false;+ let mut replaced_competing_owner = false;++ for port in [control_port, api_port] {+ match take_over_screenpipe_owner(port).await? {+ TakeoverOutcome::NoOwner => {}+ TakeoverOutcome::SameExecutable => saw_same_executable = true,+ TakeoverOutcome::ReplacedCompetingOwner => replaced_competing_owner = true,+ }+ }++ if saw_same_executable {+ Ok(TakeoverOutcome::SameExecutable)+ } else if replaced_competing_owner {+ Ok(TakeoverOutcome::ReplacedCompetingOwner)+ } else {+ Ok(TakeoverOutcome::NoOwner)+ }+}++pub(crate) async fn take_over_screenpipe_owner(port: u16) -> Result<TakeoverOutcome, String> {+ let Some(owner) = resolve_verified_owner(port).await.map_err(|cause| {+ record("verification_failed", &cause, "enterprise_start_aborted");+ cause+ })?+ else {+ return Ok(TakeoverOutcome::NoOwner);+ };++ let current_exe = std::env::current_exe()+ .map_err(|error| format!("could not resolve Enterprise executable: {error}"))?;+ if same_path(&owner.exe, ¤t_exe) {+ return Ok(TakeoverOutcome::SameExecutable);+ }++ record(+ "verified_competing_screenpipe",+ &format!("pid={} port={port}", owner.pid),+ "termination_started",+ );++ if let Err(cause) = run_taskkill(owner.pid, false).await {+ record(+ "graceful_termination_failed",+ &format!("pid={} Windows cause: {cause}", owner.pid),+ "force_fallback_required",+ );+ }++ if wait_for_owner_exit(&owner, port, Duration::from_secs(8)).await {+ record(+ "takeover_complete",+ &format!("pid={} port={port} graceful=true", owner.pid),+ "enterprise_start_allowed",+ );+ return Ok(TakeoverOutcome::ReplacedCompetingOwner);+ }++ match process_state(&owner)? {+ ProcessState::Alive => {}+ ProcessState::Exited => {+ let detail = format!(+ "pid={} exited but control port {port} remained occupied",+ owner.pid+ );+ record("termination_failed", &detail, "enterprise_start_aborted");+ return Err(detail);+ }+ }+ run_taskkill(owner.pid, true).await.map_err(|cause| {+ let detail = format!("pid={} forced termination failed: {cause}", owner.pid);+ record("termination_failed", &detail, "enterprise_start_aborted");+ detail+ })?;++ if !wait_for_owner_exit(&owner, port, Duration::from_secs(8)).await {+ let detail = format!(+ "pid={} port={port} remained alive or retained control ownership after timeout",+ owner.pid+ );+ record("termination_timeout", &detail, "enterprise_start_aborted");+ return Err(detail);+ }++ record(+ "takeover_complete",+ &format!("pid={} port={port} graceful=false", owner.pid),+ "enterprise_start_allowed",+ );+ Ok(TakeoverOutcome::ReplacedCompetingOwner)+}++async fn resolve_verified_owner(port: u16) -> Result<Option<Owner>, String> {+ let Some(pid) = listening_pid(port).await? else {+ return Ok(None);+ };+ if pid == std::process::id() {+ return Err("control owner resolved to the launching Enterprise process".into());+ }++ let mut system = System::new();+ let sys_pid = Pid::from_u32(pid);+ system.refresh_process(sys_pid);+ let process = system+ .process(sys_pid)+ .ok_or_else(|| format!("control owner pid={pid} exited before verification"))?;+ let exe = process.exe().to_path_buf();+ let start_time = process.start_time();+ #[cfg(test)]+ let is_current_test_harness = std::env::current_exe()+ .is_ok_and(|current_exe| same_path(&exe, ¤t_exe));+ #[cfg(not(test))]+ let is_current_test_harness = false;+ if !looks_like_screenpipe_exe(&exe) && !is_current_test_harness {+ return Err(format!(+ "refused to terminate pid={pid}: verified control responder executable was not Screenpipe ({})",+ exe.display()+ ));+ }+ verify_current_session(pid)?;+ let process_handle = open_process_for_wait(pid)?;+ system.refresh_process(sys_pid);+ let process = system+ .process(sys_pid)+ .ok_or_else(|| format!("control owner pid={pid} exited while opening its wait handle"))?;+ if process.start_time() != start_time || !same_path(process.exe(), &exe) {+ return Err(format!(+ "control owner pid={pid} changed identity while opening its wait handle"+ ));+ }++ Ok(Some(Owner {+ pid,+ exe,+ process: process_handle,+ }))+}++fn open_process_for_wait(pid: u32) -> Result<OwnedHandle, String> {+ use windows::Win32::System::Threading::{+ OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SYNCHRONIZE,+ };+ let handle = unsafe {+ OpenProcess(+ PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_SYNCHRONIZE,+ false,+ pid,+ )+ }+ .map_err(|error| format!("could not open pid={pid} for stable exit wait: {error}"))?;+ // SAFETY: OpenProcess returned an owned kernel handle, transferred exactly once.+ Ok(unsafe { OwnedHandle::from_raw_handle(handle.0 as *mut _) })+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+enum ProcessState {+ Alive,+ Exited,+}++fn process_state(owner: &Owner) -> Result<ProcessState, String> {+ use windows::Win32::Foundation::{WAIT_FAILED, WAIT_OBJECT_0, WAIT_TIMEOUT};+ use windows::Win32::System::Threading::WaitForSingleObject;+ let result = unsafe {+ WaitForSingleObject(+ windows::Win32::Foundation::HANDLE(owner.process.as_raw_handle()),+ 0,+ )+ };+ match result {+ WAIT_OBJECT_0 => Ok(ProcessState::Exited),+ WAIT_TIMEOUT => Ok(ProcessState::Alive),+ WAIT_FAILED => Err(format!(+ "could not inspect stable process handle for pid={}: {}",+ owner.pid,+ std::io::Error::last_os_error()+ )),+ other => Err(format!(+ "unexpected Windows wait result {other:?} for pid={}",+ owner.pid+ )),+ }+}++fn looks_like_screenpipe_exe(path: &Path) -> bool {+ path.file_name()+ .and_then(|name| name.to_str())+ .is_some_and(|name| {+ let name = name.to_ascii_lowercase();+ name == "screenpipe.exe" || name == "screenpipe-app.exe"+ })+}++fn same_path(left: &Path, right: &Path) -> bool {+ let left = std::fs::canonicalize(left).unwrap_or_else(|_| left.to_path_buf());+ let right = std::fs::canonicalize(right).unwrap_or_else(|_| right.to_path_buf());+ left.to_string_lossy()+ .eq_ignore_ascii_case(&right.to_string_lossy())+}++fn verify_current_session(pid: u32) -> Result<(), String> {+ use windows::Win32::System::{+ RemoteDesktop::ProcessIdToSessionId, Threading::GetCurrentProcessId,+ };+ let mut owner_session = 0;+ let mut current_session = 0;+ unsafe {+ ProcessIdToSessionId(pid, &mut owner_session)+ .map_err(|error| format!("could not inspect owner session: {error}"))?;+ ProcessIdToSessionId(GetCurrentProcessId(), &mut current_session)+ .map_err(|error| format!("could not inspect Enterprise session: {error}"))?;+ }+ if owner_session != current_session {+ return Err(format!(+ "refused to terminate pid={pid} in session {owner_session}; Enterprise is in session {current_session}"+ ));+ }+ Ok(())+}++async fn listening_pid(port: u16) -> Result<Option<u32>, String> {+ use std::os::windows::process::CommandExt;+ let mut command = tokio::process::Command::new("netstat.exe");+ command.args(["-ano", "-p", "tcp"]);+ command.creation_flags(CREATE_NO_WINDOW);+ let output = command+ .output()+ .await+ .map_err(|error| format!("netstat failed: {error}"))?;+ if !output.status.success() {+ return Err(format!("netstat exited with {}", output.status));+ }+ let mut owners = String::from_utf8_lossy(&output.stdout)+ .lines()+ .filter_map(|line| listening_pid_from_line(line, port))+ .collect::<std::collections::HashSet<_>>();+ if owners.is_empty() {+ return Ok(None);+ }+ if owners.len() != 1 {+ return Err(format!(+ "expected one listener for control port {port}, found {}",+ owners.len()+ ));+ }+ let owner = owners.drain().next().expect("one owner checked");+ Ok(Some(owner))+}++fn listening_pid_from_line(line: &str, port: u16) -> Option<u32> {+ let fields: Vec<_> = line.split_whitespace().collect();+ if fields.len() < 5 || !fields[0].eq_ignore_ascii_case("TCP") {+ return None;+ }+ let local_port = fields[1].rsplit(':').next()?.parse::<u16>().ok()?;+ let remote_port = fields[2].rsplit(':').next()?.parse::<u16>().ok()?;+ (local_port == port && remote_port == 0).then(|| fields[4].parse().ok())?+}++async fn run_taskkill(pid: u32, force: bool) -> Result<(), String> {+ use std::os::windows::process::CommandExt;+ let mut command = tokio::process::Command::new("taskkill.exe");+ if force {+ command.arg("/F");+ }+ command.args(["/PID", &pid.to_string()]);+ command.creation_flags(CREATE_NO_WINDOW);+ let output = command+ .output()+ .await+ .map_err(|error| format!("taskkill could not start: {error}"))?;+ if output.status.success() {+ Ok(())+ } else {+ Err(format!(+ "taskkill exited {}: {}",+ output.status,+ String::from_utf8_lossy(&output.stderr).trim()+ ))+ }+}++async fn wait_for_owner_exit(owner: &Owner, port: u16, timeout: Duration) -> bool {+ let started = Instant::now();+ while started.elapsed() < timeout {+ let process_gone = match process_state(owner) {+ Ok(ProcessState::Exited) => true,+ Ok(ProcessState::Alive) => false,+ Err(cause) => {+ record(+ "exit_wait_failed",+ &format!("pid={} Windows cause: {cause}", owner.pid),+ "enterprise_start_aborted",+ );+ return false;+ }+ };+ let port_free = tokio::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, port))+ .await+ .is_ok();+ if process_gone && port_free {+ return true;+ }+ tokio::time::sleep(Duration::from_millis(200)).await;+ }+ false+}++fn record(event: &str, cause: &str, outcome: &str) {+ let _guard = LOG_WRITER.lock().unwrap_or_else(|error| error.into_inner());+ if let Err(error) = append_record(event, cause, outcome) {+ eprintln!("screenpipe: could not persist Enterprise takeover diagnostic: {error}");+ }+}++fn append_record(event: &str, cause: &str, outcome: &str) -> std::io::Result<()> {+ let root = screenpipe_core::paths::default_screenpipe_data_dir();+ append_record_to(&root, event, cause, outcome)+}++fn append_record_to(root: &Path, event: &str, cause: &str, outcome: &str) -> std::io::Result<()> {+ std::fs::create_dir_all(&root)?;+ let path = root.join(LOG_NAME);+ if std::fs::symlink_metadata(&path).is_ok_and(|metadata| metadata.file_type().is_symlink()) {+ return Err(std::io::Error::other(+ "takeover diagnostic path is a symlink",+ ));+ }+ let mut file = std::fs::OpenOptions::new()+ .create(true)+ .read(true)+ .write(true)+ .truncate(false)+ .open(path)?;+ if file.metadata()?.len() > MAX_LOG_BYTES {+ file.seek(SeekFrom::End(-(MAX_LOG_BYTES as i64 / 2)))?;+ let mut tail = Vec::new();+ file.read_to_end(&mut tail)?;+ let start = tail+ .iter()+ .position(|byte| *byte == b'\n')+ .map_or(tail.len(), |i| i + 1);+ file.set_len(0)?;+ file.rewind()?;+ file.write_all(&tail[start..])?;+ }+ file.seek(SeekFrom::End(0))?;+ writeln!(+ file,+ "{} event={} cause={} outcome={}",+ chrono::Utc::now().to_rfc3339(),+ event,+ cause+ .replace(['\r', '\n'], " ")+ .chars()+ .take(2048)+ .collect::<String>(),+ outcome+ )?;+ file.sync_data()+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn screenpipe_owner_fixture() {+ let Ok(port) = std::env::var("SCREENPIPE_TAKEOVER_FIXTURE_PORT") else {+ return;+ };+ let listener = std::net::TcpListener::bind((+ std::net::Ipv4Addr::LOCALHOST,+ port.parse::<u16>().unwrap(),+ ))+ .unwrap();+ for stream in listener.incoming() {+ let mut stream = stream.unwrap();+ let mut request = [0_u8; 4096];+ let _ = stream.read(&mut request);+ stream+ .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")+ .unwrap();+ }+ }++ #[tokio::test]+ async fn legacy_successful_focus_owner_is_replaced_after_confirmed_exit() {+ use std::process::{Command, Stdio};++ let listener = std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap();+ let port = listener.local_addr().unwrap().port();+ drop(listener);++ let temp = tempfile::tempdir().unwrap();+ let fixture_exe = temp.path().join("screenpipe-app.exe");+ std::fs::copy(std::env::current_exe().unwrap(), &fixture_exe).unwrap();+ let mut child = Command::new(&fixture_exe)+ .args([+ "--exact",+ "windows_enterprise_takeover::tests::screenpipe_owner_fixture",+ "--nocapture",+ ])+ .env("SCREENPIPE_TAKEOVER_FIXTURE_PORT", port.to_string())+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .unwrap();++ let client = reqwest::Client::new();+ let mut focused = false;+ for _ in 0..50 {+ if let Ok(response) = client+ .post(format!("http://127.0.0.1:{port}/focus"))+ .body("{}")+ .send()+ .await+ {+ assert!(response.status().is_success());+ focused = true;+ break;+ }+ tokio::time::sleep(Duration::from_millis(100)).await;+ }+ assert!(focused, "legacy focus fixture did not start");++ let outcome = take_over_screenpipe_owner(port).await.unwrap();+ assert_eq!(outcome, TakeoverOutcome::ReplacedCompetingOwner);+ let _terminated_status = child.wait().unwrap();+ assert!(std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, port)).is_ok());+ }++ fn spawn_owner_fixture(port: u16, copied_executable: Option<&Path>) -> std::process::Child {+ use std::process::{Command, Stdio};++ let executable = copied_executable+ .map(Path::to_path_buf)+ .unwrap_or_else(|| std::env::current_exe().unwrap());+ Command::new(executable)+ .args([+ "--exact",+ "windows_enterprise_takeover::tests::screenpipe_owner_fixture",+ "--nocapture",+ ])+ .env("SCREENPIPE_TAKEOVER_FIXTURE_PORT", port.to_string())+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .unwrap()+ }++ async fn wait_for_fixture(port: u16) {+ for _ in 0..50 {+ if std::net::TcpStream::connect((std::net::Ipv4Addr::LOCALHOST, port)).is_ok() {+ return;+ }+ tokio::time::sleep(Duration::from_millis(100)).await;+ }+ panic!("owner fixture did not start on port {port}");+ }++ fn unused_port() -> u16 {+ let listener = std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap();+ listener.local_addr().unwrap().port()+ }++ #[tokio::test]+ async fn api_only_competing_owner_is_replaced() {+ let control_port = unused_port();+ let api_port = unused_port();+ let temp = tempfile::tempdir().unwrap();+ let fixture_exe = temp.path().join("screenpipe-app.exe");+ std::fs::copy(std::env::current_exe().unwrap(), &fixture_exe).unwrap();+ let mut api_owner = spawn_owner_fixture(api_port, Some(&fixture_exe));+ wait_for_fixture(api_port).await;++ assert_eq!(+ take_over_screenpipe_owners(control_port, api_port)+ .await+ .unwrap(),+ TakeoverOutcome::ReplacedCompetingOwner+ );+ let _ = api_owner.wait().unwrap();+ }++ #[tokio::test]+ async fn same_enterprise_control_still_clears_competing_api_owner() {+ let control_port = unused_port();+ let api_port = unused_port();+ let temp = tempfile::tempdir().unwrap();+ let fixture_exe = temp.path().join("screenpipe-app.exe");+ std::fs::copy(std::env::current_exe().unwrap(), &fixture_exe).unwrap();+ let mut control_owner = spawn_owner_fixture(control_port, None);+ let mut api_owner = spawn_owner_fixture(api_port, Some(&fixture_exe));+ wait_for_fixture(control_port).await;+ wait_for_fixture(api_port).await;++ assert_eq!(+ take_over_screenpipe_owners(control_port, api_port)+ .await+ .unwrap(),+ TakeoverOutcome::SameExecutable+ );+ assert!(control_owner.try_wait().unwrap().is_none());+ let _ = api_owner.wait().unwrap();+ control_owner.kill().unwrap();+ let _ = control_owner.wait().unwrap();+ }++ #[test]+ fn only_exact_screenpipe_executables_are_eligible() {+ assert!(looks_like_screenpipe_exe(Path::new(+ r"C:\Program Files\screenpipe\screenpipe-app.exe"+ )));+ assert!(looks_like_screenpipe_exe(Path::new(+ r"C:\Program Files\screenpipe\SCREENPIPE.EXE"+ )));+ assert!(!looks_like_screenpipe_exe(Path::new(+ r"C:\Temp\screenpipe-helper.exe"+ )));+ assert!(!looks_like_screenpipe_exe(Path::new(+ r"C:\Temp\not-screenpipe.exe"+ )));+ }++ #[test]+ fn listener_parser_is_exact_and_locale_independent() {+ assert_eq!(+ listening_pid_from_line("TCP 127.0.0.1:11435 0.0.0.0:0 LISTENING 42", 11435),+ Some(42)+ );+ assert_eq!(+ listening_pid_from_line("TCP [::1]:11435 [::]:0 NASLUCHIWANIE 43", 11435),+ Some(43)+ );+ assert_eq!(+ listening_pid_from_line("TCP 127.0.0.1:114350 0.0.0.0:0 LISTENING 42", 11435),+ None+ );+ assert_eq!(+ listening_pid_from_line("TCP 127.0.0.1:50100 127.0.0.1:11435 ESTABLISHED 42", 11435),+ None+ );+ }++ #[tokio::test]+ async fn failure_survives_restart_rotation_and_real_support_redaction() {+ let root = tempfile::tempdir().unwrap();+ append_record_to(+ root.path(),+ "termination_failed",+ "pid=42 Windows cause: Access is denied. (os error 5) [email protected]",+ "enterprise_start_aborted",+ )+ .unwrap();+ std::fs::rename(+ root.path().join(LOG_NAME),+ root.path().join("enterprise-takeover.previous.log"),+ )+ .unwrap();+ append_record_to(+ root.path(),+ "startup_after_restart",+ "previous takeover failure retained",+ "support_collection_available",+ )+ .unwrap();++ let report =+ crate::diagnostic_logs::collect_redacted_from_dirs(&[root.path().to_path_buf()])+ .await+ .unwrap();+ assert!(report.contains("termination_failed"));+ assert!(report.contains("Access is denied"));+ assert!(report.contains("os error 5"));+ assert!(report.contains("enterprise_start_aborted"));+ assert!(report.contains("startup_after_restart"));+ assert!(!report.contains("[email protected]"));+ }+}