| #[cfg(target_os = "macos")] |
| use std::ffi::CStr; |
| #[cfg(target_os = "macos")] |
| use std::ffi::OsStr; |
| #[cfg(target_os = "macos")] |
| use std::fs; |
| #[cfg(target_os = "macos")] |
| use std::os::unix::ffi::OsStrExt; |
| #[cfg(target_os = "windows")] |
| use std::os::windows::io::AsRawHandle; |
| #[cfg(target_os = "windows")] |
| use std::os::windows::io::FromRawHandle; |
| #[cfg(target_os = "windows")] |
| use std::os::windows::io::OwnedHandle; |
| #[cfg(target_os = "macos")] |
| use std::path::Path; |
| #[cfg(target_os = "macos")] |
| use std::path::PathBuf; |
| #[cfg(target_os = "macos")] |
| use std::process::Stdio; |
| #[cfg(target_os = "macos")] |
| use std::time::Duration; |
|
|
| #[cfg(target_os = "macos")] |
| use serde_json::Value; |
| #[cfg(target_os = "macos")] |
| use tokio::process::Command; |
| #[cfg(target_os = "macos")] |
| use tokio::time::timeout; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::Foundation::ERROR_INSUFFICIENT_BUFFER; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::Foundation::ERROR_SUCCESS; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::Storage::Packaging::Appx::FindPackagesByPackageFamily; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::Storage::Packaging::Appx::GetPackageFamilyName; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::Storage::Packaging::Appx::PACKAGE_FILTER_HEAD; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::System::Threading::OpenProcess; |
| #[cfg(target_os = "windows")] |
| use windows_sys::Win32::System::Threading::PROCESS_QUERY_LIMITED_INFORMATION; |
|
|
| use super::super::CheckStatus; |
| use super::super::DoctorCheck; |
|
|
| pub(in crate::doctor) struct InstalledApp { |
| pub(in crate::doctor) identity: &'static str, |
| pub(in crate::doctor) version: String, |
| #[cfg(target_os = "windows")] |
| package_family: &'static str, |
| #[cfg(target_os = "macos")] |
| pub(in crate::doctor) bundle: PathBuf, |
| #[cfg(target_os = "macos")] |
| pub(in crate::doctor) build: u64, |
| } |
|
|
| #[derive(Clone, Copy, Debug)] |
| pub(in crate::doctor) struct DiscoveryError; |
|
|
| pub(super) async fn installed_app() -> Result<Option<InstalledApp>, DiscoveryError> { |
| #[cfg(target_os = "windows")] |
| { |
| installed_windows_app() |
| } |
| #[cfg(target_os = "macos")] |
| { |
| installed_macos_app().await |
| } |
| #[cfg(not(any(target_os = "windows", target_os = "macos")))] |
| { |
| Ok(None) |
| } |
| } |
|
|
| #[cfg(target_os = "macos")] |
| pub(super) fn application_running(application: &InstalledApp, candidate_pid: u32) -> bool { |
| process_executable_path(candidate_pid) |
| .is_some_and(|path| path.starts_with(application.bundle.join("Contents/MacOS"))) |
| } |
|
|
| #[cfg(target_os = "macos")] |
| fn process_executable_path(pid: u32) -> Option<PathBuf> { |
| let pid = i32::try_from(pid).ok()?; |
| let mut buffer = [0_u8; libc::PROC_PIDPATHINFO_MAXSIZE as usize]; |
| let result = |
| unsafe { libc::proc_pidpath(pid, buffer.as_mut_ptr().cast(), buffer.len() as u32) }; |
| if result <= 0 { |
| return None; |
| } |
| let executable = CStr::from_bytes_until_nul(&buffer).ok()?; |
| Some(PathBuf::from(OsStr::from_bytes(executable.to_bytes()))) |
| } |
|
|
| #[cfg(target_os = "windows")] |
| pub(super) fn application_running(application: &InstalledApp, candidate_pid: u32) -> bool { |
| process_package_family(candidate_pid).as_deref() == Some(application.package_family) |
| } |
|
|
| #[cfg(target_os = "windows")] |
| fn process_package_family(pid: u32) -> Option<String> { |
| let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) }; |
| if handle == 0 { |
| return None; |
| } |
| let process = unsafe { OwnedHandle::from_raw_handle(handle as _) }; |
|
|
| let mut family_length = 0; |
| let result = unsafe { |
| GetPackageFamilyName( |
| process.as_raw_handle() as _, |
| &mut family_length, |
| std::ptr::null_mut(), |
| ) |
| }; |
| if result != ERROR_INSUFFICIENT_BUFFER || family_length == 0 { |
| return None; |
| } |
|
|
| let mut family = vec![0_u16; family_length as usize]; |
| let result = unsafe { |
| GetPackageFamilyName( |
| process.as_raw_handle() as _, |
| &mut family_length, |
| family.as_mut_ptr(), |
| ) |
| }; |
| if result != ERROR_SUCCESS { |
| return None; |
| } |
|
|
| let end = family.iter().position(|value| *value == 0)?; |
| String::from_utf16(&family[..end]).ok() |
| } |
|
|
| #[cfg(not(any(target_os = "windows", target_os = "macos")))] |
| pub(super) fn application_running(_application: &InstalledApp, _candidate_pid: u32) -> bool { |
| false |
| } |
|
|
| pub(super) fn desktop_check( |
| id: impl Into<String>, |
| status: CheckStatus, |
| summary: impl Into<String>, |
| ) -> DoctorCheck { |
| DoctorCheck::new(id, "desktop", status, summary) |
| } |
|
|
| #[cfg(target_os = "windows")] |
| fn installed_windows_app() -> Result<Option<InstalledApp>, DiscoveryError> { |
| const PACKAGE_FAMILY: &str = "OpenAI.Codex_2p2nqsd0c76g0"; |
|
|
| let family = PACKAGE_FAMILY |
| .encode_utf16() |
| .chain(std::iter::once(0)) |
| .collect::<Vec<_>>(); |
| let mut count = 0; |
| let mut length = 0; |
| let result = unsafe { |
| FindPackagesByPackageFamily( |
| family.as_ptr(), |
| PACKAGE_FILTER_HEAD, |
| &mut count, |
| std::ptr::null_mut(), |
| &mut length, |
| std::ptr::null_mut(), |
| std::ptr::null_mut(), |
| ) |
| }; |
| if result == ERROR_SUCCESS && count == 0 { |
| return Ok(None); |
| } |
| if result != ERROR_INSUFFICIENT_BUFFER { |
| return Err(DiscoveryError); |
| } |
|
|
| let mut names = vec![std::ptr::null_mut(); count as usize]; |
| let mut buffer = vec![0_u16; length as usize]; |
| let result = unsafe { |
| FindPackagesByPackageFamily( |
| family.as_ptr(), |
| PACKAGE_FILTER_HEAD, |
| &mut count, |
| names.as_mut_ptr(), |
| &mut length, |
| buffer.as_mut_ptr(), |
| std::ptr::null_mut(), |
| ) |
| }; |
| if result != ERROR_SUCCESS { |
| return Err(DiscoveryError); |
| } |
| if count == 0 { |
| return Ok(None); |
| } |
| let end = buffer |
| .iter() |
| .position(|value| *value == 0) |
| .ok_or(DiscoveryError)?; |
| let package = String::from_utf16(&buffer[..end]).map_err(|_| DiscoveryError)?; |
| let version = package |
| .strip_prefix("OpenAI.Codex_") |
| .and_then(|name| name.split('_').next()) |
| .filter(|version| { |
| version |
| .split('.') |
| .all(|part| !part.is_empty() && part.bytes().all(|digit| digit.is_ascii_digit())) |
| }) |
| .ok_or(DiscoveryError)?; |
|
|
| Ok(Some(InstalledApp { |
| identity: "OpenAI.Codex", |
| version: version.to_string(), |
| package_family: PACKAGE_FAMILY, |
| })) |
| } |
|
|
| #[cfg(target_os = "macos")] |
| async fn installed_macos_app() -> Result<Option<InstalledApp>, DiscoveryError> { |
| let applications = std::iter::once(PathBuf::from("/Applications")) |
| .chain(std::env::var_os("HOME").map(|home| PathBuf::from(home).join("Applications"))) |
| .flat_map(|directory| { |
| ["ChatGPT.app", "Codex.app"] |
| .into_iter() |
| .map(move |application| directory.join(application)) |
| }); |
|
|
| for bundle in applications { |
| match fs::metadata(&bundle) { |
| Ok(metadata) if metadata.is_dir() => {} |
| Ok(_) => continue, |
| Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue, |
| Err(_) => return Err(DiscoveryError), |
| } |
| if let Some(application) = inspect_macos_bundle(&bundle).await? { |
| return Ok(Some(application)); |
| } |
| } |
|
|
| Ok(None) |
| } |
|
|
| #[cfg(target_os = "macos")] |
| pub(in crate::doctor) async fn inspect_macos_bundle( |
| bundle: &Path, |
| ) -> Result<Option<InstalledApp>, DiscoveryError> { |
| let mut command = Command::new("/usr/bin/plutil"); |
| command |
| .args(["-convert", "json", "-o", "-"]) |
| .arg(bundle.join("Contents/Info.plist")) |
| .stdin(Stdio::null()) |
| .stderr(Stdio::null()) |
| .kill_on_drop(true); |
| let output = timeout(Duration::from_secs(5), command.output()) |
| .await |
| .map_err(|_| DiscoveryError)? |
| .map_err(|_| DiscoveryError)?; |
| if !output.status.success() || output.stdout.len() > 64 * 1024 { |
| return Err(DiscoveryError); |
| } |
| let metadata: Value = serde_json::from_slice(&output.stdout).map_err(|_| DiscoveryError)?; |
| if metadata.get("CFBundleIdentifier").and_then(Value::as_str) != Some("com.openai.codex") { |
| return Ok(None); |
| } |
| let version = metadata |
| .get("CFBundleShortVersionString") |
| .or_else(|| metadata.get("CFBundleVersion")) |
| .and_then(Value::as_str) |
| .ok_or(DiscoveryError)?; |
| let build = metadata |
| .get("CFBundleVersion") |
| .and_then(Value::as_str) |
| .and_then(|value| value.parse().ok()) |
| .ok_or(DiscoveryError)?; |
|
|
| Ok(Some(InstalledApp { |
| identity: "com.openai.codex", |
| version: version.to_string(), |
| bundle: bundle.to_path_buf(), |
| build, |
| })) |
| } |
|
|
