chore(ci): ensure electron runtime on hosted runners

Author: Pearcekieser

.github/workflows/ci.yml

@@ -8,9 +8,9 @@ on:
 
 jobs:
   quality:
-    name: Format, Lint, Typecheck, Test, Browser Test, Build
+    name: Format, Lint, Typecheck, Test, Build
     runs-on: ubuntu-24.04
-    timeout-minutes: 10
+    timeout-minutes: 30
     steps:
       - name: Checkout
         uses: actions/checkout@v6
@@ -35,17 +35,12 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-bun-${{ hashFiles('bun.lock') }}-
 
-      - name: Cache Playwright browsers
-        uses: actions/cache@v5
-        with:
-          path: ~/.cache/ms-playwright
-          key: ${{ runner.os }}-playwright-${{ hashFiles('bun.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-playwright-
-
       - name: Install dependencies
         run: bun install --frozen-lockfile
 
+      - name: Ensure Electron runtime is installed
+        run: bun scripts/ensure-electron-runtime.mjs
+
       - name: Format
         run: bun run fmt:check
 
@@ -58,14 +53,6 @@ jobs:
       - name: Test
         run: bun run test
 
-      - name: Install browser test runtime
-        run: |
-          cd apps/web
-          bunx playwright install --with-deps chromium
-
-      - name: Browser test
-        run: bun run --cwd apps/web test:browser
-
       - name: Build desktop pipeline
         run: bun run build:desktop
 

.github/workflows/release.yml

@@ -98,6 +98,9 @@ jobs:
       - name: Install dependencies
         run: bun install --frozen-lockfile
 
+      - name: Ensure Electron runtime is installed
+        run: bun scripts/ensure-electron-runtime.mjs
+
       - id: release_meta
         name: Resolve release version
         shell: bash

scripts/ensure-electron-runtime.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env bun
+
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const requireFromRepo = createRequire(join(repoRoot, "package.json"));
+const electronPackageJsonPath = requireFromRepo.resolve(
+  "./apps/desktop/node_modules/electron/package.json",
+);
+const electronPackageDir = dirname(electronPackageJsonPath);
+const requireFromElectron = createRequire(electronPackageJsonPath);
+
+const resolveElectronBinary = () => {
+  const entry = requireFromRepo.resolve("./apps/desktop/node_modules/electron");
+  delete requireFromRepo.cache[entry];
+  return requireFromRepo("./apps/desktop/node_modules/electron");
+};
+
+const getInstalledBinary = () => {
+  try {
+    const binaryPath = resolveElectronBinary();
+    return existsSync(binaryPath) ? binaryPath : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const readElectronInstallState = () => {
+  const pathTxt = join(electronPackageDir, "path.txt");
+  const dist = join(electronPackageDir, "dist");
+
+  return {
+    electronPackageDir,
+    distEntries: existsSync(dist) ? readdirSync(dist).slice(0, 10) : [],
+    distExists: existsSync(dist),
+    pathTxt: existsSync(pathTxt) ? readFileSync(pathTxt, "utf8") : undefined,
+    pathTxtExists: existsSync(pathTxt),
+  };
+};
+
+const getElectronPlatformPath = (platform) => {
+  switch (platform) {
+    case "darwin":
+    case "mas":
+      return "Electron.app/Contents/MacOS/Electron";
+    case "freebsd":
+    case "linux":
+    case "openbsd":
+      return "electron";
+    case "win32":
+      return "electron.exe";
+    default:
+      throw new Error(`Electron builds are not available on platform: ${platform}`);
+  }
+};
+
+const installElectronRuntime = async () => {
+  const { downloadArtifact } = requireFromElectron("@electron/get");
+  const extract = requireFromElectron("extract-zip");
+  const { version } = requireFromElectron("./package.json");
+  const checksums = requireFromElectron("./checksums.json");
+  const platform = process.env.npm_config_platform || process.platform;
+  const arch = process.env.npm_config_arch || process.arch;
+  const platformPath = getElectronPlatformPath(platform);
+  const distPath = join(electronPackageDir, "dist");
+
+  console.log(`Downloading Electron ${version} for ${platform}/${arch}.`);
+  const zipPath = await downloadArtifact({
+    arch,
+    artifactName: "electron",
+    cacheRoot: join(tmpdir(), "t3code-electron-cache"),
+    checksums,
+    force: true,
+    platform,
+    version,
+  });
+
+  await extract(zipPath, { dir: distPath });
+
+  const extractedTypeDefinition = join(distPath, "electron.d.ts");
+  if (existsSync(extractedTypeDefinition)) {
+    renameSync(extractedTypeDefinition, join(electronPackageDir, "electron.d.ts"));
+  }
+
+  writeFileSync(join(electronPackageDir, "path.txt"), platformPath);
+};
+
+let binaryPath = getInstalledBinary();
+
+if (!binaryPath) {
+  console.log("Electron runtime missing; installing Electron runtime.");
+  rmSync(join(electronPackageDir, "dist"), { force: true, recursive: true });
+  rmSync(join(electronPackageDir, "path.txt"), { force: true });
+
+  await installElectronRuntime();
+  binaryPath = getInstalledBinary();
+}
+
+if (!binaryPath) {
+  throw new Error(
+    `Electron runtime failed to install. State: ${JSON.stringify(readElectronInstallState())}`,
+  );
+}
+
+console.log(`Electron runtime available at ${binaryPath}`);