diff --git a/jest.setup.ts b/jest.setup.ts index 296a148..ac10156 100644 --- a/jest.setup.ts +++ b/jest.setup.ts @@ -1,10 +1,34 @@ +import { execFileSync } from 'child_process'; import * as fs from 'fs-extra'; import * as path from 'path'; -import { appsDir, asarsDir, templateApp } from './test/util'; +import { appsDir, asarsDir, fixtureDir, templateApp } from './test/util'; + +// generates binaries from hello-world.c +// hello-world-universal, hello-world-x86_64, hello-world-arm64 +const generateMachO = () => { + const src = path.resolve(fixtureDir, 'hello-world.c'); + + const outputFiles = ['x86_64', 'arm64'].map((arch) => { + const machO = path.resolve(appsDir, `hello-world-${arch === 'x86_64' ? 'x64' : arch}`); + execFileSync('clang', ['-arch', arch, '-o', machO, src]); + return machO; + }); + + execFileSync('lipo', [ + ...outputFiles, + '-create', + '-output', + path.resolve(appsDir, 'hello-world-universal'), + ]); +}; export default async () => { await fs.remove(appsDir); await fs.mkdirp(appsDir); + + // generate mach-o binaries to be leveraged in lipo tests + generateMachO(); + await templateApp('Arm64Asar.app', 'arm64', async (appPath) => { await fs.copy( path.resolve(asarsDir, 'app.asar'), diff --git a/src/asar-utils.ts b/src/asar-utils.ts index dcadf8a..eee1ff6 100644 --- a/src/asar-utils.ts +++ b/src/asar-utils.ts @@ -148,14 +148,13 @@ export const mergeASARs = async ({ const x64Content = asar.extractFile(x64AsarPath, file); const arm64Content = asar.extractFile(arm64AsarPath, file); + // Skip file if the same content if (x64Content.compare(arm64Content) === 0) { continue; } - if ( - MACHO_UNIVERSAL_MAGIC.has(x64Content.readUInt32LE(0)) && - MACHO_UNIVERSAL_MAGIC.has(arm64Content.readUInt32LE(0)) - ) { + // Skip universal Mach-O files. + if (isUniversalMachO(x64Content)) { continue; } @@ -223,3 +222,7 @@ export const mergeASARs = async ({ await Promise.all([fs.remove(x64Dir), fs.remove(arm64Dir)]); } }; + +export const isUniversalMachO = (fileContent: Buffer) => { + return MACHO_UNIVERSAL_MAGIC.has(fileContent.readUInt32LE(0)); +}; diff --git a/src/file-utils.ts b/src/file-utils.ts index 08dc1e3..dd3a6c7 100644 --- a/src/file-utils.ts +++ b/src/file-utils.ts @@ -1,6 +1,7 @@ import { spawn, ExitCodeError } from '@malept/cross-spawn-promise'; import * as fs from 'fs-extra'; import * as path from 'path'; +import { promises as stream } from 'node:stream'; const MACHO_PREFIX = 'Mach-O '; @@ -71,3 +72,14 @@ export const getAllAppFiles = async (appPath: string): Promise => { return files; }; + +export const readMachOHeader = async (path: string) => { + const chunks: Buffer[] = []; + // no need to read the entire file, we only need the first 4 bytes of the file to determine the header + await stream.pipeline(fs.createReadStream(path, { start: 0, end: 3 }), async function* (source) { + for await (const chunk of source) { + chunks.push(chunk); + } + }); + return Buffer.concat(chunks); +}; diff --git a/src/index.ts b/src/index.ts index 5a1105e..e63146d 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,14 +1,14 @@ -import { spawn } from '@malept/cross-spawn-promise'; import * as asar from '@electron/asar'; +import { spawn } from '@malept/cross-spawn-promise'; +import * as dircompare from 'dir-compare'; import * as fs from 'fs-extra'; import { minimatch } from 'minimatch'; import * as os from 'os'; import * as path from 'path'; import * as plist from 'plist'; -import * as dircompare from 'dir-compare'; -import { AppFile, AppFileType, getAllAppFiles } from './file-utils'; -import { AsarMode, detectAsarMode, mergeASARs } from './asar-utils'; +import { AsarMode, detectAsarMode, isUniversalMachO, mergeASARs } from './asar-utils'; +import { AppFile, AppFileType, getAllAppFiles, readMachOHeader } from './file-utils'; import { sha } from './sha'; import { d } from './debug'; import { computeIntegrityData } from './integrity'; @@ -162,6 +162,15 @@ export const makeUniversalApp = async (opts: MakeUniversalOpts): Promise = const first = await fs.realpath(path.resolve(tmpApp, machOFile.relativePath)); const second = await fs.realpath(path.resolve(opts.arm64AppPath, machOFile.relativePath)); + if ( + isUniversalMachO(await readMachOHeader(first)) && + isUniversalMachO(await readMachOHeader(second)) + ) { + d(machOFile.relativePath, `is already universal across builds, skipping lipo`); + knownMergedMachOFiles.add(machOFile.relativePath); + continue; + } + const x64Sha = await sha(path.resolve(opts.x64AppPath, machOFile.relativePath)); const arm64Sha = await sha(path.resolve(opts.arm64AppPath, machOFile.relativePath)); if (x64Sha === arm64Sha) { diff --git a/test/__snapshots__/index.spec.ts.snap b/test/__snapshots__/index.spec.ts.snap index 02b96f1..be1ee68 100644 --- a/test/__snapshots__/index.spec.ts.snap +++ b/test/__snapshots__/index.spec.ts.snap @@ -620,6 +620,222 @@ exports[`makeUniversalApp force packages successfully if \`out\` bundle already } `; +exports[`makeUniversalApp no asar mode different app dirs with different macho files (shim and lipo) 1`] = ` +{ + "files": { + "index.js": { + "integrity": { + "algorithm": "SHA256", + "blockSize": 4194304, + "blocks": [ + "f1e14240f7c833900fca84fabc2f0ff27084efdf1c5b228b015515de3f8fa28e", + ], + "hash": "f1e14240f7c833900fca84fabc2f0ff27084efdf1c5b228b015515de3f8fa28e", + }, + "size": 1063, + }, + "package.json": { + "integrity": { + "algorithm": "SHA256", + "blockSize": 4194304, + "blocks": [ + "2873266521e41d58d02e7acfbbbdb046edfa04b6ce262b8987de8e8548671fc7", + ], + "hash": "2873266521e41d58d02e7acfbbbdb046edfa04b6ce262b8987de8e8548671fc7", + }, + "size": 33, + }, + }, +} +`; + +exports[`makeUniversalApp no asar mode different app dirs with different macho files (shim and lipo) 2`] = ` +[ + "private/var/i-aint-got-no-rhythm.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with different macho files (shim and lipo) 3`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, + "private/var/i-aint-got-no-rhythm.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with different macho files (shim and lipo) 4`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, + "private/var/hello-world.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with different macho files (shim and lipo) 5`] = ` +{ + "Contents/Info.plist": { + "Resources/app.asar": { + "algorithm": "SHA256", + "hash": "27433ee3e34b3b0dabb29d18d40646126e80c56dbce8c4bb2adef7278b5a46c0", + }, + }, +} +`; + +exports[`makeUniversalApp no asar mode different app dirs with universal macho files (shim but don't lipo) 1`] = ` +{ + "files": { + "index.js": { + "integrity": { + "algorithm": "SHA256", + "blockSize": 4194304, + "blocks": [ + "f1e14240f7c833900fca84fabc2f0ff27084efdf1c5b228b015515de3f8fa28e", + ], + "hash": "f1e14240f7c833900fca84fabc2f0ff27084efdf1c5b228b015515de3f8fa28e", + }, + "size": 1063, + }, + "package.json": { + "integrity": { + "algorithm": "SHA256", + "blockSize": 4194304, + "blocks": [ + "2873266521e41d58d02e7acfbbbdb046edfa04b6ce262b8987de8e8548671fc7", + ], + "hash": "2873266521e41d58d02e7acfbbbdb046edfa04b6ce262b8987de8e8548671fc7", + }, + "size": 33, + }, + }, +} +`; + +exports[`makeUniversalApp no asar mode different app dirs with universal macho files (shim but don't lipo) 2`] = ` +[ + "private/var/i-aint-got-no-rhythm.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with universal macho files (shim but don't lipo) 3`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, + "private/var/i-aint-got-no-rhythm.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with universal macho files (shim but don't lipo) 4`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, + "private/var/hello-world.bin", +] +`; + +exports[`makeUniversalApp no asar mode different app dirs with universal macho files (shim but don't lipo) 5`] = ` +{ + "Contents/Info.plist": { + "Resources/app.asar": { + "algorithm": "SHA256", + "hash": "27433ee3e34b3b0dabb29d18d40646126e80c56dbce8c4bb2adef7278b5a46c0", + }, + }, +} +`; + +exports[`makeUniversalApp no asar mode identical app dirs with different macho files (e.g. do not shim, but still lipo) 1`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, +] +`; + +exports[`makeUniversalApp no asar mode identical app dirs with different macho files (e.g. do not shim, but still lipo) 2`] = ` +{ + "Contents/Info.plist": {}, +} +`; + +exports[`makeUniversalApp no asar mode identical app dirs with universal macho files (e.g., do not shim, just copy x64 dir) 1`] = ` +[ + "hello-world", + "index.js", + { + "content": "{ + "name": "app", + "main": "index.js" +}", + "name": "package.json", + }, + { + "content": "hello world", + "name": "private/var/file.txt", + }, +] +`; + +exports[`makeUniversalApp no asar mode identical app dirs with universal macho files (e.g., do not shim, just copy x64 dir) 2`] = ` +{ + "Contents/Info.plist": {}, +} +`; + exports[`makeUniversalApp no asar mode should correctly merge two identical app folders 1`] = ` [ "index.js", @@ -720,3 +936,92 @@ exports[`makeUniversalApp no asar mode should shim two different app folders 5`] }, } `; + +exports[`makeUniversalApp works for lipo binary resources 1`] = ` +{ + "files": { + "hello-world": { + "integrity": { + "algorithm": "SHA256", + "blockSize": 4194304, + "blocks": [ + "bb775443c1c6bbc9c06580111e671319a9f67cc8d3fec9443a3ee6450b443a66", + ], + "hash": "bb775443c1c6bbc9c06580111e671319a9f67cc8d3fec9443a3ee6450b443a66", + }, + "size": 49824, + "unpacked": true, + }, + "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 works for lipo binary resources 2`] = `[]`; + +exports[`makeUniversalApp works for lipo binary resources 3`] = ` +[ + "hello-world", +] +`; + +exports[`makeUniversalApp works for lipo binary resources 4`] = ` +{ + "Contents/Info.plist": { + "Resources/app.asar": { + "algorithm": "SHA256", + "hash": "16f5341e6a66b50659c9b40ca8cb3ed3f893d74813aabde99ac51af2ef9e414d", + }, + }, +} +`; diff --git a/test/fixtures/hello-world.c b/test/fixtures/hello-world.c new file mode 100644 index 0000000..f26b97c --- /dev/null +++ b/test/fixtures/hello-world.c @@ -0,0 +1,6 @@ +#include + +int main() { + printf("Hello, World!\n"); + return 0; +} diff --git a/test/index.spec.ts b/test/index.spec.ts index ff1c88a..7448e65 100644 --- a/test/index.spec.ts +++ b/test/index.spec.ts @@ -2,7 +2,13 @@ import * as fs from 'fs-extra'; import * as path from 'path'; import { makeUniversalApp } from '../dist/cjs/index'; -import { createTestApp, templateApp, VERIFY_APP_TIMEOUT, verifyApp } from './util'; +import { + createStagingAppDir, + generateNativeApp, + templateApp, + VERIFY_APP_TIMEOUT, + verifyApp, +} from './util'; import { createPackage, createPackageWithOptions } from '@electron/asar'; import { afterEach, describe, expect, it } from '@jest/globals'; @@ -28,7 +34,26 @@ describe('makeUniversalApp', () => { ); }); - it.todo('works for lipo binary resources'); + it( + 'works for lipo binary resources', + async () => { + const x64AppPath = await generateNativeApp({ + appNameWithExtension: 'LipoX64.app', + arch: 'x64', + createAsar: true, + }); + const arm64AppPath = await generateNativeApp({ + appNameWithExtension: 'LipoArm64.app', + arch: 'arm64', + createAsar: true, + }); + + const out = path.resolve(appsOutPath, 'Lipo.app'); + await makeUniversalApp({ x64AppPath, arm64AppPath, outAppPath: out, mergeASARs: true }); + await verifyApp(out, true); + }, + VERIFY_APP_TIMEOUT, + ); describe('force', () => { it('throws an error if `out` bundle already exists and `force` is `false`', async () => { @@ -46,7 +71,7 @@ describe('makeUniversalApp', () => { it( 'packages successfully if `out` bundle already exists and `force` is `true`', async () => { - const out = path.resolve(appsOutPath, 'Error.app'); + const out = path.resolve(appsOutPath, 'NoError.app'); await fs.mkdirp(out); await makeUniversalApp({ x64AppPath: path.resolve(appsPath, 'X64Asar.app'), @@ -126,7 +151,7 @@ describe('makeUniversalApp', () => { 'should not inject ElectronAsarIntegrity into `infoPlistsToIgnore`', async () => { const arm64AppPath = await templateApp('Arm64-1.app', 'arm64', async (appPath) => { - const { testPath } = await createTestApp('Arm64-1'); + const { testPath } = await createStagingAppDir('Arm64-1'); await createPackage(testPath, path.resolve(appPath, 'Contents', 'Resources', 'app.asar')); await templateApp('SubApp-1.app', 'arm64', async (subArm64AppPath) => { await fs.move( @@ -136,7 +161,7 @@ describe('makeUniversalApp', () => { }); }); const x64AppPath = await templateApp('X64-1.app', 'x64', async (appPath) => { - const { testPath } = await createTestApp('X64-1'); + const { testPath } = await createStagingAppDir('X64-1'); await createPackage(testPath, path.resolve(appPath, 'Contents', 'Resources', 'app.asar')); await templateApp('SubApp-1.app', 'x64', async (subArm64AppPath) => { await fs.move( @@ -165,7 +190,7 @@ describe('makeUniversalApp', () => { 'should shim asars with different unpacked dirs', async () => { const arm64AppPath = await templateApp('UnpackedArm64.app', 'arm64', async (appPath) => { - const { testPath } = await createTestApp('UnpackedAppArm64'); + const { testPath } = await createStagingAppDir('UnpackedAppArm64'); await createPackageWithOptions( testPath, path.resolve(appPath, 'Contents', 'Resources', 'app.asar'), @@ -177,7 +202,7 @@ describe('makeUniversalApp', () => { }); const x64AppPath = await templateApp('UnpackedX64.app', 'x64', async (appPath) => { - const { testPath } = await createTestApp('UnpackedAppX64'); + const { testPath } = await createStagingAppDir('UnpackedAppX64'); await createPackageWithOptions( testPath, path.resolve(appPath, 'Contents', 'Resources', 'app.asar'), @@ -199,7 +224,7 @@ describe('makeUniversalApp', () => { it( 'should generate AsarIntegrity for all asars in the application', async () => { - const { testPath } = await createTestApp('app-2'); + const { testPath } = await createStagingAppDir('app-2'); const testAsarPath = path.resolve(appsOutPath, 'app-2.asar'); await createPackage(testPath, testAsarPath); @@ -255,14 +280,16 @@ describe('makeUniversalApp', () => { 'should shim two different app folders', async () => { const arm64AppPath = await templateApp('ShimArm64.app', 'arm64', async (appPath) => { - const { testPath } = await createTestApp('shimArm64', { + const { testPath } = await createStagingAppDir('shimArm64', { 'i-aint-got-no-rhythm.bin': 'boomshakalaka', }); await fs.copy(testPath, path.resolve(appPath, 'Contents', 'Resources', 'app')); }); const x64AppPath = await templateApp('ShimX64.app', 'x64', async (appPath) => { - const { testPath } = await createTestApp('shimX64', { 'hello-world.bin': 'Hello World' }); + const { testPath } = await createStagingAppDir('shimX64', { + 'hello-world.bin': 'Hello World', + }); await fs.copy(testPath, path.resolve(appPath, 'Contents', 'Resources', 'app')); }); @@ -276,9 +303,117 @@ describe('makeUniversalApp', () => { }, VERIFY_APP_TIMEOUT, ); - }); - // TODO: Add tests for - // * different app dirs with different macho files - // * identical app dirs with universal macho files + it( + 'different app dirs with different macho files (shim and lipo)', + async () => { + const x64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentMachoAppX64-1.app', + arch: 'x64', + createAsar: false, + additionalFiles: { + 'hello-world.bin': 'Hello World', + }, + }); + const arm64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentMachoAppArm64-1.app', + arch: 'arm64', + createAsar: false, + additionalFiles: { + 'i-aint-got-no-rhythm.bin': 'boomshakalaka', + }, + }); + + const outAppPath = path.resolve(appsOutPath, 'DifferentMachoApp1.app'); + await makeUniversalApp({ + x64AppPath, + arm64AppPath, + outAppPath, + }); + await verifyApp(outAppPath, true); + }, + VERIFY_APP_TIMEOUT, + ); + + it( + "different app dirs with universal macho files (shim but don't lipo)", + async () => { + const x64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentButUniversalMachoAppX64-2.app', + arch: 'x64', + createAsar: false, + nativeModuleArch: 'universal', + additionalFiles: { + 'hello-world.bin': 'Hello World', + }, + }); + const arm64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentButUniversalMachoAppArm64-2.app', + arch: 'arm64', + createAsar: false, + nativeModuleArch: 'universal', + additionalFiles: { + 'i-aint-got-no-rhythm.bin': 'boomshakalaka', + }, + }); + + const outAppPath = path.resolve(appsOutPath, 'DifferentButUniversalMachoApp.app'); + await makeUniversalApp({ + x64AppPath, + arm64AppPath, + outAppPath, + }); + await verifyApp(outAppPath, true); + }, + VERIFY_APP_TIMEOUT, + ); + + it( + 'identical app dirs with different macho files (e.g. do not shim, but still lipo)', + async () => { + const x64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentMachoAppX64-2.app', + arch: 'x64', + createAsar: false, + }); + const arm64AppPath = await generateNativeApp({ + appNameWithExtension: 'DifferentMachoAppArm64-2.app', + arch: 'arm64', + createAsar: false, + }); + + const out = path.resolve(appsOutPath, 'DifferentMachoApp2.app'); + await makeUniversalApp({ + x64AppPath, + arm64AppPath, + outAppPath: out, + }); + await verifyApp(out, true); + }, + VERIFY_APP_TIMEOUT, + ); + + it( + 'identical app dirs with universal macho files (e.g., do not shim, just copy x64 dir)', + async () => { + const x64AppPath = await generateNativeApp({ + appNameWithExtension: 'UniversalMachoAppX64.app', + arch: 'x64', + createAsar: false, + nativeModuleArch: 'universal', + }); + const arm64AppPath = await generateNativeApp({ + appNameWithExtension: 'UniversalMachoAppArm64.app', + arch: 'arm64', + createAsar: false, + nativeModuleArch: 'universal', + }); + + const out = path.resolve(appsOutPath, 'UniversalMachoApp.app'); + await makeUniversalApp({ x64AppPath, arm64AppPath, outAppPath: out }); + await verifyApp(out, true); + }, + VERIFY_APP_TIMEOUT, + ); + }); }); diff --git a/test/util.ts b/test/util.ts index 64d9313..54abadd 100644 --- a/test/util.ts +++ b/test/util.ts @@ -5,7 +5,7 @@ import * as fs from 'fs-extra'; import * as path from 'path'; import plist from 'plist'; import * as fileUtils from '../dist/cjs/file-utils'; -import { getRawHeader } from '@electron/asar'; +import { createPackageWithOptions, getRawHeader } from '@electron/asar'; declare const expect: typeof import('@jest/globals').expect; @@ -14,22 +14,24 @@ declare const expect: typeof import('@jest/globals').expect; // plus some tests create fixtures at runtime export const VERIFY_APP_TIMEOUT = 80 * 1000; -export const asarsDir = path.resolve(__dirname, 'fixtures', 'asars'); -export const appsDir = path.resolve(__dirname, 'fixtures', 'apps'); +export const fixtureDir = path.resolve(__dirname, 'fixtures'); +export const asarsDir = path.resolve(fixtureDir, 'asars'); +export const appsDir = path.resolve(fixtureDir, 'apps'); export const appsOutPath = path.resolve(appsDir, 'out'); -export const verifyApp = async (appPath: string) => { +export const verifyApp = async (appPath: string, containsRuntimeGeneratedMacho = false) => { await ensureUniversal(appPath); const resourcesDir = path.resolve(appPath, 'Contents', 'Resources'); const resourcesDirContents = await fs.readdir(resourcesDir); + const ignoreKeys = containsRuntimeGeneratedMacho ? ['hello-world'] : []; // sort for consistent result const asars = resourcesDirContents.filter((p) => p.endsWith('.asar')).sort(); for await (const asar of asars) { // verify header const asarFs = getRawHeader(path.resolve(resourcesDir, asar)); - expect(removeUnstableProperties(asarFs.header)).toMatchSnapshot(); + expect(removeUnstableProperties(asarFs.header, ignoreKeys)).toMatchSnapshot(); } // check all app and unpacked dirs (incl. shimmed) @@ -66,12 +68,14 @@ export const verifyApp = async (appPath: string) => { for (let i = 0; i < integrity.length; i++) { const relativePath = infoPlists[i]; const asarIntegrity = integrity[i]; - integrityMap[relativePath] = asarIntegrity; + // note: `infoPlistsToIgnore` will not have integrity in sub-app plists + integrityMap[relativePath] = asarIntegrity + ? removeUnstableProperties(asarIntegrity, ['blocks', 'hash']) + : undefined; } expect(integrityMap).toMatchSnapshot(); }; -// note: `infoPlistsToIgnore` will not have integrity in sub-app plists const extractAsarIntegrity = async (infoPlist: string) => { const { ElectronAsarIntegrity: integrity, ...otherData } = plist.parse( await fs.readFile(infoPlist, 'utf-8'), @@ -104,9 +108,20 @@ export const toSystemIndependentPath = (s: string): string => { return path.sep === '/' ? s : s.replace(/\\/g, '/'); }; -export const removeUnstableProperties = (data: any) => { +export const removeUnstableProperties = (data: any, stripKeys: string[]) => { + const removeKeysRecursively: (obj: any, keys: string[]) => any = (obj, keys) => + obj !== Object(obj) + ? obj + : Array.isArray(obj) + ? obj.map((item) => removeKeysRecursively(item, keys)) + : Object.fromEntries( + Object.entries(obj) + // .map(([k, v]) => [k, removeKeysRecursively(v, keys)]) + .filter(([k]) => !keys.includes(k)), + ); + return JSON.parse( - JSON.stringify(data, (name, value) => { + JSON.stringify(removeKeysRecursively(data, stripKeys), (name, value) => { if (name === 'offset') { return undefined; } @@ -116,6 +131,10 @@ export const removeUnstableProperties = (data: any) => { }; /** + * Creates an app directory at runtime for usage: + * - `testPath` can be used with `asar.createPackage`. Just set the output `.asar` path to `Test.app/Contents/Resources/.asar` + * - `testPath` can be utilized for logic paths involving `AsarMode.NO_ASAR` and copied directly to `Test.app/Contents/Resources` + * * Directory structure: * testName * ├── private @@ -127,7 +146,7 @@ export const removeUnstableProperties = (data: any) => { * ├── index.js * ├── package.json */ -export const createTestApp = async ( +export const createStagingAppDir = async ( testName: string | undefined, additionalFiles: Record = {}, ) => { @@ -181,3 +200,42 @@ export const templateApp = async ( return appPath; }; + +export const generateNativeApp = async (options: { + appNameWithExtension: string; + arch: string; + createAsar: boolean; + nativeModuleArch?: string; + additionalFiles?: Record; +}) => { + const { + appNameWithExtension, + arch, + createAsar, + nativeModuleArch = arch, + additionalFiles, + } = options; + const appPath = await templateApp(appNameWithExtension, arch, async (appPath) => { + const resources = path.join(appPath, 'Contents', 'Resources'); + const resourcesApp = path.resolve(resources, 'app'); + if (!fs.existsSync(resourcesApp)) { + await fs.mkdir(resourcesApp); + } + const { testPath } = await createStagingAppDir( + path.basename(appNameWithExtension, '.app'), + additionalFiles, + ); + await fs.copy( + path.join(appsDir, `hello-world-${nativeModuleArch}`), + path.join(testPath, 'hello-world'), + ); + if (createAsar) { + await createPackageWithOptions(testPath, path.resolve(resources, 'app.asar'), { + unpack: '**/hello-world', + }); + } else { + await fs.copy(testPath, resourcesApp); + } + }); + return appPath; +};