Personal AI, On Personal Devices
Python
fix(desktop): AppImage env-strip + attach to existing healthy server (#496)
Jon Saad-Falconf72abadf6864
diff --git a/frontend/src-tauri/src/lib.rs b/frontend/src-tauri/src/lib.rsindex 8c6d57c8..679ed147 100644--- a/frontend/src-tauri/src/lib.rs+++ b/frontend/src-tauri/src/lib.rs@@ -689,6 +689,39 @@ fn format_uv_sync_failure()}+/// Strip AppImage-injected environment from a subprocess command (#455).+///+/// When the OpenJarvis desktop binary is shipped as an AppImage, the AppImage+/// runtime sets `LD_LIBRARY_PATH` (and friends) to the extracted-to-/tmp+/// bundled lib dir. Any child we spawn inherits that env by default — but the+/// children we spawn (`uv`, `ollama`, `git`) live outside the AppImage and+/// must NOT load their shared libraries from the AppImage's bundle. The+/// classic symptom: `uv` finds `python3`, `python3` tries to `import numpy`,+/// numpy's `.so` files try to dlopen libstdc++/libssl/libcrypto, the linker+/// picks the AppImage's versions which were built against a different glibc+/// or libcrypto API, and python dies silently — before any startup log+/// reaches us. The user sees "API Server — starting server..." forever.+///+/// Fix: when we detect we're inside an AppImage (the AppImage runtime sets+/// `$APPIMAGE` to the original image path), strip the leaked env vars before+/// spawn. Conditional on `APPIMAGE` being set so regular Linux installs that+/// legitimately use `LD_LIBRARY_PATH` are untouched. Linux-only — the+/// `#[cfg]` makes this a no-op on macOS / Windows.+#[cfg_attr(not(target_os = "linux"), allow(unused_variables))]+fn prepare_subprocess_for_appimage(cmd: &mut tokio::process::Command) {+ #[cfg(target_os = "linux")]+ {+ if std::env::var_os("APPIMAGE").is_some() {+ cmd.env_remove("LD_LIBRARY_PATH");+ cmd.env_remove("LD_PRELOAD");+ cmd.env_remove("APPIMAGE");+ cmd.env_remove("APPIMAGE_UUID");+ cmd.env_remove("APPDIR");+ cmd.env_remove("ARGV0");+ }+ }+}+/// Error message shown when `uv sync` can't even be spawned (#331) —/// e.g. the resolved `uv` binary doesn't exist or isn't executable.fn format_uv_sync_spawn_error(root: &std::path::Path, uv_bin: &str, err: &str) -> String {@@ -734,13 +767,15 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {// Try the bundled sidecar first, fall back to system ollamalet ollama_child = {let ollama_bin = resolve_bin("ollama");- let sidecar = tokio::process::Command::new(&ollama_bin)+ let mut sidecar_cmd = tokio::process::Command::new(&ollama_bin);+ sidecar_cmd.arg("serve").env("OLLAMA_HOST", format!("127.0.0.1:{}", OLLAMA_PORT)).stdout(std::process::Stdio::null())- .stderr(std::process::Stdio::null())- .spawn();- match sidecar {+ .stderr(std::process::Stdio::null());+ // Avoid LD_LIBRARY_PATH leak when running inside an AppImage (#455).+ prepare_subprocess_for_appimage(&mut sidecar_cmd);+ match sidecar_cmd.spawn() {Ok(child) => Some(child),Err(_) => None,}@@ -980,41 +1015,106 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {}}- // Kill any leftover server on our port from a previous run+ // If something is already serving on our port, decide what to do based+ // on what it actually responds with — don't blindly kill it (#455).+ //+ // The OLD behaviour was: any HTTP response (even 404) → `fuser -k 8000/tcp`+ // / `taskkill /PID /F`. That broke the legitimate case where a user had+ // already started `jarvis serve` in a terminal and then launched the+ // desktop app — the app killed their server, then raced to spawn its+ // own, sometimes losing the race and hanging.+ //+ // New behaviour, by response shape:+ // * 2xx /health — healthy jarvis serve. Attach to it; skip the+ // uv-sync + spawn dance entirely. Done.+ // * 503 — server is up but engine isn't ready. Surface+ // an actionable message; don't kill (matches+ // our wait_for_jarvis_health 503 contract).+ // * any other status — something else is listening on the port. Tell+ // the user via the error banner instead of+ // force-killing a foreign service.+ // * Err (conn refused) — nothing is listening. Proceed to spawn.+ //+ // TODO(#455 follow-up): validate /health response body before attaching+ // so a multi-user host can't trivially spoof us. Also accept a port+ // override from config instead of hard-coding JARVIS_PORT.{let client = reqwest::Client::builder().timeout(Duration::from_secs(2)).build().unwrap();- if client+ match client.get(format!("http://127.0.0.1:{}/health", JARVIS_PORT)).send().await- .is_ok(){- // Something is already listening — try to kill it- #[cfg(unix)]- {- let _ = tokio::process::Command::new("fuser")- .args(["-k", &format!("{}/tcp", JARVIS_PORT)])- .output()- .await;- tokio::time::sleep(Duration::from_secs(2)).await;- }- #[cfg(target_os = "windows")]- {- // Find the PID holding the port via netstat, then kill it- if let Ok(output) = tokio::process::Command::new("cmd")- .args(["/C", &format!(- "for /f \"tokens=5\" %a in ('netstat -ano ^| findstr :{port} ^| findstr LISTENING') do taskkill /PID %a /F",- port = JARVIS_PORT,- )])- .output()+ Ok(resp) if resp.status().is_success() => {+ // Confirm with a second probe — the first might have caught+ // a flickering server (engine half-loaded, dying mid-stop,+ // etc.) and we don't want to claim ready off a 2-second+ // snapshot. Small sleep between to give the server room.+ tokio::time::sleep(Duration::from_millis(500)).await;+ let confirm = client+ .get(format!("http://127.0.0.1:{}/health", JARVIS_PORT))+ .send().await- {- let _ = output; // best-effort+ .map(|r| r.status().is_success())+ .unwrap_or(false);+ if !confirm {+ // First probe was 2xx but the second wasn't — fall+ // through to the spawn path. The server probably went+ // away between probes.+ // (No early return — we want to spawn our own.)+ } else {+ // Attach to the existing healthy server. Mark every+ // pre-spawn step done so the setup UI doesn't show a+ // half-progress bar (model_ready / ollama_ready stay+ // false otherwise because we skipped those steps).+ let mut s = status.lock().await;+ s.phase = "ready".into();+ s.detail = format!(+ "Connected to existing API server on port {}.",+ JARVIS_PORT,+ );+ s.server_ready = true;+ s.model_ready = true;+ s.ollama_ready = true;+ return;}- tokio::time::sleep(Duration::from_secs(2)).await;+ }+ Ok(resp) if resp.status() == reqwest::StatusCode::SERVICE_UNAVAILABLE => {+ let mut s = status.lock().await;+ s.error = Some(format!(+ "An API server is already running on port {} but its \+ inference engine isn't ready (HTTP 503). If this is your \+ `jarvis serve`, wait for it to finish loading and relaunch. \+ Otherwise, stop that service or change the port.",+ JARVIS_PORT,+ ));+ return;+ }+ Ok(resp) => {+ // Something else (a different web server, a stale process,+ // a 4xx-returning instance) is on our port. Don't kill it —+ // give the user actionable info instead.+ let lsof_hint = if cfg!(target_os = "windows") {+ format!("netstat -ano | findstr :{}", JARVIS_PORT)+ } else {+ format!("lsof -i :{}", JARVIS_PORT)+ };+ let mut s = status.lock().await;+ s.error = Some(format!(+ "Port {} is already in use by another service (it answered \+ /health with HTTP {}). Stop that service or change the \+ OpenJarvis port, then relaunch.\n\nTo identify it:\n {}",+ JARVIS_PORT,+ resp.status(),+ lsof_hint,+ ));+ return;+ }+ Err(_) => {+ // Nothing listening — proceed to the normal spawn path.}}}@@ -1039,7 +1139,8 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {let mut s = status.lock().await;s.detail = "Installing dependencies (uv sync — may take 1-2 min on first boot)...".into();}- let sync_output = tokio::process::Command::new(&uv_bin)+ let mut sync_cmd = tokio::process::Command::new(&uv_bin);+ sync_cmd.args(["sync","--extra", "server",@@ -1048,9 +1149,10 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {]).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped())- .current_dir(root)- .output()- .await;+ .current_dir(root);+ // Avoid LD_LIBRARY_PATH leak when running inside an AppImage (#455).+ prepare_subprocess_for_appimage(&mut sync_cmd);+ let sync_output = sync_cmd.output().await;match sync_output {Ok(out) if !out.status.success() => {let stderr = String::from_utf8_lossy(&out.stderr);@@ -1097,6 +1199,10 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped()).current_dir(root);+ // Avoid LD_LIBRARY_PATH leak when running inside an AppImage (#455) —+ // do this BEFORE cmd.env() calls below so our explicit cloud-key env+ // additions aren't accidentally stripped.+ prepare_subprocess_for_appimage(&mut cmd);// Inject cloud API keys from ~/.openjarvis/cloud-keys.envfor (key, value) in read_cloud_keys() {@@ -2544,4 +2650,78 @@ mod tests {let doc: toml_edit::DocumentMut = out.parse().unwrap();assert_eq!(doc["engine"]["lmstudio"]["host"].as_str(), Some("http://new:2"));}++ // -----------------------------------------------------------------+ // #455 — AppImage subprocess env-strip helper+ // -----------------------------------------------------------------+ //+ // `prepare_subprocess_for_appimage` strips LD_LIBRARY_PATH (and the+ // related AppImage runtime variables) from a child `Command` ONLY+ // when the parent process is itself running inside an AppImage —+ // detected by the presence of the `APPIMAGE` env variable that the+ // AppImage runtime sets to the original .AppImage path. We can't+ // observe the env_remove calls directly through tokio's Command+ // API (it doesn't expose its env map publicly), so these tests+ // exercise the documented contract on each platform:+ //+ // * on macOS / Windows: the function is a no-op regardless of env.+ // * on Linux without $APPIMAGE: also a no-op.+ // * on Linux with $APPIMAGE: it doesn't panic, doesn't return an+ // error, and the calling code that follows succeeds. The+ // observable behaviour test is the integration repro on a real+ // AppImage build (covered in PR test plan).+ //+ // The Mutex serialises any test that touches the process-wide+ // `APPIMAGE` env var so cargo test's parallel runner can't race two+ // tests setting and unsetting it concurrently. `static Mutex` works+ // on a const path since Rust 1.63 (and Tauri's MSRV is well above).++ static APPIMAGE_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());++ // Pick a binary that exists on every test target so the test body is+ // doing something other than constructing an obviously-broken command+ // path on Windows.+ #[cfg(target_os = "windows")]+ const HARMLESS_BIN: &str = "cmd";+ #[cfg(not(target_os = "windows"))]+ const HARMLESS_BIN: &str = "/bin/true";++ #[test]+ fn prepare_subprocess_for_appimage_no_appimage_is_safe() {+ let _guard = APPIMAGE_ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());+ let prev = std::env::var_os("APPIMAGE");+ // SAFETY: APPIMAGE_ENV_LOCK serialises every test that touches+ // this env var, so the mutation is single-threaded for the+ // duration of the lock. The 2024-edition env mutation rules+ // require the `unsafe` block but the guard makes it sound.+ unsafe {+ std::env::remove_var("APPIMAGE");+ }+ let mut cmd = tokio::process::Command::new(HARMLESS_BIN);+ super::prepare_subprocess_for_appimage(&mut cmd);+ if let Some(v) = prev {+ unsafe {+ std::env::set_var("APPIMAGE", v);+ }+ }+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn prepare_subprocess_for_appimage_with_appimage_set_is_safe() {+ let _guard = APPIMAGE_ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());+ let prev = std::env::var_os("APPIMAGE");+ unsafe {+ std::env::set_var("APPIMAGE", "/tmp/test.AppImage");+ }+ let mut cmd = tokio::process::Command::new(HARMLESS_BIN);+ super::prepare_subprocess_for_appimage(&mut cmd);+ unsafe {+ if let Some(v) = prev {+ std::env::set_var("APPIMAGE", v);+ } else {+ std::env::remove_var("APPIMAGE");+ }+ }+ }}