release: v1.0.9 - fix os error 740 (auto-elevate before update)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: drrakendu78

.release-notes-v1.0.9.md

@@ -0,0 +1,42 @@
+# UniCreate - Patch Notes v1.0.9
+
+Date: 2026-05-13
+Release tag: `v1.0.9`
+Repository: `drrakendu78/UniCreate`
+
+## Highlights
+
+- **Auto-update no longer fails with `os error 740`** on non-admin sessions: UniCreate now restarts itself as administrator automatically before launching the updater. One-click update again works end to end.
+- **All updater error messages translated to English** (previously some surfaced the localized Windows error text, e.g. "L'opération demandée nécessite une élévation").
+
+## Changes
+
+### 1) Fix — `ERROR_ELEVATION_REQUIRED` (740) on auto-update
+
+- Windows installer-detection heuristic forces UAC elevation for any `.exe` whose name contains `updater` / `setup` / `install`. Launching `UniCreate-Updater.exe` from a non-admin process therefore fails with OS error 740, which the previous build surfaced as a cryptic toast.
+- UniCreate now checks `is_running_as_admin` before triggering the updater. When the app is not elevated, it persists the pending download URL + filename in `localStorage` (`unicreate-pending-update`), calls a new `restart_as_admin` Tauri command, and resumes the install automatically once the app reboots with elevated privileges. A single UAC prompt now suffices — no need to manually relaunch the app as admin.
+
+Impacted files:
+- `src-tauri/Cargo.toml` (added `is_elevated` dependency on Windows)
+- `src-tauri/src/lib.rs` (new `is_running_as_admin` and `restart_as_admin` Tauri commands)
+- `src-tauri/src/github.rs` (`start_silent_update` now translates `raw_os_error() == 740` into a clear English message)
+- `src/App.tsx` (`openUpdateAction` checks admin first + resumes pending update on next boot)
+
+### 2) Updater error messages are now consistently in English
+
+- The pre-existing English strings stay unchanged.
+- The 740 case used to fall through to `std::io::Error::Display`, which Windows localizes (French users saw "L'opération demandée nécessite une élévation"). It now returns: *"Update requires administrator privileges. Please restart UniCreate as administrator and try again."*
+
+Impacted files:
+- `src-tauri/src/github.rs`
+
+### 3) Version bump
+
+- App version updated to `1.0.9`.
+
+## Checksums (SHA-256)
+
+| File | SHA-256 |
+|------|---------|
+| `UniCreate_1.0.9_x64-setup.exe` | `a56a1fb2a1b498e92da853f8f380bc357ed0ead56760e40c80f5af64760464fd` |
+| `UniCreate_1.0.9_x64_en-US.msi` | `4f59bd03348e5024090aec16f564341f6163f5c6fa1398645d10604dbf55c3e4` |

package.json

@@ -1,7 +1,7 @@
 {
   "name": "unicreate",
   "private": true,
-  "version": "1.0.8",
+  "version": "1.0.9",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "unicreate"
-version = "1.0.8"
+version = "1.0.9"
 description = "UniCreate - WinGet Manifest Creator GUI"
 authors = ["Drrakendu78"]
 edition = "2021"
@@ -28,3 +28,6 @@ dirs = "6.0"
 base64 = "0.22"
 zip = "2"
 keyring = { version = "3", features = ["windows-native"] }
+
+[target.'cfg(windows)'.dependencies]
+is_elevated = "0.1"

src-tauri/Cargo.toml

@@ -283,7 +283,16 @@ pub fn start_silent_update(download_url: &str, file_name: Option<&str>) -> Resul
             "--pid", &current_pid.to_string(),
         ])
         .spawn()
-        .map_err(|e| format!("Cannot start updater: {}", e))?;
+        .map_err(|e| {
+            // ERROR_ELEVATION_REQUIRED (740): Windows installer-detection heuristic
+            // auto-elevates any .exe whose name contains "updater" / "setup" / "install".
+            // Running the updater from a non-admin process fails with this code.
+            if e.raw_os_error() == Some(740) {
+                "Update requires administrator privileges. Please restart UniCreate as administrator and try again.".to_string()
+            } else {
+                format!("Cannot start updater: {}", e)
+            }
+        })?;
 
     Ok(())
 }

src-tauri/src/github.rs

@@ -131,6 +131,64 @@ fn start_silent_update(download_url: String, file_name: Option<String>) -> Resul
     github::start_silent_update(&download_url, file_name.as_deref())
 }
 
+#[tauri::command]
+fn is_running_as_admin() -> bool {
+    #[cfg(target_os = "windows")]
+    {
+        is_elevated::is_elevated()
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        false
+    }
+}
+
+#[tauri::command]
+async fn restart_as_admin(app_handle: tauri::AppHandle) -> Result<(), String> {
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+        use std::process::Command;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+        let exe = std::env::current_exe().map_err(|e| e.to_string())?;
+        let exe_str = exe
+            .to_str()
+            .ok_or_else(|| "Invalid executable path".to_string())?;
+
+        if exe_str.contains("WindowsApps") {
+            return Err("Microsoft Store apps cannot be elevated to administrator.".to_string());
+        }
+
+        let escaped = exe_str.replace("'", "''");
+        let ps_command = format!("Start-Process -FilePath '{}' -Verb RunAs", escaped);
+        let powershell_path = std::path::Path::new("C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe");
+        let ps = if powershell_path.exists() {
+            powershell_path.to_str().unwrap()
+        } else {
+            "powershell.exe"
+        };
+
+        match Command::new(ps)
+            .creation_flags(CREATE_NO_WINDOW)
+            .args(["-NoProfile", "-WindowStyle", "Hidden", "-Command", &ps_command])
+            .spawn()
+        {
+            Ok(_) => {
+                tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+                app_handle.exit(0);
+                Ok(())
+            }
+            Err(e) => Err(format!("Failed to restart as administrator: {}. Try running the app as admin manually.", e)),
+        }
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        let _ = app_handle;
+        Err("Elevation not supported on this platform.".to_string())
+    }
+}
+
 #[tauri::command]
 async fn start_device_flow() -> Result<github::DeviceFlowStart, String> {
     github::start_device_flow().await
@@ -301,6 +359,8 @@ pub fn run() {
             check_package_exists,
             check_app_update,
             start_silent_update,
+            is_running_as_admin,
+            restart_as_admin,
             start_device_flow,
             poll_device_flow,
             authenticate_github,

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "UniCreate",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "identifier": "com.drrakendu78.unicreate",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/tauri.conf.json

@@ -21,6 +21,7 @@ import logoMarkUrl from "@/assets/logo-mark.png";
 
 const appWindow = getCurrentWindow();
 const DISMISSED_UPDATE_VERSION_KEY = "unicreate-dismissed-update-version";
+const PENDING_UPDATE_KEY = "unicreate-pending-update";
 
 function Toasts() {
   const { toasts, removeToast } = useToastStore();
@@ -294,6 +295,43 @@ function App() {
     };
   }, [autoCheckUpdates]);
 
+  // Resume a pending update after the user restarted the app as admin.
+  // PENDING_UPDATE_KEY is set just before calling restart_as_admin in openUpdateAction.
+  // Once we're back with elevated privileges, we kick off start_silent_update directly.
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      let pending: { downloadUrl: string; downloadName?: string; latestVersion?: string } | null = null;
+      try {
+        const raw = localStorage.getItem(PENDING_UPDATE_KEY);
+        if (raw) pending = JSON.parse(raw);
+      } catch { pending = null; }
+      if (!pending?.downloadUrl) return;
+
+      const isAdmin = await invoke<boolean>("is_running_as_admin").catch(() => false);
+      if (cancelled) return;
+
+      // Always clear the flag once: avoids an infinite restart loop if anything fails.
+      try { localStorage.removeItem(PENDING_UPDATE_KEY); } catch {}
+
+      if (!isAdmin) return; // elevation refused or failed: give up silently
+
+      try {
+        await invoke("start_silent_update", {
+          downloadUrl: pending.downloadUrl,
+          fileName: pending.downloadName,
+        });
+        if (pending.latestVersion) {
+          localStorage.setItem(DISMISSED_UPDATE_VERSION_KEY, pending.latestVersion);
+        }
+        await appWindow.close().catch(() => {});
+      } catch (e) {
+        addToast(`Update failed: ${String(e)}`, "error");
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [addToast]);
+
   const dismissUpdatePopup = () => {
     if (appUpdateInfo) {
       localStorage.setItem(DISMISSED_UPDATE_VERSION_KEY, appUpdateInfo.latestVersion);
@@ -310,6 +348,32 @@ function App() {
 
     setIsApplyingUpdate(true);
 
+    // Windows installer-detection heuristic forces UAC elevation for any .exe whose
+    // name contains "updater" / "setup". Launching the updater from a non-admin
+    // process fails with ERROR_ELEVATION_REQUIRED (740). To avoid this, we restart
+    // the app as admin first, persist the update info, and resume the install on
+    // next boot (see the useEffect that reads PENDING_UPDATE_KEY).
+    const isAdmin = await invoke<boolean>("is_running_as_admin").catch(() => true);
+    if (!isAdmin) {
+      try {
+        localStorage.setItem(PENDING_UPDATE_KEY, JSON.stringify({
+          downloadUrl: appUpdateInfo.downloadUrl,
+          downloadName: appUpdateInfo.downloadName,
+          latestVersion: appUpdateInfo.latestVersion,
+        }));
+      } catch {}
+      addToast("Restarting as administrator to install the update...", "info");
+      try {
+        await invoke("restart_as_admin");
+        // App closes after this call.
+      } catch (e) {
+        try { localStorage.removeItem(PENDING_UPDATE_KEY); } catch {}
+        setIsApplyingUpdate(false);
+        addToast(`Failed to restart as administrator: ${String(e)}`, "error");
+      }
+      return;
+    }
+
     try {
       await invoke("start_silent_update", {
         downloadUrl: appUpdateInfo.downloadUrl,