fix(mac): only fuse macOS universal builds on the combined universal package (#8799)

Author: t3chguy

.changeset/eighty-swans-hang.md

@@ -0,0 +1,5 @@
+---
+"app-builder-lib": patch
+---
+
+fix(mac): only fuse macOS universal builds on the combined universal package

packages/app-builder-lib/src/macPackager.ts

@@ -10,7 +10,7 @@ import { DIR_TARGET, Platform, Target } from "./core"
 import { AfterPackContext, ElectronPlatformName } from "./index"
 import { MacConfiguration, MasConfiguration } from "./options/macOptions"
 import { Packager } from "./packager"
-import { chooseNotNull, PlatformPackager } from "./platformPackager"
+import { chooseNotNull, DoPackOptions, PlatformPackager } from "./platformPackager"
 import { ArchiveTarget } from "./targets/ArchiveTarget"
 import { PkgTarget, prepareProductBuildArgs } from "./targets/pkg"
 import { createCommonTarget, NoOpTarget } from "./targets/targetFactory"
@@ -107,32 +107,35 @@ export class MacPackager extends PlatformPackager<MacConfiguration> {
     }
   }
 
-  protected async doPack(
-    outDir: string,
-    appOutDir: string,
-    platformName: ElectronPlatformName,
-    arch: Arch,
-    platformSpecificBuildOptions: MacConfiguration,
-    targets: Array<Target>
-  ): Promise<any> {
+  protected async doPack(config: DoPackOptions<MacConfiguration>): Promise<any> {
+    const { outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets } = config
+
     switch (arch) {
       default: {
-        return super.doPack(outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets)
+        return super.doPack(config)
       }
       case Arch.universal: {
         const outDirName = (arch: Arch) => `${appOutDir}-${Arch[arch]}-temp`
+        const options = {
+          ...config,
+          options: {
+            sign: false,
+            disableAsarIntegrity: true,
+            disableFuses: true,
+          },
+        }
 
         const x64Arch = Arch.x64
         const x64AppOutDir = outDirName(x64Arch)
-        await super.doPack(outDir, x64AppOutDir, platformName, x64Arch, platformSpecificBuildOptions, targets, false, true)
+        await super.doPack({ ...options, appOutDir: x64AppOutDir, arch: x64Arch })
 
         if (this.info.cancellationToken.cancelled) {
           return
         }
 
         const arm64Arch = Arch.arm64
         const arm64AppOutPath = outDirName(arm64Arch)
-        await super.doPack(outDir, arm64AppOutPath, platformName, arm64Arch, platformSpecificBuildOptions, targets, false, true)
+        await super.doPack({ ...options, appOutDir: arm64AppOutPath, arch: arm64Arch })
 
         if (this.info.cancellationToken.cancelled) {
           return
@@ -177,6 +180,8 @@ export class MacPackager extends PlatformPackager<MacConfiguration> {
           return
         }
 
+        await this.doAddElectronFuses(packContext)
+
         await this.doSignAfterPack(outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets)
         break
       }
@@ -202,7 +207,7 @@ export class MacPackager extends PlatformPackager<MacConfiguration> {
 
       const targetOutDir = path.join(outDir, `${targetName}${getArchSuffix(arch, this.platformSpecificBuildOptions.defaultArch)}`)
       if (prepackaged == null) {
-        await this.doPack(outDir, targetOutDir, "mas", arch, masBuildOptions, [target])
+        await this.doPack({ outDir, appOutDir: targetOutDir, platformName: "mas", arch, platformSpecificBuildOptions: masBuildOptions, targets: [target] })
         await this.sign(path.join(targetOutDir, `${this.appInfo.productFilename}.app`), targetOutDir, masBuildOptions, arch)
       } else {
         await this.sign(prepackaged, targetOutDir, masBuildOptions, arch)
@@ -212,7 +217,14 @@ export class MacPackager extends PlatformPackager<MacConfiguration> {
     if (!hasMas || targets.length > 1) {
       const appPath = prepackaged == null ? path.join(this.computeAppOutDir(outDir, arch), `${this.appInfo.productFilename}.app`) : prepackaged
       if (prepackaged == null) {
-        await this.doPack(outDir, path.dirname(appPath), this.platform.nodeName as ElectronPlatformName, arch, this.platformSpecificBuildOptions, targets)
+        await this.doPack({
+          outDir,
+          appOutDir: path.dirname(appPath),
+          platformName: this.platform.nodeName as ElectronPlatformName,
+          arch,
+          platformSpecificBuildOptions: this.platformSpecificBuildOptions,
+          targets,
+        })
       }
       this.packageInDistributableFormat(appPath, arch, targets, taskManager)
     }

packages/app-builder-lib/src/platformPackager.ts

@@ -34,6 +34,20 @@ import { resolveFunction } from "./util/resolve"
 import { flipFuses, FuseConfig, FuseV1Config, FuseV1Options, FuseVersion } from "@electron/fuses"
 import { FuseOptionsV1 } from "./configuration"
 
+export type DoPackOptions<DC extends PlatformSpecificBuildOptions> = {
+  outDir: string
+  appOutDir: string
+  platformName: ElectronPlatformName
+  arch: Arch
+  platformSpecificBuildOptions: DC
+  targets: Array<Target>
+  options?: {
+    sign?: boolean
+    disableAsarIntegrity?: boolean
+    disableFuses?: boolean
+  }
+}
+
 export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions> {
   get packagerOptions(): PackagerOptions {
     return this.info.options
@@ -138,7 +152,14 @@ export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions>
 
   async pack(outDir: string, arch: Arch, targets: Array<Target>, taskManager: AsyncTaskManager): Promise<any> {
     const appOutDir = this.computeAppOutDir(outDir, arch)
-    await this.doPack(outDir, appOutDir, this.platform.nodeName as ElectronPlatformName, arch, this.platformSpecificBuildOptions, targets)
+    await this.doPack({
+      outDir,
+      appOutDir,
+      platformName: this.platform.nodeName as ElectronPlatformName,
+      arch,
+      platformSpecificBuildOptions: this.platformSpecificBuildOptions,
+      targets,
+    })
     this.packageInDistributableFormat(appOutDir, arch, targets, taskManager)
   }
 
@@ -188,16 +209,7 @@ export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions>
     }
   }
 
-  protected async doPack(
-    outDir: string,
-    appOutDir: string,
-    platformName: ElectronPlatformName,
-    arch: Arch,
-    platformSpecificBuildOptions: DC,
-    targets: Array<Target>,
-    sign = true,
-    disableAsarIntegrity = false
-  ) {
+  protected async doPack(packOptions: DoPackOptions<DC>) {
     if (this.packagerOptions.prepackaged != null) {
       return
     }
@@ -209,6 +221,8 @@ export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions>
     // Due to node-gyp rewriting GYP_MSVS_VERSION when reused across the same session, we must reset the env var: https://github.com/electron-userland/electron-builder/issues/7256
     delete process.env.GYP_MSVS_VERSION
 
+    const { outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets, options } = packOptions
+
     const beforePack = await resolveFunction(this.appInfo.type, this.config.beforePack, "beforePack")
     if (beforePack != null) {
       await beforePack({
@@ -305,7 +319,7 @@ export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions>
       await framework.beforeCopyExtraFiles({
         packager: this,
         appOutDir,
-        asarIntegrity: asarOptions == null || disableAsarIntegrity ? null : await computeData({ resourcesPath, resourcesRelativePath }),
+        asarIntegrity: asarOptions == null || options?.disableAsarIntegrity ? null : await computeData({ resourcesPath, resourcesRelativePath }),
         platformName,
       })
     }
@@ -331,16 +345,23 @@ export abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions>
     const isAsar = asarOptions != null
     await this.sanityCheckPackage(appOutDir, isAsar, framework, !!this.config.disableSanityCheckAsar)
 
-    // the fuses MUST be flipped right before signing
-    if (this.config.electronFuses != null) {
-      const fuseConfig = this.generateFuseConfig(this.config.electronFuses)
-      await this.addElectronFuses(packContext, fuseConfig)
+    if (!options?.disableFuses) {
+      await this.doAddElectronFuses(packContext)
     }
-    if (sign) {
+    if (options?.sign ?? true) {
       await this.doSignAfterPack(outDir, appOutDir, platformName, arch, platformSpecificBuildOptions, targets)
     }
   }
 
+  // the fuses MUST be flipped right before signing
+  protected async doAddElectronFuses(packContext: AfterPackContext) {
+    if (this.config.electronFuses == null) {
+      return
+    }
+    const fuseConfig = this.generateFuseConfig(this.config.electronFuses)
+    await this.addElectronFuses(packContext, fuseConfig)
+  }
+
   private generateFuseConfig(fuses: FuseOptionsV1): FuseV1Config {
     const config: FuseV1Config = {
       version: FuseVersion.V1,

test/src/helpers/CheckingPackager.ts

@@ -6,6 +6,7 @@ import { MacPackager } from "app-builder-lib/out/macPackager"
 import { DmgTarget } from "dmg-builder"
 import { WinPackager } from "app-builder-lib/out/winPackager"
 import { SignOptions as MacSignOptions } from "@electron/osx-sign/dist/cjs/types"
+import { DoPackOptions } from "app-builder-lib/out/platformPackager"
 
 export class CheckingWinPackager extends WinPackager {
   effectiveDistOptions: any
@@ -50,7 +51,7 @@ export class CheckingMacPackager extends MacPackager {
   }
 
   //noinspection JSUnusedLocalSymbols
-  async doPack(outDir: string, appOutDir: string, platformName: string, arch: Arch, customBuildOptions: MacConfiguration, targets: Array<Target>) {
+  async doPack(_options: DoPackOptions<MacConfiguration>) {
     // skip
   }