Move a translocated Lite to Applications before updating (0.0.96)

src-tauri/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "lite"
-version = "0.0.95"
+version = "0.0.96"
 description = "A fast, local workspace for AI coding agents."
 authors = ["Ultralytics"]
 edition = "2024"

src-tauri/src/lib.rs

@@ -7968,8 +7968,67 @@ async fn check_update(app: AppHandle) -> Result<Option<ReleaseInfo>, String> {
         .map_err(|error| error.to_string())
 }
 
+// macOS runs a downloaded app that Finder never moved from a read-only copy, which no update can replace.
+// Lite copies itself where dragging it would have put it and lifts the download mark, so the copy opens in
+// place, as apps that offer to move themselves to Applications do.
+#[cfg(target_os = "macos")]
+fn move_to_applications(bundle: &Path) -> Result<PathBuf, String> {
+    let name = bundle.file_name().ok_or("Could not read Lite's location")?;
+    let mut folders = vec![PathBuf::from("/Applications")];
+    folders.extend(std::env::home_dir().map(|home| home.join("Applications")));
+    for folder in folders {
+        let _ = fs::create_dir_all(&folder);
+        let staged = folder.join(format!(".{}.new", name.to_string_lossy()));
+        let _ = fs::remove_dir_all(&staged);
+        if !Command::new("/usr/bin/ditto")
+            .arg(bundle)
+            .arg(&staged)
+            .status()
+            .is_ok_and(|status| status.success())
+        {
+            continue;
+        }
+        // An older Lite already there is the one this copy replaces.
+        let target = folder.join(name);
+        let _ = fs::remove_dir_all(&target);
+        if fs::rename(&staged, &target).is_err() {
+            let _ = fs::remove_dir_all(&staged);
+            continue;
+        }
+        let _ = Command::new("/usr/bin/xattr")
+            .args(["-dr", "com.apple.quarantine"])
+            .arg(&target)
+            .status();
+        return Ok(target);
+    }
+    Err("Drag Lite into your Applications folder, open it from there, and update again".into())
+}
+
 #[tauri::command]
 async fn install_update(app: AppHandle) -> Result<(), String> {
+    // The moved copy opens to the same update waiting for it.
+    #[cfg(target_os = "macos")]
+    if let Some(bundle) = std::env::current_exe()
+        .ok()
+        .and_then(|executable| executable.ancestors().nth(3).map(Path::to_path_buf))
+        .filter(|bundle| bundle.to_string_lossy().contains("/AppTranslocation/"))
+    {
+        let moved = tauri::async_runtime::spawn_blocking(move || move_to_applications(&bundle))
+            .await
+            .map_err(|error| error.to_string())??;
+        Command::new("/usr/bin/open")
+            .arg("-n")
+            .arg(&moved)
+            .spawn()
+            .map_err(|error| {
+                format!(
+                    "Moved Lite to {}, but could not open it: {error}",
+                    path_text(&moved)
+                )
+            })?;
+        app.exit(0);
+        return Ok(());
+    }
     let cleanup_app = app.clone();
     let update = app
         .updater_builder()