feat(cli): check plugin versions for incompatibilities

check core plugin versions for incompatibilities between Cargo and NPM releases

a plugin NPM/cargo version is considered "incompatible" if their major or minor versions are not equal

on dev we show an warning
on build we error out (with a `--ignore-incompatible-plugins` flag to prevent that)

this is an idea from @oscartbeaumont
we've seen several plugin changes that require updates for both the cargo and the NPM releases of a plugin, and if they are not in sync, the functionality does not work
e.g. tauri-apps/plugins-workspace#2573 where the change actually breaks the app updater if you miss the NPM update

Author: lucasfernog

.changes/check-plugin-versions.md

@@ -0,0 +1,6 @@
+---
+"tauri-cli": minor:feat
+"@tauri-apps/cli": minor:feat
+---
+
+Check installed plugin NPM/crate versions for incompatible releases.

Cargo.lock

@@ -110,6 +110,7 @@ memchr = "2"
 tempfile = "3"
 uuid = { version = "1", features = ["v5"] }
 rand = "0.9"
+rayon = "1"
 
 [dev-dependencies]
 insta = "1"

crates/tauri-cli/Cargo.toml

@@ -6,8 +6,9 @@ use crate::{
   bundle::BundleFormat,
   helpers::{
     self,
-    app_paths::tauri_dir,
+    app_paths::{frontend_dir, tauri_dir},
     config::{get as get_config, ConfigHandle, FrontendDist},
+    npm::PackageManager,
   },
   interface::{rust::get_cargo_target_dir, AppInterface, Interface},
   ConfigValue, Result,
@@ -60,6 +61,11 @@ pub struct Options {
   /// Skip prompting for values
   #[clap(long, env = "CI")]
   pub ci: bool,
+  /// Do not error out if aversion incompatibility is detected on an installed plugin.
+  ///
+  /// Only use this when you are sure the mismatch is incorrectly detected as incompatible plugin versions can lead to unknown behavior.
+  #[clap(long)]
+  pub ignore_incompatible_plugins: bool,
 }
 
 pub fn command(mut options: Options, verbosity: u8) -> Result<()> {
@@ -121,6 +127,32 @@ pub fn setup(
   mobile: bool,
 ) -> Result<()> {
   let tauri_path = tauri_dir();
+
+  log::info!("Looking up installed plugins to check incompatible versions...");
+  let installed_plugins = crate::info::plugins::installed_plugins(
+    frontend_dir(),
+    tauri_path,
+    PackageManager::from_project(frontend_dir()),
+  );
+  let incompatible_plugins = installed_plugins.incompatible();
+  if !incompatible_plugins.is_empty() {
+    let incompatible_text = incompatible_plugins
+      .iter()
+      .map(|p| {
+        format!(
+          "{} (v{}) : {} (v{})",
+          p.crate_name, p.crate_version, p.npm_name, p.npm_version
+        )
+      })
+      .collect::<Vec<_>>()
+      .join("\n");
+    if options.ignore_incompatible_plugins {
+      log::error!("Found incompatible Tauri plugins. Make sure the NPM and crate versions are on the same major/minor releases:\n{}", incompatible_text);
+    } else {
+      anyhow::bail!("Found incompatible Tauri plugins. Make sure the NPM and crate versions are on the same major/minor releases:\n{}", incompatible_text);
+    }
+  }
+
   set_current_dir(tauri_path).with_context(|| "failed to change current working directory")?;
 
   let config_guard = config.lock().unwrap();

crates/tauri-cli/src/build.rs

@@ -9,6 +9,7 @@ use crate::{
     config::{
       get as get_config, reload as reload_config, BeforeDevCommand, ConfigHandle, FrontendDist,
     },
+    npm::PackageManager,
   },
   interface::{AppInterface, ExitReason, Interface},
   CommandExt, ConfigValue, Result,
@@ -135,6 +136,29 @@ fn command_internal(mut options: Options) -> Result<()> {
 
 pub fn setup(interface: &AppInterface, options: &mut Options, config: ConfigHandle) -> Result<()> {
   let tauri_path = tauri_dir();
+
+  std::thread::spawn(|| {
+    let installed_plugins = crate::info::plugins::installed_plugins(
+      frontend_dir(),
+      tauri_path,
+      PackageManager::from_project(frontend_dir()),
+    );
+    let incompatible_plugins = installed_plugins.incompatible();
+    if !incompatible_plugins.is_empty() {
+      let incompatible_text = incompatible_plugins
+        .iter()
+        .map(|p| {
+          format!(
+            "{} (v{}) : {} (v{})",
+            p.crate_name, p.crate_version, p.npm_name, p.npm_version
+          )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+      log::warn!("Found incompatible Tauri plugins. Make sure the NPM and crate versions are on the same major/minor releases:\n{}", incompatible_text);
+    }
+  });
+
   set_current_dir(tauri_path).with_context(|| "failed to change current working directory")?;
 
   if let Some(before_dev) = config

crates/tauri-cli/src/dev.rs

@@ -20,7 +20,7 @@ mod env_system;
 mod ios;
 mod packages_nodejs;
 mod packages_rust;
-mod plugins;
+pub mod plugins;
 
 #[derive(Deserialize)]
 struct JsCliVersionMetadata {

crates/tauri-cli/src/info/mod.rs

@@ -16,8 +16,91 @@ use crate::{
   interface::rust::get_workspace_dir,
 };
 
+use rayon::prelude::*;
+
 use super::{packages_nodejs, packages_rust, SectionItem};
 
+#[derive(Debug)]
+pub struct InstalledPlugin {
+  pub crate_name: String,
+  pub npm_name: String,
+  pub crate_version: semver::Version,
+  pub npm_version: semver::Version,
+}
+
+#[derive(Debug)]
+pub struct InstalledPlugins(Vec<InstalledPlugin>);
+
+impl InstalledPlugins {
+  pub fn incompatible(&self) -> Vec<&InstalledPlugin> {
+    self
+      .0
+      .iter()
+      .filter(|p| {
+        p.crate_version.major != p.npm_version.major || p.crate_version.minor != p.npm_version.minor
+      })
+      .collect()
+  }
+}
+
+pub fn installed_plugins(
+  frontend_dir: &Path,
+  tauri_dir: &Path,
+  package_manager: PackageManager,
+) -> InstalledPlugins {
+  let manifest: Option<CargoManifest> =
+    if let Ok(manifest_contents) = fs::read_to_string(tauri_dir.join("Cargo.toml")) {
+      toml::from_str(&manifest_contents).ok()
+    } else {
+      None
+    };
+
+  let lock: Option<CargoLock> = get_workspace_dir()
+    .ok()
+    .and_then(|p| fs::read_to_string(p.join("Cargo.lock")).ok())
+    .and_then(|s| toml::from_str(&s).ok());
+
+  let installed_plugins = helpers::plugins::known_plugins()
+    .into_par_iter()
+    .filter_map(|(plugin, _)| {
+      let crate_name = format!("tauri-plugin-{plugin}");
+      let crate_version = crate_version(tauri_dir, manifest.as_ref(), lock.as_ref(), &crate_name);
+      let Some(crate_version) = crate_version.version.and_then(|v| {
+        semver::Version::parse(&v)
+          .inspect_err(|_| {
+            log::error!("Failed to parse version `{v}` for crate `{crate_name}`");
+          })
+          .ok()
+      }) else {
+        return None;
+      };
+
+      let npm_name = format!("@tauri-apps/plugin-{plugin}");
+      let npm_version = package_manager
+        .current_package_version(&npm_name, &frontend_dir)
+        .unwrap_or_default();
+      if let Some(npm_version) = npm_version.and_then(|v| {
+        semver::Version::parse(&v)
+          .inspect_err(|_| {
+            log::error!("Failed to parse version `{v}` for NPM package `{npm_name}`");
+          })
+          .ok()
+      }) {
+        return Some(InstalledPlugin {
+          crate_name,
+          npm_name,
+          crate_version,
+          npm_version,
+        });
+      }
+
+      None
+    })
+    .collect();
+
+  InstalledPlugins(installed_plugins)
+}
+
 pub fn items(
   frontend_dir: Option<&PathBuf>,
   tauri_dir: Option<&Path>,

crates/tauri-cli/src/info/plugins.rs

@@ -78,6 +78,11 @@ pub struct Options {
   /// e.g. `tauri android build -- [runnerArgs]`.
   #[clap(last(true))]
   pub args: Vec<String>,
+  /// Do not error out if aversion incompatibility is detected on an installed plugin.
+  ///
+  /// Only use this when you are sure the mismatch is incorrectly detected as incompatible plugin versions can lead to unknown behavior.
+  #[clap(long)]
+  pub ignore_incompatible_plugins: bool,
 }
 
 impl From<Options> for BuildOptions {
@@ -92,6 +97,7 @@ impl From<Options> for BuildOptions {
       config: options.config,
       args: options.args,
       ci: options.ci,
+      ignore_incompatible_plugins: options.ignore_incompatible_plugins,
     }
   }
 }

crates/tauri-cli/src/mobile/android/build.rs

@@ -88,6 +88,11 @@ pub struct Options {
   /// e.g. `tauri ios build -- [runnerArgs]`.
   #[clap(last(true))]
   pub args: Vec<String>,
+  /// Do not error out if aversion incompatibility is detected on an installed plugin.
+  ///
+  /// Only use this when you are sure the mismatch is incorrectly detected as incompatible plugin versions can lead to unknown behavior.
+  #[clap(long)]
+  pub ignore_incompatible_plugins: bool,
 }
 
 #[derive(Debug, Clone, Copy, ValueEnum)]
@@ -132,6 +137,7 @@ impl From<Options> for BuildOptions {
       config: options.config,
       args: options.args,
       ci: options.ci,
+      ignore_incompatible_plugins: options.ignore_incompatible_plugins,
     }
   }
 }