fix: stop false manual-download update prompts (#78)

* fix: stop false manual-download update prompts

* refactor: reuse updater result mapping

* refactor: clarify manual-download update mapping

Author: zouyonghe

src-tauri/src/bridge/commands.rs

@@ -8,10 +8,10 @@ use crate::bridge::updater_messages::{
 };
 use crate::bridge::updater_mode::{resolve_desktop_update_mode, DesktopUpdateMode};
 use crate::bridge::updater_types::{
-    map_manual_download_result, map_no_update_result, map_update_available_result,
-    map_update_channel_error, map_update_channel_ok, map_update_check_error,
-    map_update_install_error, map_update_install_ok, DesktopAppUpdateChannelResult,
-    DesktopAppUpdateCheckResult, DesktopAppUpdateResult,
+    map_manual_download_no_update_result, map_manual_download_update_available_result,
+    map_no_update_result, map_update_available_result, map_update_channel_error,
+    map_update_channel_ok, map_update_check_error, map_update_install_error, map_update_install_ok,
+    DesktopAppUpdateChannelResult, DesktopAppUpdateCheckResult, DesktopAppUpdateResult,
 };
 use crate::{
     append_desktop_log, restart_backend_flow, runtime_paths, shell_locale, tray, update_channel,
@@ -61,16 +61,13 @@ fn build_channel_aware_updater(
         .map_err(|error| format!("Failed to initialize updater: {error}"))
 }
 
-fn short_circuit_update_check(
+fn update_check_short_circuit_result(
     mode: DesktopUpdateMode,
     current_version: &str,
 ) -> Option<(&'static str, DesktopAppUpdateCheckResult)> {
     match mode {
         DesktopUpdateMode::NativeUpdater => None,
-        DesktopUpdateMode::ManualDownload => Some((
-            "desktop updater check routed to manual-download mode for current Linux install",
-            map_manual_download_result(current_version, desktop_manual_download_reason()),
-        )),
+        DesktopUpdateMode::ManualDownload => None,
         DesktopUpdateMode::Unsupported => Some((
             "desktop updater check is unsupported on the current platform/runtime mode",
             map_update_check_error(
@@ -302,8 +299,9 @@ pub(crate) async fn desktop_bridge_check_app_update(
     app_handle: AppHandle,
 ) -> DesktopAppUpdateCheckResult {
     let current_version = app_handle.package_info().version.to_string();
+    let update_mode = resolve_desktop_update_mode();
     if let Some((log_message, result)) =
-        short_circuit_update_check(resolve_desktop_update_mode(), &current_version)
+        update_check_short_circuit_result(update_mode, &current_version)
     {
         append_desktop_log(log_message);
         return result;
@@ -315,10 +313,21 @@ pub(crate) async fn desktop_bridge_check_app_update(
     };
 
     match updater.check().await {
-        Ok(Some(update)) => {
-            map_update_available_result(current_version, update.version.clone().to_string())
-        }
-        Ok(None) => map_no_update_result(current_version),
+        Ok(Some(update)) => match update_mode {
+            DesktopUpdateMode::ManualDownload => map_manual_download_update_available_result(
+                &current_version,
+                &update.version,
+                desktop_manual_download_reason(),
+            ),
+            _ => map_update_available_result(&current_version, &update.version),
+        },
+        Ok(None) => match update_mode {
+            DesktopUpdateMode::ManualDownload => map_manual_download_no_update_result(
+                &current_version,
+                desktop_manual_download_reason(),
+            ),
+            _ => map_no_update_result(&current_version),
+        },
         Err(error) => map_update_check_error(
             Some(current_version),
             format!("Failed to check updates: {error}"),
@@ -361,32 +370,38 @@ mod tests {
     use super::*;
 
     #[test]
-    fn updater_check_mode_returns_manual_download_result() {
-        let (log_message, result) =
-            short_circuit_update_check(DesktopUpdateMode::ManualDownload, "4.19.2")
-                .expect("manual-download mode should short-circuit update checks");
+    fn update_check_short_circuit_only_applies_to_unsupported_mode() {
+        assert!(
+            update_check_short_circuit_result(DesktopUpdateMode::ManualDownload, "4.19.2")
+                .is_none(),
+            "manual-download mode should keep running the update check"
+        );
+    }
 
-        assert_eq!(
-            log_message,
-            "desktop updater check routed to manual-download mode for current Linux install"
+    #[test]
+    fn updater_check_manual_download_mode_only_reports_reason_without_forced_update_flag() {
+        let result = crate::bridge::updater_types::map_manual_download_no_update_result(
+            "4.19.2",
+            crate::bridge::updater_messages::desktop_manual_download_reason(),
         );
+
         assert_eq!(
             result,
             crate::bridge::updater_types::DesktopAppUpdateCheckResult {
                 ok: true,
                 reason: Some(crate::bridge::updater_messages::desktop_manual_download_reason()),
                 current_version: Some("4.19.2".to_string()),
-                latest_version: None,
-                has_update: true,
-                manual_download_required: true,
+                latest_version: Some("4.19.2".to_string()),
+                has_update: false,
+                manual_download_required: false,
             }
         );
     }
 
     #[test]
     fn updater_check_mode_returns_unsupported_result() {
         let (log_message, result) =
-            short_circuit_update_check(DesktopUpdateMode::Unsupported, "4.19.2")
+            update_check_short_circuit_result(DesktopUpdateMode::Unsupported, "4.19.2")
                 .expect("unsupported mode should short-circuit update checks");
 
         assert_eq!(

src-tauri/src/bridge/updater_types.rs

@@ -28,29 +28,61 @@ pub(crate) struct DesktopAppUpdateChannelResult {
     pub channel: Option<UpdateChannel>,
 }
 
-pub(crate) fn map_no_update_result(current_version: String) -> DesktopAppUpdateCheckResult {
+fn map_update_result(
+    current_version: &str,
+    latest_version: &str,
+    reason: Option<String>,
+    has_update: bool,
+    manual_download_required: bool,
+) -> DesktopAppUpdateCheckResult {
     DesktopAppUpdateCheckResult {
         ok: true,
-        reason: None,
-        current_version: Some(current_version.clone()),
-        latest_version: Some(current_version),
-        has_update: false,
-        manual_download_required: false,
+        reason,
+        current_version: Some(current_version.to_string()),
+        latest_version: Some(latest_version.to_string()),
+        has_update,
+        manual_download_required,
     }
 }
 
+pub(crate) fn map_no_update_result(current_version: &str) -> DesktopAppUpdateCheckResult {
+    map_update_result(current_version, current_version, None, false, false)
+}
+
 pub(crate) fn map_update_available_result(
-    current_version: String,
-    latest_version: String,
+    current_version: &str,
+    latest_version: &str,
 ) -> DesktopAppUpdateCheckResult {
-    DesktopAppUpdateCheckResult {
-        ok: true,
-        reason: None,
-        current_version: Some(current_version),
-        latest_version: Some(latest_version),
-        has_update: true,
-        manual_download_required: false,
-    }
+    map_update_result(current_version, latest_version, None, true, false)
+}
+
+/// Maps a manual-download install that did find a newer remote release.
+pub(crate) fn map_manual_download_update_available_result(
+    current_version: &str,
+    latest_version: &str,
+    reason: impl Into<String>,
+) -> DesktopAppUpdateCheckResult {
+    map_update_result(
+        current_version,
+        latest_version,
+        Some(reason.into()),
+        true,
+        true,
+    )
+}
+
+/// Maps a manual-download install that checked successfully but found no newer release.
+pub(crate) fn map_manual_download_no_update_result(
+    current_version: &str,
+    reason: impl Into<String>,
+) -> DesktopAppUpdateCheckResult {
+    map_update_result(
+        current_version,
+        current_version,
+        Some(reason.into()),
+        false,
+        false,
+    )
 }
 
 pub(crate) fn map_update_check_error(
@@ -97,29 +129,13 @@ pub(crate) fn map_update_channel_error(reason: impl Into<String>) -> DesktopAppU
     }
 }
 
-pub(crate) fn map_manual_download_result(
-    current_version: &str,
-    reason: impl Into<String>,
-) -> DesktopAppUpdateCheckResult {
-    DesktopAppUpdateCheckResult {
-        ok: true,
-        reason: Some(reason.into()),
-        current_version: Some(current_version.to_string()),
-        latest_version: None,
-        // Manual-download mode should still trigger update UI even though
-        // we cannot determine an exact remote latest version here.
-        has_update: true,
-        manual_download_required: true,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn map_no_update_result_keeps_current_version() {
-        let result = map_no_update_result("4.19.2".to_string());
+        let result = map_no_update_result("4.19.2");
         assert!(result.ok);
         assert_eq!(result.current_version.as_deref(), Some("4.19.2"));
         assert_eq!(result.latest_version.as_deref(), Some("4.19.2"));
@@ -129,14 +145,28 @@ mod tests {
 
     #[test]
     fn map_update_available_result_marks_update_available() {
-        let result = map_update_available_result("4.19.2".to_string(), "4.20.0".to_string());
+        let result = map_update_available_result("4.19.2", "4.20.0");
         assert!(result.ok);
         assert_eq!(result.current_version.as_deref(), Some("4.19.2"));
         assert_eq!(result.latest_version.as_deref(), Some("4.20.0"));
         assert!(result.has_update);
         assert!(!result.manual_download_required);
     }
 
+    #[test]
+    fn map_manual_download_update_available_result_marks_manual_download_upgrade() {
+        let result = map_manual_download_update_available_result(
+            "4.19.2",
+            "4.20.0",
+            crate::bridge::updater_messages::DESKTOP_UPDATER_MANUAL_DOWNLOAD_REASON,
+        );
+        assert!(result.ok);
+        assert_eq!(result.current_version.as_deref(), Some("4.19.2"));
+        assert_eq!(result.latest_version.as_deref(), Some("4.20.0"));
+        assert!(result.has_update);
+        assert!(result.manual_download_required);
+    }
+
     #[test]
     fn map_update_check_error_keeps_known_current_version() {
         let result = map_update_check_error(Some("4.19.2".to_string()), "network error");
@@ -163,19 +193,37 @@ mod tests {
     }
 
     #[test]
-    fn map_manual_download_result_keeps_current_version_and_reason() {
-        let result = map_manual_download_result(
+    fn map_manual_download_no_update_result_keeps_current_version_and_reason() {
+        let result = map_manual_download_no_update_result(
             "4.19.2",
             crate::bridge::updater_messages::DESKTOP_UPDATER_MANUAL_DOWNLOAD_REASON,
         );
         assert!(result.ok);
         assert_eq!(result.current_version.as_deref(), Some("4.19.2"));
-        assert_eq!(result.latest_version, None);
-        assert!(result.has_update);
-        assert!(result.manual_download_required);
+        assert_eq!(result.latest_version.as_deref(), Some("4.19.2"));
+        assert!(!result.has_update);
+        assert!(!result.manual_download_required);
         assert_eq!(
             result.reason.as_deref(),
             Some(crate::bridge::updater_messages::DESKTOP_UPDATER_MANUAL_DOWNLOAD_REASON)
         );
     }
+
+    #[test]
+    fn map_manual_download_no_update_result_keeps_manual_download_message_without_update_flag() {
+        let result = map_manual_download_no_update_result(
+            "4.19.2",
+            crate::bridge::updater_messages::desktop_manual_download_reason(),
+        );
+
+        assert!(result.ok);
+        assert_eq!(result.current_version.as_deref(), Some("4.19.2"));
+        assert_eq!(result.latest_version.as_deref(), Some("4.19.2"));
+        assert_eq!(
+            result.reason.as_deref(),
+            Some(crate::bridge::updater_messages::desktop_manual_download_reason().as_str())
+        );
+        assert!(!result.has_update);
+        assert!(!result.manual_download_required);
+    }
 }