fix: fall back to older bundled distrobox when latest version not downloaded

When DISTROBOX_VERSION is bumped but not yet downloaded, the app now:
1. Falls back to the most recent bundled version on disk, or system distrobox
2. Shows an 'Update Distrobox' button in the sidebar when an update is available
3. Cleans up old bundled versions after a successful download

Added resolve_bundled_distrobox_path() for smart path resolution,
is_bundled_update_available() for UI state, and bundled_update_available
property on RootStore for reactive sidebar button visibility.

Author: ranfdev

src/distrobox_downloader.rs

@@ -25,6 +25,81 @@ pub fn get_bundled_distrobox_dir() -> PathBuf {
     user_data_dir.join("distroshelf")
 }
 
+/// Resolves the best available bundled distrobox path.
+/// Returns the current version's path if it exists, otherwise finds the most recent older version.
+/// Returns None if no bundled version is found at all.
+pub fn resolve_bundled_distrobox_path() -> Option<PathBuf> {
+    let current = get_bundled_distrobox_path();
+    if current.exists() {
+        return Some(current);
+    }
+    find_latest_bundled_version()
+}
+
+/// Returns true if the user has a bundled distrobox but it's not the latest (DISTROBOX_VERSION).
+/// This means an update is available to download.
+pub fn is_bundled_update_available() -> bool {
+    let current = get_bundled_distrobox_path();
+    if current.exists() {
+        return false; // Already have the latest
+    }
+    // An update is available if there's an older version on disk but not the current one
+    find_latest_bundled_version().is_some()
+}
+
+/// Scans the bundled distrobox directory for version subdirectories and returns the path
+/// to the distrobox binary in the most recent version found.
+fn find_latest_bundled_version() -> Option<PathBuf> {
+    let parent = get_bundled_distrobox_dir();
+    let entries = std::fs::read_dir(&parent).ok()?;
+
+    let mut versions: Vec<(Vec<u32>, PathBuf)> = entries
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            let name = entry.file_name();
+            let name_str = name.to_str()?;
+            let version_str = name_str.strip_prefix("distrobox-")?;
+            let binary_path = entry.path().join("distrobox");
+            if !binary_path.exists() {
+                return None;
+            }
+            let parts: Option<Vec<u32>> = version_str.split('.').map(|p| p.parse().ok()).collect();
+            Some((parts?, binary_path))
+        })
+        .collect();
+
+    versions.sort_by(|a, b| a.0.cmp(&b.0));
+    versions.last().map(|(_, path)| path.clone())
+}
+
+/// Removes all bundled distrobox version directories except the current one (DISTROBOX_VERSION).
+pub fn cleanup_old_bundled_versions() {
+    let parent = get_bundled_distrobox_dir();
+    let current_dir_name = format!("distrobox-{}", DISTROBOX_VERSION);
+
+    let entries = match std::fs::read_dir(&parent) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+
+    for entry in entries.flatten() {
+        let name = entry.file_name();
+        let name_str = match name.to_str() {
+            Some(s) => s.to_string(),
+            None => continue,
+        };
+        if name_str.starts_with("distrobox-") && name_str != current_dir_name {
+            if entry.path().is_dir() {
+                if let Err(e) = std::fs::remove_dir_all(entry.path()) {
+                    tracing::warn!("Failed to remove old bundled version {:?}: {}", entry.path(), e);
+                } else {
+                    tracing::info!("Removed old bundled version: {}", name_str);
+                }
+            }
+        }
+    }
+}
+
 fn log(task: &DistroboxTask, msg: &str) {
     task.append_output(msg);
     task.append_output("\n");
@@ -130,8 +205,13 @@ pub fn download_distrobox(root_store: &RootStore) -> DistroboxTask {
 
         log(&task, "Distrobox installed successfully.");
 
+        // Clean up old bundled versions
+        log(&task, "Cleaning up old bundled versions...");
+        cleanup_old_bundled_versions();
+
         if let Some(root_store) = root_store_weak.upgrade() {
             root_store.distrobox_version().refetch();
+            root_store.update_bundled_update_available();
             root_store.set_current_dialog(crate::models::DialogType::None);
         }
 

src/models/root_store.rs

@@ -74,6 +74,9 @@ mod imp {
         #[property(get, set, builder(DialogType::default()))]
         current_dialog: RefCell<DialogType>,
 
+        #[property(get, set)]
+        bundled_update_available: std::cell::Cell<bool>,
+
         /// Parameters for the current dialog (not a GObject property)
         pub dialog_params: RefCell<DialogParams>,
     }
@@ -104,6 +107,7 @@ mod imp {
                 containers_query: Query::new("containers".into(), || async { Ok(vec![]) }),
                 tasks: TypedListStore::new(),
                 selected_task: Default::default(),
+                bundled_update_available: std::cell::Cell::new(false),
                 settings: gio::Settings::new("com.ranfdev.DistroShelf"),
             }
         }
@@ -125,17 +129,17 @@ mod imp {
                     move |settings, _key| {
                         let val = settings.string("distrobox-executable");
                         if val == "bundled" {
-                            // Check if bundled version exists
-                            let path = crate::distrobox_downloader::get_bundled_distrobox_path();
-                            if !path.exists() {
+                            if crate::distrobox_downloader::resolve_bundled_distrobox_path()
+                                .is_none()
+                            {
                                 obj.download_distrobox();
                             } else {
-                                // Just refetch version to update UI
                                 obj.distrobox_version().refetch();
                             }
                         } else {
                             obj.distrobox_version().refetch();
                         }
+                        obj.update_bundled_update_available();
                     }
                 ),
             );
@@ -172,9 +176,9 @@ impl RootStore {
         let cmd_factory: crate::backends::distrobox::command::CmdFactory = Box::new(move || {
             let distrobox_executable_val = this_clone.settings().string("distrobox-executable");
             let selected_program: String = if distrobox_executable_val == "bundled" {
-                crate::distrobox_downloader::get_bundled_distrobox_path()
-                    .to_string_lossy()
-                    .into_owned()
+                crate::distrobox_downloader::resolve_bundled_distrobox_path()
+                    .map(|p| p.to_string_lossy().into_owned())
+                    .unwrap_or_else(|| "distrobox".into())
             } else {
                 "distrobox".into()
             };
@@ -206,6 +210,11 @@ impl RootStore {
         let this_clone = this.clone();
         this.distrobox_version().connect_error(move |_error| {
             this_clone.set_current_view(ViewType::Welcome);
+            this_clone.update_bundled_update_available();
+        });
+        let this_clone = this.clone();
+        this.distrobox_version().connect_success(move |_version| {
+            this_clone.update_bundled_update_available();
         });
         this.distrobox_version().refetch();
 
@@ -345,6 +354,16 @@ impl RootStore {
         self.containers_query().refetch();
     }
 
+    /// Recalculates and sets the `bundled_update_available` property.
+    /// Should be called after distrobox_version query completes, after a download, or when
+    /// the distrobox-executable setting changes.
+    pub fn update_bundled_update_available(&self) {
+        let settings_val = self.settings().string("distrobox-executable");
+        let available =
+            settings_val == "bundled" && crate::distrobox_downloader::is_bundled_update_available();
+        self.set_bundled_update_available(available);
+    }
+
     pub fn download_distrobox(&self) -> DistroboxTask {
         // Guard: if a download task is already in progress, return it instead of creating a duplicate
         for task in self.tasks().iter() {

src/widgets/window.rs

@@ -325,12 +325,44 @@ impl DistroShelfWindow {
                     .set_visible_child_name(visible_child_name);
             });
 
-        // Add tasks button to the bottom of the sidebar
+        // Add tasks button and update button to the bottom of the sidebar
+        let sidebar_bottom_box = gtk::Box::new(gtk::Orientation::Vertical, 0);
+
+        // "Update Distrobox" button — visible only when a bundled update is available
+        let update_button = gtk::Button::builder()
+            .label(&gettext("Update Distrobox"))
+            .build();
+        update_button.add_css_class("suggested-action");
+        update_button.add_css_class("pill");
+        update_button.set_margin_start(12);
+        update_button.set_margin_end(12);
+        update_button.set_margin_top(12);
+        update_button.set_visible(self.root_store().bundled_update_available());
+        update_button.connect_clicked(clone!(
+            #[weak(rename_to = this)]
+            self,
+            move |_| {
+                this.root_store().download_distrobox();
+                this.root_store()
+                    .set_current_dialog(DialogType::TaskManager);
+            }
+        ));
+        self.root_store().connect_bundled_update_available_notify(clone!(
+            #[weak]
+            update_button,
+            move |root_store| {
+                update_button.set_visible(root_store.bundled_update_available());
+            }
+        ));
+        sidebar_bottom_box.append(&update_button);
+
         let tasks_button = TasksButton::new(&self.root_store());
         tasks_button.add_css_class("flat");
+        sidebar_bottom_box.append(&tasks_button);
+
         self.imp()
             .sidebar_bottom_slot
-            .set_child(Some(&tasks_button));
+            .set_child(Some(&sidebar_bottom_box));
     }
 
     pub fn add_toast(&self, toast: adw::Toast) {