feat: Mac .pkg installer

This adds support for building Mac .pkg installers. This current
implementation is intentionally a bit simplistic: it produces one
.pkg per package in the user's workspace, without any special
branding applied. We currently only allow the app identifier and
install location to be configured, but we can consider adding further
customization in the future.

Author: mistydemeo

cargo-dist/src/backend/installer/macpkg.rs

@@ -0,0 +1,99 @@
+//! Code for generating installer.pkg
+
+use std::{collections::BTreeMap, fs};
+
+use axoasset::LocalAsset;
+use axoprocess::Cmd;
+use camino::Utf8PathBuf;
+use serde::Serialize;
+use temp_dir::TempDir;
+use tracing::info;
+
+use crate::{create_tmp, DistResult};
+
+use super::ExecutableZipFragment;
+
+/// Info about a package installer
+#[derive(Debug, Clone, Serialize)]
+pub struct PkgInstallerInfo {
+    /// ExecutableZipFragment for this variant
+    pub artifact: ExecutableZipFragment,
+    /// Identifier for the final installer
+    pub identifier: String,
+    /// Default install location
+    pub install_location: String,
+    /// Final file path of the pkg
+    pub file_path: Utf8PathBuf,
+    /// Dir stuff goes to
+    pub package_dir: Utf8PathBuf,
+    /// The app version
+    pub version: String,
+    /// Executable aliases
+    pub bin_aliases: BTreeMap<String, Vec<String>>,
+}
+
+impl PkgInstallerInfo {
+    /// Build the pkg installer
+    pub fn build(&self) -> DistResult<()> {
+        info!("building a pkg: {}", self.identifier);
+
+        // We can't build directly from dist_dir because the
+        // package installer wants the directory we feed it
+        // to have the final package layout, which in this case
+        // is going to be an FHS-ish path installed into a public
+        // location. So instead we create a new tree with our stuff
+        // like we want it, and feed that to pkgbuild.
+        let (_build_dir, build_dir) = create_tmp()?;
+        let bindir = build_dir.join("bin");
+        LocalAsset::create_dir_all(&bindir)?;
+        let libdir = build_dir.join("lib");
+        LocalAsset::create_dir_all(&libdir)?;
+
+        info!("Copying executables");
+        for exe in &self.artifact.executables {
+            info!("{} => {:?}", &self.package_dir.join(exe), bindir.join(exe));
+            LocalAsset::copy_file_to_file(&self.package_dir.join(exe), bindir.join(exe))?;
+        }
+        #[cfg(unix)]
+        for (bin, targets) in &self.bin_aliases {
+            for target in targets {
+                std::os::unix::fs::symlink(&bindir.join(bin), &bindir.join(target))?;
+            }
+        }
+        for lib in self
+            .artifact
+            .cdylibs
+            .iter()
+            .chain(self.artifact.cstaticlibs.iter())
+        {
+            LocalAsset::copy_file_to_file(&self.package_dir.join(lib), libdir.join(lib))?;
+        }
+
+        // The path the two pkg files get placed in while building
+        let pkg_output = TempDir::new()?;
+        let pkg_output_path = pkg_output.path();
+        let pkg_path = pkg_output_path.join("package.pkg");
+        let product_path = pkg_output_path.join("product.pkg");
+
+        let mut pkgcmd = Cmd::new("/usr/bin/pkgbuild", "create individual pkg");
+        pkgcmd.arg("--root").arg(build_dir);
+        pkgcmd.arg("--identifier").arg(&self.identifier);
+        pkgcmd.arg("--install-location").arg(&self.install_location);
+        pkgcmd.arg("--version").arg(&self.version);
+        pkgcmd.arg(&pkg_path);
+        // Ensures stdout from the build process doesn't taint the dist-manifest
+        pkgcmd.stdout_to_stderr();
+        pkgcmd.run()?;
+
+        // OK, we've made a package. Now wrap it in a product pkg.
+        let mut productcmd = Cmd::new("/usr/bin/productbuild", "create final product .pkg");
+        productcmd.arg("--package").arg(&pkg_path);
+        productcmd.arg(&product_path);
+        productcmd.stdout_to_stderr();
+        productcmd.run()?;
+
+        fs::copy(&product_path, &self.file_path)?;
+
+        Ok(())
+    }
+}

cargo-dist/src/backend/installer/mod.rs

@@ -5,6 +5,7 @@
 use std::collections::BTreeMap;
 
 use camino::Utf8PathBuf;
+use macpkg::PkgInstallerInfo;
 use serde::Serialize;
 
 use crate::{
@@ -18,6 +19,7 @@ use self::msi::MsiInstallerInfo;
 use self::npm::NpmInstallerInfo;
 
 pub mod homebrew;
+pub mod macpkg;
 pub mod msi;
 pub mod npm;
 pub mod powershell;
@@ -37,6 +39,8 @@ pub enum InstallerImpl {
     Homebrew(HomebrewInstallerInfo),
     /// Windows msi installer
     Msi(MsiInstallerInfo),
+    /// Mac pkg installer
+    Pkg(PkgInstallerInfo),
 }
 
 /// Generic info about an installer

cargo-dist/src/config.rs

@@ -439,6 +439,11 @@ pub struct DistMetadata {
     /// Any additional steps that need to be performed before building local artifacts
     #[serde(default)]
     pub github_build_setup: Option<String>,
+
+    /// Configuration specific to Mac .pkg installers
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub mac_pkg_config: Option<MacPkgConfig>,
 }
 
 /// values of the form `permission-name: read`
@@ -523,6 +528,7 @@ impl DistMetadata {
             package_libraries: _,
             install_libraries: _,
             github_build_setup: _,
+            mac_pkg_config: _,
         } = self;
         if let Some(include) = include {
             for include in include {
@@ -618,6 +624,7 @@ impl DistMetadata {
             package_libraries,
             install_libraries,
             github_build_setup,
+            mac_pkg_config,
         } = self;
 
         // Check for global settings on local packages
@@ -799,6 +806,9 @@ impl DistMetadata {
         if install_libraries.is_none() {
             install_libraries.clone_from(&workspace_config.install_libraries);
         }
+        if mac_pkg_config.is_none() {
+            mac_pkg_config.clone_from(&workspace_config.mac_pkg_config);
+        }
 
         // This was historically implemented as extend, but I'm not convinced the
         // inconsistency is worth the inconvenience...
@@ -956,6 +966,8 @@ pub enum InstallerStyle {
     Homebrew,
     /// Generate an msi installer that embeds the binary
     Msi,
+    /// Generate an Apple pkg installer that embeds the binary
+    Pkg,
 }
 
 impl std::fmt::Display for InstallerStyle {
@@ -966,6 +978,7 @@ impl std::fmt::Display for InstallerStyle {
             InstallerStyle::Npm => "npm",
             InstallerStyle::Homebrew => "homebrew",
             InstallerStyle::Msi => "msi",
+            InstallerStyle::Pkg => "pkg",
         };
         string.fmt(f)
     }
@@ -1675,6 +1688,18 @@ impl std::fmt::Display for ProductionMode {
     }
 }
 
+/// Configuration for Mac .pkg installers
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct MacPkgConfig {
+    /// A unique identifier, in tld.domain.package format
+    pub identifier: String,
+    /// The location to which the software should be installed.
+    /// If not specified, /usr/local will be used.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub install_location: Option<String>,
+}
+
 pub(crate) fn parse_metadata_table_or_manifest(
     manifest_path: &Utf8Path,
     dist_manifest_path: Option<&Utf8Path>,

cargo-dist/src/errors.rs

@@ -234,22 +234,22 @@ pub enum DistError {
         generate_mode: crate::config::GenerateMode,
     },
 
-    /// msi with too many packages
+    /// msi/pkg with too many packages
     #[error("{artifact_name} depends on multiple packages, which isn't yet supported")]
     #[diagnostic(help("depends on {spec1} and {spec2}"))]
-    MultiPackageMsi {
-        /// Name of the msi
+    MultiPackage {
+        /// Name of the artifact
         artifact_name: String,
         /// One of the pacakges
         spec1: String,
         /// A different package
         spec2: String,
     },
 
-    /// msi with too few packages
+    /// msi/pkg with too few packages
     #[error("{artifact_name} has no binaries")]
     #[diagnostic(help("This should be impossible, you did nothing wrong, please file an issue!"))]
-    NoPackageMsi {
+    NoPackage {
         /// Name of the msi
         artifact_name: String,
     },
@@ -525,6 +525,16 @@ pub enum DistError {
     #[error("We failed to decode the certificate stored in the CODESIGN_CERTIFICATE environment variable.")]
     #[diagnostic(help("Is the value of this envirionment variable valid base64?"))]
     CertificateDecodeError {},
+
+    /// Missing configuration for a .pkg
+    #[error("A Mac .pkg installer was requested, but the config is missing")]
+    #[diagnostic(help("Please ensure a dist.mac-pkg-config section is present in your config. For more details see: https://example.com"))]
+    MacPkgConfigMissing {},
+
+    /// User left identifier empty in init
+    #[error("No bundle identifier was specified")]
+    #[diagnostic(help("Please either enter a bundle identifier, or disable the Mac .pkg"))]
+    MacPkgBundleIdentifierMissing {},
 }
 
 /// This error indicates we tried to deserialize some YAML with serde_yml

cargo-dist/src/init.rs

@@ -477,6 +477,7 @@ fn get_new_dist_metadata(
             package_libraries: None,
             install_libraries: None,
             github_build_setup: None,
+            mac_pkg_config: None,
         }
     };
 
@@ -664,6 +665,7 @@ fn get_new_dist_metadata(
                 InstallerStyle::Npm,
                 InstallerStyle::Homebrew,
                 InstallerStyle::Msi,
+                InstallerStyle::Pkg,
             ]
         } else {
             eprintln!("{notice} no CI backends enabled, most installers have been hidden");
@@ -692,6 +694,7 @@ fn get_new_dist_metadata(
                 InstallerStyle::Npm => "npm",
                 InstallerStyle::Homebrew => "homebrew",
                 InstallerStyle::Msi => "msi",
+                InstallerStyle::Pkg => "pkg",
             });
         }
 
@@ -779,6 +782,66 @@ fn get_new_dist_metadata(
         }
     }
 
+    // Special handling of the pkg installer
+    if meta
+        .installers
+        .as_deref()
+        .unwrap_or_default()
+        .contains(&InstallerStyle::Pkg)
+    {
+        let pkg_is_new = !orig_meta
+            .installers
+            .as_deref()
+            .unwrap_or_default()
+            .contains(&InstallerStyle::Pkg);
+
+        if pkg_is_new && orig_meta.mac_pkg_config.is_none() {
+            let prompt = r#"you've enabled a Mac .pkg installer. This requires a unique bundle ID;
+    please enter one now. This is in reverse-domain name format.
+    For more information, consult the Apple documentation:
+    https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFBundles/BundleTypes/BundleTypes.html#//apple_ref/doc/uid/10000123i-CH101-SW1"#;
+            let default = "".to_string();
+
+            let identifier: String = if args.yes {
+                default
+            } else {
+                let res = Input::with_theme(&theme)
+                    .with_prompt(prompt)
+                    .allow_empty(true)
+                    .interact_text()?;
+                eprintln!();
+                res
+            };
+            let identifier = identifier.trim();
+            if identifier.is_empty() {
+                return Err(DistError::MacPkgBundleIdentifierMissing {});
+            }
+
+            let prompt = r#"Please enter the installation prefix this .pkg should use."#;
+            let prefix = if args.yes {
+                None
+            } else {
+                let res: String = Input::with_theme(&theme)
+                    .with_prompt(prompt)
+                    .allow_empty(true)
+                    .interact_text()?;
+                eprintln!();
+
+                let trimmed = res.trim();
+                if trimmed.is_empty() {
+                    None
+                } else {
+                    Some(trimmed.to_owned())
+                }
+            };
+
+            meta.mac_pkg_config = Some(config::MacPkgConfig {
+                identifier: identifier.to_owned(),
+                install_location: prefix,
+            })
+        }
+    }
+
     meta.publish_jobs = if publish_jobs.is_empty() {
         None
     } else {
@@ -978,6 +1041,7 @@ fn apply_dist_to_metadata(metadata: &mut toml_edit::Item, meta: &DistMetadata) {
         bin_aliases: _,
         system_dependencies: _,
         github_build_setup: _,
+        mac_pkg_config: _,
     } = &meta;
 
     // Forcibly inline the default install_path if not specified,

cargo-dist/src/lib.rs

@@ -17,7 +17,7 @@ use axoasset::LocalAsset;
 use axoprocess::Cmd;
 use backend::{
     ci::CiInfo,
-    installer::{self, msi::MsiInstallerInfo, InstallerImpl},
+    installer::{self, macpkg::PkgInstallerInfo, msi::MsiInstallerInfo, InstallerImpl},
 };
 use build::generic::{build_generic_target, run_extra_artifacts_build};
 use build::{
@@ -312,8 +312,9 @@ fn build_fake(
             with_root,
         }) => zip_dir(src_path, dest_path, zip_style, with_root.as_deref())?,
         BuildStep::GenerateInstaller(installer) => match installer {
-            // MSI, unlike other installers, isn't safe to generate on any platform
+            // MSI and pkg, unlike other installers, aren't safe to generate on any platform
             InstallerImpl::Msi(msi) => generate_fake_msi(dist_graph, msi, manifest)?,
+            InstallerImpl::Pkg(pkg) => generate_fake_pkg(dist_graph, pkg, manifest)?,
             _ => generate_installer(dist_graph, installer, manifest)?,
         },
         BuildStep::Checksum(ChecksumImpl {
@@ -367,6 +368,16 @@ fn generate_fake_msi(
     Ok(())
 }
 
+fn generate_fake_pkg(
+    _dist: &DistGraph,
+    pkg: &PkgInstallerInfo,
+    _manifest: &DistManifest,
+) -> DistResult<()> {
+    LocalAsset::write_new_all("", &pkg.file_path)?;
+
+    Ok(())
+}
+
 /// Generate a checksum for the src_path to dest_path
 fn generate_and_write_checksum(
     manifest: &mut DistManifest,
@@ -727,6 +738,7 @@ fn generate_installer(
             installer::homebrew::write_homebrew_formula(dist, info, manifest)?
         }
         InstallerImpl::Msi(info) => info.build(dist)?,
+        InstallerImpl::Pkg(info) => info.build()?,
     }
     Ok(())
 }

cargo-dist/src/manifest.rs

@@ -355,6 +355,11 @@ fn add_manifest_artifact(
             description = Some("install via msi".to_owned());
             kind = cargo_dist_schema::ArtifactKind::Installer;
         }
+        ArtifactKind::Installer(InstallerImpl::Pkg(..)) => {
+            install_hint = None;
+            description = Some("install via pkg".to_owned());
+            kind = cargo_dist_schema::ArtifactKind::Installer;
+        }
         ArtifactKind::Checksum(_) => {
             install_hint = None;
             description = None;