feat(updater): Add .deb Package Support to Linux Updater

plugins/updater/src/error.rs

@@ -63,6 +63,10 @@ pub enum Error {
     TempDirNotOnSameMountPoint,
     #[error("binary for the current target not found in the archive")]
     BinaryNotFoundInArchive,
+    #[error("Authentication failed or was cancelled")]
+    AuthenticationFailed,
+    #[error("Failed to install .deb package")]
+    DebInstallFailed,
     #[error("invalid updater binary format")]
     InvalidUpdaterFormat,
     #[error(transparent)]

plugins/updater/src/updater.rs

@@ -748,7 +748,7 @@ impl Update {
     }
 }
 
-/// Linux (AppImage)
+/// Linux (AppImage and Deb)
 #[cfg(any(
     target_os = "linux",
     target_os = "dragonfly",
@@ -760,12 +760,19 @@ impl Update {
     /// ### Expected structure:
     /// ├── [AppName]_[version]_amd64.AppImage.tar.gz    # GZ generated by tauri-bundler
     /// │   └──[AppName]_[version]_amd64.AppImage        # Application AppImage
+    /// ├── [AppName]_[version]_amd64.deb                # Debian package
     /// └── ...
     ///
-    /// We should have an AppImage already installed to be able to copy and install
-    /// the extract_path is the current AppImage path
-    /// tmp_dir is where our new AppImage is found
     fn install_inner(&self, bytes: &[u8]) -> Result<()> {
+        if self.is_deb_package() {
+            self.install_deb_update(bytes)
+        } else {
+            // Handle AppImage or other formats
+            self.install_appimage_update(bytes)
+        }
+    }
+
+    fn install_appimage_update(&self, bytes: &[u8]) -> Result<()> {
         use std::os::unix::fs::{MetadataExt, PermissionsExt};
         let extract_path_metadata = self.extract_path.metadata()?;
 
@@ -835,6 +842,132 @@ impl Update {
 
         Err(Error::TempDirNotOnSameMountPoint)
     }
+
+    fn is_deb_package(&self) -> bool {
+        // First check if we're in a typical Debian installation path
+        let in_system_path = self
+            .extract_path
+            .to_str()
+            .map(|p| p.starts_with("/usr"))
+            .unwrap_or(false);
+
+        if !in_system_path {
+            return false;
+        }
+
+        // Then verify it's actually a Debian-based system by checking for dpkg
+        let dpkg_exists = std::path::Path::new("/var/lib/dpkg").exists();
+        let apt_exists = std::path::Path::new("/etc/apt").exists();
+
+        // Additional check for the package in dpkg database
+        let package_in_dpkg = if let Ok(output) = std::process::Command::new("dpkg")
+            .args(["-S", &self.extract_path.to_string_lossy()])
+            .output()
+        {
+            output.status.success()
+        } else {
+            false
+        };
+
+        // Consider it a deb package only if:
+        // 1. We're in a system path AND
+        // 2. We have Debian package management tools AND
+        // 3. The binary is tracked by dpkg
+        dpkg_exists && apt_exists && package_in_dpkg
+    }
+
+    fn install_deb_update(&self, bytes: &[u8]) -> Result<()> {
+        // Create a temporary directory
+        let tmp_dir = tempfile::Builder::new()
+            .prefix("tauri_deb_update")
+            .tempdir_in("/tmp")?;
+
+        let deb_path = tmp_dir.path().join("package.deb");
+
+        // Direct .deb file
+        std::fs::write(&deb_path, bytes)?;
+
+        // Try different privilege escalation methods
+        let installation_result = self.try_install_with_privileges(&deb_path);
+
+        // Clean up
+        let _ = std::fs::remove_file(&deb_path);
+
+        installation_result
+    }
+
+    fn try_install_with_privileges(&self, deb_path: &Path) -> Result<()> {
+        // 1. First try using pkexec (graphical sudo prompt)
+        if let Ok(status) = std::process::Command::new("pkexec")
+            .arg("dpkg")
+            .arg("-i")
+            .arg(deb_path)
+            .status()
+        {
+            if status.success() {
+                return Ok(());
+            }
+        }
+
+        // 2. Try zenity for a more user-friendly graphical sudo experience
+        if let Ok(password) = self.get_password_graphically() {
+            if self.install_with_sudo(deb_path, &password)? {
+                return Ok(());
+            }
+        }
+
+        // 3. Final fallback: terminal sudo
+        let status = std::process::Command::new("sudo")
+            .arg("dpkg")
+            .arg("-i")
+            .arg(deb_path)
+            .status()?;
+
+        if status.success() {
+            Ok(())
+        } else {
+            Err(Error::DebInstallFailed)
+        }
+    }
+
+    fn get_password_graphically(&self) -> Result<String> {
+        let output = std::process::Command::new("zenity")
+            .args([
+                "--password",
+                "--title=Authentication Required",
+                "--text=Enter your password to install the update:",
+            ])
+            .output()?;
+
+        if output.status.success() {
+            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            Err(Error::AuthenticationFailed)
+        }
+    }
+
+    fn install_with_sudo(&self, deb_path: &Path, password: &str) -> Result<bool> {
+        use std::io::Write;
+        use std::process::{Command, Stdio};
+
+        let mut child = Command::new("sudo")
+            .arg("-S") // read password from stdin
+            .arg("dpkg")
+            .arg("-i")
+            .arg(deb_path)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+
+        if let Some(mut stdin) = child.stdin.take() {
+            // Write password to stdin
+            writeln!(stdin, "{}", password)?;
+        }
+
+        let status = child.wait()?;
+        Ok(status.success())
+    }
 }
 
 /// MacOS