evaluate bytecode inside custom electron builds

[ThaUnknown]

Clear and concise description of the problem

When using the bytecode plugin the npms electron install is used, this is problematic as the npm versions used by electron and the environment might miss-match.

This is a problem for CI and for custom electron builds. CI might be running different versions of the OS which might use electron versions that behave differently, and custom electron builds might be running modified versions of nodejs which are also incompatible as they might be compiled using different SDK versions or apply their own custom patches.

Suggested solution

Evaluate the bytecode inside the respective electron processes.

This is however difficult as it requires to read the respective electron-dist location, be it from electron-builder or electron-forge, obtaining their .zips, unpacking them and executing their electron installs, from there on out however it's quite simple as you only need to run a specific cli file, which already exists

Alternative

No response

Additional context

No response

Validations

• Follow the Code of Conduct.
• Read the Contributing Guidelines.
• Read the docs.
• Check that there isn't already an issue that requests the same feature to avoid creating a duplicate.

[ThaUnknown]

I imagine something like

const electronUnzipPlugin = () => {
  return {
    name: 'electron-unzip',
    buildStart () {
      const electronDistPath = resolve(__dirname, 'electron-dist')

      let zipPattern: string
      switch (process.platform) {
        case 'win32':
          zipPattern = '*win32*.zip'
          break
        case 'freebsd':
        case 'openbsd':
        case 'linux':
          zipPattern = '*linux*.zip'
          break
        default:
          console.warn(`Bytecode unsuppored platform: ${process.platform}`)
          return
      }

      try {
        const zipFile = glob.sync(zipPattern, { cwd: electronDistPath })[0]

        if (!zipFile) {
          console.warn(`No electron distribution zip file found for pattern: ${zipPattern}`)
          return
        }

        const zipPath = resolve(electronDistPath, zipFile)
        const extractDir = resolve(electronDistPath, zipFile.replace('.zip', ''))

        process.env.ELECTRON_EXEC_PATH = extractDir + (process.platform === 'win32' ? '/electron.exe' : '/electron')

        if (existsSync(extractDir)) {
          console.log(`Electron distribution already extracted: ${extractDir}`)
          return
        }

        console.log(`Extracting electron distribution: ${zipFile}`)

        mkdirSync(extractDir, { recursive: true })

        if (process.platform === 'win32') {
          execSync(`powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`)
        } else {
          execSync(`unzip -q "${zipPath}" -d "${extractDir}"`)
        }

        console.log(`Successfully extracted: ${zipFile}`)
      } catch (error) {
        console.error('Failed to extract electron distribution:', error)
      }
    }
  }
}

would work, however npm's extract-zip should probably be used if we want to support darwin, however since the bytecode plugin doesn't support multi-arch builds in the first place it's not a problem since it can't be used there without significant performance loss

[alex8088]

Are you sure you are using electron-vite (https://electron-vite.org/)? Electron-vite compiles bytecode using the electron installed in the project instead of the local nodejs. No need to worry about the CI environment. https://electron-vite.org/guide/source-code-protection#what-is-v8-bytecode

[ThaUnknown]

yes, however I'm using a custom electron-dist, electron-vite uses the npm installed electron version, which might be different from the electron-dist, so to fix this you'd effectively need to implement electron's install.js but for the custom electron-dist, which is an example of what I provided above, except I didn't check what electron version is used and unpacked the first zip

the CI wording was poor, I mean that if you compile with CI, it's SDKs might be different, so it might output electron versions that are different from the defaults when you compile electron yourself