Move macOS app rename migration to updater startup

Signed-off-by: Yujong Lee <yujonglee.dev@gmail.com>

Author: yujonglee

Cargo.lock

@@ -22,12 +22,8 @@ tokio = { workspace = true, features = ["macros", "time"] }
 tauri = { workspace = true, features = ["test"] }
 tauri-specta = { workspace = true, features = ["derive", "typescript"] }
 
-flate2 = "1"
 serde = { workspace = true }
 specta = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
-tar = "0.4"
-tempfile = { workspace = true }
-
 thiserror = { workspace = true }
 tracing = { workspace = true }

plugins/updater2/Cargo.toml

@@ -64,7 +64,7 @@ updatedEvent: "plugin:updater2:updated-event"
 
 /** user-defined types **/
 
-export type InstallResult = { kind: "relaunch_current" } | { kind: "macos_bundle_update"; current_path: string; staged_path: string; target_path: string; backup_path: string; stage_dir: string }
+export type InstallResult = { kind: "relaunch_current" }
 export type UpdateDownloadFailedEvent = { version: string }
 export type UpdateDownloadingEvent = { version: string }
 export type UpdateReadyEvent = { version: string }

plugins/updater2/js/bindings.gen.ts

@@ -20,18 +20,8 @@ pub enum Error {
     VersionMismatch { expected: String, actual: String },
     #[error("failed to determine current app path")]
     FailedToDetermineCurrentAppPath,
-    #[error("failed to determine target app path")]
-    FailedToDetermineTargetAppPath,
-    #[error("invalid update archive: {0}")]
-    InvalidUpdateArchive(String),
     #[error("failed to schedule installed app launch at {path}: {details}")]
     FailedToScheduleInstalledAppLaunch { path: String, details: String },
-    #[error("macOS authorization step failed: {details}")]
-    MacosAuthorizationFailed { details: String },
-    #[error("macOS target bundle already exists at {path}")]
-    MacosTargetBundleConflict { path: String },
-    #[error("invalid postinstall state: {0}")]
-    InvalidPostinstallState(String),
 }
 
 impl Serialize for Error {

plugins/updater2/src/error.rs

@@ -13,13 +13,6 @@ use crate::events::{
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum InstallResult {
     RelaunchCurrent,
-    MacosBundleUpdate {
-        current_path: String,
-        staged_path: String,
-        target_path: String,
-        backup_path: String,
-        stage_dir: String,
-    },
 }
 
 pub struct Updater2<'a, R: tauri::Runtime, M: tauri::Manager<R>> {
@@ -189,79 +182,16 @@ impl<'a, R: tauri::Runtime, M: tauri::Manager<R>> Updater2<'a, R, M> {
             let _ = store.save();
         }
 
-        #[cfg(target_os = "macos")]
-        {
-            let stage_dir = self.create_macos_update_stage_dir(version)?;
-            let staged_update = match crate::migration::stage_macos_update(&bytes, &stage_dir) {
-                Ok(staged_update) => staged_update,
-                Err(err) => {
-                    let _ = std::fs::remove_dir_all(&stage_dir);
-                    return Err(err);
-                }
-            };
-
-            Ok(InstallResult::MacosBundleUpdate {
-                current_path: staged_update.current_app_path.display().to_string(),
-                staged_path: staged_update.staged_app_path.display().to_string(),
-                target_path: staged_update.target_app_path.display().to_string(),
-                backup_path: staged_update.current_backup_path.display().to_string(),
-                stage_dir: staged_update.stage_dir.display().to_string(),
-            })
-        }
-
-        #[cfg(not(target_os = "macos"))]
-        {
-            update.install(&bytes)?;
-            Ok(InstallResult::RelaunchCurrent)
-        }
+        update.install(&bytes)?;
+        Ok(InstallResult::RelaunchCurrent)
     }
 
     pub async fn postinstall(&self, result: InstallResult) -> Result<(), crate::Error> {
         match result {
             InstallResult::RelaunchCurrent => {
                 self.manager.app_handle().restart();
             }
-            InstallResult::MacosBundleUpdate {
-                current_path,
-                staged_path,
-                target_path,
-                backup_path,
-                stage_dir,
-            } => {
-                #[cfg(target_os = "macos")]
-                {
-                    let handle = self.manager.app_handle().clone();
-                    let current_pid = std::process::id();
-
-                    crate::migration::schedule_macos_update_after_exit(
-                        current_pid,
-                        crate::migration::StagedMacosUpdate {
-                            current_app_path: PathBuf::from(current_path),
-                            staged_app_path: PathBuf::from(staged_path),
-                            target_app_path: PathBuf::from(target_path),
-                            current_backup_path: PathBuf::from(backup_path),
-                            stage_dir: PathBuf::from(stage_dir),
-                        },
-                    )?;
-
-                    handle.exit(0);
-                }
-                #[cfg(not(target_os = "macos"))]
-                {
-                    let _ = (
-                        current_path,
-                        staged_path,
-                        target_path,
-                        backup_path,
-                        stage_dir,
-                    );
-                    return Err(crate::Error::InvalidPostinstallState(
-                        "macos_bundle_update is only valid on macOS".into(),
-                    ));
-                }
-            }
         }
-        Ok(())
     }
 }
 
@@ -295,48 +225,3 @@ fn get_cache_path<R: tauri::Runtime, M: tauri::Manager<R>>(
         .map(|p: PathBuf| p.join("updates"))?;
     Some(dir.join(format!("{}.bin", version)))
 }
-
-#[cfg(target_os = "macos")]
-impl<'a, R: tauri::Runtime, M: tauri::Manager<R>> Updater2<'a, R, M> {
-    fn create_macos_update_stage_dir(&self, version: &str) -> Result<PathBuf, crate::Error> {
-        let base_dir = self
-            .manager
-            .app_handle()
-            .path()
-            .app_cache_dir()
-            .map_err(|_| crate::Error::CachePathUnavailable)?
-            .join("updates")
-            .join("staged");
-        std::fs::create_dir_all(&base_dir)?;
-
-        let version = sanitize_path_component(version);
-        let current_pid = std::process::id();
-
-        for attempt in 0..100 {
-            let nanos = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap_or_default()
-                .as_nanos();
-            let stage_dir = base_dir.join(format!("{version}-{current_pid}-{nanos}-{attempt}"));
-
-            match std::fs::create_dir(&stage_dir) {
-                Ok(()) => return Ok(stage_dir),
-                Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => continue,
-                Err(err) => return Err(err.into()),
-            }
-        }
-
-        Err(crate::Error::CachePathUnavailable)
-    }
-}
-
-#[cfg(target_os = "macos")]
-fn sanitize_path_component(value: &str) -> String {
-    value
-        .chars()
-        .map(|ch| match ch {
-            'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' => ch,
-            _ => '_',
-        })
-        .collect()
-}

plugins/updater2/src/ext.rs

@@ -3,7 +3,7 @@ mod error;
 mod events;
 mod ext;
 #[cfg(target_os = "macos")]
-mod migration;
+mod startup_migration;
 mod store;
 
 pub use error::{Error, Result};
@@ -40,6 +40,13 @@ pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
         .setup(move |app, _api| {
             specta_builder.mount_events(app);
 
+            #[cfg(target_os = "macos")]
+            match startup_migration::maybe_schedule_legacy_bundle_rename_on_launch(app) {
+                Ok(true) => {}
+                Ok(false) => {}
+                Err(err) => tracing::error!("failed to schedule legacy bundle rename: {}", err),
+            }
+
             let handle = app.clone();
             tauri::async_runtime::spawn(async move {
                 loop {