Ely Office: six offline-first desktop apps in Rust and GPUI

ElyDoc, ElyTable, ElyShow (LibreOfficeKit), ElyPDF (MuPDF), ElyTree (Git),
ElyMark (Milkdown and CodeMirror in CEF). ElyMail and ElyAgent follow.

crates/ely-platform/src/apps.rs

@@ -0,0 +1,189 @@
+//! Starting another Ely app installed beside this one.
+
+use std::{
+    io,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use crate::AppId;
+
+/// Where `app` sits for an install laid out like `exe`'s.
+fn beside(exe: &Path, app: AppId) -> Vec<PathBuf> {
+    let file = format!("{}{}", app.slug(), std::env::consts::EXE_SUFFIX);
+    let Some(dir) = exe.parent() else {
+        return Vec::new();
+    };
+    let mut places = vec![dir.join(&file)];
+    // macOS: Name.app/Contents/MacOS; Windows: Ely Office\Name.
+    if let Some(bundle) = dir.parent().and_then(Path::parent) {
+        let app_dir = format!("{}.app", app.name());
+        if let Some(apps) = bundle.parent() {
+            places.push(apps.join(app_dir).join("Contents/MacOS").join(&file));
+        }
+    }
+    if let Some(suite) = dir.parent() {
+        places.push(suite.join(app.name()).join(&file));
+    }
+    places
+}
+
+/// `app`'s binary: beside this one, else wherever macOS has it.
+fn find(app: AppId) -> io::Result<Option<PathBuf>> {
+    let exe = std::env::current_exe()?;
+    let near = beside(&exe, app).into_iter().find(|place| place.is_file());
+    Ok(near.or_else(|| registered(app)))
+}
+
+#[cfg(target_os = "macos")]
+fn registered(app: AppId) -> Option<PathBuf> {
+    use objc2_app_kit::NSWorkspace;
+    use objc2_foundation::NSString;
+    let id = NSString::from_str(&app.bundle_id());
+    let url = NSWorkspace::sharedWorkspace().URLForApplicationWithBundleIdentifier(&id)?;
+    let bundle = PathBuf::from(url.path()?.to_string());
+    let binary = bundle.join("Contents/MacOS").join(app.slug());
+    binary.is_file().then_some(binary)
+}
+
+#[cfg(not(target_os = "macos"))]
+fn registered(_: AppId) -> Option<PathBuf> {
+    None
+}
+
+/// Whether `app` can be started from here.
+pub fn installed(app: AppId) -> bool {
+    matches!(find(app), Ok(Some(_)))
+}
+
+/// The `.app` a macOS binary sits in.
+fn bundle_of(binary: &Path) -> Option<&Path> {
+    let bundle = binary.parent()?.parent()?.parent()?;
+    (cfg!(target_os = "macos") && bundle.extension().is_some_and(|ext| ext == "app")).then_some(bundle)
+}
+
+/// Starts `app` with `files`; a running one takes them.
+pub fn open(app: AppId, files: &[PathBuf]) -> io::Result<()> {
+    let found = find(app)?.ok_or_else(|| {
+        io::Error::new(io::ErrorKind::NotFound, format!("{} is not installed", app.name()))
+    })?;
+    // Launch Services hands files to a running app.
+    if let Some(bundle) = bundle_of(&found) {
+        let out = Command::new("open").arg("-a").arg(bundle).args(files).output()?;
+        if !out.status.success() {
+            let said = String::from_utf8_lossy(&out.stderr).trim().to_owned();
+            return Err(io::Error::other(format!("{}: {said}", app.name())));
+        }
+        log::info!("apps: opened {} with {} files", app.name(), files.len());
+        return Ok(());
+    }
+    let mut command = Command::new(&found);
+    command.args(files);
+    let child = fresh_signals(&mut command).spawn()?;
+    log::info!("apps: started {} as {}", app.name(), child.id());
+    Ok(())
+}
+
+/// The started app takes signals as from a shell.
+#[cfg(unix)]
+fn fresh_signals(command: &mut Command) -> &mut Command {
+    use std::os::unix::process::CommandExt as _;
+    // Chromium's ignored or blocked signals would carry over.
+    unsafe {
+        command.pre_exec(|| {
+            for signal in [libc::SIGTERM, libc::SIGINT, libc::SIGHUP, libc::SIGQUIT] {
+                libc::signal(signal, libc::SIG_DFL);
+            }
+            let mut none: libc::sigset_t = std::mem::zeroed();
+            libc::sigemptyset(&mut none);
+            libc::pthread_sigmask(libc::SIG_SETMASK, &none, std::ptr::null_mut());
+            Ok(())
+        })
+    }
+}
+
+#[cfg(not(unix))]
+fn fresh_signals(command: &mut Command) -> &mut Command {
+    command
+}
+
+/// Opens `path` in the default app; a refusal says why.
+pub fn open_default(path: &Path) -> io::Result<()> {
+    let mut command = if cfg!(target_os = "macos") {
+        Command::new("open")
+    } else if cfg!(windows) {
+        let mut start = Command::new("cmd");
+        start.args(["/C", "start", ""]);
+        start
+    } else {
+        Command::new("xdg-open")
+    };
+    let out = command.arg(path).output()?;
+    if !out.status.success() {
+        let said = String::from_utf8_lossy(&out.stderr).trim().to_owned();
+        return Err(io::Error::other(said));
+    }
+    log::info!("apps: the system opened an output");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::{Path, PathBuf};
+
+    use crate::AppId;
+
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn a_missing_output_says_so() {
+        let dir = tempfile::tempdir().expect("a temp dir");
+        let error = super::open_default(&dir.path().join("gone.txt")).expect_err("no file");
+        assert!(error.to_string().contains("does not exist"), "{error}");
+    }
+
+    #[test]
+    fn each_install_layout_names_its_sibling() {
+        let suffix = std::env::consts::EXE_SUFFIX;
+        let places = super::beside(
+            Path::new("/Apps/ElyTree.app/Contents/MacOS/ely-tree"),
+            AppId::Mark,
+        );
+        assert!(places.contains(&PathBuf::from(format!(
+            "/Apps/ElyMark.app/Contents/MacOS/ely-mark{suffix}"
+        ))));
+        let places = super::beside(Path::new("/target/debug/ely-tree"), AppId::Mark);
+        assert_eq!(
+            places[0],
+            PathBuf::from(format!("/target/debug/ely-mark{suffix}"))
+        );
+        let places = super::beside(Path::new("/Ely Office/ElyTree/ely-tree.exe"), AppId::Mark);
+        assert!(places.contains(&PathBuf::from(format!(
+            "/Ely Office/ElyMark/ely-mark{suffix}"
+        ))));
+    }
+}
+
+#[cfg(all(test, unix))]
+mod signals {
+    use std::os::unix::process::ExitStatusExt as _;
+
+    /// A starter that ignores and blocks SIGTERM, as Chromium may.
+    #[test]
+    fn a_started_app_still_stops_on_sigterm() {
+        unsafe {
+            libc::signal(libc::SIGTERM, libc::SIG_IGN);
+            let mut term: libc::sigset_t = std::mem::zeroed();
+            libc::sigemptyset(&mut term);
+            libc::sigaddset(&mut term, libc::SIGTERM);
+            libc::pthread_sigmask(libc::SIG_BLOCK, &term, std::ptr::null_mut());
+        }
+        let mut command = std::process::Command::new("/bin/sleep");
+        command.arg("30");
+        let mut child = super::fresh_signals(&mut command).spawn().unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(200));
+        unsafe { libc::kill(child.id() as i32, libc::SIGTERM) };
+        let status = child.wait().unwrap();
+        unsafe { libc::signal(libc::SIGTERM, libc::SIG_DFL) };
+        assert_eq!(status.signal(), Some(libc::SIGTERM), "{status:?}");
+    }
+}