windows: Implement AutoUpdater (#25734)

Part of #24800



https://github.com/user-attachments/assets/e70d594e-3635-4f93-9073-5abf7e9d2b20



Release Notes:

- N/A

crates/auto_update_helper/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "auto_update_helper"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[[bin]]
+name = "auto_update_helper"
+path = "src/auto_update_helper.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+log.workspace = true
+simplelog.workspace = true
+workspace-hack.workspace = true
+
+[target.'cfg(target_os = "windows")'.dependencies]
+windows.workspace = true
+
+[target.'cfg(target_os = "windows")'.build-dependencies]
+winresource = "0.1"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-pc-windows-msvc"]

crates/auto_update_helper/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/auto_update_helper/build.rs

@@ -0,0 +1,15 @@
+fn main() {
+    #[cfg(target_os = "windows")]
+    {
+        println!("cargo:rerun-if-changed=manifest.xml");
+
+        let mut res = winresource::WindowsResource::new();
+        res.set_manifest_file("manifest.xml");
+        res.set_icon("app-icon.ico");
+
+        if let Err(e) = res.compile() {
+            eprintln!("{}", e);
+            std::process::exit(1);
+        }
+    }
+}

crates/auto_update_helper/manifest.xml

@@ -0,0 +1,16 @@
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <asmv3:application>
+        <asmv3:windowsSettings>
+            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
+            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+        </asmv3:windowsSettings>
+    </asmv3:application>
+    <dependency>
+        <dependentAssembly>
+            <assemblyIdentity type='win32'
+                name='Microsoft.Windows.Common-Controls'
+                version='6.0.0.0' processorArchitecture='*'
+                publicKeyToken='6595b64144ccf1df' />
+        </dependentAssembly>
+    </dependency>
+</assembly>

crates/auto_update_helper/src/auto_update_helper.rs

@@ -0,0 +1,94 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+#[cfg(target_os = "windows")]
+mod dialog;
+#[cfg(target_os = "windows")]
+mod updater;
+
+#[cfg(target_os = "windows")]
+fn main() {
+    if let Err(e) = windows_impl::run() {
+        log::error!("Error: Zed update failed, {:?}", e);
+        windows_impl::show_error(format!("Error: {:?}", e));
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+fn main() {}
+
+#[cfg(target_os = "windows")]
+mod windows_impl {
+    use std::path::Path;
+
+    use super::dialog::create_dialog_window;
+    use super::updater::perform_update;
+    use anyhow::{Context, Result};
+    use windows::{
+        Win32::{
+            Foundation::{HWND, LPARAM, WPARAM},
+            UI::WindowsAndMessaging::{
+                DispatchMessageW, GetMessageW, MB_ICONERROR, MB_SYSTEMMODAL, MSG, MessageBoxW,
+                PostMessageW, WM_USER,
+            },
+        },
+        core::HSTRING,
+    };
+
+    pub(crate) const WM_JOB_UPDATED: u32 = WM_USER + 1;
+    pub(crate) const WM_TERMINATE: u32 = WM_USER + 2;
+
+    pub(crate) fn run() -> Result<()> {
+        let helper_dir = std::env::current_exe()?
+            .parent()
+            .context("No parent directory")?
+            .to_path_buf();
+        init_log(&helper_dir)?;
+        let app_dir = helper_dir
+            .parent()
+            .context("No parent directory")?
+            .to_path_buf();
+
+        log::info!("======= Starting Zed update =======");
+        let (tx, rx) = std::sync::mpsc::channel();
+        let hwnd = create_dialog_window(rx)?.0 as isize;
+        std::thread::spawn(move || {
+            let result = perform_update(app_dir.as_path(), Some(hwnd));
+            tx.send(result).ok();
+            unsafe { PostMessageW(Some(HWND(hwnd as _)), WM_TERMINATE, WPARAM(0), LPARAM(0)) }.ok();
+        });
+        unsafe {
+            let mut message = MSG::default();
+            while GetMessageW(&mut message, None, 0, 0).as_bool() {
+                DispatchMessageW(&message);
+            }
+        }
+        Ok(())
+    }
+
+    fn init_log(helper_dir: &Path) -> Result<()> {
+        simplelog::WriteLogger::init(
+            simplelog::LevelFilter::Info,
+            simplelog::Config::default(),
+            std::fs::File::options()
+                .append(true)
+                .create(true)
+                .open(helper_dir.join("auto_update_helper.log"))?,
+        )?;
+        Ok(())
+    }
+
+    pub(crate) fn show_error(mut content: String) {
+        if content.len() > 600 {
+            content.truncate(600);
+            content.push_str("...\n");
+        }
+        let _ = unsafe {
+            MessageBoxW(
+                None,
+                &HSTRING::from(content),
+                windows::core::w!("Error: Zed update failed."),
+                MB_ICONERROR | MB_SYSTEMMODAL,
+            )
+        };
+    }
+}

crates/auto_update_helper/src/dialog.rs

@@ -0,0 +1,236 @@
+use std::{cell::RefCell, sync::mpsc::Receiver};
+
+use anyhow::{Context as _, Result};
+use windows::{
+    Win32::{
+        Foundation::{HWND, LPARAM, LRESULT, RECT, WPARAM},
+        Graphics::Gdi::{
+            BeginPaint, CLEARTYPE_QUALITY, CLIP_DEFAULT_PRECIS, CreateFontW, DEFAULT_CHARSET,
+            DeleteObject, EndPaint, FW_NORMAL, LOGFONTW, OUT_TT_ONLY_PRECIS, PAINTSTRUCT,
+            ReleaseDC, SelectObject, TextOutW,
+        },
+        System::LibraryLoader::GetModuleHandleW,
+        UI::{
+            Controls::{PBM_SETRANGE, PBM_SETSTEP, PBM_STEPIT, PROGRESS_CLASS},
+            WindowsAndMessaging::{
+                CREATESTRUCTW, CS_HREDRAW, CS_VREDRAW, CreateWindowExW, DefWindowProcW,
+                GWLP_USERDATA, GetDesktopWindow, GetWindowLongPtrW, GetWindowRect, HICON,
+                IMAGE_ICON, LR_DEFAULTSIZE, LR_SHARED, LoadImageW, PostQuitMessage, RegisterClassW,
+                SPI_GETICONTITLELOGFONT, SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS, SendMessageW,
+                SetWindowLongPtrW, SystemParametersInfoW, WINDOW_EX_STYLE, WM_CLOSE, WM_CREATE,
+                WM_DESTROY, WM_NCCREATE, WM_PAINT, WNDCLASSW, WS_CAPTION, WS_CHILD, WS_EX_TOPMOST,
+                WS_POPUP, WS_VISIBLE,
+            },
+        },
+    },
+    core::HSTRING,
+};
+
+use crate::{
+    updater::JOBS,
+    windows_impl::{WM_JOB_UPDATED, WM_TERMINATE, show_error},
+};
+
+#[repr(C)]
+#[derive(Debug)]
+struct DialogInfo {
+    rx: Receiver<Result<()>>,
+    progress_bar: isize,
+}
+
+pub(crate) fn create_dialog_window(receiver: Receiver<Result<()>>) -> Result<HWND> {
+    unsafe {
+        let class_name = windows::core::w!("Zed-Auto-Updater-Dialog-Class");
+        let module = GetModuleHandleW(None).context("unable to get module handle")?;
+        let handle = LoadImageW(
+            Some(module.into()),
+            windows::core::PCWSTR(1 as _),
+            IMAGE_ICON,
+            0,
+            0,
+            LR_DEFAULTSIZE | LR_SHARED,
+        )
+        .context("unable to load icon file")?;
+        let wc = WNDCLASSW {
+            lpfnWndProc: Some(wnd_proc),
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            hIcon: HICON(handle.0),
+            ..Default::default()
+        };
+        RegisterClassW(&wc);
+        let mut rect = RECT::default();
+        GetWindowRect(GetDesktopWindow(), &mut rect)
+            .context("unable to get desktop window rect")?;
+        let width = 400;
+        let height = 150;
+        let info = Box::new(RefCell::new(DialogInfo {
+            rx: receiver,
+            progress_bar: 0,
+        }));
+
+        let hwnd = CreateWindowExW(
+            WS_EX_TOPMOST,
+            class_name,
+            windows::core::w!("Zed Editor"),
+            WS_VISIBLE | WS_POPUP | WS_CAPTION,
+            rect.right / 2 - width / 2,
+            rect.bottom / 2 - height / 2,
+            width,
+            height,
+            None,
+            None,
+            None,
+            Some(Box::into_raw(info) as _),
+        )
+        .context("unable to create dialog window")?;
+        Ok(hwnd)
+    }
+}
+
+macro_rules! return_if_failed {
+    ($e:expr) => {
+        match $e {
+            Ok(v) => v,
+            Err(e) => {
+                return LRESULT(e.code().0 as _);
+            }
+        }
+    };
+}
+
+macro_rules! make_lparam {
+    ($l:expr, $h:expr) => {
+        LPARAM(($l as u32 | ($h as u32) << 16) as isize)
+    };
+}
+
+unsafe extern "system" fn wnd_proc(
+    hwnd: HWND,
+    msg: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    match msg {
+        WM_NCCREATE => unsafe {
+            let create_struct = lparam.0 as *const CREATESTRUCTW;
+            let info = (*create_struct).lpCreateParams as *mut RefCell<DialogInfo>;
+            let info = Box::from_raw(info);
+            SetWindowLongPtrW(hwnd, GWLP_USERDATA, Box::into_raw(info) as _);
+            DefWindowProcW(hwnd, msg, wparam, lparam)
+        },
+        WM_CREATE => unsafe {
+            // Create progress bar
+            let mut rect = RECT::default();
+            return_if_failed!(GetWindowRect(hwnd, &mut rect));
+            let progress_bar = return_if_failed!(CreateWindowExW(
+                WINDOW_EX_STYLE(0),
+                PROGRESS_CLASS,
+                None,
+                WS_CHILD | WS_VISIBLE,
+                20,
+                50,
+                340,
+                35,
+                Some(hwnd),
+                None,
+                None,
+                None,
+            ));
+            SendMessageW(
+                progress_bar,
+                PBM_SETRANGE,
+                None,
+                Some(make_lparam!(0, JOBS.len() * 10)),
+            );
+            SendMessageW(progress_bar, PBM_SETSTEP, Some(WPARAM(10)), None);
+            with_dialog_data(hwnd, |data| {
+                data.borrow_mut().progress_bar = progress_bar.0 as isize
+            });
+            LRESULT(0)
+        },
+        WM_PAINT => unsafe {
+            let mut ps = PAINTSTRUCT::default();
+            let hdc = BeginPaint(hwnd, &mut ps);
+
+            let font_name = get_system_ui_font_name();
+            let font = CreateFontW(
+                24,
+                0,
+                0,
+                0,
+                FW_NORMAL.0 as _,
+                0,
+                0,
+                0,
+                DEFAULT_CHARSET,
+                OUT_TT_ONLY_PRECIS,
+                CLIP_DEFAULT_PRECIS,
+                CLEARTYPE_QUALITY,
+                0,
+                &HSTRING::from(font_name),
+            );
+            let temp = SelectObject(hdc, font.into());
+            let string = HSTRING::from("Zed Editor is updating...");
+            return_if_failed!(TextOutW(hdc, 20, 15, &string).ok());
+            return_if_failed!(DeleteObject(temp).ok());
+
+            return_if_failed!(EndPaint(hwnd, &ps).ok());
+            ReleaseDC(Some(hwnd), hdc);
+
+            LRESULT(0)
+        },
+        WM_JOB_UPDATED => with_dialog_data(hwnd, |data| {
+            let progress_bar = data.borrow().progress_bar;
+            unsafe { SendMessageW(HWND(progress_bar as _), PBM_STEPIT, None, None) }
+        }),
+        WM_TERMINATE => {
+            with_dialog_data(hwnd, |data| {
+                if let Ok(result) = data.borrow_mut().rx.recv() {
+                    if let Err(e) = result {
+                        log::error!("Failed to update Zed: {:?}", e);
+                        show_error(format!("Error: {:?}", e));
+                    }
+                }
+            });
+            unsafe { PostQuitMessage(0) };
+            LRESULT(0)
+        }
+        WM_CLOSE => LRESULT(0), // Prevent user occasionally closing the window
+        WM_DESTROY => {
+            unsafe { PostQuitMessage(0) };
+            LRESULT(0)
+        }
+        _ => unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) },
+    }
+}
+
+fn with_dialog_data<F, T>(hwnd: HWND, f: F) -> T
+where
+    F: FnOnce(&RefCell<DialogInfo>) -> T,
+{
+    let raw = unsafe { GetWindowLongPtrW(hwnd, GWLP_USERDATA) as *mut RefCell<DialogInfo> };
+    let data = unsafe { Box::from_raw(raw) };
+    let result = f(data.as_ref());
+    unsafe { SetWindowLongPtrW(hwnd, GWLP_USERDATA, Box::into_raw(data) as _) };
+    result
+}
+
+fn get_system_ui_font_name() -> String {
+    unsafe {
+        let mut info: LOGFONTW = std::mem::zeroed();
+        if SystemParametersInfoW(
+            SPI_GETICONTITLELOGFONT,
+            std::mem::size_of::<LOGFONTW>() as u32,
+            Some(&mut info as *mut _ as _),
+            SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
+        )
+        .is_ok()
+        {
+            let font_name = String::from_utf16_lossy(&info.lfFaceName);
+            font_name.trim_matches(char::from(0)).to_owned()
+        } else {
+            "MS Shell Dlg".to_owned()
+        }
+    }
+}

crates/auto_update_helper/src/updater.rs

@@ -0,0 +1,171 @@
+use std::{
+    os::windows::process::CommandExt,
+    path::Path,
+    time::{Duration, Instant},
+};
+
+use anyhow::{Context, Result};
+use windows::Win32::{
+    Foundation::{HWND, LPARAM, WPARAM},
+    System::Threading::CREATE_NEW_PROCESS_GROUP,
+    UI::WindowsAndMessaging::PostMessageW,
+};
+
+use crate::windows_impl::WM_JOB_UPDATED;
+
+type Job = fn(&Path) -> Result<()>;
+
+#[cfg(not(test))]
+pub(crate) const JOBS: [Job; 6] = [
+    // Delete old files
+    |app_dir| {
+        let zed_executable = app_dir.join("Zed.exe");
+        log::info!("Removing old file: {}", zed_executable.display());
+        std::fs::remove_file(&zed_executable).context(format!(
+            "Failed to remove old file {}",
+            zed_executable.display()
+        ))
+    },
+    |app_dir| {
+        let zed_cli = app_dir.join("bin\\zed.exe");
+        log::info!("Removing old file: {}", zed_cli.display());
+        std::fs::remove_file(&zed_cli)
+            .context(format!("Failed to remove old file {}", zed_cli.display()))
+    },
+    // Copy new files
+    |app_dir| {
+        let zed_executable_source = app_dir.join("install\\Zed.exe");
+        let zed_executable_dest = app_dir.join("Zed.exe");
+        log::info!(
+            "Copying new file {} to {}",
+            zed_executable_source.display(),
+            zed_executable_dest.display()
+        );
+        std::fs::copy(&zed_executable_source, &zed_executable_dest)
+            .map(|_| ())
+            .context(format!(
+                "Failed to copy new file {} to {}",
+                zed_executable_source.display(),
+                zed_executable_dest.display()
+            ))
+    },
+    |app_dir| {
+        let zed_cli_source = app_dir.join("install\\bin\\zed.exe");
+        let zed_cli_dest = app_dir.join("bin\\zed.exe");
+        log::info!(
+            "Copying new file {} to {}",
+            zed_cli_source.display(),
+            zed_cli_dest.display()
+        );
+        std::fs::copy(&zed_cli_source, &zed_cli_dest)
+            .map(|_| ())
+            .context(format!(
+                "Failed to copy new file {} to {}",
+                zed_cli_source.display(),
+                zed_cli_dest.display()
+            ))
+    },
+    // Clean up installer folder and updates folder
+    |app_dir| {
+        let updates_folder = app_dir.join("updates");
+        log::info!("Cleaning up: {}", updates_folder.display());
+        std::fs::remove_dir_all(&updates_folder).context(format!(
+            "Failed to remove updates folder {}",
+            updates_folder.display()
+        ))
+    },
+    |app_dir| {
+        let installer_folder = app_dir.join("install");
+        log::info!("Cleaning up: {}", installer_folder.display());
+        std::fs::remove_dir_all(&installer_folder).context(format!(
+            "Failed to remove installer folder {}",
+            installer_folder.display()
+        ))
+    },
+];
+
+#[cfg(test)]
+pub(crate) const JOBS: [Job; 2] = [
+    |_| {
+        std::thread::sleep(Duration::from_millis(1000));
+        if let Ok(config) = std::env::var("ZED_AUTO_UPDATE") {
+            match config.as_str() {
+                "err" => Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "Simulated error",
+                ))
+                .context("Anyhow!"),
+                _ => panic!("Unknown ZED_AUTO_UPDATE value: {}", config),
+            }
+        } else {
+            Ok(())
+        }
+    },
+    |_| {
+        std::thread::sleep(Duration::from_millis(1000));
+        if let Ok(config) = std::env::var("ZED_AUTO_UPDATE") {
+            match config.as_str() {
+                "err" => Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "Simulated error",
+                ))
+                .context("Anyhow!"),
+                _ => panic!("Unknown ZED_AUTO_UPDATE value: {}", config),
+            }
+        } else {
+            Ok(())
+        }
+    },
+];
+
+pub(crate) fn perform_update(app_dir: &Path, hwnd: Option<isize>) -> Result<()> {
+    let hwnd = hwnd.map(|ptr| HWND(ptr as _));
+
+    for job in JOBS.iter() {
+        let start = Instant::now();
+        loop {
+            if start.elapsed().as_secs() > 2 {
+                return Err(anyhow::anyhow!("Timed out"));
+            }
+            match (*job)(app_dir) {
+                Ok(_) => {
+                    unsafe { PostMessageW(hwnd, WM_JOB_UPDATED, WPARAM(0), LPARAM(0))? };
+                    break;
+                }
+                Err(err) => {
+                    // Check if it's a "not found" error
+                    let io_err = err.downcast_ref::<std::io::Error>().unwrap();
+                    if io_err.kind() == std::io::ErrorKind::NotFound {
+                        log::warn!("File or folder not found.");
+                        unsafe { PostMessageW(hwnd, WM_JOB_UPDATED, WPARAM(0), LPARAM(0))? };
+                        break;
+                    }
+
+                    log::error!("Operation failed: {}", err);
+                    std::thread::sleep(Duration::from_millis(50));
+                }
+            }
+        }
+    }
+    let _ = std::process::Command::new(app_dir.join("Zed.exe"))
+        .creation_flags(CREATE_NEW_PROCESS_GROUP.0)
+        .spawn();
+    log::info!("Update completed successfully");
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::perform_update;
+
+    #[test]
+    fn test_perform_update() {
+        let app_dir = std::path::Path::new("C:/");
+        assert!(perform_update(app_dir, None).is_ok());
+
+        // Simulate a timeout
+        unsafe { std::env::set_var("ZED_AUTO_UPDATE", "err") };
+        let ret = perform_update(app_dir, None);
+        assert!(ret.is_err_and(|e| e.to_string().as_str() == "Timed out"));
+    }
+}