refactor(cli): improve errors (#14126)

* refactor(cli): improve errors

* update change files

* license

* add errorext with fs_context helper

* update linux

* lint

* fmt

* windows

* revert bundler breaking change

* fix ios mod

* ref

* reduce amount of enum variants

* fix macos build

* Fix windows build

* Clippy

* capitalize cargo [skip ci]

---------

Co-authored-by: Tony <[email protected]>

Author: lucasfernog

.changes/improve-errors.md

@@ -0,0 +1,8 @@
+---
+"@tauri-apps/cli": minor:enhance
+"tauri-cli": minor:enhance
+"tauri-bundler": minor:enhance
+---
+
+Improve error messages with more context.
+

Cargo.lock

@@ -375,7 +375,7 @@ fn main() -> Result<()> {
   if let Some(filename) = bench_file.to_str() {
     utils::write_json(filename, &serde_json::to_value(&new_data)?)
       .context("failed to write benchmark results to file")?;
-    println!("Results written to: {}", filename);
+    println!("Results written to: {filename}");
   } else {
     eprintln!("Cannot write bench.json, path contains invalid UTF-8");
   }

bench/src/run_benchmark.rs

@@ -20,8 +20,8 @@ tauri-utils = { version = "2.7.0", path = "../tauri-utils", features = [
 ] }
 image = "0.25"
 flate2 = "1"
-anyhow = "1"
 thiserror = "2"
+anyhow = "1"
 serde_json = "1"
 serde = { version = "1", features = ["derive"] }
 strsim = "0.11"

crates/tauri-bundler/Cargo.toml

@@ -49,8 +49,6 @@ pub use self::{
     Settings, SettingsBuilder, Size, UpdaterSettings,
   },
 };
-#[cfg(target_os = "macos")]
-use anyhow::Context;
 pub use settings::{NsisSettings, WindowsSettings, WixLanguage, WixLanguageConfig, WixSettings};
 
 use std::{
@@ -223,24 +221,24 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<Bundle>> {
         .map(|b| b.bundle_paths)
       {
         for app_bundle_path in &app_bundle_paths {
+          use crate::error::ErrorExt;
+
           log::info!(action = "Cleaning"; "{}", app_bundle_path.display());
           match app_bundle_path.is_dir() {
             true => std::fs::remove_dir_all(app_bundle_path),
             false => std::fs::remove_file(app_bundle_path),
           }
-          .with_context(|| {
-            format!(
-              "Failed to clean the app bundle at {}",
-              app_bundle_path.display()
-            )
-          })?
+          .fs_context(
+            "failed to clean the app bundle",
+            app_bundle_path.to_path_buf(),
+          )?;
         }
       }
     }
   }
 
   if bundles.is_empty() {
-    return Err(anyhow::anyhow!("No bundles were built").into());
+    return Ok(bundles);
   }
 
   let bundles_wo_updater = bundles

crates/tauri-bundler/src/bundle.rs

@@ -6,10 +6,10 @@
 use super::debian;
 use crate::{
   bundle::settings::Arch,
+  error::{Context, ErrorExt},
   utils::{fs_utils, http_utils::download, CommandExt},
   Settings,
 };
-use anyhow::Context;
 use std::{
   fs,
   path::{Path, PathBuf},
@@ -124,13 +124,13 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<PathBuf>> {
   // xdg-open will be handled by the `files` config instead
   if settings.deep_link_protocols().is_some() && !app_dir_usr_bin.join("xdg-open").exists() {
     fs::copy("/usr/bin/xdg-mime", app_dir_usr_bin.join("xdg-mime"))
-      .context("xdg-mime binary not found")?;
+      .fs_context("xdg-mime binary not found", "/usr/bin/xdg-mime".to_string())?;
   }
 
   // we also check if the user may have provided their own copy already
   if settings.appimage().bundle_xdg_open && !app_dir_usr_bin.join("xdg-open").exists() {
     fs::copy("/usr/bin/xdg-open", app_dir_usr_bin.join("xdg-open"))
-      .context("xdg-open binary not found")?;
+      .fs_context("xdg-open binary not found", "/usr/bin/xdg-open".to_string())?;
   }
 
   let search_dirs = [

crates/tauri-bundler/src/bundle/linux/appimage.rs

@@ -24,8 +24,12 @@
 // generate postinst or prerm files.
 
 use super::freedesktop;
-use crate::{bundle::settings::Arch, utils::fs_utils, Settings};
-use anyhow::Context;
+use crate::{
+  bundle::settings::Arch,
+  error::{Context, ErrorExt},
+  utils::fs_utils,
+  Settings,
+};
 use flate2::{write::GzEncoder, Compression};
 use tar::HeaderMode;
 use walkdir::WalkDir;
@@ -64,30 +68,32 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<PathBuf>> {
   let base_dir = settings.project_out_directory().join("bundle/deb");
   let package_dir = base_dir.join(&package_base_name);
   if package_dir.exists() {
-    fs::remove_dir_all(&package_dir)
-      .with_context(|| format!("Failed to remove old {package_base_name}"))?;
+    fs::remove_dir_all(&package_dir).fs_context(
+      "Failed to Remove old package directory",
+      package_dir.clone(),
+    )?;
   }
   let package_path = base_dir.join(&package_name);
 
   log::info!(action = "Bundling"; "{} ({})", package_name, package_path.display());
 
-  let (data_dir, _) = generate_data(settings, &package_dir)
-    .with_context(|| "Failed to build data folders and files")?;
+  let (data_dir, _) =
+    generate_data(settings, &package_dir).context("Failed to build data folders and files")?;
   fs_utils::copy_custom_files(&settings.deb().files, &data_dir)
-    .with_context(|| "Failed to copy custom files")?;
+    .context("Failed to copy custom files")?;
 
   // Generate control files.
   let control_dir = package_dir.join("control");
   generate_control_file(settings, arch, &control_dir, &data_dir)
-    .with_context(|| "Failed to create control file")?;
-  generate_scripts(settings, &control_dir).with_context(|| "Failed to create control scripts")?;
-  generate_md5sums(&control_dir, &data_dir).with_context(|| "Failed to create md5sums file")?;
+    .context("Failed to create control file")?;
+  generate_scripts(settings, &control_dir).context("Failed to create control scripts")?;
+  generate_md5sums(&control_dir, &data_dir).context("Failed to create md5sums file")?;
 
   // Generate `debian-binary` file; see
   // http://www.tldp.org/HOWTO/Debian-Binary-Package-Building-HOWTO/x60.html#AEN66
   let debian_binary_path = package_dir.join("debian-binary");
   create_file_with_data(&debian_binary_path, "2.0\n")
-    .with_context(|| "Failed to create debian-binary file")?;
+    .context("Failed to create debian-binary file")?;
 
   // Apply tar/gzip/ar to create the final package file.
   let control_tar_gz_path =

crates/tauri-bundler/src/bundle/linux/debian.rs

@@ -21,12 +21,12 @@ use std::fs::{read_to_string, File};
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
 
-use anyhow::Context;
 use handlebars::Handlebars;
 use image::{self, codecs::png::PngDecoder, ImageDecoder};
 use serde::Serialize;
 
 use crate::{
+  error::Context,
   utils::{self, fs_utils},
   Settings,
 };
@@ -114,11 +114,13 @@ pub fn generate_desktop_file(
   if let Some(template) = custom_template_path {
     handlebars
       .register_template_string("main.desktop", read_to_string(template)?)
-      .with_context(|| "Failed to setup custom handlebar template")?;
+      .map_err(Into::into)
+      .context("Failed to setup custom handlebar template")?;
   } else {
     handlebars
       .register_template_string("main.desktop", include_str!("./main.desktop"))
-      .with_context(|| "Failed to setup default handlebar template")?;
+      .map_err(Into::into)
+      .context("Failed to setup default handlebar template")?;
   }
 
   #[derive(Serialize)]

crates/tauri-bundler/src/bundle/linux/freedesktop/mod.rs

@@ -3,9 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use crate::{bundle::settings::Arch, Settings};
+use crate::{bundle::settings::Arch, error::ErrorExt, Settings};
 
-use anyhow::Context;
 use rpm::{self, signature::pgp, Dependency, FileMode, FileOptions};
 use std::{
   env,
@@ -48,10 +47,13 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<PathBuf>> {
   let base_dir = settings.project_out_directory().join("bundle/rpm");
   let package_dir = base_dir.join(&package_base_name);
   if package_dir.exists() {
-    fs::remove_dir_all(&package_dir)
-      .with_context(|| format!("Failed to remove old {package_base_name}"))?;
+    fs::remove_dir_all(&package_dir).fs_context(
+      "Failed to remove old package directory",
+      package_dir.clone(),
+    )?;
   }
-  fs::create_dir_all(&package_dir)?;
+  fs::create_dir_all(&package_dir)
+    .fs_context("Failed to create package directory", package_dir.clone())?;
   let package_path = base_dir.join(&package_name);
 
   log::info!(action = "Bundling"; "{} ({})", package_name, package_path.display());

crates/tauri-bundler/src/bundle/linux/rpm.rs

@@ -24,16 +24,15 @@
 
 use super::{
   icon::create_icns_file,
-  sign::{notarize, notarize_auth, notarize_without_stapling, sign, NotarizeAuthError, SignTarget},
+  sign::{notarize, notarize_auth, notarize_without_stapling, sign, SignTarget},
 };
 use crate::{
+  error::{Context, ErrorExt, NotarizeAuthError},
   utils::{fs_utils, CommandExt},
   Error::GenericError,
   Settings,
 };
 
-use anyhow::Context;
-
 use std::{
   ffi::OsStr,
   fs,
@@ -65,12 +64,16 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<PathBuf>> {
   log::info!(action = "Bundling"; "{} ({})", app_product_name, app_bundle_path.display());
 
   if app_bundle_path.exists() {
-    fs::remove_dir_all(&app_bundle_path)
-      .with_context(|| format!("Failed to remove old {app_product_name}"))?;
+    fs::remove_dir_all(&app_bundle_path).fs_context(
+      "failed to remove old app bundle",
+      app_bundle_path.to_path_buf(),
+    )?;
   }
   let bundle_directory = app_bundle_path.join("Contents");
-  fs::create_dir_all(&bundle_directory)
-    .with_context(|| format!("Failed to create bundle directory at {bundle_directory:?}"))?;
+  fs::create_dir_all(&bundle_directory).fs_context(
+    "failed to create bundle directory",
+    bundle_directory.to_path_buf(),
+  )?;
 
   let resources_dir = bundle_directory.join("Resources");
   let bin_dir = bundle_directory.join("MacOS");
@@ -134,7 +137,7 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<PathBuf>> {
       }
       Err(e) => {
         if matches!(e, NotarizeAuthError::MissingTeamId) {
-          return Err(anyhow::anyhow!("{e}").into());
+          return Err(e.into());
         } else {
           log::warn!("skipping app notarization, {}", e.to_string());
         }
@@ -401,8 +404,10 @@ fn copy_frameworks_to_bundle(
     return Ok(paths);
   }
   let dest_dir = bundle_directory.join("Frameworks");
-  fs::create_dir_all(bundle_directory)
-    .with_context(|| format!("Failed to create Frameworks directory at {dest_dir:?}"))?;
+  fs::create_dir_all(&dest_dir).fs_context(
+    "failed to create Frameworks directory",
+    dest_dir.to_path_buf(),
+  )?;
   for framework in frameworks.iter() {
     if framework.ends_with(".framework") {
       let src_path = PathBuf::from(framework);