Automatical postinstall script for macos

[haikesan]

What is the problem or limitation you are having?

I am now trying to use postinstall script in my pkg file on macos. It is present in cookiecutter template, but, nor pkgbuild or productbuild doesn't really do anything with it. Didn't find any workarounds or solutions for this in docs, and I don't want to spin xcode project in here.

Describe the solution you'd like

I will like to have option to include custom payload for installer-only, inside resources, that will be packed alongside with .html file and license.
My postinstall depends on pre-compiled executable (Yes, this is intended and fully needed for my usecase. Also, including some additional data in installer could be useful sometimes), which I would like to invoke from postinstall script.
Is this even possible?

Describe alternatives you've considered

I've checked the docs for some configuration options, checked older version of macos app template..

Additional context

No response

[haikesan]

In briefcase/platforms/macOS/init.py there is macOSPackageMixin, which is writing this:
with self.console.wait_bar("Writing component manifest..."):
with components_plist_path.open("wb") as components_plist:
plistlib.dump(
[
{
"BundleHasStrictIdentifier": True,
"BundleIsRelocatable": False,
"BundleIsVersionChecked": True,
"BundleOverwriteAction": "upgrade",
"RootRelativeBundlePath": self.package_path(app).name,
}
],
components_plist,
)
I could manually edit this after project generation to include BundlePostInstallScriptPath, but this solution doesn't look like pretty one for me..

[haikesan]

Also, found interesting comment:
# Console apps are installed in /Library/Formal Name, and include the
# post-install scripts. Normal apps are installed in /Applications, and don't
# include the scripts.

But, some "normal" apps also want to have postinstall..
For some reason, resources are also not updated, maybe reason is in some caches?
Also, maybe everything here is not intended and I should write plugin for myself?

[freakboy3742]

Thanks for the request.

Firstly - you're not missing anything. While some of the infrastructure for pre/post install scripts is present in the installer, it isn't something we currently support.

However, we've recently added support for pre/post install scripts on Windows MSI installers, and we're definitely interested in extending that to PKG installers for macOS. If you want to make a proposal (and/or turn that proposal into a pull request), that would be a very helpful way to contribute to Briefcase as a project.

[haikesan]

My really DIRTY solution (later will think of how to clean it up and to contribute accordingly):

src/custombuilder.py

import plistlib
from pathlib import Path

from briefcase.commands import PackageCommand
from briefcase.config import AppConfig
from briefcase.exceptions import BriefcaseCommandError
from briefcase.platforms.macOS import app, macOSPackageMixin
from briefcase.platforms.macOS import SigningIdentity


class macOSPackageCustomMixin(macOSPackageMixin):
    def package_app(
        self,
        app: AppConfig,
        notarize_app=None,
        identity=None,
        adhoc_sign=False,
        sign_installer=True,
        installer_identity=None,
        submission_id=None,
        **kwargs,
    ):
        self.verify_not_on_icloud(app)

        self.console.info("Skipping signing...", prefix=app.app_name)

        if app.packaging_format == "zip":
            self.package_zip(
                app,
                notarize_app=notarize_app,
                identity=identity,
            )

        elif app.packaging_format == "pkg":
            # If the user has indicated they want to sign the installer (the default),
            # and the signing identity for the app *isn't* the adhoc identity, select an
            # identity for signing the installer.

            self.package_pkg(
                app,
                notarize_app=notarize_app,
                identity=identity,
                installer_identity=installer_identity,
            )

        else:  # Default packaging format is DMG
            self.package_dmg(
                app,
                notarize_app=notarize_app,
                identity=identity,
            )

    def package_pkg(
        self,
        app: AppConfig,
        notarize_app: bool,
        identity,
        installer_identity,
    ):
        """Package the app as an installer."""
        identity = SigningIdentity()
        dist_path: Path = self.distribution_path(app)

        self.console.info("Building PKG...", prefix=app.app_name)

        installer_path = self.bundle_path(app) / "installer"

        with self.console.wait_bar("Installing license..."):
            license_file = self.base_path / "LICENSE"
            if license_file.is_file():
                (installer_path / "resources").mkdir(exist_ok=True)
                self.tools.shutil.copy(
                    license_file,
                    installer_path / "resources/LICENSE",
                )
            else:
                raise BriefcaseCommandError(
                    """\
Your project does not contain a LICENSE file.

Create a file named `LICENSE` in the same directory as your `pyproject.toml`
with your app's licensing terms.
"""
                )

        # pkgbuild's default behavior is to make "relocatable" installs, which means
        # that if you've ever run the app, the installer will default to updating *that*
        # version, rather than putting it in the location that the installer specifies.
        # This means if you've ever used `briefcase run`, that will be the install
        # location of the "installed" app. To work around this, you have to provide a
        # plist file - but that requires providing a "root" folder that *only* contains
        # the products you want to install. So - we need to copy the built app to a
        # "clean" packaging location.
        with self.console.wait_bar("Copying app into products folder..."):
            installed_app_path = installer_path / "root" / self.package_path(app).name
            if installed_app_path.exists():
                self.tools.shutil.rmtree(installed_app_path)
            self.tools.shutil.copytree(
                self.package_path(app),
                installed_app_path,
                # Ensure that symlinks are preserved in the duplication.
                symlinks=True,
            )

        components_plist_path = self.bundle_path(app) / "installer/components.plist"

        with self.console.wait_bar("Writing component manifest..."):
            with components_plist_path.open("wb") as components_plist:
                plistlib.dump(
                    [
                        {
                            "BundleHasStrictIdentifier": True,
                            "BundleIsRelocatable": False,
                            "BundleIsVersionChecked": True,
                            "BundleOverwriteAction": "upgrade",
                            "RootRelativeBundlePath": self.package_path(app).name,
                            "BundlePostInstallScriptPath": "postinstall",
                        }
                    ],
                    components_plist,
                )

        # Console apps are installed in /Library/Formal Name, and include the
        # post-install scripts. Normal apps are installed in /Applications, and don't
        # include the scripts.
        install_args = [
            "--install-location",
            f"/Applications",
            "--scripts",
            installer_path / "scripts",
        ]

        with self.console.wait_bar("Building app package..."):
            installer_packages_path = installer_path / "packages"
            if installer_packages_path.exists():
                self.tools.shutil.rmtree(installer_packages_path)
            installer_packages_path.mkdir()

            self.tools.subprocess.run(
                [
                    "pkgbuild",
                    "--root",
                    installer_path / "root",
                    "--component-plist",
                    components_plist_path,
                ]
                + install_args
                + [
                    installer_packages_path / f"{app.app_name}.pkg",
                ],
                check=True,
            )

        # Build package
        with self.console.wait_bar(f"Building {dist_path.name}..."):
            signing_options = []

            self.tools.subprocess.run(
                [
                    "productbuild",
                    "--distribution",
                    installer_path / "Distribution.xml",
                    "--package-path",
                    installer_path / "packages",
                    "--resources",
                    installer_path / "resources",
                ]
                + signing_options
                + [
                    dist_path,
                ],
                check=True,
            )

        if notarize_app:
            self.console.info(
                f"Notarizing PKG with team ID {installer_identity.team_id}...",
                prefix=app.app_name,
            )
            self.notarize(
                app,
                identity=identity,
                installer_identity=installer_identity,
            )

    def sign_file(
        self,
        path: Path,
        identity: SigningIdentity,
        entitlements: Path | None = None,
    ):
        pass


class macOSAppPackageCustomCommand(
    macOSPackageCustomMixin, app.macOSAppMixin, PackageCommand
):
    description = "Package a macOS app for distribution with postinstall support."


create = app.macOSAppCreateCommand
update = app.macOSAppUpdateCommand
open = app.macOSAppOpenCommand
build = app.macOSAppBuildCommand
run = app.macOSAppRunCommand
package = macOSAppPackageCustomCommand
publish = app.macOSAppPublishCommand
dev = app.macOSAppDevCommand

[project.entry-points."briefcase.platforms"]
macOScustom = "briefcase.platforms.macOS"

[project.entry-points."briefcase.formats.macOScustom"]
app = "custombuilder"

in installer/scripts:

postinstall:

#!/bin/sh
echo "Post installation process started"

./postinstall_bin

echo "Post installation process finished"

postinstall_bin - custom binary itself

Done this at late night yesterday, so it's mostly workaround for my situation, not solution or customizable idea.
Maybe will help to someone for now, and later I'll try to make a contribution