chore: fix lint

* Ignore differences caused by merged machO files

* Fix filter indent

* Fix types & Fix error caught by type check

.circleci/config.yml

@@ -1,35 +1,30 @@
-steps-test: &steps-test
-  steps:
-    - checkout
-    - restore_cache:
-        keys:
-          - v1-dependencies-{{ arch }}-{{ checksum "yarn.lock" }}
-          - v1-dependencies-{{ arch }}
-    - run: yarn --frozen-lockfile
-    - save_cache:
-        paths:
-          - node_modules
-        key: v1-dependencies-{{ arch }}-{{ checksum "yarn.lock" }}
-    - run: yarn build
-    - run: yarn test
-
 version: 2.1
 
 orbs:
-  cfa: continuousauth/npm@1.0.2
-
-jobs:
-  test:
-    macos:
-      xcode: "13.4.1"
-    resource_class: macos.x86.medium.gen2
-    <<: *steps-test
+  cfa: continuousauth/npm@2.0.0
+  node: electronjs/node@2.1.0
 
 workflows:
-  version: 2
   test_and_release:
+    # Run the test jobs first, then the release only when all the test jobs are successful
     jobs:
-      - test
+      - node/test:
+          executor: node/macos
+          name: test-mac-<< matrix.node-version >>
+          override-ci-command: yarn install --frozen-lockfile --ignore-engines
+          test-steps:
+            - node/install-rosetta
+            - run: yarn build
+            - run: yarn lint
+            - run: yarn test
+          use-test-steps: true
+          matrix:
+            alias: test
+            parameters:
+              node-version:
+                - 20.5.0
+                - 18.17.0
+                - 16.20.1
       - cfa/release:
           requires:
             - test
@@ -38,4 +33,3 @@ workflows:
               only:
                 - main
           context: cfa-release
-

.github/workflows/add-to-project.yml

@@ -0,0 +1,29 @@
+name: Add to Ecosystem WG Project
+
+on:
+  issues:
+    types:
+      - opened
+  pull_request_target:
+    types:
+      - opened
+
+permissions: {}
+
+jobs:
+  add-to-project:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Generate GitHub App token
+        uses: electron/github-app-auth-action@384fd19694fe7b6dcc9a684746c6976ad78228ae # v1.1.1
+        id: generate-token
+        with:
+          creds: ${{ secrets.ECOSYSTEM_ISSUE_TRIAGE_GH_APP_CREDS }}
+          org: electron
+      - name: Add to Project
+        uses: dsanders11/project-actions/add-item@3a81985616963f32fae17d1d1b406c631f3201a1 # v1.1.0
+        with:
+          field: Opened
+          field-value: ${{ github.event.pull_request.created_at || github.event.issue.created_at }}
+          project-number: 89
+          token: ${{ steps.generate-token.outputs.token }}

.gitignore

@@ -1,3 +1,7 @@
 node_modules
 dist
+entry-asar/*.js*
+entry-asar/*.ts
 *.app
+test/fixtures/apps
+coverage

entry-asar/ambient.d.ts

@@ -0,0 +1,19 @@
+declare namespace NodeJS {
+  interface Process extends EventEmitter {
+    // This is an undocumented private API. It exists.
+    _archPath: string;
+  }
+}
+
+declare module 'electron' {
+  const app: Electron.App;
+
+  namespace Electron {
+    interface App {
+      getAppPath: () => string;
+      setAppPath: (p: string) => void;
+    }
+  }
+
+  export { app };
+}

entry-asar/has-asar.js

@@ -1,7 +0,0 @@
-if (process.arch === 'arm64') {
-  process._archPath = require.resolve('../app-arm64.asar');
-} else {
-  process._archPath = require.resolve('../app-x64.asar');
-}
-
-require(process._archPath);

entry-asar/has-asar.ts

@@ -0,0 +1,27 @@
+import { app } from 'electron';
+import path from 'path';
+
+if (process.arch === 'arm64') {
+  setPaths('arm64');
+} else {
+  setPaths('x64');
+}
+
+function setPaths(platform: string) {
+  // This should return the full path, ending in something like
+  // Notion.app/Contents/Resources/app.asar
+  const appPath = app.getAppPath();
+  const asarFile = `app-${platform}.asar`;
+
+  // Maybe we'll handle this in Electron one day
+  if (path.basename(appPath) === 'app.asar') {
+    const platformAppPath = path.join(path.dirname(appPath), asarFile);
+
+    // This is an undocumented API. It exists.
+    app.setAppPath(platformAppPath);
+  }
+
+  process._archPath = require.resolve(`../${asarFile}`);
+}
+
+require(process._archPath);

entry-asar/no-asar.js

@@ -1,7 +0,0 @@
-if (process.arch === 'arm64') {
-  process._archPath = require.resolve('../app-arm64');
-} else {
-  process._archPath = require.resolve('../app-x64');
-}
-
-require(process._archPath);

entry-asar/no-asar.ts

@@ -0,0 +1,27 @@
+import { app } from 'electron';
+import path from 'path';
+
+if (process.arch === 'arm64') {
+  setPaths('arm64');
+} else {
+  setPaths('x64');
+}
+
+function setPaths(platform: string) {
+  // This should return the full path, ending in something like
+  // Notion.app/Contents/Resources/app
+  const appPath = app.getAppPath();
+  const appFolder = `app-${platform}`;
+
+  // Maybe we'll handle this in Electron one day
+  if (path.basename(appPath) === 'app') {
+    const platformAppPath = path.join(path.dirname(appPath), appFolder);
+
+    // This is an undocumented private API. It exists.
+    app.setAppPath(platformAppPath);
+  }
+
+  process._archPath = require.resolve(`../${appFolder}`);
+}
+
+require(process._archPath);

jest.config.js

@@ -0,0 +1,14 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '.': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.jest.json'
+      }
+    ]
+  },
+  globalSetup: './jest.setup.ts'
+};

jest.setup.ts

@@ -0,0 +1,57 @@
+import { downloadArtifact } from '@electron/get';
+import * as zip from 'cross-zip';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+const asarsDir = path.resolve(__dirname, 'test', 'fixtures', 'asars');
+const appsDir = path.resolve(__dirname, 'test', 'fixtures', 'apps');
+
+const templateApp = async (
+  name: string,
+  arch: string,
+  modify: (appPath: string) => Promise<void>,
+) => {
+  const electronZip = await downloadArtifact({
+    artifactName: 'electron',
+    version: '27.0.0',
+    platform: 'darwin',
+    arch,
+  });
+  const appPath = path.resolve(appsDir, name);
+  zip.unzipSync(electronZip, appsDir);
+  await fs.rename(path.resolve(appsDir, 'Electron.app'), appPath);
+  await fs.remove(path.resolve(appPath, 'Contents', 'Resources', 'default_app.asar'));
+  await modify(appPath);
+};
+
+export default async () => {
+  await fs.remove(appsDir);
+  await fs.mkdirp(appsDir);
+  await templateApp('Asar.app', 'arm64', async (appPath) => {
+    await fs.copy(
+      path.resolve(asarsDir, 'app.asar'),
+      path.resolve(appPath, 'Contents', 'Resources', 'app.asar'),
+    );
+  });
+
+  await templateApp('X64Asar.app', 'x64', async (appPath) => {
+    await fs.copy(
+      path.resolve(asarsDir, 'app.asar'),
+      path.resolve(appPath, 'Contents', 'Resources', 'app.asar'),
+    );
+  });
+
+  await templateApp('NoAsar.app', 'arm64', async (appPath) => {
+    await fs.copy(
+      path.resolve(asarsDir, 'app'),
+      path.resolve(appPath, 'Contents', 'Resources', 'app'),
+    );
+  });
+
+  await templateApp('X64NoAsar.app', 'x64', async (appPath) => {
+    await fs.copy(
+      path.resolve(asarsDir, 'app'),
+      path.resolve(appPath, 'Contents', 'Resources', 'app'),
+    );
+  });
+};

package.json

@@ -15,45 +15,56 @@
     "url": "https://github.com/electron/universal.git"
   },
   "engines": {
-    "node": ">=8.6"
+    "node": ">=16.4"
   },
   "files": [
     "dist/*",
     "entry-asar/*",
+    "!entry-asar/**/*.ts",
     "README.md"
   ],
   "author": "Samuel Attard",
   "scripts": {
-    "build": "tsc && tsc -p tsconfig.esm.json",
-    "lint": "prettier --check \"src/**/*.ts\"",
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json && tsc -p tsconfig.entry-asar.json",
+    "lint": "prettier --check \"{src,entry-asar,test}/**/*.ts\" \"*.ts\"",
+    "prettier:write": "prettier --write \"{src,entry-asar,test}/**/*.ts\" \"*.ts\"",
     "prepublishOnly": "npm run build",
-    "test": "exit 0",
+    "test": "jest",
     "prepare": "husky install"
   },
   "devDependencies": {
-    "@continuous-auth/semantic-release-npm": "^3.0.0",
-    "@types/debug": "^4.1.5",
-    "@types/fs-extra": "^9.0.4",
-    "@types/minimatch": "^3.0.5",
-    "@types/node": "^14.14.7",
-    "@types/plist": "^3.0.2",
-    "husky": "^8.0.0",
-    "lint-staged": "^10.5.1",
-    "prettier": "^2.1.2",
-    "typescript": "^4.0.5"
+    "@continuous-auth/semantic-release-npm": "^4.0.0",
+    "@electron/get": "^3.0.0",
+    "@types/cross-zip": "^4.0.1",
+    "@types/debug": "^4.1.10",
+    "@types/fs-extra": "^11.0.3",
+    "@types/jest": "^29.5.7",
+    "@types/minimatch": "^5.1.2",
+    "@types/node": "^20.8.10",
+    "@types/plist": "^3.0.4",
+    "cross-zip": "^4.0.0",
+    "husky": "^8.0.3",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.0.2",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@electron/asar": "^3.2.1",
-    "@malept/cross-spawn-promise": "^1.1.0",
+    "@electron/asar": "^3.2.7",
+    "@malept/cross-spawn-promise": "^2.0.0",
     "debug": "^4.3.1",
-    "dir-compare": "^3.0.0",
-    "fs-extra": "^9.0.1",
-    "minimatch": "^3.0.4",
-    "plist": "^3.0.4"
+    "dir-compare": "^4.2.0",
+    "fs-extra": "^11.1.1",
+    "minimatch": "^9.0.3",
+    "plist": "^3.1.0"
   },
   "lint-staged": {
     "*.ts": [
       "prettier --write"
     ]
+  },
+  "resolutions": {
+    "jackspeak": "2.1.1"
   }
 }

src/asar-utils.ts

@@ -1,10 +1,10 @@
-import * as asar from '@electron/asar';
+import asar from '@electron/asar';
 import { execFileSync } from 'child_process';
-import * as crypto from 'crypto';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as minimatch from 'minimatch';
-import * as os from 'os';
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import path from 'path';
+import { minimatch } from 'minimatch';
+import os from 'os';
 import { d } from './debug';
 
 const LIPO = 'lipo';
@@ -25,18 +25,15 @@ export type MergeASARsOptions = {
 // See: https://github.com/apple-opensource-mirror/llvmCore/blob/0c60489d96c87140db9a6a14c6e82b15f5e5d252/include/llvm/Object/MachOFormat.h#L108-L112
 const MACHO_MAGIC = new Set([
   // 32-bit Mach-O
-  0xfeedface,
-  0xcefaedfe,
+  0xfeedface, 0xcefaedfe,
 
   // 64-bit Mach-O
-  0xfeedfacf,
-  0xcffaedfe,
+  0xfeedfacf, 0xcffaedfe,
 ]);
 
 const MACHO_UNIVERSAL_MAGIC = new Set([
-    // universal
-    0xcafebabe,
-    0xbebafeca,
+  // universal
+  0xcafebabe, 0xbebafeca,
 ]);
 
 export const detectAsarMode = async (appPath: string) => {
@@ -153,7 +150,10 @@ export const mergeASARs = async ({
       continue;
     }
 
-    if (MACHO_UNIVERSAL_MAGIC.has(x64Content.readUInt32LE(0)) && MACHO_UNIVERSAL_MAGIC.has(arm64Content.readUInt32LE(0))) {
+    if (
+      MACHO_UNIVERSAL_MAGIC.has(x64Content.readUInt32LE(0)) &&
+      MACHO_UNIVERSAL_MAGIC.has(arm64Content.readUInt32LE(0))
+    ) {
       continue;
     }
 

src/debug.ts

@@ -1,3 +1,3 @@
-import * as debug from 'debug';
+import debug from 'debug';
 
 export const d = debug('electron-universal');

src/index.ts

@@ -1,8 +1,7 @@
 import { spawn } from '@malept/cross-spawn-promise';
 import * as asar from '@electron/asar';
-import * as crypto from 'crypto';
 import * as fs from 'fs-extra';
-import * as minimatch from 'minimatch';
+import { minimatch } from 'minimatch';
 import * as os from 'os';
 import * as path from 'path';
 import * as plist from 'plist';
@@ -31,7 +30,7 @@ export type MakeUniversalOpts = {
   /**
    * Forcefully overwrite any existing files that are in the way of generating the universal application
    */
-  force: boolean;
+  force?: boolean;
   /**
    * Merge x64 and arm64 ASARs into one.
    */
@@ -134,7 +133,7 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
         );
       }
     }
-
+    const knownMergedMachOFiles = new Set();
     for (const machOFile of x64Files.filter((f) => f.type === AppFileType.MACHO)) {
       const first = await fs.realpath(path.resolve(tmpApp, machOFile.relativePath));
       const second = await fs.realpath(path.resolve(opts.arm64AppPath, machOFile.relativePath));
@@ -171,6 +170,7 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
         '-output',
         await fs.realpath(path.resolve(tmpApp, machOFile.relativePath)),
       ]);
+      knownMergedMachOFiles.add(machOFile.relativePath);
     }
 
     /**
@@ -186,8 +186,18 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise<void> =
         path.resolve(opts.arm64AppPath, 'Contents', 'Resources', 'app'),
         { compareSize: true, compareContent: true },
       );
+      const differences = comparison.diffSet!.filter((difference) => difference.state !== 'equal');
+      d(`Found ${differences.length} difference(s) between the x64 and arm64 folders`);
+      const nonMergedDifferences = differences.filter(
+        (difference) =>
+          !difference.name1 ||
+          !knownMergedMachOFiles.has(
+            path.join('Contents', 'Resources', 'app', difference.relativePath, difference.name1),
+          ),
+      );
+      d(`After discluding MachO files merged with lipo ${nonMergedDifferences.length} remain.`);
 
-      if (!comparison.same) {
+      if (nonMergedDifferences.length > 0) {
         d('x64 and arm64 app folders are different, creating dynamic entry ASAR');
         await fs.move(
           path.resolve(tmpApp, 'Contents', 'Resources', 'app'),

src/sha.ts

@@ -1,16 +1,13 @@
 import * as fs from 'fs-extra';
 import * as crypto from 'crypto';
+import { pipeline } from 'stream/promises';
+
 import { d } from './debug';
 
 export const sha = async (filePath: string) => {
   d('hashing', filePath);
   const hash = crypto.createHash('sha256');
   hash.setEncoding('hex');
-  const fileStream = fs.createReadStream(filePath);
-  fileStream.pipe(hash);
-  await new Promise((resolve, reject) => {
-    fileStream.on('end', () => resolve());
-    fileStream.on('error', (err) => reject(err));
-  });
+  await pipeline(fs.createReadStream(filePath), hash);
   return hash.read();
 };

test/asar-utils.spec.ts

@@ -0,0 +1,26 @@
+import * as path from 'path';
+
+import { AsarMode, detectAsarMode, generateAsarIntegrity } from '../src/asar-utils';
+
+const asarsPath = path.resolve(__dirname, 'fixtures', 'asars');
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+describe('asar-utils', () => {
+  describe('detectAsarMode', () => {
+    it('should correctly detect an asar enabled app', async () => {
+      expect(await detectAsarMode(path.resolve(appsPath, 'Asar.app'))).toBe(AsarMode.HAS_ASAR);
+    });
+
+    it('should correctly detect an app without an asar', async () => {
+      expect(await detectAsarMode(path.resolve(appsPath, 'NoAsar.app'))).toBe(AsarMode.NO_ASAR);
+    });
+  });
+
+  describe('generateAsarIntegrity', () => {
+    it('should deterministically hash an asar header', async () => {
+      expect(generateAsarIntegrity(path.resolve(asarsPath, 'app.asar')).hash).toEqual(
+        '85fff474383bd8df11cd9c5784e8fcd1525af71ff140a8a882e1dc9d5b39fcbf',
+      );
+    });
+  });
+});

test/file-utils.spec.ts

@@ -0,0 +1,61 @@
+import * as path from 'path';
+
+import { AppFile, AppFileType, getAllAppFiles } from '../src/file-utils';
+
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+describe('file-utils', () => {
+  describe('getAllAppFiles', () => {
+    let asarFiles: AppFile[];
+    let noAsarFiles: AppFile[];
+
+    beforeAll(async () => {
+      asarFiles = await getAllAppFiles(path.resolve(appsPath, 'Asar.app'));
+      noAsarFiles = await getAllAppFiles(path.resolve(appsPath, 'NoAsar.app'));
+    });
+
+    it('should correctly identify plist files', async () => {
+      expect(asarFiles.find((f) => f.relativePath === 'Contents/Info.plist')?.type).toBe(
+        AppFileType.INFO_PLIST,
+      );
+    });
+
+    it('should correctly identify asar files as app code', async () => {
+      expect(asarFiles.find((f) => f.relativePath === 'Contents/Resources/app.asar')?.type).toBe(
+        AppFileType.APP_CODE,
+      );
+    });
+
+    it('should correctly identify non-asar code files as plain text', async () => {
+      expect(
+        noAsarFiles.find((f) => f.relativePath === 'Contents/Resources/app/index.js')?.type,
+      ).toBe(AppFileType.PLAIN);
+    });
+
+    it('should correctly identify the Electron binary as Mach-O', async () => {
+      expect(noAsarFiles.find((f) => f.relativePath === 'Contents/MacOS/Electron')?.type).toBe(
+        AppFileType.MACHO,
+      );
+    });
+
+    it('should correctly identify the Electron Framework as Mach-O', async () => {
+      expect(
+        noAsarFiles.find(
+          (f) =>
+            f.relativePath ===
+            'Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework',
+        )?.type,
+      ).toBe(AppFileType.MACHO);
+    });
+
+    it('should correctly identify the v8 context snapshot', async () => {
+      expect(
+        noAsarFiles.find(
+          (f) =>
+            f.relativePath ===
+            'Contents/Frameworks/Electron Framework.framework/Versions/A/Resources/v8_context_snapshot.arm64.bin',
+        )?.type,
+      ).toBe(AppFileType.SNAPSHOT);
+    });
+  });
+});

test/fixtures/asars/app/index.js

@@ -0,0 +1,2 @@
+console.log('I am an app folder', process.arch);
+process.exit(0);

test/fixtures/asars/app/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "app",
+  "main": "index.js"
+}

test/fixtures/tohash

@@ -0,0 +1 @@
+hello there

test/index.spec.ts

@@ -0,0 +1,40 @@
+import { spawn } from '@malept/cross-spawn-promise';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+
+import { makeUniversalApp } from '../src/index';
+
+const appsPath = path.resolve(__dirname, 'fixtures', 'apps');
+
+async function ensureUniversal(app: string) {
+  const exe = path.resolve(app, 'Contents', 'MacOS', 'Electron');
+  const result = await spawn(exe);
+  expect(result).toContain('arm64');
+  const result2 = await spawn('arch', ['-x86_64', exe]);
+  expect(result2).toContain('x64');
+}
+
+describe('makeUniversalApp', () => {
+  it('should correctly merge two identical asars', async () => {
+    const out = path.resolve(appsPath, 'MergedAsar.app');
+    await makeUniversalApp({
+      x64AppPath: path.resolve(appsPath, 'X64Asar.app'),
+      arm64AppPath: path.resolve(appsPath, 'Asar.app'),
+      outAppPath: out,
+    });
+    await ensureUniversal(out);
+    // Only a single asar as they were identical
+    expect(
+      (await fs.readdir(path.resolve(out, 'Contents', 'Resources'))).filter((p) =>
+        p.endsWith('asar'),
+      ),
+    ).toEqual(['app.asar']);
+  }, 60000);
+
+  // TODO: Add tests for
+  // * different asar files
+  // * identical app dirs
+  // * different app dirs
+  // * different app dirs with different macho files
+  // * identical app dirs with universal macho files
+});

test/sha.spec.ts

@@ -0,0 +1,11 @@
+import * as path from 'path';
+
+import { sha } from '../src/sha';
+
+describe('sha', () => {
+  it('should correctly hash a file', async () => {
+    expect(await sha(path.resolve(__dirname, 'fixtures', 'tohash'))).toEqual(
+      '12998c017066eb0d2a70b94e6ed3192985855ce390f321bbdb832022888bd251',
+    );
+  });
+});

tsconfig.cjs.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"]
+}

tsconfig.entry-asar.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "entry-asar",
+  },
+  "include": [
+    "entry-asar"
+  ],
+  "exclude": []
+}

tsconfig.esm.json

@@ -3,5 +3,6 @@
   "compilerOptions": {
     "module": "esnext",
     "outDir": "dist/esm"
-  }
+  },
+  "include": ["src"]
 }

tsconfig.jest.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "outDir": "dist/esm",
+    "types": [
+      "jest"
+    ]
+  },
+  "include": ["src"]
+}

tsconfig.json

@@ -13,9 +13,11 @@
     ],
     "allowSyntheticDefaultImports": true,
     "moduleResolution": "node",
+    "esModuleInterop": true,
     "declaration": true
   },
   "include": [
-    "src"
+    "src",
+    "entry-asar"
   ]
 }