fix: fully respect singleArchFiles option (#152)

Files listed under `singleArchFiles` are allowed to be unique for
different platforms so `dupedFiles` should not return them.

Fix: #151

.github/workflows/docs.yml

@@ -14,12 +14,12 @@ jobs:
     runs-on: ubuntu-latest
     environment: docs-publish
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+      - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
         with:
           node-version-file: '.nvmrc'
       - name: Install dependencies
-        run: yarn --frozen-lockfile
+        run: yarn --immutable
       - name: Build API documentation
         run: yarn build:docs
       - name: Azure login
@@ -29,7 +29,7 @@ jobs:
           tenant-id: ${{ secrets.AZURE_OIDC_TENANT_ID }}
           subscription-id: ${{ secrets.AZURE_OIDC_SUBSCRIPTION_ID }}
       - name: Upload to Azure Blob Storage
-        uses: azure/cli@089eac9d8cc39f5d003e94f8b65efc51076c9cbd # v2.1.0
+        uses: azure/cli@9f7ce6f37c31b777ec6c6b6d1dfe7db79f497956 # v2.2.0
         with:
           inlineScript: |
             az storage blob upload-batch --account-name ${{ secrets.AZURE_ECOSYSTEM_PACKAGES_STORAGE_ACCOUNT_NAME }} -d '$web/${{ github.event.repository.name }}/${{ github.ref_name }}' -s ./docs --overwrite --auth-mode login

.github/workflows/release.yml

@@ -18,16 +18,16 @@ jobs:
       id-token: write # for CFA and npm provenance
     steps:
       - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           persist-credentials: false
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
         with:
           node-version-file: '.nvmrc'
           cache: 'yarn'
       - name: Install
-        run: yarn install --frozen-lockfile
+        run: yarn install --immutable
       - uses: continuousauth/action@4e8a2573eeb706f6d7300d6a9f3ca6322740b72d # v1.0.5
         timeout-minutes: 60
         with:

.github/workflows/semantic.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: semantic-pull-request
-        uses: amannn/action-semantic-pull-request@0723387faaf9b38adef4775cd42cfd5155ed6017 # v5.5.3
+        uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:

.github/workflows/test.yml

@@ -22,14 +22,14 @@ jobs:
     runs-on: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
         with:
           node-version: "${{ matrix.node-version }}"
           cache: 'yarn'
       - name: Install
-        run: yarn install --frozen-lockfile
+        run: yarn install --immutable
       - name: Build
         run: yarn build
       - name: Lint

.gitignore

@@ -7,3 +7,4 @@ test/fixtures/apps
 coverage
 docs
 .vscode
+.yarn/install-state.gz

.yarnrc.yml

@@ -0,0 +1,10 @@
+enableScripts: false
+
+nodeLinker: node-modules
+
+npmMinimalAgeGate: 10080
+
+npmPreapprovedPackages:
+  - "@electron/*"
+
+yarnPath: .yarn/releases/yarn-4.10.3.cjs

package.json

@@ -32,8 +32,7 @@
     "build:docs": "npx typedoc",
     "lint": "prettier --check \"{src,entry-asar,test}/**/*.ts\" \"*.ts\"",
     "prettier:write": "prettier --write \"{src,entry-asar,test}/**/*.ts\" \"*.ts\"",
-    "prepublishOnly": "npm run build",
+    "prepack": "npm run build",
-    "pretest": "npm run build",
     "test": "vitest run",
     "prepare": "husky"
   },
@@ -65,5 +64,6 @@
     "*.ts": [
       "prettier --write"
     ]
-  }
+  },
+  "packageManager": "yarn@4.10.3+sha512.c38cafb5c7bb273f3926d04e55e1d8c9dfa7d9c3ea1f36a4868fa028b9e5f72298f0b7f401ad5eb921749eb012eb1c3bb74bf7503df3ee43fd600d14a018266f"
 }

src/file-utils.ts

@@ -3,15 +3,19 @@ import path from 'node:path';
 import { promises as stream } from 'node:stream';
 
 import { spawn, ExitCodeError } from '@malept/cross-spawn-promise';
+import { minimatch } from 'minimatch';
 
 const MACHO_PREFIX = 'Mach-O ';
 
+const UNPACKED_ASAR_PATH = path.join('Contents', 'Resources', 'app.asar.unpacked');
+
 export enum AppFileType {
   MACHO,
   PLAIN,
   INFO_PLIST,
   SNAPSHOT,
   APP_CODE,
+  SINGLE_ARCH,
 }
 
 export type AppFile = {
@@ -19,11 +23,37 @@ export type AppFile = {
   type: AppFileType;
 };
 
+export type GetAllAppFilesOpts = {
+  singleArchFiles?: string;
+};
+
+const isSingleArchFile = (relativePath: string, opts: GetAllAppFilesOpts): boolean => {
+  if (opts.singleArchFiles === undefined) {
+    return false;
+  }
+
+  const unpackedPath = path.relative(UNPACKED_ASAR_PATH, relativePath);
+
+  // Outside of app.asar.unpacked
+  if (unpackedPath.startsWith('..')) {
+    return false;
+  }
+
+  return minimatch(unpackedPath, opts.singleArchFiles, {
+    matchBase: true,
+  });
+};
+
 /**
  *
  * @param appPath Path to the application
  */
-export const getAllAppFiles = async (appPath: string): Promise<AppFile[]> => {
+export const getAllAppFiles = async (
+  appPath: string,
+  opts: GetAllAppFilesOpts,
+): Promise<AppFile[]> => {
+  const unpackedPath = path.join('Contents', 'Resources', 'app.asar.unpacked');
+
   const files: AppFile[] = [];
 
   const visited = new Set<string>();
@@ -35,6 +65,8 @@ export const getAllAppFiles = async (appPath: string): Promise<AppFile[]> => {
     const info = await fs.promises.stat(p);
     if (info.isSymbolicLink()) return;
     if (info.isFile()) {
+      const relativePath = path.relative(appPath, p);
+
       let fileType = AppFileType.PLAIN;
 
       var fileOutput = '';
@@ -49,6 +81,8 @@ export const getAllAppFiles = async (appPath: string): Promise<AppFile[]> => {
       }
       if (p.endsWith('.asar')) {
         fileType = AppFileType.APP_CODE;
+      } else if (isSingleArchFile(relativePath, opts)) {
+        fileType = AppFileType.SINGLE_ARCH;
       } else if (fileOutput.startsWith(MACHO_PREFIX)) {
         fileType = AppFileType.MACHO;
       } else if (p.endsWith('.bin')) {
@@ -58,7 +92,7 @@ export const getAllAppFiles = async (appPath: string): Promise<AppFile[]> => {
       }
 
       files.push({
-        relativePath: path.relative(appPath, p),
+        relativePath,
         type: fileType,
       });
     }

src/index.ts

@@ -6,7 +6,7 @@ import * as asar from '@electron/asar';
 import { spawn } from '@malept/cross-spawn-promise';
 import * as dircompare from 'dir-compare';
 import { minimatch } from 'minimatch';
-import * as plist from 'plist';
+import plist from 'plist';
 
 import { AsarMode, detectAsarMode, isUniversalMachO, mergeASARs } from './asar-utils.js';
 import { AppFile, AppFileType, fsMove, getAllAppFiles, readMachOHeader } from './file-utils.js';
@@ -75,7 +75,12 @@ export type MakeUniversalOpts = {
 };
 
 const dupedFiles = (files: AppFile[]) =>
-  files.filter((f) => f.type !== AppFileType.SNAPSHOT && f.type !== AppFileType.APP_CODE);
+  files.filter(
+    (f) =>
+      f.type !== AppFileType.SNAPSHOT &&
+      f.type !== AppFileType.APP_CODE &&
+      f.type !== AppFileType.SINGLE_ARCH,
+  );
 
 export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> => {
   d('making a universal app with options', opts);
@@ -121,8 +126,8 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
 
     const uniqueToX64: string[] = [];
     const uniqueToArm64: string[] = [];
-    const x64Files = await getAllAppFiles(await fs.promises.realpath(tmpApp));
+    const x64Files = await getAllAppFiles(await fs.promises.realpath(tmpApp), opts);
-    const arm64Files = await getAllAppFiles(await fs.promises.realpath(opts.arm64AppPath));
+    const arm64Files = await getAllAppFiles(await fs.promises.realpath(opts.arm64AppPath), opts);
 
     for (const file of dupedFiles(x64Files)) {
       if (!arm64Files.some((f) => f.relativePath === file.relativePath))
@@ -143,7 +148,9 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
       );
     }
 
-    for (const file of x64Files.filter((f) => f.type === AppFileType.PLAIN)) {
+    // Single Arch files are copied as is without processing.
+    const multiArchFiles = x64Files.filter((f) => f.type !== AppFileType.SINGLE_ARCH);
+    for (const file of multiArchFiles.filter((f) => f.type === AppFileType.PLAIN)) {
       const x64Sha = await sha(path.resolve(opts.x64AppPath, file.relativePath));
       const arm64Sha = await sha(path.resolve(opts.arm64AppPath, file.relativePath));
       if (x64Sha !== arm64Sha) {
@@ -159,7 +166,7 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
       }
     }
     const knownMergedMachOFiles = new Set();
-    for (const machOFile of x64Files.filter((f) => f.type === AppFileType.MACHO)) {
+    for (const machOFile of multiArchFiles.filter((f) => f.type === AppFileType.MACHO)) {
       const first = await fs.promises.realpath(path.resolve(tmpApp, machOFile.relativePath));
       const second = await fs.promises.realpath(
         path.resolve(opts.arm64AppPath, machOFile.relativePath),
@@ -355,9 +362,9 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
       }
     }
 
-    const generatedIntegrity = await computeIntegrityData(path.join(tmpApp, 'Contents'));
+    const generatedIntegrity = await computeIntegrityData(path.join(tmpApp, 'Contents'), opts);
 
-    const plistFiles = x64Files.filter((f) => f.type === AppFileType.INFO_PLIST);
+    const plistFiles = multiArchFiles.filter((f) => f.type === AppFileType.INFO_PLIST);
     for (const plistFile of plistFiles) {
       const x64PlistPath = path.resolve(opts.x64AppPath, plistFile.relativePath);
       const arm64PlistPath = path.resolve(opts.arm64AppPath, plistFile.relativePath);

src/integrity.ts

@@ -17,13 +17,20 @@ export interface AsarIntegrity {
   [key: string]: HeaderHash;
 }
 
-export async function computeIntegrityData(contentsPath: string): Promise<AsarIntegrity> {
+export type ComputeIntegrityDataOpts = {
+  singleArchFiles?: string;
+};
+
+export async function computeIntegrityData(
+  contentsPath: string,
+  opts: ComputeIntegrityDataOpts,
+): Promise<AsarIntegrity> {
   const root = await fs.promises.realpath(contentsPath);
 
   const resourcesRelativePath = 'Resources';
   const resourcesPath = path.resolve(root, resourcesRelativePath);
 
-  const resources = await getAllAppFiles(resourcesPath);
+  const resources = await getAllAppFiles(resourcesPath, opts);
   const resourceAsars = resources
     .filter((file) => file.type === AppFileType.APP_CODE)
     .reduce<IntegrityMap>(

test/__snapshots__/index.spec.ts.snap

@@ -339,6 +339,86 @@ exports[`makeUniversalApp > asar mode > should merge two different asars when \`
 }
 `;
 
+exports[`makeUniversalApp > asar mode > should merge two different asars with native files when \`mergeASARs\` is enabled 1`] = `
+{
+  "files": {
+    "hello-world-arm64": "<stripped>",
+    "hello-world-x64": "<stripped>",
+    "index.js": {
+      "integrity": {
+        "algorithm": "SHA256",
+        "blockSize": 4194304,
+        "blocks": [
+          "0f6311dac07f0876c436ce2be042eb88c96e17eaf140b39627cf720dd87ad5b8",
+        ],
+        "hash": "0f6311dac07f0876c436ce2be042eb88c96e17eaf140b39627cf720dd87ad5b8",
+      },
+      "size": 66,
+    },
+    "package.json": {
+      "integrity": {
+        "algorithm": "SHA256",
+        "blockSize": 4194304,
+        "blocks": [
+          "d6226276d47adc7aa20e6c46e842e258f5157313074a035051a89612acdd6be3",
+        ],
+        "hash": "d6226276d47adc7aa20e6c46e842e258f5157313074a035051a89612acdd6be3",
+      },
+      "size": 41,
+    },
+    "private": {
+      "files": {
+        "var": {
+          "files": {
+            "app": {
+              "files": {
+                "file.txt": {
+                  "link": "private/var/file.txt",
+                },
+              },
+            },
+            "file.txt": {
+              "integrity": {
+                "algorithm": "SHA256",
+                "blockSize": 4194304,
+                "blocks": [
+                  "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+                ],
+                "hash": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+              },
+              "size": 11,
+            },
+          },
+        },
+      },
+    },
+    "var": {
+      "link": "private/var",
+    },
+  },
+}
+`;
+
+exports[`makeUniversalApp > asar mode > should merge two different asars with native files when \`mergeASARs\` is enabled 2`] = `[]`;
+
+exports[`makeUniversalApp > asar mode > should merge two different asars with native files when \`mergeASARs\` is enabled 3`] = `
+[
+  "hello-world-arm64",
+  "hello-world-x64",
+]
+`;
+
+exports[`makeUniversalApp > asar mode > should merge two different asars with native files when \`mergeASARs\` is enabled 4`] = `
+{
+  "Contents/Info.plist": {
+    "Resources/app.asar": {
+      "algorithm": "SHA256",
+      "hash": "<stripped>",
+    },
+  },
+}
+`;
+
 exports[`makeUniversalApp > asar mode > should not inject ElectronAsarIntegrity into \`infoPlistsToIgnore\` 1`] = `
 {
   "files": {

test/file-utils.spec.ts

@@ -12,8 +12,8 @@ describe('file-utils', () => {
     let noAsarFiles: AppFile[];
 
     beforeAll(async () => {
-      asarFiles = await getAllAppFiles(path.resolve(appsPath, 'Arm64Asar.app'));
+      asarFiles = await getAllAppFiles(path.resolve(appsPath, 'Arm64Asar.app'), {});
-      noAsarFiles = await getAllAppFiles(path.resolve(appsPath, 'Arm64NoAsar.app'));
+      noAsarFiles = await getAllAppFiles(path.resolve(appsPath, 'Arm64NoAsar.app'), {});
     });
 
     it('should correctly identify plist files', async () => {

test/index.spec.ts

@@ -142,6 +142,65 @@ describe('makeUniversalApp', () => {
       },
     );
 
+    it(
+      'should merge two different asars with native files when `mergeASARs` is enabled',
+      { timeout: VERIFY_APP_TIMEOUT },
+      async () => {
+        const x64AppPath = await generateNativeApp({
+          appNameWithExtension: 'SingleArchFiles-x64.app',
+          arch: 'x64',
+          createAsar: true,
+          singleArchBindings: true,
+        });
+        const arm64AppPath = await generateNativeApp({
+          appNameWithExtension: 'SingleArchFiles-arm64.app',
+          arch: 'arm64',
+          createAsar: true,
+          singleArchBindings: true,
+        });
+        const out = path.resolve(appsOutPath, 'SingleArchFiles.app');
+        await makeUniversalApp({
+          x64AppPath,
+          arm64AppPath,
+          outAppPath: out,
+          mergeASARs: true,
+          singleArchFiles: 'hello-world-*',
+        });
+        await verifyApp(out, true);
+      },
+    );
+
+    it(
+      'throws an error if `mergeASARs` is enabled and `singleArchFiles` is missing a unique native file',
+      { timeout: VERIFY_APP_TIMEOUT },
+      async () => {
+        const x64AppPath = await generateNativeApp({
+          appNameWithExtension: 'SingleArchFiles-2-x64.app',
+          arch: 'x64',
+          createAsar: true,
+          singleArchBindings: true,
+        });
+        const arm64AppPath = await generateNativeApp({
+          appNameWithExtension: 'SingleArchFiles-2-arm64.app',
+          arch: 'arm64',
+          createAsar: true,
+          singleArchBindings: true,
+        });
+        const out = path.resolve(appsOutPath, 'SingleArchFiles-2.app');
+        await expect(
+          makeUniversalApp({
+            x64AppPath,
+            arm64AppPath,
+            outAppPath: out,
+            mergeASARs: true,
+            singleArchFiles: 'bad-rule',
+          }),
+        ).rejects.toThrow(
+          /the number of mach-o files is not the same between the arm64 and x64 builds/,
+        );
+      },
+    );
+
     it(
       'should not inject ElectronAsarIntegrity into `infoPlistsToIgnore`',
       { timeout: VERIFY_APP_TIMEOUT },

test/util.ts

@@ -33,7 +33,12 @@ export const verifyApp = async (appPath: string, containsRuntimeGeneratedMacho =
     // verify header
     const asarFs = getRawHeader(path.resolve(resourcesDir, asar));
     expect(
-      removeUnstableProperties(asarFs.header, containsRuntimeGeneratedMacho ? ['hello-world'] : []),
+      removeUnstableProperties(
+        asarFs.header,
+        containsRuntimeGeneratedMacho
+          ? ['hello-world', 'hello-world-arm64', 'hello-world-x64']
+          : [],
+      ),
     ).toMatchSnapshot();
   }
 
@@ -53,7 +58,7 @@ export const verifyApp = async (appPath: string, containsRuntimeGeneratedMacho =
     await verifyFileTree(path.resolve(resourcesDir, dir));
   }
 
-  const allFiles = await fileUtils.getAllAppFiles(appPath);
+  const allFiles = await fileUtils.getAllAppFiles(appPath, {});
   const infoPlists = allFiles
     .filter(
       (appFile) =>
@@ -89,7 +94,7 @@ const extractAsarIntegrity = async (infoPlist: string) => {
 export const verifyFileTree = async (dirPath: string) => {
   const { expect } = await import('vitest');
 
-  const dirFiles = await fileUtils.getAllAppFiles(dirPath);
+  const dirFiles = await fileUtils.getAllAppFiles(dirPath, {});
   const files = dirFiles.map((file) => {
     const it = path.join(dirPath, file.relativePath);
     const name = toSystemIndependentPath(file.relativePath);
@@ -229,6 +234,7 @@ export const generateNativeApp = async (options: {
   createAsar: boolean;
   nativeModuleArch?: string;
   additionalFiles?: Record<string, string>;
+  singleArchBindings?: boolean;
 }) => {
   const {
     appNameWithExtension,
@@ -236,6 +242,7 @@ export const generateNativeApp = async (options: {
     createAsar,
     nativeModuleArch = arch,
     additionalFiles,
+    singleArchBindings,
   } = options;
   const appPath = await templateApp(appNameWithExtension, arch, async (appPath) => {
     const resources = path.join(appPath, 'Contents', 'Resources');
@@ -247,14 +254,19 @@ export const generateNativeApp = async (options: {
       path.basename(appNameWithExtension, '.app'),
       additionalFiles,
     );
-    await fs.promises.cp(
+    let targetBinding: string;
-      path.join(appsDir, `hello-world-${nativeModuleArch}`),
+    if (singleArchBindings) {
-      path.join(testPath, 'hello-world'),
+      targetBinding = path.join(testPath, `hello-world-${nativeModuleArch}`);
-      { recursive: true, verbatimSymlinks: true },
+    } else {
-    );
+      targetBinding = path.join(testPath, 'hello-world');
+    }
+    await fs.promises.cp(path.join(appsDir, `hello-world-${nativeModuleArch}`), targetBinding, {
+      recursive: true,
+      verbatimSymlinks: true,
+    });
     if (createAsar) {
       await createPackageWithOptions(testPath, path.resolve(resources, 'app.asar'), {
-        unpack: '**/hello-world',
+        unpack: '**/hello-world*',
       });
     } else {
       await fs.promises.cp(testPath, resourcesApp, { recursive: true, verbatimSymlinks: true });