fix: use FileCopier for copying files and queue creation of symlinks

packages/app-builder-lib/package.json

@@ -48,7 +48,7 @@
   "dependencies": {
     "@develar/schema-utils": "~2.6.5",
     "@electron/fuses": "^1.8.0",
-    "@electron/asar": "^3.2.13",
+    "@electron/asar": "3.2.13",
     "@electron/notarize": "2.5.0",
     "@electron/osx-sign": "1.3.1",
     "@electron/rebuild": "3.7.0",

packages/app-builder-lib/src/asar/asarUtil.ts

@@ -1,7 +1,7 @@
 import { CreateOptions, createPackageWithOptions } from "@electron/asar"
 import { AsyncTaskManager, log } from "builder-util"
 import { CancellationToken } from "builder-util-runtime"
-import { Filter, MAX_FILE_REQUESTS } from "builder-util/out/fs"
+import { FileCopier, Filter, Link, MAX_FILE_REQUESTS } from "builder-util/out/fs"
 import * as fsNode from "fs"
 import * as fs from "fs-extra"
 import * as path from "path"
@@ -10,12 +10,15 @@ import { AsarOptions } from "../options/PlatformSpecificBuildOptions"
 import { PlatformPackager } from "../platformPackager"
 import { ResolvedFileSet, getDestinationPath } from "../util/appFileCopier"
 import { detectUnpackedDirs } from "./unpackDetector"
+import { platform } from "os"
+import { mkdir, readlink, symlink } from "fs-extra"
 
 /** @internal */
 export class AsarPackager {
   private readonly outFile: string
-  private rootForAppFilesWithoutAsar!: string
+  private readonly rootForAppFilesWithoutAsar: string
   private readonly tmpDir = new tempFile.TmpDir()
+  private readonly fileCopier = new FileCopier()
 
   constructor(
     private readonly config: {
@@ -26,13 +29,12 @@ export class AsarPackager {
     }
   ) {
     this.outFile = path.join(config.resourcePath, `app.asar`)
+    this.rootForAppFilesWithoutAsar = path.join(config.resourcePath, "app")
   }
 
   async pack(fileSets: Array<ResolvedFileSet>, _packager: PlatformPackager<any>) {
-    this.rootForAppFilesWithoutAsar = await this.tmpDir.getTempDir({ prefix: "asar-app" })
-
     const cancellationToken = new CancellationToken()
-    cancellationToken.on("cancel", () => this.tmpDir.cleanupSync())
+    cancellationToken.on("cancel", () => this.cleanup())
 
     const orderedFileSets = [
       // Write dependencies first to minimize offset changes to asar header
@@ -45,6 +47,12 @@ export class AsarPackager {
     const { unpackedPaths, copiedFiles } = await this.detectAndCopy(orderedFileSets, cancellationToken)
     const unpackGlob = unpackedPaths.length > 1 ? `{${unpackedPaths.join(",")}}` : unpackedPaths.pop()
 
+    await this.executeElectronAsar(copiedFiles, unpackGlob)
+
+    this.cleanup()
+  }
+
+  private async executeElectronAsar(copiedFiles: string[], unpackGlob: string | undefined) {
     let ordering = this.config.options.ordering || undefined
     if (!ordering) {
       // `copiedFiles` are already ordered due to `orderedFileSets` input, so we just map to their relative paths (via substring) within the asar.
@@ -69,95 +77,104 @@ export class AsarPackager {
     }
     await createPackageWithOptions(this.rootForAppFilesWithoutAsar, this.outFile, options)
     console.log = consoleLogger
+  }
 
-    await this.tmpDir.cleanup()
+  private cleanup() {
+    fsNode.rmSync(this.rootForAppFilesWithoutAsar, { recursive: true })
+    this.tmpDir.cleanupSync()
   }
 
   private async detectAndCopy(fileSets: ResolvedFileSet[], cancellationToken: CancellationToken) {
     const taskManager = new AsyncTaskManager(cancellationToken)
     const unpackedPaths = new Set<string>()
     const copiedFiles = new Set<string>()
 
+    const createdSourceDirs = new Set<string>()
+    const links: Array<Link> = []
+    const symlinkType = platform() === "win32" ? "junction" : "file"
+
     const matchUnpacker = (file: string, dest: string, stat: fs.Stats) => {
       if (this.config.unpackPattern?.(file, stat)) {
         log.debug({ file }, "unpacking")
         unpackedPaths.add(dest)
         return
       }
     }
-    const writeFileOrSymlink = async (options: { transformedData: string | Buffer | undefined; file: string; destination: string; stat: fs.Stats; fileSet: ResolvedFileSet }) => {
-      const {
-        transformedData,
-        file: source,
-        destination,
-        stat,
-        fileSet: { src: sourceDir },
-      } = options
-      copiedFiles.add(destination)
-
-      // If transformed data, skip symlink logic
-      if (transformedData) {
-        return this.copyFileOrData(transformedData, source, destination, stat)
+    const writeFileOrQueueSymlink = async (options: { transformedData: string | Buffer | undefined; file: string; destFile: string; stat: fs.Stats; fileSet: ResolvedFileSet }) => {
+      const { transformedData, file, destFile, stat, fileSet } = options
+      if (!stat.isFile() && !stat.isSymbolicLink()) {
+        return
       }
+      copiedFiles.add(destFile)
 
-      const realPathFile = await fs.realpath(source)
+      const dir = path.dirname(destFile)
+      if (!createdSourceDirs.has(dir)) {
+        await mkdir(dir, { recursive: true })
+        createdSourceDirs.add(dir)
+      }
 
-      if (source === realPathFile) {
-        return this.copyFileOrData(undefined, source, destination, stat)
+      // write any data if provided, skip symlink check
+      if (transformedData != null) {
+        return fs.writeFile(destFile, transformedData, { mode: stat.mode })
       }
 
-      const realPathRelative = path.relative(sourceDir, realPathFile)
+      const realPathFile = await fs.realpath(file)
+      const realPathRelative = path.relative(fileSet.src, realPathFile)
       const isOutsidePackage = realPathRelative.startsWith("..")
       if (isOutsidePackage) {
-        log.error({ source: log.filePath(source), realPathFile: log.filePath(realPathFile) }, `unable to copy, file is symlinked outside the package`)
-        throw new Error(
-          `Cannot copy file (${path.basename(source)}) symlinked to file (${path.basename(realPathFile)}) outside the package as that violates asar security integrity`
-        )
+        log.error({ source: log.filePath(file), realPathFile: log.filePath(realPathFile) }, `unable to copy, file is symlinked outside the package`)
+        throw new Error(`Cannot copy file (${path.basename(file)}) symlinked to file (${path.basename(realPathFile)}) outside the package as that violates asar security integrity`)
+      }
+
+      // not a symlink, copy directly
+      if (file === realPathFile) {
+        return this.fileCopier.copy(file, destFile, stat)
       }
 
-      const symlinkTarget = path.resolve(this.rootForAppFilesWithoutAsar, realPathRelative)
-      await this.copyFileOrData(undefined, source, symlinkTarget, stat)
-      const target = path.relative(path.dirname(destination), symlinkTarget)
-      fsNode.symlinkSync(target, destination)
+      // okay, it must be a symlink. evaluate link to be relative to source file in asar
+      let link = await readlink(file)
+      if (path.isAbsolute(link)) {
+        link = path.relative(path.dirname(file), link)
+      }
 
-      copiedFiles.add(symlinkTarget)
+      links.push({ file: destFile, link })
     }
 
     for await (const fileSet of fileSets) {
       if (this.config.options.smartUnpack !== false) {
         detectUnpackedDirs(fileSet, unpackedPaths, this.config.defaultDestination)
       }
+
+      // Don't use BluebirdPromise, we need to retain order of execution/iteration through the ordered fileset
       for (let i = 0; i < fileSet.files.length; i++) {
         const file = fileSet.files[i]
         const transformedData = fileSet.transformedFiles?.get(i)
-        const metadata = fileSet.metadata.get(file) || (await fs.lstat(file))
-
-        const relative = path.relative(this.config.defaultDestination, getDestinationPath(file, fileSet))
-        const dest = path.resolve(this.rootForAppFilesWithoutAsar, relative)
+        const stat = fileSet.metadata.get(file)!
+        const destFile = getDestinationPath(file, fileSet)
 
-        matchUnpacker(file, dest, metadata)
-        taskManager.addTask(writeFileOrSymlink({ transformedData, file, destination: dest, stat: metadata, fileSet }))
+        matchUnpacker(file, destFile, stat)
+        taskManager.addTask(writeFileOrQueueSymlink({ transformedData, file, destFile, stat, fileSet }))
 
         if (taskManager.tasks.length > MAX_FILE_REQUESTS) {
           await taskManager.awaitTasks()
         }
       }
     }
+    // finish copy then set up all symlinks
+    await taskManager.awaitTasks()
+    for (const it of links) {
+      taskManager.addTask(symlink(it.link, it.file, symlinkType))
+
+      if (taskManager.tasks.length > MAX_FILE_REQUESTS) {
+        await taskManager.awaitTasks()
+      }
+    }
     await taskManager.awaitTasks()
     return {
       unpackedPaths: Array.from(unpackedPaths),
       copiedFiles: Array.from(copiedFiles),
     }
   }
-
-  private async copyFileOrData(data: string | Buffer | undefined, source: string, destination: string, stat: fs.Stats) {
-    await fs.mkdir(path.dirname(destination), { recursive: true })
-    if (data) {
-      await fs.writeFile(destination, data, { mode: stat.mode })
-    } else {
-      await fs.copyFile(source, destination)
-    }
-  }
 }
 
 function orderFileSet(fileSet: ResolvedFileSet): ResolvedFileSet {