use anyhow::Context as _;
use std::ffi::CString;
use std::path::Path;
use std::path::PathBuf;
use tempfile::Builder;
use tokio::process::Command;
const CODEX_BUNDLE_IDENTIFIER: &str = "com.openai.codex";
const CODEX_DMG_URL_ARM64: &str = "https://persistent.oaistatic.com/codex-app-prod/Codex.dmg";
const CODEX_DMG_URL_X64: &str =
"https://persistent.oaistatic.com/codex-app-prod/Codex-latest-x64.dmg";
pub async fn run_mac_app_open_or_install(
workspace: PathBuf,
download_url_override: Option<String>,
) -> anyhow::Result<()> {
if let Some(app_path) = find_existing_codex_app_path(&codex_app_search_dirs()) {
eprintln!(
"Opening Desktop app at {app_path}...",
app_path = app_path.display()
);
open_codex_app(&app_path, &workspace).await?;
return Ok(());
}
eprintln!("Desktop app not found; downloading installer...");
let download_url = download_url_override.unwrap_or_else(|| {
let default_url = if is_apple_silicon_mac() {
CODEX_DMG_URL_ARM64
} else {
CODEX_DMG_URL_X64
};
default_url.to_string()
});
let installed_app = download_and_install_codex_to_user_applications(&download_url)
.await
.context("failed to download/install Desktop app")?;
eprintln!(
"Launching Desktop app from {installed_app}...",
installed_app = installed_app.display()
);
open_codex_app(&installed_app, &workspace).await?;
Ok(())
}
fn is_apple_silicon_mac() -> bool {
fn macos_sysctl_flag(name: &str) -> Option<bool> {
let name = CString::new(name).ok()?;
let mut value: libc::c_int = 0;
let mut size = std::mem::size_of_val(&value);
let result = unsafe {
libc::sysctlbyname(
name.as_ptr(),
(&mut value as *mut libc::c_int).cast::<libc::c_void>(),
&mut size,
std::ptr::null_mut(),
0,
)
};
(result == 0).then_some(value != 0)
}
std::env::consts::ARCH == "aarch64"
|| macos_sysctl_flag("sysctl.proc_translated").unwrap_or(false)
|| macos_sysctl_flag("hw.optional.arm64").unwrap_or(false)
}
fn find_existing_codex_app_path(applications_dirs: &[PathBuf]) -> Option<PathBuf> {
applications_dirs
.iter()
.flat_map(|dir| ["ChatGPT.app", "Codex.app"].map(|app_name| dir.join(app_name)))
.find(|candidate| is_codex_app_bundle(candidate))
}
fn codex_app_search_dirs() -> Vec<PathBuf> {
let mut paths = vec![PathBuf::from("/Applications")];
if let Some(home) = std::env::var_os("HOME") {
paths.push(PathBuf::from(home).join("Applications"));
}
paths
}
fn is_codex_app_bundle(app_path: &Path) -> bool {
if !app_path.is_dir() {
return false;
}
std::process::Command::new("/usr/bin/plutil")
.arg("-extract")
.arg("CFBundleIdentifier")
.arg("raw")
.arg("-o")
.arg("-")
.arg(app_path.join("Contents/Info.plist"))
.output()
.is_ok_and(|output| {
output.status.success()
&& String::from_utf8_lossy(&output.stdout).trim() == CODEX_BUNDLE_IDENTIFIER
})
}
async fn open_codex_app(app_path: &Path, workspace: &Path) -> anyhow::Result<()> {
eprintln!(
"Opening workspace {workspace}...",
workspace = workspace.display()
);
let url = codex_new_thread_url(workspace);
let status = Command::new("open")
.arg("-a")
.arg(app_path)
.arg(&url)
.status()
.await
.context("failed to invoke `open`")?;
if status.success() {
return Ok(());
}
anyhow::bail!(
"`open -a {app_path} {url}` exited with {status}",
app_path = app_path.display(),
url = url
);
}
fn codex_new_thread_url(workspace: &Path) -> String {
let workspace = workspace.as_os_str().to_string_lossy();
let mut serializer = url::form_urlencoded::Serializer::new(String::new());
serializer.append_pair("path", workspace.as_ref());
let query = serializer.finish();
format!("codex://threads/new?{query}")
}
async fn download_and_install_codex_to_user_applications(dmg_url: &str) -> anyhow::Result<PathBuf> {
let temp_dir = Builder::new()
.prefix("codex-app-installer-")
.tempdir()
.context("failed to create temp dir")?;
let tmp_root = temp_dir.path().to_path_buf();
let _temp_dir = temp_dir;
let dmg_path = tmp_root.join("Codex.dmg");
download_dmg(dmg_url, &dmg_path).await?;
eprintln!("Mounting Desktop app installer...");
let mount_point = mount_dmg(&dmg_path).await?;
eprintln!(
"Installer mounted at {mount_point}.",
mount_point = mount_point.display()
);
let result = async {
let app_in_volume = find_codex_app_in_mount(&mount_point)
.context("failed to locate Codex.app in mounted dmg")?;
install_codex_app_bundle(&app_in_volume).await
}
.await;
let detach_result = detach_dmg(&mount_point).await;
if let Err(err) = detach_result {
eprintln!(
"warning: failed to detach dmg at {mount_point}: {err}",
mount_point = mount_point.display()
);
}
result
}
async fn install_codex_app_bundle(app_in_volume: &Path) -> anyhow::Result<PathBuf> {
for applications_dir in candidate_applications_dirs()? {
eprintln!(
"Installing Desktop app into {applications_dir}...",
applications_dir = applications_dir.display()
);
std::fs::create_dir_all(&applications_dir).with_context(|| {
format!(
"failed to create applications dir {applications_dir}",
applications_dir = applications_dir.display()
)
})?;
let dest_app = applications_dir.join("Codex.app");
if dest_app.is_dir() {
return Ok(dest_app);
}
match copy_app_bundle(app_in_volume, &dest_app).await {
Ok(()) => return Ok(dest_app),
Err(err) => {
eprintln!(
"warning: failed to install Codex.app to {applications_dir}: {err}",
applications_dir = applications_dir.display()
);
}
}
}
anyhow::bail!("failed to install Codex.app to any applications directory");
}
fn candidate_applications_dirs() -> anyhow::Result<Vec<PathBuf>> {
let mut dirs = vec![PathBuf::from("/Applications")];
dirs.push(user_applications_dir()?);
Ok(dirs)
}
async fn download_dmg(url: &str, dest: &Path) -> anyhow::Result<()> {
eprintln!("Downloading installer...");
let status = Command::new("curl")
.arg("-fL")
.arg("--retry")
.arg("3")
.arg("--retry-delay")
.arg("1")
.arg("-o")
.arg(dest)
.arg(url)
.status()
.await
.context("failed to invoke `curl`")?;
if status.success() {
return Ok(());
}
anyhow::bail!("curl download failed with {status}");
}
async fn mount_dmg(dmg_path: &Path) -> anyhow::Result<PathBuf> {
let output = Command::new("hdiutil")
.arg("attach")
.arg("-nobrowse")
.arg("-readonly")
.arg(dmg_path)
.output()
.await
.context("failed to invoke `hdiutil attach`")?;
if !output.status.success() {
anyhow::bail!(
"`hdiutil attach` failed with {status}: {stderr}",
status = output.status,
stderr = String::from_utf8_lossy(&output.stderr)
);
}
let stdout = String::from_utf8_lossy(&output.stdout);
parse_hdiutil_attach_mount_point(&stdout)
.map(PathBuf::from)
.with_context(|| format!("failed to parse mount point from hdiutil output:\n{stdout}"))
}
async fn detach_dmg(mount_point: &Path) -> anyhow::Result<()> {
let status = Command::new("hdiutil")
.arg("detach")
.arg(mount_point)
.status()
.await
.context("failed to invoke `hdiutil detach`")?;
if status.success() {
return Ok(());
}
anyhow::bail!("hdiutil detach failed with {status}");
}
fn find_codex_app_in_mount(mount_point: &Path) -> anyhow::Result<PathBuf> {
let direct = mount_point.join("Codex.app");
if direct.is_dir() {
return Ok(direct);
}
for entry in std::fs::read_dir(mount_point).with_context(|| {
format!(
"failed to read {mount_point}",
mount_point = mount_point.display()
)
})? {
let entry = entry.context("failed to read mount directory entry")?;
let path = entry.path();
if path.extension().is_some_and(|ext| ext == "app") && path.is_dir() {
return Ok(path);
}
}
anyhow::bail!(
"no .app bundle found at {mount_point}",
mount_point = mount_point.display()
);
}
async fn copy_app_bundle(src_app: &Path, dest_app: &Path) -> anyhow::Result<()> {
let status = Command::new("ditto")
.arg(src_app)
.arg(dest_app)
.status()
.await
.context("failed to invoke `ditto`")?;
if status.success() {
return Ok(());
}
anyhow::bail!("ditto copy failed with {status}");
}
fn user_applications_dir() -> anyhow::Result<PathBuf> {
let home = std::env::var_os("HOME").context("HOME is not set")?;
Ok(PathBuf::from(home).join("Applications"))
}
fn parse_hdiutil_attach_mount_point(output: &str) -> Option<String> {
output.lines().find_map(|line| {
if !line.contains("/Volumes/") {
return None;
}
if let Some((_, mount)) = line.rsplit_once('\t') {
return Some(mount.trim().to_string());
}
line.split_whitespace()
.find(|field| field.starts_with("/Volumes/"))
.map(str::to_string)
})
}
#[cfg(test)]
mod tests {
use super::codex_new_thread_url;
use super::find_existing_codex_app_path;
use super::parse_hdiutil_attach_mount_point;
use pretty_assertions::assert_eq;
use std::fs;
use std::path::Path;
fn write_app_bundle(app_path: &Path, bundle_identifier: &str) {
let contents_path = app_path.join("Contents");
fs::create_dir_all(&contents_path).expect("create app bundle");
fs::write(
contents_path.join("Info.plist"),
format!(
r#"<?xml version="1.0"?><plist version="1.0"><dict><key>CFBundleIdentifier</key><string>{bundle_identifier}</string></dict></plist>"#
),
)
.expect("write Info.plist");
}
#[test]
fn finds_chatgpt_app_with_codex_bundle_identifier() {
let temp_dir = tempfile::tempdir().expect("create temp dir");
let app_path = temp_dir.path().join("ChatGPT.app");
write_app_bundle(&app_path, "com.openai.codex");
assert_eq!(
find_existing_codex_app_path(&[temp_dir.path().to_path_buf()]),
Some(app_path)
);
}
#[test]
fn ignores_classic_chatgpt_app() {
let temp_dir = tempfile::tempdir().expect("create temp dir");
write_app_bundle(&temp_dir.path().join("ChatGPT.app"), "com.openai.chat");
let codex_app_path = temp_dir.path().join("Codex.app");
write_app_bundle(&codex_app_path, "com.openai.codex");
assert_eq!(
find_existing_codex_app_path(&[temp_dir.path().to_path_buf()]),
Some(codex_app_path)
);
}
#[test]
fn parses_mount_point_from_tab_separated_hdiutil_output() {
let output = "/dev/disk2s1\tApple_HFS\tCodex\t/Volumes/Codex\n";
assert_eq!(
parse_hdiutil_attach_mount_point(output).as_deref(),
Some("/Volumes/Codex")
);
}
#[test]
fn parses_mount_point_with_spaces() {
let output = "/dev/disk2s1\tApple_HFS\tCodex Installer\t/Volumes/Codex Installer\n";
assert_eq!(
parse_hdiutil_attach_mount_point(output).as_deref(),
Some("/Volumes/Codex Installer")
);
}
#[test]
fn codex_new_thread_url_encodes_workspace_path() {
let url = url::Url::parse(&codex_new_thread_url(Path::new("/tmp/codex workspace/#1")))
.expect("deep link should parse");
assert_eq!(
(
url.scheme().to_string(),
url.host_str().map(str::to_string),
url.path().to_string(),
url.query_pairs().into_owned().collect::<Vec<_>>(),
),
(
"codex".to_string(),
Some("threads".to_string()),
"/new".to_string(),
vec![("path".to_string(), "/tmp/codex workspace/#1".to_string())],
)
);
}
}