chore: retry and cache the Electron zip download during CI builds

The "Build packages" step fails intermittently on every branch when the
Electron zip download from GitHub's release CDN is reset mid-stream:

    RequestError: socket hang up ... code: 'ECONNRESET'
    url: .../download/v37.6.0/electron-v37.6.0-linux-x64.zip

@electron/packager fetches that zip through @electron/get, which downloads
via got.stream(). got does not retry streams — its retry config is present
but inert there — so a single reset becomes an unhandled rejection that
kills the build. @electron/get exposes no retry option of its own.

Call downloadArtifact() directly so the download can be retried with
backoff, then hand the file to the packager via electronZipDir so it skips
its own download. The retry also covers the SHASUMS256.txt fetch, which
@electron/get re-requests on every run even on a cache hit.

Also cache the download across builds. @electron/get's default cache root
is platform-specific, so the build job pins it via electron_config_cache
(the same variable the electron package's own installer honors) to keep a
single save_cache path valid on all five platform executors. The cache key
tracks the pinned Electron version, so it invalidates on an upgrade.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: mschile

.circleci/src/pipeline/@pipeline.yml

@@ -329,11 +329,29 @@ commands:
   build-and-persist:
     description: Save entire folder as artifact for other jobs to run without reinstalling
     steps:
+      - run:
+          name: Generate Electron version key
+          command: node -p "require('./package.json').devDependencies.electron" > electron_version
+      - restore_cache:
+          name: Restore Electron download cache
+          keys:
+            - v{{ checksum ".circleci/cache-version.txt" }}-{{ checksum "platform_key"
+              }}-electron-download-cache-{{ checksum "electron_version" }}
       - run:
           name: Build packages
           command: |
             source ./scripts/ensure-node.sh
+            # @packages/electron forwards this to @electron/get, whose default
+            # cache root is platform-specific — pinning it keeps a single
+            # save_cache path valid on every executor
+            export electron_config_cache="$HOME/.electron-cache"
             yarn build
+      - save_cache:
+          name: Save Electron download cache
+          key: v{{ checksum ".circleci/cache-version.txt" }}-{{ checksum "platform_key"
+            }}-electron-download-cache-{{ checksum "electron_version" }}
+          paths:
+            - ~/.electron-cache
       - run:
           name: Sync Cloud Validations
           command: |

packages/electron/package.json

@@ -23,6 +23,7 @@
   },
   "devDependencies": {
     "@electron/fuses": "1.8.0",
+    "@electron/get": "^4.0.1",
     "@electron/packager": "18.3.6",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.31.0",

packages/electron/src/install.ts

@@ -135,6 +135,35 @@ interface PkgElectronAppOptions {
   overwrite: boolean
   electronVersion: string
   icon: string
+  electronZipDir?: string
+}
+
+// @electron/packager would fetch this through @electron/get, which never
+// retries and re-fetches SHASUMS256.txt even on cache hits. Calling it here
+// lets us retry; electronZipDir then points the packager at the result.
+async function downloadElectronZipWithRetries (options: { version: string, platform: string, arch: string }): Promise<string> {
+  // required dynamically for the same mksnapshot reason as @electron/packager below
+  const e = 'electron'
+  const { downloadArtifact } = require(`@${e}/get`)
+  const retryDelaysMs = [2000, 4000, 8000, 16000, 32000]
+
+  // same env var the `electron` package's own installer honors, so CI can point
+  // both at one cacheable directory. Undefined falls back to the platform default.
+  const cacheRoot = process.env.electron_config_cache
+
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await downloadArtifact({ artifactName: 'electron', cacheRoot, ...options })
+    } catch (err) {
+      const delayMs = retryDelaysMs[attempt]
+
+      if (delayMs === undefined) throw err
+
+      debug('electron zip download failed %o', { attempt, err })
+      console.log(`Electron download failed (${(err as Error).message}), retrying in ${delayMs / 1000}s (attempt ${attempt + 1} of ${retryDelaysMs.length})`)
+      await new Promise((resolve) => setTimeout(resolve, delayMs))
+    }
+  }
 }
 
 async function pkgElectronApp (
@@ -180,6 +209,14 @@ async function pkgElectronApp (
     ...options,
   }
 
+  const zipPath = await downloadElectronZipWithRetries({
+    version: resolvedOptions.electronVersion,
+    platform: resolvedOptions.platform,
+    arch: resolvedOptions.arch,
+  })
+
+  resolvedOptions.electronZipDir = path.dirname(zipPath)
+
   debug('packager options %j', resolvedOptions)
   const [appPath] = await pkgr(resolvedOptions)