feat: bump minimum node version to 16 and add tests (#86)

BREAKING CHANGE: Minimum node version is now 16

.circleci/config.yml

@@ -1,8 +1,8 @@
 version: 2.1
 
 orbs:
-  cfa: continuousauth/npm@1.0.2
-  node: electronjs/node@1.4.1
+  cfa: continuousauth/npm@2.0.0
+  node: electronjs/node@2.1.0
 
 workflows:
   test_and_release:
@@ -13,6 +13,7 @@ workflows:
           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
@@ -24,9 +25,6 @@ workflows:
                 - 20.5.0
                 - 18.17.0
                 - 16.20.1
-                - 14.21.3
-                - 12.22.12
-                - 10.24.1
       - cfa/release:
           requires:
             - test

.gitignore

@@ -1,3 +1,7 @@
 node_modules
 dist
-*.app
+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.ts

@@ -1,5 +1,5 @@
-const { app } = require('electron');
-const path = require('path');
+import { app } from 'electron';
+import path from 'path';
 
 if (process.arch === 'arm64') {
   setPaths('arm64');
@@ -7,7 +7,7 @@ if (process.arch === 'arm64') {
   setPaths('x64');
 }
 
-function setPaths(platform) {
+function setPaths(platform: string) {
   // This should return the full path, ending in something like
   // Notion.app/Contents/Resources/app.asar
   const appPath = app.getAppPath();

entry-asar/no-asar.ts

@@ -1,10 +1,13 @@
+import { app } from 'electron';
+import path from 'path';
+
 if (process.arch === 'arm64') {
   setPaths('arm64');
 } else {
   setPaths('x64');
 }
 
-function setPaths(platform) {
+function setPaths(platform: string) {
   // This should return the full path, ending in something like
   // Notion.app/Contents/Resources/app
   const appPath = app.getAppPath();

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,46 +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,entry-asar}/**/*.{js,ts}\"",
-    "prettier:write": "prettier --write \"{src,entry-asar}/**/*.{js,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,
+  0xcafebabe, 0xbebafeca,
 ]);
 
 export const detectAsarMode = async (appPath: string) => {

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.
    */

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"
   ]
 }