fix: main binary name can't contain dots (#13429)

* fix: main binary name can't contain dots

* Revert the change in tauri.conf.json

* Change file

* Use target platform when matching extension

Author: Legend-Master

.changes/fix-main-binary-name-with-dot.md

@@ -0,0 +1,6 @@
+---
+"tauri-utils": "patch:bug"
+"tauri-bundler": "patch:bug"
+---
+
+Fix `mainBinaryName` doesn't work when there's `.` in it

crates/tauri-build/src/lib.rs

@@ -528,7 +528,7 @@ pub fn try_build(attributes: Attributes) -> Result<()> {
 
   if let Some(paths) = &config.bundle.external_bin {
     copy_binaries(
-      ResourcePaths::new(external_binaries(paths, &target_triple).as_slice(), true),
+      ResourcePaths::new(&external_binaries(paths, &target_triple, &target), true),
       &target_triple,
       target_dir,
       manifest.package.as_ref().map(|p| &p.name),

crates/tauri-bundler/src/bundle.rs

@@ -13,7 +13,7 @@ mod settings;
 mod updater_bundle;
 mod windows;
 
-use tauri_utils::display_path;
+use tauri_utils::{display_path, platform::Target as TargetPlatform};
 
 pub use self::{
   category::AppCategory,
@@ -48,19 +48,14 @@ pub fn bundle_project(settings: &Settings) -> crate::Result<Vec<Bundle>> {
 
   package_types.sort_by_key(|a| a.priority());
 
-  let target_os = settings
-    .target()
-    .split('-')
-    .nth(2)
-    .unwrap_or(std::env::consts::OS)
-    .replace("darwin", "macos");
+  let target_os = settings.target_platform();
 
-  if target_os != std::env::consts::OS {
+  if *target_os != TargetPlatform::current() {
     log::warn!("Cross-platform compilation is experimental and does not support all features. Please use a matching host system for full compatibility.");
   }
 
   // Sign windows binaries before the bundling step in case neither wix and nsis bundles are enabled
-  if target_os == "windows" {
+  if matches!(target_os, TargetPlatform::Windows) {
     if settings.can_sign() {
       for bin in settings.binaries() {
         let bin_path = settings.binary_path(bin);

crates/tauri-bundler/src/bundle/settings.rs

@@ -12,6 +12,7 @@ use tauri_utils::{
     BundleType, DeepLinkProtocol, FileAssociation, NSISInstallerMode, NsisCompression,
     RpmCompression,
   },
+  platform::Target as TargetPlatform,
   resources::{external_binaries, ResourcePaths},
 };
 
@@ -760,6 +761,8 @@ pub struct Settings {
   bundle_settings: BundleSettings,
   /// the binaries to bundle.
   binaries: Vec<BundleBinary>,
+  /// The target platform.
+  target_platform: TargetPlatform,
   /// The target triple.
   target: String,
 }
@@ -855,6 +858,7 @@ impl SettingsBuilder {
     } else {
       target_triple()?
     };
+    let target_platform = TargetPlatform::from_triple(&target);
 
     Ok(Settings {
       log_level: self.log_level.unwrap_or(log::Level::Error),
@@ -872,9 +876,10 @@ impl SettingsBuilder {
           .bundle_settings
           .external_bin
           .as_ref()
-          .map(|bins| external_binaries(bins, &target)),
+          .map(|bins| external_binaries(bins, &target, &target_platform)),
         ..self.bundle_settings
       },
+      target_platform,
       target,
     })
   }
@@ -901,6 +906,11 @@ impl Settings {
     &self.target
   }
 
+  /// Returns the [`TargetPlatform`].
+  pub fn target_platform(&self) -> &TargetPlatform {
+    &self.target_platform
+  }
+
   /// Returns the architecture for the binary being bundled (e.g. "arm", "x86" or "x86_64").
   pub fn binary_arch(&self) -> Arch {
     if self.target.starts_with("x86_64") {
@@ -955,19 +965,23 @@ impl Settings {
 
   /// Returns the path to the specified binary.
   pub fn binary_path(&self, binary: &BundleBinary) -> PathBuf {
-    let target_os = self
-      .target()
-      .split('-')
-      .nth(2)
-      .unwrap_or(std::env::consts::OS);
-
-    let path = self.project_out_directory.join(binary.name());
+    let target_os = self.target_platform();
+
+    let mut path = self.project_out_directory.join(binary.name());
+
+    if matches!(target_os, TargetPlatform::Windows) {
+      // Append the `.exe` extension without overriding the existing extensions
+      let extension = if let Some(extension) = path.extension() {
+        let mut extension = extension.to_os_string();
+        extension.push(".exe");
+        extension
+      } else {
+        "exe".into()
+      };
+      path.set_extension(extension);
+    };
 
-    if target_os == "windows" {
-      path.with_extension("exe")
-    } else {
-      path
-    }
+    path
   }
 
   /// Returns the list of binaries to bundle.
@@ -985,18 +999,13 @@ impl Settings {
   ///
   /// Fails if the host/target's native package type is not supported.
   pub fn package_types(&self) -> crate::Result<Vec<PackageType>> {
-    let target_os = self
-      .target
-      .split('-')
-      .nth(2)
-      .unwrap_or(std::env::consts::OS)
-      .replace("darwin", "macos");
-
-    let platform_types = match target_os.as_str() {
-      "macos" => vec![PackageType::MacOsBundle, PackageType::Dmg],
-      "ios" => vec![PackageType::IosBundle],
-      "linux" => vec![PackageType::Deb, PackageType::Rpm, PackageType::AppImage],
-      "windows" => vec![PackageType::WindowsMsi, PackageType::Nsis],
+    let target_os = self.target_platform();
+
+    let platform_types = match target_os {
+      TargetPlatform::MacOS => vec![PackageType::MacOsBundle, PackageType::Dmg],
+      TargetPlatform::Ios => vec![PackageType::IosBundle],
+      TargetPlatform::Linux => vec![PackageType::Deb, PackageType::Rpm, PackageType::AppImage],
+      TargetPlatform::Windows => vec![PackageType::WindowsMsi, PackageType::Nsis],
       os => {
         return Err(crate::Error::GenericError(format!(
           "Native {os} bundles not yet supported."

crates/tauri-bundler/src/bundle/updater_bundle.rs

@@ -14,7 +14,7 @@ use crate::{
   utils::fs_utils,
   Settings,
 };
-use tauri_utils::display_path;
+use tauri_utils::{display_path, platform::Target as TargetPlatform};
 
 use std::{
   fs::{self, File},
@@ -27,14 +27,9 @@ use zip::write::SimpleFileOptions;
 
 // Build update
 pub fn bundle_project(settings: &Settings, bundles: &[Bundle]) -> crate::Result<Vec<PathBuf>> {
-  let target_os = settings
-    .target()
-    .split('-')
-    .nth(2)
-    .unwrap_or(std::env::consts::OS)
-    .replace("darwin", "macos");
-
-  if target_os == "windows" {
+  let target_os = settings.target_platform();
+
+  if matches!(target_os, TargetPlatform::Windows) {
     return bundle_update_windows(settings, bundles);
   }
 

crates/tauri-cli/config.schema.json

@@ -24,7 +24,7 @@
       "pattern": "^[^/\\:*?\"<>|]+$"
     },
     "mainBinaryName": {
-      "description": "App main binary filename. Defaults to the name of your cargo crate.",
+      "description": "Overrides app's main binary filename.\n\n By default, Tauri uses the output binary from `cargo`, by setting this, we will rename that binary in `tauri-cli`'s\n `tauri build` command, and target `tauri bundle` to it\n\n If possible, change the [`package name`] or set the [`name field`] instead,\n and if that's not enough and you're using nightly, consider using the [`different-binary-name`] feature instead\n\n Note: this config should not include the binary extension (e.g. `.exe`), we'll add that for you\n\n [`package name`]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-name-field\n [`name field`]: https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-name-field\n [`different-binary-name`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#different-binary-name",
       "type": [
         "string",
         "null"

crates/tauri-cli/src/interface/rust.rs

@@ -35,7 +35,7 @@ use crate::{
   },
   ConfigValue,
 };
-use tauri_utils::{display_path, platform::Target};
+use tauri_utils::{display_path, platform::Target as TargetPlatform};
 
 mod cargo_config;
 mod desktop;
@@ -529,7 +529,7 @@ impl Rust {
 
           if let Some(event_path) = event.paths.first() {
             if !ignore_matcher.is_ignore(event_path, event_path.is_dir()) {
-              if is_configuration_file(self.app_settings.target, event_path) {
+              if is_configuration_file(self.app_settings.target_platform, event_path) {
                 if let Ok(config) = reload_config(merge_configs) {
                   let (manifest, modified) =
                     rewrite_manifest(config.lock().unwrap().as_ref().unwrap())?;
@@ -643,9 +643,18 @@ struct WorkspacePackageSettings {
 #[derive(Clone, Debug, Deserialize)]
 struct BinarySettings {
   name: String,
+  /// This is from nightly: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#different-binary-name
+  filename: Option<String>,
   path: Option<String>,
 }
 
+impl BinarySettings {
+  /// The file name without the binary extension (e.g. `.exe`)
+  pub fn file_name(&self) -> &str {
+    self.filename.as_ref().unwrap_or(&self.name)
+  }
+}
+
 /// The package settings.
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "kebab-case")]
@@ -699,7 +708,7 @@ pub struct RustAppSettings {
   package_settings: PackageSettings,
   cargo_config: CargoConfig,
   target_triple: String,
-  target: Target,
+  target_platform: TargetPlatform,
 }
 
 #[derive(Deserialize)]
@@ -866,13 +875,19 @@ impl AppSettings for RustAppSettings {
       .out_dir(options)
       .context("failed to get project out directory")?;
 
-    let ext = if self.target_triple.contains("windows") {
-      "exe"
-    } else {
-      ""
+    let mut path = out_dir.join(bin_name);
+    if matches!(self.target_platform, TargetPlatform::Windows) {
+      // Append the `.exe` extension without overriding the existing extensions
+      let extension = if let Some(extension) = path.extension() {
+        let mut extension = extension.to_os_string();
+        extension.push(".exe");
+        extension
+      } else {
+        "exe".into()
+      };
+      path.set_extension(extension);
     };
-
-    Ok(out_dir.join(bin_name).with_extension(ext))
+    Ok(path)
   }
 
   fn get_binaries(&self) -> crate::Result<Vec<BundleBinary>> {
@@ -885,9 +900,10 @@ impl AppSettings for RustAppSettings {
         .clone()
         .unwrap_or_default();
       for bin in bins {
-        let is_main = bin.name == self.cargo_package_settings.name || bin.name == default_run;
+        let file_name = bin.file_name();
+        let is_main = file_name == self.cargo_package_settings.name || file_name == default_run;
         binaries.push(BundleBinary::with_path(
-          bin.name.clone(),
+          file_name.to_owned(),
           is_main,
           bin.path.clone(),
         ))
@@ -1087,7 +1103,7 @@ impl RustAppSettings {
             .to_string()
         })
     });
-    let target = Target::from_triple(&target_triple);
+    let target = TargetPlatform::from_triple(&target_triple);
 
     Ok(Self {
       manifest: Mutex::new(manifest),
@@ -1097,7 +1113,7 @@ impl RustAppSettings {
       package_settings,
       cargo_config,
       target_triple,
-      target,
+      target_platform: target,
     })
   }
 

crates/tauri-cli/src/interface/rust/desktop.rs

@@ -17,6 +17,7 @@ use std::{
     Arc, Mutex,
   },
 };
+use tauri_utils::platform::Target as TargetPlatform;
 
 pub struct DevChild {
   manually_killed_app: Arc<AtomicBool>,
@@ -188,16 +189,16 @@ pub fn build(
 
     let lipo_status = lipo_cmd.output_ok()?.status;
     if !lipo_status.success() {
-      return Err(anyhow::anyhow!(format!(
+      return Err(anyhow::anyhow!(
         "Result of `lipo` command was unsuccessful: {lipo_status}. (Is `lipo` installed?)"
-      )));
+      ));
     }
   } else {
     build_production_app(options, available_targets, config_features)
       .with_context(|| "failed to build app")?;
   }
 
-  rename_app(bin_path, main_binary_name)
+  rename_app(bin_path, main_binary_name, &app_settings.target_platform)
 }
 
 fn build_production_app(
@@ -305,12 +306,18 @@ fn validate_target(
   Ok(())
 }
 
-fn rename_app(bin_path: PathBuf, main_binary_name: Option<&str>) -> crate::Result<PathBuf> {
+fn rename_app(
+  bin_path: PathBuf,
+  main_binary_name: Option<&str>,
+  target_platform: &TargetPlatform,
+) -> crate::Result<PathBuf> {
   if let Some(main_binary_name) = main_binary_name {
-    let new_path = bin_path
-      .with_file_name(main_binary_name)
-      .with_extension(bin_path.extension().unwrap_or_default());
-
+    let extension = if matches!(target_platform, TargetPlatform::Windows) {
+      ".exe"
+    } else {
+      ""
+    };
+    let new_path = bin_path.with_file_name(format!("{main_binary_name}{extension}"));
     fs::rename(&bin_path, &new_path).with_context(|| {
       format!(
         "failed to rename `{}` to `{}`",

crates/tauri-schema-generator/schemas/config.schema.json

@@ -24,7 +24,7 @@
       "pattern": "^[^/\\:*?\"<>|]+$"
     },
     "mainBinaryName": {
-      "description": "App main binary filename. Defaults to the name of your cargo crate.",
+      "description": "Overrides app's main binary filename.\n\n By default, Tauri uses the output binary from `cargo`, by setting this, we will rename that binary in `tauri-cli`'s\n `tauri build` command, and target `tauri bundle` to it\n\n If possible, change the [`package name`] or set the [`name field`] instead,\n and if that's not enough and you're using nightly, consider using the [`different-binary-name`] feature instead\n\n Note: this config should not include the binary extension (e.g. `.exe`), we'll add that for you\n\n [`package name`]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-name-field\n [`name field`]: https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-name-field\n [`different-binary-name`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#different-binary-name",
       "type": [
         "string",
         "null"

crates/tauri-utils/src/config.rs

@@ -2946,7 +2946,19 @@ pub struct Config {
   #[serde(alias = "product-name")]
   #[cfg_attr(feature = "schema", validate(regex(pattern = "^[^/\\:*?\"<>|]+$")))]
   pub product_name: Option<String>,
-  /// App main binary filename. Defaults to the name of your cargo crate.
+  /// Overrides app's main binary filename.
+  ///
+  /// By default, Tauri uses the output binary from `cargo`, by setting this, we will rename that binary in `tauri-cli`'s
+  /// `tauri build` command, and target `tauri bundle` to it
+  ///
+  /// If possible, change the [`package name`] or set the [`name field`] instead,
+  /// and if that's not enough and you're using nightly, consider using the [`different-binary-name`] feature instead
+  ///
+  /// Note: this config should not include the binary extension (e.g. `.exe`), we'll add that for you
+  ///
+  /// [`package name`]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-name-field
+  /// [`name field`]: https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-name-field
+  /// [`different-binary-name`]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#different-binary-name
   #[serde(alias = "main-binary-name")]
   pub main_binary_name: Option<String>,
   /// App version. It is a semver version number or a path to a `package.json` file containing the `version` field.