fix: bootstrap ghostty runtime for registry installs

Author: OneNoted

Cargo.lock

@@ -8,9 +8,10 @@ use std::{
     collections::{HashMap, HashSet},
     future::pending,
     path::PathBuf,
+    process::{Command, Stdio},
     rc::Rc,
     thread,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use adw::prelude::*;
@@ -36,6 +37,7 @@ use taskers_domain::{
 };
 use taskers_ghostty::{
     BackendChoice, BackendProbe, DefaultBackend, GhosttyHost, SurfaceDescriptor, TerminalBackend,
+    ensure_runtime_installed,
 };
 use taskers_runtime::{
     ShellLaunchSpec, default_shell_program, install_shell_integration, validate_shell_program,
@@ -55,6 +57,8 @@ struct Cli {
     clean_shell: bool,
     #[arg(long, default_value_t = false, conflicts_with = "clean_shell")]
     raw_shell: bool,
+    #[arg(long, hide = true, default_value_t = false)]
+    internal_ghostty_probe: bool,
 }
 
 struct StartupContext {
@@ -1462,6 +1466,9 @@ impl UiHandle {
 
 fn main() -> gtk::glib::ExitCode {
     let cli = Cli::parse();
+    if cli.internal_ghostty_probe {
+        return run_internal_ghostty_probe();
+    }
     let shell_mode_non_unique = cli.clean_shell || cli.raw_shell;
     let run_non_unique = shell_mode_non_unique
         || cli.socket.is_some()
@@ -1472,6 +1479,14 @@ fn main() -> gtk::glib::ExitCode {
         .session
         .unwrap_or_else(session_store::default_session_path);
     let config_path = settings_store::default_config_path();
+    let ghostty_runtime_toast = match ensure_runtime_installed() {
+        Ok(Some(runtime)) => Some(format!(
+            "Installed Ghostty runtime assets to {}",
+            runtime.runtime_dir.display()
+        )),
+        Ok(None) => None,
+        Err(error) => Some(format!("Ghostty runtime bootstrap unavailable: {error}")),
+    };
     let probe = DefaultBackend::probe(BackendChoice::Auto);
     if cli.clean_shell {
         unsafe {
@@ -1523,7 +1538,7 @@ fn main() -> gtk::glib::ExitCode {
         initialize_terminal_backend(&probe);
     let startup_toast = merge_startup_toasts(
         merge_startup_toasts(
-            shell_integration_toast,
+            merge_startup_toasts(ghostty_runtime_toast, shell_integration_toast),
             cli.clean_shell
                 .then(|| "Using clean shell startup".to_string()),
         ),
@@ -1657,6 +1672,15 @@ fn initialize_terminal_backend(
         return (BackendChoice::Mock, probe.notes.clone(), None, None);
     }
 
+    if let Err(error) = probe_ghostty_backend_process() {
+        let note = format!(
+            "{} Ghostty self-probe failed; using placeholder terminal surfaces.",
+            probe.notes
+        );
+        let toast = format!("Ghostty backend unavailable: {error}");
+        return (BackendChoice::Mock, note, None, Some(toast));
+    }
+
     match GhosttyHost::new() {
         Ok(host) => (
             BackendChoice::Ghostty,
@@ -1672,6 +1696,67 @@ fn initialize_terminal_backend(
     }
 }
 
+fn run_internal_ghostty_probe() -> gtk::glib::ExitCode {
+    match GhosttyHost::new() {
+        Ok(host) => {
+            let _ = host.tick();
+            thread::sleep(Duration::from_millis(250));
+            gtk::glib::ExitCode::SUCCESS
+        }
+        Err(error) => {
+            eprintln!("ghostty self-probe failed: {error}");
+            gtk::glib::ExitCode::FAILURE
+        }
+    }
+}
+
+fn probe_ghostty_backend_process() -> Result<(), String> {
+    let current_exe = std::env::current_exe()
+        .map_err(|error| format!("failed to resolve current executable: {error}"))?;
+    let mut child = Command::new(current_exe)
+        .arg("--internal-ghostty-probe")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .map_err(|error| format!("failed to launch Ghostty self-probe: {error}"))?;
+
+    let deadline = Instant::now() + Duration::from_secs(5);
+    loop {
+        match child.try_wait() {
+            Ok(Some(status)) => {
+                if status.success() {
+                    return Ok(());
+                }
+                return Err(describe_exit_status(status));
+            }
+            Ok(None) if Instant::now() < deadline => thread::sleep(Duration::from_millis(50)),
+            Ok(None) => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return Err("Ghostty self-probe timed out".into());
+            }
+            Err(error) => return Err(format!("failed to wait for Ghostty self-probe: {error}")),
+        }
+    }
+}
+
+fn describe_exit_status(status: std::process::ExitStatus) -> String {
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::ExitStatusExt;
+
+        if let Some(signal) = status.signal() {
+            return format!("Ghostty self-probe crashed with signal {signal}");
+        }
+    }
+
+    match status.code() {
+        Some(code) => format!("Ghostty self-probe exited with status {code}"),
+        None => "Ghostty self-probe exited unsuccessfully".into(),
+    }
+}
+
 fn merge_startup_toasts(first: Option<String>, second: Option<String>) -> Option<String> {
     match (first, second) {
         (Some(first), Some(second)) => Some(format!("{first}\n{second}")),

crates/taskers-app/src/main.rs

@@ -965,6 +965,8 @@ fn install_ghostty_runtime(
             "-Dapp-runtime=gtk",
             "-Demit-exe=false",
             "-Dgtk-wayland=false",
+            "-Dstrip=true",
+            "-Di18n=false",
             "--summary",
             "none",
             "--prefix",
@@ -1008,6 +1010,16 @@ fn install_ghostty_runtime(
             embedded_terminfo_dir.display()
         )
     })?;
+    std::fs::write(
+        resources_dir.join(".taskers-runtime-version"),
+        env!("CARGO_PKG_VERSION"),
+    )
+    .with_context(|| {
+        format!(
+            "failed to write Ghostty runtime version marker to {}",
+            resources_dir.join(".taskers-runtime-version").display()
+        )
+    })?;
 
     Ok(())
 }

crates/taskers-cli/src/main.rs

@@ -13,8 +13,14 @@ build = "build.rs"
 gtk.workspace = true
 libloading = "0.8"
 serde.workspace = true
+tar = "0.4"
 thiserror.workspace = true
+ureq = "2.12"
+xz2 = "0.1"
 
 [features]
 default = []
 libghostty = []
+
+[dev-dependencies]
+tempfile.workspace = true

crates/taskers-ghostty/Cargo.toml

@@ -18,6 +18,10 @@ fn main() {
     if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("linux") {
         return;
     }
+    println!("cargo:rustc-cfg=taskers_ghostty_bridge");
+    if let Ok(target) = env::var("TARGET") {
+        println!("cargo:rustc-env=TASKERS_BUILD_TARGET={target}");
+    }
 
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("manifest dir"));
     let workspace_root = manifest_dir
@@ -28,7 +32,7 @@ fn main() {
     let vendor_dir = workspace_root.join("vendor").join("ghostty");
     if !vendor_dir.exists() {
         println!(
-            "cargo:warning=vendored Ghostty source tree not found; building without the Ghostty bridge"
+            "cargo:warning=vendored Ghostty source tree not found; runtime bundle bootstrap will be required"
         );
         return;
     }
@@ -60,6 +64,8 @@ fn build_bridge(vendor_dir: &Path, install_dir: &Path) {
             "-Dapp-runtime=gtk",
             "-Demit-exe=false",
             "-Dgtk-wayland=false",
+            "-Dstrip=true",
+            "-Di18n=false",
             "--summary",
             "none",
             "--prefix",

crates/taskers-ghostty/build.rs

@@ -1,4 +1,4 @@
-use crate::bridge::{runtime_bridge_path, runtime_resources_dir};
+use crate::runtime::{runtime_bridge_path, runtime_resources_dir};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use thiserror::Error;

crates/taskers-ghostty/src/backend.rs

@@ -19,6 +19,7 @@ use libloading::Library;
 use thiserror::Error;
 
 use crate::backend::SurfaceDescriptor;
+use crate::runtime::{configure_runtime_environment, runtime_bridge_path};
 
 #[derive(Debug, Error)]
 pub enum GhosttyError {
@@ -197,85 +198,6 @@ impl Drop for GhosttyHost {
     }
 }
 
-pub fn configure_runtime_environment() {
-    if std::env::var_os("GHOSTTY_RESOURCES_DIR").is_some() {
-        return;
-    }
-
-    if let Some(path) = installed_runtime_dir().filter(|path| path.exists()) {
-        unsafe {
-            std::env::set_var("GHOSTTY_RESOURCES_DIR", &path);
-        }
-        return;
-    }
-
-    if let Some(path) = option_env!("TASKERS_GHOSTTY_BUILD_RESOURCES_DIR")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-    {
-        unsafe {
-            std::env::set_var("GHOSTTY_RESOURCES_DIR", &path);
-        }
-    }
-}
-
-pub fn runtime_resources_dir() -> Option<PathBuf> {
-    if let Some(path) = std::env::var_os("GHOSTTY_RESOURCES_DIR")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-    {
-        return Some(path);
-    }
-
-    if let Some(path) = installed_runtime_dir().filter(|path| path.exists()) {
-        return Some(path);
-    }
-
-    option_env!("TASKERS_GHOSTTY_BUILD_RESOURCES_DIR")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-}
-
-pub fn runtime_bridge_path() -> Option<PathBuf> {
-    if let Some(path) = std::env::var_os("TASKERS_GHOSTTY_BRIDGE_PATH")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-    {
-        return Some(path);
-    }
-
-    if let Some(path) = installed_runtime_dir()
-        .map(|root| root.join("lib").join("libtaskers_ghostty_bridge.so"))
-        .filter(|path| path.exists())
-    {
-        return Some(path);
-    }
-
-    option_env!("TASKERS_GHOSTTY_BUILD_BRIDGE_PATH")
-        .map(PathBuf::from)
-        .filter(|path| path.exists())
-}
-
-fn installed_runtime_dir() -> Option<PathBuf> {
-    if let Some(path) = std::env::var_os("TASKERS_GHOSTTY_RUNTIME_DIR").map(PathBuf::from) {
-        return Some(path);
-    }
-
-    if let Some(path) = std::env::var_os("XDG_DATA_HOME")
-        .map(PathBuf::from)
-        .map(|path| path.join("taskers").join("ghostty"))
-    {
-        return Some(path);
-    }
-
-    std::env::var_os("HOME").map(PathBuf::from).map(|path| {
-        path.join(".local")
-            .join("share")
-            .join("taskers")
-            .join("ghostty")
-    })
-}
-
 #[cfg(taskers_ghostty_bridge)]
 fn load_bridge_library() -> Result<GhosttyBridgeLibrary, GhosttyError> {
     let path = runtime_bridge_path().ok_or(GhosttyError::LibraryPathUnavailable)?;

crates/taskers-ghostty/src/bridge.rs

@@ -1,8 +1,13 @@
 pub mod backend;
 pub mod bridge;
+pub mod runtime;
 
 pub use backend::{
     AdapterError, BackendAvailability, BackendChoice, BackendProbe, DefaultBackend,
     SurfaceDescriptor, TerminalBackend,
 };
-pub use bridge::{GhosttyError, GhosttyHost, configure_runtime_environment};
+pub use bridge::{GhosttyError, GhosttyHost};
+pub use runtime::{
+    RuntimeBootstrap, RuntimeBootstrapError, configure_runtime_environment,
+    ensure_runtime_installed,
+};